🤖 machine learning

LiBaGS: Lightweight Boundary Gap Synthesis for Targeted Synthetic Data Selection

LiBaGS is a lightweight, generator-agnostic method that optimizes synthetic data selection by scoring samples based on boundary proximity, uncertainty, and density while employing a boundary-gap allocation rule and marginal-value stopping criterion to improve downstream task accuracy without redundant or unrealistic data.

Original authors: Abhishek Moturu, Anna Goldenberg, Babak Taati

Published 2026-05-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Abhishek Moturu, Anna Goldenberg, Babak Taati

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot to distinguish between two types of objects, like cats and dogs. You have a pile of real photos, but there are some tricky areas where the robot gets confused. Maybe it doesn't know what to do with a cat that looks a bit like a dog, or a dog with a very unusual pose. These "confusing spots" are like the decision boundaries in the paper's language.

The problem is that your pile of real photos might be missing examples right in these confusing spots. You could try to generate more fake photos (synthetic data) to fill the gaps, but that's risky. If you just throw in thousands of random fake photos, you might waste time teaching the robot about things it already knows, or worse, you might teach it with fake photos that look nothing like real life (like a cat with six legs).

LiBaGS is a new, smart "filter" or "selector" for these fake photos. Here is how it works, using some everyday analogies:

1. The "Smart Scout" vs. The "Blind Generator"

Imagine a factory that can print millions of fake photos (the generator). Sometimes the factory is great; sometimes it prints weird garbage.

Old methods often just grab the first few photos that look "hard" or "uncertain" and add them to the training pile.
LiBaGS acts like a smart scout. It doesn't care how the photo was made (whether by a fancy AI or a simple drawing tool). It just looks at the photo and asks four questions before letting it into the classroom:
1. Is it near the confusion zone? (Is it close to the decision boundary where the robot gets stuck?)
2. Is the robot actually confused by it? (Does the robot have low confidence when looking at it?)
3. Is it realistic? (Does it look like a real animal, or is it a glitchy artifact?)
4. Do we already have enough examples like this? (If we already have 100 photos of "fluffy dogs," do we really need another one?)

2. The "Empty Seat" Analogy

Think of the robot's learning space as a theater.

Real data fills up the comfortable seats in the middle of the room.
LiBaGS looks for the empty seats (sparse regions) right near the stage lights (the decision boundary) where the action happens.
If a seat is already full of real photos, LiBaGS says, "No need to add a fake one here."
If a seat is empty and right next to the stage, LiBaGS says, "Perfect! Let's put a high-quality fake photo here to help the robot learn."

3. The "Diminishing Returns" Rule

LiBaGS has a special rule for knowing when to stop. Imagine you are filling a bucket with water.

