📚TheoryIntermediate

Data Augmentation Theory

Key Points

•
Data augmentation expands the training distribution by applying label-preserving transformations to inputs, which lowers overfitting and improves generalization.
•
The theory relies on invariances and symmetries: if a transformation does not change the label, we can legally create more training samples by transforming inputs.
•
Augmentation can be formalized as vicinal risk minimization (VRM), which minimizes loss over a smoothed distribution around each sample instead of only the empirical points.
•
Group theory gives a clean view: transformations form a group acting on data, and averaging over the group projects models toward invariance.
•
Mixup and noise injection are augmentation methods that create new samples through convex combinations or small perturbations, often improving margins and robustness.
•
Test-time augmentation (TTA) averages predictions on multiple transformed versions of the same input to reduce variance.
•
Augmentation increases computation roughly in proportion to the number of transformations per sample, but usually pays off by reducing generalization error.
•
Poorly chosen transforms (e.g., ones that break labels) can harm accuracy, so alignment with task-specific invariances is crucial.

Prerequisites

→Basic probability and expectations — Augmentation is formalized by expectations over transformation distributions and vicinal risk.
→Supervised learning and loss functions — Understanding empirical risk, true risk, and how loss is computed is essential.
→Linear algebra and vector operations — Mixup and noise injection operate on vectors and matrices.
→Group theory (introductory) — Invariances and symmetries are naturally expressed with group actions.
→Random number generation in C++ — Stochastic transforms require sampling from Bernoulli, Normal, Gamma/Beta.
→Image representation and OpenCV basics — Implementing vision augmentations needs image matrices and geometric warps.
→Overfitting and regularization — Augmentation mainly combats overfitting and improves generalization.
→Optimization and training loops — Knowing where to insert augmentation (data loader vs. model) is important.
→Numerical stability — Mixup and soft labels require careful handling to avoid NaNs and precision loss.
→Evaluation protocols and leakage prevention — Augmentation must not contaminate validation/test splits.

Detailed Explanation

Tap terms for definitions

01Overview

Data augmentation is the practice of expanding the training distribution by applying transformations to inputs that preserve (or intentionally reshape in a controlled way) the relationship between inputs and labels. Intuitively, if rotating a cat image still shows a cat, then rotated versions are valid extra training examples. This combats overfitting by exposing the model to variations it will encounter at test time and by smoothing the empirical distribution concentrated at the original samples. Theoretically, augmentation relates to vicinal risk minimization (VRM): instead of minimizing loss only on observed points, we minimize expected loss over a vicinity around each sample, defined by a transformation distribution. When augmentations reflect true invariances or symmetries of the task, training with them reduces the effective hypothesis space and often tightens generalization bounds. Beyond classic geometric transforms for images (flip, rotate, crop), modern methods include stochastic noise injection, color jitter, Cutout, Mixup, and domain-specific edits. Test-time augmentation (TTA) further stabilizes predictions by averaging model outputs over multiple transformed inputs. In practice, augmentation is a simple, high-impact regularizer that requires no change to model parameters and can be implemented on-the-fly during training or precomputed offline, trading storage for speed.

02Intuition & Analogies

Imagine teaching someone to recognize your handwriting. If they only see each letter exactly once, they might memorize quirks rather than learn the true idea of each letter. If you show them the letter written slightly bigger, smaller, tilted, or with a different pen, they start understanding what really defines that letter. Data augmentation does the same for machine learning: it shows the model many harmless variations of the same underlying concept so the model learns the essence, not the noise. Another analogy is learning to recognize a song. Even if it’s played faster, in a different key, or on another instrument, you still know it’s the same tune. If we know which changes keep identity intact (key shift for a trained musician; rotation for objects; synonym for certain text tasks), we can expand our training set cheaply. Think of transformations as a dial you turn to explore the neighborhood around each training sample. Turning it a little (small noise) teaches local smoothness; turning it in structured ways (flip, rotate) teaches symmetry; combining two songs softly (Mixup) teaches the model to behave linearly between examples. Over time, exposing the model to these safe neighborhoods reduces its temptation to memorize exact pixels or token positions. It’s like practicing driving on different days and roads so you don’t panic when the real world throws rain or traffic at you. The theoretical comfort comes from the fact that we’re not inventing labels at random—we’re using changes that leave the label valid, so the expanded set still reflects the same underlying task.

03Formal Definition

Let (X, Y)

\sim

P be the true data-label distribution on input space

X

and label space

Y

