Data-Centric AI

Data-centric AI is the practice of improving an AI system by systematically engineering its data, including label consistency, coverage of real conditions, class balance, and cleanliness, while the model and training code stay largely fixed. Andrew Ng popularized the term in 2021, arguing that architectures such as convolutional neural networks and transformers are mature enough that most applications gain more from better data than from a better model. Its opposite, model-centric AI, holds a benchmark dataset fixed and iterates on architectures, loss functions, and hyperparameter tuning, the way most academic leaderboards work.

Ng's best-known example came from steel sheet inspection: a defect detector stuck at 76.2% accuracy gained nothing from model-centric improvements, and fixing inconsistent labels raised it to 93.1%. Later that year, DeepLearning.AI and Landing AI ran a Data-Centric AI Competition in which the model was fixed and entrants could only improve a noisy image classification dataset of handwritten Roman numerals, capped at 10,000 images.

Core Practices#

• Consistent data labeling: Annotators follow written rules for ambiguous cases, such as whether a box includes a car's side mirror or how to label a half-hidden person. Two annotators who resolve these cases differently create label noise that no model can learn around.
• Finding label errors: A model's disagreements with the given labels point to likely mistakes. A 2021 study by Northcutt, Athalye, and Mueller found label errors in an average of at least 3.3% of test examples across 10 popular datasets, and in at least 6% of the ImageNet validation set.
• Targeted collection and synthetic data: Error analysis by class, scene, lighting, or object size shows where a model fails, and new examples for exactly those slices help more than random additions.
• Data cleaning: Removing corrupted files, irrelevant images, and duplicates, especially near-duplicates that sit in both the training and test splits.
• Data augmentation: Widening the range of lighting, scale, and viewpoint the model sees without collecting new images.

Duplicates across splits cause data leakage, which inflates test scores, and class imbalance lets a model reach high accuracy while missing the rare class that matters, as in manufacturing defect detection where flawed parts are scarce. In medical image analysis, datasets are small and expert labels expensive, so consistent, reviewed labels matter more than volume.

The Data-Centric Loop#

A data-centric team keeps the model fixed, studies its errors with tools such as a confusion matrix, and changes the data in response, as the First Fine-Tune and the Iteration Loop lesson does when it turns a YOLO26 model's weakest class into the next dataset fix:

This example corrupts 20% of the labels in scikit-learn's handwritten digits dataset, flags examples whose out-of-fold prediction disagrees with their label, and retrains the same model without them:

import numpy as np
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_predict, train_test_split

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# Replace 20% of the training labels with random digits to mimic annotation errors
rng = np.random.default_rng(0)
noisy = y_train.copy()
flip = rng.random(len(noisy)) < 0.2
noisy[flip] = rng.integers(0, 10, flip.sum())
wrong = noisy != y_train  # some random digits match the true label

# The model stays fixed; only the training data changes
model = LogisticRegression(max_iter=5000)
print(f"noisy labels: {model.fit(X_train, noisy).score(X_test, y_test):.1%} test accuracy")

# Flag examples whose out-of-fold prediction disagrees with their label, then drop them
keep = cross_val_predict(model, X_train, noisy, cv=5) == noisy
print(f"flagged {(~keep).sum()} examples, {(~keep & wrong).sum()} of {wrong.sum()} wrong labels")
print(f"cleaned labels: {model.fit(X_train[keep], noisy[keep]).score(X_test, y_test):.1%} test accuracy")

Test accuracy rises from 87.0% to 94.1% with no change to the model. The filter flags 354 examples: 211 of the 213 wrong labels and 143 correct but unusual ones, so the cleaned set loses some valid examples along with nearly all of the errors.

Comparing data changes requires knowing exactly which data trained which model. Ultralytics Platform stores immutable dataset versions: the Save Dataset Version option in cloud training links each model to the snapshot it trained on, Compare Versions lists the images, annotations, and classes that changed between two snapshots, and the dataset's Models tab lists each model's dataset version beside headline metrics such as mAP_50-95.

Data-Centric AI vs. Related Terms#

• Active learning: Chooses which unlabeled examples to label next, usually the ones the model is least sure about. It is one technique within data-centric AI.
• Data flywheel: The production loop in which a deployed model's inputs and errors become new training data, so data-centric work repeats with every release.
• Machine learning operations (MLOps): The engineering practices that version, train, deploy, and monitor models, which make data changes reproducible and comparable.