burn-onnx 0.21.0-pre.3

Library for importing ONNX models into the Burn framework
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super::prelude::*;
use onnx_ir::ir::ArgType;

impl NodeCodegen for onnx_ir::node::bernoulli::BernoulliNode {
    fn inputs(&self) -> &[Argument] {
        &self.inputs
    }

    fn outputs(&self) -> &[Argument] {
        &self.outputs
    }

    fn forward(&self, scope: &mut ScopeAtPosition<'_>) -> TokenStream {
        let input = scope.arg(self.inputs.first().unwrap());
        let output = arg_to_ident(self.outputs.first().unwrap());

        // Use Default distribution for Bernoulli
        let dist = quote! { Distribution::Default };

        // Generate random values and compare with input to get binary output
        let input_random = quote! { #input.random_like(#dist).lower(#input) };

        // Convert to the output type based on the output tensor kind
        let output_ty = &self.outputs.first().unwrap().ty;
        let output_random = match output_ty {
            ArgType::Tensor(t) => {
                let dtype_tokens = t.dtype.to_tokens();
                match &t.dtype {
                    dtype if dtype.is_bool() => input_random,
                    dtype if dtype.is_int() || dtype.is_uint() => {
                        quote! { #input_random.int().cast(#dtype_tokens) }
                    }
                    dtype if dtype.is_float() => {
                        quote! { #input_random.float().cast(#dtype_tokens) }
                    }
                    _ => input_random,
                }
            }
            _ => input_random,
        };

        quote! {
            let #output = #output_random;
        }
    }

    fn register_imports(&self, imports: &mut BurnImports) {
        imports.register("burn::tensor::Distribution");
    }
}

#[cfg(test)]
mod tests {
    use super::super::test_helpers::*;
    use burn::tensor::{BoolStore, DType};
    use insta::assert_snapshot;
    use onnx_ir::node::bernoulli::BernoulliNodeBuilder;

    #[test]
    fn test_bernoulli_bool() {
        let node = BernoulliNodeBuilder::new("bernoulli1")
            .input_tensor("input", 2, DType::F32)
            .output_tensor("output", 2, DType::Bool(BoolStore::Native))
            .build();
        let code = codegen_forward_default(&node);
        assert_snapshot!(code, @r"
        pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2, Bool> {
            let output = input.random_like(Distribution::Default).lower(input);
            output
        }
        ");
    }

    #[test]
    fn test_bernoulli_int() {
        let node = BernoulliNodeBuilder::new("bernoulli2")
            .input_tensor("input", 2, DType::F32)
            .output_tensor("output", 2, DType::I32)
            .build();
        let code = codegen_forward_default(&node);
        assert_snapshot!(code, @r"
        pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2, Int> {
            let output = input
                .random_like(Distribution::Default)
                .lower(input)
                .int()
                .cast(burn::tensor::DType::I32);
            output
        }
        ");
    }

    #[test]
    fn test_bernoulli_float() {
        let node = BernoulliNodeBuilder::new("bernoulli3")
            .input_tensor("input", 2, DType::F64)
            .output_tensor("output", 2, DType::F32)
            .build();
        let code = codegen_forward_default(&node);
        assert_snapshot!(code, @r"
        pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
            let output = input
                .random_like(Distribution::Default)
                .lower(input)
                .float()
                .cast(burn::tensor::DType::F32);
            output
        }
        ");
    }

    #[test]
    fn test_bernoulli_int64() {
        let node = BernoulliNodeBuilder::new("bernoulli4")
            .input_tensor("input", 2, DType::F32)
            .output_tensor("output", 2, DType::I64)
            .build();
        let code = codegen_forward_default(&node);
        assert_snapshot!(code, @r"
        pub fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2, Int> {
            let output = input
                .random_like(Distribution::Default)
                .lower(input)
                .int()
                .cast(burn::tensor::DType::I64);
            output
        }
        ");
    }
}