active-vision 0.0.5__py3-none-any.whl → 0.1.1__py3-none-any.whl

active_vision/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "0.0.5"
+__version__ = "0.1.1"
 
 from .core import *

active_vision/core.py

@@ -1,19 +1,7 @@
 import pandas as pd
 from loguru import logger
-from fastai.callback.all import ShowGraphCallback
-from fastai.vision.all import (
-    ImageDataLoaders,
-    aug_transforms,
-    Resize,
-    vision_learner,
-    accuracy,
-    valley,
-    slide,
-    minimum,
-    steep,
-)
+from fastai.vision.all import *
 import torch
-import torch.nn.functional as F
 
 import warnings
 from typing import Callable
@@ -22,7 +10,28 @@ warnings.filterwarnings("ignore", category=FutureWarning)
 
 
 class ActiveLearner:
-    def __init__(self, model_name: str):
+    """
+    Active Learning framework for computer vision tasks.
+
+    Attributes:
+        Model Related:
+            model: The base model architecture (str or Callable)
+            learn: fastai Learner object for training
+            lrs: Learning rate finder results
+
+        Data Related:
+            train_set (pd.DataFrame): Training dataset
+            eval_set (pd.DataFrame): Evaluation dataset with ground truth labels
+            dls: fastai DataLoaders object
+            class_names: List of class names from the dataset
+            num_classes (int): Number of classes in the dataset
+
+        Prediction Related:
+            pred_df (pd.DataFrame): Predictions on a dataframe
+            eval_df (pd.DataFrame): Predictions on evaluation data
+    """
+
+    def __init__(self, model_name: str | Callable):
         self.model = self.load_model(model_name)
 
     def load_model(self, model_name: str | Callable):
@@ -43,6 +52,7 @@ class ActiveLearner:
         batch_size: int = 16,
         image_size: int = 224,
         batch_tfms: Callable = None,
+        learner_path: str = None,
     ):
         logger.info(f"Loading dataset from {filepath_col} and {label_col}")
         self.train_set = df.copy()
@@ -58,22 +68,66 @@ class ActiveLearner:
             item_tfms=Resize(image_size),
             batch_tfms=batch_tfms,
         )
-        logger.info("Creating learner")
-        self.learn = vision_learner(self.dls, self.model, metrics=accuracy).to_fp16()
+
+        if learner_path:
+            logger.info(f"Loading learner from {learner_path}")
+            gpu_available = torch.cuda.is_available()
+            if gpu_available:
+                logger.info(f"Loading learner on GPU.")
+            else:
+                logger.info(f"Loading learner on CPU.")
+
+            self.learn = load_learner(learner_path, cpu=not gpu_available)
+        else:
+            logger.info("Creating learner")
+            self.learn = vision_learner(
+                self.dls, self.model, metrics=accuracy
+            ).to_fp16()
+
         self.class_names = self.dls.vocab
+        self.num_classes = self.dls.c
         logger.info("Done. Ready to train.")
 
-    def show_batch(self):
-        self.dls.show_batch()
+    def show_batch(
+        self,
+        num_samples: int = 9,
+        unique: bool = False,
+        num_rows: int = None,
+        num_cols: int = None,
+    ):
+        """
+        Show a batch of images from the dataset.
+
+        Args:
+            num_samples: Number of samples to show.
+            unique: Whether to show unique samples.
+            num_rows: Number of rows in the grid.
+            num_cols: Number of columns in the grid.
+        """
+        self.dls.show_batch(
+            max_n=num_samples, unique=unique, nrows=num_rows, ncols=num_cols
+        )
 
     def lr_find(self):
         logger.info("Finding optimal learning rate")
         self.lrs = self.learn.lr_find(suggest_funcs=(minimum, steep, valley, slide))
         logger.info(f"Optimal learning rate: {self.lrs.valley}")
 
