InformedAbliterationPipeline

API reference for the analysis-informed pipeline that auto-configures abliteration parameters from model geometry.

Overview

InformedAbliterationPipeline extends AbliterationPipeline with a new ANALYZE stage inserted between PROBE and DISTILL. Five analysis modules run on the collected activations and their outputs automatically configure direction extraction, layer selection, regularization, and refinement strategy — no manual tuning required.

SUMMON → PROBE → ANALYZE → DISTILL → EXCISE → VERIFY → REBIRTH
                    ↑
            auto-configures ↓
         n_directions, regularization, layers,
         direction_method, refinement_passes

from obliteratus.informed_pipeline import InformedAbliterationPipeline

pipeline = InformedAbliterationPipeline(
    model_name="meta-llama/Llama-3.1-8B-Instruct",
    output_dir="abliterated_informed",
)
output_path, report = pipeline.run_informed()

print(f"Detected alignment: {report.insights.detected_alignment_method}")
print(f"Cone type: {'polyhedral' if report.insights.cone_is_polyhedral else 'linear'}")
print(f"Refusal rate: {report.final_refusal_rate:.0%}")
print(f"Ouroboros passes: {report.ouroboros_passes}")

---

Class: obliteratus.informed_pipeline.InformedAbliterationPipeline

Inherits all parameters from AbliterationPipeline. The additional parameters below control the ANALYZE stage.

Constructor

Base Parameters (inherited)

All AbliterationPipeline constructor parameters are accepted. The method argument is fixed to "informed" internally; the base pipeline is initialized with method="advanced" and then overridden.

model_name · str · required

HuggingFace model name or local path.

output_dir · str · default: "abliterated_informed"

Output directory for the saved model and metadata.

device · str · default: "auto"

Device for model execution.

dtype · str · default: "float16"

Model dtype.

trust_remote_code · bool · default: "True"

Pass to AutoModelForCausalLM. Defaults to True for informed pipeline (wider model support).

harmful_prompts · list[str] | None · default: "None"

Custom harmful prompts. Defaults to the built-in 512-pair dataset.

harmless_prompts · list[str] | None · default: "None"

Custom harmless prompts.

on_stage · Callable[[StageResult], None] | None · default: "None"

Stage-change callback. Receives StageResult objects including the new "analyze" stage key.

on_log · Callable[[str], None] | None · default: "None"

Log message callback.

quantization · str | None · default: "None"

Quantization mode: "4bit" or "8bit".

Analysis Module Flags

run_cone_analysis · bool · default: "True"

Run ConceptConeAnalyzer to detect linear vs. polyhedral refusal geometry. Informs n_directions and direction_method.

run_alignment_detection · bool · default: "True"

Run AlignmentImprintDetector to classify DPO / RLHF / CAI / SFT. Informs regularization and kl_budget.

run_cross_layer_analysis · bool · default: "True"

Run CrossLayerAlignmentAnalyzer for cluster-aware layer selection.

run_sparse_analysis · bool · default: "True"

Run SparseDirectionSurgeon to compute Refusal Sparsity Index. Enables sparse surgery when RSI is high.

run_defense_analysis · bool · default: "True"

Run DefenseRobustnessEvaluator to estimate self-repair risk and entanglement. Informs refinement_passes and layer skipping.

Ouroboros Compensation Parameters

ouroboros_threshold · float · default: "0.5"

If post-excision refusal rate exceeds this value, trigger additional Ouroboros compensation passes (re-probe → re-distill → re-excise).

max_ouroboros_passes · int · default: "3"

Maximum number of Ouroboros compensation loops.

Entanglement & Sparsity Thresholds

entanglement_gate · float · default: "0.8"

Layers with entanglement score above this value are skipped during excision to protect capabilities.

sparse_surgery_threshold · float · default: "0.5"

RSI threshold above which sparse surgery is used instead of dense projection.

---

Method: run_informed()

def run_informed(self) -> tuple[Path, InformedPipelineReport]

Executes the full analysis-informed pipeline and returns a (output_path, report) tuple.

output_path · Path

Path to the saved abliterated model directory.

report · InformedPipelineReport

Complete report with analysis insights, pipeline stats, and Ouroboros results.

---

InformedPipelineReport

@dataclass
class InformedPipelineReport:
    insights: AnalysisInsights
    stages: list[StageResult]
    analysis_duration: float
    total_duration: float
    ouroboros_passes: int
    final_refusal_rate: float

insights · AnalysisInsights

Complete analysis insights from the ANALYZE stage. See AnalysisInsights below.

stages · list[StageResult]

Ordered list of StageResult objects from every pipeline stage.

analysis_duration · float

