initial commit

.gitattributes

@@ -0,0 +1,2 @@
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,209 @@
+# 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__/
+
+ai/

FileCrawler.py

@@ -0,0 +1,134 @@
+import os
+
+from django.core.serializers.json import DjangoJSONEncoder
+import json
+json.JSONEncoder.default = DjangoJSONEncoder
+
+from tqdm import tqdm
+
+import random
+
+
+class Directory(object):
+  def __init__(self, path, name):
+    self._path = path.replace('\\', '/').replace('//', '/')
+    self._name = name
+    self._files = {}
+    self._filesArr = []
+
+
+class File(object):
+  def __init__(self, directory, path, name, extension):
+    self._directory = directory
+    self._path = path.replace('\\', '/').replace('//', '/')
+    self._name = name
+    self._extension = extension
+    self._pathDir = os.path.dirname(self._path)
+    self._dirName = os.path.basename(self._pathDir)
+    self._fileSize = None
+
+
+class FileCrawler(object):
+  def __init__(self, p_rootFolder, p_directoryNameContainsFilterSet, p_fileNameContainsFilterSet, p_extensionFilterSet):
+    self._rootFolder = p_rootFolder
+
+    self._directoryNameContainsFilterSet = None
+    if p_directoryNameContainsFilterSet is not None and len(p_directoryNameContainsFilterSet) > 0:
+      self._directoryNameContainsFilterSet = p_directoryNameContainsFilterSet
+
+    self._fileNameContainsFilterSet = None
+    if p_fileNameContainsFilterSet is not None and len(p_fileNameContainsFilterSet) > 0:
+      self._fileNameContainsFilterSet = p_fileNameContainsFilterSet
+
+    self._extensionFilterSet = None
+    if p_extensionFilterSet is not None and len(p_extensionFilterSet) > 0:
+      self._extensionFilterSet = p_extensionFilterSet
+
+    self._pathFiles = []
+
+    self._directories = {}
+    self._files = {}
+    self._filesArr = []
+
+    self.Crawl(p_rootFolder)
+
+    self._lenDirectories = len(self._directories)
+    self._lenFiles = len(self._files)
+    self._pathFiles = sorted(self._pathFiles)
+
+
+  def Decimate(self, decimateCount=None, isRandomSample=True):
+    files = None
+    if decimateCount is not None:
+      if isRandomSample:
+        files = random.sample(self._filesArr, decimateCount)
+      else:
+        files = self._filesArr[:decimateCount]
+    else:
+      files = self._files.values()
+
+    namesExtensionsFiles = {}
+    for fileIdx, file in tqdm(enumerate(files), desc="Decimate"):
+      namesExtensionsFiles[file._name + file._extension] = file
+
+    return namesExtensionsFiles
+
+
+  def Crawl(self, p_rootFolder, p_indent=''):
+    fname = p_rootFolder.split(os.sep)[-1]
+    rootLevelCount = p_rootFolder.count(os.sep)
+    for root, dirNames, fileNames in os.walk(p_rootFolder):      
+      levelCount = root.count(os.sep) - rootLevelCount
+      indent = p_indent + ' ' * (levelCount*2)
+      for fileName in fileNames:        
+        fF, fFe = os.path.splitext(fileName)
+        ff = fileName.lower()
+        ff, ffe = os.path.splitext(ff)
+
+        if self._extensionFilterSet is not None:
+          if ffe not in self._extensionFilterSet:
+            continue
+
+        if self._directoryNameContainsFilterSet is not None:
+          directoryNameFilterFound = False
+          for directoryNameFilter in self._directoryNameContainsFilterSet:
+            if directoryNameFilter in root:
+              directoryNameFilterFound = True
+              break
+          if not directoryNameFilterFound:
+            continue
+
+        if self._fileNameContainsFilterSet is not None:
+          fileNameFilterFound = False
+          for fileNameFilter in self._fileNameContainsFilterSet:
+            if fileNameFilter in ff:
+              fileNameFilterFound = True
+              break
+          if not fileNameFilterFound:
+            continue
+
+        pathFile = os.path.join(root, fileName)
+        pathFile = pathFile.replace('\\', '/').replace('//', '/')
+        self._pathFiles.append(pathFile)
+
+        root = root.replace('\\', '/').replace('//', '/')
+        if root not in self._directories:
+          directoryName = os.path.basename(root)
+          directory = Directory(root, directoryName)
+          self._directories[directory._path] = directory
+        else:
+          directory = self._directories[root]
+
+        file = File(directory, pathFile, fF, fFe)
+        self._files[file._path] = file
+        self._filesArr.append(file)
+        directory._files[file._path] = file
+        directory._filesArr.append(file)
+
+      for dirName in dirNames:
+        dirRootFolder = f'{root}/{dirName}'
+        self.Crawl(dirRootFolder, indent)
+
+
+if __name__ == '__main__':
+  print('done.')

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Syneticai
+
+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.

