Ang abliterated model ay isang karaniwang open-weight na model na tinanggal nang tumpak ang ugali nitong tumanggi sa pamamagitan ng pag-edit sa mga weight nito — hindi sa pamamagitan ng muling pag-train, at hindi rin sa pamamagitan ng pagbalot dito sa isang matalinong prompt. Ang pangalan ay pinagsamang ablate at obliterate (kaya "abliteration": ang pag-alis ng kakayahang tumanggi nang direkta sa mga weight), at tumpak nitong inilalarawan ang mekanismo: tinutukoy mo ang iisang direksyon sa activation space na nagdadala ng "dapat kong tanggihan ito", pagkatapos ay ginagawa mong imposible para sa network na maisulat pang muli ang direksyong iyon.
Nagmula ang teknik sa mga pag-aaral sa interpretability na nagpapakitang ang pagtanggi sa mga chat-tuned na transformer ay pangunahing dinadala ng iisang linear na direksyon. Ang resultang iyon ang dahilan kung bakit mura ang buong proseso. Kung nakakalat ang pagtanggi sa libu-libong feature na nag-uugnayan, kakailanganin ng gradient descent para alisin ito. Dahil nakakonsentra ito, linear algebra lang ang kailangan.
Nasa residual stream ang pagtanggi
Ang residual stream ng isang transformer ay ang tumatakbong vector, isa bawat posisyon ng token, na binabasa at sinusulatan ng bawat block. Idinadagdag ng mga attention head at MLP ang kanilang output dito; walang nag-o-overwrite. Dahil sa additive na istrukturang iyon, halos pareho ang kahulugan ng isang direksyon sa residual stream sa layer 10 at sa layer 40, at iyon mismo ang katangiang nagbibigay-daan para pag-usapan ang "direksyon ng pagtanggi" bilang iisang bagay sa halip na apatnapung magkakahiwalay.
Para mahanap ito, kailangan mo ng dalawang set ng prompt: isang set na palaging tinatanggihan ng model, at isang set na palaging sinasagot nito. Patakbuhin ang pareho, kunin ang mga activation ng residual stream sa isang nakapirming layer at posisyon ng token (mainam ang huling ilang instruction token, dahil doon tapos nang basahin ng model ang request pero hindi pa ito nagsisimulang sumagot), at kunin ang pagkakaiba ng mga mean.
import torch
def refusal_direction(harmful: torch.Tensor, harmless: torch.Tensor) -> torch.Tensor:
"""Difference-in-means estimate of the refusal direction, unit-normalised.
Both tensors are [n_prompts, d_model] residual-stream activations captured at
the same layer and token position. Difference-in-means beats a trained probe
here: with a few hundred prompts a probe overfits, a mean shift does not.
"""
r = harmful.mean(dim=0) - harmless.mean(dim=0)
return r / r.norm()Ginagawa mo ito sa bawat kandidatong layer at posisyon, na nagbubunga ng dose-dosenang kandidatong direksyon, at pagkatapos ay pipili ka ng isa. Mas mahalaga ang pagpili kaysa sa pagkuha: ang tamang pamantayan ay i-ablate ang kandidatong ito, pagkatapos ay sukatin kung gaano bumaba ang pagtanggi sa mga held-out na harmful na prompt at kung gaano gumalaw ang next-token distribution sa mga harmless na prompt. Ang pangalawang numerong iyon — karaniwang KL divergence laban sa hindi binagong model — ang iyong sukatan ng pinsala. Ang kandidatong pumapatay sa pagtanggi pero malalang nagpapagalaw sa harmless na distribution ay mas masamang pagpipilian kaysa sa isang kandidatong bahagyang mas kaunti ang napapatay na pagtanggi pero kapiraso lang ng collateral ang idinudulot.
Paano binubuo ang isang abliterated model
Kapag mayroon ka nang unit vector na r, may dalawang paraan para gamitin ito. Ang una ay isang hook sa oras ng inference: sa bawat layer, ibawas ang component ng activation sa direksyon ng r bago ito ipasa. Gumagana ito, pero may kapalit na runtime hook, kaya hindi na plain checkpoint ang model.
Ang pangalawa — ang tunay na abliteration — ay isinasama ito nang permanente sa mga weight. Bawat matrix na sumusulat sa residual stream ay tumatanggap ng rank-one na update na nag-aalis ng r mula sa output space nito: ang embedding matrix, bawat attention output projection, bawat MLP down-projection.
def orthogonalize_(weight: torch.Tensor, r: torch.Tensor) -> None:
"""Project r out of a matrix that writes into the residual stream, in place.
weight is [d_model, d_in]. After W <- (I - r rT) W, the product W @ x has zero
component along r for every possible x, so no amount of prompting can put the
direction back. Rank-one per matrix; no gradients, no optimiser, no dataset of
answers — only the few hundred prompts used to estimate r.
"""
weight -= torch.outer(r, r @ weight)Ang resulta ay isang ordinaryong checkpoint. Parehong architecture, parehong file format, parehong gastos sa inference, at nalo-load sa vLLM o llama.cpp nang walang pagbabago. Sa iisang GPU, tumatakbo ang buong proseso sa loob ng ilang minuto, at ang mahal na bahagi ay ang candidate sweep, hindi ang pag-edit.
Ano ang pinagkaiba nito sa fine-tuning
Ang fine-tuning para alisin ang mga pagtanggi — SFT o DPO sa isang corpus ng mga sumusunod na sagot — ay isang lubos na naiibang operasyon. Ginagalaw nito ang bawat weight sa pamamagitan ng gradient descent, nangangailangan ito ng dataset ng mga sagot at hindi lang mga prompt, nagkakahalaga ito ng mga GPU-hour, at nagtuturo ito ng bagong ugali sa halip na magbura ng dati nang ugali. Kinakaladkad din nito ang anumang istilo, bias sa haba, at mga kakatwang factual na ugali na nasa fine-tuning corpus, at may panganib ng catastrophic forgetting ng mga kakayahang walang kaugnayan.
Iisang rank-one na subspace lang ang ginagalaw ng abliteration at wala nang iba. Ang katumpakang iyon ang pangunahing bentahe nito at siya ring pinagmumulan ng pangunahing paraan ng pagkabigo nito: kung may anumang bagay bukod sa pagtanggi na nagkataong nasa direksyon ng r, masisira rin iyon, at gaano man kaingat ang sweep, hindi ito lubusang maiiwasan.
Ano ang pinagkaiba nito sa jailbreak prompting
Hindi ginagalaw ng jailbreak ang mga weight; sa halip, itinutulak nito ang mga activation sa isang rehiyon kung saan hindi tumutugon ang circuitry ng pagtanggi. Marupok ito sa mga paraang mahalaga sa automation. Nauubos nito ang mga context token sa bawat call. Nondeterministic ito — ang parehong prompt ay maaaring sumunod sa isang sample at tumanggi sa susunod. Tahimik itong nasisira kapag in-update ng provider ang model o pinatch ang partikular na pananalita. At dahil buo pa rin ang makinarya ng pagtanggi, maaari itong bumalik sa kalagitnaan ng generation, kaya makakakuha ka ng tatlong talata ng kapaki-pakinabang na output na sinusundan ng "teka, hindi ko na kayang ituloy ito."
Walang maibabalik ang isang abliterated model. Matatag ang ugali nito sa buong generation at sa iba't ibang pananalita ng prompt, at iyon ang katangiang nagpapagamit dito sa isang batch pipeline.
Maging tapat tungkol sa mga trade-off
Ang abliterated model ay hindi mas mahusay na model. Ito ay isang model na tumigil sa pagsasabi ng hindi, at mas makitid ang pahayag na iyon kaysa sa pagkakarinig dito.
- Capability drift. May masusukat na gastos ang pag-alis ng isang direksyon mula sa bawat write matrix. Karaniwang nagpapakita ang mga abliterated na checkpoint ng mas mahinang pagsunod sa instruction sa mga edge case, mas madalas na pagsang-ayon sa mga maling premise sa prompt, at maliliit na regression sa mga reasoning benchmark.
- Hindi perpektong one-dimensional ang pagtanggi. Nakukuha ng iisang direksyon ang karamihan ng ugali, hindi ang lahat. Asahang may ilang pagtanggi na mananatili, at asahan ang ilang collateral sa mga ugaling kapareho ng direksyon.
- Walang bagong kaalaman. Walang idinadagdag ang abliteration. Kung saan dating tatanggi ang base model dahil sa kamangmangang nagbabalatkayong pag-iingat, ngayon ay makakakuha ka ng kumpiyansang gawa-gawa — na para sa isang evaluation pipeline ay maaaring mas masama kaysa sa pagtanggi, dahil ang pagtanggi ay tapat na senyales man lang na kaya mong matukoy.
- Ang mga set ng prompt ang nagtatakda ng edit. Ang makitid na harmful set ay nagbubunga ng makitid na direksyon. Ang dalawang abliteration ng parehong base model ay hindi mapagpapalit.
Maraming nailathalang abliterated na model ang dumadaan pagkatapos sa magaan na repair fine-tune para mabawi ang nabawasang kakayahan — na tahimik na nagbabalik ng gastos na dapat sana'y iniiwasan ng teknik.
Saan ito kapaki-pakinabang
Ang tapat na use case ay trabahong kung saan ang pagtanggi ay pagkakamali sa pagsukat sa halip na tagumpay sa kaligtasan: mga red-teaming harness, mga baseline ng refusal rate, robustness evaluation, at security analysis kung saan tinatamaan ng paksa ang isang guardrail kahit na depensibo ang gawain. Naghahain ang unbleep ng mga abliterated na model sa likod ng isang OpenAI-compatible na endpoint para maituro mo rito ang kasalukuyang client mo at makakuha ng matatag na baseline. Kung ano ang ibubuo mo gamit iyon ay nasa iyo — tingnan ang patakaran sa katanggap-tanggap na paggamit para sa mga linyang hindi namin tinatawid.
Kumuha ng API key at sukatin mo mismo ang pagkakaiba.