Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,211 @@
+# 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__/
+*.pt
+*.jpg`
+runs/
+data/

README.md

@@ -1,3 +1,26 @@
----
-license: mit
----
+---
+library_name: ultralytics
+pipeline_tag: image-segmentation
+tags:
+  - yolo
+  - yolo11
+  - ultralytics
+  - segmentation
+  - instance-segmentation
+license: mit
+---
+
+# YOLOv11-seg – Earthworm Body Mask
+
+This repository hosts a **custom YOLOv11 segmentation model** trained with [Ultralytics](https://github.com/ultralytics/ultralytics).
+The model detects and segments earthworm bodies in images.
+
+## Model Details
+- **Architecture:** YOLOv11-seg (Ultralytics)
+- **Framework:** PyTorch / Ultralytics
+- **Task:** Instance segmentation
+- **Classes:**
+  - `0: body_mask`
+
+## Weights
+- `best.pt` (current checkpoint uploaded here)

args.yaml

@@ -0,0 +1,106 @@
+task: segment
+mode: train
+model: yolo11l-seg.pt
+data: data.yaml
+epochs: 500
+time: null
+patience: 100
+batch: 4
+imgsz: 1024
+save: true
+save_period: -1
+cache: false
+device: null
+workers: 8
+project: null
+name: train4
+exist_ok: false
+pretrained: true
+optimizer: auto
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+fraction: 1.0
+profile: false
+freeze: null
+multi_scale: false
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+vid_stride: 1
+stream_buffer: false
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+embed: null
+show: false
+save_frames: false
+save_txt: false
+save_conf: false
+save_crop: false
+show_labels: true
+show_conf: true
+show_boxes: true
+line_width: null
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: true
+opset: null
+workspace: null
+nms: false
+lr0: 0.01
+lrf: 0.01
+momentum: 0.937
+weight_decay: 0.0005
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+pose: 12.0
+kobj: 1.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.5
+shear: 0.0
+perspective: 0.0
+flipud: 0.0
+fliplr: 0.5
+bgr: 0.0
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+copy_paste_mode: flip
+auto_augment: randaugment
+erasing: 0.4
+crop_fraction: 1.0
+cfg: null
+tracker: botsort.yaml
+save_dir: runs/segment/train4

data.yaml

@@ -0,0 +1,7 @@
+path: yolo_split # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+names:
+  0: body_mask

inference.py

@@ -0,0 +1,22 @@
+import os
+
+from ultralytics import YOLO
+import glob
+# Load your trained segmentation model
+model = YOLO('runs/segment/train/weights/last.pt')
+IN_DIR = "/home/quentin/repos/yolov11-segmentation_earth-worm/data/yolo_split/images/val"
+# Predict on an image, replace with your image path or URL
+
+files = sorted(glob.glob(f"{IN_DIR}/*.jpg"))
+for f in files:
+
+    results = model(f)
+# Save results, this includes saving masks
+    os.makedirs("results/", exist_ok=True)
+    results[0].save(f"results/result_{os.path.basename(f)}")
+#
+# for f in sorted(glob.glob(f"{IN_DIR}/2024-10-08/*.jpg")):
+#     results = model(f)
+#     # Save results, this includes saving masks
+#     os.makedirs("results/2024-10-08", exist_ok=True)
+#     results[0].save(f"results/2024-10-08/result_{os.path.basename(f)}")

requiremnts.txt

@@ -0,0 +1,4 @@
+ultralytics>=8.3
+torch
+torchvision
+pillow

split_train_val.py

@@ -0,0 +1,88 @@
+
+import sys
+import hashlib
+import shutil
+from pathlib import Path
+from wsgiref.validate import assert_
+
+from ultralytics.data.converter import convert_coco
+import os
+
+
+INPUT_DIR = "data/coco"
+YOLO_DATA_DIR = "data/yolo"
+TARGET_DIR = "data/yolo_split"
+
+
+
+def md5_of_file(path, chunk=1<<20):
+    h = hashlib.md5()
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(chunk)
+            if not b:
+                break
+            h.update(b)
+    return h.hexdigest()
+
+
+if __name__ == "__main__":
+    if os.path.isdir(YOLO_DATA_DIR):
+        shutil.rmtree(YOLO_DATA_DIR)
+
+    if os.path.isdir(TARGET_DIR):
+        shutil.rmtree(TARGET_DIR)
+
+
+    convert_coco(labels_dir="data/coco", use_segments=True, save_dir=YOLO_DATA_DIR )
+
+    train_dir = os.path.join(TARGET_DIR,"images", "train")
+    train_dir_annotations = os.path.join(TARGET_DIR,"labels", "train")
+    val_dir = os.path.join(TARGET_DIR, "images","val")
+    val_dir_annotations = os.path.join(TARGET_DIR, "labels","val")
+
+    os.makedirs(train_dir, exist_ok=True)
+    os.makedirs(train_dir_annotations, exist_ok=True)
+    os.makedirs(val_dir, exist_ok=True)
+    os.makedirs(val_dir_annotations, exist_ok=True)
+
+    files = list(Path(INPUT_DIR).rglob("*.jpg"))
+    print(f"Found {len(files)} .jpg files")
+
+    n_train = n_val = 0
+    label_dir = os.path.join(YOLO_DATA_DIR,  "labels", "default")
+
+    for f in files:
+        md5 = md5_of_file(f)
+        bucket = int(md5, 16) % 100
+        # label_file = os.path.join(label_dir, os.path.splitext(f.name)[0]) + ".txt")
+        label_basename = os.path.splitext(f.name)[0] + ".txt"
+        label_file = os.path.join(label_dir, label_basename)
+        if not os.path.exists(label_file):
+            continue
+
+        if bucket < 20:
+            dst = os.path.join(val_dir,  f.name)
+            shutil.copy2(f, dst)
+            dst = os.path.join(val_dir_annotations, label_basename)
+            n_val += 1
+        else:
+            dst = os.path.join(train_dir, f.name)
+            shutil.copy2(f, dst)
+            dst = os.path.join(train_dir_annotations, label_basename)
+            n_train += 1
+
+        lines = []
+        with open(label_file, "r", encoding="utf-8") as f:
+            for line in f:
+                parts = line.strip().split()
+                if not parts:
+                    continue
+                if parts[0] == "1":
+                    parts[0] = "0"
+                lines.append(" ".join(parts))
+
+        with open(dst, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines))
+
+    print(f"Copied {n_train} files to train/, {n_val} files to val/")

train.py

@@ -0,0 +1,7 @@
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolo11l-seg.pt")  # load a pretrained model (recommended for training)
+
+# Train the model
+results = model.train(data="data.yaml", epochs=500, imgsz=1024, batch=4)