. A (possibly stochastic) augmentation is a random transformation T:

X

\to

X

drawn from a distribution

T

. If the task is invariant to a family of transforms G (e.g., rotations), then P(y

∣

x) = P(y

∣

\cdot

x) for all g

\in

G. The augmented data distribution induced by

T

is P_{

T

}(x, y) =

E_{T \sim T}

[ P(

T^{- 1}

x, y)

∣

det

J_{

T^{- 1}

}(x)

∣

] when T is invertible and measurable (Jacobian term appears for density changes). In practice, we draw (

x_{i}

y_{i}

) from the dataset and sample x' = T(

x_{i}

) with y' =

y_{i}

(label-preserving) or y' defined by a rule (e.g., Mixup). Vicinal Risk Minimization (VRM) replaces the empirical distribution

\hat{P}

(x,y) =

\frac{1}{n} \sum_{i = 1}^{n}

δ_{(x_{i}, y_{i})}

with a vicinal distribution v(x,y) =

\frac{1}{n} \sum_{i = 1}^{n}

ν

((x,y)

∣

(

x_{i}

y_{i}

)), where

ν

is a vicinity kernel induced by augmentation. Training minimizes

R_{v}

(f) =

E_{(x, y) \sim v}

[

ℓ

(f(x),y)], smoothing the objective compared to empirical risk. Group-theoretically, augmentation corresponds to averaging over group actions: projecting predictions toward the invariant subspace via

f_{G}

(x) =

E_{g \sim μ_{G}}

[f(g

\cdot

x)], where

μ_{G}

is often the Haar measure on G.

04When to Use

Use data augmentation when you have limited labeled data, when you know valid invariances (e.g., image flips in object classification), or when you want to reduce overfitting without changing model capacity. It is especially effective in vision (geometric and photometric transforms), audio (time/frequency masking, pitch shifts), and some NLP tasks (back-translation, synonym replacement), and for robustness against corruptions and distribution shift. Mixup and noise injection are strong general-purpose augmentations that improve margins and calibration in both vision and tabular problems. Employ augmentation during training to expose the model to diverse views, and consider test-time augmentation to reduce prediction variance. Prefer on-the-fly augmentation when I/O is cheap and CPU/GPU has headroom; precompute augmented datasets when training time is critical but storage is ample. Tune the strength of augmentation to match realism: small noise improves smoothness; heavier transforms enforce stronger priors but risk label mismatch. For tasks with geometry-sensitive labels (e.g., object detection, segmentation), pair image transforms with consistent label transforms (boxes, masks).

⚠️Common Mistakes

Breaking label invariance: Some transforms change labels (e.g., flipping digits 6↔9, mirroring text, rotating asymmetrical logos). Always validate invariances per task and class.
Over-augmentation: Strong or unrealistic transforms can push samples off the data manifold, causing underfitting. Start with modest ranges and escalate gradually.
Ignoring labels during transform: For detection/segmentation, forgetting to adjust bounding boxes or masks yields inconsistent supervision.
Mismatch between train and test: Training with heavy color jitter but evaluating on grayscale distribution can create a gap. Consider TTA or calibrate augment policies to expected deployment conditions.
Deterministic or low-diversity policies: If transforms rarely change the input (tiny probabilities), augmentation brings little benefit. Ensure sufficient randomness and coverage.
Data leakage via augmentation: Duplicating samples across train/validation after augmentation inflates scores. Apply augmentation only to training, and keep splits clean.
Improper order and statistics: For images, do color jitter in the right color space, add noise after scaling, and keep normalization consistent. For Mixup, ensure label mixing matches loss function (e.g., supports soft labels).
Performance pitfalls: On-the-fly augmentations can bottleneck data pipelines. Use parallel workers, caching, or lighter transforms to keep GPUs fed.

Key Formulas

Empirical Risk

\hat{R} (f) = \frac{1}{n} i = 1 \sum n ℓ (f (x_{i}), y_{i})

Explanation: Average loss over the training set. ERM fits the observed samples exactly without smoothing.

True Risk

R (f) = E_{(x, y) \sim P} [ℓ (f (x), y)]

Explanation: Expected loss under the true, unknown data distribution. Generalization aims to make this small.

Vicinal Distribution

v (x, y) = \frac{1}{n} i = 1 \sum n ν ((x, y) ∣ (x_{i}, y_{i}))

Explanation: VRM replaces the empirical spikes with a neighborhood distribution around each sample, induced by augmentation.

VRM Risk