-    def train(self, epochs: int, lr: float):
-        logger.info(f"Training for {epochs} epochs with learning rate: {lr}")
-        self.learn.fine_tune(epochs, lr, cbs=[ShowGraphCallback()])
+    def train(self, epochs: int, lr: float, head_tuning_epochs: int = 1):
+        """
+        Train the model.
+
+        Args:
+            epochs: Number of epochs to train for.
+            lr: Learning rate.
+            head_tuning_epochs: Number of epochs to train the head.
+        """
+        logger.info(f"Training head for {head_tuning_epochs} epochs")
+        logger.info(f"Training model end-to-end for {epochs} epochs")
+        logger.info(f"Learning rate: {lr} with one-cycle learning rate scheduler")
+        self.learn.fine_tune(
+            epochs, lr, freeze_epochs=head_tuning_epochs, cbs=[ShowGraphCallback()]
+        )
 
     def predict(self, filepaths: list[str], batch_size: int = 16):
         """
@@ -87,7 +141,8 @@ class ActiveLearner:
             {
                 "filepath": filepaths,
                 "pred_label": [self.learn.dls.vocab[i] for i in cls_preds.numpy()],
-                "pred_conf": torch.max(F.softmax(preds, dim=1), dim=1)[0].numpy(),
+                "pred_conf": torch.max(preds, dim=1)[0].numpy(),
+                "pred_raw": preds.numpy().tolist(),
             }
         )
         return self.pred_df
@@ -131,11 +186,17 @@ class ActiveLearner:
         """
 
         # Remove samples that is already in the training set
-        df = df[~df["filepath"].isin(self.train_set["filepath"])]
+        df = df[~df["filepath"].isin(self.train_set["filepath"])].copy()
 
         if strategy == "least-confidence":
             logger.info(f"Getting top {num_samples} low confidence samples")
-            uncertain_df = df.sort_values(by="pred_conf", ascending=True).head(
+
+            df.loc[:, "uncertainty_score"] = 1 - (df["pred_conf"]) / (
+                self.num_classes - (self.num_classes - 1)
+            )
+
+            # Sort by descending uncertainty score
+            uncertain_df = df.sort_values(by="uncertainty_score", ascending=False).head(
                 num_samples
             )
             return uncertain_df
@@ -197,15 +258,15 @@ class ActiveLearner:
                 return;
             }
             
-            if (e.key.toLowerCase() == "w") {
+            if (e.key === "ArrowUp" || e.key === "Enter") {
                 document.getElementById("submit_btn").click();
-            } else if (e.key.toLowerCase() == "d") {
+            } else if (e.key === "ArrowRight") {
                 document.getElementById("next_btn").click();
-            } else if (e.key.toLowerCase() == "a") {
+            } else if (e.key === "ArrowLeft") {
                 document.getElementById("back_btn").click();
             }
         }
