Add and Prepare Data

Create the Dataset#

Open Annotate in the sidebar and click New Dataset. The dialog asks for a source, a name, the task type, an optional license, face blurring, and visibility:

Decision rule: upload a copy for this course. Cloud and On Premise datasets keep pixels outside Platform, so smart annotation, Clustering, cloning, and version snapshots are unavailable for them.

The task type decides which tools and models appear. Platform supports all seven Ultralytics YOLO tasks:

Worked Example: Check the Dataset Before Upload#

Platform accepts JPEG, PNG, WebP, BMP, TIFF, HEIC, AVIF, JP2, DNG, and MPO images up to 50 MB and at least 28 px on the short side, and reads YOLO, COCO, LabelMe, Ultralytics or Labelbox NDJSON, and semantic PNG mask labels. Pascal VOC XML is detected but not imported. This script checks a local YOLO dataset against those rules, here the public medical pills dataset:

from collections import Counter
from pathlib import Path

from PIL import Image

from ultralytics.data.utils import check_det_dataset

ACCEPTED = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff", ".heic", ".avif", ".jp2", ".dng", ".mpo"}
data = check_det_dataset("medical-pills.yaml")  # your local dataset YAML
root = Path(data["path"])

problems = Counter()
for split in ("train", "val", "test"):
    if not data.get(split):
        continue
    files = [p for p in Path(data[split]).rglob("*") if p.is_file()]
    images = [p for p in files if p.suffix.lower() in ACCEPTED]
    labeled = 0
    for img in images:
        label = Path(str(img).replace("images", "labels")).with_suffix(".txt")
        labeled += label.exists() and label.stat().st_size > 0
        if min(Image.open(img).size) < 28:
            problems["under 28 px (rejected)"] += 1
        if img.stat().st_size > 50 * 1024**2:
            problems["over 50 MB (rejected)"] += 1
    problems["unsupported files (skipped)"] += len(files) - len(images)
    print(f"{split:<5} {len(images):>4} images, {labeled:>4} labeled, {len(images) - labeled:>3} background")
problems["Pascal VOC .xml labels (not imported)"] += len(list(root.rglob("*.xml")))
print("classes:", data["names"])
print("problems:", {k: v for k, v in problems.items() if v} or "none")

train   92 images,   92 labeled,   0 background
val     23 images,   23 labeled,   0 background
classes: {0: 'pill'}
problems: none

What the output tells you:

• Per-split counts. Images inside train/, val/, and test/ folders keep that split on upload, so these numbers are what Platform will show. A missing val line means Platform will invent a random validation split for you (see the pitfall below).
• Background images (no label file) are fine in moderation; they teach the model what "nothing here" looks like. Hundreds of them usually mean labels failed to export.
• problems: none means every image will process. Any count here is a file that will land in the Errors tab or never arrive at all.

Zip the dataset folder with its data.yaml and drag the archive onto the gallery. Platform detects the format automatically, stores identical images once, and asks whether to Skip, Keep Both, or Replace when an upload collides with images already in the dataset.

Worked Example: Sample Video Before Platform Does#

Platform samples each video at 1 frame per second and keeps at most 100 frames, widening the interval for clips longer than 100 seconds:

That suits a quick look and fails most real projects: a 30-minute shift recording becomes 100 frames, mostly of an empty aisle. Sample long footage yourself and upload the frames:

For uniform sampling, FFmpeg is enough:

mkdir -p frames
ffmpeg -i source.mp4 -vf fps=1 frames/%06d.jpg

For event-driven sampling, let a pretrained Ultralytics YOLO model keep only frames that contain your object:

from pathlib import Path

import cv2

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # or your latest fine-tune
out = Path("frames")
out.mkdir(exist_ok=True)

source = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"
seen = kept = 0
for i, result in enumerate(model.predict(source, stream=True, vid_stride=5, classes=[0], conf=0.5, verbose=False)):
    seen += 1
    if len(result.boxes):  # keep only frames where a person was detected
        cv2.imwrite(str(out / f"frame_{i:05d}.jpg"), result.orig_img)
        kept += 1
print(f"Kept {kept} of {seen} sampled frames")

Kept 12 of 12 sampled frames

vid_stride=5 looks at every fifth frame, classes=[0] restricts detection to people, and conf=0.5 ignores weak guesses. This busy demo clip has people in every sampled frame; on a recording of a mostly empty scene the kept fraction drops sharply, and so does your labeling bill. Raise vid_stride until neighboring kept frames stop looking identical.

Read Platform's Processing Signals#

After upload, Platform validates, normalizes (images over 4,096 px are resized), thumbnails, parses labels, and computes statistics. Check three places:

• Errors tab appears only when files fail: corrupted files, unsupported formats, images under 28 px, or CMYK and indexed color modes, each with a fix hint. Re-export or re-upload them.
• Charts tab shows split distribution, top classes, image dimensions, file sizes, annotation locations, box sizes, and objects per image. Look for a class that barely appears, tiny images, or boxes clustered in one corner.
• The badge in the dataset header reads Ready once processing has finished and the dataset has at least one train image, one val or test image, and one labeled image. Click Not Ready to see which condition is missing.

Start From a Public Dataset#

No data yet? The Explore page lists official and community datasets. Clone Dataset copies images, annotations, and classes into your workspace, counts against your storage, and keeps the source's public visibility by default, so flip the switch in the dialog if you'll add anything sensitive.

Pitfalls#