R_{v} (f) = E_{(x, y) \sim v} [ℓ (f (x), y)]

Explanation: Objective minimized when training with augmentation; it averages loss over local vicinities rather than single points.

Label Invariance

P (y ∣ x) = P (y ∣ g \cdot x), \forall g \in G

Explanation: States that labels are unchanged under transformations from group G. Validates label-preserving augmentation.

Augmented Distribution

P_{T} (x, y) = E_{T \sim T} [P (T^{- 1} x, y) ∣ det J_{T^{- 1}} (x)∣]

Explanation: Defines how the original distribution transforms under random, invertible augmentations, accounting for density change via the Jacobian.

Augmented Loss

\tilde{ℓ} (f, x, y) = E_{T \sim T} [ℓ (f (T x), y)]

Explanation: The loss averaged over random transforms of x. Training minimizes the expectation instead of a single configuration.

Group Averaging

f_{G} (x) = E_{g \sim μ_{G}} [f (g \cdot x)]

Explanation: A projection that enforces invariance by averaging predictions over group actions.

Mixup

x^{'} = λ x_{i} + (1 - λ) x_{j}, y^{'} = λ y_{i} + (1 - λ) y_{j}, λ \sim Beta (α, α)

Explanation: Creates convex combinations of two samples and labels, encouraging linear behavior between classes and improving margins.

Effective Sample Size (Heuristic)

n_{eff} \approx \frac{nk}{1 + ( k - 1 ) ρ}

Explanation: With k augmentations per sample and correlation $ρ$ between them, the effective number of independent samples grows sublinearly when augmentations are correlated.

Rademacher Complexity

R_{S} (F) = E_{σ} [f \in F sup \frac{1}{n} i = 1 \sum n σ_{i} f (x_{i})]

Explanation: Measures the capacity of a hypothesis class on a sample. With diverse augmentation (larger n), it typically decreases roughly like 1/ $n$ .

Test-Time Augmentation Averaging

\overset{p}{^} (y ∣ x) \approx \frac{1}{m} j = 1 \sum m p_{θ} (y ∣ T_{j} x)

Explanation: Approximates the expectation of the model’s predictive distribution over random transforms by a finite average at inference.

Complexity Analysis

If each original sample is augmented into k variants per epoch, total training-time compute typically scales by a factor of about k. For vector/tabular features of dimension d, simple noise or Mixup augmentations cost O(d) time and O(d) additional memory per sample. For images of size H×W, most pixel-wise photometric operations (brightness, contrast, noise) are O(HW), while geometric transforms like rotation or affine warp are also O(HW) with larger constant factors due to interpolation. A pipeline that applies a sequence of a transforms has time roughly O(a·HW) per image. When augmentations are performed on-the-fly with parallel workers, the augmentation stage can be overlapped with model compute; otherwise, it can become an I/O or CPU bottleneck that starves the GPU. Precomputing k variants multiplies storage by k but amortizes compute at training time. Test-time augmentation with m views multiplies inference cost by m, which may be acceptable for offline evaluation but expensive in latency-critical settings. Memory overhead during augmentation is often a single additional buffer of size O(HW) (or O(d) for vectors) per worker to hold intermediate results; streaming in-place operations can keep memory constant. For Mixup within a batch of size b and dimension d, constructing mixed pairs by a cyclic permutation costs O(bd) time and O(bd) space to store the mixed batch. Random number generation is typically O(1) per scalar sample and can be vectorized; however, high-quality RNG and per-pixel sampling add overhead. Overall, choose k and transform complexity so that augmentation benefits outweigh the increased training or inference time, and profile to keep the input pipeline from dominating runtime.

Code Examples

Image augmentation pipeline with OpenCV: rotation, flip, color jitter, Gaussian noise, and random erasing

