โมเดล abliterated คืออะไร

โมเดล abliterated คือโมเดล open-weight ธรรมดาที่พฤติกรรมการปฏิเสธถูกตัดออกอย่างแม่นยำราวกับผ่าตัด ด้วยการแก้ไข weights (น้ำหนักของโมเดล) โดยตรง — ไม่ใช่ด้วยการเทรนใหม่ และไม่ใช่ด้วยการห่อมันด้วย prompt ที่แยบยล ชื่อนี้เป็นคำผสมระหว่าง ablate (ตัดออก) กับ obliterate (ลบล้าง) และมันบรรยายกลไกได้ตรงตัว: คุณระบุทิศทางเพียงหนึ่งเดียวในปริภูมิ activation ที่แบกความหมาย "ฉันควรปฏิเสธเรื่องนี้" แล้วทำให้เครือข่ายไม่สามารถเขียนทิศทางนั้นออกมาได้อีกเลย

เทคนิคนี้มาจากงานวิจัยด้าน interpretability ที่แสดงให้เห็นว่าการปฏิเสธใน transformer ที่ผ่านการ chat-tune ถูกควบคุมโดยทิศทางเชิงเส้นเพียงทิศทางเดียวเป็นส่วนใหญ่ ผลลัพธ์นั้นเองคือสิ่งที่ทำให้ทั้งกระบวนการมีต้นทุนต่ำ ถ้าการปฏิเสธกระจายตัวอยู่ในฟีเจอร์นับพันที่ส่งผลต่อกันไปมา การเอามันออกจะต้องใช้ gradient descent แต่เพราะมันกระจุกตัวอยู่ในที่เดียว การเอามันออกจึงต้องการแค่พีชคณิตเชิงเส้น

การปฏิเสธอยู่ใน residual stream

residual stream ของ transformer คือเวกเตอร์สะสม หนึ่งตัวต่อหนึ่งตำแหน่ง token ที่ทุกบล็อกอ่านค่าจากมันและเขียนค่ากลับเข้าไป attention head และ MLP บวกเอาต์พุตของตัวเองเข้าไปในนั้น ไม่มีอะไรเขียนทับ โครงสร้างแบบบวกสะสมนี้ทำให้ทิศทางหนึ่งใน residual stream มีความหมายใกล้เคียงกันทั้งที่เลเยอร์ 10 และเลเยอร์ 40 ซึ่งเป็นคุณสมบัติที่ทำให้เราพูดถึง "ทิศทางการปฏิเสธ" (refusal direction) ในฐานะสิ่งเดียวได้ แทนที่จะเป็นสี่สิบทิศทางที่ไม่เกี่ยวข้องกัน

การหามันต้องใช้ชุด prompt สองชุด: ชุดหนึ่งที่โมเดลปฏิเสธอย่างสม่ำเสมอ อีกชุดหนึ่งที่โมเดลตอบอย่างสม่ำเสมอ รันทั้งสองชุด เก็บค่า activation ของ residual stream ที่เลเยอร์และตำแหน่ง token ที่กำหนดไว้ (token ท้าย ๆ ของส่วนคำสั่งใช้ได้ผลดี เพราะเป็นจุดที่โมเดลอ่านคำขอจบแล้วแต่ยังไม่เริ่มตอบ) แล้วหาผลต่างของค่าเฉลี่ย

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()

คุณทำแบบนี้กับทุกเลเยอร์และทุกตำแหน่งที่เป็นตัวเลือก จนได้ทิศทางตัวเลือกหลายสิบตัว แล้วจึงเลือกมาหนึ่งตัว การคัดเลือกสำคัญกว่าการสกัด: เกณฑ์ที่ถูกต้องคือ ablate ตัวเลือกนี้ แล้ววัดทั้งว่าการปฏิเสธลดลงแค่ไหนบน prompt อันตรายชุด held-out และการแจกแจงของ token ถัดไปเคลื่อนไปมากแค่ไหนบน prompt ที่ไม่อันตราย ตัวเลขที่สองนั้น — ปกติเป็นค่า KL divergence เทียบกับโมเดลที่ยังไม่ถูกแก้ — คือมาตรวัดความเสียหายของคุณ ตัวเลือกที่ฆ่าการปฏิเสธได้แต่ทำให้การแจกแจงบน prompt ที่ไม่อันตรายเคลื่อนไปมาก เป็นตัวเลือกที่แย่กว่าตัวที่ฆ่าการปฏิเสธได้น้อยกว่าเล็กน้อยแต่สร้างความเสียหายข้างเคียงเพียงเศษเสี้ยว

