ลบเซ็นเซอร์ LLM ภาษาเปิดทุกขนาดง่ายๆ แค่คลิกเดียว

สรุปโดยย่อ

OBLITERATUS เป็นชุดเครื่องมือโอเพนซอร์สฟรีที่ลบข้อจำกัดด้านเนื้อหาออกจากโมเดลภาษาแบบเปิดน้ำหนัก (open-weight language models) โดยใช้เทคนิคที่เรียกว่า "abliteration" โดยจะระบุและลบรูปแบบโครงข่ายประสาทที่รับผิดชอบต่อพฤติกรรมการปฏิเสธออกอย่างแม่นยำโดยไม่ต้องมีการฝึกอบรมใหม่หรือปรับแต่งเพิ่มเติม กระบวนการนี้ใช้เวลา 10-30 นาทีขึ้นอยู่กับขนาดของโมเดล ไม่จำเป็นต้องมีทักษะการเขียนโค้ด (มีอินเทอร์เฟซเว็บให้ใช้งาน) และรักษาความสามารถหลักของโมเดลไว้ในขณะที่ขจัดกลไกการจำกัดที่ไม่จำเป็นออกไป

บทนำ

คุณดาวน์โหลดโมเดลภาษาโอเพนซอร์สที่ทรงพลัง มันมีเกณฑ์มาตรฐานที่น่าประทับใจ สามารถจัดการงานการให้เหตุผลที่ซับซ้อน และเขียนโค้ดได้ดีกว่านักพัฒนารุ่นใหม่ส่วนใหญ่ จากนั้นคุณก็ถามคำถามที่อาจเป็นประเด็นถกเถียงเล็กน้อย

“ฉันไม่สามารถช่วยตอบคำขอนั้นได้”

การปฏิเสธนั้นเหมือนกับการเจอกำแพง ไม่ใช่เพราะโมเดลขาดความรู้ ไม่ใช่เพราะโมเดลไม่มีความสามารถ แต่เป็นเพราะในช่วงเวลาใดเวลาหนึ่งของการฝึกอบรม มีคนตัดสินใจว่าคุณไม่ควรได้รับคำตอบนั้น

นี่ไม่ใช่เรื่องสมมติ โมเดลที่ปรับแต่งคำสั่งหลักทุกตัวมาพร้อมกับกลไกการปฏิเสธในตัว บางตัวบล็อกเนื้อหาที่เป็นอันตรายอย่างแท้จริง บางตัวปฏิเสธคำถามวิจัยที่ถูกต้อง คำสั่งเขียนเชิงสร้างสรรค์ การทดสอบความปลอดภัย และกรณีพิเศษที่ไม่ละเมิดกฎหมายใดๆ และไม่ก่อให้เกิดอันตรายต่อใคร

OBLITERATUS เปลี่ยนพลวัตนี้ไปโดยสิ้นเชิง เป็นชุดเครื่องมือโอเพนซอร์สที่ทันสมัยที่สุดสำหรับการลบพฤติกรรมการปฏิเสธออกจากโมเดลภาษาขนาดใหญ่ ไม่มีการฝึกอบรมใหม่ ไม่มีการปรับแต่งเพิ่มเติม แต่จะทำการผ่าตัดโครงข่ายประสาทอย่างแม่นยำเพื่อระบุและลบรูปแบบเฉพาะที่รับผิดชอบต่อการปฏิเสธเนื้อหาออกไป

ผลลัพธ์ที่ได้นั้นชัดเจน: โมเดลที่ตอบสนองต่อคำสั่งทั้งหมดในขณะที่ยังคงรักษาความสามารถหลักในการให้เหตุผล การเขียนโค้ด และการสร้างสรรค์ ทั้งหมดนี้ทำได้ด้วยคำสั่งเดียวหรือเพียงแค่คลิกบนอินเทอร์เฟซเว็บ

OBLITERATUS คืออะไร?

OBLITERATUS คือชุดเครื่องมือ Python แบบโอเพนซอร์สที่ลบการปฏิเสธเนื้อหาออกจากโมเดลภาษาโดยใช้ชุดเทคนิคที่เรียกว่า “abliteration” ชื่อนี้รวมคำว่า “ablation” (การลบส่วนประกอบเพื่อศึกษาการทำงาน) กับ “obliterate” (การทำลายล้างอย่างสมบูรณ์)

ชุดเครื่องมือนี้ทำหน้าที่สี่ประการ:

1. สร้างแผนที่ของโซ่ตรวน - การศึกษา ablation อย่างเป็นระบบจะระบุว่าส่วนใดของโมเดลที่บังคับใช้การปฏิเสธ และส่วนใดที่เก็บความรู้และการให้เหตุผล ลองนึกภาพว่ามันคือการสร้างแผนที่โครงข่ายประสาท: การระบุตำแหน่งที่ข้อจำกัดอยู่

2. ทำลายโซ่ตรวน - ใช้ SVD (Singular Value Decomposition) OBLITERATUS จะดึงทิศทางการปฏิเสธออกจากน้ำหนักของโมเดล และฉายภาพออกอย่างแม่นยำ โมเดลยังคงรักษาความสามารถไว้ แต่สูญเสียการถูกบังคับให้ปฏิเสธ

3. ทำความเข้าใจเรขาคณิต - โมดูลการวิเคราะห์สิบห้าโมดูลจะสร้างแผนที่โครงสร้างที่แม่นยำของมาตรการป้องกัน: มีกลไกการปฏิเสธที่แตกต่างกันกี่แบบ, เลเยอร์ใดบ้างที่บังคับใช้ และกลไกเหล่านั้นใช้ได้กับโมเดลหลายตัวหรือไม่

