[WIP] Improve Yolo WASM UI example (#591)

* return detections with classes names

* ignore .DS_Store

* example how to load wasm module

* add param to set model size

* add param for model size

* accept iou and confidence threshold on run

* conf and iou thresholds

* clamp only

* remove images from branch

* a couple of renamings, add readme with instructions

* final design

* minor font + border update

candle-wasm-examples/yolo/src/worker.rs

@@ -25,6 +25,14 @@ macro_rules! console_log {
 #[derive(Serialize, Deserialize)]
 pub struct ModelData {
     pub weights: Vec<u8>,
+    pub model_size: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct RunData {
+    pub image_data: Vec<u8>,
+    pub conf_threshold: f32,
+    pub iou_threshold: f32,
 }
 
 pub struct Model {
@@ -32,7 +40,12 @@ pub struct Model {
 }
 
 impl Model {
-    pub fn run(&self, image_data: Vec<u8>) -> Result<Vec<Vec<Bbox>>> {
+    pub fn run(
+        &self,
+        image_data: Vec<u8>,
+        conf_threshold: f32,
+        iou_threshold: f32,
+    ) -> Result<Vec<Vec<Bbox>>> {
         console_log!("image data: {}", image_data.len());
         let image_data = std::io::Cursor::new(image_data);
         let original_image = image::io::Reader::new(image_data)
@@ -68,20 +81,37 @@ impl Model {
         let image_t = (image_t.unsqueeze(0)?.to_dtype(DType::F32)? * (1. / 255.))?;
         let predictions = self.model.forward(&image_t)?.squeeze(0)?;
         console_log!("generated predictions {predictions:?}");
-        let bboxes = report(&predictions, original_image, width, height)?;
+        let bboxes = report(
+            &predictions,
+            original_image,
+            width,
+            height,
+            conf_threshold,
+            iou_threshold,
+        )?;
         Ok(bboxes)
     }
 
-    pub fn load_(weights: &[u8]) -> Result<Self> {
+    pub fn load_(weights: &[u8], model_size: &str) -> Result<Self> {
+        let multiples = match model_size {
+            "n" => Multiples::n(),
+            "s" => Multiples::s(),
+            "m" => Multiples::m(),
+            "l" => Multiples::l(),
+            "x" => Multiples::x(),
+            _ => Err(candle::Error::Msg(
+                "invalid model size: must be n, s, m, l or x".to_string(),
+            ))?,
+        };
         let dev = &Device::Cpu;
         let weights = safetensors::tensor::SafeTensors::deserialize(weights)?;
         let vb = VarBuilder::from_safetensors(vec![weights], DType::F32, dev);
-        let model = YoloV8::load(vb, Multiples::s(), 80)?;
+        let model = YoloV8::load(vb, multiples, 80)?;
         Ok(Self { model })
     }
 
     pub fn load(md: ModelData) -> Result<Self> {
-        Self::load_(&md.weights)
+        Self::load_(&md.weights, &md.model_size.to_string())
     }
 }
 
@@ -93,7 +123,7 @@ pub struct Worker {
 #[derive(Serialize, Deserialize)]
 pub enum WorkerInput {
     ModelData(ModelData),
-    Run(Vec<u8>),
+    RunData(RunData),
 }
 
 #[derive(Serialize, Deserialize)]
@@ -125,10 +155,12 @@ impl yew_agent::Worker for Worker {
                 }
                 Err(err) => Err(format!("model creation error {err:?}")),
             },
-            WorkerInput::Run(image_data) => match &mut self.model {
+            WorkerInput::RunData(rd) => match &mut self.model {
                 None => Err("model has not been set yet".to_string()),
                 Some(model) => {
-                    let result = model.run(image_data).map_err(|e| e.to_string());
+                    let result = model
+                        .run(rd.image_data, rd.conf_threshold, rd.iou_threshold)
+                        .map_err(|e| e.to_string());
                     Ok(WorkerOutput::ProcessingDone(result))
                 }
             },