Refactor the examples to the plugin system (second-state#22)

* Refactor the TFLite example

* Use WasmEdge 0.13 and wasi-nn 0.4.
* Add GitHub Actions CI

Part of Issue second-state#21

Signed-off-by: Michael Yuan <michael@secondstate.io>

* Add trigger to all branches

Signed-off-by: Michael Yuan <michael@secondstate.io>

---------

Signed-off-by: Michael Yuan <michael@secondstate.io>

Author: juntao

.github/workflows/tflite.yml

@@ -0,0 +1,51 @@
+name: Build and Test TFlite examples
+
+on:
+  workflow_dispatch:
+    inputs:
+      logLevel:
+        description: 'Log level'
+        required: true
+        default: 'info'
+  push:
+    branches: [ '*' ]
+  pull_request:
+    branches: [ '*' ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-20.04
+
+    steps:
+    - uses: actions/checkout@v2
+      
+    - name: Install apt-get packages
+      run: |
+        sudo ACCEPT_EULA=Y apt-get update
+        sudo ACCEPT_EULA=Y apt-get upgrade
+        sudo apt-get install wget git curl software-properties-common build-essential
+    
+    - name: Install Rust target for wasm
+      run: |
+        rustup target add wasm32-wasi
+        
+    - name: Install WasmEdge + WASI-NN + TFLite
+      run: |
+        VERSION=0.13.1
+        TFVERSION=2.12.0
+        curl -s -L -O --remote-name-all https://github.com/second-state/WasmEdge-tensorflow-deps/releases/download/TF-2.12.0-CC/WasmEdge-tensorflow-deps-TFLite-TF-$TFVERSION-CC-manylinux2014_x86_64.tar.gz
+        tar -zxf WasmEdge-tensorflow-deps-TFLite-TF-$TFVERSION-CC-manylinux2014_x86_64.tar.gz
+        rm -f WasmEdge-tensorflow-deps-TFLite-TF-$TFVERSION-CC-manylinux2014_x86_64.tar.gz
+        sudo mv libtensorflowlite_c.so /usr/local/lib
+        sudo mv libtensorflowlite_flex.so /usr/local/lib
+        curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | sudo bash -s -- -v $VERSION --plugins wasi_nn-tensorflowlite -p /usr/local
+        
+    - name: Example
+      run: |
+        cd tflite-birds_v1-image/rust
+        cargo build --target wasm32-wasi --release
+        cd ..
+        wasmedge compile rust/target/wasm32-wasi/release/wasmedge-wasinn-example-tflite-bird-image.wasm wasmedge-wasinn-example-tflite-bird-image.wasm
+        wasmedge --dir .:. wasmedge-wasinn-example-tflite-bird-image.wasm lite-model_aiy_vision_classifier_birds_V1_3.tflite bird.jpg
+

tflite-birds_v1-image/README.md

@@ -10,42 +10,34 @@ This crate depends on the `wasi-nn` in the `Cargo.toml`:
 
 ```toml
 [dependencies]
-wasi-nn = "0.3.0"
+wasi-nn = "0.4.0"
 ```
 
 ## Build
 
 Compile the application to WebAssembly:
 
 ```bash
-cd rust/tflite-bird && cargo build --target=wasm32-wasi --release
+cd rust && cargo build --target=wasm32-wasi --release
 ```
 
-The output WASM file will be at [`rust/tflite-bird/target/wasm32-wasi/release/wasmedge-wasinn-example-tflite-bird-image.wasm`](wasmedge-wasinn-example-tflite-bird-image.wasm).
+The output WASM file will be at [`rust/target/wasm32-wasi/release/wasmedge-wasinn-example-tflite-bird-image.wasm`](wasmedge-wasinn-example-tflite-bird-image.wasm).
 To speed up the image processing, we can enable the AOT mode in WasmEdge with:
 
 ```bash
-wasmedgec rust/tflite-bird/target/wasm32-wasi/release/wasmedge-wasinn-example-tflite-bird-image.wasm wasmedge-wasinn-example-tflite-bird-image.wasm
+wasmedge compile rust/target/wasm32-wasi/release/wasmedge-wasinn-example-tflite-bird-image.wasm wasmedge-wasinn-example-tflite-bird-image.wasm
 ```
 
 ## Run
 
-### Download fixture
+### Test data
 
 The testing image is located at `./bird.jpg`:
 
 ![Aix galericulata](bird.jpg)
 
 The `tflite` model is located at `./lite-model_aiy_vision_classifier_birds_V1_3.tflite`
 
-### Generate Image Tensor
-
-If you want to generate the [raw](birdx224x224x3.rgb) tensor, you can run:
-
-```shell
-cd rust/image-converter/ && cargo run ../../bird.jpg ../../birdx224x224x3.rgb
-```
-
 ### Execute
 
 Users should [install the WasmEdge with WASI-NN TensorFlow-Lite backend plug-in](https://wasmedge.org/book/en/write_wasm/rust/wasinn.html#get-wasmedge-with-wasi-nn-plug-in-tensorflow-lite-backend).

tflite-birds_v1-image/birdx224x224x3.rgb

@@ -8,6 +8,6 @@ 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.3.0" }
+wasi-nn = "0.4.0"
 
 [workspace]

tflite-birds_v1-image/rust/tflite-bird/Cargo.toml renamed to tflite-birds_v1-image/rust/Cargo.toml

@@ -1,60 +1,38 @@
 use image::io::Reader;
 use image::DynamicImage;
-use std::convert::TryInto;
 use std::env;
 use std::fs;
-use wasi_nn;
+use std::error::Error;
+use wasi_nn::{GraphBuilder, GraphEncoding, ExecutionTarget, TensorType};
 mod imagenet_classes;
 
-pub fn main() {
+pub fn main() -> Result<(), Box<dyn Error>> {
     let args: Vec<String> = env::args().collect();
     let model_bin_name: &str = &args[1];
     let image_name: &str = &args[2];
 
-    let weights = fs::read(model_bin_name).unwrap();
+    let weights = fs::read(model_bin_name)?;
     println!("Read graph weights, size in bytes: {}", weights.len());
 
-    let graph = unsafe {
-        wasi_nn::load(
-            &[&weights],
-            wasi_nn::GRAPH_ENCODING_TENSORFLOWLITE,
-            wasi_nn::EXECUTION_TARGET_CPU,
-        )
-        .unwrap()
-    };
+    let graph = GraphBuilder::new(GraphEncoding::TensorflowLite, ExecutionTarget::CPU).build_from_bytes(&[&weights])?;
+    let mut ctx = graph.init_execution_context()?;
     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, 224, 224, 3],
-        type_: wasi_nn::TENSOR_TYPE_U8,
-        data: &tensor_data,
-    };
-    unsafe {
-        wasi_nn::set_input(context, 0, tensor).unwrap();
-    }
+
+    // Pass tensor data into the TFLite runtime
+    ctx.set_input(0, TensorType::U8, &[1, 224, 224, 3], &tensor_data)?;
+
     // Execute the inference.
-    unsafe {
-        wasi_nn::compute(context).unwrap();
-    }
-    println!("Executed graph inference");
+    ctx.compute()?;
+
     // Retrieve the output.
-    let mut output_buffer = vec![0u8; 965];
-    unsafe {
-        wasi_nn::get_output(
-            context,
-            0,
-            &mut output_buffer[..] as *mut [u8] as *mut u8,
-            output_buffer.len().try_into().unwrap(),
-        )
-        .unwrap();
-    }
+    let mut output_buffer = vec![0u8; imagenet_classes::AIY_BIRDS_V1.len()];
+    _ = ctx.get_output(0, &mut output_buffer)?;
 
+    // Sort the result with the highest probability result first
     let results = sort_results(&output_buffer);
     for i in 0..5 {
         println!(
@@ -65,6 +43,8 @@ pub fn main() {
             imagenet_classes::AIY_BIRDS_V1[results[i].0]
         );
     }
+
+    Ok(())
 }
 
 // Sort the buffer of probabilities. The graph places the match probability for each class at the