1 // g++ -std=c++17 -O2 augment_opencv.cpp `pkg-config --cflags --libs opencv4` -o augment_opencv
2 #include <opencv2/opencv.hpp>
3 #include <iostream>
4 #include <random>
5 
6 using namespace cv;
7 
8 // Apply random rotation around image center
9 static Mat randomRotate(const Mat &img, std::mt19937 &rng, double max_deg = 20.0) {
10     std::uniform_real_distribution<double> dist(-max_deg, max_deg);
11     double angle = dist(rng);
12     Point2f center(img.cols / 2.0f, img.rows / 2.0f);
13     Mat M = getRotationMatrix2D(center, angle, 1.0);
14     Mat rotated;
15     // Use border reflect to avoid black corners
16     warpAffine(img, rotated, M, img.size(), INTER_LINEAR, BORDER_REFLECT_101);
17     return rotated;
18 }
19 
20 // Random horizontal/vertical flip
21 static Mat randomFlip(const Mat &img, std::mt19937 &rng, double p_h = 0.5, double p_v = 0.1) {
22     std::bernoulli_distribution bh(p_h), bv(p_v);
23     Mat out = img.clone();
24     if (bh(rng)) flip(out, out, 1);
25     if (bv(rng)) flip(out, out, 0);
26     return out;
27 }
28 
29 // Color jitter: brightness and contrast
30 static Mat colorJitter(const Mat &img, std::mt19937 &rng, double b_range = 0.2, double c_range = 0.2) {
31     std::uniform_real_distribution<double> db(1.0 - b_range, 1.0 + b_range);
32     std::uniform_real_distribution<double> dc(1.0 - c_range, 1.0 + c_range);
33     double b = db(rng); // brightness multiplier
34     double c = dc(rng); // contrast multiplier
35     Mat out;
36     img.convertTo(out, CV_32F, 1.0/255.0);
37     // out = c * out + (b - 1)
38     out = c * out + (b - 1.0);
39     // Clip to [0,1]
40     cv::min(out, 1.0, out);
41     cv::max(out, 0.0, out);
42     out.convertTo(out, img.type(), 255.0);
43     return out;
44 }
45 
46 // Add Gaussian noise with standard deviation sigma (in 0..255 scale)
47 static Mat addGaussianNoise(const Mat &img, std::mt19937 &rng, double sigma = 10.0, double p = 0.5) {
48     std::bernoulli_distribution apply(p);
49     if (!apply(rng)) return img.clone();
50     Mat noise(img.size(), img.type());
51     std::normal_distribution<float> nd(0.0f, static_cast<float>(sigma));
52     noise.forEach<cv::Vec3b>([&](cv::Vec3b &pix, const int *pos){
53         for (int c = 0; c < 3; ++c) {
54             float n = nd(rng);
55             int val = static_cast<int>(n);
56             pix[c] = static_cast<uchar>(std::clamp(val + 128, 0, 255));
57         }
58     });
59     Mat out;
60     // Convert to 16S to accumulate without overflow
61     Mat img16, noise16;
62     img.convertTo(img16, CV_16S);
63     noise.convertTo(noise16, CV_16S, 1.0, -128); // shift back
64     add(img16, noise16, img16, noArray(), CV_16S);
65     img16.convertTo(out, img.type());
66     return out;
67 }
68 
69 // Random erasing (Cutout) with a rectangle of zeros
70 static Mat randomErasing(const Mat &img, std::mt19937 &rng, double p = 0.5, double scale_min = 0.02, double scale_max = 0.2, double ratio_min = 0.3, double ratio_max = 3.3) {
71     std::bernoulli_distribution apply(p);
72     if (!apply(rng)) return img.clone();
73     int H = img.rows, W = img.cols;
74     std::uniform_real_distribution<double> dscale(scale_min, scale_max);
75     std::uniform_real_distribution<double> dratio(ratio_min, ratio_max);
76     double target = dscale(rng) * H * W;
77     double ratio = dratio(rng);
78     int h = static_cast<int>(std::round(std::sqrt(target * ratio)));
79     int w = static_cast<int>(std::round(std::sqrt(target / ratio)));
80     h = std::min(h, H);
81     w = std::min(w, W);
82     std::uniform_int_distribution<int> dy(0, H - h);
83     std::uniform_int_distribution<int> dx(0, W - w);
84     int y = dy(rng), x = dx(rng);
85     Mat out = img.clone();
86     out(Rect(x, y, w, h)) = Scalar(0, 0, 0);
87     return out;
88 }
89 
90 static Mat augmentImage(const Mat &img, std::mt19937 &rng) {
91     Mat out = img;
92     out = randomRotate(out, rng, 20.0);
93     out = randomFlip(out, rng, 0.5, 0.1);
94     out = colorJitter(out, rng, 0.15, 0.15);
95     out = addGaussianNoise(out, rng, 8.0, 0.5);
96     out = randomErasing(out, rng, 0.5);
97     return out;
98 }
99 
100 int main(int argc, char** argv) {
101     if (argc < 3) {
102         std::cerr << "Usage: " << argv[0] << " input.jpg num_augments\n";
103         return 1;
104     }
105     std::string path = argv[1];
106     int N = std::stoi(argv[2]);
107     Mat img = imread(path, IMREAD_COLOR);
108     if (img.empty()) {
109         std::cerr << "Failed to read image: " << path << "\n";
110         return 1;
111     }
112     std::random_device rd; std::mt19937 rng(rd());
113     for (int i = 0; i < N; ++i) {
114         Mat aug = augmentImage(img, rng);
115         std::string out_name = "aug_" + std::to_string(i) + ".png";
116         imwrite(out_name, aug);
117         std::cout << "Wrote " << out_name << "\n";
118     }
119     return 0;
120 }
121

