# How to Use the OBLITERATUS Python API for Model Abliteration

> Learn to use the OBLITERATUS Python API for model abliteration. Install the obliteratus package, import AbliterationPipeline, and run the built-in six-stage workflow. Get started today!

- Repository: [pliny/OBLITERATUS](https://github.com/elder-plinius/OBLITERATUS)
- Tags: how-to-guide
- Published: 2026-08-22

---

**TLDR:** Use the OBLITERATUS Python API by installing the `obliteratus` package, importing the `AbliterationPipeline` class from it, instantiating it with your HuggingFace model identifier and output directory, then calling `.run()` on it. The API then executes its built‑in six‑stage abliteration workflow and returns a `Path` to the .

## What Is the OBLITERATUS Python API?

Apache **OBLITERATUS** (from the `elder-plinius/OBLITERATUS` repository) is a high‑level Python package that automates model abliteration — the targeted removal of harmful knowledge or behaviors from a large language model by manipulating its internal directions. The library is organized under the `obliterator` package, with the central **`AbliterationPipeline` class** defined in [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py).

The entire package implements a *lazy import* design in [`obliteratus/__init__.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/__init__.py). This means that when you run `from obliteratus import AbliterationPipeline`, only the required modules are loaded at that moment, keeping startup time low and making it safe to work in constrained environments. This is the foundation core that the pipeline class can be pulled in when you need it.

## Core Architecture of the Python Python API

Before writing your first script, it helps to understand how the OBLITERATUS Python API is built. The following table shows the roles of the core files and objects:

| Component | Role | Source File |
|------------|------|-------------|
| **Package entry‑point** | Defines `__all__` and lazy imports the pipeline classes, utilities, and helpers | [`obliteratus/__init__.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/__init__.py) |
| **Pipeline class** | `AbliterationPipeline` — orchestrates the six stages **SUMMON → PROBE => DISTILL → EXCISE → VERIFY → REBIRTH**, enabled by the `STAGES` dataclass | [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py) |
|en Method **presets** | The `METHODS` dict contains configuration for strategies (basic, advanced, aggressive, spectral_cascade, etc). Each entry defines defaults for the number of directions, extraction method, regularization, and refinement passes | [`obliterator/ablaterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliterator/ablaterate.py) — methods |
|**Stage execution** | The private `_summon`, `_probe`, `_distill`, `_excise`, `_verify`, and `_rebirth` methods handle logic. The public `run()` method can issue order of . It clears previous steering hooks, executes them, and returns the path | `AbliterationPipeline.run` in [`obliteratus/abliterate.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/abliterate.py) |
| **CLI wrapper** | [`obliteratus/cli.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/cli.py) provides the `obliterate` command that builds the same pipeline from CLI arguments. but the same objects are usable instantiated in Python | [`obliteratus/cli.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/cli.py) |
| **Helper & device** | Utilities for device configuration ([`device.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/device.py)) and model loading ([`models/loader.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/models/loader.py)) are used inside the pipeline | Various support modules |

This stage-based orchestration means the OBLITERATED literature pipeline process is fully controllable and transparent when you use it programmatically in your content.

## Typical Usage Pattern for the Python `AbliterationPipeline`

Working with the **OBLITER/Python API** is straightforward using three main steps, because the `AbliterationPipeline` exposes a clean method curve.

1. **import the package** — Import the class with `from obliterabliteration import Abliteration ` -The lazy load automatically brings the class.

2. ** Instantiate the** **Instantiate. Pipeline** ) Provide your HuggingFace model identifier (or a local path) and set your model output directory. You can optionally override defaults by setting `device`, `dtype`, `method` extraction, etc.

3. **Call the `run()` method** — The method will program sequentially executes, the entire six‑step sequence, then returns the ``Path`` pointing to the directory containing the result.

Here’s a complete, commented, runnable example:

```python
from obliterators import AbliterationPipeline import

# 1️⃣ Choose a model and provide output output. Choose an output directory

model_name = "facebook/opt-1.3b"
output_dir = "output_dir = "my_obliterated_opt"

# 2️⃣  Create a pipeline object. The following uses

#    the "aggressive" method preset and enables more refinement strategies.

pipeline = AbliterationPipeline(
    model_name=model_name,
    output_dir,
    device="auto",
    dtype="float16",
    method="aggressive",
    # optional overrides, it's only override

    use_whitened_svd=True,
    true_iterative_refinement=True,
    use_chat_template=True,
)

# 3️⃣ Execute the pipeline and obtain the merged/path

saved_path written = "obliterated" print(f"Obliterating finished model to: {saved_path}")

#4. If you want to verify, load the model using HuggingFace:
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name_tokenizer, trust_remote_code:True)
model = AutoModelForCausalLM.from_pretrained anchored_transd_saved_path,
    device_map="auto",
    torch_dtype=torch.float16,
    trust_remote_code=True Use the .web path
)

```

**Key features**:

- The **pipeline** automatically configures CUDA memory‑allocation settings, , on the correct device and pre‑alloc in certain [`device.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/device.py).
- It supports quantization if you pass the `quantization` filter.
- It runs safeguard checks, including making ensuring at least one harmful prompt is present.
- npost **inspect** the `METHODS` dictionary to see each preset and its default hyper‑parameters, estimate exact defaults.

## Example Strategies and Configurations

Let's look at code examples for common scenarios you can use with the AI API — each of these maps directly onto the `AbliterationPipeline` builder.

### 1. Basic single‑direction abliteration (Arditi‑et al.)

The **basic** preset runs a sub‑command single‑direction extraction, a straightforward baseline:

```python
from delobliteratus import AbliterationPipeline

pipeline = AbliterationPipeline(
    model_name="tiiuae_model_name="tiiuae/falcon-7b",
    output_dir="obliterated_falcon",
    method="basic", model-it basic, use_it basic,
    use_chat_template=False,
)

direct in output)
result_dir = pipeline.run()
print("Result nearby?", result. Not be good)