PrepareDatasets.py

@@ -0,0 +1,89 @@
+import sys
+import os
+import shutil
+
+from tqdm import tqdm
+
+
+def CreateYaml(newDatasetFolder):
+  pathYaml = f'{newDatasetFolder}/{newDatasetFolder}.yaml'
+
+  userName = '{user}'
+
+  if os.path.exists(pathYaml):
+    os.remove(pathYaml)
+  with open(pathYaml, 'w', newline='\n') as f:
+    f.write(f'''
+train: /home/{userName}/datasets/ApplesM5/{newDatasetFolder}/yolos/images/trains
+val: /home/{userName}/datasets/ApplesM5/{newDatasetFolder}/yolos/images/vals
+
+nc: 1
+names:
+  0: 'Apple'
+
+''')
+    f.flush()
+
+
+def IgnorePlusHash(src, names):
+  # Ignore files containing "+#" in their names
+  return [name for name in names if '+#' in name]
+
+if __name__ == "__main__":
+
+  originsFolders = [
+    'synetic-bg',
+    'real',
+    'real-original'
+  ]
+
+  newFolders = [
+    'synetic',
+
+    'synetic-bg-train+real-val',
+    'synetic-train+real-val',
+    'synetic+real',
+
+    'synetic-bg-train+real-original-val',
+    'synetic-train+real-original-val',
+    'synetic+real-original',
+  ]
+
+  for originFolder in originsFolders:
+    CreateYaml(originFolder)
+
+  newDatasetsFoldersAndTrainsValsOrigins = [
+    [ 'synetic', ['synetic-bg'], ['synetic-bg'], True ],
+
+    [ 'synetic-bg-train+real-val', ['synetic-bg'], ['real'], False ],
+    [ 'synetic-train+real-val', ['synetic-bg'], ['real'], False ],
+    [ 'synetic+real', ['synetic', 'real'], ['synetic', 'real'], False ],
+
+    [ 'synetic-bg-train+real-original-val', ['synetic-bg'], ['real-original'], False ],
+    [ 'synetic-train+real-original-val', ['synetic-bg'], ['real-original'], False ],
+    [ 'synetic+real-original', ['synetic', 'real-original'], ['synetic', 'real-original'], False ],
+  ]
+
+  datasFormats = ['images', 'labels']
+
+  datasOriginsTypes = ['trains', 'vals']
+
+  for (newDatasetFolder, trainsOrigins, valsOrigins, ignorePlusHash) in newDatasetsFoldersAndTrainsValsOrigins:
+    print(f'Processing: {newDatasetFolder}..')
+
+    if os.path.exists(newDatasetFolder):
+      shutil.rmtree(newDatasetFolder)
+    os.makedirs(newDatasetFolder)
+
+    CreateYaml(newDatasetFolder)
+
+    for dataOriginType, datasOrigins in tqdm(zip(datasOriginsTypes, [trainsOrigins, valsOrigins])):
+      for dataOrigin in datasOrigins:
+        for dataFormat in datasFormats:
+          src = f'./{dataOrigin}/yolos/{dataFormat}/{dataOriginType}/'
+          dst = f'{newDatasetFolder}/yolos/{dataFormat}/{dataOriginType}/'
+          
+          if ignorePlusHash:
+            shutil.copytree(src, dst, dirs_exist_ok=True, ignore=IgnorePlusHash)
+          else:
+            shutil.copytree(src, dst, dirs_exist_ok=True)

