active-vision 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

active_vision/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "0.4.1"
+__version__ = "0.4.3"
 
 from .core import *

active_vision/core.py

@@ -20,8 +20,11 @@ from fastai.vision.all import (
     valley,
     vision_learner,
 )
+from itables import show
 from loguru import logger
 
+from .utils import get_base64_image
+
 warnings.filterwarnings("ignore", category=FutureWarning)
 pd.set_option("display.max_colwidth", 50)
 
@@ -102,6 +105,9 @@ class ActiveLearner:
         self.valid_set = self.learn.dls.valid_ds.items
         self.class_names = self.dls.vocab
         self.num_classes = self.dls.c
+
+        logger.info(f"Training set size: {len(self.train_set)}")
+        logger.info(f"Validation set size: {len(self.valid_set)}")
         logger.info("Done. Ready to train.")
 
     def load_dataset(
@@ -209,7 +215,9 @@ class ActiveLearner:
         logger.info(f"Learning rate: {lr} with one-cycle learning rate scheduler")
         self.learn.fine_tune(epochs, lr, freeze_epochs=head_tuning_epochs)
 
-    def predict(self, filepaths: list[str], batch_size: int = 16):
+    def predict(
+        self, filepaths: list[str], batch_size: int = 16, interactive: bool = False
+    ):
         """
         Run inference on an unlabeled dataset. Returns a df with filepaths and predicted labels, and confidence scores.
         """
@@ -257,47 +265,108 @@ class ActiveLearner:
             lambda x: [round(e, 4) for e in x]
         )
 
+        if interactive:
+            logger.info("Rendering interactive table")
+            interactive_pred_df = self.pred_df.copy()
+            interactive_pred_df["image"] = interactive_pred_df["filepath"].apply(
+                get_base64_image
+            )
+            interactive_pred_df = interactive_pred_df[
+                ["image", "filepath", "pred_label", "pred_conf", "logits", "embeddings"]
+            ]
+
+            show(
+                interactive_pred_df,
+                columnDefs=[{"width": "200px", "targets": "_all"}],
+                style="width:1200px",
+                autoWidth=False,
+            )
+
         return self.pred_df
 
     def evaluate(
-        self, df: pd.DataFrame, filepath_col: str, label_col: str, batch_size: int = 16
+        self,
+        df: pd.DataFrame,
+        filepath_col: str,
+        label_col: str,
+        batch_size: int = 16,
+        interactive: bool = False,
     ):
         """
         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)
+        test_dl = self.dls.test_dl(self.eval_set, bs=batch_size, with_labels=True)
+        probs, targs, cls_preds, loss = self.learn.get_preds(
+            dl=test_dl, with_decoded=True, with_loss=True
+        )
 
-        self.eval_df = pd.DataFrame(
+        eval_df = pd.DataFrame(
             {
-                "filepath": filepaths,
-                "label": labels,
+                "filepath": self.eval_set[filepath_col].tolist(),
+                "label": self.eval_set[label_col].tolist(),
                 "pred_label": [self.learn.dls.vocab[i] for i in cls_preds.numpy()],
+                "pred_conf": torch.max(F.softmax(probs, dim=1), dim=1)[0].numpy(),
+                "probs": probs.numpy().tolist(),
+                "loss": loss.numpy().tolist(),
             }
         )
 
-        accuracy = float((self.eval_df["label"] == self.eval_df["pred_label"]).mean())
+        accuracy = float((eval_df["label"] == eval_df["pred_label"]).mean())
         self.eval_accuracy = accuracy
         logger.info(f"Accuracy: {accuracy:.2%}")
-        return accuracy
+
+        if interactive:
+            logger.info("Rendering interactive table")
+
+            interactive_eval_df = eval_df.copy()
+            interactive_eval_df["image"] = interactive_eval_df["filepath"].apply(
+                get_base64_image
+            )
+            interactive_eval_df = interactive_eval_df[
+                [
+                    "image",
+                    "filepath",
+                    "label",
+                    "pred_label",
+                    "pred_conf",
+                    "loss",
+                    "probs",
+                ]
+            ]
+
+            show(
+                interactive_eval_df,
+                columnDefs=[{"width": "200px", "targets": "_all"}],
+                style="width:1200px",
+                autoWidth=False,
+            )
+
+        return eval_df
 
     def sample_uncertain(
-        self, df: pd.DataFrame, num_samples: int, strategy: str = "least-confidence"
+        self,
+        df: pd.DataFrame,
+        num_samples: int,
+        strategy: str = "least-confidence",
+        interactive: bool = False,
     ):
         """
         Sample top `num_samples` low confidence samples. Returns a df with filepaths and predicted labels, and confidence scores.
 
+        Args:
+            df: DataFrame with predictions
+            num_samples: Number of samples to select
+            strategy: Sampling strategy to use
+            interactive: Whether to display an interactive table of results
+
         Strategies:
-        - least-confidence: Get top `num_samples` low confidence samples.
-        - margin-of-confidence: Get top `num_samples` samples with the smallest margin between the top two predictions.
-        - ratio-of-confidence: Get top `num_samples` samples with the highest ratio between the top two predictions.
-        - entropy: Get top `num_samples` samples with the highest entropy.
+            - least-confidence: Get top `num_samples` low confidence samples.
+            - margin-of-confidence: Get top `num_samples` samples with the smallest margin between the top two predictions.
+            - ratio-of-confidence: Get top `num_samples` samples with the highest ratio between the top two predictions.
+            - entropy: Get top `num_samples` samples with the highest entropy.
         """
-
         # Remove samples that is already in the training set
         df = df[~df["filepath"].isin(self.dataset["filepath"])].copy()
 
@@ -366,20 +435,45 @@ class ActiveLearner:
         ]
 
         df["score"] = df["score"].round(4)
+        result_df = df.sort_values(by="score", ascending=False).head(num_samples)
+
+        if interactive:
+            logger.info("Rendering interactive table")
+            interactive_df = result_df.copy()
+            interactive_df["image"] = interactive_df["filepath"].apply(get_base64_image)
+            interactive_df = interactive_df[
+                ["image", "filepath", "strategy", "score", "pred_label", "pred_conf"]
+            ]
+
+            show(
+                interactive_df,
+                columnDefs=[{"width": "200px", "targets": "_all"}],
+                style="width:1200px",
+                autoWidth=False,
+            )
 
-        return df.sort_values(by="score", ascending=False).head(num_samples)
+        return result_df
 
     def sample_diverse(
-        self, df: pd.DataFrame, num_samples: int, strategy: str = "model-based-outlier"
+        self,
+        df: pd.DataFrame,
+        num_samples: int,
+        strategy: str = "model-based-outlier",
+        interactive: bool = False,
     ):
         """
         Sample top `num_samples` diverse samples. Returns a df with filepaths and predicted labels, and confidence scores.
 
-        Strategies:
-        - model-based-outlier: Get top `num_samples` samples with lowest activation of the model's last layer.
-        - cluster-based: Get top `num_samples` samples with the highest distance to the nearest neighbor.
-        - representative: Get top `num_samples` samples with the highest distance to the centroid of the training set.
+        Args:
+            df: DataFrame with predictions
+            num_samples: Number of samples to select
+            strategy: Sampling strategy to use
+            interactive: Whether to display an interactive table of results
 
