[Examples] OpenVINO mobilenet taking image as input (second-state#2)

Signed-off-by: Jianbai Ye <jianbaiye@outlook.com>

Author: gusye1234

.github/workflows/build.yaml

@@ -52,6 +52,15 @@ jobs:
           source /opt/intel/openvino_2021/bin/setupvars.sh;\
           ldconfig;\
           cd WasmEdge && cmake --install build && cd ..;\
-          cd mobilenet;\
+          cd openvino-mobilenet-raw;\
           ./download_mobilenet.sh;\
           wasmedge --dir .:. wasmedge-wasinn-example-mobilenet.wasm mobilenet.xml mobilenet.bin tensor-1x224x224x3-f32.bgr"
+      - name: Build and run Rust example - Mobilenet Image
+        run: |
+          bash -c "\
+          source /opt/intel/openvino_2021/bin/setupvars.sh;\
+          ldconfig;\
+          cd WasmEdge && cmake --install build && cd ..;\
+          cd openvino-mobilenet-image;\
+          ./download_mobilenet.sh;\
+          wasmedge --dir .:. wasmedge-wasinn-example-mobilenet-image.wasm mobilenet.xml mobilenet.bin input.jpg"

.gitignore

@@ -1,5 +1,13 @@
 **/build
 **/target
 
+openvino-mobilenet-image/mobilenet.bin
+openvino-mobilenet-image/mobilenet.xml
+openvino-mobilenet-image/input.jpg
+
+openvino-mobilenet-raw/mobilenet.bin
+openvino-mobilenet-raw/mobilenet.xml
+openvino-mobilenet-raw/tensor-1x224x224x3-f32.bgr
+
 .DS_Store
 Cargo.lock

mobilenet/rust/Cargo.lock

@@ -0,0 +1,63 @@
+# Mobilenet example for WASI-NN
+
+This package is a high-level Rust bindings for [wasi-nn] example of Mobilenet.
+
+[wasi-nn]: https://github.com/WebAssembly/wasi-nn
+
+## Dependencies
+
+This crate depends on the `wasi-nn` in the `Cargo.toml`:
+
+```toml
+[dependencies]
+wasi-nn = "0.1.0"
+```
+
+## Build
+
+Compile the application to WebAssembly:
+
+```bash
+cargo build --target=wasm32-wasi --release
+```
+
+The output WASM file will be at `target/wasm32-wasi/release/wasmedge-wasinn-example-mobilenet-image.wasm`.
+To speed up the image processing, we can enable the AOT mode in WasmEdge with:
+
+```bash
+wasmedgec rust/target/wasm32-wasi/release/wasmedge-wasinn-example-mobilenet-image.wasm wasmedge-wasinn-example-mobilenet-image.wasm
+```
+
+## Run
+
+First download the fixture files with the script:
+
+```bash
+./download_mobilenet.sh
+```
+
+it will also download a testing image `input.jpg`
+
+![](https://github.com/bytecodealliance/wasi-nn/raw/main/rust/images/1.jpg)
+
+And execute the WASM with the `wasmedge` with OpenVINO supporting:
+
+```bash
+wasmedge --dir .:. wasmedge-wasinn-example-mobilenet-image.wasm mobilenet.xml mobilenet.bin input.jpg
+```
+
+You will get the output:
+
+```bash
+Read graph XML, size in bytes: 143525
+Read graph weights, size in bytes: 13956476
+Loaded graph into wasi-nn with ID: 0
+Created wasi-nn execution context with ID: 0
+Read input tensor, size in bytes: 602112
+Executed graph inference
+   1.) [954](0.9789)banana
+   2.) [940](0.0074)spaghetti squash
+   3.) [951](0.0014)lemon
+   4.) [969](0.0005)eggnog
+   5.) [942](0.0005)butternut squash
+```

openvino-mobilenet-image/README.md

@@ -0,0 +1,12 @@
+FIXTURE=https://github.com/intel/openvino-rs/raw/v0.3.3/crates/openvino/tests/fixtures/mobilenet
+TODIR=$1
+
+if [ ! -f $TODIR/mobilenet.bin ]; then
+    wget --no-clobber --directory-prefix=$TODIR $FIXTURE/mobilenet.bin
+fi
+if [ ! -f $TODIR/mobilenet.xml ]; then
+    wget --no-clobber --directory-prefix=$TODIR $FIXTURE/mobilenet.xml
+fi
+if [ ! -f $TODIR/input.jpg ]; then
+    wget --no-clobber --directory-prefix=$TODIR https://github.com/bytecodealliance/wasi-nn/raw/main/rust/images/1.jpg -O input.jpg
+fi

openvino-mobilenet-image/download_mobilenet.sh

@@ -0,0 +1,16 @@
+[package]
+name = "wasmedge-wasinn-example-mobilenet-image"
+version = "0.19.0"
+authors = ["Second-State"]
+readme = "README.md"
+edition = "2018"
+publish = false
+
+[dependencies]
+image = { version = "0.23.14", default-features = false, features = ["gif", "jpeg", "ico", "png", "pnm", "tga", "tiff", "webp", "bmp", "hdr", "dxt", "dds", "farbfeld"]  }
+wasi-nn = { version = "0.1.0" }
+
+# This crate is built with the wasm32-wasi target, so it's separate
+# from the main Wasmtime build, so use this directive to exclude it
+# from the parent directory's workspace.
+[workspace]

openvino-mobilenet-image/rust/Cargo.toml

@@ -0,0 +1,123 @@
+use image::io::Reader;
+use image::DynamicImage;
+use std::convert::TryInto;
+use std::env;
+use std::fs;
+use wasi_nn;
+mod imagenet_classes;
+
+pub fn main() {
+    main_entry();
+}
+
+#[no_mangle]
+fn main_entry() {
+    infer_image();
+}
+
+fn infer_image() {
+    let args: Vec<String> = env::args().collect();
+    let model_xml_name: &str = &args[1];
+    let model_bin_name: &str = &args[2];
+    let image_name: &str = &args[3];
+
+    let xml = fs::read_to_string(model_xml_name).unwrap();
+    println!("Read graph XML, size in bytes: {}", xml.len());
+
+    let weights = fs::read(model_bin_name).unwrap();
+    println!("Read graph weights, size in bytes: {}", weights.len());
+
+    let graph = unsafe {
+        wasi_nn::load(
+            &[&xml.into_bytes(), &weights],
+            wasi_nn::GRAPH_ENCODING_OPENVINO,
+            wasi_nn::EXECUTION_TARGET_CPU,
+        )
+        .unwrap()
+    };
+    println!("Loaded graph into wasi-nn with ID: {}", graph);
+
+    let context = unsafe { wasi_nn::init_execution_context(graph).unwrap() };
+    println!("Created wasi-nn execution context with ID: {}", context);
+
+    // Load a tensor that precisely matches the graph input tensor (see
+    let tensor_data = image_to_tensor(image_name.to_string(), 224, 224);
+    println!("Read input tensor, size in bytes: {}", tensor_data.len());
+    let tensor = wasi_nn::Tensor {
+        dimensions: &[1, 3, 224, 224],
+        r#type: wasi_nn::TENSOR_TYPE_F32,
+        data: &tensor_data,
+    };
+    unsafe {
+        wasi_nn::set_input(context, 0, tensor).unwrap();
+    }
+    // Execute the inference.
+    unsafe {
+        wasi_nn::compute(context).unwrap();
+    }
+    println!("Executed graph inference");
+    // Retrieve the output.
+    let mut output_buffer = vec![0f32; 1001];
+    unsafe {
+        wasi_nn::get_output(
+            context,
+            0,
+            &mut output_buffer[..] as *mut [f32] as *mut u8,
+            (output_buffer.len() * 4).try_into().unwrap(),
+        )
+        .unwrap();
+    }
+
+    let results = sort_results(&output_buffer);
+    for i in 0..5 {
+        println!(
+            "   {}.) [{}]({:.4}){}",
+            i + 1,
+            results[i].0,
+            results[i].1,
+            imagenet_classes::IMAGENET_CLASSES[results[i].0]
+        );
+    }
+}
+
+// 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]) -> Vec<InferenceResult> {
+    let mut results: Vec<InferenceResult> = buffer
+        .iter()
+        .skip(1)
+        .enumerate()
+        .map(|(c, p)| InferenceResult(c, *p))
+        .collect();
+    results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+    results
+}
+
+// Take the image located at 'path', open it, resize it to height x width, and then converts
+// the pixel precision to FP32. The resulting BGR pixel vector is then returned.
+fn image_to_tensor(path: String, height: u32, width: u32) -> Vec<u8> {
+    let pixels = Reader::open(path).unwrap().decode().unwrap();
+    let dyn_img: DynamicImage = pixels.resize_exact(width, height, image::imageops::Triangle);
+    let bgr_img = dyn_img.to_bgr8();
+    // Get an array of the pixel values
+    let raw_u8_arr: &[u8] = &bgr_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];
+
+    for i in 0..raw_u8_arr.len() {
+        // Read the number as a f32 and break it into u8 bytes
+        let u8_f32: f32 = raw_u8_arr[i] as f32;
+        let u8_bytes = u8_f32.to_ne_bytes();
+
+        for j in 0..4 {
+            u8_f32_arr[(i * 4) + j] = u8_bytes[j];
+        }
+    }
+    return u8_f32_arr;
+}
+
+// A wrapper for class ID and match probabilities.
+#[derive(Debug, PartialEq)]
+struct InferenceResult(usize, f32);