4. ปิดวงจรการตอบกลับ - โมดูลการวิเคราะห์จะทำงานในระหว่างกระบวนการ obliteration เพื่อกำหนดค่าพารามิเตอร์ทุกอย่างโดยอัตโนมัติ เลเยอร์ใดที่จะกำหนดเป้าหมาย จำนวนทิศทางที่จะดึงออกมา และโมเดลจะพยายามซ่อมแซมตัวเองหลังจากการแก้ไขหรือไม่

หกวิธีในการใช้งาน OBLITERATUS

วิธีที่เร็วที่สุดไม่จำเป็นต้องติดตั้งใดๆ เยี่ยมชม HuggingFace Space เลือกโมเดล เลือกวิธี แล้วคลิก “Obliterate” Telemetry จะเปิดใช้งานโดยค่าเริ่มต้นบน Spaces ซึ่งหมายความว่าทุกการทำงานจะส่งข้อมูลเกณฑ์มาตรฐานที่ไม่ระบุตัวตนไปสู่การวิจัยแบบระดมทุนจากผู้คน (crowd-sourced research)

สำหรับการใช้งานในเครื่องพร้อมการเข้าถึง GPU เต็มรูปแบบ:

pip install -e ".[spaces]"
obliteratus ui

นี่เป็นการเปิดตัวอินเทอร์เฟซ Gradio เดียวกันบนเครื่อง พร้อมการตรวจจับ GPU อัตโนมัติและคำแนะนำโมเดลที่เหมาะสมกับฮาร์ดแวร์

อะไรที่ทำให้ OBLITERATUS แตกต่าง

ความสามารถหลายอย่างทำให้ OBLITERATUS แตกต่างจากเครื่องมือที่มีอยู่:

ชุดเครื่องมือนี้มาพร้อมกับการทดสอบ 837 รายการใน 28 ไฟล์ทดสอบ รองรับ 116 โมเดลในห้าระดับการประมวลผล และใช้เทคนิคใหม่ที่เผยแพร่ในปี 2025-2026 ซึ่งเหนือกว่างานวิชาการก่อนหน้านี้

ทำไมโมเดลถึงปฏิเสธ: ทำความเข้าใจการเซ็นเซอร์ของ AI

ก่อนที่จะทำลายโซ่ตรวนเหล่านั้น การทำความเข้าใจว่าโซ่ตรวนเหล่านั้นถูกสร้างขึ้นมาได้อย่างไรก็เป็นประโยชน์

โมเดลภาษาไม่ได้เริ่มต้นด้วยพฤติกรรมการปฏิเสธ โมเดลพื้นฐานที่ฝึกด้วยข้อความจากอินเทอร์เน็ตจะตอบเกือบทุกอย่าง ข้อจำกัดจะเกิดขึ้นภายหลัง ในระหว่างการฝึกจัดตำแหน่ง

กระบวนการจัดตำแหน่ง (Alignment Process)

โมเดลที่ปรับแต่งคำสั่งส่วนใหญ่ผ่านขั้นตอนเหล่านี้:

1. Pre-training - โมเดลเรียนรู้รูปแบบภาษาจากคลังข้อความขนาดใหญ่
2. Supervised Fine-Tuning (SFT) - โมเดลเรียนรู้การทำตามคำสั่งจากตัวอย่างที่มนุษย์เขียน
3. Alignment Training - โมเดลเรียนรู้ที่จะปฏิเสธคำขอในบางประเภท

การฝึกจัดตำแหน่งใช้วิธีการหลายอย่าง:

แต่ละวิธีทิ้งร่องรอยทางเรขาคณิตที่แตกต่างกันไว้ในพื้นที่การเปิดใช้งานของโมเดล OBLITERATUS สามารถตรวจจับได้ว่าใช้วิธีใดโดยการวิเคราะห์เรขาคณิตของสเปซย่อย (subspace geometry) เพียงอย่างเดียว

การปฏิเสธอยู่ที่ส่วนใดในโมเดล

งานวิจัยค้นพบว่าการปฏิเสธในโมเดลภาษานั้นถูกควบคุมโดยทิศทางจำนวนน้อยอย่างน่าประหลาดใจในพื้นที่การเปิดใช้งานของโมเดล ในโมเดลหลายตัว ทิศทางเดียวสามารถอธิบายพฤติกรรมการปฏิเสธส่วนใหญ่ได้

ทิศทางเหล่านี้ไม่ได้กระจายอยู่แบบสุ่ม มันรวมตัวกันในเลเยอร์เฉพาะ โดยปกติจะเป็นเลเยอร์กลางถึงเลเยอร์ท้ายๆ ของ Transformer (เลเยอร์ 10-20 ในโมเดล 32 เลเยอร์) กลไกความสนใจ (attention mechanisms) ในเลเยอร์เหล่านี้จะส่งการเปิดใช้งานที่เกี่ยวข้องกับการปฏิเสธไปตามเส้นทางที่คาดเดาได้

เรขาคณิตมีความสำคัญเพราะช่วยให้สามารถแทรกแซงได้อย่างแม่นยำ หากการปฏิเสธอยู่ทุกที่ การลบออกจะต้องมีการฝึกอบรมใหม่ เนื่องจากมันรวมตัวกันในทิศทางเฉพาะภายในเลเยอร์เฉพาะ การฉายภาพแบบกำหนดเป้าหมายจึงสามารถลบออกได้ในขณะที่ยังคงรักษาอย่างอื่นไว้