+        Strategies:
+            - model-based-outlier: Get top `num_samples` samples with lowest activation of the model's last layer.
+            - cluster-based: Get top `num_samples` samples with the highest distance to the nearest neighbor.
+            - representative: Get top `num_samples` samples with the highest distance to the centroid of the training set.
         """
         # Remove samples that is already in the training set
         df = df[~df["filepath"].isin(self.dataset["filepath"])].copy()
@@ -444,19 +538,54 @@ class ActiveLearner:
             ]
 
             df["score"] = df["score"].round(4)
+            result_df = df.sort_values(by="score", ascending=False).head(num_samples)
 
-            # Sort by score ascending higher rank = more outlier-like compared to the validation set
-            return df.sort_values(by="score", ascending=False).head(num_samples)
+            if interactive:
+                logger.info("Rendering interactive table")
+                interactive_df = result_df.copy()
+                interactive_df["image"] = interactive_df["filepath"].apply(
+                    get_base64_image
+                )
+                interactive_df = interactive_df[
+                    [
+                        "image",
+                        "filepath",
+                        "strategy",
+                        "score",
+                        "pred_label",
+                        "pred_conf",
+                    ]
+                ]
+
+                show(
+                    interactive_df,
+                    columnDefs=[{"width": "200px", "targets": "_all"}],
+                    style="width:1200px",
+                    autoWidth=False,
+                )
+
+            return result_df
 
         else:
             logger.error(f"Unknown strategy: {strategy}")
             raise ValueError(f"Unknown strategy: {strategy}")
 
-    def sample_random(self, df: pd.DataFrame, num_samples: int, seed: int = None):
+    def sample_random(
+        self,
+        df: pd.DataFrame,
+        num_samples: int,
+        seed: int = None,
+        interactive: bool = False,
+    ):
         """
         Sample `num_samples` random samples. Returns a df with filepaths and predicted labels, and confidence scores.
-        """
 
+        Args:
+            df: DataFrame with predictions
+            num_samples: Number of samples to select
+            seed: Random seed for reproducibility
+            interactive: Whether to display an interactive table of results
+        """
         logger.info(f"Sampling {num_samples} random samples")
         df = df[~df["filepath"].isin(self.dataset["filepath"])].copy()
         df["strategy"] = "random"
@@ -464,9 +593,32 @@ class ActiveLearner:
 
         if seed is not None:
             logger.info(f"Using seed: {seed}")
-        return df.sample(n=num_samples, random_state=seed)
+        result_df = df.sample(n=num_samples, random_state=seed)
+
+        if interactive:
+            logger.info("Rendering interactive table")
+            interactive_df = result_df.copy()
+            interactive_df["image"] = interactive_df["filepath"].apply(get_base64_image)
+            interactive_df = interactive_df[
+                ["image", "filepath", "strategy", "score", "pred_label", "pred_conf"]
+            ]
 