-        document.addEventListener('keypress', shortcuts, false);
+        document.addEventListener('keydown', shortcuts, false);
         </script>
         """
 
@@ -214,36 +275,149 @@ class ActiveLearner:
         filepaths = df["filepath"].tolist()
 
         with gr.Blocks(head=shortcut_js) as demo:
-            current_index = gr.State(value=0)
+            with gr.Tabs():
+                with gr.Tab("Labeling"):
+                    current_index = gr.State(value=0)
+
+                    with gr.Row(min_height=500):
+                        image = gr.Image(
+                            type="filepath",
+                            label="Image",
+                            value=filepaths[0],
+                            height=500
+                        )
+
+                        # Add bar plot with top 5 predictions
+                        with gr.Column():
+                            pred_plot = gr.BarPlot(
+                                x="probability",
+                                y="class",
+                                title="Top 5 Predictions",
+                                x_lim=[0, 1],
+                                value=None
+                                if "pred_raw" not in df.columns
+                                else pd.DataFrame(
+                                    {
+                                        "class": self.class_names,
+                                        "probability": df["pred_raw"].iloc[0],
+                                    }
+                                ).nlargest(5, "probability"),
+                            )
+
+                            filename = gr.Textbox(
+                                label="Filename", value=filepaths[0], interactive=False
+                            )
+
+                            pred_label = gr.Textbox(
+                                label="Predicted Label",
+                                value=df["pred_label"].iloc[0]
+                                if "pred_label" in df.columns
+                                else "",
+                                interactive=False,
+                            )
+                            pred_conf = gr.Textbox(
+                                label="Confidence",
+                                value=f"{df['pred_conf'].iloc[0]:.2%}"
+                                if "pred_conf" in df.columns
+                                else "",
+                                interactive=False,
+                            )
+
+                    category = gr.Radio(
+                        choices=self.class_names,
+                        label="Select Category",
+                        value=df["pred_label"].iloc[0]
+                        if "pred_label" in df.columns
+                        else None,
+                    )
 
-            filename = gr.Textbox(
-                label="Filename", value=filepaths[0], interactive=False
-            )
+                    with gr.Row():
+                        back_btn = gr.Button("← Previous", elem_id="back_btn")
+                        submit_btn = gr.Button(
+                            "Submit (↑/Enter)",
+                            variant="primary",
+                            elem_id="submit_btn",
+                        )
+                        next_btn = gr.Button("Next →", elem_id="next_btn")
+
+                    progress = gr.Slider(
+                        minimum=0,
+                        maximum=len(filepaths) - 1,
+                        value=0,
+                        label="Progress",
+                        interactive=False,
+                    )
 
-            image = gr.Image(
-                type="filepath", label="Image", value=filepaths[0], height=500
+                    finish_btn = gr.Button("Finish Labeling", variant="primary")
+
+                with gr.Tab("Zero-Shot Inference"):
+                    gr.Markdown("""
+                    Uses a VLM to predict the label of the image.
+                    """)
+
+                    import xinfer
+                    from xinfer.model_registry import model_registry
+                    from xinfer.types import ModelInputOutput
+
+                    # Get models and filter for image-to-text models
+                    all_models = model_registry.list_models()
+                    model_list = [
+                        model.id
+                        for model in all_models
+                        if model.input_output == ModelInputOutput.IMAGE_TEXT_TO_TEXT
+                    ]
+
+                    with gr.Row():
+                        with gr.Row():
+                            model_dropdown = gr.Dropdown(
+                                choices=model_list,
+                                label="Select a model",
+                                value="vikhyatk/moondream2",
+                            )
+                            device_dropdown = gr.Dropdown(
+                                choices=["cuda", "cpu"],
+                                label="Device",
+                                value="cuda" if torch.cuda.is_available() else "cpu",
+                            )
+                            dtype_dropdown = gr.Dropdown(
+                                choices=["float32", "float16", "bfloat16"],
+                                label="Data Type",
+                                value="float16"
+                                if torch.cuda.is_available()
+                                else "float32",
+                            )
+
+                    with gr.Column():
+                        prompt_textbox = gr.Textbox(
+                            label="Prompt",
+                            lines=5,
+                            value=f"Classify the image into one of the following categories: {self.class_names}. Answer with the category name only.",
+                            interactive=True,
+                        )
+                        inference_btn = gr.Button("Run Inference", variant="primary")
+
+                        result_textbox = gr.Textbox(
+                            label="Result",
+                            lines=3,
+                            interactive=False,
+                        )
+
+            def run_zero_shot_inference(prompt, model, device, dtype, current_filename):
+                model = xinfer.create_model(model, device=device, dtype=dtype)
+                result = model.infer(current_filename, prompt).text
+                return result
+
+            inference_btn.click(
+                fn=run_zero_shot_inference,
+                inputs=[
+                    prompt_textbox,
+                    model_dropdown,
+                    device_dropdown,
+                    dtype_dropdown,
+                    filename,
+                ],
+                outputs=[result_textbox],
             )
-            category = gr.Radio(choices=self.class_names, label="Select Category")
-
-            with gr.Row():
-                back_btn = gr.Button("← Previous (A)", elem_id="back_btn")
-                submit_btn = gr.Button(
-                    "Submit (W)",
-                    variant="primary",
-                    elem_id="submit_btn",
-                    interactive=False,
-                )
-                next_btn = gr.Button("Next → (D)", elem_id="next_btn")
-
-            progress = gr.Slider(
-                minimum=0,
-                maximum=len(filepaths) - 1,
-                value=0,
-                label="Progress",
-                interactive=False,
-            )
-
-            finish_btn = gr.Button("Finish Labeling", variant="primary")
 
             def update_submit_btn(choice):
                 return gr.Button(interactive=choice is not None)
@@ -253,23 +427,84 @@ class ActiveLearner:
             )
 
             def navigate(current_idx, direction):
+                # Convert current_idx to int before arithmetic
+                current_idx = int(current_idx)
                 next_idx = current_idx + direction
+
                 if 0 <= next_idx < len(filepaths):
-                    return filepaths[next_idx], filepaths[next_idx], next_idx, next_idx
+                    plot_data = (
+                        None
+                        if "pred_raw" not in df.columns
+                        else pd.DataFrame(
+                            {
+                                "class": self.class_names,
+                                "probability": df["pred_raw"].iloc[next_idx],
+                            }
+                        ).nlargest(5, "probability")
+                    )
+                    return (
+                        filepaths[next_idx],
+                        filepaths[next_idx],
+                        df["pred_label"].iloc[next_idx]
+                        if "pred_label" in df.columns
+                        else "",
+                        f"{df['pred_conf'].iloc[next_idx]:.2%}"
+                        if "pred_conf" in df.columns
+                        else "",
+                        df["pred_label"].iloc[next_idx]
+                        if "pred_label" in df.columns
+                        else None,
+                        next_idx,
+                        next_idx,
+                        plot_data,
+                    )
+                plot_data = (
+                    None
+                    if "pred_raw" not in df.columns
+                    else pd.DataFrame(
+                        {
+                            "class": self.class_names,
+                            "probability": df["pred_raw"].iloc[current_idx],
+                        }
+                    ).nlargest(5, "probability")
+                )
                 return (
                     filepaths[current_idx],
                     filepaths[current_idx],
+                    df["pred_label"].iloc[current_idx]
+                    if "pred_label" in df.columns
+                    else "",
+                    f"{df['pred_conf'].iloc[current_idx]:.2%}"
+                    if "pred_conf" in df.columns
+                    else "",
+                    df["pred_label"].iloc[current_idx]
+                    if "pred_label" in df.columns
+                    else None,
                     current_idx,
                     current_idx,
+                    plot_data,
                 )
 
             def save_and_next(current_idx, selected_category):
+                # Convert current_idx to int before arithmetic
+                current_idx = int(current_idx)
+
                 if selected_category is None:
+                    plot_data = None if "pred_raw" not in df.columns else pd.DataFrame(
+                        {
+                            "class": self.class_names,
+                            "probability": df["pred_raw"].iloc[current_idx],
+                        }
+                    ).nlargest(5, "probability")
                     return (
                         filepaths[current_idx],
                         filepaths[current_idx],
+                        df["pred_label"].iloc[current_idx] if "pred_label" in df.columns else "",
+                        f"{df['pred_conf'].iloc[current_idx]:.2%}" if "pred_conf" in df.columns else "",
+                        df["pred_label"].iloc[current_idx] if "pred_label" in df.columns else None,
                         current_idx,
                         current_idx,
+                        plot_data,
                     )
 
                 # Save the current annotation
@@ -279,13 +514,39 @@ class ActiveLearner:
                 # Move to next image if not at the end
                 next_idx = current_idx + 1
                 if next_idx >= len(filepaths):
+                    plot_data = None if "pred_raw" not in df.columns else pd.DataFrame(
+                        {
+                            "class": self.class_names,
+                            "probability": df["pred_raw"].iloc[current_idx],
+                        }
+                    ).nlargest(5, "probability")
                     return (
                         filepaths[current_idx],
                         filepaths[current_idx],
+                        df["pred_label"].iloc[current_idx] if "pred_label" in df.columns else "",
+                        f"{df['pred_conf'].iloc[current_idx]:.2%}" if "pred_conf" in df.columns else "",
+                        df["pred_label"].iloc[current_idx] if "pred_label" in df.columns else None,
                         current_idx,
                         current_idx,
+                        plot_data,
                     )
-                return filepaths[next_idx], filepaths[next_idx], next_idx, next_idx
+
+                plot_data = None if "pred_raw" not in df.columns else pd.DataFrame(
+                    {
+                        "class": self.class_names,
+                        "probability": df["pred_raw"].iloc[next_idx],
+                    }
+                ).nlargest(5, "probability")
+                return (
+                    filepaths[next_idx],
+                    filepaths[next_idx],
+                    df["pred_label"].iloc[next_idx] if "pred_label" in df.columns else "",
+                    f"{df['pred_conf'].iloc[next_idx]:.2%}" if "pred_conf" in df.columns else "",
+                    df["pred_label"].iloc[next_idx] if "pred_label" in df.columns else None,
+                    next_idx,
+                    next_idx,
+                    plot_data,
+                )
 
             def convert_csv_to_parquet():
                 try:
@@ -301,19 +562,46 @@ class ActiveLearner:
             back_btn.click(
                 fn=lambda idx: navigate(idx, -1),
                 inputs=[current_index],
-                outputs=[filename, image, current_index, progress],
+                outputs=[
+                    filename,
+                    image,
+                    pred_label,
+                    pred_conf,
+                    category,
+                    current_index,
+                    progress,
+                    pred_plot,
+                ],
             )
 
             next_btn.click(
                 fn=lambda idx: navigate(idx, 1),
                 inputs=[current_index],
-                outputs=[filename, image, current_index, progress],
+                outputs=[
+                    filename,
+                    image,
+                    pred_label,
+                    pred_conf,
+                    category,
+                    current_index,
+                    progress,
+                    pred_plot,
+                ],
             )
 
             submit_btn.click(
                 fn=save_and_next,
                 inputs=[current_index, category],
-                outputs=[filename, image, current_index, progress],
+                outputs=[
+                    filename,
+                    image,
+                    pred_label,
+                    pred_conf,
+                    category,
+                    current_index,
+                    progress,
+                    pred_plot,
+                ],
             )
 
             finish_btn.click(fn=convert_csv_to_parquet)
@@ -325,10 +613,6 @@ class ActiveLearner:
         Add samples to the training set.
         """
         new_train_set = df.copy()