README.md

@@ -0,0 +1,110 @@
+# ApplesM5
+## Breaking the Bottleneck: Synthetic Data as the New Foundation for Vision AI
+
+This repository contains training images and scripts for the Synetic AI **ApplesM5** object detection project that was used in the **Breaking the Bottleneck: Synthetic Data as the New Foundation for Vision AI** white paper, using **Ultralytics YOLO12**. The core scripts allow you to train models using custom YAML datasets and evaluate the results using the provided train_metrics.py script.
+
+The paper is available for download at https://synetic.ai/white-paper/breaking/benchmark .
+
+---
+
+## 📂 Repository Structure (Key Files)
+
+| File                       | Purpose                                                                                     |
+| -------------------------- | ------------------------------------------------------------------------------------------- |
+| `PrepareDatasets.py`       | Produces the individual datasets used for training various combinations.                    |
+| `applesm5-train-det.py`    | Trains YOLO12 detection models using specified datasets and hyperparameters.                |
+| `FileCrawler.py`           | Recursively crawls directories to find image and label files. Used for evaluating datasets. |
+| `train_metrics.py`         | Runs evaluations on trained YOLO12 models and computes mAP, precision, and recall metrics.  |
+| `*.yaml` (dataset configs) | Define dataset splits, including training, validation, and test image directories.          |
+
+---
+
+## ⚙️ Setup
+
+### 1. Install Dependencies
+
+```bash
+pip install ultralytics tqdm
+```
+
+Your environment should have **PyTorch** and GPU drivers properly configured.
+
+---
+
+## 🚀 Usage
+
+### 0. Prepare Datasets (`PrepareDatasets.py`)
+
+It will produce multiple folders combinations of synetic and real from the real and synetic source folders.
+
+```bash
+python PrepareDatasets.py
+```
+
+### A. Training Models (`applesm5-train-det.py`)
+
+To train object detection models using YOLO12:
+
+```bash
+python applesm5-train-det.py
+```
+
+Key things to configure:
+
+- Edit the `dataNames` list to point to your dataset YAML files (e.g., `real`, `synetic+real`, etc.).
+- YAML files should be placed at `/home/user/datasets/ApplesM5/`.
+- Adjust `hyperparams`, `epochs`, and GPU `devices` as needed.
+- The script trains multiple model variants (`yolo12n.yaml`, etc.) and saves results to the Ultralytics default `runs/detect/` folder.
+
+---
+
+### B. Dataset YAML Files
+
+Example dataset YAML (`real.yaml`):
+
+```yaml
+path: /path/to/your/dataset
+train: images/train
+val: images/val
+test: images/test
+names:
+  0: apple
+```
+
+Modify the paths in your YAML files to point to your dataset locations.
+
+---
+
+### C. Evaluating Models (`train_metrics.py`)
+
+After training, you can evaluate your models on a validation dataset:
+
+```bash
+python train_metrics.py
+```
+
+Make sure to adjust the following in the script:
+
+- `modelPaths`: list of trained YOLO12 model `.pt` files to evaluate.
+- `pathValsDataset`: path to your validation images (`.png`/`.jpg`).
+
+This will compute **mAP50**, **mAP50-95**, **precision**, and **recall** scores and print them to the console.
+
+---
+
+## ✅ Example Workflow
+
+1. Prepare datasets and YAML config files.
+2. Train detection models with `applesm5-train-det.py`.
+3. Run `train_metrics.py` to benchmark models.
+4. Iterate on your datasets and training parameters to improve performance.
+
+---
+
+## 🔧 Notes
+
+- The training script assumes a multi-GPU setup (adjust the `devices` list if needed).
+- The repo is tuned for an NVIDIA DGX or similar system with 8 GPUs but can be modified for single-GPU setups.
+- Dataset YAML and trained model `.pt` files follow the **Ultralytics YOLO12** conventions.
+
+---