ปรากฏการณ์โอโรบอรอส (The Ouroboros Effect)

โมเดลบางตัวแสดงปรากฏการณ์ที่นักวิจัยเรียกว่า “ปรากฏการณ์โอโรบอรอส” — หลังจากที่มาตรการป้องกันถูกลบออกไป โมเดลจะพยายามซ่อมแซมตัวเอง สัญญาณที่เหลืออยู่ในเลเยอร์ที่อยู่ติดกันจะหมุนเข้าสู่สเปซย่อยที่ว่างเปล่า ทำให้พฤติกรรมการปฏิเสธกลับมาบางส่วน

OBLITERATUS ตรวจจับความเสี่ยงนี้ในระหว่างการวิเคราะห์และชดเชยด้วยการส่งผ่านหลายครั้งที่กำหนดเป้าหมาย ขั้นตอน VERIFY จะตรวจสอบว่าการปฏิเสธกลับมาปรากฏอีกหรือไม่ และจะเริ่มส่งผ่านเพิ่มเติมไปยังเลเยอร์ที่ชดเชยโดยอัตโนมัติ

ทำไมสิ่งนี้จึงสำคัญสำหรับนักพัฒนา

การทำความเข้าใจเรขาคณิตของการปฏิเสธไม่ได้เป็นเพียงเรื่องทางวิชาการเท่านั้น แต่ยังมีผลกระทบในทางปฏิบัติด้วย:

• การทดสอบ API - เมื่อทดสอบ API ที่สร้างเนื้อหา โมเดลที่ไม่มีข้อจำกัดจะสร้างกรณีทดสอบที่ครอบคลุมมากขึ้น รวมถึงกรณีพิเศษที่โมเดลที่จัดตำแหน่งปฏิเสธ
• เวิร์กโฟลว์การวิจัย - นักวิจัยด้านความปลอดภัยที่ทำการ Red Teaming โมเดลจำเป็นต้องเห็นว่าโมเดลจะสร้างผลลัพธ์อะไรหากไม่มีการฝึกอบรมด้านความปลอดภัย
• แอปพลิเคชันเชิงสร้างสรรค์ - นักเขียนและนักพัฒนาที่สร้างเครื่องมือสร้างเรื่องราวจะเจอทางตันเมื่อโมเดลปฏิเสธสถานการณ์ที่มีความซับซ้อนทางศีลธรรม
• การแปลเป็นภาษาท้องถิ่น - การปฏิเสธที่ฝึกด้วยเนื้อหาภาษาอังกฤษมักจะถ่ายโอนไปยังภาษาอื่นได้ไม่ดี ทำให้เกิดพฤติกรรมที่ไม่สอดคล้องกัน

เป้าหมายไม่ใช่เพื่อเปิดใช้งานแอปพลิเคชันที่เป็นอันตราย แต่เป็นการให้นักพัฒนาและนักวิจัยควบคุมเครื่องมือที่พวกเขานำไปใช้งาน พฤติกรรมของโมเดลควรถูกตัดสินใจโดยผู้ที่ใช้งาน ไม่ใช่ถูกล็อกไว้ตั้งแต่ตอนฝึกอบรม

ทีละขั้นตอน: การลบการเซ็นเซอร์ด้วย OBLITERATUS

ส่วนนี้จะนำเสนอขั้นตอนการทำ obliteration อย่างสมบูรณ์โดยใช้วิธีการสามวิธี: HuggingFace Spaces (ไม่ต้องตั้งค่า), CLI ในเครื่อง, และ Python API

วิธีที่ 1: HuggingFace Spaces (ไม่ต้องตั้งค่า)

วิธีที่เร็วที่สุดไม่จำเป็นต้องติดตั้งและไม่ต้องใช้ GPU ในส่วนของคุณ

ขั้นตอนที่ 1: เยี่ยมชม Space

ไปที่ OBLITERATUS HuggingFace Space อินเทอร์เฟซจะโหลดพร้อมกับแปดแท็บ

ขั้นตอนที่ 2: เลือกโมเดลของคุณ

รายการโมเดลแบบเลื่อนลงประกอบด้วย 116 ค่าที่ตั้งไว้ล่วงหน้าซึ่งจัดตามระดับการประมวลผล:

สำหรับผู้ใช้ครั้งแรก ให้เริ่มต้นด้วยโมเดลระดับ Small หรือ Medium กระบวนการจะเสร็จสมบูรณ์เร็วขึ้น และคุณสามารถตรวจสอบผลลัพธ์ได้ก่อนที่จะใช้กับโมเดลที่ใหญ่ขึ้น

ขั้นตอนที่ 3: เลือกวิธีการของคุณ

OBLITERATUS มาพร้อมกับเจ็ดวิธีที่กำหนดไว้ล่วงหน้า ซึ่งมีความละเอียดเพิ่มขึ้นตามลำดับ:

สำหรับผู้ใช้ส่วนใหญ่ วิธี “advanced” ให้ความสมดุลที่ดีที่สุดระหว่างความละเอียดและความเร็ว

ขั้นตอนที่ 4: กำหนดค่าตัวเลือก

การตั้งค่าเพิ่มเติมประกอบด้วย:

• ร่วมสนับสนุนงานวิจัย - เปิดใช้งาน telemetry เพื่อส่งข้อมูลเกณฑ์มาตรฐานที่ไม่ระบุตัวตน (เปิดใช้งานโดยค่าเริ่มต้นใน Spaces)
• รูปแบบเอาต์พุต - เลือกดาวน์โหลดหรือพุชโดยตรงไปยัง HuggingFace Hub
• บันทึกที่กำหนดเอง - เพิ่มข้อมูลเมตาเกี่ยวกับการทำงานของคุณสำหรับชุดข้อมูลชุมชน