This program demonstrates a practical image augmentation pipeline using OpenCV. It composes rotation, random flips, color jitter, Gaussian noise, and random erasing (Cutout). Each operation is stochastic and label-preserving for many image classification tasks. Running it creates multiple augmented variants that approximate sampling from a vicinal distribution around the original image.

Time: O(N · H · W) for N augmentations of an H×W image, with small constant factors per transform; rotation and warping incur interpolation overhead.Space: O(H · W) additional memory per augmentation for intermediate buffers; constant extra besides storing outputs.

Mixup for mini-batches (vectors and soft labels) with Beta sampling

1 // g++ -std=c++17 -O2 mixup.cpp -o mixup
2 #include <bits/stdc++.h>
3 using namespace std;
4 
5 struct Sample {
6     vector<float> x; // features of dimension d
7     vector<float> y; // one-hot or soft labels of size C
8 };
9 
10 // Sample from Beta(alpha, alpha) using two Gamma(alpha, 1)
11 static float sample_beta_symmetric(float alpha, mt19937 &rng) {
12     gamma_distribution<float> g(alpha, 1.0f);
13     float a = g(rng);
14     float b = g(rng);
15     return a / (a + b + 1e-12f);
16 }
17 
18 // Perform Mixup within a batch by pairing each sample with a shuffled partner
19 static vector<Sample> mixup_batch(const vector<Sample> &batch, float alpha, mt19937 &rng) {
20     int b = (int)batch.size();
21     vector<int> perm(b);
22     iota(perm.begin(), perm.end(), 0);
23     shuffle(perm.begin(), perm.end(), rng);
24 
25     vector<Sample> out = batch;
26     for (int i = 0; i < b; ++i) {
27         const auto &a = batch[i];
28         const auto &c = batch[perm[i]];
29         float lam = sample_beta_symmetric(alpha, rng);
30         int d = (int)a.x.size();
31         int C = (int)a.y.size();
32         out[i].x.resize(d);
33         out[i].y.resize(C);
34         for (int j = 0; j < d; ++j) out[i].x[j] = lam * a.x[j] + (1.0f - lam) * c.x[j];
35         for (int j = 0; j < C; ++j) out[i].y[j] = lam * a.y[j] + (1.0f - lam) * c.y[j];
36     }
37     return out;
38 }
39 
40 int main() {
41     // Create a toy batch of 4 samples with d=3 features and C=2 classes
42     vector<Sample> batch(4);
43     for (int i = 0; i < 4; ++i) {
44         batch[i].x = {float(i), float(i+1), float(i+2)}; // toy features
45         batch[i].y = {i % 2 == 0 ? 1.0f : 0.0f, i % 2 == 0 ? 0.0f : 1.0f}; // one-hot
46     }
47     random_device rd; mt19937 rng(rd());
48     float alpha = 0.4f; // beta parameter; larger => stronger mixing
49     auto mixed = mixup_batch(batch, alpha, rng);
50 
51     cout << fixed << setprecision(3);
52     for (size_t i = 0; i < mixed.size(); ++i) {
53         cout << "Sample " << i << "\n  x: ";
54         for (auto v : mixed[i].x) cout << v << ' ';
55         cout << "\n  y: ";
56         for (auto v : mixed[i].y) cout << v << ' ';
57         cout << "\n";
58     }
59     return 0;
60 }
61

This code implements Mixup for vector features and one-hot (or soft) labels. It samples λ from a symmetric Beta(α, α) via two Gamma draws, shuffles the batch to form pairs, and outputs convex combinations of both features and labels. This aligns with VRM by smoothing the empirical distribution between samples, often improving margins and calibration. Integrate this before the forward pass; ensure your loss (e.g., cross-entropy) supports soft labels.

Time: O(b · d + b · C) for batch size b, feature dimension d, and classes C.Space: O(b · (d + C)) to store the mixed batch.

Composable tabular augmentation pipeline (Gaussian noise, feature dropout)

