From 1beaba82b8813c5953887baee80e8f8f9e28037a Mon Sep 17 00:00:00 2001
From: Damiano Vincenzo Coppola <damiano.coppola03@gmail.com>
Date: Tue, 16 Apr 2024 12:01:49 +0200
Subject: [PATCH] Feat: implemented trainer  (#7)

* Feat:changed model of choice to train

* Fix:forgot a file

* fix
---
 README.md                   |   3 +
 Trainer.ipynb               | 255 ++++++++++++++++++++++++++++++
 custom-data.yaml.dist       |   8 +
 test.ipynb                  | 189 ----------------------
 yolov7-e6e-custom.yaml.dist | 306 ++++++++++++++++++++++++++++++++++++
 5 files changed, 572 insertions(+), 189 deletions(-)
 create mode 100644 Trainer.ipynb
 create mode 100644 custom-data.yaml.dist
 delete mode 100644 test.ipynb
 create mode 100644 yolov7-e6e-custom.yaml.dist

diff --git a/README.md b/README.md
index 8d80b62..f23890d 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,5 @@
 # EurobotVision
 Vision repo for Eurobot
+
+
+Create train and val folder where you need to put the dataset 
\ No newline at end of file
diff --git a/Trainer.ipynb b/Trainer.ipynb
new file mode 100644
index 0000000..d1f50f9
--- /dev/null
+++ b/Trainer.ipynb
@@ -0,0 +1,255 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Requirement already satisfied: torch in /home/defenge/.local/lib/python3.10/site-packages (2.2.2)\n",
+      "Requirement already satisfied: torchvision in /home/defenge/.local/lib/python3.10/site-packages (0.17.2)\n",
+      "Requirement already satisfied: torchaudio in /home/defenge/.local/lib/python3.10/site-packages (2.2.2)\n",
+      "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (8.9.2.26)\n",
+      "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (12.1.3.1)\n",
+      "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (11.0.2.54)\n",
+      "Requirement already satisfied: jinja2 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (3.1.3)\n",
+      "Requirement already satisfied: filelock in /home/defenge/.local/lib/python3.10/site-packages (from torch) (3.13.3)\n",
+      "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (12.1.105)\n",
+      "Requirement already satisfied: typing-extensions>=4.8.0 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (4.10.0)\n",
+      "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (11.4.5.107)\n",
+      "Requirement already satisfied: triton==2.2.0 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (2.2.0)\n",
+      "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (12.1.0.106)\n",
+      "Requirement already satisfied: networkx in /home/defenge/.local/lib/python3.10/site-packages (from torch) (3.2.1)\n",
+      "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (10.3.2.106)\n",
+      "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (2.19.3)\n",
+      "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (12.1.105)\n",
+      "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (12.1.105)\n",
+      "Requirement already satisfied: sympy in /home/defenge/.local/lib/python3.10/site-packages (from torch) (1.12)\n",
+      "Requirement already satisfied: fsspec in /home/defenge/.local/lib/python3.10/site-packages (from torch) (2024.3.1)\n",
+      "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /home/defenge/.local/lib/python3.10/site-packages (from torch) (12.1.105)\n",
+      "Requirement already satisfied: nvidia-nvjitlink-cu12 in /home/defenge/.local/lib/python3.10/site-packages (from nvidia-cusolver-cu12==11.4.5.107->torch) (12.4.99)\n",
+      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /home/defenge/.local/lib/python3.10/site-packages (from torchvision) (10.2.0)\n",
+      "Requirement already satisfied: numpy in /home/defenge/.local/lib/python3.10/site-packages (from torchvision) (1.23.5)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /home/defenge/.local/lib/python3.10/site-packages (from jinja2->torch) (2.1.5)\n",
+      "Requirement already satisfied: mpmath>=0.19 in /home/defenge/.local/lib/python3.10/site-packages (from sympy->torch) (1.3.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install torch torchvision torchaudio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "fatal: destination path 'yolov7' already exists and is not an empty directory.\n",
+      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
+      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
+      "  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\n",
+      "mv: cannot stat '/yolov7-e6e.pt': No such file or directory\n",
+      "mv: cannot stat '/train': No such file or directory\n",
+      "mv: cannot stat '/val': No such file or directory\n",
+      "cp: cannot stat '/custom-data.yaml.dist': No such file or directory\n",
+      "cp: cannot stat '/yolov7-e6e-custom.yaml.dist': No such file or directory\n"
+     ]
+    }
+   ],
+   "source": [
+    "cwd = 'pwd'\n",
+    "!git clone git@github.com:WongKinYiu/yolov7.git\n",
+    "!curl -o yolov7-e6e.pt https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e.pt\n",
+    "!mv \"${cwd}/yolov7-e6e.pt\" \"${cwd}/yolov7\"\n",
+    "!mv \"${cwd}/train\" \"${cwd}/yolov7/data\"\n",
+    "!mv \"${cwd}/val\" \"${cwd}/yolov7/data\"\n",
+    "!cp \"${cwd}/custom-data.yaml.dist\" \"${cwd}/yolov7/data/custom-data.yaml\"\n",
+    "!cp \"${cwd}/yolov7-e6e-custom.yaml.dist\" \"${cwd}/yolov7/cfg/training/yolov7-e6e-custom.yaml\"\n",
+    "#non funzionano i mv e cp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/defenge/dev/EurobotVision/yolov7\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd yolov7\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install -qr requirements.txt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch \n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "import cv2\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from models.yolo import Model\n",
+    "from utils.general import check_requirements, set_logging\n",
+    "from utils.google_utils import attempt_download\n",
+    "from utils.torch_utils import select_device"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "check_requirements(Path(\"\").parent / 'requirements.txt', exclude=('pycocotools', 'thop'))\n",
+    "set_logging()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "YOLOR 🚀 v0.1-128-ga207844 torch 2.2.2+cu121 CUDA:0 (NVIDIA GeForce GTX 1080, 8191.875MB)\n",
+      "\n",
+      "Namespace(weights='yolov7-e6e.pt', cfg='cfg/training/yolov7-e6e-custom.yaml', data='data/custom-data.yaml', hyp='data/hyp.scratch.custom.yaml', epochs=100, batch_size=4, img_size=[1280, 960], rect=False, resume=False, nosave=False, notest=False, noautoanchor=False, evolve=False, bucket='', cache_images=False, image_weights=False, device='0', multi_scale=False, single_cls=False, adam=False, sync_bn=False, local_rank=-1, workers=1, project='runs/train', entity=None, name='test-custom', exist_ok=False, quad=False, linear_lr=False, label_smoothing=0.0, upload_dataset=False, bbox_interval=-1, save_period=-1, artifact_alias='latest', freeze=[0], v5_metric=False, world_size=1, global_rank=-1, save_dir='runs/train/test-custom4', total_batch_size=4)\n",
+      "\u001b[34m\u001b[1mtensorboard: \u001b[0mStart with 'tensorboard --logdir runs/train', view at http://localhost:6006/\n",
+      "\u001b[34m\u001b[1mhyperparameters: \u001b[0mlr0=0.01, lrf=0.1, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.3, cls_pw=1.0, obj=0.7, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.2, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0, paste_in=0.0, loss_ota=1\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/home/defenge/dev/EurobotVision/yolov7/train.py\", line 616, in <module>\n",
+      "    train(hyp, opt, device, tb_writer)\n",
+      "  File \"/home/defenge/dev/EurobotVision/yolov7/train.py\", line 71, in train\n",
+      "    run_id = torch.load(weights, map_location=device).get('wandb_id') if weights.endswith('.pt') and os.path.isfile(weights) else None\n",
+      "  File \"/home/defenge/.local/lib/python3.10/site-packages/torch/serialization.py\", line 1040, in load\n",
+      "    return _legacy_load(opened_file, map_location, pickle_module, **pickle_load_args)\n",
+      "  File \"/home/defenge/.local/lib/python3.10/site-packages/torch/serialization.py\", line 1258, in _legacy_load\n",
+      "    magic_number = pickle_module.load(f, **pickle_load_args)\n",
+      "EOFError: Ran out of input\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python3 train.py --workers 1 --device 0 --batch-size 4 --epochs 100 --img 1280 960 --data data/custom-data.yaml --hyp data/hyp.scratch.custom.yaml --cfg cfg/training/yolov7-e6e-custom.yaml --name test-custom --weights yolov7-e6e.pt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Requirement already satisfied: ipywidgets in /home/defenge/.local/lib/python3.10/site-packages (8.1.2)\n",
+      "Requirement already satisfied: jupyterlab-widgets~=3.0.10 in /home/defenge/.local/lib/python3.10/site-packages (from ipywidgets) (3.0.10)\n",
+      "Requirement already satisfied: widgetsnbextension~=4.0.10 in /home/defenge/.local/lib/python3.10/site-packages (from ipywidgets) (4.0.10)\n",
+      "Requirement already satisfied: ipython>=6.1.0 in /home/defenge/.local/lib/python3.10/site-packages (from ipywidgets) (8.22.2)\n",
+      "Requirement already satisfied: traitlets>=4.3.1 in /home/defenge/.local/lib/python3.10/site-packages (from ipywidgets) (5.14.2)\n",
+      "Requirement already satisfied: comm>=0.1.3 in /home/defenge/.local/lib/python3.10/site-packages (from ipywidgets) (0.2.2)\n",
+      "Requirement already satisfied: decorator in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (5.1.1)\n",
+      "Requirement already satisfied: stack-data in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (0.6.3)\n",
+      "Requirement already satisfied: jedi>=0.16 in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (0.19.1)\n",
+      "Requirement already satisfied: pexpect>4.3 in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (4.9.0)\n",
+      "Requirement already satisfied: pygments>=2.4.0 in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (2.17.2)\n",
+      "Requirement already satisfied: prompt-toolkit<3.1.0,>=3.0.41 in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (3.0.43)\n",
+      "Requirement already satisfied: exceptiongroup in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (1.2.0)\n",
+      "Requirement already satisfied: matplotlib-inline in /home/defenge/.local/lib/python3.10/site-packages (from ipython>=6.1.0->ipywidgets) (0.1.6)\n",
+      "Requirement already satisfied: parso<0.9.0,>=0.8.3 in /home/defenge/.local/lib/python3.10/site-packages (from jedi>=0.16->ipython>=6.1.0->ipywidgets) (0.8.3)\n",
+      "Requirement already satisfied: ptyprocess>=0.5 in /home/defenge/.local/lib/python3.10/site-packages (from pexpect>4.3->ipython>=6.1.0->ipywidgets) (0.7.0)\n",
+      "Requirement already satisfied: wcwidth in /home/defenge/.local/lib/python3.10/site-packages (from prompt-toolkit<3.1.0,>=3.0.41->ipython>=6.1.0->ipywidgets) (0.2.13)\n",
+      "Requirement already satisfied: pure-eval in /home/defenge/.local/lib/python3.10/site-packages (from stack-data->ipython>=6.1.0->ipywidgets) (0.2.2)\n",
+      "Requirement already satisfied: executing>=1.2.0 in /home/defenge/.local/lib/python3.10/site-packages (from stack-data->ipython>=6.1.0->ipywidgets) (2.0.1)\n",
+      "Requirement already satisfied: asttokens>=2.1.0 in /home/defenge/.local/lib/python3.10/site-packages (from stack-data->ipython>=6.1.0->ipywidgets) (2.4.1)\n",
+      "Requirement already satisfied: six>=1.12.0 in /usr/lib/python3/dist-packages (from asttokens>=2.1.0->stack-data->ipython>=6.1.0->ipywidgets) (1.16.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install ipywidgets "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#model = torch.load('load_the_model_here_to_test')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#img = ''\n",
+    "#results = model(img)\n",
+    "#results.print()\n",
+    "#%matplotlib inline\n",
+    "#plt.imshow(np.squeeze(results.render()))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/custom-data.yaml.dist b/custom-data.yaml.dist
new file mode 100644
index 0000000..6a49a7e
--- /dev/null
+++ b/custom-data.yaml.dist
@@ -0,0 +1,8 @@
+# train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
+train: ./data/train
+val: ./data/val  
+# number of classes
+nc: 2
+
+# class names
+names: [ 'plants', 'void' ]
diff --git a/test.ipynb b/test.ipynb
deleted file mode 100644
index de4d032..0000000
--- a/test.ipynb
+++ /dev/null
@@ -1,189 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Requirement already satisfied: torch in ./.venv/lib/python3.12/site-packages (2.2.2)\n",
-      "Requirement already satisfied: torchvision in ./.venv/lib/python3.12/site-packages (0.17.2)\n",
-      "Collecting torchaudio\n",
-      "  Using cached torchaudio-2.2.2-cp312-cp312-macosx_11_0_arm64.whl.metadata (6.4 kB)\n",
-      "Requirement already satisfied: filelock in ./.venv/lib/python3.12/site-packages (from torch) (3.13.3)\n",
-      "Requirement already satisfied: typing-extensions>=4.8.0 in ./.venv/lib/python3.12/site-packages (from torch) (4.10.0)\n",
-      "Requirement already satisfied: sympy in ./.venv/lib/python3.12/site-packages (from torch) (1.12)\n",
-      "Requirement already satisfied: networkx in ./.venv/lib/python3.12/site-packages (from torch) (3.2.1)\n",
-      "Requirement already satisfied: jinja2 in ./.venv/lib/python3.12/site-packages (from torch) (3.1.3)\n",
-      "Requirement already satisfied: fsspec in ./.venv/lib/python3.12/site-packages (from torch) (2024.3.1)\n",
-      "Requirement already satisfied: numpy in ./.venv/lib/python3.12/site-packages (from torchvision) (1.26.4)\n",
-      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in ./.venv/lib/python3.12/site-packages (from torchvision) (10.2.0)\n",
-      "Requirement already satisfied: MarkupSafe>=2.0 in ./.venv/lib/python3.12/site-packages (from jinja2->torch) (2.1.5)\n",
-      "Requirement already satisfied: mpmath>=0.19 in ./.venv/lib/python3.12/site-packages (from sympy->torch) (1.3.0)\n",
-      "Using cached torchaudio-2.2.2-cp312-cp312-macosx_11_0_arm64.whl (1.8 MB)\n",
-      "Installing collected packages: torchaudio\n",
-      "Successfully installed torchaudio-2.2.2\n"
-     ]
-    }
-   ],
-   "source": [
-    "!pip install torch torchvision torchaudio"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "fatal: il percorso di destinazione 'yolov5' esiste già e non è una directory vuota.\n"
-     ]
-    }
-   ],
-   "source": [
-    "!git clone git@github.com:ultralytics/yolov5.git"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!cd yolov5 && pip install -qr requirements.txt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch \n",
-    "from matplotlib import pyplot as plt\n",
-    "import numpy as np\n",
-    "import cv2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[31mERROR: Could not find a version that satisfies the requirement ipwidgets (from versions: none)\u001b[0m\u001b[31m\n",
-      "\u001b[0m\u001b[31mERROR: No matching distribution found for ipwidgets\u001b[0m\u001b[31m\n",
-      "\u001b[0m"
-     ]
-    }
-   ],
-   "source": [
-    "!pip install ipwidgets "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "YOLOv5 🚀 v7.0-295-gac6c4383 Python-3.12.2 torch-2.2.2 CPU\n",
-      "\n",
-      "Downloading https://github.com/ultralytics/yolov5/releases/download/v7.0/yolov5s.pt to yolov5s.pt...\n",
-      "100%|██████████| 14.1M/14.1M [00:03<00:00, 3.91MB/s]\n",
-      "\n",
-      "Fusing layers... \n",
-      "YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients\n",
-      "Adding AutoShape... \n"
-     ]
-    }
-   ],
-   "source": [
-    "model = torch.hub.load('yolov5', 'yolov5s', source='local')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "img = '/Users/damianocoppola/dev/EurobotVision/ img/IMG_6614.jpg'\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "image 1/1: 4032x3024 1 potted plant, 1 vase\n",
-      "Speed: 152.8ms pre-process, 129.5ms inference, 1.0ms NMS per image at shape (1, 3, 640, 480)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.image.AxesImage at 0x29da914c0>"
-      ]
-     },
-     "execution_count": 63,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "results = model(img)\n",
-    "results.print()\n",
-    "%matplotlib inline\n",
-    "plt.imshow(np.squeeze(results.render()))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/yolov7-e6e-custom.yaml.dist b/yolov7-e6e-custom.yaml.dist
new file mode 100644
index 0000000..6d5befb
--- /dev/null
+++ b/yolov7-e6e-custom.yaml.dist
@@ -0,0 +1,306 @@
+# parameters
+nc: 2  # number of classes
+depth_multiple: 1.0  # model depth multiple
+width_multiple: 1.0  # layer channel multiple
+
+# anchors
+anchors:
+  - [ 19,27,  44,40,  38,94 ]  # P3/8
+  - [ 96,68,  86,152,  180,137 ]  # P4/16
+  - [ 140,301,  303,264,  238,542 ]  # P5/32
+  - [ 436,615,  739,380,  925,792 ]  # P6/64
+
+# yolov7 backbone
+backbone:
+  # [from, number, module, args],
+  [[-1, 1, ReOrg, []],  # 0
+   [-1, 1, Conv, [80, 3, 1]],  # 1-P1/2
+   
+   [-1, 1, DownC, [160]],  # 2-P2/4  
+   [-1, 1, Conv, [64, 1, 1]],
+   [-2, 1, Conv, [64, 1, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [160, 1, 1]],  # 12
+   [-11, 1, Conv, [64, 1, 1]],
+   [-12, 1, Conv, [64, 1, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [160, 1, 1]],  # 22
+   [[-1, -11], 1, Shortcut, [1]],  # 23
+         
+   [-1, 1, DownC, [320]],  # 24-P3/8  
+   [-1, 1, Conv, [128, 1, 1]],
+   [-2, 1, Conv, [128, 1, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [320, 1, 1]],  # 34
+   [-11, 1, Conv, [128, 1, 1]],
+   [-12, 1, Conv, [128, 1, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [320, 1, 1]],  # 44
+   [[-1, -11], 1, Shortcut, [1]],  # 45
+         
+   [-1, 1, DownC, [640]],  # 46-P4/16  
+   [-1, 1, Conv, [256, 1, 1]],
+   [-2, 1, Conv, [256, 1, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [640, 1, 1]],  # 56
+   [-11, 1, Conv, [256, 1, 1]],
+   [-12, 1, Conv, [256, 1, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [640, 1, 1]],  # 66
+   [[-1, -11], 1, Shortcut, [1]],  # 67
+         
+   [-1, 1, DownC, [960]],  # 68-P5/32  
+   [-1, 1, Conv, [384, 1, 1]],
+   [-2, 1, Conv, [384, 1, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [960, 1, 1]],  # 78
+   [-11, 1, Conv, [384, 1, 1]],
+   [-12, 1, Conv, [384, 1, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [-1, 1, Conv, [384, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [960, 1, 1]],  # 88
+   [[-1, -11], 1, Shortcut, [1]],  # 89
+         
+   [-1, 1, DownC, [1280]],  # 90-P6/64  
+   [-1, 1, Conv, [512, 1, 1]],
+   [-2, 1, Conv, [512, 1, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [1280, 1, 1]],  # 100 
+   [-11, 1, Conv, [512, 1, 1]],
+   [-12, 1, Conv, [512, 1, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [-1, 1, Conv, [512, 3, 1]],
+   [[-1, -3, -5, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [1280, 1, 1]],  # 110
+   [[-1, -11], 1, Shortcut, [1]],  # 111 
+  ]
+
+# yolov7 head
+head:
+  [[-1, 1, SPPCSPC, [640]], # 112
+  
+   [-1, 1, Conv, [480, 1, 1]],
+   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+   [89, 1, Conv, [480, 1, 1]], # route backbone P5
+   [[-1, -2], 1, Concat, [1]],
+   
+   [-1, 1, Conv, [384, 1, 1]],
+   [-2, 1, Conv, [384, 1, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [480, 1, 1]], # 126
+   [-11, 1, Conv, [384, 1, 1]],
+   [-12, 1, Conv, [384, 1, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [480, 1, 1]], # 136
+   [[-1, -11], 1, Shortcut, [1]],  # 137
+  
+   [-1, 1, Conv, [320, 1, 1]],
+   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+   [67, 1, Conv, [320, 1, 1]], # route backbone P4
+   [[-1, -2], 1, Concat, [1]],
+   
+   [-1, 1, Conv, [256, 1, 1]],
+   [-2, 1, Conv, [256, 1, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [320, 1, 1]], # 151
+   [-11, 1, Conv, [256, 1, 1]],
+   [-12, 1, Conv, [256, 1, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [320, 1, 1]], # 161
+   [[-1, -11], 1, Shortcut, [1]],  # 162
+   
+   [-1, 1, Conv, [160, 1, 1]],
+   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+   [45, 1, Conv, [160, 1, 1]], # route backbone P3
+   [[-1, -2], 1, Concat, [1]],
+   
+   [-1, 1, Conv, [128, 1, 1]],
+   [-2, 1, Conv, [128, 1, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [160, 1, 1]], # 176
+   [-11, 1, Conv, [128, 1, 1]],
+   [-12, 1, Conv, [128, 1, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [-1, 1, Conv, [64, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [160, 1, 1]], # 186
+   [[-1, -11], 1, Shortcut, [1]],  # 187
+      
+   [-1, 1, DownC, [320]],
+   [[-1, 162], 1, Concat, [1]],
+   
+   [-1, 1, Conv, [256, 1, 1]],
+   [-2, 1, Conv, [256, 1, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [320, 1, 1]], # 199
+   [-11, 1, Conv, [256, 1, 1]],
+   [-12, 1, Conv, [256, 1, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [-1, 1, Conv, [128, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [320, 1, 1]], # 209
+   [[-1, -11], 1, Shortcut, [1]],  # 210
+      
+   [-1, 1, DownC, [480]],
+   [[-1, 137], 1, Concat, [1]],
+   
+   [-1, 1, Conv, [384, 1, 1]],
+   [-2, 1, Conv, [384, 1, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [480, 1, 1]], # 222
+   [-11, 1, Conv, [384, 1, 1]],
+   [-12, 1, Conv, [384, 1, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [-1, 1, Conv, [192, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [480, 1, 1]], # 232
+   [[-1, -11], 1, Shortcut, [1]],  # 233
+      
+   [-1, 1, DownC, [640]],
+   [[-1, 112], 1, Concat, [1]],
+   
+   [-1, 1, Conv, [512, 1, 1]],
+   [-2, 1, Conv, [512, 1, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [640, 1, 1]], # 245
+   [-11, 1, Conv, [512, 1, 1]],
+   [-12, 1, Conv, [512, 1, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [-1, 1, Conv, [256, 3, 1]],
+   [[-1, -2, -3, -4, -5, -6, -7, -8], 1, Concat, [1]],
+   [-1, 1, Conv, [640, 1, 1]], # 255
+   [[-1, -11], 1, Shortcut, [1]],  # 256
+   
+   [187, 1, Conv, [320, 3, 1]],
+   [210, 1, Conv, [640, 3, 1]],
+   [233, 1, Conv, [960, 3, 1]],
+   [256, 1, Conv, [1280, 3, 1]],
+   
+   [186, 1, Conv, [320, 3, 1]],
+   [161, 1, Conv, [640, 3, 1]],
+   [136, 1, Conv, [960, 3, 1]],
+   [112, 1, Conv, [1280, 3, 1]],
+
+   [[257,258,259,260,261,262,263,264], 1, IAuxDetect, [nc, anchors]],   # Detect(P3, P4, P5, P6)
+  ]