briny_ai 0.3.0

A tiny & efficient AI inference engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::abstracted::internal::Closure;
use crate::{
    abstracted::internal::TensorLike,
    manual::{
        TensorFloat,
        tensors::{Tensor, WithGrad},
    },
};

pub trait LossEval {
    type Data;
    type Tensor: TensorLike<TensorFloat>;
    type BackFn<'a>: Closure<TensorFloat, Self::Tensor>;

    fn evaluate<'a>(
        &self,
        pred: &'a WithGrad<Self::Data>,
        actual: &'a Self::Data,
    ) -> (f64, Self::BackFn<'a>);
}

#[cfg(feature = "dyntensor")]
pub struct MseLoss;
#[cfg(not(feature = "dyntensor"))]
pub struct MseLoss<const N: usize, const D: usize>;

#[cfg(feature = "dyntensor")]
impl LossEval for MseLoss {
    type Data = Tensor<TensorFloat>;
    type Tensor = Tensor<TensorFloat>;

    type BackFn<'a> =
        alloc::boxed::Box<dyn Fn(crate::manual::TensorFloat) -> Tensor<TensorFloat> + 'a>;

    fn evaluate<'a>(
        &self,
        pred: &'a WithGrad<Self::Data>,
        actual: &'a Self::Data,
    ) -> (
        f64,
        alloc::boxed::Box<dyn Fn(TensorFloat) -> Tensor<TensorFloat> + 'a>,
    ) {
        let (loss, back) = crate::manual::backprop::mse_loss(pred, actual);
        (loss as f64, back)
    }
}
#[cfg(not(feature = "dyntensor"))]
impl<const N: usize, const D: usize> LossEval for MseLoss<N, D> {
    type Data = Tensor<TensorFloat, N, D>;
    type Tensor = Tensor<TensorFloat, N, D>;

    #[cfg(feature = "alloc")]
    type BackFn<'a> =
        alloc::boxed::Box<dyn Fn(crate::manual::TensorFloat) -> Tensor<TensorFloat, N, D> + 'a>;
    #[cfg(not(feature = "alloc"))]
    type BackFn<'a> = box_closure::OpaqueFn<
        'a,
        TensorFloat,
        Tensor<TensorFloat, N, D>,
        box_closure::Align32<256>,
    >;

    fn evaluate<'a>(
        &self,
        pred: &'a WithGrad<Self::Data>,
        actual: &'a Self::Data,
    ) -> (f64, Self::BackFn<'a>) {
        let (loss, back) = crate::manual::backprop::mse_loss(pred, actual);
        (loss as f64, back)
    }
}