Upload 11 files

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
+wbc_classifier/best_model_checkpoint.pth filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Katakam Prashanth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1 @@
----
-title: SmartCBC
-emoji: 🔥
-colorFrom: gray
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.0.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SmartCBC-Multimodal-Pipeline

app.py

@@ -0,0 +1,132 @@
+# app.py
+
+import gradio as gr
+from PIL import Image
+
+from pipeline import SmartCBC
+
+# -------------------------------------------------
+# Initialize pipeline ONCE (cached in Spaces)
+# -------------------------------------------------
+cbc = SmartCBC()   # loads YOLO + classifier once
+
+
+# -------------------------------------------------
+# Core Gradio wrapper
+# -------------------------------------------------
+def analyze_images(images, age, gender, output_mode):
+    """
+    Wrapper for SmartCBC.analyze() or SmartCBC.analyze_batch()
+    depending on whether 1 or multiple images are uploaded.
+    """
+    if images is None or len(images) == 0:
+        return "Please upload at least one image.", None
+
+    # Gradio Gallery sometimes returns list of tuples: (PIL.Image, metadata)
+    def to_pil_list(img_list):
+        pil_list = []
+        for item in img_list:
+            if isinstance(item, tuple):
+                # assume first element is the PIL image
+                pil = item[0]
+            else:
+                pil = item
+            pil_list.append(pil)
+        return pil_list
+
+    pil_images = to_pil_list(images)
+
+    # If 1 image → single-FOV path
+    if len(pil_images) == 1:
+        result = cbc.analyze(
+            image=pil_images[0],
+            age=age,
+            gender=gender
+        )
+    else:
+        # Multiple images → multi-FOV aggregation
+        result = cbc.analyze(
+            image=pil_images,   # list → analyze_batch under the hood
+            age=age,
+            gender=gender
+        )
+
+    if output_mode == "Text Report":
+        return result["report_text"], None
+    else:
+        return None, result
+
+
+# -------------------------------------------------
+# Gradio UI Layout
+# -------------------------------------------------
+with gr.Blocks(title="SmartCBC - Multimodal Blood Analysis") as demo:
+
+    gr.Markdown("""
+    # 🩸 SmartCBC — Multimodal AI Blood Smear Analysis  
+    Upload **one or multiple** peripheral smear FOV images and get:  
+    - RBC / WBC / Platelet counts  
+    - WBC subtype classification  
+    - Aggregated multi-FOV differential  
+    - Age-specific reference comparisons  
+    - Clinical insights (non-diagnostic)  
+    """)
+
+    with gr.Row():
+        img_in = gr.Gallery(
+            label="Upload 1 or Multiple Blood Smear Images (FOVs)",
+            columns=3,
+            height="auto",
+            allow_preview=True,
+            type="pil"
+        )
+
+        with gr.Column():
+            age_in = gr.Number(label="Age (years)", value=30)
+            gender_in = gr.Dropdown(
+                ["M", "F", ""],
+                label="Gender (optional)",
+                value=""
+            )
+            output_mode = gr.Radio(
+                ["Text Report", "Structured JSON"],
+                value="Text Report",
+                label="Output Format"
+            )
+            btn = gr.Button("Analyze")
+
+    # OUTPUT AREAS
+    txt_out = gr.Textbox(
+        label="Report (Human Readable)",
+        visible=True,
+        lines=30,
+        interactive=False
+    )
+
+    json_out = gr.JSON(
+        label="Structured Output (JSON)",
+        visible=False
+    )
+
+    # Toggle visibility
+    def toggle_output(mode):
+        return (
+            gr.update(visible=(mode == "Text Report")),
+            gr.update(visible=(mode == "Structured JSON"))
+        )
+
+    output_mode.change(toggle_output, [output_mode], [txt_out, json_out])
+
+    # Button Binding
+    btn.click(
+        analyze_images,
+        inputs=[img_in, age_in, gender_in, output_mode],
+        outputs=[txt_out, json_out]
+    )
+
+
+# -------------------------------------------------
+# HF Spaces entrypoint
+# -------------------------------------------------
+if __name__ == "__main__":
+    demo.launch()

