Docs
Everything you need to get started with Remap Studios — from installation to advanced usage.
Installation
Desktop App
Download the latest release for your platform from the Downloads page. The desktop app bundles everything you need — no separate Python installation required for basic usage.
# macOS — drag Remap Studios to Applications # Windows — run the installer or use portable .exe # Linux — chmod +x the AppImage and run it
Dependencies
Remap Studios requires Python 3.9+ and PyTorch 2.1+. Install core dependencies:
# CPU only pip install torch safetensors psutil numpy # NVIDIA GPU (CUDA 12.1) pip install torch --index-url https://download.pytorch.org/whl/cu121 pip install safetensors psutil numpy # Apple Silicon GPU (MPS) pip install torch safetensors psutil numpy
Quick Start
Get from zero to your first unlearned model in under 5 minutes.
Open a Model
Launch Remap Studios and click Open File (⌘O). Select a .safetensors, .pt, .gguf, or model directory. The app will parse tensors, compute statistics, and build the layer graph.
Explore the Architecture
Switch to the Visualization tab to see your model as an interactive neural network graph. Hover over nodes to inspect layers. Use Weight Explorer to see individual tensor statistics.
Configure Unlearning
Go to the Unlearn tab. Select a target capability (what you want the model to forget), choose a method (Retain-Aware is recommended), and set your training steps and learning rate.
Run & Monitor
Click Start Unlearning. Watch the real-time loss curves, weight changes, and node erasure progress. The unlearning canvas shows forget loss, retain loss, and total loss simultaneously.
Export the Result
Once complete, export via File → Export (⌘E). Choose from Safetensors, PyTorch, GGUF, or ONNX format. The exported model has fewer parameters and faster inference.
System Requirements
Minimum
- ✓macOS 12+, Windows 10+, or Ubuntu 20.04+
- ✓4 GB RAM
- ✓Python 3.9+
- ✓500 MB disk space (plus model files)
- ✓Any modern CPU
Recommended
- ✓8+ GB RAM
- ✓NVIDIA GPU with CUDA 12+ or Apple M1/M2/M3
- ✓SSD for fast model loading
- ✓Python 3.11+ with PyTorch 2.2+
Machine Unlearning
Machine unlearning is the process of making a trained model forget specific knowledge without retraining from scratch. Traditional approaches require full retraining, which costs the same compute as the original training run. Unlearning achieves the same result in a fraction of the time and compute.
Why it matters: Large language models learn patterns, facts, biases, and redundant representations during training. Much of this is unnecessary for your specific use case. Unlearning lets you surgically remove what you don't need while preserving what you do.
Applications:
- →Remove memorized training data (privacy compliance)
- →Eliminate biased or harmful knowledge
- →Reduce model size without retraining
- →Specialize a general model for a specific domain
- →Remove redundant parameters to cut inference costs
Model Architecture
A neural network is organized into layers, each containing tensors (multi-dimensional arrays of numbers). Understanding this structure is key to effective unlearning.
Embedding Layers
Convert input tokens into dense vectors. Usually fixed after training — not a target for unlearning.
Attention Layers
The core of transformer models. Compute relevance scores between tokens. Most knowledge is stored here.
Feed-Forward Layers
Two linear transformations with activation. Contain the bulk of parameters — primary target for pruning.
Output Layer
Projects hidden states back to vocabulary space. Usually not modified during unlearning.
Unlearning Methods
Remap Studios supports three unlearning methods, each with different tradeoffs.
Retain-Aware Unlearning
RecommendedThe default and recommended method. It simultaneously forgets the target capability while actively preserving unrelated knowledge. Uses a dual-objective loss function.
+ Highest accuracy retention
+ Minimal collateral damage
+ Works on all model sizes
− Slightly slower than basic methods
Use this for almost everything — it's the best balance of forgetting quality and knowledge preservation.
Gradient Forgetting
A baseline method that maximizes loss on the target capability by reversing gradient direction. Simple but may cause collateral damage to unrelated knowledge.
+ Fastest method
+ Simple implementation
− May degrade unrelated capabilities
− Less precise targeting
Quick experiments or when speed matters more than precision.
Knowledge Distillation
Uses a teacher-student framework where the student model learns to replicate the teacher's behavior on retain data while ignoring forget data.
+ Good for large models
+ Can produce smaller student models
− Requires more compute
− Needs careful tuning
When you also want to compress the model size, not just unlearn.
Loading Models
Remap Studios supports multiple model formats. You can load individual files or entire model directories.
| Format | Extension | Notes |
|---|---|---|
| Safetensors | .safetensors | Preferred format. Fast loading, memory-mapped. |
| PyTorch | .pt / .pth | Standard PyTorch checkpoint format. |
| GGUF | .gguf | Quantized format for inference. Read-only (convert for unlearning). |
| ONNX | .onnx | Cross-framework format. Read-only analysis supported. |
| Jupyter Notebook | .ipynb | Parses notebook cells for model code detection. |
| HuggingFace Dir | (directory) | Loads config.json + weight files from a model directory. |
Tip: Use Open Folder (⌘⇧O) to load an entire HuggingFace model directory. The app will auto-detect the format and load all weight files.
Weight Analysis
The Weight Explorer lets you inspect individual tensors in your model. Select a layer from the dropdown to see all its tensors with shapes, dtypes, and sizes.
Per-Tensor Statistics
Click any tensor to view detailed statistics in the Properties panel:
- •Mean, Std, Min, Max, Median
- •L2 Norm
- •Zero count and percentage
- •Skewness and Kurtosis (distribution shape)
- •Percentiles (P1, P5, P25, P75, P95, P99)
Heatmap Visualization
Switch to the Heatmap tab to see a 2D weight distribution visualization. Select a tensor from the dropdown — the heatmap renders a 128×128 downsampled view of the weight matrix. Brighter pixels indicate higher absolute values.
Running Unlearning
Navigate to the Unlearn tab and configure your unlearning run:
Target Capability
RequiredWhat you want the model to forget. Select from detected capabilities or enter a custom target.
Method
Retain-Aware UnlearningThe unlearning algorithm. Retain-Aware is recommended for most use cases.
Training Steps
200Number of optimization steps. More steps = more thorough forgetting, but diminishing returns past ~500.
Learning Rate
1e-5Step size for gradient updates. Too high causes instability; too low means slow convergence.
Retain Weight
2.0How much to prioritize preserving unrelated knowledge. Higher = safer but slower forgetting.
Batch Size
8Number of samples processed per step. Larger batches are more stable but use more memory.
Evaluation
After unlearning, evaluate the result to confirm the target was forgotten while unrelated capabilities remain intact.
- →Compare weight distributions before and after using the heatmap
- →Check forget loss convergence in the unlearning visualization
- →Monitor retain loss to ensure no collateral damage
- →Run evaluation probes on specific capabilities
- →Measure parameter reduction and inference speed improvement
Exporting Models
Export your unlearned model via File → Export (⌘E). Supported output formats:
Safetensors
.safetensorsPreferred format. Fast loading, safe for production.
PyTorch
.ptStandard checkpoint. Compatible with all PyTorch tooling.
GGUF
.ggufQuantized format for llama.cpp and Ollama.
ONNX
.onnxCross-framework format for production deployment.
Desktop App — IDE Overview
The Remap Studios desktop app is a professional IDE for model unlearning. Here's the layout:
Keyboard Shortcuts
File
View
Navigation
Run
AI Chat Assistant
The AI Assistant (bottom-right panel) helps you analyze your model using natural language. Load a model first, then ask questions like:
Need help?
Can't find what you're looking for? Reach out through any of these channels: