# How to Configure Data Augmentation Techniques in YOLOv5 Training

> Learn to configure YOLOv5 data augmentation techniques by editing hyper-parameter YAML files and using the augment flag. Improve your model's performance effectively.

- Repository: [Ultralytics/yolov5](https://github.com/ultralytics/yolov5)
- Tags: how-to-guide
- Published: 2026-03-06

---

**You configure data augmentation in YOLOv5 by editing probability values in a hyper-parameter YAML file (e.g., [`data/hyps/hyp.scratch-med.yaml`](https://github.com/ultralytics/yolov5/blob/main/data/hyps/hyp.scratch-med.yaml)) and enabling the `--augment` flag during training, which triggers the augmentation pipeline in [`utils/dataloaders.py`](https://github.com/ultralytics/yolov5/blob/main/utils/dataloaders.py).**

The Ultralytics YOLOv5 repository provides a flexible, YAML-driven system for controlling how training images are transformed. By adjusting probabilities and strength coefficients, you can tune the balance between regularization and fidelity without modifying Python source code. This guide explains exactly where these settings live, how the pipeline applies them, and how to customize them for your dataset.

## Where YOLOv5 Stores Augmentation Settings

### Hyper-parameter YAML Files

Augmentation probabilities and strength coefficients are stored in the `data/hyps/` directory. Files such as [`hyp.scratch-med.yaml`](https://github.com/ultralytics/yolov5/blob/main/hyp.scratch-med.yaml) expose tunable variables that the dataloader consumes at runtime:

```yaml
hsv_h: 0.015          # hue jitter fraction (0-1)

hsv_s: 0.7            # saturation jitter fraction

hsv_v: 0.4            # value jitter fraction

mosaic: 1.0           # mosaic probability (0-1)

mixup: 0.1            # mixup probability

copy_paste: 0.0       # copy-paste probability (segmentation only)

```

When you launch training with `--hyp data/hyps/custom.yaml`, YOLOv5 loads these values into the `hyp` dictionary that controls every stochastic transform.

### The --augment Flag

The `--augment` command-line argument (defaulting to `True` in [`train.py`](https://github.com/ultralytics/yolov5/blob/main/train.py)) sets the `augment` parameter when constructing the `LoadImagesAndLabels` dataloader in [`utils/dataloaders.py`](https://github.com/ultralytics/yolov5/blob/main/utils/dataloaders.py). Without this flag set to `True`, the pipeline skips all random augmentations and returns only letterboxed images.

## Core Augmentation Techniques in YOLOv5

### Mosaic and Mosaic9 Compositing

**Mosaic** combines four training images into a single composite, forcing the model to learn object detection across non-natural boundaries. In [`utils/dataloaders.py`](https://github.com/ultralytics/yolov5/blob/main/utils/dataloaders.py) (lines 771–777), the dataloader checks the hyper-parameter probability before invoking `load_mosaic()`:

```python
if mosaic := self.mosaic and random.random() < hyp["mosaic"]:
    img, labels = self.load_mosaic(index)

```

**Mosaic9** extends this to nine images (lines 931–939) and is controlled by the `mosaic9` key in your YAML file.

### MixUp and Copy-Paste

**MixUp** blends two images with random weighting to improve generalization. The dataloader applies it immediately after Mosaic when `random.random() < hyp["mixup"]` (lines 777–782):

```python
if random.random() < hyp["mixup"]:
    img, labels = mixup(img, labels, *self.load_mosaic(random.randint(0, len(self.labels) - 1)))

```

**Copy-Paste** (segmentation only) copies object masks from one image to another. It resides in [`utils/segment/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/segment/augmentations.py) (lines 236–247) and triggers when `hyp["copy_paste"]` exceeds a random threshold.

### HSV Color Jitter and Geometric Transforms

**HSV augmentation** shifts hue, saturation, and value according to the `hsv_h`, `hsv_s`, and `hsv_v` coefficients. The implementation in [`utils/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/augmentations.py) (lines 73–86) converts the image to HSV space, applies random gains, and clips the result.

**Random perspective** (rotation, scale, shear, translation) is handled by `random_perspective()` in [`utils/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/augmentations.py) (lines 152–192). The dataloader invokes this whenever `self.augment` is `True`, using degrees and translation values from the hyper-parameter dictionary.

## Customizing Your Augmentation Pipeline

### Editing the Hyper-parameter YAML

Create a custom file (e.g., [`data/hyps/custom.yaml`](https://github.com/ultralytics/yolov5/blob/main/data/hyps/custom.yaml)) and adjust probabilities to suit your dataset. Lower `mosaic` for small objects that get lost in compositing, or increase `hsv_h` for datasets with variable lighting.

### Command-line Training Example

Pass your custom YAML and ensure augmentation is active:

```bash
python train.py \
  --data coco.yaml \
  --cfg yolov5s.yaml \
  --weights '' \
  --batch 16 \
  --epochs 100 \
  --img 640 \
  --hyp data/hyps/custom.yaml \
  --augment

```

### Python API Usage

For programmatic control, load the YAML and pass it to `create_dataloader`:

```python
from utils.dataloaders import create_dataloader
import yaml

# Load custom hyperparameters

with open('data/hyps/custom.yaml') as f:
    hyp = yaml.safe_load(f)

# Build loader with augmentation enabled

train_loader, dataset = create_dataloader(
    path='train/images',
    imgsz=640,
    batch_size=16,
    stride=32,
    hyp=hyp,               # augmentation probabilities

    augment=True,          # enable pipeline

    cache=False,
    rect=False,
    workers=8,
    prefix='train: '
)

```

## Debugging and Manual Augmentation Testing

To verify augmentation behavior without running full training, invoke individual functions from [`utils/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/augmentations.py):

```python
import cv2
import numpy as np
from utils.augmentations import augment_hsv, random_perspective

# Load a sample image

img = cv2.imread('sample.jpg')  # BGR format

# Test HSV jitter with default training gains

img_hsv = augment_hsv(img.copy(), hgain=0.015, sgain=0.7, vgain=0.4)

# Test geometric augmentation

labels = np.array([[0, 0.5, 0.5, 0.2, 0.2]])  # [class, x_center, y_center, w, h]

img_geo, labels_geo = random_perspective(
    img_hsv,
    targets=labels,
    degrees=0.0,
    translate=0.1,
    scale=0.9,
    shear=0.0,
    perspective=0.0,
    border=(0, 0)
)

cv2.imwrite('augmented_sample.jpg', img_geo)

```

## Summary

- **Hyper-parameter YAML files** (`data/hyps/*.yaml`) control augmentation probabilities and strengths such as `mosaic`, `mixup`, `hsv_h`, and `copy_paste`.
- **The `--augment` flag** in [`train.py`](https://github.com/ultralytics/yolov5/blob/main/train.py) enables the augmentation pipeline in [`utils/dataloaders.py`](https://github.com/ultralytics/yolov5/blob/main/utils/dataloaders.py), specifically within the `LoadImagesAndLabels` class.
- **Mosaic, MixUp, and Copy-Paste** are applied stochastically based on YAML probabilities in [`utils/dataloaders.py`](https://github.com/ultralytics/yolov5/blob/main/utils/dataloaders.py) (lines 771–782 and 931–939).
- **HSV jitter and geometric transforms** (rotation, scale, shear) are implemented in [`utils/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/augmentations.py) (lines 73–86 and 152–192) and invoked when `augment=True`.
- **Customization** involves editing YAML values and passing the file via `--hyp`, or programmatically setting `augment=True` and supplying a custom `hyp` dictionary to `create_dataloader`.

## Frequently Asked Questions

### What is the default augmentation setting in YOLOv5?

By default, [`train.py`](https://github.com/ultralytics/yolov5/blob/main/train.py) sets `--augment` to `True`, which enables the full augmentation pipeline defined in the hyper-parameter YAML file (usually [`hyp.scratch-low.yaml`](https://github.com/ultralytics/yolov5/blob/main/hyp.scratch-low.yaml) or [`hyp.scratch-med.yaml`](https://github.com/ultralytics/yolov5/blob/main/hyp.scratch-med.yaml)). This includes Mosaic (probability 1.0), HSV jitter, and random geometric transforms.

### How do I disable Mosaic augmentation in YOLOv5?

To disable Mosaic, set `mosaic: 0.0` in your custom hyper-parameter YAML file and pass it to training with `--hyp custom.yaml`. Alternatively, you can disable all augmentations by omitting the `--augment` flag or setting `augment=False` when constructing the dataloader programmatically.

### Can I use Copy-Paste augmentation for object detection (not segmentation)?

No. According to the source code in [`utils/segment/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/segment/augmentations.py) (lines 236–247), Copy-Paste is implemented only for segmentation masks. It requires polygonal annotation data and is controlled by the `copy_paste` hyper-parameter, which defaults to `0.0` in standard detection configs.

### Where are the augmentation functions implemented in the YOLOv5 source code?

Core image transformations reside in [`utils/augmentations.py`](https://github.com/ultralytics/yolov5/blob/main/utils/augmentations.py), including `augment_hsv()` (lines 73–86) for color jitter and `random_perspective()` (lines 152–192) for geometric warping. The dataloader logic that orchestrates Mosaic, MixUp, and Copy-Paste is located in [`utils/dataloaders.py`](https://github.com/ultralytics/yolov5/blob/main/utils/dataloaders.py) within the `LoadImagesAndLabels` class (lines 771–782 and 931–939).