applesm5-train-det.py

@@ -0,0 +1,108 @@
+import ultralytics
+
+
+'''
+
+NOTE:
+adjust this code as needed - the below are parameters for a 8xB200 system
+
+
+'''
+
+
+if __name__ == "__main__":
+  ultralytics.checks()
+  
+  userName = '{user}'
+
+  epochs = 100
+  
+  # pick and choose what datasets to train - make sure to first run PrepareDatasets.py
+  dataNames = [
+    'synetic-train+real-val',
+    'synetic-train+real-original-val',
+
+    'synetic-bg-train+real-val',
+    'synetic+real',
+
+    'synetic-bg-train+real-original-val',
+    'synetic+real-original',
+
+    'real',
+    'real-original',
+
+    'synetic-bg',
+    'synetic',
+  ]
+
+  hyperparams = [
+    ('12', 'n', f'/home/{userName}/datasets/ApplesM5'),
+    ('11', 'n', f'/home/{userName}/datasets/ApplesM5'),
+    ('v8', 'n', f'/home/{userName}/datasets/ApplesM5'),
+    ('v6', 'n', f'/home/{userName}/datasets/ApplesM5'),
+    ('v5', 'n', f'/home/{userName}/datasets/ApplesM5'),
+    ('v3', 'n', f'/home/{userName}/datasets/ApplesM5'),
+    ('rtdetr', '-l', f'/home/{userName}/datasets/ApplesM5')
+  ]
+
+  for dataName in dataNames:
+    for hyperparam in hyperparams:
+      modelVersion, modelSize, pathDataYaml = hyperparam
+
+      pathDataYaml = f'{pathDataYaml}/{dataName}/{dataName}.yaml'
+
+      projectName = f'ApplesM5_{modelVersion}{modelSize}'
+      taskName = 'detect'
+      
+      if 'rtdetr' in modelVersion:
+        modelName = f"{modelVersion}{modelSize}.pt"
+        modelDet = ultralytics.RTDETR(modelName)
+      else:
+        modelName = f"yolo{modelVersion}{modelSize}.yaml"
+        modelDet = ultralytics.YOLO(modelName)
+        
+      trainName = f'{projectName}-{taskName}-{epochs}_{dataName}_0'
+
+      devices = [0, 1, 2, 3, 4, 5, 6, 7]
+      devicesLen = len(devices)
+
+      batchSize = devicesLen * 30 * 2
+
+      batchSize = int(batchSize)
+
+      results = modelDet.train(
+        imgsz=640,
+
+        name=trainName,
+        data=pathDataYaml,
+        task=taskName,
+        epochs=epochs,
+        device=devices,
+        batch=batchSize,
+        workers=28,
+
+        cache='disk',
+
+        flipud=0.5,
+        fliplr=0.5,
+
+        hsv_h=0.1,
+        hsv_s=0.1,
+        hsv_v=0.1,
+
+        mosaic=0.75,
+        close_mosaic=0,
+
+        degrees=45.0,
+        shear=15.0,
+        perspective=0.0005,
+        translate=0.3,
+        mixup=0.1,        # image mixup (probability)
+        copy_paste=0.1,   # segment copy-paste (probability)
+        auto_augment='randaugment', # (str) auto augmentation policy for classification (randaugment, autoaugment, augmix)
+        augment=True,
+
+        val=True,
+
+      )
+