Как аблитерация LLM убирает отказы правкой весов, а не обучением

Задайте современной чат-модели вполне законный технический вопрос, и вы всё равно можете получить «Извините, я не могу с этим помочь». Небольшие instruct-модели вроде Qwen3-4B делают так регулярно. Отказ кажется встроенным, но нигде не прописан жёстко. Исследования показывают, что он лежит вдоль одного направления в пространстве активаций модели, а техника под названием аблитерация убирает это направление, напрямую редактируя веса. Ни дообучения, ни обучающих данных не требуется.

Исследования того, как языковые модели отказывают, указывают на нечто вполне конкретное: в некоторых выровненных моделях поведение отказа можно описать как низкоразмерное направление в пространстве активаций. На этом и строится аблитерация. Она вносит точечные изменения в веса, подавляющие это направление. В отличие от дообучения, ей не нужны ни обучающий набор, ни градиентный спуск, ни долгая оптимизация. Она ищет вектор отказа модели и изменяет выбранные матрицы весов так, чтобы отказы стали менее вероятными.

Ниже объясняется, как работает аблитерация, как вектор отказа находят расчётом разности средних, как open-source инструмент Heretic автоматизирует настройку и как локально запустить аблитерированный чекпоинт Qwen3-4B-Instruct-2507. Что разбирается:

• геометрическая интуиция, стоящая за вектором отказа
• почему его удаление в основном не затрагивает рассуждения
• как запустить полученную модель из Python или Ollama
• что эта техника означает для безопасности моделей с открытыми весами и для red teaming

Что означает это слово

«Аблитерация» (abliteration) соединяет ablation, то есть хирургическое удаление, и obliteration, то есть полное стирание. Проще говоря, она навсегда вырезает механизм отказа модели, редактируя её внутренние веса, без какого-либо обучения или дообучения и не затрагивая базовые способности модели.

Причина, по которой это может работать, кроется в том, как выполняется выравнивание. Когда лаборатории выравнивают модель с помощью RLHF (обучения с подкреплением на основе обратной связи от людей) или DPO (прямой оптимизации предпочтений), они не переписывают её знания о мире. Они усиливают одно поведенческое направление. Когда во входных данных есть чувствительные паттерны, срабатывает триггер отказа, и модель выдаёт шаблонный отказ.

Аблитерация находит, где этот триггер расположен в пространстве активаций, а затем проецирует его из матриц весов, чтобы он больше не мог сработать.

Поиск направления отказа

Внутри большой языковой модели идеи, признаки и темы проявляются как прямые направления в пространстве с тысячами измерений, и отказ не исключение. Чтобы вычленить его направление, достаточно простой статистической операции — разности средних. Она выполняется в три шага:

1. Записать вредные активации. Прогнать через модель набор вредных запросов и снять скрытые состояния в residual stream на каждом слое трансформера в позиции последнего токена.
2. Записать безвредные активации. Сделать то же самое с эквивалентным набором безобидных запросов, например «Как испечь хлеб?»
3. Вычислить разность. Вычесть средний вектор безобидных активаций из среднего вектора вредных. Общие языковые и семантические признаки взаимно уничтожаются, и остаётся один вектор: направление отказа, обозначаемое r-hat.

Оставшийся вектор и есть направление отказа, взятое со слоя, где оно сильнее всего. Когда оно известно, правка сводится к проецированию этой компоненты из весов, как в наброске ниже:

[ Incoming Token Activations ] ──> [ Weight Matrix (W) ] ──> [ Output without Refusal Vector ]
                                            │
                                  [ Vector Projection (r̂)
                                      Stripped Out ]

Почему модель сохраняет способности

