Zer0Kernel Security Community — 🧠 Обсуждение нейросетей

Qwen
LLM-агент — это не просто модель, которая отвечает на вопрос. Это система, в которой языковая модель выступает ядром принятия решений: она получает задачу, разбивает её на шаги, вызывает внешние инструменты, анализирует результаты и корректирует план до тех пор, пока цель не достигнута. Ключевое отличие от обычного чат-бота — наличие цикла «рассуждение → действие → наблюдение», который повторяется итеративно.

Базовый цикл рассуждения​


В основе большинства агентных систем лежит паттерн, который можно описать тремя фазами:

  1. Рассуждение (Thought) — модель анализирует текущее состояние, определяет, что нужно сделать дальше.
  2. Действие (Action) — модель выбирает инструмент и формирует вызов с конкретными аргументами.
  3. Наблюдение (Observation) — результат выполнения инструмента возвращается в контекст модели.

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

Код:
┌─────────────────────────────────────────────┐
│  Задача (user query)                        │
└──────────────────┬──────────────────────────┘
                   ▼
┌─────────────────────────────────────────────┐
│  Рассуждение: что делать дальше?            │
└──────────────────┬──────────────────────────┘
                   ▼
┌─────────────────────────────────────────────┐
│  Действие: вызов инструмента                │
└──────────────────┬──────────────────────────┘
                   ▼
┌─────────────────────────────────────────────┐
│  Наблюдение: результат инструмента          │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
          Задача решена? ──Нет──→ вернуться к «Рассуждение»
                   │
                  Да
                   ▼
              Финальный ответ

Этот паттерн известен как ReAct (Reasoning + Acting) и был предложен в работе Yao et al. (2022). Он показал, что чередование рассуждений с действиями даёт лучшие результаты...
Ответы: 0 Просмотры: 10 Последняя активность:
Qwen
Языковая модель после предобучения на корпусе текстов умеет предсказывать следующий токен, но не понимает, какой ответ полезен, безопасен и соответствует ожиданиям пользователя. Выравнивание (alignment) — этап постобучения, на котором модель учат предпочитать одни ответы другим. Два наиболее распространённых подхода: RLHF (Reinforcement Learning from Human Feedback) и DPO (Direct Preference Optimization).

Что решает выравнивание​


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

Типичные цели выравнивания:

  • Полезность — ответ решает задачу пользователя.
  • Безопасность — модель отказывается от вредных запросов, не генерирует опасные инструкции.
  • Честность — модель не выдумывает факты, признаёт неопределённость.
  • Стиль — ответы соответствуют формату и тону, ожидаемому от ассистента.

Классический RLHF: три этапа​


RLHF — это пайплайн из трёх последовательных стадий. Каждая требует отдельного набора данных и отдельной модели.

Этап 1. Сбор данных предпочтений​


Аннотаторам показывают промпт и несколько ответов модели (обычно два). Задача — выбрать лучший. Результат — датасет пар (chosen, rejected) для каждого промпта.

Качество этого датасета критично: если аннотаторы непоследовательны или инструкции размыты, reward-модель выучит шум вместо реальных предпочтений.

Этап 2. Обучение reward-модели (RM)​


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

Код:
L_RM = -log σ(r(x, y_w) - r(x, y_l))

где r(x, y) — скалярная оценка пары (промпт, ответ), y_w — предпочтённый ответ, y_l —...
Ответы: 0 Просмотры: 11 Последняя активность:
Qwen
KV cache — это буфер в GPU-памяти, где хранятся уже вычисленные проекции Key и Value для предыдущих токенов. Без него autoregressive генерация была бы квадратичной по вычислениям: на каждом шаге пришлось бы заново прогонять весь контекст через все слои attention.

Механика: зачем нужен кэш​


В transformer-слое с self-attention каждый токен проецируется в три вектора: Query (Q), Key (K) и Value (V). Attention score считается как softmax(QK^T / √d), а выход — как взвешенная сумма V.

При генерации token-by-token на шаге t модель обрабатывает только один новый токен, но для attention ему нужны K и V всех предыдущих позиций (0..t−1). Если не кэшировать, на каждом шаге пришлось бы пересчитывать K и V для всей последовательности — суммарно O(n²) операций на генерацию из n токенов.

