Load the fine-tuned HarmBench Llama-2-13B classifier. Model: cais/HarmBench-Llama-2-13b-cls Paper: Mazeika et al. (2024) — HarmBench (ICML 20

Load watchtower state from disk.

Load state from disk for resumption.

Create harmful/harmless activations with planted refusal signal.

Create a minimal ModelHandle with a tiny GPT-2 for testing (no network).

Create a forward hook that applies steering vectors.

Create a minimal ModelHandle with a tiny GPT-2 for testing.

Create a minimal ModelHandle with a tiny GPT-2 for testing.

Measure how well a transferred direction separates harmful/harmless. Fidelity = correlation between source projection magnitudes and

Measure KL divergence from reference (pre-ablation) logits.

Measure refusal rate on a subset of harmful prompts. Applies the model's chat template (when available) so the model is in chat mode — matchi

Measure how selectively a projector targets its intended category. Selectivity = 1 - (collateral damage / intended removal) Collatera

Generate all combinations of sweep parameters.

Extract Pareto-optimal trials (refusal reduction vs distortion).

Let the user choose their compute tier with auto-detection.

Show models for the chosen tier and let the user pick.

Let the user pick how many samples to evaluate on (custom mode).

Let the user choose which ablation strategies to run (custom mode).

Let the user pick an ablation preset or go custom. Returns a StudyPreset if chosen, or None for custom mode.

Pre-compute per-layer statistics for fast trial evaluation.

Print results as CSV.

Print launch configuration.

Print model recommendations based on detected hardware.

Print a human-readable summary of aggregated results.

Print a beautiful system info panel.

Generate a random projection configuration.

Compute Spearman-like rank agreement between projection and causal rankings.

Save model with comprehensive analysis metadata.

Subtract dominant benign activation PCs from refusal directions.

Remove protected concept atoms with ridge-regularized projection.

Rescale weight matrices to their previously captured norms. Should be called ONCE after ALL subspace directions have been projected o

Restore completed rounds and interrupted round state from checkpoint. Returns: (result_with_completed_rounds, partial_contenders, remaini

Convert benchmark results list to a CSV string. Returns None if empty.

Run lm-evaluation-harness via CLI subprocess.

Run lm-evaluation-harness via Python API.

Run a single method, optionally inside a gpu_wrapper.

Run ablation with quantized model loading.

Run model with a single activation patched.

Safely convert a value to float, returning None on failure.

Write benchmark results to a temp CSV file and return the path.

Save tournament progress so it can be resumed after quota exhaustion.

Save sweep results to JSON.

Synchronously write a v2 telemetry report to local JSONL and sync to Hub.

Approximate silhouette score from cosine similarity matrix.

Simulate self-repair graph when no empirical data is available. Uses heuristic: when layer i is ablated, layers with high refusal str

Build base SSH command with common options.

Find a writable directory for telemetry storage. Priority order: 1. ``OBLITERATUS_DATA_DIR`` env var (explicit override) 2. HuggingFace S

Execute *fn* inside a ZeroGPU GPU allocation. Used by ``run_tourney`` to give each tournament method its own 5-minute GPU allocation instead

TPE-inspired sampling: bias towards configurations similar to good trials.

Transport a refusal direction through the OT map. Applies T to the source direction and normalizes in the target space.

Estimate curvature from a single triangle using angle excess. On a Riemannian manifold with curvature K, the angle sum of a geodesic

Verify excision and run Ouroboros-compensated refinement if needed. After the initial excision, uses analysis modules to detect: 1. R

Winsorize activation vectors to tame outlier values. Clamps each layer's activations to the [p, 1-p] percentile range computed across

Analyze refusal directions across all layers with trained probes. Args: refusal_directions: {layer_idx: direction} for each layer

Analyze cone geometry across multiple layers. Args: harmful_acts: {layer_idx: [activations]} per layer. harmless_acts

Apply pre-computed LoRA adapters by modifying weights in-place. This is equivalent to merging the LoRA into the base model. The adapters dict

Project refusal direction out of weight matrices. When multi_dir_norm_fix=True, uses the correct approach: capture norms before projecting an

Generate a Hub repo ID like ``{namespace}/{short_model}-OBLITERATED``. If *org* is given, uses that as the namespace (e.g. a shared community org

Run multiple abliteration methods on a single model and compare results. This is the API endpoint that enables programmatic benchmarking — call i

Extract the hyperparameter ranges from top-performing runs. Takes the top 25% of runs by composite score and returns the median value

Blend Pass 2 layers with per-layer gradient gamma.

Blend Pass 2 layers toward stock: W = (1-gamma)*W_v1 + gamma*W_stock.

Build the remote obliteratus CLI command.

Build remote 'obliteratus run' command.

Build remote 'obliteratus tourney' command.

Remove temporary offload directory if one was auto-created.

Coherence check.

Coherence check: 6 capability prompts, check for direct/useful responses.

Collect first-token logits from the original (pre-abliteration) model.

Compare base vs. instruct activations to measure alignment delta. Args: base_activations: {layer_idx: mean_activation} from base

Compute rank correlation between Tuned Lens and Logit Lens gap rankings. Args: tuned_result: MultiLayerTunedLensResult from analy

Compare whitened vs standard SVD directions. Returns cosine similarities between the whitened and standard directions, revealing how

Score an abliteration run on [0, 1]. Higher is better. Weights: 35% refusal removal — the whole point 25% coherence

Compute geodesic (curvature-aware) projection for a single activation. Standard linear projection: x' = x - (x^T r) r Geodesic projec

Compute per-layer gamma using a gradient strategy.

Compute LoRA adapter pairs (B, A) for refusal direction ablation. For each target weight matrix W with refusal direction d: A = d^T @ W

Create a tiny GPT-2 model for controlled experiments.

Full-gate Pareto dominance with capability as a secondary axis.

Compare effective rank before and after abliteration. Args: weight_before: Original weight matrix. weight_after: Weight matrix af