-    def sample_combination(self, df: pd.DataFrame, num_samples: int, combination: dict):
+            show(
+                interactive_df,
+                columnDefs=[{"width": "200px", "targets": "_all"}],
+                style="width:1200px",
+                autoWidth=False,
+            )
+
+        return result_df
+
+    def sample_combination(
+        self,
+        df: pd.DataFrame,
+        num_samples: int,
+        combination: dict,
+        interactive: bool = False,
+    ):
         """
         Sample samples based on a combination of strategies.
 
@@ -491,6 +643,7 @@ class ActiveLearner:
                     - representative
                 Other:
                     - random
+            interactive: Whether to display an interactive table of results
 
         Returns:
             DataFrame containing the combined samples
@@ -528,14 +681,16 @@ class ActiveLearner:
                 "entropy",
             ]:
                 strategy_df = self.sample_uncertain(
-                    df=df, num_samples=n_samples, strategy=strategy
+                    df=df, num_samples=n_samples, strategy=strategy, interactive=False
                 )
             elif strategy in ["model-based-outlier", "cluster-based", "representative"]:
                 strategy_df = self.sample_diverse(
-                    df=df, num_samples=n_samples, strategy=strategy
+                    df=df, num_samples=n_samples, strategy=strategy, interactive=False
                 )
             elif strategy == "random":
-                strategy_df = self.sample_random(df=df, num_samples=n_samples)
+                strategy_df = self.sample_random(
+                    df=df, num_samples=n_samples, interactive=False
+                )
             else:
                 raise ValueError(f"Unknown strategy: {strategy}")
 
@@ -543,7 +698,24 @@ class ActiveLearner:
             # Remove selected samples from the pool to avoid duplicates
             df = df[~df["filepath"].isin(strategy_df["filepath"])]
 
-        return pd.concat(sampled_dfs, ignore_index=True)
+        combined_df = pd.concat(sampled_dfs, ignore_index=True)
+
+        if interactive:
+            logger.info("Rendering interactive table")
+            interactive_df = combined_df.copy()
+            interactive_df["image"] = interactive_df["filepath"].apply(get_base64_image)
+            interactive_df = interactive_df[
+                ["image", "filepath", "strategy", "score", "pred_label", "pred_conf"]
+            ]
+
+            show(
+                interactive_df,
+                columnDefs=[{"width": "200px", "targets": "_all"}],
+                style="width:1200px",
+                autoWidth=False,
+            )
+
+        return combined_df
 
     def summary(self, filename: str = None, show: bool = True):
         results_df = pd.DataFrame(
@@ -567,13 +739,22 @@ class ActiveLearner:
         if filename is None:
             # Generate filename with timestamp, accuracy and dataset size
             from datetime import datetime
+
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            accuracy_str = f"{self.eval_accuracy:.2%}" if self.eval_accuracy is not None else "no_eval"
+            accuracy_str = (
+                f"{self.eval_accuracy:.2%}"
+                if self.eval_accuracy is not None
+                else "no_eval"
+            )
             dataset_size = len(self.train_set) + len(self.valid_set)
-            filename = f"{self.name}_{timestamp}_acc_{accuracy_str}_n_{dataset_size}.parquet"
+            filename = f"{self.name}_{timestamp}_acc_{accuracy_str}_n_{dataset_size}_results.parquet"
         elif not filename.endswith(".parquet"):
             filename = f"{filename}.parquet"
 
+        logger.info("Saving learner to pickle file")
+        learner_name = filename.replace("_results.parquet", "_learner.pkl")
+        self.learn.export(learner_name)
+
         results_df.to_parquet(filename)
         logger.info(f"Saved results to {filename}")
         if show:
@@ -597,12 +778,14 @@ class ActiveLearner:
                 return;
             }
             
-            if (e.key === "ArrowUp") {
+            if (e.key === "ArrowUp" || e.key === "w") {
                 document.getElementById("submit_btn").click();
-            } else if (e.key === "ArrowRight") {
+            } else if (e.key === "ArrowRight" || e.key === "d") {
                 document.getElementById("next_btn").click();
-            } else if (e.key === "ArrowLeft") {
+            } else if (e.key === "ArrowLeft" || e.key === "a") {
                 document.getElementById("back_btn").click();
+            } else if (e.key === "ArrowDown" || e.key === "s") {
+                document.getElementById("finish_btn").click();
             }
         }
         document.addEventListener('keydown', shortcuts, false);
@@ -710,6 +893,11 @@ class ActiveLearner:
                         interactive=True,
                     )
 
+                    # Add element_id to finish button
+                    finish_btn = gr.Button(
+                        "Finish Labeling", variant="primary", elem_id="finish_btn"
+                    )
+
                     # Add event handler for slider changes
                     progress.change(
                         fn=lambda idx: navigate(idx, 0),
@@ -728,8 +916,6 @@ class ActiveLearner:
                         ],
                     )
 
-                    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.

active_vision/utils.py

@@ -0,0 +1,58 @@
+import base64
+import os
+from io import BytesIO
+
+from itables import show
+from loguru import logger
+from PIL import Image
+
+
+def get_base64_image(filepath, width=200):
+    try:
+        with Image.open(filepath) as img:
+            # Convert to RGB if needed
+            if img.mode != "RGB":
+                img = img.convert("RGB")
+
+            aspect_ratio = img.height / img.width
+            height = int(width * aspect_ratio)
+            img = img.resize((width, height), Image.Resampling.LANCZOS)
+            buffered = BytesIO()
+            img.save(buffered, format="JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            return f'<img src="data:image/jpeg;base64,{img_str}" width="{width}" alt="Sample Image">'
+    except Exception as e:
+        logger.warning(f"Failed to encode image {filepath}: {e}")
+        return None
+
+
+def show_interactive_table(df, filepath_col="filepath", image_col="image"):
+    """
+    Display an interactive table with images from filepaths.
+
+    Args:
+        df: pandas DataFrame that contains a 'filepath' column
+    """
+    # Create a copy to avoid modifying the original dataframe
+    interactive_df = df.copy()
+
+    # Add image column by applying get_base64_image to filepath column
+    interactive_df[image_col] = interactive_df[filepath_col].apply(get_base64_image)
+
+    # Convert filepath to clickable link with relative path
+    interactive_df[filepath_col] = interactive_df[filepath_col].apply(
+        lambda x: f'<a href="{x.replace(os.sep, "/")}">{x}</a>'
+    )
+
+    # Reorder columns to show image first
+    cols = interactive_df.columns.tolist()
+    cols.remove(image_col)
+    interactive_df = interactive_df[[image_col] + cols]
+
+    # Display interactive table
+    show(
+        interactive_df,
+        columnDefs=[{"width": "200px", "targets": "_all"}],
+        style="width:1200px",
+        autoWidth=False,
+    )

{active_vision-0.4.1.dist-info → active_vision-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: active-vision
-Version: 0.4.1
+Version: 0.4.3
 Summary: Active learning for computer vision.
 Project-URL: Homepage, https://github.com/dnth/active-vision
 Project-URL: Bug Tracker, https://github.com/dnth/active-vision/issues
@@ -12,6 +12,7 @@ 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: itables>=2.2.4
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: seaborn>=0.13.2
 Requires-Dist: timm>=1.0.13
@@ -59,7 +60,7 @@ Description-Content-Type: text/markdown
     <br />
     <a href="https://dnth.github.io/active-vision" target="_blank" rel="noopener noreferrer"><strong>Explore the docs »</strong></a>
     <br />
-    <a href="#️-quickstart" target="_blank" rel="noopener noreferrer">Quickstart</a>
+    <a href="#-quickstart" target="_blank" rel="noopener noreferrer">Quickstart</a>
     ·
     <a href="https://github.com/dnth/active-vision/issues/new?assignees=&labels=Feature+Request&projects=&template=feature_request.md" target="_blank" rel="noopener noreferrer">Feature Request</a>
     ·
@@ -109,7 +110,12 @@ Get a release from PyPI
 pip install active-vision
 ```
 
-Install from source
+Install bleeding edge from source
+```bash
+pip install git+https://github.com/dnth/active-vision.git
+```
+
+Local install
 ```bash
 git clone https://github.com/dnth/active-vision.git
 cd active-vision
@@ -135,8 +141,8 @@ pip install -e .
 
 ## 🚀 Quickstart
 
-[![Open In Colab][colab_badge]](https://colab.research.google.com/github/dnth/active-vision/blob/main/nbs/imagenette/quickstart.ipynb)
-[![Open In Kaggle][kaggle_badge]](https://kaggle.com/kernels/welcome?src=https://github.com/dnth/active-vision/blob/main/nbs/imagenette/quickstart.ipynb)
+[![Open In Colab][colab_badge]](https://colab.research.google.com/github/dnth/active-vision/blob/main/docs/quickstart.ipynb)
+[![Open In Kaggle][kaggle_badge]](https://kaggle.com/kernels/welcome?src=https://github.com/dnth/active-vision/blob/main/docs/quickstart.ipynb)
 
 The following are code snippets for the active learning loop in active-vision. I recommend running the quickstart notebook in Colab or Kaggle to see the full workflow.
 
@@ -150,7 +156,7 @@ al = ActiveLearner(name="cycle-1")
 al.load_model(model="resnet18", pretrained=True)
 
 # Load dataset 
-al.load_dataset(train_df, filepath_col="filepath", label_col="label", batch_size=8)
+al.load_dataset(train_df, filepath_col="filepath", label_col="label")
 
 # Train model
 al.train(epochs=10, lr=5e-3)
@@ -275,7 +281,34 @@ I decided to stop the active learning loop at 1188 labeled images because the pe
 | 1188            	| 96.57%              	| 13           	| vit-base-patch16-224 	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/eurosat_rgb/02_train.ipynb)     	|
 
 
-## ➿ Workflow
+### Beans
+- num classes: 3
+- num images: 1034
+
+| #Labeled Images 	| Evaluation Accuracy 	| Train Epochs 	| Model                	| Active Learning 	| Source                                                                                     	|
+|----------------:	|--------------------:	|-------------:	|----------------------	|:---------------:	|--------------------------------------------------------------------------------------------	|
+| 380            	| 95.31%              	| 13           	| vit_small_patch16_224      	| ✓               	| [Link](https://github.com/dnth/active-vision/blob/main/nbs/beans/active_learning.ipynb)     	|
+| 1034            | 98.43%               | 13            | vit_small_patch16_224                 | ❌                | [Link](https://github.com/dnth/active-vision/blob/main/nbs/beans/train_all.ipynb)             |
+
+
+## 🧱 Sampling Approaches
+
+Uncertainty and diversity sampling are most effective when combined. Some recommmendations:
+
+- Least Confidence Sampling with Cluster-Based Sampling: This approach first selects a large sample of the most uncertain items using least confidence sampling, and then applies cluster-based sampling to ensure diversity within that selection. This method helps to select data points that are both uncertain and representative of different clusters in the data.
+
+- Uncertainty Sampling with Model-Based Outliers: This strategy combines uncertainty sampling to find items near the decision boundary with model-based outlier detection to identify items with features that are relatively unknown to the current model. This approach aims to maximize the model's current confusion by selecting items that are both uncertain and different from the current training data.
+
+- Uncertainty Sampling with Model-Based Outliers and Clustering: To address the issue of the previous approach potentially oversampling similar items, clustering can be applied after using uncertainty sampling with model-based outliers to ensure diversity.
+
+- Representative Sampling with Cluster-Based Sampling: This method addresses the limitation of basic representative sampling by independently clustering both the training data and the unlabeled data. It then identifies clusters that are most representative of the unlabeled data and oversamples from those clusters. This leads to a more diverse set of items compared to representative sampling alone.
+
+- Sampling from the Highest-Entropy Cluster: This method combines clustering with uncertainty by selecting the cluster with the highest average uncertainty (using entropy). This method aims to sample data points from the cluster that straddles the decision boundary most closely.
+
+- Combining Active Learning Scores: Rather than filtering the output of one sampling strategy with another, this approach combines the scores from different sampling strategies and ranks items based on an aggregate score. This allows for a more nuanced approach to selecting items.
+
+
+## ➿ Workflows
 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.
 
 ### With unlabeled data
@@ -340,22 +373,6 @@ graph TD
 ```
 
 
+## 📚 Acknowledgements
 
-## 🧱 Sampling Approaches
-
-Recommendation 1:
-- 10% randomly selected from unlabeled items.
-- 80% selected from the lowest confidence items.
-- 10% selected as outliers.
-
-Recommendation 2:
-
-- 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.
-
-
-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.
-
+This project is inspired by the book [Human-in-the-Loop Machine Learning by Robert Monarch](https://www.manning.com/books/human-in-the-loop-machine-learning).

active_vision-0.4.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+active_vision/__init__.py,sha256=ztL09ANIuHmKmue2Uaui475201zOvb4sEYHNspIzDEA,43
+active_vision/core.py,sha256=9Qwmrere_ryQKqFKLm0aRp-3drz2yBzHfm6jumjWAto,47765
+active_vision/utils.py,sha256=L2nIUSohqCABqV8qjKNTHmxQoiom2DXMjce5aw2_Tjc,1902
+active_vision-0.4.3.dist-info/METADATA,sha256=JLNqzChj2bhefMu9a4HSrimzImsYm1ePuJhJbTNUWe8,19798
+active_vision-0.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+active_vision-0.4.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+active_vision-0.4.3.dist-info/RECORD,,

active_vision-0.4.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-active_vision/__init__.py,sha256=vauWDAlrr6fiIylIKSzErXOEopRtTsBk8G4hC9418M0,43
-active_vision/core.py,sha256=ZDRylM3KsoLxy9qA9bld4WxzcKcyCwH8IJ1cFxtz5mE,41607
-active_vision-0.4.1.dist-info/METADATA,sha256=LpgLc_E7jJVXxUHrIPv-1RZq_CEE3enyb0O2PDZMrJM,17262
-active_vision-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-active_vision-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-active_vision-0.4.1.dist-info/RECORD,,