pipeline.py

@@ -0,0 +1,292 @@
+# pipeline.py
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence, List
+
+import numpy as np
+import torch
+from PIL import Image
+
+from utils.detector import load_detector, run_detector
+from utils.classifier import load_wbc_classifier, classify_wbc_crop
+from utils.analysis import CLASS_NAMES, map_age_to_group, pick_gender_for_group
+from utils.report import build_api_response
+
+# -------------------------------------------------
+# PATHS & DEVICE
+# -------------------------------------------------
+REPO_ROOT = Path(__file__).resolve().parent
+
+DETECTOR_WEIGHTS = REPO_ROOT / "yolov8_detector" / "best.pt"
+CLASSIFIER_WEIGHTS = REPO_ROOT / "wbc_classifier" / "best_model_checkpoint.pth"
+REF_CSV = REPO_ROOT / "data" / "WBC differential references.csv"
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+class SmartCBC:
+    """
+    Main SmartCBC pipeline orchestrator.
+
+    Usage (single FOV):
+
+        from pipeline import SmartCBC
+        cbc = SmartCBC()
+        result = cbc.analyze(image, age=32, gender="M")
+
+    Usage (multiple FOVs):
+
+        result = cbc.analyze_batch([img1, img2, img3], age=32, gender="M")
+
+    You can also pass a list directly to `analyze()` and it will auto-route:
+
+        result = cbc.analyze([img1, img2, img3], age=32, gender="M")
+
+    `result` is a dict ready for API / UI usage:
+        - patient_id
+        - timestamp
+        - fovs_analyzed
+        - coarse_counts         (RBC/WBC/Platelet)
+        - wbc_subtypes          (raw counts per subtype)
+        - wbc_percentages       (percent per subtype)
+        - report_text           (plain text report)
+        - calibration           (placeholders for now)
+    """
+
+    def __init__(
+        self,
+        detector_weights: Optional[str | Path] = None,
+        classifier_weights: Optional[str | Path] = None,
+        ref_csv: Optional[str | Path] = None,
+        conf_thres: float = 0.25,
+        imgsz: int = 512,
+    ) -> None:
+        self.detector_weights = str(detector_weights or DETECTOR_WEIGHTS)
+        self.classifier_weights = str(classifier_weights or CLASSIFIER_WEIGHTS)
+        self.ref_csv = str(ref_csv or REF_CSV)
+
+        self.conf_thres = conf_thres
+        self.imgsz = imgsz
+        self.device = DEVICE
+
+        # Load models once
+        self.detector = load_detector(self.detector_weights)
+        self.classifier = load_wbc_classifier(self.classifier_weights)
+
+    # -------------------------------------------------
+    # PUBLIC ENTRYPOINT (single OR multi)
+    # -------------------------------------------------
+    def analyze(
+        self,
+        image: Any | Sequence[Any],
+        age: Optional[float] = None,
+        gender: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run SmartCBC analysis.
+
+        If `image` is:
+          - a single image (PIL / np.ndarray / path) -> analyze one FOV
+          - a list/tuple of images                      -> aggregate over multiple FOVs
+        """
+
+        # If multiple FOVs are provided, delegate to analyze_batch()
+        if isinstance(image, (list, tuple)):
+            return self.analyze_batch(list(image), age=age, gender=gender)
+
+        # Single-image path (current behavior)
+        pil_img = self._ensure_pil(image)
+
+        age_years, age_group, gender = self._resolve_age_gender(age, gender)
+
+        coarse_counts, subtype_counts = self._run_models_on_image(pil_img)
+
+        ai_result = {
+            "patient_id": f"PAT-{uuid.uuid4().hex[:8].upper()}",
+            "timestamp": datetime.now().isoformat(timespec="seconds"),
+            "fovs_analyzed": 1,
+            "coarse_counts": coarse_counts,
+            "wbc_subtypes": subtype_counts,
+            "calibration": {
+                "fov_area_mm2": None,
+                "calibration_constant": None,
+            },
+        }
+
+        response = build_api_response(
+            ai_result=ai_result,
+            age_group=age_group,
+            gender=gender,
+            reference_csv=self.ref_csv,
+            overlay_image=None,
+        )
+
+        response["age_years"] = age_years
+        response["age_group"] = age_group
+        response["gender"] = gender
+
+        return response
+
+    # -------------------------------------------------
+    # NEW: MULTI-FOV ANALYSIS
+    # -------------------------------------------------
+    def analyze_batch(
+        self,
+        images: Sequence[Any],
+        age: Optional[float] = None,
+        gender: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run SmartCBC analysis over MULTIPLE FOV images.
+
+        Parameters
+        ----------
+        images : list/tuple of PIL / np.ndarray / path
+        age    : float (years), optional
+        gender : "M" | "F", optional
+
+        Returns
+        -------
+        Aggregated result dict:
+            - fovs_analyzed = len(images)
+            - coarse_counts (sum over all FOVs)
+            - wbc_subtypes (sum over all FOVs)
+            - wbc_percentages, report_text, etc.
+        """
+
+        if not images:
+            raise ValueError("analyze_batch() received an empty images list.")
+
+        age_years, age_group, gender = self._resolve_age_gender(age, gender)
+
+        # Initialize aggregate counts
+        agg_coarse: Dict[str, int] = {"WBC": 0, "RBC": 0, "Platelet": 0}
+        agg_subtypes: Dict[str, int] = {name: 0 for name in CLASS_NAMES}
+
+        fov_count = 0
+
+        for img in images:
+            pil_img = self._ensure_pil(img)
+            coarse_counts, subtype_counts = self._run_models_on_image(pil_img)
+
+            # Aggregate coarse counts
+            for k, v in coarse_counts.items():
+                agg_coarse[k] = agg_coarse.get(k, 0) + v
+
+            # Aggregate subtype counts
+            for k, v in subtype_counts.items():
+                agg_subtypes[k] = agg_subtypes.get(k, 0) + v
+
+            fov_count += 1
+
+        ai_result = {
+            "patient_id": f"PAT-{uuid.uuid4().hex[:8].upper()}",
+            "timestamp": datetime.now().isoformat(timespec="seconds"),
+            "fovs_analyzed": fov_count,
+            "coarse_counts": agg_coarse,
+            "wbc_subtypes": agg_subtypes,
+            "calibration": {
+                "fov_area_mm2": None,
+                "calibration_constant": None,
+            },
+        }
+
+        response = build_api_response(
+            ai_result=ai_result,
+            age_group=age_group,
+            gender=gender,
+            reference_csv=self.ref_csv,
+            overlay_image=None,
+        )
+
+        response["age_years"] = age_years
+        response["age_group"] = age_group
+        response["gender"] = gender
+
+        return response
+
+    # -------------------------------------------------
+    # INTERNAL HELPERS
+    # -------------------------------------------------
+    def _resolve_age_gender(
+        self,
+        age: Optional[float],
+        gender: Optional[str],
+    ) -> tuple[float, str, Optional[str]]:
+        """
+        Compute age_years, age_group, gender with defaults and CSV-based inference.
+        """
+        age_years = float(age) if age is not None else 30.0
+        age_group = map_age_to_group(age_years)
+
+        if gender is None or str(gender).strip() == "":
+            gender = pick_gender_for_group(age_group, csv_path=self.ref_csv)
+        gender = None if gender is None else str(gender).upper()
+
+        return age_years, age_group, gender
+
+    def _ensure_pil(self, image: Any) -> Image.Image:
+        """
+        Convert various input types to a PIL.Image in RGB mode.
+        """
+        if isinstance(image, Image.Image):
+            return image.convert("RGB")
+        if isinstance(image, np.ndarray):
+            if image.ndim == 2:
+                image = np.stack([image] * 3, axis=-1)
+            return Image.fromarray(image).convert("RGB")
+        if isinstance(image, (str, Path)):
+            return Image.open(image).convert("RGB")
+        raise TypeError(f"Unsupported image type: {type(image)}")
+
+    def _run_models_on_image(
+        self,
+        img: Image.Image,
+    ) -> tuple[Dict[str, int], Dict[str, int]]:
+        """
+        Run YOLO detector + WBC classifier on a single image.
+
+        Returns
+        -------
+        coarse_counts : {"WBC": int, "RBC": int, "Platelet": int}
+        subtype_counts: {subtype_name: int}
+        """
+        coarse_counts: Dict[str, int] = {"WBC": 0, "RBC": 0, "Platelet": 0}
+        subtype_counts: Dict[str, int] = {name: 0 for name in CLASS_NAMES}
+
+        detections = run_detector(
+            model=self.detector,
+            image=img,
+            imgsz=self.imgsz,
+            conf_thres=self.conf_thres,
+        )
+
+        w, h = img.size
+
+        for det in detections:
+            x1, y1, x2, y2 = det["box"]
+            label = det["label"]  # "RBC", "WBC", "Platelet"
+
+            x1 = max(int(x1), 0)
+            y1 = max(int(y1), 0)
+            x2 = min(int(x2), w)
+            y2 = min(int(y2), h)
+
+            if label in coarse_counts:
+                coarse_counts[label] += 1
+            else:
+                coarse_counts[label] = 1
+
+            if label == "WBC" and x2 > x1 and y2 > y1:
+                crop = img.crop((x1, y1, x2, y2))
+                subtype = classify_wbc_crop(self.classifier, crop)
+                if subtype in subtype_counts:
+                    subtype_counts[subtype] += 1
+                else:
+                    subtype_counts[subtype] = 1
+
+        return coarse_counts, subtype_counts

requirements.txt

@@ -0,0 +1,6 @@
+torch
+torchvision
+ultralytics
+gradio
+pandas
+Pillow

test_pipeline.py

@@ -0,0 +1,48 @@
+# test_pipeline.py
+
+from pathlib import Path
+from PIL import Image
+
+from pipeline import SmartCBC
+
+def main():
+    # 1) Initialize pipeline (loads YOLO + classifier)
+    cbc = SmartCBC()
+
+    # 2) Pick a sample FOV image (from your TXL-PBC test set)
+    test_dir = Path("/home/enma/Projects/blood_analyzer/TXL-PBC_Dataset/TXL-PBC/images/test")
+    image_paths = list(test_dir.glob("*.*"))
+
+    if not image_paths:
+        print(f"No images found in {test_dir}")
+        return
+
+    sample_path = image_paths[0]
+    print(f"Using sample image: {sample_path}")
+
+    img = Image.open(sample_path).convert("RGB")
+
+    # 3) Run analysis
+    result = cbc.analyze(
+        image=img,
+        age=32,        # you can change this
+        gender="M",    # or leave None / ""
+    )
+
+    # 4) Print key outputs
+    print("\n=== Coarse Counts ===")
+    print(result.get("coarse_counts"))
+
+    print("\n=== WBC Subtypes ===")
+    print(result.get("wbc_subtypes"))
+
+    print("\n=== WBC Percentages ===")
+    print(result.get("wbc_percentages"))
+
+    print("\n=== Report Text (first 40 lines) ===")
+    report_lines = result.get("report_text", "").splitlines()
+    for line in report_lines[:40]:
+        print(line)
+
+if __name__ == "__main__":
+    main()

wbc_classifier/best_model_checkpoint.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f987d514b82516f3a0b974a01ddd07fb98b0cc4049020a96dd5e3df1fabf0a82
+size 134

yolov8_detector/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd5a31cf18dbfd11f35248cfde75a8dd854fff6ca6549c6de035ce295f64944d
+size 5609270