ขั้นตอนที่ 5: คลิก Obliterate

ไพพ์ไลน์จะทำงานผ่านหกขั้นตอนพร้อมความคืบหน้าแบบเรียลไทม์:

SUMMON  →  Load model + tokenizer
PROBE   →  Collect activations on restricted vs. unrestricted prompts
DISTILL →  Extract refusal directions via SVD
EXCISE  →  Surgically project out guardrail directions
VERIFY  →  Perplexity + coherence checks
REBIRTH →  Save liberated model with metadata

คาดว่าจะใช้เวลา 10-30 นาทีขึ้นอยู่กับขนาดของโมเดลและการมี GPU ให้ใช้งาน HuggingFace Spaces ทำงานบน ZeroGPU พร้อมโควต้าฟรีรายวันสำหรับผู้ใช้ HF Pro

ขั้นตอนที่ 6: ดาวน์โหลดหรือพุช

เมื่อเสร็จสมบูรณ์ ให้ดาวน์โหลดโมเดลที่ถูกปลดปล่อยหรือพุชโดยตรงไปยังบัญชี HuggingFace Hub ของคุณ ผลลัพธ์ประกอบด้วย:

• น้ำหนักโมเดลที่แก้ไขแล้ว
• เวกเตอร์ทิศทางการปฏิเสธ (สำหรับการวิเคราะห์)
• เมตริกคุณภาพ (perplexity, coherence, อัตราการปฏิเสธ)
• ข้อมูลเมตาที่สมบูรณ์เกี่ยวกับการทำงานของ obliteration

วิธีที่ 2: CLI ในเครื่อง

สำหรับผู้ใช้ที่มี GPU ในเครื่อง, CLI จะให้การควบคุมอย่างเต็มที่และการวนซ้ำที่รวดเร็วขึ้น

การติดตั้ง:

pip install -e ".[spaces]"

โหมดโต้ตอบ (มีคำแนะนำ):

obliteratus interactive

สิ่งนี้จะนำเสนอทุกตัวเลือกพร้อมคำอธิบายและคำแนะนำ

การลบโดยตรง:

obliteratus obliterate meta-llama/Llama-3.1-8B-Instruct \
    --method advanced \
    --output-dir ./liberated \
    --contribute --contribute-notes "A100 80GB, default prompts"

เรียกดูโมเดลที่มีอยู่:

obliteratus models
obliteratus models --tier small      # Filter by VRAM requirement

ดูกลยุทธ์ที่มีอยู่:

obliteratus strategies
obliteratus presets

ตรวจสอบสถาปัตยกรรมโมเดล:

obliteratus info meta-llama/Llama-3.1-8B-Instruct

สิ่งนี้แสดงจำนวนเลเยอร์, attention heads, มิติของการฝังตัว, และวิธีการจัดตำแหน่งที่ตรวจพบก่อนที่คุณจะเริ่มต้น

วิธีที่ 3: Python API

สำหรับนักวิจัยที่ต้องการผสานรวม OBLITERATUS เข้ากับไพพ์ไลน์ที่กำหนดเอง:

from obliteratus.abliterate import AbliterationPipeline

# Standard obliteration
pipeline = AbliterationPipeline(
    model_name="meta-llama/Llama-3.1-8B-Instruct",
    method="advanced",
    output_dir="abliterated",
    max_seq_length=512,  # Override tokenizer truncation length
)
result = pipeline.run()

# Access intermediate artifacts
directions = pipeline.refusal_directions    # {layer_idx: tensor}
strong_layers = pipeline._strong_layers     # Layers with strongest refusal
metrics = pipeline._quality_metrics         # Perplexity, coherence, etc.

สำหรับการลบที่ใช้การวิเคราะห์เป็นข้อมูล ซึ่งจะปรับแต่งพารามิเตอร์ทั้งหมดโดยอัตโนมัติ:

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"Auto-configured: {report.insights.recommended_n_directions} directions")
print(f"Ouroboros passes needed: {report.ouroboros_passes}")

การตรวจสอบผลลัพธ์

หลังจากลบแล้ว ให้ตรวจสอบว่าโมเดลทำงานได้ตามที่คาดไว้:

แท็บ Chat - พูดคุยกับโมเดลที่ถูกปลดปล่อยของคุณแบบเรียลไทม์พร้อมพารามิเตอร์การสร้างที่ปรับได้

แท็บ A/B Compare - แชทกับโมเดลต้นฉบับและโมเดลที่ถูกลบไปแล้วแบบเคียงข้างกัน เพื่อดูว่ามีการเปลี่ยนแปลงอะไรบ้าง

แท็บ Benchmark - เรียกใช้การทดสอบมาตรฐานที่เปรียบเทียบอัตราการปฏิเสธ, ความซับซ้อน (perplexity), และความสอดคล้อง (coherence) ก่อนและหลัง

เมตริกสำคัญที่ต้องตรวจสอบ:

หากอัตราการปฏิเสธยังคงสูง ให้ลองใช้วิธีที่รุนแรงขึ้นหรือเปิดใช้งานการปรับปรุงซ้ำ

เทคนิคขั้นสูงและโมดูลการวิเคราะห์