-        # new_train_set.drop(columns=["pred_conf"], inplace=True)
-        # new_train_set.rename(columns={"pred_label": "label"}, inplace=True)
-
-        # len_old = len(self.train_set)
 
         logger.info(f"Adding {len(new_train_set)} samples to training set")
         self.train_set = pd.concat([self.train_set, new_train_set])
@@ -340,13 +624,3 @@ class ActiveLearner:
 
         self.train_set.to_parquet(f"{output_filename}.parquet")
         logger.info(f"Saved training set to {output_filename}.parquet")
-
-        # if len(self.train_set) == len_old:
-        #     logger.warning("No new samples added to training set")
-
-        # elif len_old + len(new_train_set) < len(self.train_set):
-        #     logger.warning("Some samples were duplicates and removed from training set")
-
-        # else:
-        #     logger.info("All new samples added to training set")
-        #     logger.info(f"Training set now has {len(self.train_set)} samples")

{active_vision-0.0.5.dist-info → active_vision-0.1.1.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.2
 Name: active-vision
-Version: 0.0.5
+Version: 0.1.1
 Summary: Active learning for edge vision.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: accelerate>=1.2.1
 Requires-Dist: datasets>=3.2.0
 Requires-Dist: fastai>=2.7.18
 Requires-Dist: gradio>=5.12.0
@@ -13,6 +14,8 @@ Requires-Dist: ipywidgets>=8.1.5
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: seaborn>=0.13.2
 Requires-Dist: timm>=1.0.13
+Requires-Dist: transformers>=4.48.0
+Requires-Dist: xinfer>=0.3.2
 
 ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue?style=for-the-badge)
 ![License](https://img.shields.io/badge/License-Apache%202.0-green.svg?style=for-the-badge)
@@ -68,17 +71,18 @@ cd active-vision
 pip install -e .
 ```
 
-I recommend using [uv](https://docs.astral.sh/uv/) to set up a virtual environment and install the package. You can also use other virtual env of your choice.
-
-If you're using uv:
-
-```bash
-uv venv
-uv sync
-```
-Once the virtual environment is created, you can install the package using pip.
 
 > [!TIP]
+> I recommend using [uv](https://docs.astral.sh/uv/) to set up a virtual environment and install the package. You can also use other virtual env of your choice.
+> 
+> If you're using uv:
+> 
+> ```bash
+> uv venv
+> uv sync
+> ```
+> Once the virtual environment is created, you can install the package using pip.
+>
 > If you're using uv add a `uv` before the pip install command to install into your virtual environment. Eg:
 > ```bash
 > uv pip install active-vision
@@ -117,12 +121,16 @@ pred_df = al.predict(filepaths)
 # Sample low confidence predictions from unlabeled set
 uncertain_df = al.sample_uncertain(pred_df, num_samples=10)
 
-# Launch a Gradio UI to label the low confidence samples
+# Launch a Gradio UI to label the low confidence samples, save the labeled samples to a file
 al.label(uncertain_df, output_filename="uncertain")
 ```
 
 ![Gradio UI](https://raw.githubusercontent.com/dnth/active-vision/main/assets/labeling_ui.png)
 
+In the UI, you can optionally run zero-shot inference on the image. This will use a VLM to predict the label of the image. There are a dozen VLM models as supported in the [x.infer project](https://github.com/dnth/x.infer).
+
+![Zero-Shot Inference](https://raw.githubusercontent.com/dnth/active-vision/main/assets/zero_shot_ui.png)
+
 Once complete, the labeled samples will be save into a new df.
 We can now add the newly labeled data to the training set.
 
@@ -167,12 +175,12 @@ The active learning loop is a iterative process and can keep going until you hit
 For this dataset,I decided to stop the active learning loop at 275 labeled images because the performance on the evaluation set is close to the top performing model on the leaderboard. 
 
 
-| #Labeled Images | Evaluation Accuracy | Train Epochs | Model                | Active Learning | Source |
-|-----------------|---------------------|--------------|----------------------|----------------|--------|
-| 9469            | 94.90%              | 80           | xse_resnext50        | ❌             | [Link](https://github.com/fastai/imagenette) |
-| 9469            | 95.11%              | 200          | xse_resnext50        | ❌             | [Link](https://github.com/fastai/imagenette) |
-| 275             | 99.33%               | 6            | convnext_small_in22k | ✓              | [Link](https://github.com/dnth/active-vision/blob/main/nbs/05_retrain_larger.ipynb) |
-| 275             | 93.40%               | 4            | resnet18             | ✓              | [Link](https://github.com/dnth/active-vision/blob/main/nbs/04_relabel_loop.ipynb) |
+| #Labeled Images 	| Evaluation Accuracy 	| Train Epochs 	| Model                	| Active Learning 	| Source                                                                              	|
+|----------------:	|--------------------:	|-------------:	|----------------------	|:---------------:	|-------------------------------------------------------------------------------------	|
+| 9469            	| 94.90%              	| 80           	| xse_resnext50        	| ❌                | [Link](https://github.com/fastai/imagenette)                                        	 |
+| 9469            	| 95.11%              	| 200          	| xse_resnext50        	| ❌                | [Link](https://github.com/fastai/imagenette)                                        	 |
+| 275             	| 99.33%              	| 6            	| convnext_small_in22k 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/05_retrain_larger.ipynb) 	|
+| 275             	| 93.40%              	| 4            	| resnet18             	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/04_relabel_loop.ipynb)   	|
 
 ### Dog Food
 - num classes: 2
@@ -182,11 +190,11 @@ To start the active learning loop, I labeled 20 images (10 images from each clas
 
 I decided to stop the active learning loop at 160 labeled images because the performance on the evaluation set is close to the top performing model on the leaderboard. You can decide your own stopping point based on your use case.
 
-| #Labeled Images | Evaluation Accuracy | Train Epochs | Model | Active Learning | Source |
-|-----------------|---------------------|--------------|-------|----------------|--------|
-| 2100            | 99.70%              | ?            | vit-base-patch16-224   | ❌             | [Link](https://huggingface.co/abhishek/autotrain-dog-vs-food) |
-| 160             | 100.00%             | 6            | convnext_small_in22k   | ✓              | [Link](https://github.com/dnth/active-vision/blob/main/nbs/dog_food_dataset/02_train.ipynb) |
-| 160             | 97.60%              | 4            | resnet18              | ✓              | [Link](https://github.com/dnth/active-vision/blob/main/nbs/dog_food_dataset/01_label.ipynb) |
+| #Labeled Images 	| Evaluation Accuracy 	| Train Epochs 	| Model                	| Active Learning 	| Source                                                                                      	|
+|----------------:	|--------------------:	|-------------:	|----------------------	|:---------------:	|---------------------------------------------------------------------------------------------	|
+| 2100            	| 99.70%              	| ?            	| vit-base-patch16-224 	| ❌               	| [Link](https://huggingface.co/abhishek/autotrain-dog-vs-food)                               	|
+| 160             	| 100.00%             	| 6            	| convnext_small_in22k 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/dog_food_dataset/02_train.ipynb) 	|
+| 160             	| 97.60%              	| 4            	| resnet18             	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/dog_food_dataset/01_label.ipynb) 	|
 
 ### Oxford-IIIT Pet
 - num classes: 37
@@ -196,13 +204,27 @@ To start the active learning loop, I labeled 370 images (10 images from each cla
 
 I decided to stop the active learning loop at 612 labeled images because the performance on the evaluation set is close to the top performing model on the leaderboard. You can decide your own stopping point based on your use case.
 
-| #Labeled Images | Evaluation Accuracy | Train Epochs | Model | Active Learning | Source |
-|-----------------|---------------------|--------------|-------|----------------|--------|
-| 3680             | 95.40%              | 5           | vit-base-patch16-224   | ❌              | [Link](https://huggingface.co/walterg777/vit-base-oxford-iiit-pets) |
-| 612             | 90.26%              | 11            | convnext_small_in22k              | ✓              | [Link](https://github.com/dnth/active-vision/blob/main/nbs/oxford_iiit_pets/02_train.ipynb) |
-| 612             | 91.38%              | 11            | vit-base-patch16-224              | ✓              | [Link](https://github.com/dnth/active-vision/blob/main/nbs/oxford_iiit_pets/03_train_vit.ipynb) |
+| #Labeled Images 	| Evaluation Accuracy 	| Train Epochs 	| Model                	| Active Learning 	| Source                                                                                          	|
+|----------------:	|--------------------:	|-------------:	|----------------------	|:---------------:	|-------------------------------------------------------------------------------------------------	|
+| 3680            	| 95.40%              	| 5            	| vit-base-patch16-224 	| ❌                | [Link](https://huggingface.co/walterg777/vit-base-oxford-iiit-pets)                             	 |
+| 612             	| 90.26%              	| 11           	| convnext_small_in22k 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/oxford_iiit_pets/02_train.ipynb)     	|
+| 612             	| 91.38%              	| 11           	| vit-base-patch16-224 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/oxford_iiit_pets/03_train_vit.ipynb) 	|
+
+### Eurosat RGB
+- num classes: 10
+- num images: 16100
+
+To start the active learning loop, I labeled 100 images (10 images from each class) and iteratively labeled the most informative images until I hit 1188 labeled images. 
+
+I decided to stop the active learning loop at 1188 labeled images because the performance on the evaluation set is close to the top performing model on the leaderboard. You can decide your own stopping point based on your use case.
 
 
+| #Labeled Images 	| Evaluation Accuracy 	| Train Epochs 	| Model                	| Active Learning 	| Source                                                                                     	|
+|----------------:	|--------------------:	|-------------:	|----------------------	|:---------------:	|--------------------------------------------------------------------------------------------	|
+| 16100           	| 98.55%              	| 6            	| vit-base-patch16-224 	| ❌                | [Link](https://github.com/dnth/active-vision/blob/main/nbs/eurosat_rgb/03_train_all.ipynb)  |
+| 1188            	| 94.59%              	| 6            	| vit-base-patch16-224 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/eurosat_rgb/02_train.ipynb)     	|
+| 1188            	| 96.57%              	| 13           	| vit-base-patch16-224 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/eurosat_rgb/02_train.ipynb)     	|
+
 
 ## ➿ Workflow
 This section describes a more detailed workflow for active learning. There are two workflows for active learning that we can use depending on the availability of labeled data.
@@ -270,55 +292,21 @@ graph TD
 
 
 
-<!-- ## Methodology
-To test out the workflows we will use the [imagenette dataset](https://huggingface.co/datasets/frgfm/imagenette). But this will be applicable to any dataset.
-
-Imagenette is a subset of the ImageNet dataset with 10 classes. We will use this dataset to test out the workflows. Additionally, Imagenette has an existing leaderboard which we can use to evaluate the performance of the models.
-
-### Step 1: Download the dataset
-Download the imagenette dataset. The imagenette dataset has a train and validation split. Since the leaderboard is based on the validation set, we will evalutate the performance of our model on the validation set to make it easier to compare to the leaderboard.
-
-We will treat the imagenette train set as a unlabeled set and iteratively sample from it while monitoring the performance on the validation set. Ideally we will be able to get to a point where the performance on the validation set is close to the leaderboard with minimal number of labeled images.
+## 🧱 Sampling Approaches
 
-I've processed the imagenette dataset and uploaded it to the hub. You can download it from [here](https://huggingface.co/datasets/dnth/active-learning-imagenette).
+Recommendation 1:
+- 10% randomly selected from unlabeled items.
+- 80% selected from the lowest confidence items.
+- 10% selected as outliers.
 
-To load the dataset, you can use the following code:
-```python
-from datasets import load_dataset
-
-unlabeled_dataset = load_dataset("dnth/active-learning-imagenette", "unlabeled")
-eval_dataset = load_dataset("dnth/active-learning-imagenette", "evaluation")
-```
+Recommendation 2:
 
-### Step 2: Initial Sampling
-Label an initial dataset of 10 images from each class. This will give us a small proxy dataset to train our model on. The sampling will be done randomly. There are more intelligent sampling strategies but we will start with random sampling.
+- Sample 100 predicted images at 10–20% confidence.
+- Sample 100 predicted images at 20–30% confidence.
+- Sample 100 predicted images at 30–40% confidence, and so on.
 
-### Step 3: Training the proxy model
-Train a proxy model on the initial dataset. The proxy model will be a small model that is easy to train and deploy. We will use the fastai framework to train the model. We will use the resnet18 architecture as a starting point. Once training is complete, compute the accuracy of the proxy model on the validation set and compare it to the leaderboard.
 
-> [!TIP]
-> With the initial model we got 91.24% accuracy on the validation set. See the [notebook](./nbs/01_initial_sampling.ipynb) for more details.
-> | Train Epochs | Number of Images | Validation Accuracy |      Source      |
-> |--------------|-----------------|----------------------|------------------|
-> | 10           | 100             | 91.24%               | Initial sampling [notebook](./nbs/01_initial_sampling.ipynb) |
-> | 80           | 9469            | 94.90%               | fastai |
-> | 200          | 9469            | 95.11%               | fastai |
+Uncertainty and diversity sampling are most effective when combined. For instance, you could first sample the most uncertain items using an uncertainty sampling method, then apply a diversity sampling method such as clustering to select a diverse set from the uncertain items.
 
+Ultimately, the right ratios can depend on the specific task and dataset.
 
-
-### Step 4: Inference on the unlabeled dataset
-Run inference on the unlabeled dataset (the remaining imagenette train set) and evaluate the performance of the proxy model. 
-
-### Step 5: Active learning
-Use active learning to select the most informative images to label from the unlabeled set. Pick the top 10 images from the unlabeled set that the proxy model is least confident about and label them.
-
-### Step 6: Repeat
-Repeat step 3 - 5 until the performance on the validation set is close to the leaderboard. Note the number of labeled images vs the performance on the validation set. Ideally we want to get to a point where the performance on the validation set is close to the leaderboard with minimal number of labeled images.
-
-
-After the first iteration we got 94.57% accuracy on the validation set. See the [notebook](./nbs/03_retrain_model.ipynb) for more details.
-
-> [!TIP]
-> | Train Epochs | Number of Images | Validation Accuracy |      Source      |
-> |--------------|-----------------|----------------------|------------------|
-> | 10           | 200             | 94.57%               | First relabeling [notebook](./nbs/03_retrain_model.ipynb) | -->

active_vision-0.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+active_vision/__init__.py,sha256=xWa6YKvR3wF8p_D9PprKNGP3VnxjbyVpcwnPCMhhaHM,43
+active_vision/core.py,sha256=jWzTOx3GCB2Sq5-JGgoi-ZD2teoIGTYas9StqZxXefo,24999
+active_vision-0.1.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+active_vision-0.1.1.dist-info/METADATA,sha256=U8-IH0WJnPj6KPBsfsxcW4GZCTDY0KFxrqz7migcnro,15454
+active_vision-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+active_vision-0.1.1.dist-info/top_level.txt,sha256=7qUQvccN2UU63z5S9vrgJmqK-8sFGrtpf1e9Z86nihE,14
+active_vision-0.1.1.dist-info/RECORD,,

active_vision-0.0.5.dist-info/RECORD

@@ -1,7 +0,0 @@
-active_vision/__init__.py,sha256=u-7eEtxmLFoQfY0fM9JSs_lWb4e1c7WxR3cC619BTXE,43
-active_vision/core.py,sha256=mKS-ZZunjPgXuavm_J4oYiO9lm6UNRjFEzIn4kNfdVA,13421
-active_vision-0.0.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-active_vision-0.0.5.dist-info/METADATA,sha256=mSFB-DeJ43roTwswTp3oHcG3CIyKnO-7ZCqaYbw26eQ,15846
-active_vision-0.0.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-active_vision-0.0.5.dist-info/top_level.txt,sha256=7qUQvccN2UU63z5S9vrgJmqK-8sFGrtpf1e9Z86nihE,14
-active_vision-0.0.5.dist-info/RECORD,,