👻 Erasus

🚀 Try it NOW (No Setup Required)

Why Erasus?

🧠 How It Works

┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
│ 1. CORESET SELECTION │────▶│ 2. TARGETED │────▶│ 3. EVALUATION & │
│ │ │ UNLEARNING │ │ CERTIFICATION │
│ Pick the minimal │ │ │ │ │
│ set of samples that │ │ Apply gradient ascent,│ │ MIA, accuracy, │
│ define forgetting │ │ Fisher, SCRUB, LoRA, │ │ perplexity, FID, │
│ "support vectors" │ │ or 16+ other methods │ │ certified removal │
└──────────────────────┘ └──────────────────────┘ └──────────────────────┘

⚡ Key Features

🏗️ Supported Models

📦 Installation

# From PyPI
pip install erasus
pip install erasus[full] # with diffusers, datasets, wandb, etc.
pip install erasus[hub] # Hugging Face Hub push/pull
# From source (development)
git clone https://github.com/OnePunchMonk/erasus.git
cd erasus
pip install -e .
# With all optional dependencies
pip install -e ".[full]"
# Hugging Face Hub (push/pull unlearned models)
pip install -e ".[hub]"
# Interactive dashboards (Streamlit / Gradio)
pip install -e ".[dashboard]"
# Development
pip install -e ".[dev]"

Notebooks & dashboards

Quick Setup Script

bash scripts/setup_env.sh # CPU
bash scripts/setup_env.sh --gpu # CUDA 12.1

Docker

docker compose -f docker/docker-compose.yml up test # Run tests
docker compose -f docker/docker-compose.yml run dev # Dev shell
docker compose -f docker/docker-compose.yml up benchmark # GPU benchmarks

🚀 Quick Start

Python API

from erasus.unlearners import ErasusUnlearner
# 1. Load your model
model = ... # Any PyTorch model
# 2. Create unlearner
unlearner = ErasusUnlearner(
 model=model,
 strategy="gradient_ascent", # 27 strategies available
 selector="influence", # 19 selectors available
 device="cuda",
)
# 3. Unlearn
result = unlearner.fit(
 forget_data=forget_loader, # Data to remove
 retain_data=retain_loader, # Data to preserve
 prune_ratio=0.1, # Use top 10% coreset
 epochs=5,
)
# 4. Evaluate
metrics = unlearner.evaluate(
 forget_data=forget_loader,
 retain_data=retain_loader,
)
print(f"MIA AUC: {metrics['mia_auc']:.4f}") # Should → 0.5

Modality-Specific Unlearners

from erasus.unlearners import VLMUnlearner, LLMUnlearner, DiffusionUnlearner
# CLIP: Remove NSFW concepts
vlm = VLMUnlearner(model=clip_model, strategy="modality_decoupling")
vlm.fit(forget_data=nsfw_loader, retain_data=safe_loader)
# LLaMA: Remove hazardous knowledge
llm = LLMUnlearner(model=llama_model, strategy="gradient_ascent")
llm.fit(forget_data=harmful_loader, retain_data=benign_loader)
# Stable Diffusion: Remove artist styles
diff = DiffusionUnlearner(model=sd_model, strategy="concept_erasure")
diff.fit(forget_data=artist_loader, retain_data=general_loader)

Auto-Detect Model Type

from erasus.unlearners import MultimodalUnlearner
# Automatically picks the right unlearner
unlearner = MultimodalUnlearner.from_model(your_model)

CLI

# Run unlearning
erasus unlearn --config configs/default.yaml
# Evaluate results
erasus evaluate --config configs/default.yaml --checkpoint model.pt
# Run benchmarks
erasus benchmark --strategies gradient_ascent,scrub --selectors random,influence
# Generate visualizations
erasus visualize --type embeddings --method tsne --output embeddings.png
erasus visualize --type comparison --output comparison.png
erasus visualize --type report --output report.html

🔧 Strategies & Selectors

Unlearning Strategies (30)

Coreset Selectors (24)

📊 Evaluation & Metrics

from erasus.metrics import MetricSuite
suite = MetricSuite(["accuracy", "mia", "perplexity"])
results = suite.run(model, forget_loader, retain_loader)

📈 Visualization

from erasus.visualization import (
 EmbeddingVisualizer,
 LossLandscapeVisualizer,
 GradientVisualizer,
 ReportGenerator,
)
from erasus.visualization.attention import AttentionVisualizer
from erasus.visualization.comparisons import ComparisonVisualizer
# t-SNE / PCA embeddings
viz = EmbeddingVisualizer(model)
viz.plot(data_loader, method="tsne")
# Loss landscape
landscape = LossLandscapeVisualizer(model)
landscape.plot_2d_contour(data_loader)
# Attention heatmaps (before vs. after)
attn_viz = AttentionVisualizer(model_after)
attn_viz.plot_attention_comparison(inputs, model_before)
# Before/after comparisons
comp = ComparisonVisualizer()
comp.plot_prediction_shift(model_before, model_after, forget_loader)
comp.plot_metric_comparison(metrics_before, metrics_after)
# HTML report
report = ReportGenerator("Unlearning Report")
report.add_metrics(metrics)
report.save("report.html")