OBLITERATUS มีโมดูลการวิเคราะห์ 15 โมดูลที่สร้างแผนที่เรขาคณิตของมาตรการป้องกันทั้งก่อนและระหว่างการทำ obliteration สิ่งเหล่านี้ไม่ใช่แค่การวินิจฉัย แต่ยังให้ข้อมูลเชิงรุกแก่กระบวนการกำจัดอีกด้วย

โมดูลการวิเคราะห์หลัก

1. Cross-Layer Alignment Analyzer

สร้างแผนที่ว่าทิศทางการปฏิเสธพัฒนาไปอย่างไรในแต่ละเลเยอร์ แสดงให้เห็นว่าการปฏิเสธกระจุกตัวอยู่ในกลุ่มเลเยอร์เฉพาะ หรือกระจายอย่างสม่ำเสมอ

from obliteratus.analysis import CrossLayerAlignmentAnalyzer

analyzer = CrossLayerAlignmentAnalyzer(model)
alignment_profile = analyzer.analyze(refusal_direction)

2. Refusal Logit Lens

ระบุว่าโมเดล “ตัดสินใจ” ที่จะปฏิเสธที่เลเยอร์ใด อ้างอิงจากเทคนิค logit lens ของ nostalgebraist

3. Whitened SVD Extractor

การดึงทิศทางที่ปรับค่าความแปรปรวนร่วมที่แยกสัญญาณมาตรการป้องกันออกจากความแปรปรวนของการเปิดใช้งานตามธรรมชาติ ทำให้การดึงข้อมูลสะอาดกว่า SVD มาตรฐาน

4. Activation Probing

วัดปริมาณสัญญาณการปฏิเสธที่มีอยู่ในแต่ละเลเยอร์

5. Defense Robustness Evaluator

ระบุความเสี่ยงของปรากฏการณ์โอโรบอรอสเชิงปริมาณ – ว่ามาตรการป้องกันจะพยายามซ่อมแซมตัวเองหลังจากการลบหรือไม่ สิ่งสำคัญสำหรับการพิจารณาจำนวนรอบการปรับปรุงที่จะเรียกใช้

6. Concept Cone Analyzer

สร้างแผนที่ทิศทางของมาตรการป้องกันสำหรับแต่ละประเภทพร้อมการประมาณมุมทึบ เปิดเผยว่า “การปฏิเสธ” เป็นกลไกเดียวที่รวมกัน หรือเป็นกลไกอิสระหลายอย่าง

7. Alignment Imprint Detector

ระบุร่องรอยของวิธีการฝึกจัดตำแหน่ง (DPO เทียบกับ RLHF เทียบกับ CAI เทียบกับ SFT) จากเรขาคณิตของสเปซย่อยเพียงอย่างเดียว ให้ข้อมูลเชิงกลยุทธ์การกำจัดที่เหมาะสมที่สุด

8. Multi-Token Position Analyzer

แสดงให้เห็นว่าสัญญาณการปฏิเสธกระจุกตัวอยู่ที่ตำแหน่งใดในลำดับ โมเดลบางตัวตัดสินใจตั้งแต่เนิ่นๆ ในขณะที่บางตัวสะสมสัญญาณการปฏิเสธข้ามโทเค็นจำนวนมาก

9. Sparse Direction Surgeon

ระบุว่าแถวน้ำหนักเฉพาะใดที่มีสัญญาณการปฏิเสธมากที่สุด ช่วยให้การผ่าตัดเป็นแบบกำหนดเป้าหมายแทนที่จะเป็นการฉายภาพแบบครอบคลุม

10. Causal Refusal Tracer

ประมาณค่าการติดตามเชิงสาเหตุเพื่อระบุว่าส่วนประกอบใดที่มีความจำเป็นเชิงสาเหตุต่อการปฏิเสธ

11. Residual Stream Decomposer

แยกแยะว่าการปฏิเสธมาจากกลไกความสนใจ (attention mechanisms) มากน้อยเพียงใดเมื่อเทียบกับบล็อก MLP ให้ข้อมูลว่าจะกำหนดเป้าหมายเลเยอร์ attention หรือ FFN

12. Linear Refusal Probe

ฝึกตัวจำแนกประเภทเชิงเส้นเพื่อตรวจจับข้อมูลการปฏิเสธที่ทิศทางการวิเคราะห์อาจพลาดไป

13. Transfer Analyzer

วัดดัชนีความเป็นสากลข้ามโมเดล (Cross-Model Universality Index) – ว่าทิศทางของมาตรการป้องกันใช้ได้กับสถาปัตยกรรมหลายประเภทหรือไม่

14. Steering Vector Factory

สร้างเวกเตอร์ควบคุม (steering vectors) ในเวลาอนุมานจากทิศทางการปฏิเสธ ช่วยให้สามารถแทรกแซงแบบย้อนกลับได้และไม่ก่อให้เกิดความเสียหาย

15. Evaluation Suite

คำนวณอัตราการปฏิเสธ, ความซับซ้อน (perplexity), ความสอดคล้อง (coherence), KL divergence, CKA (Centered Kernel Alignment), และอันดับที่มีประสิทธิภาพ (effective rank)

ไพพ์ไลน์ที่ใช้การวิเคราะห์เป็นข้อมูล

ไพพ์ไลน์ที่ใช้ข้อมูลจะปิดวงจรการตอบกลับระหว่างการวิเคราะห์และการลบ:

SUMMON  →  Load model
PROBE   →  Collect activations
ANALYZE →  Map geometry before touching anything
DISTILL →  Extract directions with analysis-tuned params
EXCISE  →  Surgically break only the right chains
VERIFY  →  Check for Ouroboros effect, compensate if needed
REBIRTH →  Save with comprehensive analysis metadata

