smelte-rs 0.1.0

Efficient inference ML framework written in rust
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

use super::ops;
use super::tensor::Tensor;
use crate::traits::{
    Tensor as TensorTrait, TensorAdd, TensorGelu, TensorMatmul, TensorMatmulT, TensorMul,
    TensorNormalize, TensorOps, TensorSelect, TensorSoftmax, TensorTanh,
};
use crate::SmeltError;

impl<'a> TensorTrait for Tensor<'a> {
    fn shape(&self) -> &[usize] {
        &self.shape
    }
    fn zeros(shape: Vec<usize>) -> Self {
        Self::zeros(shape)
    }
}

impl<'a> TensorAdd<Tensor<'a>> for Tensor<'a> {
    fn add(x: &Self, y: &mut Self) -> Result<(), SmeltError> {
        ops::add(x, y)
    }
}

impl<'a> TensorMul<Tensor<'a>> for Tensor<'a> {
    fn mul(x: &Self, y: &mut Self) -> Result<(), SmeltError> {
        ops::mul(x, y)
    }
}

impl<'a> TensorNormalize<Tensor<'a>> for Tensor<'a> {
    fn normalize(x: &mut Self, epsilon: f32) -> Result<(), SmeltError> {
        ops::normalize(x, epsilon)
    }
}

impl<'a> TensorMatmul<Tensor<'a>> for Tensor<'a> {
    fn matmul(x: &Self, y: &Self, out: &mut Self) -> Result<(), SmeltError> {
        ops::matmul(x, y, out)
    }
}

impl<'a> TensorMatmulT<Tensor<'a>> for Tensor<'a> {
    fn matmul_t(x: &Self, y: &Self, out: &mut Self) -> Result<(), SmeltError> {
        ops::matmul_t(x, y, out)
    }
}

impl<'a> TensorSelect<Tensor<'a>> for Tensor<'a> {
    fn select(x: &[usize], weight: &Self, out: &mut Self) -> Result<(), SmeltError> {
        ops::select(x, weight, out)
    }
}

impl<'a> TensorGelu<Tensor<'a>> for Tensor<'a> {
    fn gelu(x: &mut Tensor<'a>) -> Result<(), SmeltError> {
        ops::apply(x, ops::gelu);
        Ok(())
    }
}

impl<'a> TensorTanh<Tensor<'a>> for Tensor<'a> {
    fn tanh(x: &mut Tensor<'a>) -> Result<(), SmeltError> {
        ops::apply(x, ops::inline_tanh);
        Ok(())
    }
}

impl<'a> TensorSoftmax<Tensor<'a>> for Tensor<'a> {
    fn softmax(x: &mut Tensor<'a>) -> Result<(), SmeltError> {
        ops::softmax(x)
    }
}

impl<'a> TensorOps<Tensor<'a>> for Tensor<'a> {}