tfmicro 0.1.0

Rust bindings of TensorFlow Lite for Microcontrollers
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

//! micro_speech example, from audio files

use tfmicro::{Frontend, MicroInterpreter, Model, MutableOpResolver};

use itertools::Itertools;
use log::info;

/// Returns 40 elements of micro_feature from an audio slice
fn micro_speech_frontend(
    frontend: &mut Frontend,
    audio_slice: &[i16],
) -> [u8; 40] {
    // Run generate_micro_features
    let mut output: [u16; 40] = [0; 40];
    frontend.generate_micro_features(audio_slice, &mut output);

    // Scaling, values derived from those used in the training pipeline. See
    // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/micro_speech/micro_features/micro_features_generator.cc
    let mut scaled_features: [u8; 40] = [0; 40];
    for m in 0..40 {
        let scaled = ((output[m] as f32 * 2550.) + 3328.) / 6656.;
        scaled_features[m] = match scaled {
            x if x < 0. => 0u8,
            x if x > 255. => 255u8,
            x => x as u8,
        };
    }

    scaled_features
}

#[test]
fn micro_speech_with_audio() {
    env_logger::init();
    info!("---- Starting tensorflow micro example: micro_speech_from_audio");

    let model = include_bytes!("../examples/models/micro_speech.tflite");
    let no_1000ms = &include_bytes!("../examples/models/no_1000ms_sample.data")
        .chunks_exact(2)
        .map(|c| i16::from_le_bytes([c[0], c[1]]))
        .collect_vec();
    let yes_1000ms =
        &include_bytes!("../examples/models/yes_1000ms_sample.data")
            .chunks_exact(2)
            .map(|c| i16::from_le_bytes([c[0], c[1]]))
            .collect_vec();

    // Frontend for creating micro_features
    let mut frontend = Frontend::new().unwrap();

    // Map the model into a usable data structure. This doesn't involve
    // any copying or parsing, it's a very lightweight operation.
    let model = Model::from_buffer(&model[..]).unwrap();

    // Create an area of memory to use for input, output, and
    // intermediate arrays.
    const TENSOR_ARENA_SIZE: usize = 10 * 1024;
    let mut tensor_arena: [u8; TENSOR_ARENA_SIZE] = [0; TENSOR_ARENA_SIZE];

    // Pull in all needed operation implementations
    let micro_op_resolver = MutableOpResolver::empty()
        .depthwise_conv_2d()
        .fully_connected()
        .softmax();

    // Build an interpreter to run the model with
    let mut interpreter =
        MicroInterpreter::new(&model, micro_op_resolver, &mut tensor_arena[..])
            .unwrap();

    // Check properties of the input sensor
    assert_eq!([1, 49, 40, 1], interpreter.input_info(0).dims);

    // -------- 'yes' example --------

    // Run the front end on 30ms slices every 20ms
    let micro_feature = (0..49)
        .map(|n| &yes_1000ms[n * 320..(n * 320) + 480])
        .map(|audio_slice| micro_speech_frontend(&mut frontend, audio_slice))
        .fold(vec![], |mut acc: Vec<u8>, slice| {
            acc.extend(&slice[..]);
            acc
        });

    assert_eq!(micro_feature.len(), 1960);

    // Invoke interpreter
    interpreter.input(0, &micro_feature).unwrap();
    interpreter.invoke().unwrap();

    // Get the output tensor
    let output_tensor = interpreter.output(0);
    assert_eq!([1, 4], output_tensor.info().dims);

    info!("{:?}", output_tensor.as_data::<u8>());

    // Result must be 'yes'
    assert_eq!(Some(2), output_tensor.as_data::<u8>().iter().position_max());
    assert!(output_tensor.as_data::<u8>()[2] > 220);

    // -------- 'no' example --------

    // Run the front end on 30ms slices every 20ms
    let micro_feature = (0..49)
        .map(|n| &no_1000ms[n * 320..(n * 320) + 480])
        .map(|audio_slice| micro_speech_frontend(&mut frontend, audio_slice))
        .fold(vec![], |mut acc: Vec<u8>, slice| {
            acc.extend(&slice[..]);
            acc
        });

    assert_eq!(micro_feature.len(), 1960);

    // Invoke interpreter
    interpreter.input(0, &micro_feature).unwrap();
    interpreter.invoke().unwrap();

    // Get the output tensor
    let output_tensor = interpreter.output(0);
    assert_eq!([1, 4], output_tensor.info().dims);

    info!("{:?}", output_tensor.as_data::<u8>());

    // Result must be 'no'
    assert_eq!(Some(3), output_tensor.as_data::<u8>().iter().position_max());
    assert!(output_tensor.as_data::<u8>()[3] > 220);

    info!("---- Done");
}