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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

mod actfn;
pub use actfn::*;

mod optim;
pub use optim::*;

mod loss;
pub use loss::*;

use crate::manual::tensors::{IntoWithGrad, Tensor, TensorGrad, TensorOps};
use box_closure::{
    Align1, Align2, Align4, Align8, Align16, Align32, OpaqueFn, OpaqueFnMut, OpaqueFnOnce,
};

pub trait Closure<Arg, Ret> {
    fn invoke(&self, args: Arg) -> Ret;
}

pub trait ClosureMut<Arg, Ret> {
    fn invoke(&mut self, args: Arg) -> Ret;
}

pub trait ClosureOnce<Arg, Ret> {
    fn invoke(self, args: Arg) -> Ret;
}

macro_rules! __generate_opaque_closure_impl {
    ($struct:ident, $buf:ident) => {
        impl<'a, A, R, const B: usize> Closure<A, R> for $struct<'a, A, R, $buf<B>> {
            fn invoke(&self, args: A) -> R {
                self.call(args)
            }
        }
    };
}

macro_rules! __generate_opaque_mut_impl {
    ($struct:ident, $buf:ident) => {
        impl<'a, A, R, const B: usize> ClosureMut<A, R> for $struct<'a, A, R, $buf<B>> {
            fn invoke(&mut self, args: A) -> R {
                self.call(args)
            }
        }
    };
}

macro_rules! __generate_opaque_once_impl {
    ($struct:ident, $buf:ident) => {
        impl<'a, A, R, const B: usize> ClosureOnce<A, R> for $struct<'a, A, R, $buf<B>> {
            fn invoke(self, args: A) -> R {
                self.call(args)
            }
        }
    };
}

__generate_opaque_closure_impl!(OpaqueFn, Align1);
__generate_opaque_closure_impl!(OpaqueFn, Align2);
__generate_opaque_closure_impl!(OpaqueFn, Align4);
__generate_opaque_closure_impl!(OpaqueFn, Align8);
__generate_opaque_closure_impl!(OpaqueFn, Align16);
__generate_opaque_closure_impl!(OpaqueFn, Align32);
__generate_opaque_mut_impl!(OpaqueFnMut, Align1);
__generate_opaque_mut_impl!(OpaqueFnMut, Align2);
__generate_opaque_mut_impl!(OpaqueFnMut, Align4);
__generate_opaque_mut_impl!(OpaqueFnMut, Align8);
__generate_opaque_mut_impl!(OpaqueFnMut, Align16);
__generate_opaque_mut_impl!(OpaqueFnMut, Align32);
__generate_opaque_once_impl!(OpaqueFnOnce, Align1);
__generate_opaque_once_impl!(OpaqueFnOnce, Align2);
__generate_opaque_once_impl!(OpaqueFnOnce, Align4);
__generate_opaque_once_impl!(OpaqueFnOnce, Align8);
__generate_opaque_once_impl!(OpaqueFnOnce, Align16);
__generate_opaque_once_impl!(OpaqueFnOnce, Align32);

impl<A, R, F: ?Sized + Fn(A) -> R> Closure<A, R> for F {
    fn invoke(&self, args: A) -> R {
        self(args)
    }
}

impl<A, R, F: ?Sized + FnMut(A) -> R> ClosureMut<A, R> for F {
    fn invoke(&mut self, args: A) -> R {
        self(args)
    }
}

impl<A, R, F: FnOnce(A) -> R> ClosureOnce<A, R> for F {
    fn invoke(self, args: A) -> R {
        self(args)
    }
}

pub trait TensorLike<T>: TensorGrad + TensorOps<T> + IntoWithGrad {
    fn __new_with_data(data: &[T], shape: &[usize]) -> Self;
}
#[cfg(not(feature = "dyntensor"))]
impl<T: Copy + Default, const N: usize, const R: usize> TensorLike<T> for Tensor<T, N, R> {
    fn __new_with_data(data: &[T], shape: &[usize]) -> Self {
        Self::new(
            shape.try_into().expect("invalid shape for const rank"),
            data.try_into().expect("invalid data length for const size"),
        )
    }
}
#[cfg(feature = "dyntensor")]
impl<T: Copy + Default> TensorLike<T> for Tensor<T> {
    fn __new_with_data(data: &[T], shape: &[usize]) -> Self {
        Self::new(shape, data)
    }
}