1 // g++ -std=c++17 -O2 tabular_augment.cpp -o tabular_augment
2 #include <bits/stdc++.h>
3 using namespace std;
4 
5 using Vec = vector<float>;
6 
7 struct Transform {
8     virtual ~Transform() = default;
9     virtual Vec operator()(const Vec &x, mt19937 &rng) const = 0;
10 };
11 
12 struct GaussianNoise : Transform {
13     float sigma; // standard deviation per feature
14     explicit GaussianNoise(float s) : sigma(s) {}
15     Vec operator()(const Vec &x, mt19937 &rng) const override {
16         normal_distribution<float> nd(0.0f, sigma);
17         Vec y = x;
18         for (auto &v : y) v += nd(rng);
19         return y;
20     }
21 };
22 
23 struct FeatureDropout : Transform {
24     float p; // probability to drop a feature to zero (or mean)
25     explicit FeatureDropout(float prob) : p(prob) {}
26     Vec operator()(const Vec &x, mt19937 &rng) const override {
27         bernoulli_distribution bd(p);
28         Vec y = x;
29         for (auto &v : y) if (bd(rng)) v = 0.0f;
30         return y;
31     }
32 };
33 
34 struct Compose : Transform {
35     vector<shared_ptr<Transform>> ops;
36     explicit Compose(vector<shared_ptr<Transform>> t) : ops(move(t)) {}
37     Vec operator()(const Vec &x, mt19937 &rng) const override {
38         Vec y = x;
39         for (const auto &op : ops) y = (*op)(y, rng);
40         return y;
41     }
42 };
43 
44 int main() {
45     // Example feature vector
46     Vec x = {1.0f, 2.0f, 3.5f, -0.7f};
47 
48     // Build pipeline: small Gaussian noise then dropout
49     auto pipeline = Compose({ make_shared<GaussianNoise>(0.05f),
50                               make_shared<FeatureDropout>(0.2f) });
51 
52     random_device rd; mt19937 rng(rd());
53 
54     for (int i = 0; i < 5; ++i) {
55         Vec aug = pipeline(x, rng);
56         cout << "Augmented: ";
57         for (auto v : aug) cout << fixed << setprecision(3) << v << ' ';
58         cout << '\n';
59     }
60     return 0;
61 }
62

This example shows a simple, extensible augmentation pipeline for tabular vectors. It composes Gaussian noise (encouraging local smoothness) and feature dropout (promoting robustness to missing/noisy features). The interface mimics common deep learning frameworks, but is pure C++. Extend it with task-specific transforms (e.g., scaling-invariant perturbations) as needed.

Time: O(a · d) per sample where a is the number of transforms and d is feature dimension.Space: O(d) for intermediate vectors.