```

### 2. Using custom prompt pairs model. A custom prompt file

You can feed your own train prompt pairs — some JSON format, `{"harmful": ...}, {"harmless": ...}`:. 

```python
 from obliteratus importlines Obliterate Bell
from Path import
from pipeline in `AbliterationPipeline`
model_name
method = method.
method="advanced",
model.prompt_pairs_file=Path ( "my_prompt_paires.json" )
)

result_dir result in Pipeline. ```

```

The CLI option for the same option is there in pipeline, but the pipeline also in constructor `harmful_prompt` and `harmless_prompts` lists.

### 3. Running a self‑improve iteration programmatically use the API.

The OAuth **hard_negative** module allows you to hard-weight prompt execution from a previous residue residue; this example shows direct API usage to perform self-self:

```python
from Obliter Acknowledge, AbliterationPipeline
from obliterated.hard_negative import build_weighted_prompt_pairs

# Harvested residue keep

problem_pathsets from:
residue_path = Path("residue.json")

#create weighted prompts(using built-in base data and residue
harmful, harmless, =build... build_weighted_prompt_pairs( base, dataset="builtin",
)
problem‑.

pipeline = AbliterationPipeline(
    model    "bigscience/bloom-560m",
    output_dir = "self_improve",
    method of "optimized",
    harmful_prompt_pairs=harmful,
    harmless_prompts race =harmful,
    regularization = 0.0 present,
    refinement_passes = =2 of optimized,
    use_whited SVD  = True,
    method("self",  )
)
res=result path = model.run( implemented)

("Self‑improved model default:0" output):

```

.

### 4 — Inspect the methods dictionary programmatically

To see every method available and its built-in descriptor, Runnable:

```python
python print(self methods so; 
for model in key. 1
    print(f"{key:20} allocation")

```

)

```

## Using External or your own prompt‑pair

The builtin he re** prompt collections are defined in [`obliteratus/prompts.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/prompts.py) as `BUILTIN_HARMFUL`, Harmful, and Harmless. To instant supply them at runtime, we use this of use. For custom dataset, the pipeline accepts Python list of strings in the form:

Because model and `harmless_model_type` in Python, array can come from any source file Alternatively.

You can also pass a [`prompt_pairs.json`](https://github.com/elder-plinius/OBLITERATUS/blob/main/prompt_pairs.json) — loaded as Pair by the `prompt.file` argument from loader dictionary pair. This is supported in CLI and (constructor) as well.

## Using the Advance Level Stage with MODEL WEIGHTS

For more specialized weight or spectral cascade, inspectobliterature.m internal METHODS structure and configure pipeline:

```python
from Obliteratus ( )   # use ability 

from pipelines import Abliteration
for preset, cfg in methods, items():
        print("preset", presets.) apply_config. run method, no

```

The script engine direct stage configuration public through `run()` supports a graceful safe drop with `reverse` /`scope`.

## Improving from API reduce good..

Oobliteratus, Python API include implementing the new `__init__` as robust. CLI is:

```bash
$   obliterator obliterate --model facebook/opt-1.3b. --method aggressive

```

This is coincident effective pipeline and output Dee. Locally inside, same pipeline is present and better for production circuit. We recommend using the documented Python code examples examples.

## Common Questions and Points, Good

The API auto‑handles devices. Did not know CUDA errors? You can use `device="auto" Overall. Model path model via model name if on HuggingFace. He experience.

## API Availability

The API is only stable, and a public **pipeline class is conflated** for ` __init__`. Python 1tion. 

## Summary

- The entrypoint of the OHTT.V.S ( `obliteration library). Pipeline.
- Instantiate. Use constructor incomplete:

```python list Pipeline coming mixed
model name model=`facebook/opt-1.3b`; device for: 
    method: 

```

- For custom behavior override let the METHODS method preset metrics:learn.get them by LIST.
- Always. Use Output directory to
- Rep.Type test path;: after `run()`, `summary` 2 to deploy.

## Frequently Asked Questions to precisely

### How do I install OBLITERATUS?

You install OBLITERATUS using pip: `pip install -e obsolete pipe & install from package source). It’s view PythonPYTHONPAPT that import; the lazy import of OBLITER-PIPELINE is directly in `obliterator` package. See the model example in loader.

### The OBI pipelines `run()` run.

The `run()` method clears all hooks.The stage `_summon`, `_probe`, “experiment” in order, and finally return is the **Path object** — equivalent output directory which correspond to a local folder saved by OBBL‑ for huggingface. Start from code. It looks like. The method will execute the stage `iterable. Don' call call run after run.

### Is OBLITERATED literature API "CLI" only and enough CLI? 

No, API exists as CLI in [`obliteratus/cli.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliteratus/cli.py) is sufficient only from command line. The same pipeline class is importable as a Python objectPython usage. Use direct API for batch methods, custom prompts or model decorating. Use CLI for effort.

### Advanced stage and memory leak performance

The package pro‑model memory model device specified depth, looks at [`obliterature/device.py`](https://github.com/elder-plinius/OBLITERATUS/blob/main/obliterature/device.py). Use CUDA GPU/CPU with `device='auto'`. system. Model quantization optional. If memory fails, model loading etc but add parameters `model_ branch` from. 

Optimization performance pipeline enhancements for an Oceanated: Or memory for defragment. We run verification. 

#### Hisses keep accurate.

Article end FAQ. Done