The first few drops (synthetic samples) in an empty spot make a huge difference.
But if you keep pouring water into the same spot, the bucket overflows, and the extra water just spills out (it doesn't help the robot learn anything new).
LiBaGS calculates the "marginal value." It keeps adding fake photos only as long as each new one adds a significant amount of value. Once the value gets too small (the bucket is full enough), it stops automatically. You don't have to guess how many fake photos to make; LiBaGS figures it out.

4. The "Soft Teacher"

Sometimes, a fake photo is right on the edge of being a cat or a dog. If you tell the robot, "This is 100% a cat," the robot might get confused later.

LiBaGS uses soft labels. Instead of shouting "CAT!", it whispers, "This looks 70% like a cat and 30% like a dog." This helps the robot understand the nuance of the confusing edge cases without forcing it to make a hard, potentially wrong decision.

The Results

The authors tested this method on three different tasks:

A simple math puzzle with two curved lines (Two Moons).
Distinguishing between the handwritten numbers 3 and 8.
Telling cats apart from dogs in real photos (CIFAR-10).

In all three cases, LiBaGS helped the robot learn better than other methods. It didn't just add more data; it added the right data. It filled the specific gaps where the robot was weak, ignored the gaps that were already full, and threw away the weird, unrealistic fake photos.

In short: LiBaGS is a lightweight, smart manager that ensures your robot only learns from the fake examples that actually help it solve the hardest parts of the puzzle, saving time and preventing confusion.

Technical Summary: LiBaGS (Lightweight Boundary Gap Synthesis)

Problem Statement

Synthetic data is frequently employed to address scarcity, imbalance, privacy constraints, or local incompleteness in supervised learning. However, a recurring issue is that not all synthetic samples are beneficial. Samples may be rare but irrelevant (far from the decision boundary), uncertain but redundant (surrounded by existing real data), or boundary-like but harmful (lying off the real data manifold).

Existing methods, such as classical oversampling (e.g., SMOTE, ADASYN) and modern targeted generation (e.g., diffusion-based synthesis guided by uncertainty or feedback), often treat usefulness as a local score, a generation prompt, or a curriculum signal. They frequently lack an explicit mechanism to determine where synthetic samples should be placed relative to real-data coverage and how many should be retained to avoid diminishing returns.

Methodology: LiBaGS

LiBaGS is a lightweight, generator-agnostic framework for targeted synthetic training data selection. It operates as a post-processing allocation rule that scores, filters, and diversifies a finite pool of candidate synthetic samples proposed by any generator (e.g., interpolators, diffusion models, simulators).

1. Scoring and Boundary-Gap Importance

For each candidate $z$ , LiBaGS computes a "boundary-gap importance" score $r(z)$ by combining four factors:

Decision-Boundary Proximity: Measured via a smooth weight $a_\tau(z)$ based on the top-two class probability margin $\Delta(z)$ . Candidates near the boundary receive higher weights.
Predictive Uncertainty: Measured by the predictive entropy $u(z)$ of a scoring model trained on real data.
Support Validity: A score $b(z) \in [0, 1]$ ensuring the candidate lies near the real data manifold, filtering out unrealistic artifacts.
Real-Data Density: An estimate $\hat{p}(z)$ of the local density of real training samples.

The importance score is defined as:
$r(z) = a_\tau(z) \cdot u(z) \cdot b(z)$

2. Boundary-Gap Allocation Rule

LiBaGS formulates the selection problem as minimizing a local risk objective $J_m(q)$ , which approximates classification error near the decision boundary. The objective balances the importance of a region ( $r(z)$ ) against the total evidence available ($np(z) + mq(z)$).

Minimizing this objective yields an optimal allocation density $q^*(z)$ :
$q^*(z) = \frac{1}{m} \left[ \sqrt{\frac{r(z)}{\lambda}} - np(z) \right]_+$
where $\lambda$ is a normalization constant. Intuitively, this rule allocates synthetic samples to regions that are:

Important for the decision boundary (high $r(z)$ ).
Poorly covered by real data (low $np(z)$).
It assigns zero synthetic mass to regions already well-covered by real data.

In practice, for a finite candidate pool, this results in a selection score $G_j$ for each candidate $j$ :
$G_j = \left[ \sqrt{\frac{r(z_j)}{\lambda}} - n\hat{p}(z_j) \right]_+$

3. Adaptive Stopping and Diversity

Adaptive Stopping: Instead of a fixed synthetic budget, LiBaGS employs a marginal-value stopping rule. It calculates the marginal gain $\Delta_j(t_j)$ of adding a sample to a region with existing coverage. Selection continues greedily until the best remaining marginal gain falls below a threshold $\eta$ , determined by the flattening point of the marginal gain curve. This learns the optimal number of synthetic samples $b_m$ from the data.
Soft Labels: Near ambiguous boundaries, hard labels from generators can be overconfident. LiBaGS uses a soft label $\tilde{y}(z)$ that blends the generator's one-hot label with the scoring model's probability vector, weighted by the boundary proximity $a_\tau(z)$ .
Diversity Objective: To avoid selecting near-duplicates, LiBaGS maximizes a submodular objective $F(S)$ that rewards coverage of high-value candidates while penalizing redundancy based on feature-space similarity.

Key Contributions

Formulation: The authors frame targeted synthetic data selection as a boundary-gap allocation problem, explicitly modeling the trade-off between boundary importance and real-data coverage.
Derivation: They derive a boundary-gap allocation rule that integrates boundary proximity, uncertainty, support validity, and real-data density.
Algorithm: They provide a practical algorithm featuring adaptive stopping (learning the synthetic count) and diversity-aware selection.
Empirical Validation: They demonstrate that LiBaGS outperforms classical oversampling, hard augmentation, uncertainty-based selection, and targeted-generation criteria across multiple datasets.

Experimental Results

The authors evaluated LiBaGS on three tasks:

Two Moons: A nonlinear classification task with an explicit gap in the decision boundary.
8x8 Digits (3 vs. 8): A binary classification task using handwritten digits with difficult boundaries.
CIFAR-10 (Cat vs. Dog): An image classification task using a frozen ResNet-50 and a Stable Diffusion candidate pool.

Performance:

Two Moons: LiBaGS achieved 0.9454 accuracy, improving over Empirical Risk Minimization (ERM) at 0.8859 and outperforming all baselines (e.g., Deliberate Practice at 0.9437, Uncertainty-only at 0.9431).
8x8 Digits: LiBaGS achieved 0.9540 accuracy, surpassing ERM (0.9391) and other baselines like Feedback-guided (0.9516).
CIFAR-10: LiBaGS achieved 0.8159 accuracy, compared to ERM's 0.8040. While the gains are modest, they are consistent across seeds.

The results indicate that LiBaGS is most effective when the candidate pool contains informative, on-support samples located in sparse boundary regions.

Significance and Claims

The paper claims that synthetic data is most useful when it fills sparse, on-support boundary gaps rather than merely increasing dataset size. LiBaGS addresses the "usefulness" issue by:

Targeting: Explicitly selecting samples that are near the decision boundary, uncertain, and under-represented in real data.
Filtering: Rejecting candidates that are off-support or redundant.
Adaptivity: Learning the appropriate amount of synthetic data to add, avoiding the brittleness of fixed budgets.

The authors position LiBaGS as a lightweight allocation rule that can be integrated into existing synthetic data pipelines without retraining generators. They acknowledge limitations, noting that the method depends on the quality of the candidate pool and the accuracy of the support estimation, and that it does not guarantee data quality if the underlying generator is biased. The method is presented as a selection strategy to improve training signals in sparse regions, rather than a standalone solution for all data scarcity problems.