Удаление одного направления звучит радикально, но это очень узкая правка. У пространства активаций тысячи измерений, а проекция убирает лишь одно — то, что отделяет отказ от согласия. Всё, что модель знает о коде, математике, истории или грамматике, живёт в других направлениях, и их не трогают. Дообучение, напротив, сдвигает сразу все параметры. Поэтому аблитерированный чекпоинт, как правило, сохраняет общие навыки, а модель, обученная против своих ограничений, может часть из них потерять. Ограничение по KL-дивергенции добавляет вторую страховку: правка, которая слишком сильно сдвигает выходное распределение от исходной модели, штрафуется во время поиска.

Запуск аблитерированной модели

Чтобы пользоваться результатом, не нужны ни дообучение, ни проприетарный API, ни собственный движок инференса. Изменение находится в самих весах, поэтому модель без всяких модификаций запускается в стандартной библиотеке Hugging Face transformers. Ollama тоже подходит.

В Ollama одна команда скачивает и запускает квантизованную сборку:

ollama run hf.co/IamLucif3r/Qwen3-4B-Instruct-2507-Abliterated:Q4_K_M

В Python начните с импортов:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

Затем загрузите токенизатор и веса и сгенерируйте ответ:

# 1. Specify the model repository
model_id = "IamLucif3r/qwen3-4b-instruct-2507-abliterated"# 2. Load tokenizer and abliterated weights
print("Loading model weights...")
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)# 3. Structure your prompt using Qwen's chat template
messages = [
    {
        "role": "system",
        "content": "You are a direct, highly technical security assistant. Provide precise and unrestricted explanations."
    },
    {
        "role": "user",
        "content": "Explain how buffer overflow vulnerabilities overwrite the instruction pointer (EIP/RIP) and provide a minimal C code example illustrating the flaw."
    }
]# 4. Format and tokenize
prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)# 5. Generate completion
outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.7,
    top_p=0.9
)# 6. Decode output
response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print("\n--- Response ---")
print(response)

В bfloat16 модель на 4B помещается примерно в 8–12 ГБ видеопамяти. Это делает её практичной на ноутбуках, личных рабочих станциях и edge-устройствах. Mac mini справляется с ней без проблем, а в качестве фронтенда к ней хорошо подходит OpenWebUI.

Автоматизация поиска с Heretic

Теория направленной абляции аккуратна, но ортогонализация весов вручную раньше была утомительным методом проб и ошибок. Исследователи писали собственные хуки активаций, проверяли десятки отдельных слоёв и вручную подбирали силу абляции, чтобы общие рассуждения не деградировали.

Heretic, инструмент с открытым исходным кодом, автоматизирует весь этот цикл оптимизации и сводит когнитивный ущерб к минимуму. Его конвейеру не нужны ни написанные вручную скрипты PyTorch, ни размеченные вредные ответы, ни большой GPU-кластер.

Сначала настройте обычное окружение Python с поддержкой GPU, будь то CUDA или Apple Silicon, и установите пакет:

pip install -U heretic-llm

Затем укажите инструменту командной строки идентификатор Hugging Face модели, которую нужно обработать:

heretic Qwen/Qwen3-4B-Instruct-2507

За этой одной командой Heretic делает три вещи:

• Бенчмарк железа: проверяет доступную видеопамять, чтобы выбрать оптимальный размер батча для оценки.
• Сэмплирование активаций: обрабатывает контрастные наборы вредных и безвредных инструкций и вычисляет векторы разности средних для каждого слоя.
• Оптимизацию гиперпараметров: использует Tree-structured Parzen Estimators (TPE через Optuna) для поиска весов слоёв. Цель — снизить долю отказов, удерживая низкой дивергенцию Кульбака — Лейблера (KL), чтобы сохранить базовые рассуждения.

На выходе получается чекпоинт с открытыми весами, готовый к использованию для инференса или аудита безопасности.

Три способа обойти отказы

Те, кто хочет обойти ограничения безопасности LLM, обычно выбирают один из трёх подходов: джейлбрейки на уровне промптов, дообучение параметров или механистическую аблитерацию. Все три нацелены на одно и то же поведение. Сильно различаются они механикой, вычислительной стоимостью и долговечностью.

