TRAINING

[project]

name = "your_project_name"

version = "0.1.0"

description = "Add your description here"

readme = "README.md"

requires-python = ">=3.12"

dependencies = [ "ultralytics>=8.4.18", ]

Then click “Save As”:

• Go to your working directory (the folder where you extracted your Roboflow .zip archive)

• In “Save as type”, select “All files (.)”

• In “File name”, enter pyproject.toml (this name must be exact and cannot be changed)

• Finally, save the file.

Important point: make sure that “.toml” is indeed the file extension. To do this, you first need to display file extensions:

Go to View → Show (at the bottom) → File name extensions, then check that the file name ends with “.toml”.

PYTHON CODE

Now, create a Python file in the same folder, using the same method as before:

• Open a text editor

• Write the three lines below (you can copy-paste them)

• Click “Save As”

• Set the extension to .py (same process as before, but instead of .toml, use .py)

The lines in question:

from ultralytics import YOLO

model = YOLO(“yolo26n.pt”)

results = model.train(data=”data.yaml”, epochs=100, imgsz=640)

EXPLANATIONS

• • • model = YOLO(“yolo26n.pt”)

This line is used to specify which model you want to train. In this case, we can see that a “nano” model is being used because there is an “n” after “yolov26”. YOLO provides five model sizes: nano (“n”), small (“s”), medium (“m”), large (“l”), and extra-large (“x”). Intuitively, smaller models are faster but less accurate, while larger models require more computation time but are more robust and powerful.

These models are pre-trained to save both training time and to improve performance.

(For advanced AI users, YOLO also allows you to build your own neural network by manually defining each layer in a .yaml file — see the official documentation)

• • • results = model.train(data=”data.yaml”, epochs=100, imgsz=640)

• data: set this to the name of your .yaml file provided in the Roboflow .zip export.
• epochs: epochs correspond to the number of training cycles. To put it simply, the model goes through all images in the training set and updates its parameters. The number of epochs defines how many times it will iterate over the entire dataset.
• imgsz: this refers to the size of your images, so you should use the same value you selected in Roboflow. The default value is 640, so if you want larger or smaller images, you must explicitly specify it; otherwise, images will be resized (downscaled or upscaled) automatically.

To give you some typical parameter benchmarks:

• model: yolo26n.pt (Nano version for speed) or yolo26s.pt (Small version for accuracy).
• epochs: 100 is the default value. For small datasets, you can increase it to 300.
• imgsz: 640 is the default value. Use 320 for faster processing or 1280 to detect very small objects.
• batch: -1 for automatic adjustment based on your VRAM, or 16 by default.
• device: 0 to use your first GPU, or cpu if you don’t have one.

Regarding model size, it is recommended to switch to a larger model than yolo26s (such as the m, l, or x versions) in the following situations:

• Need for maximum accuracy: If your current model suffers from underfitting and fails to capture complex details, a larger model offers greater learning capacity.
• Dataset complexity: For large datasets (> 50,000 images) with many classes or dense scenes, Medium or Large models perform better.
• Difficult objects: If you are working with high-resolution images containing very small objects (such as aerial or medical imaging), the increased capacity helps reduce detection errors.
• Sufficient hardware resources: Use a larger model if deployment is on a server (such as the ISDM MESO cluster) or a powerful GPU rather than on mobile or CPU.