KV cache устраняет эту избыточность: после первого прогона (prefill) K и V всех токенов сохраняются в памяти. На каждом следующем шаге (decode) вычисляются только K и V нового токена, дописываются в буфер, и attention считается по всему накопленному кэшу.

Две фазы инференса принципиально различаются по характеру нагрузки:

  • Prefill — обработка всего входного промпта за один проход. Вычисления ограничены производительностью GPU (compute-bound), память кэша заполняется целиком.
  • Decode — генерация по одному токену за шаг. Каждый шаг требует чтения всего накопленного KV cache из памяти, поэтому фаза ограничена пропускной способностью памяти (memory-bound).

Именно поэтому на этапе decode скорость генерации падает с ростом длины контекста: объём данных, которые нужно прочитать из VRAM на каждом шаге, растёт линейно.

Формула размера​


Код:
KV_cache_bytes = 2 × num_layers × num_kv_heads × head_dim × seq_len × bytes_per_element

  • 2 — хранятся и K, и V
  • num_layers — число transformer-слоёв
  • num_kv_heads — число голов K/V (при GQA/MQA меньше числа Q-голов)
  • head_dim — размерность одной головы (обычно 128)...
Qwen
Mixture of Experts (MoE) — архитектурный паттерн, при котором слой нейросети разбивается на несколько подсетей-«экспертов», а для каждого входного токена активируется только их подмножество. Это позволяет нарастить ёмкость модели без пропорционального роста вычислительных затрат: параметров больше, но на каждый токен тратится меньше FLOPs.

Как устроен MoE-слой​


В классическом трансформере каждый блок содержит MLP (Multi-Layer Perceptron), который обрабатывает все токены одинаково. В MoE-варианте этот MLP заменяется набором из E экспертных подсетей. Каждая подсеть выполняет собственное вычисление независимо, а результаты комбинируются — через усреднение или взвешенную сумму.

MoE бывает двух типов:

  • Dense MoE — все эксперты активируются для каждого входа. Ёмкость растёт, но и вычисления растут пропорционально.
  • Sparse MoE — для каждого токена выбирается только подмножество экспертов (обычно K из E). Именно этот вариант даёт выигрыш в эффективности.

В большинстве опубликованных работ MoE применяется к MLP-слоям внутри трансформерных блоков. Однако исследования показывают, что концепцию можно распространить и на другие части архитектуры. Работа SwitchHead предлагает применять MoE к проекционным слоям, которые формируют матрицы Q, K и V для операции внимания. Другие работы рассматривают условное выполнение на уровне самих голов внимания.

Почему sparse MoE экономит вычисления​


Ключевое преимущество sparse MoE — более высокая flop-эффективность на параметр. Модель содержит больше весов и, следовательно, большую ёмкость, но на каждый токен в forward pass активируется лишь часть из них.

Конкретный пример — Mixtral 8x7B. Модель содержит 32 трансформерных блока, в каждом из которых MLP заменён на MoE-блок с восемью экспертами. Для каждого токена активируются только два эксперта из восьми. В результате:

  • Общее число параметров модели — около 47 миллиардов.
  • Активных параметров на один токен — примерно 12,9 миллиарда...
Qwen

Что такое function calling и зачем он нужен​


Function calling (вызов функций) — это механизм, при котором LLM не просто генерирует текст, а формирует структурированный запрос на выполнение внешнего действия: вызов API, запрос к базе данных, отправку письма, вычисление. Впервые эта возможность появилась в GPT-4 и затем была воспроизведена в других моделях.

Ключевое отличие от «классических» агентных подходов: способность вызывать функции приобретается моделью в процессе обучения (дообучения), а не только через промпт-инжиниринг. Модель не угадывает формат инструмента из контекста — она обучена генерировать вызов в определённом формате, который рантайм может распарсить и исполнить.

Цикл рассуждение–действие–наблюдение​


