MixUp strategy in Computer Vision

Introduction

MixUp helps models learn better by mixing two images and their labels. This makes the model more confident and less likely to guess wrong.

When training image classifiers to improve accuracy.

To reduce overfitting on small datasets.

When you want your model to be more robust to noisy or unclear images.

To help the model generalize better to new, unseen images.

Syntax

Computer Vision

def mixup_data(x, y, alpha=1.0):
    '''Returns mixed inputs, pairs of targets, and lambda'''
    if alpha > 0:
        lam = np.random.beta(alpha, alpha)
    else:
        lam = 1
    batch_size = x.shape[0]
    index = np.random.permutation(batch_size)
    mixed_x = lam * x + (1 - lam) * x[index]
    y_a, y_b = y, y[index]
    return mixed_x, y_a, y_b, lam

The function takes a batch of images x and labels y.

It mixes images and labels using a random weight lam from a Beta distribution.

Examples

This mixes the batch with alpha=0.4 controlling the strength of mixing.

Computer Vision

mixed_x, y_a, y_b, lam = mixup_data(images, labels, alpha=0.4)

With alpha=0, no mixing happens; original data is returned.

Computer Vision

mixed_x, y_a, y_b, lam = mixup_data(images, labels, alpha=0)

Sample Model

This example loads a small image dataset, applies MixUp to one batch, trains a simple model on it, and then evaluates the model.

Computer Vision

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical

# Load digits dataset
digits = load_digits()
X = digits.images
y = digits.target

# Normalize images
X = X / 16.0

# One-hot encode labels
y = to_categorical(y, num_classes=10)

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# MixUp function
def mixup_data(x, y, alpha=0.2):
    if alpha > 0:
        lam = np.random.beta(alpha, alpha)
    else:
        lam = 1
    batch_size = x.shape[0]
    index = np.random.permutation(batch_size)
    mixed_x = lam * x + (1 - lam) * x[index]
    y_a, y_b = y, y[index]
    return mixed_x, y_a, y_b, lam

# Build simple model
model = Sequential([
    Flatten(input_shape=(8,8)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Prepare one batch with MixUp
batch_size = 32
x_batch = X_train[:batch_size]
y_batch = y_train[:batch_size]
mixed_x, y_a, y_b, lam = mixup_data(x_batch, y_batch, alpha=0.2)
mixed_y = lam * y_a + (1 - lam) * y_b

# Train on mixed batch
model.train_on_batch(mixed_x, mixed_y)  # Using mixed soft labels

# Evaluate on test data
loss, acc = model.evaluate(X_test, y_test, verbose=0)
print(f"Test loss: {loss:.4f}")
print(f"Test accuracy: {acc:.4f}")

Important Notes

MixUp works best when applied during training, mixing batches on the fly.

The labels are mixed the same way as images, so the loss function must handle soft labels.

MixUp can slow training a bit but usually improves final accuracy.

Summary

MixUp blends images and labels to help models learn smoother decision boundaries.

It is useful to reduce overfitting and improve robustness.

MixUp requires adjusting the loss to handle mixed labels.