labelr 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

labelr/annotate.py

@@ -4,17 +4,17 @@ import string
 from openfoodfacts.utils import get_logger
 
 try:
+    from openfoodfacts.ml.object_detection import ObjectDetectionRawResult
     from ultralytics.engine.results import Results
 except ImportError:
     pass
 
-from labelr.triton.object_detection import ObjectDetectionResult
 
 logger = get_logger(__name__)
 
 
 def format_annotation_results_from_triton(
-    objects: list[ObjectDetectionResult], image_width: int, image_height: int
+    objects: list["ObjectDetectionRawResult"], image_width: int, image_height: int
 ):
     """Format annotation results from a Triton object detection model into
     Label Studio format."""

labelr/main.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Optional
+from typing import Annotated
 
 import typer
 from openfoodfacts.utils import get_logger
@@ -6,7 +6,6 @@ from openfoodfacts.utils import get_logger
 from labelr.apps import datasets as dataset_app
 from labelr.apps import projects as project_app
 from labelr.apps import users as user_app
-from labelr.config import LABEL_STUDIO_DEFAULT_URL
 
 app = typer.Typer(pretty_exceptions_show_locals=False)
 
@@ -14,243 +13,48 @@ logger = get_logger()
 
 
 @app.command()
-def predict_object(
+def predict(
     model_name: Annotated[
         str, typer.Option(help="Name of the object detection model to run")
     ],
+    label_names: Annotated[list[str], typer.Argument(help="List of label names")],
     image_url: Annotated[str, typer.Option(help="URL of the image to process")],
     triton_uri: Annotated[
         str, typer.Option(help="URI (host+port) of the Triton Inference Server")
     ],
-    threshold: float = 0.5,
-):
-    from openfoodfacts.utils import get_image_from_url
-
-    from labelr.triton.object_detection import ObjectDetectionModelRegistry
-
-    model = ObjectDetectionModelRegistry.get(model_name)
-    image = get_image_from_url(image_url)
-    output = model.detect_from_image(image, triton_uri=triton_uri)
-    results = output.select(threshold=threshold)
-
-    for result in results:
-        typer.echo(result)
-
-
-# Temporary scripts
-
-
-@app.command()
-def skip_rotated_images(
-    api_key: Annotated[str, typer.Option(envvar="LABEL_STUDIO_API_KEY")],
-    project_id: Annotated[int, typer.Option(help="Label Studio project ID")],
-    updated_by: Annotated[
-        Optional[int], typer.Option(help="User ID to declare as annotator")
-    ] = None,
-    label_studio_url: str = LABEL_STUDIO_DEFAULT_URL,
-):
-    import requests
-    import tqdm
-    from label_studio_sdk.client import LabelStudio
-    from label_studio_sdk.types.task import Task
-    from openfoodfacts.ocr import OCRResult
-
-    session = requests.Session()
-    ls = LabelStudio(base_url=label_studio_url, api_key=api_key)
-
-    task: Task
-    for task in tqdm.tqdm(
-        ls.tasks.list(project=project_id, fields="all"), desc="tasks"
-    ):
-        if any(annotation["was_cancelled"] for annotation in task.annotations):
-            continue
-
-        assert task.total_annotations == 1, (
-            "Task has multiple annotations (%s)" % task.id
-        )
-        task_id = task.id
-
-        annotation = task.annotations[0]
-        annotation_id = annotation["id"]
-
-        ocr_url = task.data["image_url"].replace(".jpg", ".json")
-        ocr_result = OCRResult.from_url(ocr_url, session=session, error_raise=False)
-
-        if ocr_result is None:
-            logger.warning("No OCR result for task: %s", task_id)
-            continue
-
-        orientation_result = ocr_result.get_orientation()
-
-        if orientation_result is None:
-            # logger.info("No orientation for task: %s", task_id)
-            continue
-
-        orientation = orientation_result.orientation.name
-        if orientation != "up":
-            logger.info(
-                "Skipping rotated image for task: %s (orientation: %s)",
-                task_id,
-                orientation,
-            )
-            ls.annotations.update(
-                id=annotation_id,
-                was_cancelled=True,
-                updated_by=updated_by,
-            )
-        elif orientation == "up":
-            logger.debug("Keeping annotation for task: %s", task_id)
-
-
-@app.command()
-def fix_label(
-    api_key: Annotated[str, typer.Option(envvar="LABEL_STUDIO_API_KEY")],
-    project_id: Annotated[int, typer.Option(help="Label Studio project ID")],
-    label_studio_url: str = LABEL_STUDIO_DEFAULT_URL,
-):
-    import tqdm
-    from label_studio_sdk.client import LabelStudio
-    from label_studio_sdk.types.task import Task
-
-    ls = LabelStudio(base_url=label_studio_url, api_key=api_key)
-
-    task: Task
-    for task in tqdm.tqdm(
-        ls.tasks.list(project=project_id, fields="all"), desc="tasks"
-    ):
-        for prediction in task.predictions:
-            updated = False
-            if "result" in prediction:
-                for result in prediction["result"]:
-                    value = result["value"]
-                    if "rectanglelabels" in value and value["rectanglelabels"] != [
-                        "price-tag"
-                    ]:
-                        value["rectanglelabels"] = ["price-tag"]
-                        updated = True
-
-            if updated:
-                print(f"Updating prediction {prediction['id']}, task {task.id}")
-                ls.predictions.update(prediction["id"], result=prediction["result"])
-
-        for annotation in task.annotations:
-            updated = False
-            if "result" in annotation:
-                for result in annotation["result"]:
-                    value = result["value"]
-                    if "rectanglelabels" in value and value["rectanglelabels"] != [
-                        "price-tag"
-                    ]:
-                        value["rectanglelabels"] = ["price-tag"]
-                        updated = True
-
-            if updated:
-                print(f"Updating annotation {annotation['id']}, task {task.id}")
-                ls.annotations.update(annotation["id"], result=annotation["result"])
-
-
-@app.command()
-def select_price_tag_images(
-    api_key: Annotated[str, typer.Option(envvar="LABEL_STUDIO_API_KEY")],
-    project_id: Annotated[int, typer.Option(help="Label Studio project ID")],
-    label_studio_url: str = LABEL_STUDIO_DEFAULT_URL,
-):
-    import typing
-    from pathlib import Path
-    from typing import Any
-    from urllib.parse import urlparse
-
-    import requests
-    import tqdm
-    from label_studio_sdk.client import LabelStudio
-    from label_studio_sdk.types.task import Task
-
-    session = requests.Session()
-    ls = LabelStudio(base_url=label_studio_url, api_key=api_key)
-
-    proof_paths = (Path(__file__).parent / "proof.txt").read_text().splitlines()
-    task: Task
-    for task in tqdm.tqdm(
-        ls.tasks.list(project=project_id, include="data,id"), desc="tasks"
-    ):
-        data = typing.cast(dict[str, Any], task.data)
-
-        if "is_raw_product_shelf" in data:
-            continue
-        image_url = data["image_url"]
-        file_path = urlparse(image_url).path.replace("/img/", "")
-        r = session.get(
-            f"https://robotoff.openfoodfacts.org/api/v1/images/predict?image_url={image_url}&models=price_proof_classification",
-        )
-
-        if r.status_code != 200:
-            print(
-                f"Failed to get prediction for {image_url}, error: {r.text} (status: {r.status_code})"
-            )
-            continue
-
-        prediction = r.json()["predictions"]["price_proof_classification"][0]["label"]
-
-        is_raw_preduct_shelf = False
-        if prediction in ("PRICE_TAG", "SHELF"):
-            is_raw_preduct_shelf = file_path in proof_paths
-
-        ls.tasks.update(
-            task.id,
-            data={
-                **data,
-                "is_raw_product_shelf": "true" if is_raw_preduct_shelf else "false",
-            },
-        )
-
-
-@app.command()
-def add_predicted_category(
-    api_key: Annotated[str, typer.Option(envvar="LABEL_STUDIO_API_KEY")],
-    project_id: Annotated[int, typer.Option(help="Label Studio project ID")],
-    label_studio_url: str = LABEL_STUDIO_DEFAULT_URL,
+    image_size: Annotated[
+        int, typer.Option(help="Size of the image the model expects")
+    ] = 640,
+    threshold: Annotated[float, typer.Option(help="Detection threshold")] = 0.5,
+    triton_model_version: str = "1",
 ):
+    """Predict objects in an image using an object detection model served by
+    Triton."""
     import typing
-    from typing import Any
-
-    import requests
-    import tqdm
-    from label_studio_sdk.client import LabelStudio
-    from label_studio_sdk.types.task import Task
-
-    session = requests.Session()
-    ls = LabelStudio(base_url=label_studio_url, api_key=api_key)
 
-    task: Task
-    for task in tqdm.tqdm(
-        ls.tasks.list(project=project_id, include="data,id"), desc="tasks"
-    ):
-        data = typing.cast(dict[str, Any], task.data)
+    from openfoodfacts.ml.object_detection import ObjectDetector
+    from openfoodfacts.utils import get_image_from_url
+    from PIL import Image
 
-        if "predicted_category" in data:
-            continue
-        image_url = data["image_url"]
-        r = session.get(
-            f"https://robotoff.openfoodfacts.org/api/v1/images/predict?image_url={image_url}&models=price_proof_classification",
-        )
+    model = ObjectDetector(
+        model_name=model_name, label_names=label_names, image_size=image_size
+    )
+    image = typing.cast(Image.Image | None, get_image_from_url(image_url))
 
-        if r.status_code != 200:
-            print(
-                f"Failed to get prediction for {image_url}, error: {r.text} (status: {r.status_code})"
-            )
-            continue
+    if image is None:
+        logger.error("Failed to download image from URL: %s", image_url)
+        raise typer.Abort()
 
-        predicted_category = r.json()["predictions"]["price_proof_classification"][0][
-            "label"
-        ]
+    output = model.detect_from_image(
+        image,
+        triton_uri=triton_uri,
+        model_version=triton_model_version,
+        threshold=threshold,
+    )
+    results = output.to_list()
 
-        ls.tasks.update(
-            task.id,
-            data={
-                **data,
-                "predicted_category": predicted_category,
-            },
-        )
+    for result in results:
+        typer.echo(result)
 
 
 app.add_typer(user_app.app, name="users", help="Manage Label Studio users")

{labelr-0.1.0.dist-info → labelr-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labelr
-Version: 0.1.0
+Version: 0.2.0
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -16,6 +16,7 @@ Provides-Extra: ultralytics
 Requires-Dist: ultralytics>=8.3.49; extra == "ultralytics"
 Provides-Extra: triton
 Requires-Dist: tritonclient>=2.52.0; extra == "triton"
+Requires-Dist: openfoodfacts[ml]>=2.3.4; extra == "triton"
 
 # Labelr
 
@@ -36,50 +37,22 @@ It currently allows to:
 ## Installation
 
 Python 3.10 or higher is required to run this CLI.
-You need to install the CLI manually for now, there is no project published on Pypi.
-To do so:
 
-We recommend to install the CLI in a virtual environment. You can either use pip or conda for that.
-
-### Pip
-
-Create the virtualenv:
+To install the CLI, simply run:
 
 ```bash
-python3 -m venv labelr
-source labelr/bin/activate
-```
-### Conda
-
-With conda:
-```bash
-conda create -n labelr python=3.12
-conda activate labelr
-```
-
-Then, clone the repository and install the requirements:
-
-```bash
-git clone git@github.com:openfoodfacts/openfoodfacts-ai.git
-```
-
-```bash
-pip install -r requirements.txt
+pip install labelr
 ```
+We recommend to install the CLI in a virtual environment. You can either use pip or conda for that.
 
-We assume in the following that you have installed the CLI in a virtual environment, and defined the following alias in your shell configuration file (e.g. `.bashrc` or `.zshrc`):
+There are two optional dependencies that you can install to use the CLI:
+- `ultralytics`: pre-annotate object detection datasets with an ultralytics model (yolo, yolo-world)
+- `triton`: pre-annotate object detection datasets using a model served by a Triton inference server
 
-```bash
-alias labelr='${VIRTUALENV_DIR}/bin/python3 ${PROJECT_PATH}/main.py'
-```
-or if you are using conda:
-```bash
-alias labelr='${CONDA_PREFIX}/bin/python3 ${PROJECT_PATH}/main.py'
-``` 
+To install the optional dependencies, you can run:
 
-with `${VIRTUALENV_DIR}` the path to the virtual environment where you installed the CLI and `${PROJECT_PATH}` the path to the root of the project, for example:
 ```bash
-${PROJECT_PATH} = /home/user/openfoodfacts-ai/ml_utils/ml_utils_cli
+pip install labelr[ultralytics,triton]
 ```
 
 ## Usage

{labelr-0.1.0.dist-info → labelr-0.2.0.dist-info}/RECORD

@@ -1,20 +1,19 @@
 labelr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 labelr/__main__.py,sha256=G4e95-IfhI-lOmkOBP6kQ8wl1x_Fl7dZlLOYr90K83c,66
-labelr/annotate.py,sha256=8O9SO2thevo_Aa6etIUxCz2xJVXB4MwuSHj4jxz8sqQ,3441
+labelr/annotate.py,sha256=aphaxyGvKVTjB4DQvj00HpX-X8Xz70UHoKSf4QFWaO4,3456
 labelr/check.py,sha256=3wK6mE0UsKvoBNm0_lyWhCMq7gxkv5r50pvO70damXY,2476
 labelr/config.py,sha256=3RXF_NdkSuHvfVMGMlYmjlw45fU77zQkLX7gmZq7NxM,64
 labelr/export.py,sha256=tcOmVnOdJidWfNouNWoQ4OJgHMbbG-bLFHkId9huiS0,10170
-labelr/main.py,sha256=1_cZoJLBMpUV-lnaKb1XaVff4XxWjpIUZbSNQh44tPE,8715
+labelr/main.py,sha256=gQ8I287mpLy3HIUWqZUyoLAfPwkphwOIzut7hEbH8tY,2135
 labelr/sample.py,sha256=cpzvgZWVU6GzwD35tqGKEFVKAgqQbSHlWW6IL9FG15Q,5918
 labelr/types.py,sha256=CahqnkLnGj23Jg0X9nftK7Jiorq50WYQqR8u9Ln4E-k,281
 labelr/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 labelr/apps/datasets.py,sha256=DXU8XZx0iEHDI5SvUeI8atCKSUmj9YJwO6xTgMZDgEI,7936
 labelr/apps/projects.py,sha256=HpulSciBVTk1sSR1uXjtHytny9t-rN8wiaQ5llNBX6Y,12420
 labelr/apps/users.py,sha256=twQSlpHxE0hrYkgrJpEFbK8lYfWnpJr8vyfLHLtdAUU,909
-labelr/triton/object_detection.py,sha256=QKUOWiYFH72omyZH4SdbA56JDiVA_e_N8YCSQarkzWQ,7409
-labelr-0.1.0.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-labelr-0.1.0.dist-info/METADATA,sha256=tBsu8c-LehNqjPNiCG3XjRLboQNeq2RSy9JZiv4v9Dc,6528
-labelr-0.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-labelr-0.1.0.dist-info/entry_points.txt,sha256=OACukVeR_2z54i8yQuWqqk_jdEHlyTwmTFOFBmxPp1k,43
-labelr-0.1.0.dist-info/top_level.txt,sha256=bjZo50aGZhXIcZYpYOX4sdAQcamxh8nwfEh7A9RD_Ag,7
-labelr-0.1.0.dist-info/RECORD,,
+labelr-0.2.0.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+labelr-0.2.0.dist-info/METADATA,sha256=nxbEiMBsVEQS71pzZ39uLL_GCVebIB71wyxvFsueGcU,5960
+labelr-0.2.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+labelr-0.2.0.dist-info/entry_points.txt,sha256=OACukVeR_2z54i8yQuWqqk_jdEHlyTwmTFOFBmxPp1k,43
+labelr-0.2.0.dist-info/top_level.txt,sha256=bjZo50aGZhXIcZYpYOX4sdAQcamxh8nwfEh7A9RD_Ag,7
+labelr-0.2.0.dist-info/RECORD,,

labelr/triton/object_detection.py

@@ -1,241 +0,0 @@
-import dataclasses
-import functools
-import logging
-import time
-from typing import Any, Optional
-
-import numpy as np
-from PIL import Image
-
-try:
-    import grpc
-    from tritonclient.grpc import service_pb2, service_pb2_grpc
-    from tritonclient.grpc.service_pb2_grpc import GRPCInferenceServiceStub
-except ImportError:
-    pass
-
-logger = logging.getLogger(__name__)
-
-
-JSONType = dict[str, Any]
-
-OBJECT_DETECTION_MODEL_VERSION = {
-    "nutriscore": "tf-nutriscore-1.0",
-    "nutrition_table": "tf-nutrition-table-1.0",
-    "universal_logo_detector": "tf-universal-logo-detector-1.0",
-}
-
-LABELS = {
-    "nutriscore": [
-        "NULL",
-        "nutriscore-a",
-        "nutriscore-b",
-        "nutriscore-c",
-        "nutriscore-d",
-        "nutriscore-e",
-    ],
-}
-
-OBJECT_DETECTION_IMAGE_MAX_SIZE = (1024, 1024)
-
-
-@functools.cache
-def get_triton_inference_stub(
-    triton_uri: str,
-) -> "GRPCInferenceServiceStub":
-    """Return a gRPC stub for Triton Inference Server.
-
-    :param triton_uri: URI of the Triton Inference Server
-    :return: gRPC stub for Triton Inference Server
-    """
-    triton_uri = triton_uri
-    channel = grpc.insecure_channel(triton_uri)
-    return service_pb2_grpc.GRPCInferenceServiceStub(channel)
-
-
-def convert_image_to_array(image: Image.Image) -> np.ndarray:
-    """Convert a PIL Image into a numpy array.
-
-    The image is converted to RGB if needed before generating the array.
-
-    :param image: the input image
-    :return: the generated numpy array of shape (width, height, 3)
-    """
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-
-    (im_width, im_height) = image.size
-
-    return np.array(image.getdata()).reshape((im_height, im_width, 3)).astype(np.uint8)
-
-
-@dataclasses.dataclass
-class ObjectDetectionResult:
-    bounding_box: tuple[int, int, int, int]
-    score: float
-    label: str
-
-
-@dataclasses.dataclass
-class ObjectDetectionRawResult:
-    num_detections: int
-    detection_boxes: np.ndarray
-    detection_scores: np.ndarray
-    detection_classes: np.ndarray
-    label_names: list[str]
-    detection_masks: Optional[np.ndarray] = None
-    boxed_image: Optional[Image.Image] = None
-
-    def select(self, threshold: Optional[float] = None) -> list[ObjectDetectionResult]:
-        if threshold is None:
-            threshold = 0.5
-
-        box_masks = self.detection_scores > threshold
-        selected_boxes = self.detection_boxes[box_masks]
-        selected_scores = self.detection_scores[box_masks]
-        selected_classes = self.detection_classes[box_masks]
-
-        results = []
-        for bounding_box, score, label in zip(
-            selected_boxes, selected_scores, selected_classes
-        ):
-            label_int = int(label)
-            label_str = self.label_names[label_int]
-            if label_str is not None:
-                result = ObjectDetectionResult(
-                    bounding_box=tuple(bounding_box.tolist()),  # type: ignore
-                    score=float(score),
-                    label=label_str,
-                )
-                results.append(result)
-
-        return results
-
-    def to_json(self, threshold: Optional[float] = None) -> list[JSONType]:
-        return [dataclasses.asdict(r) for r in self.select(threshold)]
-
-
-def resize_image(image: Image.Image, max_size: tuple[int, int]) -> Image.Image:
-    width, height = image.size
-    max_width, max_height = max_size
-
-    if width > max_width or height > max_height:
-        new_image = image.copy()
-        new_image.thumbnail((max_width, max_height))
-        return new_image
-
-    return image
-
-
-class RemoteModel:
-    def __init__(self, name: str, label_names: list[str]):
-        self.name: str = name
-        self.label_names = label_names
-
-    def detect_from_image(
-        self,
-        image: Image.Image,
-        triton_uri: str,
-    ) -> ObjectDetectionRawResult:
-        """Run object detection model on an image.
-
-        :param image: the input Pillow image
-        :param triton_uri: URI of the Triton Inference Server.
-        :return: the detection result
-        """
-        resized_image = resize_image(image, OBJECT_DETECTION_IMAGE_MAX_SIZE)
-        image_array = convert_image_to_array(resized_image)
-        grpc_stub = get_triton_inference_stub(triton_uri)
-        request = service_pb2.ModelInferRequest()
-        request.model_name = self.name
-
-        image_input = service_pb2.ModelInferRequest().InferInputTensor()
-        image_input.name = "inputs"
-        image_input.datatype = "UINT8"
-        image_input.shape.extend([1, image_array.shape[0], image_array.shape[1], 3])
-        request.inputs.extend([image_input])
-
-        for output_name in (
-            "num_detections",
-            "detection_classes",
-            "detection_scores",
-            "detection_boxes",
-        ):
-            output = service_pb2.ModelInferRequest().InferRequestedOutputTensor()
-            output.name = output_name
-            request.outputs.extend([output])
-
-        request.raw_input_contents.extend([image_array.tobytes()])
-        start_time = time.monotonic()
-        response = grpc_stub.ModelInfer(request)
-        logger.debug(
-            "Inference time for %s: %s", self.name, time.monotonic() - start_time
-        )
-
-        if len(response.outputs) != 4:
-            raise Exception(f"expected 4 output, got {len(response.outputs)}")
-
-        if len(response.raw_output_contents) != 4:
-            raise Exception(
-                f"expected 4 raw output content, got {len(response.raw_output_contents)}"
-            )
-
-        output_index = {output.name: i for i, output in enumerate(response.outputs)}
-        num_detections = (
-            np.frombuffer(
-                response.raw_output_contents[output_index["num_detections"]],
-                dtype=np.float32,
-            )
-            .reshape((1, 1))
-            .astype(int)[0][0]  # type: ignore
-        )
-        detection_scores = np.frombuffer(
-            response.raw_output_contents[output_index["detection_scores"]],
-            dtype=np.float32,
-        ).reshape((1, -1))[0]
-        detection_classes = (
-            np.frombuffer(
-                response.raw_output_contents[output_index["detection_classes"]],
-                dtype=np.float32,
-            )
-            .reshape((1, -1))
-            .astype(int)  # type: ignore
-        )[0]
-        detection_boxes = np.frombuffer(
-            response.raw_output_contents[output_index["detection_boxes"]],
-            dtype=np.float32,
-        ).reshape((1, -1, 4))[0]
-
-        result = ObjectDetectionRawResult(
-            num_detections=num_detections,
-            detection_classes=detection_classes,
-            detection_boxes=detection_boxes,
-            detection_scores=detection_scores,
-            detection_masks=None,
-            label_names=self.label_names,
-        )
-
-        return result
-
-
-class ObjectDetectionModelRegistry:
-    models: dict[str, RemoteModel] = {}
-    _loaded = False
-
-    @classmethod
-    def get_available_models(cls) -> list[str]:
-        cls.load_all()
-        return list(cls.models.keys())
-
-    @classmethod
-    def load(cls, name: str) -> RemoteModel:
-        label_names = LABELS[name]
-        model = RemoteModel(name, label_names)
-        cls.models[name] = model
-        return model
-
-    @classmethod
-    def get(cls, name: str) -> RemoteModel:
-        if name not in cls.models:
-            cls.load(name)
-        return cls.models[name]