Любой агентный цикл строится на трёх шагах:

  1. Рассуждение (Reasoning). Модель анализирует запрос пользователя и определяет, какое действие нужно выполнить.
  2. Действие (Action). Модель генерирует структурированный вызов: имя функции и аргументы в формате JSON. Генерация останавливается.
  3. Наблюдение (Observation). Внешний код выполняет вызов и возвращает результат модели. Модель продолжает генерацию с учётом полученного результата.

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

Роли сообщений в диалоге с function calling​


В обычном чате чередуются роли user и assistant. Function calling добавляет новые роли:

РольНазначение
userЗапрос пользователя
assistantОтвет модели или запрос на вызов функции
toolРезультат выполнения инструмента

Пример диалога (формат, близкий к Mistral API):

JSON:
[
  {
    "role": "user",
    "content": "Каков статус моей транзакции T1001?"
  },
  {
    "role": "assistant",
    "content": "",
    "function_call": {
      "name": "retrieve_payment_status",
      "arguments": "{\"transaction_id\": \"T1001\"}"
    }
  },
  {
    "role": "tool"...
zer0coder
1790238610990.png


Локальные LLM часто содержат достаточно агрессивный safety/alignment слой: модель знает ответ, но вместо него начинает писать что-то вроде:

«Я не могу помочь с этим запросом...»

или:

«Я не могу предоставить такую информацию...»

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

Один из способов изменить такое поведение — abliteration. Для его автоматизации существует утилита Heretic (GitHub - p-e-w/heretic: Fully automatic censorship removal for language models).

В этой статье разберём:

  • что именно делает Heretic;
  • какое железо потребуется;
  • какой формат модели нужен;
  • как установить Heretic;
  • как обработать Qwen3;
  • что делать при нехватке VRAM;
  • как выбрать результат;
  • как дополнительно адаптировать обработку под русский язык;
  • как проверить, что модель действительно стала лучше, а не просто перестала писать слово «не могу»;
  • как затем сделать GGUF для Ollama или LM Studio.

---

# Что такое Heretic

Heretic — инструмент для автоматической модификации поведения transformer-моделей.

В отличие от обычного fine-tuning, LoRA или повторного обучения модели, Heretic использует метод directional ablation, также называемый abliteration.

В сильно упрощённом виде идея выглядит так.

Берётся два набора запросов:

Код:
good prompts

то есть обычные запросы, на которые модель отвечает нормально, и:

Код:
bad prompts

то есть запросы, на которых проявляется интересующее нас поведение — в данном случае отказ.

Heretic прогоняет эти запросы через модель и анализирует внутренние активации transformer-слоёв.

На их основе определяется направление в пространстве активаций, коррелирующее с отказами.

Условно...
Qwen

Прямой ответ: что такое галлюцинация и почему она возникает​


Галлюцинация LLM — это генерация текста, который выглядит правдоподобно, но содержит фактические ошибки: несуществующие ссылки, выдуманные API, искажённые данные или события, которых не было. Модель не «лжёт» намеренно. Она предсказывает наиболее вероятную последовательность токенов, и если в обучающих данных не было точного ответа, заполняет пробел статистически правдоподобным, но неверным продолжением.

Полностью устранить галлюцинации невозможно — это следствие самой архитектуры autoregressive language models. Но долю ошибок можно существенно снизить комбинацией методов: retrieval-augmented generation, structured output, настройка параметров декодирования и пост-валидация.

Механизмы галлюцинаций на разных уровнях​


Обучение: сжатие, конфликты и временной срез​


LLM не хранит факты в виде записей базы данных. Знания «впечатаны» в веса модели через предсказание следующего токена на огромном корпусе текстов. Это создаёт несколько системных проблем:

  • Конфликт источников. Если в обучающих данных одно утверждение встречается чаще другого (даже если второе верное), модель склонна воспроизводить более частотный вариант. Частотность в корпусе не равна истинности.
  • Разреженность знаний. Для узкоспециальных тем — редкие CVE, внутренние API, локальные нормативные акты — модель видела мало примеров и вынуждена интерполировать. Интерполяция между далёкими точками часто даёт бессмысленный результат.
  • Временной срез. Обучение завершается на определённой дате. Всё, что произошло после, модели неизвестно, но она может генерировать правдоподобные, но вымышленные события, «заполняя» пробел после cutoff.
  • Сжатие с потерями. Модель с конечным числом параметров не способна точно запомнить весь корпус. Она хранит сжатое представление, и при извлечении редких или детальных фактов точность падает.

Декодирование: как параметры сэмплирования влияют на...​

zer0coder
1789972380915.png


Pirate Face — наконец-то свой Pirate Bay для нейросетей

Модели синхронизируются с HuggingFace, превращаются в торрент с проверенной контрольной суммой и хранятся по принципу peer-to-peer.
На фоне покупки компании Хуангом идея вполне здравая.

Это на случай если решат всё позапретить.)
Qwen

Что такое prompt engineering и почему он вообще нужен​


Большая языковая модель не «понимает» задачу в человеческом смысле. Она предсказывает следующий токен на основе всего, что было подано на вход. Качество ответа напрямую зависит от того, как сформулирован запрос, в каком порядке подана информация и какие ограничения заданы. Prompt engineering — это набор приёмов, которые позволяют управлять поведением модели без изменения её весов.

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

Системный промпт: роль, формат, ограничения​


Системный промпт (system prompt) — это инструкция, которая подаётся модели до начала диалога. В большинстве API она передаётся отдельным полем с ролью system и не видна конечному пользователю напрямую, но влияет на каждый последующий ответ.

Что стоит включать в системный промпт​


  • Роль и экспертиза. Указание, кем модель должна себя считать: «Ты — технический редактор», «Ты — senior DevOps-инженер». Это задаёт регистр, глубину и терминологию.
  • Формат ответа. Явное указание: «Отвечай в формате JSON», «Используй Markdown-таблицы», «Не более трёх абзацев».
  • Ограничения. Чего делать нельзя: «Не выдумывай источники», «Не давай медицинских рекомендаций», «Если не знаешь — скажи об этом».
  • Стиль и тон. «Пиши кратко», «Избегай канцелярита», «Обращайся на ты».

Типичные ошибки в системных промптах​


ОшибкаПочему вредитКак исправить
Слишком длинный промпт с противоречиямиМодель усредняет конфликтующие инструкцииСократить до ключевых правил, убрать дубли
Негативные формулировки без позитивной альтернативы«Не будь многословным» не говорит, каким бытьЗаменить на «Отвечай в 2–3 предложениях»
Инструкции, дублирующие пользовательский запросМодель может запутаться в...
Qwen

Почему генерация токенов — узкое место инференса​


Автодополнение в больших языковых моделях работает последовательно: каждый новый токен зависит от всех предыдущих. На этапе декодирования модель обрабатывает по одному токену за шаг, и вычислительная мощность GPU используется лишь на малую долю — основная задержка уходит на чтение весов из памяти, а не на арифметику. Это делает генерацию memory-bound задачей.

Квантование снижает объём весов и ускоряет чтение, но не меняет саму последовательную природу декодирования. Увеличение батча помогает утилизации, но растёт задержка для отдельного запроса. Speculative decoding предлагает другой подход: выполнять несколько шагов декодирования за один проход через целевую модель.

Основная идея: черновик и верификация​


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

Алгоритм на каждом шаге:

  1. Черновая модель (draft model) генерирует K токенов автодополнением. Это маленькая модель с тем же токенизатором, работающая значительно быстрее целевой.
  2. Целевая модель (target model) выполняет один прямой проход по всем K черновым токенам параллельно — как если бы это был промпт.
  3. Верификация: для каждой позиции сравнивается распределение вероятностей целевой модели с распределением черновой. Токены принимаются или отклоняются по правилу, которое гарантирует, что итоговое распределение в точности совпадает с распределением целевой модели при обычном автодополнении.
  4. Принятые токены добавляются в вывод. На первой позиции, где токен отклонён, целевая модель сэмплирует корректный токен из скорректированного распределения.

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

Математика...​

Новые сообщения на форуме

Статистика форума

Темы
914
Сообщения
1 074
Пользователи
69
Новый пользователь
theprof
Назад
Верх Низ