Upload 23 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* 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
+videos/video_1.mp4 filter=lfs diff=lfs merge=lfs -text
+videos/video_2.mp4 filter=lfs diff=lfs merge=lfs -text
+videos/video_3.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,143 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Local folder
+local_folder
+project_demo
+project_demo/
+logs/
+local_folder/
+/demo.py
+demo.py
+runs/
+
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+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
+
+.vscode
+
+# 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/
+
+# 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
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.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
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+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/

README.md

@@ -1,13 +1,118 @@
----
-title: YOL Streamlit
-emoji: 📈
-colorFrom: indigo
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.31.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Real-time Object Detection and Tracking with YOLOv8 and Streamlit
+
+This repository is a comprehensive open-source project that demonstrates the integration of object detection and tracking using the YOLOv8 object detection algorithm and Streamlit, a popular Python web application framework for building interactive web applications. This project provides a user-friendly and customizable interface that can detect and track objects in real-time video streams.
+
+## Demo WebApp
+
+This app is up and running on Streamlit cloud server!!! Thanks 'Streamlit' for the community support for the cloud upload. You can check the demo of this web application on the link below.
+
+[yolov8-streamlit-detection-tracking-webapp](https://codingmantras-yolov8-streamlit-detection-tracking-app-njcqjg.streamlit.app/)
+
+## Tracking With Object Detection Demo
+
+<https://user-images.githubusercontent.com/104087274/234874398-75248e8c-6965-4c91-9176-622509f0ad86.mov>
+
+## Demo Pics
+
+### Home page
+
+<img src="https://github.com/CodingMantras/yolov8-streamlit-detection-tracking/blob/master/assets/pic1.png" >
+
+### Page after uploading an image and object detection
+
+<img src="https://github.com/CodingMantras/yolov8-streamlit-detection-tracking/blob/master/assets/pic3.png" >
+
+### Segmentation task on image
+
+<img src="https://github.com/CodingMantras/yolov8-streamlit-detection-tracking/blob/master/assets/segmentation.png" >
+
+## Requirements
+
+Python 3.6+
+YOLOv8
+Streamlit
+
+```bash
+pip install ultralytics streamlit pytube
+```
+
+## Installation
+
+- Clone the repository: git clone <https://github.com/CodingMantras/yolov8-streamlit-detection-tracking.git>
+- Change to the repository directory: `cd yolov8-streamlit-detection-tracking`
+- Create `weights`, `videos`, and `images` directories inside the project.
+- Download the pre-trained YOLOv8 weights from (<https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt>) and save them to the `weights` directory in the same project.
+
+## Usage
+
+- Run the app with the following command: `streamlit run app.py`
+- The app should open in a new browser window.
+
+### ML Model Config
+
+- Select task (Detection, Segmentation)
+- Select model confidence
+- Use the slider to adjust the confidence threshold (25-100) for the model.
+
+One the model config is done, select a source.
+
+### Detection on images
+
+- The default image with its objects-detected image is displayed on the main page.
+- Select a source. (radio button selection `Image`).
+- Upload an image by clicking on the "Browse files" button.
+- Click the "Detect Objects" button to run the object detection algorithm on the uploaded image with the selected confidence threshold.
+- The resulting image with objects detected will be displayed on the page. Click the "Download Image" button to download the image.("If save image to download" is selected)
+
+## Detection in Videos
+
+- Create a folder with name `videos` in the same directory
+- Dump your videos in this folder
+- In `settings.py` edit the following lines.
+
+```python
+# video
+VIDEO_DIR = ROOT / 'videos' # After creating the videos folder
+
+# Suppose you have four videos inside videos folder
+# Edit the name of video_1, 2, 3, 4 (with the names of your video files) 
+VIDEO_1_PATH = VIDEO_DIR / 'video_1.mp4' 
+VIDEO_2_PATH = VIDEO_DIR / 'video_2.mp4'
+VIDEO_3_PATH = VIDEO_DIR / 'video_3.mp4'
+VIDEO_4_PATH = VIDEO_DIR / 'video_4.mp4'
+
+# Edit the same names here also.
+VIDEOS_DICT = {
+    'video_1': VIDEO_1_PATH,
+    'video_2': VIDEO_2_PATH,
+    'video_3': VIDEO_3_PATH,
+    'video_4': VIDEO_4_PATH,
+}
+
+# Your videos will start appearing inside streamlit webapp 'Choose a video'.
+```
+
+- Click on `Detect Video Objects` button and the selected task (detection/segmentation) will start on the selected video.
+
+### Detection on RTSP
+
+- Select the RTSP stream button
+- Enter the rtsp url inside the textbox and hit `Detect Objects` button
+
+### Detection on YouTube Video URL
+
+- Select the source as YouTube
+- Copy paste the url inside the text box.
+- The detection/segmentation task will start on the YouTube video url
+
+<https://user-images.githubusercontent.com/104087274/226178296-684ad72a-fe5f-4589-b668-95c835cd8d8a.mov>
+
+## Acknowledgements
+
+This app is based on the YOLOv8(<https://github.com/ultralytics/ultralytics>) object detection algorithm. The app uses the Streamlit(<https://github.com/streamlit/streamlit>) library for the user interface.
+
+### Disclaimer
+
+Please note that this project is intended for educational purposes only and should not be used in production environments.
+
+**Hit star ⭐ if you like this repo!!!**

app.py

@@ -0,0 +1,110 @@
+# Python In-built packages
+from pathlib import Path
+import PIL
+
+# External packages
+import streamlit as st
+
+# Local Modules
+import settings
+import helper
+
+# Setting page layout
+st.set_page_config(
+    page_title="YOLO İle Tahmin İşlemi",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Main page heading
+st.title("🚀 YOLO İle Nesne Tanıma İşlemi")
+
+# Sidebar
+st.sidebar.header("Derin Öğrenme Model Tahmin Ayarları")
+
+# Model Options
+model_type = st.sidebar.radio(
+    "Modeli Seçiniz", ['Detection', 'Segmentation'])
+
+confidence = float(st.sidebar.slider(
+    "Model Doğruluğunu Seçiniz", 25, 100, 40)) / 100
+
+# Selecting Detection Or Segmentation
+if model_type == 'Detection':
+    model_path = Path(settings.DETECTION_MODEL)
+elif model_type == 'Segmentation':
+    model_path = Path(settings.SEGMENTATION_MODEL)
+
+# Load Pre-trained ML Model
+try:
+    model = helper.load_model(model_path)
+except Exception as ex:
+    st.error(f"Unable to load model. Check the specified path: {model_path}")
+    st.error(ex)
+
+st.sidebar.header("Resim Ve Video Yapılandırılması")
+source_radio = st.sidebar.radio(
+    "Kaynağı Seçin", settings.SOURCES_LIST)
+
+source_img = None
+# If image is selected
+if source_radio == settings.IMAGE:
+    source_img = st.sidebar.file_uploader(
+        "Bir Resim Seçin...", type=("jpg", "jpeg", "png", 'bmp', 'webp'))
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        try:
+            if source_img is None:
+                default_image_path = str(settings.DEFAULT_IMAGE)
+                default_image = PIL.Image.open(default_image_path)
+                st.image(default_image_path, caption="Seçilen Resim",
+                         use_column_width=True)
+            else:
+                uploaded_image = PIL.Image.open(source_img)
+                st.image(source_img, caption="Yüklenen Resim",
+                         use_column_width=True)
+        except Exception as ex:
+            st.error("Error occurred while opening the image.")
+            st.error(ex)
+
+    with col2:
+        if source_img is None:
+            default_detected_image_path = str(settings.DEFAULT_DETECT_IMAGE)
+            default_detected_image = PIL.Image.open(
+                default_detected_image_path)
+            st.image(default_detected_image_path, caption='Tahmin İşlemi',
+                     use_column_width=True)
+        else:
+            if st.sidebar.button('Tahmin Et'):
+                res = model.predict(uploaded_image,
+                                    conf=confidence
+                                    )
+                boxes = res[0].boxes
+                res_plotted = res[0].plot()[:, :, ::-1]
+                st.image(res_plotted, caption='Tahmin İşlemi',
+                         use_column_width=True)
+                try:
+                    with st.expander("Tahmin Edilen Nesneler"):
+                        for box in boxes:
+                            st.write(box.data)
+                except Exception as ex:
+                    # st.write(ex)
+                    st.write("No image is uploaded yet!")
+
+elif source_radio == settings.VIDEO:
+    helper.play_stored_video(confidence, model)
+
+elif source_radio == settings.WEBCAM:
+    helper.play_webcam(confidence, model)
+
+elif source_radio == settings.RTSP:
+    helper.play_rtsp_stream(confidence, model)
+
+elif source_radio == settings.YOUTUBE:
+    helper.play_youtube_video(confidence, model)
+
+else:
+    st.error("Please select a valid source type!")

helper.py

@@ -0,0 +1,231 @@
+from ultralytics import YOLO
+import time
+import streamlit as st
+import cv2
+from pytube import YouTube
+
+import settings
+
+
+def load_model(model_path):
+    """
+    Loads a YOLO object detection model from the specified model_path.
+
+    Parameters:
+        model_path (str): The path to the YOLO model file.
+
+    Returns:
+        A YOLO object detection model.
+    """
+    model = YOLO(model_path)
+    return model
+
+
+def display_tracker_options():
+    display_tracker = st.radio("Display Tracker", ('Yes', 'No'))
+    is_display_tracker = True if display_tracker == 'Yes' else False
+    if is_display_tracker:
+        tracker_type = st.radio("Tracker", ("bytetrack.yaml", "botsort.yaml"))
+        return is_display_tracker, tracker_type
+    return is_display_tracker, None
+
+
+def _display_detected_frames(conf, model, st_frame, image, is_display_tracking=None, tracker=None):
+    """
+    Display the detected objects on a video frame using the YOLOv8 model.
+
+    Args:
+    - conf (float): Confidence threshold for object detection.
+    - model (YoloV8): A YOLOv8 object detection model.
+    - st_frame (Streamlit object): A Streamlit object to display the detected video.
+    - image (numpy array): A numpy array representing the video frame.
+    - is_display_tracking (bool): A flag indicating whether to display object tracking (default=None).
+
+    Returns:
+    None
+    """
+
+    # Resize the image to a standard size
+    image = cv2.resize(image, (720, int(720*(9/16))))
+
+    # Display object tracking, if specified
+    if is_display_tracking:
+        res = model.track(image, conf=conf, persist=True, tracker=tracker)
+    else:
+        # Predict the objects in the image using the YOLOv8 model
+        res = model.predict(image, conf=conf)
+
+    # # Plot the detected objects on the video frame
+    res_plotted = res[0].plot()
+    st_frame.image(res_plotted,
+                   caption='Detected Video',
+                   channels="BGR",
+                   use_column_width=True
+                   )
+
+
+def play_youtube_video(conf, model):
+    """
+    Plays a webcam stream. Detects Objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_youtube = st.sidebar.text_input("YouTube Video url")
+
+    is_display_tracker, tracker = display_tracker_options()
+
+    if st.sidebar.button('Detect Objects'):
+        try:
+            yt = YouTube(source_youtube)
+            stream = yt.streams.filter(file_extension="mp4", res=720).first()
+            vid_cap = cv2.VideoCapture(stream.url)
+
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker,
+                                             tracker,
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))
+
+
+def play_rtsp_stream(conf, model):
+    """
+    Plays an rtsp stream. Detects Objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_rtsp = st.sidebar.text_input("rtsp stream url:")
+    st.sidebar.caption('Example URL: rtsp://admin:12345@192.168.1.210:554/Streaming/Channels/101')
+    is_display_tracker, tracker = display_tracker_options()
+    if st.sidebar.button('Detect Objects'):
+        try:
+            vid_cap = cv2.VideoCapture(source_rtsp)
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker,
+                                             tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    # vid_cap = cv2.VideoCapture(source_rtsp)
+                    # time.sleep(0.1)
+                    # continue
+                    break
+        except Exception as e:
+            vid_cap.release()
+            st.sidebar.error("Error loading RTSP stream: " + str(e))
+
+
+def play_webcam(conf, model):
+    """
+    Plays a webcam stream. Detects Objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_webcam = settings.WEBCAM_PATH
+    is_display_tracker, tracker = display_tracker_options()
+    if st.sidebar.button('Detect Objects'):
+        try:
+            vid_cap = cv2.VideoCapture(source_webcam)
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker,
+                                             tracker,
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))
+
+
+def play_stored_video(conf, model):
+    """
+    Plays a stored video file. Tracks and detects objects in real-time using the YOLOv8 object detection model.
+
+    Parameters:
+        conf: Confidence of YOLOv8 model.
+        model: An instance of the `YOLOv8` class containing the YOLOv8 model.
+
+    Returns:
+        None
+
+    Raises:
+        None
+    """
+    source_vid = st.sidebar.selectbox(
+        "Choose a video...", settings.VIDEOS_DICT.keys())
+
+    is_display_tracker, tracker = display_tracker_options()
+
+    with open(settings.VIDEOS_DICT.get(source_vid), 'rb') as video_file:
+        video_bytes = video_file.read()
+    if video_bytes:
+        st.video(video_bytes)
+
+    if st.sidebar.button('Detect Video Objects'):
+        try:
+            vid_cap = cv2.VideoCapture(
+                str(settings.VIDEOS_DICT.get(source_vid)))
+            st_frame = st.empty()
+            while (vid_cap.isOpened()):
+                success, image = vid_cap.read()
+                if success:
+                    _display_detected_frames(conf,
+                                             model,
+                                             st_frame,
+                                             image,
+                                             is_display_tracker,
+                                             tracker
+                                             )
+                else:
+                    vid_cap.release()
+                    break
+        except Exception as e:
+            st.sidebar.error("Error loading video: " + str(e))

packages.txt

@@ -0,0 +1,3 @@
+freeglut3-dev
+libgtk2.0-dev
+libgl1-mesa-glx

requirements.txt

@@ -0,0 +1,87 @@
+altair==5.1.1
+attrs==23.1.0
+backports.zoneinfo==0.2.1
+blinker==1.6.2
+cachetools==5.3.1
+certifi==2023.7.22
+charset-normalizer==3.2.0
+click==8.1.7
+cmake==3.27.4.1
+contourpy==1.1.0
+cycler==0.11.0
+Cython==3.0.2
+filelock==3.12.3
+fonttools==4.42.1
+gitdb==4.0.10
+GitPython==3.1.35
+idna==3.4
+importlib-metadata==6.8.0
+importlib-resources==6.0.1
+Jinja2==3.1.2
+jsonschema==4.19.0
+jsonschema-specifications==2023.7.1
+kiwisolver==1.4.5
+lapx==0.5.4
+lit==16.0.6
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+matplotlib==3.7.2
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.1
+numpy==1.24.4
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cuda-cupti-cu11==11.7.101
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cudnn-cu11==8.5.0.96
+nvidia-cufft-cu11==10.9.0.58
+nvidia-curand-cu11==10.2.10.91
+nvidia-cusolver-cu11==11.4.0.1
+nvidia-cusparse-cu11==11.7.4.91
+nvidia-nccl-cu11==2.14.3
+nvidia-nvtx-cu11==11.7.91
+opencv-python-headless==4.8.0.76
+packaging==23.1
+pandas==2.0.3
+Pillow==9.5.0
+pkgutil-resolve-name==1.3.10
+protobuf==4.24.3
+psutil==5.9.5
+py-cpuinfo==9.0.0
+pyarrow==13.0.0
+pydeck==0.8.0
+Pygments==2.16.1
+Pympler==1.0.1
+pyparsing==3.0.9
+python-dateutil==2.8.2
+pytube==15.0.0
+pytz==2023.3.post1
+pytz-deprecation-shim==0.1.0.post0
+PyYAML==6.0.1
+referencing==0.30.2
+requests==2.31.0
+rich==13.5.2
+rpds-py==0.10.2
+scipy==1.10.1
+seaborn==0.12.2
+six==1.16.0
+smmap==5.0.0
+streamlit==1.26.0
+sympy==1.12
+tenacity==8.2.3
+toml==0.10.2
+toolz==0.12.0
+torch==2.0.1
+torchvision==0.15.2
+tornado==6.3.3
+tqdm==4.66.1
+triton==2.0.0
+typing-extensions==4.7.1
+tzdata==2023.3
+tzlocal==4.3.1
+ultralytics==8.0.173
+urllib3==2.0.4
+validators==0.22.0
+watchdog==3.0.0
+zipp==3.16.2

settings.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+import sys
+
+# Get the absolute path of the current file
+file_path = Path(__file__).resolve()
+
+# Get the parent directory of the current file
+root_path = file_path.parent
+
+# Add the root path to the sys.path list if it is not already there
+if root_path not in sys.path:
+    sys.path.append(str(root_path))
+
+# Get the relative path of the root directory with respect to the current working directory
+ROOT = root_path.relative_to(Path.cwd())
+
+# Sources
+IMAGE = 'Resim'
+VIDEO = 'Video'
+WEBCAM = 'Webcam'
+RTSP = 'RTSP'
+YOUTUBE = 'YouTube'
+
+SOURCES_LIST = [IMAGE, VIDEO, WEBCAM, RTSP, YOUTUBE]
+
+# Images config
+IMAGES_DIR = ROOT / 'images'
+DEFAULT_IMAGE = IMAGES_DIR / 'deneme.jpeg'
+DEFAULT_DETECT_IMAGE = IMAGES_DIR / 'deneme_detected.png'
+
+# Videos config
+VIDEO_DIR = ROOT / 'videos'
+VIDEO_1_PATH = VIDEO_DIR / 'video_1.mp4'
+VIDEO_2_PATH = VIDEO_DIR / 'video_2.mp4'
+VIDEO_3_PATH = VIDEO_DIR / 'video_3.mp4'
+VIDEO_4_PATH = VIDEO_DIR / 'airplane1.mp4'
+VIDEOS_DICT = {
+    'video_1': VIDEO_1_PATH,
+    'video_2': VIDEO_2_PATH,
+    'video_3': VIDEO_3_PATH,
+    'video_4': VIDEO_4_PATH,
+}
+
+# ML Model config
+MODEL_DIR = ROOT / 'weights'
+DETECTION_MODEL = MODEL_DIR / 'yolov9e.pt'
+# In case of your custome model comment out the line above and
+# Place your custom model pt file name at the line below 
+# DETECTION_MODEL = MODEL_DIR / 'my_detection_model.pt'
+
+SEGMENTATION_MODEL = MODEL_DIR / 'yolov8n-seg.pt'
+
+# Webcam
+WEBCAM_PATH = 0

videos/video_1.mp4

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

videos/video_2.mp4

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

videos/video_3.mp4

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

weights/yolov8m.pt

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

weights/yolov8n-seg.pt

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