abstraction-augmented-continual-learning

name	abstraction-augmented-continual-learning
title	Abstraction-Augmented Training: Loss Function Modification for Continual Learning
version	0.0.3
engine	skillxiv-v0.0.3-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2603.17198
keywords	["Continual Learning","Loss Function","Catastrophic Forgetting","Structural Generalization","Online Learning"]
description	Replace standard supervised fine-tuning loss with a dual-objective loss that jointly optimizes over both concrete instances and their abstract representations (entity-masked versions), eliminating need for replay buffers and improving cumulative accuracy by 2-5% on continual learning benchmarks. Use when streaming data contains latent relational structure, catastrophic forgetting is problematic, and you want to maintain structural understanding without memory overhead.
category	Component Innovation

What This Skill Does

Swap standard cross-entropy loss in continual learning with a dual-objective loss that simultaneously optimizes concrete instances and abstract versions (entity-masked or key-component-removed versions), enabling models to learn generalizable structure without maintaining large replay buffers.

The Component Swap

Old component: Standard supervised fine-tuning with only concrete instance labels, which causes entity-specific gradients to dominate and overwrites prior knowledge during streaming updates.

# Traditional continual learning: optimize only concrete instances
class StandardContinualLearning(nn.Module):
    def __init__(self, model):
        super().__init__()
        self.model = model

    def training_step(self, batch):
        inputs, labels = batch  # Concrete instances only
        logits = self.model(inputs)
        loss = F.cross_entropy(logits, labels)
        return loss

New component: Dual-objective loss combining concrete and abstract objectives, with balanced weighting to prevent catastrophic forgetting.

class AbstractionAugmentedTraining(nn.Module):
    def __init__(self, model, abstraction_fn, alpha=0.5, use_replay=True):
        super().__init__()
        self.model = model
        self.abstraction_fn = abstraction_fn  # Entity masking, key removal, etc.
        self.alpha = alpha  # Weight for abstract vs. concrete
        self.use_replay = use_replay  # Optional: small replay buffer for stability

     ():
        
         .abstraction_fn(inputs)

     ():
        
        inputs_concrete, labels_concrete = concrete_batch

        
        logits_concrete = .model(inputs_concrete)
        loss_concrete = F.cross_entropy(logits_concrete, labels_concrete)

        
         abstract_batch  :
            
            inputs_abstract = .create_abstract_version(inputs_concrete)
            labels_abstract = labels_concrete  
        :
            inputs_abstract, labels_abstract = abstract_batch

        logits_abstract = .model(inputs_abstract)
        loss_abstract = F.cross_entropy(logits_abstract, labels_abstract)

        
        loss_balanced = .alpha * loss_concrete + ( - .alpha) * loss_abstract

        
         .use_replay  replay_batch   :
            inputs_replay, labels_replay = replay_batch
            logits_replay = .model(inputs_replay)
            loss_replay = F.cross_entropy(logits_replay, labels_replay)
            loss_balanced = loss_balanced +  * loss_replay

         loss_balanced

     ():
        
        
        abstract_inputs = .create_abstract_version(new_inputs)

        
        loss = .training_step(
            concrete_batch=(new_inputs, new_labels),
            abstract_batch=(abstract_inputs, new_labels)
        )

         loss