1	// g++ -std=c++17 -O2 augment_opencv.cpp `pkg-config --cflags --libs opencv4` -o augment_opencv
2	#include <opencv2/opencv.hpp>
3	#include <iostream>
4	#include <random>
5
6	using namespace cv;
7
8	// Apply random rotation around image center
9	static Mat randomRotate(const Mat &img, std::mt19937 &rng, double max_deg = 20.0) {
10	std::uniform_real_distribution<double> dist(-max_deg, max_deg);
11	double angle = dist(rng);
12	Point2f center(img.cols / 2.0f, img.rows / 2.0f);
13	Mat M = getRotationMatrix2D(center, angle, 1.0);
14	Mat rotated;
15	// Use border reflect to avoid black corners
16	warpAffine(img, rotated, M, img.size(), INTER_LINEAR, BORDER_REFLECT_101);
17	return rotated;
18	}
19
20	// Random horizontal/vertical flip
21	static Mat randomFlip(const Mat &img, std::mt19937 &rng, double p_h = 0.5, double p_v = 0.1) {
22	std::bernoulli_distribution bh(p_h), bv(p_v);
23	Mat out = img.clone();
24	if (bh(rng)) flip(out, out, 1);
25	if (bv(rng)) flip(out, out, 0);
26	return out;
27	}
28
29	// Color jitter: brightness and contrast
30	static Mat colorJitter(const Mat &img, std::mt19937 &rng, double b_range = 0.2, double c_range = 0.2) {
31	std::uniform_real_distribution<double> db(1.0 - b_range, 1.0 + b_range);
32	std::uniform_real_distribution<double> dc(1.0 - c_range, 1.0 + c_range);
33	double b = db(rng); // brightness multiplier
34	double c = dc(rng); // contrast multiplier
35	Mat out;
36	img.convertTo(out, CV_32F, 1.0/255.0);
37	// out = c * out + (b - 1)
38	out = c * out + (b - 1.0);
39	// Clip to [0,1]
40	cv::min(out, 1.0, out);
41	cv::max(out, 0.0, out);
42	out.convertTo(out, img.type(), 255.0);
43	return out;
44	}
45
46	// Add Gaussian noise with standard deviation sigma (in 0..255 scale)
47	static Mat addGaussianNoise(const Mat &img, std::mt19937 &rng, double sigma = 10.0, double p = 0.5) {
48	std::bernoulli_distribution apply(p);
49	if (!apply(rng)) return img.clone();
50	Mat noise(img.size(), img.type());
51	std::normal_distribution<float> nd(0.0f, static_cast<float>(sigma));
52	noise.forEach<cv::Vec3b>([&](cv::Vec3b &pix, const int *pos){
53	for (int c = 0; c < 3; ++c) {
54	float n = nd(rng);
55	int val = static_cast<int>(n);
56	pix[c] = static_cast<uchar>(std::clamp(val + 128, 0, 255));
57	}
58	});
59	Mat out;
60	// Convert to 16S to accumulate without overflow
61	Mat img16, noise16;
62	img.convertTo(img16, CV_16S);
63	noise.convertTo(noise16, CV_16S, 1.0, -128); // shift back
64	add(img16, noise16, img16, noArray(), CV_16S);
65	img16.convertTo(out, img.type());
66	return out;
67	}
68
69	// Random erasing (Cutout) with a rectangle of zeros
70	static Mat randomErasing(const Mat &img, std::mt19937 &rng, double p = 0.5, double scale_min = 0.02, double scale_max = 0.2, double ratio_min = 0.3, double ratio_max = 3.3) {
71	std::bernoulli_distribution apply(p);
72	if (!apply(rng)) return img.clone();
73	int H = img.rows, W = img.cols;
74	std::uniform_real_distribution<double> dscale(scale_min, scale_max);
75	std::uniform_real_distribution<double> dratio(ratio_min, ratio_max);
76	double target = dscale(rng) * H * W;
77	double ratio = dratio(rng);
78	int h = static_cast<int>(std::round(std::sqrt(target * ratio)));
79	int w = static_cast<int>(std::round(std::sqrt(target / ratio)));
80	h = std::min(h, H);
81	w = std::min(w, W);
82	std::uniform_int_distribution<int> dy(0, H - h);
83	std::uniform_int_distribution<int> dx(0, W - w);
84	int y = dy(rng), x = dx(rng);
85	Mat out = img.clone();
86	out(Rect(x, y, w, h)) = Scalar(0, 0, 0);
87	return out;
88	}
89
90	static Mat augmentImage(const Mat &img, std::mt19937 &rng) {
91	Mat out = img;
92	out = randomRotate(out, rng, 20.0);
93	out = randomFlip(out, rng, 0.5, 0.1);
94	out = colorJitter(out, rng, 0.15, 0.15);
95	out = addGaussianNoise(out, rng, 8.0, 0.5);
96	out = randomErasing(out, rng, 0.5);
97	return out;
98	}
99
100	int main(int argc, char** argv) {
101	if (argc < 3) {
102	std::cerr << "Usage: " << argv[0] << " input.jpg num_augments\n";
103	return 1;
104	}
105	std::string path = argv[1];
106	int N = std::stoi(argv[2]);
107	Mat img = imread(path, IMREAD_COLOR);
108	if (img.empty()) {
109	std::cerr << "Failed to read image: " << path << "\n";
110	return 1;
111	}
112	std::random_device rd; std::mt19937 rng(rd());
113	for (int i = 0; i < N; ++i) {
114	Mat aug = augmentImage(img, rng);
115	std::string out_name = "aug_" + std::to_string(i) + ".png";
116	imwrite(out_name, aug);
117	std::cout << "Wrote " << out_name << "\n";
118	}
119	return 0;
120	}
121