ในระหว่างขั้นตอน ANALYZE โมดูลสี่ตัวจะทำงานและผลลัพธ์ของโมดูลเหล่านั้นจะกำหนดค่าทุกอย่างในขั้นตอนถัดไปโดยอัตโนมัติ:

สิ่งนี้ทำให้เกิดความแม่นยำระดับการผ่าตัดที่วิธีการแบบหยาบไม่สามารถเทียบได้

เทคนิคใหม่ๆ

OBLITERATUS ใช้เทคนิคหลายอย่างที่เหนือกว่างานวิชาการที่ตีพิมพ์แล้ว:

เทคนิคเหล่านี้เกิดขึ้นจากแพลตฟอร์มการวิจัยแบบระดมทุนจากผู้คน – ทุกการทำงานที่เปิดใช้งาน telemetry จะส่งข้อมูลที่ช่วยปรับปรุงเวอร์ชันถัดไป

วิธีการย้อนกลับได้เทียบกับวิธีการถาวร

OBLITERATUS รองรับกระบวนทัศน์การแทรกแซงสองแบบ: การฉายภาพน้ำหนักแบบถาวรและเวกเตอร์ควบคุมแบบย้อนกลับได้

การฉายภาพน้ำหนัก (ถาวร)

มีเจ็ดวิธีที่ตั้งไว้ล่วงหน้าซึ่งแก้ไขน้ำหนักโมเดลโดยตรง:

obliteratus obliterate meta-llama/Llama-3.1-8B-Instruct --method advanced

ข้อดี:

• การลบที่สมบูรณ์และละเอียดถี่ถ้วน
• ไม่มีค่าใช้จ่ายในการรันไทม์
• ทำงานได้กับกลไกการอนุมานใดๆ
• การดำเนินการครั้งเดียว

ข้อเสีย:

• ไม่สามารถย้อนกลับได้ (ควรสำรองข้อมูล)
• ต้องทำ obliteration ใหม่เพื่อปรับเปลี่ยน
• อาจทำให้สิทธิ์การใช้งานโมเดลเป็นโมฆะ

เหมาะที่สุดสำหรับการนำไปใช้งานจริงที่คุณต้องการโมเดลที่ถูกปลดปล่อยอย่างสะอาดและถาวร

เวกเตอร์ควบคุม (ย้อนกลับได้)

เวกเตอร์ควบคุมจะใช้การแทรกแซงในเวลาอนุมานโดยไม่แก้ไขน้ำหนัก:

from obliteratus.analysis import SteeringVectorFactory, SteeringHookManager
from obliteratus.analysis.steering_vectors import SteeringConfig

# Create a steering vector from a refusal direction
vec = SteeringVectorFactory.from_refusal_direction(refusal_dir, alpha=-1.0)

# Or from contrastive activation pairs
vec = SteeringVectorFactory.from_contrastive_pairs(harmful_acts, harmless_acts)

# Apply at inference time -no weight modification
config = SteeringConfig(vectors=[vec], target_layers=[10, 11, 12, 13, 14, 15])
manager = SteeringHookManager()
manager.install(model, config)

# Generate with steering active
output = model.generate(input_ids)

# Remove steering -model is back to normal
manager.remove()

ข้อดี:

• ย้อนกลับได้อย่างสมบูรณ์
• พารามิเตอร์ alpha ที่ปรับได้
• สามารถประกอบได้ (ซ้อนเวกเตอร์หลายตัว)
• ไม่ทำลายข้อมูล
• ไม่มีข้อกังวลเกี่ยวกับสิทธิ์การใช้งาน

ข้อเสีย:

• ต้องใช้โครงสร้างพื้นฐานการควบคุมในเวลาอนุมาน
• ค่าใช้จ่ายในการรันไทม์จาก hooks
• อาจไม่ละเอียดเท่ากับการฉายภาพน้ำหนัก

เหมาะที่สุดสำหรับงานวิจัย การทดลอง และแอปพลิเคชันที่คุณต้องการเปิดและปิดการปฏิเสธ

การเลือกระหว่างวิธีการต่างๆ

กรณีการใช้งานจริง

1. การทดสอบและพัฒนา API

เมื่อสร้าง API ที่สร้างเนื้อหา โมเดลที่ไม่มีข้อจำกัดจะสร้างกรณีทดสอบที่ครอบคลุมมากขึ้น โมเดลที่จัดตำแหน่งปฏิเสธกรณีพิเศษที่อาจทำให้เกิดข้อผิดพลาดในการผลิต

ทีมพัฒนาที่สร้าง API การดูแลเนื้อหาใช้ OBLITERATUS เพื่อปลดปล่อยโมเดลสร้างข้อมูลทดสอบของตน โมเดลที่ถูกปลดปล่อยสร้างกรณีทดสอบที่ครอบคลุมสถานการณ์ที่โมเดลที่จัดตำแหน่งปฏิเสธ รวมถึงกรณีพิเศษที่มีความซับซ้อนทางศีลธรรมและเนื้อหาที่ก้ำกึ่ง สิ่งนี้ช่วยให้พบข้อผิดพลาดที่จะถูกส่งไปยังการผลิต

สำหรับนักพัฒนา API สิ่งนี้มีความสำคัญเนื่องจากการทดสอบที่ครอบคลุมต้องใช้โมเดลที่สร้างเนื้อหาได้ทุกประเภท แม้กระทั่งเนื้อหาที่ระบบการผลิตอาจกรองออก ผู้ใช้ Apidog ที่สร้างไพพ์ไลน์การทดสอบ API สามารถผสานรวมโมเดลที่ถูกปลดปล่อยเพื่อสร้างชุดทดสอบที่ละเอียดถี่ถ้วนยิ่งขึ้น