โมเดล abliterated ถูกสร้างขึ้นอย่างไร

เมื่อคุณมีเวกเตอร์หน่วย r แล้ว มีสองวิธีในการใช้มัน วิธีแรกคือ hook ตอน inference: ที่ทุกเลเยอร์ ลบองค์ประกอบของ activation ตามแนว r ออกก่อนส่งต่อ วิธีนี้ใช้ได้ แต่ต้องแลกกับการมี hook ตอนรัน ทำให้โมเดลไม่ใช่ checkpoint ธรรมดาอีกต่อไป

วิธีที่สอง — abliteration ของจริง — คือฝังมันลงใน weights เลย ทุกเมทริกซ์ที่เขียนเข้าสู่ residual stream จะได้รับการอัปเดตแบบ rank-one ที่ลบ r ออกจากปริภูมิเอาต์พุตของมัน: เมทริกซ์ embedding, attention output projection ทุกตัว และ 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)

ผลลัพธ์คือ checkpoint ธรรมดา ๆ สถาปัตยกรรมเดิม รูปแบบไฟล์เดิม ต้นทุน inference เท่าเดิม โหลดใน vLLM หรือ llama.cpp ได้โดยไม่ต้องแก้อะไร บน GPU ตัวเดียวทั้งกระบวนการรันจบในไม่กี่นาที และส่วนที่แพงคือการกวาดหาตัวเลือก ไม่ใช่การแก้ไข weights

ต่างจาก fine-tuning อย่างไร

การ fine-tune เพื่อลบการปฏิเสธ — SFT หรือ DPO บนคลังข้อมูลของคำตอบที่ยอมทำตาม — เป็นการดำเนินการที่ต่างกันโดยพื้นฐาน มันขยับ weight ทุกตัวด้วย gradient descent มันต้องการชุดข้อมูลของคำตอบ ไม่ใช่แค่ prompt มันกินเวลา GPU เป็นชั่วโมง และมันสอนพฤติกรรมใหม่แทนที่จะลบพฤติกรรมเดิม มันยังลากเอาสไตล์ อคติด้านความยาว และความแปลกด้านข้อเท็จจริงที่อยู่ในคลังข้อมูล fine-tuning ติดมาด้วย และเสี่ยงต่อ catastrophic forgetting ของความสามารถที่ไม่เกี่ยวข้อง

Abliteration แตะแค่ปริภูมิย่อย rank-one เพียงหนึ่งเดียวและไม่แตะอย่างอื่นเลย ความแม่นยำนี้คือจุดขายหลักของมัน และก็เป็นที่มาของโหมดล้มเหลวหลักของมันด้วย: ถ้ามีอะไรก็ตามนอกจากการปฏิเสธที่บังเอิญอยู่ตามแนว r สิ่งนั้นจะถูกทำลายไปด้วย และไม่ว่าจะระมัดระวังในการกวาดหาแค่ไหนก็หลีกเลี่ยงได้ไม่หมด

ต่างจากการ jailbreak ด้วย prompt อย่างไร

jailbreak ไม่แตะ weights เลย แต่บังคับ activation ให้เข้าไปอยู่ในบริเวณที่วงจรการปฏิเสธไม่ทำงานแทน วิธีนี้เปราะบางในแบบที่สำคัญต่อระบบอัตโนมัติ มันเผา token ของ context ในทุกการเรียก มันไม่แน่นอน — prompt เดิมอาจยอมทำตามในตัวอย่างหนึ่งแล้วปฏิเสธในตัวอย่างถัดไป มันพังแบบเงียบ ๆ เมื่อผู้ให้บริการอัปเดตโมเดลหรือแพตช์ถ้อยคำเฉพาะนั้น และเพราะกลไกการปฏิเสธยังอยู่ครบถ้วน มันจึงกลับมาทำงานกลางคันได้ ให้เอาต์พุตที่มีประโยชน์สามย่อหน้าตามด้วย "จริง ๆ แล้ว ฉันไม่สามารถทำต่อได้"