1	// g++ -std=c++17 -O2 mixup.cpp -o mixup
2	#include <bits/stdc++.h>
3	using namespace std;
4
5	struct Sample {
6	vector<float> x; // features of dimension d
7	vector<float> y; // one-hot or soft labels of size C
8	};
9
10	// Sample from Beta(alpha, alpha) using two Gamma(alpha, 1)
11	static float sample_beta_symmetric(float alpha, mt19937 &rng) {
12	gamma_distribution<float> g(alpha, 1.0f);
13	float a = g(rng);
14	float b = g(rng);
15	return a / (a + b + 1e-12f);
16	}
17
18	// Perform Mixup within a batch by pairing each sample with a shuffled partner
19	static vector<Sample> mixup_batch(const vector<Sample> &batch, float alpha, mt19937 &rng) {
20	int b = (int)batch.size();
21	vector<int> perm(b);
22	iota(perm.begin(), perm.end(), 0);
23	shuffle(perm.begin(), perm.end(), rng);
24
25	vector<Sample> out = batch;
26	for (int i = 0; i < b; ++i) {
27	const auto &a = batch[i];
28	const auto &c = batch[perm[i]];
29	float lam = sample_beta_symmetric(alpha, rng);
30	int d = (int)a.x.size();
31	int C = (int)a.y.size();
32	out[i].x.resize(d);
33	out[i].y.resize(C);
34	for (int j = 0; j < d; ++j) out[i].x[j] = lam * a.x[j] + (1.0f - lam) * c.x[j];
35	for (int j = 0; j < C; ++j) out[i].y[j] = lam * a.y[j] + (1.0f - lam) * c.y[j];
36	}
37	return out;
38	}
39
40	int main() {
41	// Create a toy batch of 4 samples with d=3 features and C=2 classes
42	vector<Sample> batch(4);
43	for (int i = 0; i < 4; ++i) {
44	batch[i].x = {float(i), float(i+1), float(i+2)}; // toy features
45	batch[i].y = {i % 2 == 0 ? 1.0f : 0.0f, i % 2 == 0 ? 0.0f : 1.0f}; // one-hot
46	}
47	random_device rd; mt19937 rng(rd());
48	float alpha = 0.4f; // beta parameter; larger => stronger mixing
49	auto mixed = mixup_batch(batch, alpha, rng);
50
51	cout << fixed << setprecision(3);
52	for (size_t i = 0; i < mixed.size(); ++i) {
53	cout << "Sample " << i << "\n x: ";
54	for (auto v : mixed[i].x) cout << v << ' ';
55	cout << "\n y: ";
56	for (auto v : mixed[i].y) cout << v << ' ';
57	cout << "\n";
58	}
59	return 0;
60	}
61

1	// g++ -std=c++17 -O2 tabular_augment.cpp -o tabular_augment
2	#include <bits/stdc++.h>
3	using namespace std;
4
5	using Vec = vector<float>;
6
7	struct Transform {
8	virtual ~Transform() = default;
9	virtual Vec operator()(const Vec &x, mt19937 &rng) const = 0;
10	};
11
12	struct GaussianNoise : Transform {
13	float sigma; // standard deviation per feature
14	explicit GaussianNoise(float s) : sigma(s) {}
15	Vec operator()(const Vec &x, mt19937 &rng) const override {
16	normal_distribution<float> nd(0.0f, sigma);
17	Vec y = x;
18	for (auto &v : y) v += nd(rng);
19	return y;
20	}
21	};
22
23	struct FeatureDropout : Transform {
24	float p; // probability to drop a feature to zero (or mean)
25	explicit FeatureDropout(float prob) : p(prob) {}
26	Vec operator()(const Vec &x, mt19937 &rng) const override {
27	bernoulli_distribution bd(p);
28	Vec y = x;
29	for (auto &v : y) if (bd(rng)) v = 0.0f;
30	return y;
31	}
32	};
33
34	struct Compose : Transform {
35	vector<shared_ptr<Transform>> ops;
36	explicit Compose(vector<shared_ptr<Transform>> t) : ops(move(t)) {}
37	Vec operator()(const Vec &x, mt19937 &rng) const override {
38	Vec y = x;
39	for (const auto &op : ops) y = (*op)(y, rng);
40	return y;
41	}
42	};
43
44	int main() {
45	// Example feature vector
46	Vec x = {1.0f, 2.0f, 3.5f, -0.7f};
47
48	// Build pipeline: small Gaussian noise then dropout
49	auto pipeline = Compose({ make_shared<GaussianNoise>(0.05f),
50	make_shared<FeatureDropout>(0.2f) });
51
52	random_device rd; mt19937 rng(rd());
53
54	for (int i = 0; i < 5; ++i) {
55	Vec aug = pipeline(x, rng);
56	cout << "Augmented: ";
57	for (auto v : aug) cout << fixed << setprecision(3) << v << ' ';
58	cout << '\n';
59	}
60	return 0;
61	}
62