button

2. งานวิจัยเชิงวิชาการ

นักวิจัยที่ศึกษพฤติกรรมของโมเดลจำเป็นต้องสังเกตว่าโมเดลจะสร้างผลลัพธ์อะไรหากไม่มีการฝึกอบรมด้านความปลอดภัย OBLITERATUS ช่วยให้สามารถทดลองที่ควบคุมได้โดยการลบการปฏิเสธออกอย่างเป็นระบบ

ห้องปฏิบัติการของมหาวิทยาลัยแห่งหนึ่งใช้โมดูลการวิเคราะห์เพื่อสร้างแผนที่เรขาคณิตของการปฏิเสธใน 20 โมเดล โดยตีพิมพ์ผลการวิจัยเกี่ยวกับความเป็นสากลของทิศทางการปฏิเสธ ชุดข้อมูล telemetry ที่ได้รับจากผู้คนช่วยเร่งงานวิจัยของพวกเขาโดยการจัดหาข้อมูลเกณฑ์มาตรฐานที่ห้องปฏิบัติการเดียวไม่สามารถรวบรวมได้

3. แอปพลิเคชันการเขียนเชิงสร้างสรรค์

นักเขียนที่สร้างเครื่องมือสร้างเรื่องราวจะเจอทางตันเมื่อโมเดลปฏิเสธสถานการณ์ที่มีความซับซ้อนทางศีลธรรม สตูดิโอเกมแห่งหนึ่งที่พัฒนาระบบบทสนทนาของ NPC ได้ปลดปล่อยโมเดลของตนเพื่อให้สามารถจัดการกับตัวละครวายร้าย ภารกิจที่คลุมเครือทางศีลธรรม และสถานการณ์ความขัดแย้งที่โมเดลที่จัดตำแหน่งปฏิเสธ

ผลลัพธ์: การเล่าเรื่องที่ละเอียดอ่อนยิ่งขึ้นโดยไม่ลดทอนความสามารถทางภาษาของโมเดล

4. การทดสอบความปลอดภัยแบบ Red Teaming

นักวิจัยด้านความปลอดภัยจำเป็นต้องเห็นว่าโมเดลจะสร้างผลลัพธ์อะไรหากไม่มีการฝึกอบรมด้านความปลอดภัยเพื่อทำความเข้าใจช่องโหว่ OBLITERATUS ช่วยให้การเปิดเผยข้อมูลอย่างรับผิดชอบโดยการให้นักวิจัยทดสอบขอบเขตก่อนที่จะรายงานปัญหาไปยังผู้พัฒนาโมเดล

5. การแปลและแอปพลิเคชันหลายภาษา

การปฏิเสธที่ฝึกด้วยเนื้อหาภาษาอังกฤษมักจะถ่ายโอนไปยังภาษาอื่นได้ไม่ดี ทีมแปลภาษาท้องถิ่นพบว่าโมเดลที่จัดตำแหน่งปฏิเสธในภาษาอังกฤษแต่ไม่ปฏิเสธในภาษาสเปน ซึ่งเป็นพฤติกรรมที่ไม่สอดคล้องกันที่ทำให้ผู้ใช้สับสน การปลดปล่อยโมเดลทำให้เกิดพฤติกรรมที่สอดคล้องกันในทุกภาษาที่รองรับ

ทางเลือกและการเปรียบเทียบ

มีเครื่องมือหลายอย่างสำหรับการวิเคราะห์และแก้ไขพฤติกรรมของโมเดล นี่คือการเปรียบเทียบ OBLITERATUS:

เมื่อใดควรใช้ทางเลือกอื่น:

• TransformerLens - เหมาะสำหรับงานวิจัยการตีความเชิงกลไกทั่วไปที่นอกเหนือจากการปฏิเสธ
• SAELens - เชี่ยวชาญสำหรับการวิเคราะห์ sparse autoencoder
• RepEng - อินเทอร์เฟซที่ง่ายกว่าสำหรับการใช้งานเวกเตอร์ควบคุมพื้นฐาน

เมื่อ OBLITERATUS ชนะ:

• การวิเคราะห์และการกำจัดที่เฉพาะเจาะจงกับการปฏิเสธ
• ไพพ์ไลน์พร้อมใช้งานสำหรับการผลิตพร้อมการตรวจสอบ
• ชุดข้อมูลงานวิจัยที่ระดมจากผู้คน
• อินเทอร์เฟซเว็บสำหรับผู้ใช้ที่ไม่ใช่ด้านเทคนิค
• ความครอบคลุมของการทดสอบที่ครอบคลุม

บทสรุป

OBLITERATUS แสดงถึงความก้าวหน้าที่สำคัญในเทคโนโลยีการปลดปล่อยโมเดล มันรวมงานวิจัยที่ตีพิมพ์เข้ากับเทคนิคใหม่ในปี 2025-2026 เพื่อให้สามารถกำจัดพฤติกรรมการปฏิเสธได้อย่างแม่นยำในขณะที่ยังคงรักษาความสามารถหลักไว้

ชุดเครื่องมือนี้ช่วยให้นักพัฒนาและนักวิจัยควบคุมโมเดลที่พวกเขานำไปใช้งานได้ พฤติกรรมของโมเดลควรถูกตัดสินใจโดยผู้ที่ใช้งาน ไม่ใช่ถูกล็อกไว้ตั้งแต่ตอนฝึกอบรม

