Enum GenerationStrategy 

pub enum GenerationStrategy {
    Template,
    EDA,
    BackTranslation,
    MixUp,
    GrammarBased,
    SelfTraining,
    WeakSupervision,
}

Available synthetic data generation strategies.

Each strategy uses different techniques for creating synthetic samples, with trade-offs between quality, diversity, and computational cost.

Example

use aprender::synthetic::GenerationStrategy;

let strategy = GenerationStrategy::EDA;
assert_eq!(strategy.name(), "eda");
assert!(strategy.description().contains("Augmentation"));

References

• Template: Cubuk et al. (2019). AutoAugment. CVPR.
• EDA: Wei & Zou (2019). Easy Data Augmentation. EMNLP.
• BackTranslation: Sennrich et al. (2016). Back-translation. ACL.
• MixUp: Zhang et al. (2018). MixUp. ICLR.
• GrammarBased: Jia & Liang (2016). Data Recombination. ACL.
• SelfTraining: Xie et al. (2020). Noisy Student. CVPR.
• WeakSupervision: Ratner et al. (2017). Snorkel. VLDB.

Variants

Template

Template-based generation with slot filling.

Uses parameterized templates to generate variations by filling slots with different values. Fast and controllable, but limited diversity.

EDA

Easy Data Augmentation (synonym replacement, random insertion/swap/deletion).

Simple text transformations that preserve semantics while creating surface-level variations. Good baseline with low computational cost.

BackTranslation

Back-translation through pivot representation.

Translates to intermediate representation and back, creating paraphrases. High quality but requires translation models or intermediate formats.

MixUp

MixUp interpolation in embedding space.

Creates virtual examples by interpolating between existing samples in latent space. Improves generalization and decision boundaries.

GrammarBased

Grammar-based recombination from rules.

Uses formal grammar to generate valid samples by recombining syntactic components. Guarantees syntactic correctness.

SelfTraining

Self-training with pseudo-labels.

Uses model predictions on unlabeled data as synthetic labels. Iteratively improves with curriculum ordering.

WeakSupervision

Programmatic weak supervision with labeling functions.

Uses heuristic rules to label unlabeled data, then combines noisy labels using a generative model.

Implementations

impl GenerationStrategy

pub fn name(&self) -> &'static str

Get the strategy name as a string identifier.

pub fn description(&self) -> &'static str

Get a human-readable description of the strategy.

pub fn computational_cost(&self) -> u8

Get the relative computational cost (1 = lowest, 5 = highest).

pub fn requires_model(&self) -> bool

Check if this strategy requires a trained model.

pub fn preserves_labels(&self) -> bool

Check if this strategy preserves label semantics.

pub fn all() -> &'static [GenerationStrategy]

Get all available strategies.

pub fn from_name(name: &str) -> Option<Self>

Parse strategy from string name.

Arguments

• name - Strategy name (case-insensitive)

Returns

Some(strategy) if valid, None if unrecognized.

Trait Implementations

impl Clone for GenerationStrategy

fn clone(&self) -> GenerationStrategy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GenerationStrategy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GenerationStrategy

fn default() -> Self

Default strategy is EDA (simple, effective, low cost).

impl Display for GenerationStrategy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for GenerationStrategy

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for GenerationStrategy

fn eq(&self, other: &GenerationStrategy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for GenerationStrategy

impl Eq for GenerationStrategy

impl StructuralPartialEq for GenerationStrategy