ADASYN: Generating Where the Model Is Actually Struggling

What problem does this solve?

A retinal screening programme trains a referable-disease classifier. Roughly 6% of images are referable. SMOTE lifted recall to a usable level, but the residual errors cluster in one place: mild cases that look very close to healthy.

Those borderline images are the clinically important ones. A clearly advanced case is easy for both the model and the grader; the marginal case is where a screening programme earns or loses its value. Uniform oversampling spreads synthetic points evenly across the minority class, so it spends most of its effort in the region the model already handles.

The team wants generation concentrated where the classifier is weakest — which is exactly what ADASYN was designed to do, and exactly why it must be paired with a hard look at label quality first.

How the solution works

ADASYN measures, for each minority sample, how many of its k nearest neighbours belong to the majority class. That ratio becomes a difficulty score.

It then allocates the synthetic-sample budget in proportion to those scores. A minority point surrounded by majority neighbours receives many synthetic companions; one surrounded by its own class receives few or none.

Generation itself is the same interpolation SMOTE uses. The difference is entirely in how many points are created around each seed, not in how each point is made.

Because difficulty and mislabelling look identical from the algorithm's point of view, a label audit on the highest-difficulty samples should precede any ADASYN run.

1. 1
   Measure the imbalance Compute how many synthetic samples are needed in total to reach the requested class ratio.
2. 2
   Score each minority point For each minority sample, find its k nearest neighbours across the whole dataset and compute the fraction that belong to the majority class.
3. 3
   Normalise the scores Divide each score by the sum of all scores so they form a distribution over the minority samples.
4. 4
   Allocate the budget Multiply that distribution by the total number of synthetic samples needed, giving a per-seed generation count.
5. 5
   Interpolate For each seed, generate its allocated number of points by interpolating toward randomly chosen minority neighbours, exactly as SMOTE does.

Reference architecture

ADASYN occupies the same pipeline slot as SMOTE, but it adds a dependency on label quality that SMOTE does not have to the same degree.

Deployment options: Clinical and insurance data usually cannot leave the entity's environment, so both the label review and the training run happen inside the approved boundary.

Key capabilities

Integrations

ADASYN is a training-pipeline component whose real integration point is the annotation platform, because its output quality depends on label quality more than most samplers.

Industry use cases

Implementation approach

1. 1
   Score difficulty first Compute the neighbour ratios and look at the distribution before deciding whether ADASYN is appropriate at all.
2. 2
   Audit the hardest samples Manually review the top-ranked points. Correct or remove mislabels before generation.
3. 3
   Benchmark against SMOTE Run both on identical folds and report standard deviation alongside the mean.
4. 4
   Analyse by region Confirm the improvement appears in the boundary band, which is the only reason to prefer ADASYN.
5. 5
   Fix the parameters Record k, the sampling ratio and the seed; ADASYN's allocation is sensitive to all three.

Security & deployment

The label audit ADASYN depends on requires human access to the underlying records, which for clinical or claims data is a controlled event. Log who reviewed which samples, keep the review inside the approved environment, and treat the resulting synthetic points as derived personal data carrying the classification of their source.

A worked example

Three minority images, k = 5 neighbours each, and a total synthetic budget of 100 points.

1. Image A — deep inside the minority region. 1 of 5 neighbours is majority. r = 0.2.
2. Image B — near the boundary. 3 of 5 neighbours are majority. r = 0.6.
3. Image C — nearly surrounded. 4 of 5 neighbours are majority. r = 0.8.
4. Normalise. Sum = 1.6, so the shares are 0.125, 0.375 and 0.500.
5. Allocate. A gets about 13 synthetic points, B about 37, and C about 50.

Half the entire budget goes to a single image. If C is a genuinely difficult borderline case, that is exactly right. If C was graded incorrectly, ADASYN has just built fifty synthetic examples of a mistake — which is why the highest-r samples are the ones to inspect before running it.

In code

The useful pattern is to inspect the difficulty scores before generating anything, then compare ADASYN against SMOTE on the same folds.

import numpy as np
from sklearn.neighbors import NearestNeighbors
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.linear_model import LogisticRegression
from imblearn.over_sampling import ADASYN, SMOTE
from imblearn.pipeline import Pipeline

def difficulty_scores(X, y, minority_label=1, k=5):
    """Fraction of each minority point's neighbours that are majority class."""
    nn = NearestNeighbors(n_neighbors=k + 1).fit(X)
    idx = np.where(y == minority_label)[0]
    _, neigh = nn.kneighbors(X[idx])
    neigh = neigh[:, 1:]              # drop the point itself
    return idx, (y[neigh] != minority_label).mean(axis=1)

idx, r = difficulty_scores(X_train, y_train)
hardest = idx[np.argsort(-r)][:20]
print("inspect these labels first:", hardest.tolist())
print("difficulty range:", r.min().round(2), "to", r.max().round(2))

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
for name, sampler in [("smote", SMOTE(random_state=0)), ("adasyn", ADASYN(random_state=0))]:
    pipe = Pipeline([("s", sampler), ("clf", LogisticRegression(max_iter=2000))])
    s = cross_val_score(pipe, X_train, y_train, cv=cv, scoring="average_precision")
    print(f"{name}: PR-AUC {s.mean():.3f} +/- {s.std():.3f}")

A list of the twenty hardest minority samples to review manually, the range of difficulty scores, and a like-for-like PR-AUC comparison between SMOTE and ADASYN. If ADASYN wins by less than its own standard deviation, the difference is not real.

Diagnostic checks

• Plot the distribution of difficulty scores. A large mass at r near 1.0 suggests label noise rather than a hard boundary.
• Manually inspect the twenty highest-scoring minority samples. If several are obviously mislabelled, fix the labels before running ADASYN.
• Compare per-band performance. If ADASYN improves the aggregate but not the boundary band, it is not doing what you selected it for.
• Report standard deviation across folds. On small minority classes ADASYN's advantage over SMOTE is frequently inside the noise.
• Check for minority points with zero minority neighbours; ADASYN can fail or behave degenerately on isolated outliers.

Limitations & prerequisites

• ADASYN cannot distinguish a hard example from a wrong one, and treats both as deserving amplification.
• It ignores the majority class distribution when interpolating, so synthetic points can land inside majority territory.
• Allocation is sensitive to k; changing it redistributes the budget substantially.
• On small or sparse minority classes the difficulty estimate is unstable and the advantage over SMOTE disappears.

ADASYN against SMOTE

Same interpolation, different allocation. The distinction only matters when the boundary is where the errors live.

Run SMOTE first. ADASYN is worth trying when error analysis shows the residual failures sitting at the boundary, and only after the hardest labels have been checked.

Key takeaways

• ADASYN is SMOTE with a difficulty weighting on how many points each seed generates.
• It concentrates effort at the decision boundary, which is where borderline cases live.
• The same weighting means a mislabelled point attracts the largest share of the synthetic budget.
• Audit the highest-difficulty samples before generating anything.
• Benchmark against SMOTE on identical folds and report variance, not just the mean.

FAQ

Related topics & solutions

• SMOTE: Inventing Minority Examples Without Copying Them
• Class Imbalance: When 95% Accuracy Means the Model Found Nothing
• Label Noise: The Accuracy Ceiling Nobody Put There Deliberately
• Random Oversampling: Duplication as a Deliberate Choice
• Outliers: Telling a Broken Sensor From a Broken Chiller
• AI Products Portfolio
• Selection Bias: When Your Data Only Contains the People Who Showed Up
• Random Undersampling: Throwing Away Data on Purpose