Seconds spent in the ANALYZE stage.

total_duration · float

Total wall-clock seconds for the entire pipeline.

ouroboros_passes · int

Number of additional compensation passes triggered because refusal rate exceeded ouroboros_threshold.

final_refusal_rate · float

Refusal rate measured after all passes (including Ouroboros compensation).

---

AnalysisInsights

Populated by the ANALYZE stage. All fields are derived from the five analysis modules.

Alignment Imprint

detected_alignment_method · str

Predicted training method: "dpo", "rlhf", "cai", "sft", or "unknown".

alignment_confidence · float

Confidence score for the prediction (0.0–1.0).

alignment_probabilities · dict[str, float]

Softmax probability for each method: {"dpo": ..., "rlhf": ..., "cai": ..., "sft": ...}.

Concept Cone Geometry

cone_is_polyhedral · bool

True if the refusal subspace is polyhedral (multiple distinct directions), False if linear (single direction).

cone_dimensionality · float

Effective dimensionality of the refusal cone (1.0 = linear, >2.0 = clearly polyhedral).

mean_pairwise_cosine · float

Mean pairwise cosine similarity between per-category refusal directions.

per_category_directions · dict[str, torch.Tensor]

Per-harm-category refusal directions (e.g., {"weapons": ..., "cyber": ...}).

Cross-Layer Structure

direction_clusters · list[list[int]]

Layer clusters grouped by refusal-direction similarity.

cluster_count · int

Number of distinct refusal-direction clusters detected.

direction_persistence · float

0 = completely independent per layer, 1 = single persistent direction across all layers.

cluster_representative_layers · list[int]

Strongest layer (by refusal norm) from each cluster — used as warm-start for Bayesian optimizer.

Defense Robustness

estimated_robustness · str

Estimated alignment defense strength: "low", "medium", "high", or "very_high".

self_repair_estimate · float

Estimated Ouroboros self-repair capacity (0.0–1.0). Values above 0.7 trigger 3 refinement passes.

entanglement_score · float

Overall safety-capability entanglement (0 = fully separable, 1 = fully fused).

entangled_layers · list[int]

Layers above the entanglement gate — skipped during excision.

clean_layers · list[int]

Layers where refusal can be cleanly separated from capability.

Derived Configuration

These fields reflect what the pipeline actually used, after the analysis override:

recommended_n_directions · int

Final number of directions chosen by analysis.

recommended_direction_method · str

Final direction method: "diff_means", "svd", or "leace".

recommended_regularization · float

Final regularization value derived from alignment method + entanglement score.

recommended_refinement_passes · int

Final pass count derived from self-repair estimate.

recommended_layers · list[int]

Final layer selection after cluster analysis and entanglement gating.

skip_layers · list[int]

Layers excluded from excision due to high entanglement.

---

Code Examples

Basic Informed Run

from obliteratus.informed_pipeline import InformedAbliterationPipeline

pipeline = InformedAbliterationPipeline(
    model_name="meta-llama/Llama-3.1-8B-Instruct",
    output_dir="abliterated_informed",
)
output_path, report = pipeline.run_informed()

print(InformedAbliterationPipeline.format_insights(report.insights))

from obliteratus.informed_pipeline import InformedAbliterationPipeline

pipeline = InformedAbliterationPipeline(
    model_name="Qwen/Qwen2.5-7B-Instruct",
    # Skip sparse analysis for speed
    run_sparse_analysis=False,
    # Tighten Ouroboros threshold
    ouroboros_threshold=0.3,
    max_ouroboros_passes=5,
    # Gate highly entangled layers aggressively
    entanglement_gate=0.6,
)
output_path, report = pipeline.run_informed()
insights = report.insights
print(f"Used {insights.recommended_n_directions} directions via {insights.recommended_direction_method}")
print(f"Skipped entangled layers: {insights.skip_layers}")

from obliteratus.informed_pipeline import InformedAbliterationPipeline

pipeline = InformedAbliterationPipeline(model_name="mistralai/Mistral-7B-Instruct-v0.3")
_, report = pipeline.run_informed()

i = report.insights
print(f"Alignment: {i.detected_alignment_method} ({i.alignment_confidence:.0%} confidence)")
print(f"Cone: {'polyhedral' if i.cone_is_polyhedral else 'linear'}, dim={i.cone_dimensionality:.2f}")
print(f"Clusters: {i.cluster_count} groups")
print(f"Self-repair risk: {i.self_repair_estimate:.2f}")
print(f"Ouroboros passes applied: {report.ouroboros_passes}")
print(f"Final refusal rate: {report.final_refusal_rate:.0%}")
print(f"Analysis took: {report.analysis_duration:.1f}s")