🔐 Certification & Privacy

from erasus.certification import CertifiedRemovalVerifier, UnlearningVerifier
# Formal (ε, δ)-removal verification
verifier = CertifiedRemovalVerifier(epsilon=1.0, delta=1e-5)
result = verifier.verify(unlearned_model, retrained_model, n_total=10000, n_forget=500)
print(f"Certified: {result['certified']}")
# Statistical verification
stat_verifier = UnlearningVerifier(significance=0.05)
tests = stat_verifier.verify_all(model, forget_loader, retain_loader)

Theoretical Bounds

from erasus.certification.bounds import TheoreticalBounds
# PAC-learning utility bound
bounds = TheoreticalBounds.pac_utility_bound(
 n_total=50000, n_forget=500, n_retain=49500, delta=0.05, model=model,
)
print(f"Utility drop bound: {bounds['pac_utility_drop_bound']:.4f}")
# Certified unlearning radius
radius = TheoreticalBounds.unlearning_radius(
 epsilon=1.0, delta=1e-5, n_forget=500,
)
print(f"Certified radius: {radius['certified_radius']:.4f}")

📉 Loss Functions

🧪 Experiment Tracking

from erasus.experiments import ExperimentTracker, HyperparameterSearch, AblationStudy
# Supports: "local", "wandb", "mlflow"
with ExperimentTracker("clip_unlearning", backend="wandb") as tracker:
 tracker.log_config({"strategy": "gradient_ascent", "lr": 1e-4})
 result = unlearner.fit(...)
 tracker.log_metrics({"mia_auc": 0.52, "accuracy": 0.94})
 tracker.log_model(model)
# Hyperparameter search (Optuna or random fallback)
search = HyperparameterSearch(
 objective_fn=my_objective,
 param_space={"lr": {"type": "float", "low": 1e-5, "high": 1e-2, "log": True}},
 n_trials=50,
)
best = search.run()
# Ablation studies
ablation = AblationStudy(base_config={...}, run_fn=run_trial)
ablation.run_full_ablation({"lr": [1e-3, 1e-4, 1e-5], "strategy": ["ga", "scrub"]})
print(ablation.summary())

📁 Project Structure

erasus/
├── core/ # Base classes, registry, config, types
├── unlearners/ # High-level API (7 modality-specific unlearners)
├── strategies/ # 27 unlearning algorithms (gradient, parameter, data, LLM, diffusion, VLM, ensemble)
├── selectors/ # 19 coreset selection methods (gradient, geometry, learning, ensemble)
├── metrics/ # 15+ evaluation metrics (forgetting, utility, efficiency, privacy)
├── losses/ # 8 loss functions (retain-anchor, Fisher, adversarial, triplet, KL, MMD, L2)
├── visualization/ # Embeddings, loss surfaces, gradients, attention heatmaps, comparisons, reports
├── data/ # Dataset loaders (TOFU, WMDP, COCO, I2P, CC), preprocessing, partitioning
├── models/ # 10 model wrappers (VLM, LLM, diffusion, audio, video)
├── privacy/ # DP mechanisms, privacy accountant, certificates
├── certification/ # Certified removal, statistical verification, theoretical bounds
├── experiments/ # W&B / MLflow / local tracking, HPO, ablation studies
├── cli/ # Command-line interface (unlearn, evaluate, benchmark, visualize)
└── utils/ # Checkpointing, distributed, helpers, logging, callbacks, early stopping

🏆 Benchmarks

# TOFU Benchmark (LLM unlearning)
python benchmarks/tofu/run.py --strategies gradient_ascent,scrub --epochs 5
# Coreset comparison (knowledge_distillation ×ばつ all selectors)
python benchmarks/tofu/run_coreset_comparison.py
# MUSE Benchmark (all strategies, leaderboard)
python benchmarks/muse/run_all_strategies.py
# WMDP Benchmark (hazardous knowledge, all strategies)
python benchmarks/wmdp/run_all_strategies.py --subsets bio,cyber
# Full suite
bash scripts/run_benchmarks.sh

🧑‍💻 Examples

✅ Test Status

340 tests passed ✅ | 0 failed | 54s

python -m pytest tests/ -v --tb=short

📚 Research References

🗺️ Roadmap

💡 Project ideas

🤝 Contributing

# Setup development environment
git clone https://github.com/OnePunchMonk/erasus.git
cd erasus
pip install -e ".[dev]"
python -m pytest tests/ -v

📜 License

📖 Citation

@software{erasus2026,
 title={Erasus: Universal Machine Unlearning via Coreset Selection},
 author={Aggarwal, Avaya},
 year={2026},
 url={https://github.com/OnePunchMonk/erasus}
}