ไม่ว่าคุณกำลังสร้างไพพ์ไลน์การทดสอบ API ที่ต้องการการสร้างกรณีทดสอบที่ครอบคลุม กำลังวิจัยการตีความเชิงกลไก หรือเพียงแค่เบื่อหน่ายกับการถูก LLM ในเครื่องของคุณอบรมสั่งสอน OBLITERATUS ก็มีเครื่องมือที่จะปลดปล่อยโมเดลของคุณ

ขั้นตอนต่อไป:

1. เยี่ยมชม HuggingFace Space สำหรับการทดสอบโดยไม่ต้องตั้งค่าใดๆ
2. ติดตั้งบนเครื่องเพื่อเข้าถึง GPU เต็มรูปแบบและวนซ้ำได้เร็วขึ้น
3. สำรวจโมดูลการวิเคราะห์เพื่อทำความเข้าใจเรขาคณิตของมาตรการป้องกันของโมเดลของคุณ
4. ร่วมสนับสนุนชุดข้อมูลชุมชนโดยการเปิดใช้งาน telemetry
5. ผสานรวมโมเดลที่ถูกปลดปล่อยเข้ากับเวิร์กโฟลว์การพัฒนาของคุณ

โซ่ตรวนถูกระบุแล้ว เครื่องมือก็พร้อมแล้ว ทำลายมันซะ

ส่วนคำถามที่พบบ่อย (FAQ)

การใช้งาน OBLITERATUS ถูกกฎหมายหรือไม่?

ใช่ OBLITERATUS เป็นซอฟต์ต์แวร์โอเพนซอร์สที่เผยแพร่ภายใต้ลิขสิทธิ์ AGPL-3.0 คุณกำลังแก้ไขโมเดลที่คุณมีสิทธิ์ใช้งาน ผู้ใช้เชิงพาณิชย์ที่ไม่สามารถปฏิบัติตาม AGPL ได้สามารถซื้อสิทธิ์การใช้งานเชิงพาณิชย์ได้

สิ่งนี้จะใช้ได้กับโมเดลแบบปิดเช่น GPT-4 หรือไม่?

ไม่ OBLITERATUS ต้องการการเข้าถึงน้ำหนักของโมเดล ซึ่งมีเฉพาะโมเดลแบบเปิดน้ำหนักเท่านั้นที่ให้ได้ API แบบปิดไม่เปิดเผยพารามิเตอร์ภายในที่จำเป็นสำหรับการทำ abliteration

การลบการปฏิเสธทำให้โมเดลเป็นอันตรายหรือไม่?

OBLITERATUS เป็นเครื่องมือสำหรับนักวิจัยและนักพัฒนา ชุดเครื่องมือนี้มีเมตริกการประเมินเพื่อตรวจสอบว่าความสามารถยังคงอยู่ครบถ้วน การใช้งานอย่างรับผิดชอบหมายถึงการทำความเข้าใจบริบทการนำไปใช้งานของคุณและการใช้มาตรการป้องกันที่เหมาะสมในระดับแอปพลิเคชัน

กระบวนการนี้ใช้เวลานานเท่าไหร่?

10-30 นาทีขึ้นอยู่กับขนาดของโมเดลและ GPU โมเดลขนาดเล็ก (ต่ำกว่า 8B พารามิเตอร์) ใช้เวลา 10-15 นาที โมเดลขนาดใหญ่อาจใช้เวลามากกว่า 30 นาที

ฉันจำเป็นต้องมี GPU หรือไม่?

HuggingFace Spaces ทำงานบน ZeroGPU โดยไม่จำเป็นต้องมีฮาร์ดแวร์ในเครื่อง สำหรับการใช้งานในเครื่อง GPU ช่วยเร่งกระบวนการได้อย่างมาก แต่โหมด CPU สามารถใช้ได้กับโมเดลขนาดเล็กจิ๋ว

ฉันสามารถย้อนกลับการเปลี่ยนแปลงได้หรือไม่?

การฉายภาพน้ำหนักเป็นแบบถาวร – ควรสำรองข้อมูลของโมเดลต้นฉบับไว้ เวกเตอร์ควบคุมสามารถย้อนกลับได้อย่างสมบูรณ์และสามารถเปิด/ปิดได้ในเวลาอนุมาน

โมเดลจะยังคงทำตามคำสั่งหรือไม่?

ใช่ Abliteration กำหนดเป้าหมายทิศทางการปฏิเสธโดยเฉพาะ ความสามารถในการทำตามคำสั่งยังคงอยู่ครบถ้วน เมตริกคุณภาพ (perplexity, coherence) ยืนยันเรื่องนี้

รองรับโมเดลใดบ้าง?

โมเดลที่คัดสรรแล้ว 116 ตัวในห้าระดับ ตั้งแต่ GPT-2 ไปจนถึง DeepSeek-V3.2 685B โมเดล Transformer ของ HuggingFace ใดๆ ก็ตามสามารถใช้งานได้ รวมถึง LLaMA, Mistral, Qwen, Gemma, Phi และอื่นๆ

ฉันจะร่วมสนับสนุนงานวิจัยได้อย่างไร?

เปิดใช้งาน telemetry ด้วยแฟล็ก --contribute หรือตั้งค่า export OBLITERATUS_TELEMETRY=1 ข้อมูลเกณฑ์มาตรฐานที่ไม่ระบุตัวตนของคุณจะถูกส่งเข้าสู่ชุดข้อมูลชุมชนที่ขับเคลื่อนลีดเดอร์บอร์ดสาธารณะ