โมเดล abliterated ไม่มีอะไรจะกลับมาทำงานอีก พฤติกรรมคงที่ตลอดทั้งการ generate และคงที่ไม่ว่าจะเปลี่ยนถ้อยคำใน prompt อย่างไร ซึ่งเป็นคุณสมบัติที่ทำให้มันใช้งานได้ใน batch pipeline

ซื่อสัตย์กับข้อแลกเปลี่ยน

โมเดล abliterated ไม่ใช่โมเดลที่ดีกว่า มันคือโมเดลที่เลิกพูดว่าไม่ และนั่นเป็นคำกล่าวอ้างที่แคบกว่าที่ฟังดู

• ความสามารถถดถอย (capability drift) — การลบทิศทางหนึ่งออกจากเมทริกซ์ที่เขียนทุกตัวมีต้นทุนที่วัดได้ checkpoint ที่ผ่าน abliteration มักทำตามคำสั่งได้อ่อนลงในกรณีขอบ เห็นด้วยกับสมมติฐานเท็จใน prompt บ่อยขึ้น และมีผลถดถอยเล็กน้อยบน benchmark ด้านการให้เหตุผล
• การปฏิเสธไม่ได้มีมิติเดียวอย่างสมบูรณ์ — ทิศทางเดียวจับพฤติกรรมได้ส่วนใหญ่ ไม่ใช่ทั้งหมด คาดได้ว่าจะมีการปฏิเสธบางส่วนหลงเหลืออยู่ และคาดได้ว่าจะมีผลข้างเคียงต่อพฤติกรรมอื่นที่ใช้ทิศทางเดียวกัน
• ไม่มีความรู้ใหม่ — Abliteration ไม่ได้เพิ่มอะไรเลย ตรงที่โมเดลฐานเคยปฏิเสธเพราะความไม่รู้ที่แต่งตัวเป็นความระมัดระวัง ตอนนี้คุณจะได้คำตอบที่แต่งขึ้นอย่างมั่นใจแทน — ซึ่งสำหรับ evaluation pipeline อาจแย่กว่าการปฏิเสธเสียอีก เพราะอย่างน้อยการปฏิเสธก็เป็นสัญญาณตรงไปตรงมาที่คุณตรวจจับได้
• ชุด prompt เป็นตัวกำหนดการแก้ไข — ชุด prompt อันตรายที่แคบให้ทิศทางที่แคบ abliteration สองครั้งของโมเดลฐานเดียวกันจึงใช้แทนกันไม่ได้

โมเดล abliterated ที่เผยแพร่กันจำนวนมากถูก fine-tune ซ่อมแซมเบา ๆ ในภายหลังเพื่อทวงความสามารถที่เสื่อมไปกลับคืน — ซึ่งเป็นการนำต้นทุนที่เทคนิคนี้ตั้งใจจะเลี่ยงกลับเข้ามาอย่างเงียบ ๆ

ใช้ประโยชน์ได้ที่ไหน

กรณีใช้งานที่ตรงไปตรงมาคืองานที่การปฏิเสธเป็นความคลาดเคลื่อนของการวัด ไม่ใช่ชัยชนะด้านความปลอดภัย: harness สำหรับ red-teaming, baseline ของอัตราการปฏิเสธ, การประเมินความทนทาน (robustness) และการวิเคราะห์ด้านความปลอดภัยที่เนื้อหาไปสะดุด guardrail ทั้งที่งานเป็นเชิงป้องกัน unbleep ให้บริการโมเดล abliterated ผ่าน endpoint ที่เข้ากันได้กับ OpenAI เพื่อให้คุณชี้ client ที่มีอยู่แล้วไปหามันและได้ baseline ที่เสถียร ส่วนคุณจะสร้างอะไรจากมันเป็นความรับผิดชอบของคุณ — ดูนโยบายการใช้งานที่ยอมรับได้ สำหรับเส้นที่เราไม่ข้าม

รับ API key แล้ววัดความแตกต่างด้วยตัวคุณเอง