A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
use image::{DynamicImage, RgbImage};
use ndarray::Array;
use std::{fs, time::Instant};
pub fn main() {
// Load model from a file.
let graph =
wasi_nn::GraphBuilder::new(wasi_nn::GraphEncoding::Onnx, wasi_nn::ExecutionTarget::CPU)
.build_from_files(["fixture/mobilenet.onnx"])
.unwrap();
let mut context = graph.init_execution_context().unwrap();
println!("Created an execution context.");
// Read image from file and convert it to tensor data.
let image_data = fs::read("fixture/kitten.png").unwrap();
// Preprocessing. Normalize data based on model requirements https://github.com/onnx/models/tree/main/validated/vision/classification/mobilenet#preprocessing
let tensor_data = preprocess(
image_data.as_slice(),
224,
224,
&[0.485, 0.456, 0.406],
&[0.229, 0.224, 0.225],
);
println!("Read input tensor, size in bytes: {}", tensor_data.len());
context
.set_input(0, wasi_nn::TensorType::F32, &[1, 3, 224, 224], &tensor_data)
.unwrap();
// Execute the inference.
let before_compute = Instant::now();
context.compute().unwrap();
println!(
"Executed graph inference, took {} ms.",
before_compute.elapsed().as_millis()
);
// Retrieve the output.
let mut output_buffer = vec![0f32; 1000];
context.get_output(0, &mut output_buffer[..]).unwrap();
// Postprocessing. Calculating the softmax probability scores.
let result = postprocess(output_buffer);
// Load labels for classification
let labels_file = fs::read("fixture/synset.txt").unwrap();
let labels_str = String::from_utf8(labels_file).unwrap();
let labels: Vec<String> = labels_str
.lines()
.map(|line| {
let words: Vec<&str> = line.split_whitespace().collect();
words[1..].join(" ")
})
.collect();
println!(
"Found results, sorted top 5: {:?}",
&sort_results(&result, &labels)[..5]
)
}
// Sort the buffer of probabilities. The graph places the match probability for each class at the
// index for that class (e.g. the probability of class 42 is placed at buffer[42]). Here we convert
// to a wrapping InferenceResult and sort the results.
fn sort_results(buffer: &[f32], labels: &Vec<String>) -> Vec<InferenceResult> {
let mut results: Vec<InferenceResult> = buffer
.iter()
.enumerate()
.map(|(c, p)| InferenceResult(labels[c].clone(), *p))
.collect();
results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
results
}
// Resize image to height x width, and then converts the pixel precision to FP32, normalize with
// given mean and std. The resulting RGB pixel vector is then returned.
fn preprocess(image: &[u8], height: u32, width: u32, mean: &[f32], std: &[f32]) -> Vec<u8> {
let dyn_img: DynamicImage = image::load_from_memory(image).unwrap().resize_exact(
width,
height,
image::imageops::Triangle,
);
let rgb_img: RgbImage = dyn_img.to_rgb8();
// Get an array of the pixel values
let raw_u8_arr: &[u8] = &rgb_img.as_raw()[..];
// Create an array to hold the f32 value of those pixels
let bytes_required = raw_u8_arr.len() * 4;
let mut u8_f32_arr: Vec<u8> = vec![0; bytes_required];
// Read the number as a f32 and break it into u8 bytes
for i in 0..raw_u8_arr.len() {
let u8_f32: f32 = raw_u8_arr[i] as f32;
let rgb_iter = i % 3;
// Normalize the pixel
let norm_u8_f32: f32 = (u8_f32 / 255.0 - mean[rgb_iter]) / std[rgb_iter];
// Convert it to u8 bytes and write it with new shape
let u8_bytes = norm_u8_f32.to_ne_bytes();
for j in 0..4 {
u8_f32_arr[(raw_u8_arr.len() * 4 * rgb_iter / 3) + (i / 3) * 4 + j] = u8_bytes[j];
}
}
return u8_f32_arr;
}
fn postprocess(output_tensor: Vec<f32>) -> Vec<f32> {
// Post-Processing requirement: compute softmax to inferencing output
let output_shape = [1, 1000, 1, 1];
let exp_output = Array::from_shape_vec(output_shape, output_tensor)
.unwrap()
.mapv(|x| x.exp());
let sum_exp_output = exp_output.sum_axis(ndarray::Axis(1));
let softmax_output = exp_output / &sum_exp_output;
softmax_output.into_raw_vec()
}
pub fn bytes_to_f32_vec(data: Vec<u8>) -> Vec<f32> {
let chunks: Vec<&[u8]> = data.chunks(4).collect();
let v: Vec<f32> = chunks
.into_iter()
.map(|c| f32::from_ne_bytes(c.try_into().unwrap()))
.collect();
v.into_iter().collect()
}
// A wrapper for class ID and match probabilities.
#[derive(Debug, PartialEq)]
struct InferenceResult(String, f32);