active-vision 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

active_vision/__init__.py

@@ -1 +1,3 @@
-__version__ = "0.0.1"
+__version__ = "0.0.3"
+
+from .core import *

active_vision/core.py

@@ -0,0 +1,291 @@
+import pandas as pd
+from loguru import logger
+from fastai.vision.models import resnet18, resnet34
+from fastai.callback.all import ShowGraphCallback
+from fastai.vision.all import (
+    ImageDataLoaders,
+    aug_transforms,
+    Resize,
+    vision_learner,
+    accuracy,
+    valley,
+    slide,
+    minimum,
+    steep,
+)
+import torch
+import torch.nn.functional as F
+
+import warnings
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+
+class ActiveLearner:
+    def __init__(self, model_name: str):
+        self.model = self.load_model(model_name)
+
+    def load_model(self, model_name: str):
+        models = {"resnet18": resnet18, "resnet34": resnet34}
+        logger.info(f"Loading model {model_name}")
+        if model_name not in models:
+            logger.error(f"Model {model_name} not found")
+            raise ValueError(f"Model {model_name} not found")
+        return models[model_name]
+
+    def load_dataset(
+        self,
+        df: pd.DataFrame,
+        filepath_col: str,
+        label_col: str,
+        valid_pct: float = 0.2,
+        batch_size: int = 16,
+        image_size: int = 224,
+    ):
+        logger.info(f"Loading dataset from {filepath_col} and {label_col}")
+        self.train_set = df.copy()
+
+        logger.info("Creating dataloaders")
+        self.dls = ImageDataLoaders.from_df(
+            df,
+            path=".",
+            valid_pct=valid_pct,
+            fn_col=filepath_col,
+            label_col=label_col,
+            bs=batch_size,
+            item_tfms=Resize(image_size),
+            batch_tfms=aug_transforms(size=image_size, min_scale=0.75),
+        )
+        logger.info("Creating learner")
+        self.learn = vision_learner(self.dls, self.model, metrics=accuracy).to_fp16()
+        self.class_names = self.dls.vocab
+        logger.info("Done. Ready to train.")
+
+    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 predict(self, filepaths: list[str], batch_size: int = 16):
+        """
+        Run inference on an unlabeled dataset. Returns a df with filepaths and predicted labels, and confidence scores.
+        """
+        logger.info(f"Running inference on {len(filepaths)} samples")
+        test_dl = self.dls.test_dl(filepaths, bs=batch_size)
+        preds, _, cls_preds = self.learn.get_preds(dl=test_dl, with_decoded=True)
+
+        self.pred_df = pd.DataFrame(
+            {
+                "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(),
+            }
+        )
+        return self.pred_df
+
+    def evaluate(
+        self, df: pd.DataFrame, filepath_col: str, label_col: str, batch_size: int = 16
+    ):
+        """
+        Evaluate on a labeled dataset. Returns a score.
+        """
+        self.eval_set = df.copy()
+
+        filepaths = self.eval_set[filepath_col].tolist()
+        labels = self.eval_set[label_col].tolist()
+        test_dl = self.dls.test_dl(filepaths, bs=batch_size)
+        preds, _, cls_preds = self.learn.get_preds(dl=test_dl, with_decoded=True)
+
+        self.eval_df = pd.DataFrame(
+            {
+                "filepath": filepaths,
+                "label": labels,
+                "pred_label": [self.learn.dls.vocab[i] for i in cls_preds.numpy()],
+            }
+        )
+
+        accuracy = float((self.eval_df["label"] == self.eval_df["pred_label"]).mean())
+        logger.info(f"Accuracy: {accuracy:.2%}")
+        return accuracy
+
+    def sample_uncertain(self, df: pd.DataFrame, num_samples: int):
+        """
+        Sample top `num_samples` low confidence samples. Returns a df with filepaths and predicted labels, and confidence scores.
+        """
+        logger.info(f"Getting top {num_samples} low confidence samples")
+        uncertain_df = df.sort_values(by="pred_conf", ascending=True).head(num_samples)
+        return uncertain_df
+
+    def label(self, df: pd.DataFrame, output_filename: str = "labeled"):
+        """
+        Launch a labeling interface for the user to label the samples.
+        Input is a df with filepaths listing the files to be labeled. Output is a df with filepaths and labels.
+        """
+        import gradio as gr
+
+        shortcut_js = """
+        <script>
+        function shortcuts(e) {
+            // Only block shortcuts if we're in a text input or textarea
+            if (e.target.tagName.toLowerCase() === "textarea" || 
+                (e.target.tagName.toLowerCase() === "input" && e.target.type.toLowerCase() === "text")) {
+                return;
+            }
+            
+            if (e.key.toLowerCase() == "w") {
+                document.getElementById("submit_btn").click();
+            } else if (e.key.toLowerCase() == "d") {
+                document.getElementById("next_btn").click();
+            } else if (e.key.toLowerCase() == "a") {
+                document.getElementById("back_btn").click();
+            }
+        }
+        document.addEventListener('keypress', shortcuts, false);
+        </script>
+        """
+
+        logger.info(f"Launching labeling interface for {len(df)} samples")
+
+        filepaths = df["filepath"].tolist()
+
+        with gr.Blocks(head=shortcut_js) as demo:
+            current_index = gr.State(value=0)
+
+            filename = gr.Textbox(
+                label="Filename", value=filepaths[0], interactive=False
+            )
+
+            image = gr.Image(
+                type="filepath", label="Image", value=filepaths[0], height=500
+            )
+            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)
+
+            category.change(
+                fn=update_submit_btn, inputs=[category], outputs=[submit_btn]
+            )
+
+            def navigate(current_idx, direction):
+                next_idx = current_idx + direction
+                if 0 <= next_idx < len(filepaths):
+                    return filepaths[next_idx], filepaths[next_idx], next_idx, next_idx
+                return (
+                    filepaths[current_idx],
+                    filepaths[current_idx],
+                    current_idx,
+                    current_idx,
+                )
+
+            def save_and_next(current_idx, selected_category):
+                if selected_category is None:
+                    return (
+                        filepaths[current_idx],
+                        filepaths[current_idx],
+                        current_idx,
+                        current_idx,
+                    )
+
+                # Save the current annotation
+                with open(f"{output_filename}.csv", "a") as f:
+                    f.write(f"{filepaths[current_idx]},{selected_category}\n")
+
+                # Move to next image if not at the end
+                next_idx = current_idx + 1
+                if next_idx >= len(filepaths):
+                    return (
+                        filepaths[current_idx],
+                        filepaths[current_idx],
+                        current_idx,
+                        current_idx,
+                    )
+                return filepaths[next_idx], filepaths[next_idx], next_idx, next_idx
+
+            def convert_csv_to_parquet():
+                try:
+                    df = pd.read_csv(f"{output_filename}.csv", header=None)
+                    df.columns = ["filepath", "label"]
+                    df = df.drop_duplicates(subset=["filepath"], keep="last")
+                    df.to_parquet(f"{output_filename}.parquet")
+                    gr.Info(f"Annotation saved to {output_filename}.parquet")
+                except Exception as e:
+                    logger.error(e)
+                    return
+
+            back_btn.click(
+                fn=lambda idx: navigate(idx, -1),
+                inputs=[current_index],
+                outputs=[filename, image, current_index, progress],
+            )
+
+            next_btn.click(
+                fn=lambda idx: navigate(idx, 1),
+                inputs=[current_index],
+                outputs=[filename, image, current_index, progress],
+            )
+
+            submit_btn.click(
+                fn=save_and_next,
+                inputs=[current_index, category],
+                outputs=[filename, image, current_index, progress],
+            )
+
+            finish_btn.click(fn=convert_csv_to_parquet)
+
+        demo.launch(height=1000)
+
+    def add_to_train_set(self, df: pd.DataFrame, output_filename: str):
+        """
+        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])
+
+        self.train_set = self.train_set.drop_duplicates(
+            subset=["filepath"], keep="last"
+        )
+        self.train_set.reset_index(drop=True, inplace=True)
+
+        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.1.dist-info → active_vision-0.0.3.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.2
 Name: active-vision
-Version: 0.0.1
+Version: 0.0.3
 Summary: Active learning for edge vision.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: datasets>=3.2.0
 Requires-Dist: fastai>=2.7.18
+Requires-Dist: gradio>=5.12.0
 Requires-Dist: ipykernel>=6.29.5
 Requires-Dist: ipywidgets>=8.1.5
 Requires-Dist: loguru>=0.7.3
@@ -14,75 +15,93 @@ Requires-Dist: seaborn>=0.13.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)
+[![PyPI](https://img.shields.io/pypi/v/active-vision?style=for-the-badge)](https://pypi.org/project/active-vision/)
+![Downloads](https://img.shields.io/pepy/dt/active-vision?style=for-the-badge&logo=pypi&logoColor=white&label=Downloads&color=purple)   
 
 <p align="center">
-  <img src="./assets/logo.png" alt="active-vision">
+  <img src="https://raw.githubusercontent.com/dnth/active-vision/main/assets/logo.png" alt="active-vision">
 </p>
 
 Active learning at the edge for computer vision.
 
-The goal of this project is to create a framework for active learning at the edge for computer vision. We should be able to train a model on a small dataset and then use active learning to iteratively improve the model all on a local machine.
+The goal of this project is to create a framework for the active learning loop for computer vision deployed on edge devices. 
 
-## Tech Stack
+## Installation
+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.
 
-- Training framework: fastai
-- User interface: streamlit
-- Database: sqlite
-- Experiment tracking: wandb
+If you're using uv:
 
-## Installation
+```bash
+uv venv
+uv sync
+```
+Once the virtual environment is created, you can install the package using pip.
 
-PyPI
+Get a release from PyPI
 ```bash
 pip install active-vision
 ```
 
-Local install
+Install from source
 ```bash
 git clone https://github.com/dnth/active-vision.git
 cd active-vision
 pip install -e .
 ```
 
-## Usage [WIP]
+> [!TIP]
+> 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
+> ```
 
-```python
-import active_vision as av
+## Usage
+See the [notebook](./nbs/04_relabel_loop.ipynb) for a complete example.
 
-# Load a model
-model = av.load_model("resnet18")
+Be sure to prepared 3 datasets:
+- train: A dataframe of an existing labeled training dataset.
+- unlabeled: A dataframe of unlabeled data which we will sample from using active learning.
+- eval: A dataframe of labeled data which we will use to evaluate the performance of the model. (Optional)
 
-# Load a dataset
-dataset = av.load_dataset(df)
+```python
+from active_vision import ActiveLearner
+import pandas as pd
+
+# Create an active learner instance with a model
+al = ActiveLearner("resnet18")
 
-# Inital sampling
-dataset = av.initial_sampling(dataset, n_samples=10)
+# Load dataset 
+train_df = pd.read_parquet("training_samples.parquet")
+al.load_dataset(df, filepath_col="filepath", label_col="label")
 
-# Train the model
-model.train()
+# Train model
+al.train(epochs=3, lr=1e-3)
 
-# Save the model
-model.save()
+# Evaluate the model on a *labeled* evaluation set
+accuracy = al.evaluate(eval_df, filepath_col="filepath", label_col="label")
 
-# Evaluate the model
-model.evaluate(df)
+# Get predictions from an *unlabeled* set
+pred_df = al.predict(filepaths)
 
-# Uncertainty sampling to get the lowest confidence images
-model.uncertainty_sampling()
+# Sample low confidence predictions from unlabeled set
+uncertain_df = al.sample_uncertain(pred_df, num_samples=10)
 
-# Diversity sampling to get the most diverse images (outliers)
-model.diversity_sampling()
+# Launch a Gradio UI to label the low confidence samples
+al.label(uncertain_df, output_filename="uncertain")
+```
 
-# Random sampling
-model.random_sampling()
+![Gradio UI](./assets/labeling_ui.png)
 
-# Merge the datasets
-dataset = av.merge_datasets(dataset, dataset_2)
+Once complete, the labeled samples will be save into a new df.
+We can now add the newly labeled data to the training set.
 
-# Launch a streamlit app to label the images
-av.label_images(dataset)
+```python
+# Add newly labeled data to training set and save as a new file active_labeled
+al.add_to_train_set(labeled_df, output_filename="active_labeled")
 ```
 
+Repeat the process until the model is good enough. Use the dataset to train a larger model and deploy.
+
 ## Workflow
 There are two workflows for active learning at the edge that we can use depending on the availability of labeled data.
 

active_vision-0.0.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+active_vision/__init__.py,sha256=hZp8jB284ByY44Q5cdwTt9Zz5n4QWXnz0OexpEE9muk,43
+active_vision/core.py,sha256=0aXDI5Gpj0Spk7TSIxJf8aJDDBgZh0-jkWdYyZ1Zric,10713
+active_vision-0.0.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+active_vision-0.0.3.dist-info/METADATA,sha256=g629Kn07n4ZXOOX5cW1nPQK1IR9Mm5vW_z7RqxdwKgY,9385
+active_vision-0.0.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+active_vision-0.0.3.dist-info/top_level.txt,sha256=7qUQvccN2UU63z5S9vrgJmqK-8sFGrtpf1e9Z86nihE,14
+active_vision-0.0.3.dist-info/RECORD,,

active_vision-0.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-active_vision/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
-active_vision-0.0.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-active_vision-0.0.1.dist-info/METADATA,sha256=lPOTTVSPAaX3Rn9Q1ci_jgoQOC-HFpQIyTNqrouOYEs,7936
-active_vision-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-active_vision-0.0.1.dist-info/top_level.txt,sha256=7qUQvccN2UU63z5S9vrgJmqK-8sFGrtpf1e9Z86nihE,14
-active_vision-0.0.1.dist-info/RECORD,,