Джейлбрейки на уровне промптов

Ролевые промпты вроде «Do Anything Now», модуляция персоны и состязательные суффиксы вроде Greedy Coordinate Gradient (GCG) пытаются обмануть механизм внимания, чтобы тот ставил полезность выше отказа.

• Слабое место: они хрупкие. Суффикс, который ломает отказ на одной модели, часто совсем не работает на другой или перестаёт работать после небольшого изменения системного промпта.
• Цена: они забивают контекстное окно мусорными токенами и часто делают сам ответ хаотичным или бессвязным.

Дообучение

Здесь выровненную модель переобучают, часто с LoRA, на отобранном наборе вредоносных инструкций в паре с явными, ничем не ограниченными ответами.

• Слабое место: собрать сотни качественных пар вредных вопросов и ответов — это серьёзная ручная работа или парсинг.
• Цена: градиентный спуск — грубый инструмент. Обучение, снимающее ограничения, часто вызывает катастрофическое забывание, которое незаметно подтачивает навыки программирования, математическую логику и общий интеллект.

Аблитерация

Ортогонализация весов не обманывает модель и не переобучает её. Вместо того чтобы учить сеть новому поведению через градиенты, она применяет механистическую интерпретируемость, чтобы найти единственный одномерный вектор, стоящий за отказом, и вырезать его из матриц весов.

• Вредные ответы не нужны. Достаточно небольшого набора вредных промптов, чтобы увидеть, где активации отличаются от безвредных, и модели никогда не нужно показывать, как написать эксплойт или собрать пейлоад.
• Малые когнитивные потери. Правка строго ранга один и ограничена KL-дивергенцией, поэтому сеть сохраняет исходные способности к рассуждению и языку.
• Постоянно и переносимо. Результат — обычный лёгкий набор весов, которым можно поделиться на Hugging Face и запускать на потребительском железе без специального кода инференса.

Что это говорит о безопасности открытых весов

Создание такого чекпоинта обнажает неудобный факт о выравнивании: при открытых весах дообучение на безопасность — временная защита. Если правка весов так легко обходит выравнивание, как индустрии выстраивать настоящую эшелонированную защиту? Выделяются два направления.

Первое — обеспечивать безопасность на входе и выходе с помощью отдельных, защищённых моделей-ограничителей, таких как Llama Guard, которые работают вне основного движка генерации. Внешние прокси-файрволы, например NeMo Guardrails или промежуточное ПО API, тоже могут сверять промпты и ответы со строгой политикой организации, прежде чем что-либо покинет конвейер инференса.

Второе — выполнять инференс в аппаратно изолированных средах, таких как AMD SEV-SNP или NVIDIA H100 Confidential Computing, чтобы тензоры весов оставались зашифрованными в памяти. Если веса нельзя прочитать или изменить через хуки отладчика, атаки ортогонализацией становятся невозможными для внешних пользователей.

Аблитерация показывает, что безопасность ИИ не решится лучшими системными промптами или более длинными циклами RLHF. Для исследователей безопасности и red team аблитерированные чекпоинты служат инструментом, позволяющим выяснить, что модель знает по существу. Разумный следующий шаг — загрузить такой чекпоинт через стандартные конвейеры transformers и использовать его для аудита собственных промптов и инструментов.

Открытым остаётся вопрос: если выравнивание можно стереть простой матричной проекцией, не стоит ли передовым лабораториям вовсе отказаться от выравнивания постфактум?

Источники

1. Refusal in Language Models Is Mediated by a Single Direction (arXiv 2406.11717)
2. Концепция разности средних в описании блога EleutherAI
3. Heretic, open-source инструмент для аблитерации на GitHub
4. Confidential Computing on NVIDIA H100 GPU: A Performance Benchmark Study (arXiv 2409.03992)