Заметка Что такое веса нейросети: как модель хранит знания и создаёт ответы

В описании языковых моделей часто встречаются обозначения:

7B
14B
32B
70B

Например:

Qwen 7B
Qwen 32B
Llama 70B

Буква B означает billion — миллиард.

Если указано:

32B

это означает, что нейросеть содержит примерно 32 миллиарда параметров.

Основную часть этих параметров составляют веса модели.

Веса определяют:

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

Веса — это числовая структура, определяющая способности и поведение нейросети.

---

# Что такое веса модели

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

Упрощённо:

Запрос пользователя
        ↓
Преобразование текста в токены
        ↓
Вычисления с использованием весов
        ↓
Вероятности следующих токенов
        ↓
Готовый ответ

Веса можно представить как настройки внутренних связей нейросети.

---

# Простой пример

Представим очень маленькую систему, которая получает три признака:

x1 — признак, связанный с Python
x2 — признак, связанный с ошибкой
x3 — признак, связанный с файлами

Система вычисляет результат:

Результат = x1 × w1 + x2 × w2 + x3 × w3

Здесь:

w1
w2
w3

— веса.

Например:

w1 = 0,8
w2 = -0,3
w3 = 1,2

Большой положительный вес усиливает влияние признака.

Отрицательный вес может уменьшать определённую активацию.

В реальной языковой модели используется не три коэффициента, а миллиарды весов, распределённых по множеству слоёв.

---

# Хранятся ли знания внутри весов

Да, но не в форме обычной базы данных.

Внутри весов нет текстового списка:

Столица Франции = Париж
Python использует def для объявления функции
Конфигурация Nginx находится в nginx.conf

Знания представлены распределёнными числовыми закономерностями.

Условно в весах отражаются:

• правила языка;
• значения слов;
• связи между понятиями;
• грамматика;
• синтаксис программного кода;
• фактические сведения;
• способы решения задач;
• стили ответов;
• шаблоны рассуждений.

Нельзя открыть один параметр и сказать:

Именно этот вес хранит знание о Python.

Одно понятие может одновременно зависеть от тысяч или миллионов параметров.

---

# Как модель получает веса

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

Затем модели дают текст и предлагают предсказать следующий токен.

Пример:

Вход:

Python — это язык ...

Правильное продолжение:

программирования

В начале модель может ошибиться:

Python — это язык автомобиля

Система сравнивает предсказание с правильным ответом и вычисляет ошибку — loss.

После этого веса немного изменяются:

Исходные веса
        ↓
Предсказание модели
        ↓
Вычисление ошибки
        ↓
Обратное распространение ошибки
        ↓
Небольшое изменение весов
        ↓
Обновлённые веса

Этот процесс повторяется огромное количество раз.

Постепенно модель учится:

• продолжать предложения;
• понимать контекст;
• писать программный код;
• отвечать на вопросы;
• переводить текст;
• объяснять ошибки;
• соблюдать инструкции.

---

# Что такое параметр модели

В упрощённом объяснении слова «вес» и «параметр» часто используют как синонимы.

Но технически параметры могут включать:

• матрицы весов;
• bias — смещения;
• embedding-векторы;
• коэффициенты нормализации;
• другие обучаемые числовые значения.

Когда говорят:

Модель имеет 32 миллиарда параметров

это означает общее количество обучаемых числовых значений.

Большинство из них являются элементами крупных матриц весов.

---

# Что означает 7B, 14B и 32B

Примеры:

7B  = около 7 миллиардов параметров
14B = около 14 миллиардов параметров
32B = около 32 миллиардов параметров
70B = около 70 миллиардов параметров

Количество параметров не равно количеству известных фактов.

Нельзя сказать:

Один параметр = один факт

Параметры совместно формируют способности нейросети.

Модель большего размера потенциально может:

• хранить более сложные закономерности;
• лучше понимать контекст;
• качественнее работать с кодом;
• решать более сложные задачи.

Но качество зависит не только от размера.

Также важны:

• архитектура;
• качество обучающих данных;
• способ обучения;
• tokenizer;
• длина контекста;
• дообучение;
• квантование;
• системные инструкции.

---

# Сколько места занимают веса

Размер весов зависит от формата хранения одного параметра.

| Формат | Приблизительный размер параметра | Модель 7B |
|---|---:|---:|
| FP32 | 4 байта | около 28 ГБ |
| FP16 или BF16 | 2 байта | около 14 ГБ |
| INT8 | около 1 байта | около 7 ГБ |
| 4-bit | около 0,5 байта | примерно 3,5–5 ГБ |

Реальный размер может быть больше из-за:

• коэффициентов квантования;
• служебных данных;
• конфигурации модели;
• tokenizer;
• выравнивания;
• дополнительных тензоров.

Для модели на 30 миллиардов параметров:

BF16:

30 млрд × 2 байта ≈ 60 ГБ

8-bit:

30 млрд × 1 байт ≈ 30 ГБ

4-bit:

30 млрд × 0,5 байта ≈ 15 ГБ

Это только приблизительный размер весов.

Для запуска также требуется память для:

• KV-кеша;
• входного контекста;
• промежуточных вычислений;
• CUDA;
• inference-сервера;
• системных процессов.

---

# Где хранятся веса модели

На диске веса обычно находятся в файлах:

model.safetensors

или разбиваются на несколько частей:

model-00001-of-00008.safetensors
model-00002-of-00008.safetensors
model-00003-of-00008.safetensors
...

При запуске модели веса загружаются:

Накопитель
    ↓
Оперативная память
    ↓
Видеопамять GPU

Возможны разные схемы.

## Все веса в VRAM

GPU
└── Все веса модели

Это обычно самый быстрый вариант.

## Часть весов в RAM

GPU
├── Часть весов
└── Активные вычисления

RAM
└── Остальные веса

Такой режим называется offload.

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

## Несколько видеокарт

GPU 1
└── Первые слои

GPU 2
└── Следующие слои

GPU 3
└── Остальная часть модели

В MoE-моделях по разным GPU также могут распределяться отдельные эксперты.

---

# Веса и контекст — это разные вещи

Веса — постоянная обученная часть модели.

Контекст — информация, переданная модели в текущем запросе.

Веса:
то, чему модель научилась во время обучения

Контекст:
текущий запрос, история переписки и переданные документы

Пример:

Веса модели:
модель умеет читать русский язык и анализировать Python

Контекст:
пользователь передал конкретный файл app.py

После завершения запроса содержимое файла app.py само по себе не записывается в веса.

Чтобы изменить веса, необходимо отдельное обучение или дообучение.

---

# Веса и история чата

История разговора обычно передаётся модели как часть контекста.

Схема:

Системная инструкция
        +
Предыдущие сообщения
        +
Новый вопрос
        ↓
Модель с неизменёнными весами
        ↓
Новый ответ

Модель не обучается заново после каждого сообщения.

Она использует уже существующие веса и временный контекст текущего разговора.

---

# Веса и RAG

При использовании RAG веса модели не изменяются.

Документы хранятся отдельно:

PDF
Статьи
Исходный код
Документация
База знаний

После вопроса система находит подходящие фрагменты и передаёт их модели:

Вопрос пользователя
        ↓
Поиск по базе знаний
        ↓
Найденные фрагменты
        ↓
Вопрос + фрагменты
        ↓
Модель с неизменёнными весами
        ↓
Ответ

Например, во внешней документации указано:

Внутренний сервис работает на порту 8085.

RAG добавляет эту информацию в запрос, и модель отвечает:

Внутренний сервис использует порт 8085.

Если завтра порт изменится на 8086, достаточно обновить документ.

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

---

# Веса и LoRA

LoRA добавляет к определённым слоям модели небольшие обучаемые поправки.

Базовые веса обычно остаются замороженными:

Базовая модель
└── Основные веса W

LoRA обучает дополнительные матрицы:

A
B

Условно изменение весов можно представить так:

W' = W + ΔW

где:

ΔW = B × A

При генерации базовая модель и LoRA работают совместно:

Результат слоя =
результат основных весов
+
поправка LoRA

Общая схема:

Запрос
    ↓
Базовая модель + LoRA-адаптер
    ↓
Ответ

Данные не проходят сначала через LoRA, а затем через модель.

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

---

# Что хранится в LoRA-адаптере

LoRA-адаптер не хранит обучающие примеры как обычные текстовые записи.

Например, в датасете мог быть пример:

Пользователь:
Найди утечку памяти в коде.

Ассистент:
Сначала проверь все пути выхода после malloc...

Во время обучения этот пример изменяет числовые параметры адаптера.

После обучения получается файл:

adapter_model.safetensors

В нём находятся числовые матрицы, а не обычный список вопросов и ответов.

LoRA может изменить:

• стиль ответа;
• формат;
• специализацию;
• последовательность анализа;
• предпочтительный способ исправления кода;
• терминологию;
• поведение модели.

---

# Пример использования LoRA

Базовая Qwen3-Coder умеет проверять программный код.

С помощью LoRA можно усилить определённое поведение:

Всегда сначала объяснять ошибку
Делать минимальные изменения
Не изменять публичный API
Добавлять обработку исключений
Использовать определённый стиль кода
Отвечать на русском языке

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

Обучение изменяет числовые веса так, чтобы модель чаще формировала нужные ответы.

---

# Что такое слои модели

Языковая модель состоит из множества последовательных слоёв.

Упрощённо:

Входные токены
      ↓
Embedding
      ↓
Transformer layer 1
      ↓
Transformer layer 2
      ↓
Transformer layer 3
      ↓
...
      ↓
Выходной слой
      ↓
Вероятности следующего токена

Каждый слой получает числовое представление токенов, преобразует его и передаёт дальше.

Внутри слоя находятся:

Attention
├── q_proj
├── k_proj
├── v_proj
└── o_proj

Feed Forward Network
├── gate_proj
├── up_proj
└── down_proj

У каждой проекции есть собственные матрицы весов.

---

# Что такое q_proj, k_proj, v_proj и o_proj

Механизм attention использует несколько преобразований.

## q_proj

Создаёт представление запроса — Query.

Условно:

Что текущий токен ищет?

## k_proj

Создаёт ключ — Key.

Условно:

Какую информацию содержит другой токен?

## v_proj

Создаёт значение — Value.

Условно:

Какую информацию нужно передать дальше?

## o_proj

Объединяет результат attention и передаёт его следующей части слоя.

Именно к этим модулям часто подключается LoRA:

target_modules=[
    "q_proj",
    "k_proj",
    "v_proj",
    "o_proj",
]

---

# Что такое embedding-веса

Перед обработкой текст разбивается на токены.

Пример:

"Напиши функцию на Python"
        ↓
[токен 1845, токен 9182, токен 321, токен 7054]

Каждому токену соответствует числовой вектор.

Условный пример:

"Python" →

[0,14, -0,83, 0,42, 0,09, ...]

Таблица таких векторов называется embedding-матрицей.

Она также является частью весов модели.

Embedding помогает представить токены в многомерном пространстве, где могут отражаться смысловые связи.

Например, представления:

Python
Java
C++
программирование
функция
компилятор

будут иметь определённые взаимосвязи.

---

# Как веса используются при генерации ответа

Допустим, пользователь пишет:

Напиши функцию сложения на Python.

Модель выполняет следующие действия:

1. Разбивает запрос на токены.
2. Преобразует токены в embedding-векторы.
3. Пропускает их через слои трансформера.
4. Использует матрицы весов в каждом слое.
5. Вычисляет вероятности следующего токена.

Условный результат:

"def"      — 61%
"Вот"      — 14%
"Функция"  — 9%
"class"    — 3%
остальное  — 13%

Модель выбирает один токен:

def

Затем снова выполняет вычисления:

def add

Далее:

def add(

Потом:

def add(a: int, b: int) -> int:

Процесс продолжается до окончания ответа.

Веса определяют вероятности токенов на каждом шаге.

---

# Что такое выходные веса

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

Например, словарь модели содержит:

150 000 токенов

Выходной слой рассчитывает значение для каждого возможного токена:

def
return
class
Python
функция
...

После применения нормализации получаются вероятности следующего токена.

---

# Температура не изменяет веса

Параметры генерации:

• temperature;
• top_p;
• top_k;
• repetition_penalty;

не изменяют веса и знания модели.

Они влияют только на выбор токена из рассчитанного распределения вероятностей.

Веса модели
└── Определяют вероятности токенов

Temperature
└── Регулирует случайность выбора

При низкой температуре модель чаще выбирает наиболее вероятные токены.

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

---

# Что такое квантование весов

Квантование уменьшает точность хранения параметров.

Например, исходный вес:

0,13742891

может быть представлен более грубо:

0,14

Упрощённо:

FP32  → 32 бита на параметр
BF16  → 16 бит
FP16  → 16 бит
INT8  → 8 бит
INT4  → 4 бита

Преимущества квантования:

• меньше расход VRAM;
• меньше размер файлов;
• быстрее загрузка;
• возможность запустить более крупную модель.

Недостатки:

• возможная потеря качества;
• ошибки округления;
• некоторые слои чувствительны к квантованию;
• обучение становится сложнее;
• требуется деквантование при вычислениях.

---

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

Модель содержит 32 миллиарда параметров.

## BF16

32 млрд × 2 байта ≈ 64 ГБ

## INT8

32 млрд × 1 байт ≈ 32 ГБ

## 4-bit

32 млрд × 0,5 байта ≈ 16 ГБ

На практике 4-битная модель может занимать больше из-за дополнительных коэффициентов и метаданных.

Также необходимо оставить память для KV-кеша и вычислений.

---

# Как QLoRA использует веса

При QLoRA:

Базовые веса модели
└── Загружены в 4-битном виде

LoRA-адаптер
└── Обучается в более высокой точности

Схема:

4-битная базовая модель
        +
Обучаемый LoRA-адаптер
        ↓
Дообученная система

QLoRA позволяет дообучать крупные модели с меньшим количеством видеопамяти.

При этом изменяются не все базовые веса, а только параметры адаптера.

---

# Что такое замороженные веса

При LoRA основные веса модели обычно замораживаются.

Это означает:

Градиенты для базовых весов не рассчитываются
Базовые веса не обновляются
Обучается только адаптер

Преимущества:

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

Пример:

Qwen3-Coder
├── LoRA для Python
├── LoRA для C
├── LoRA для анализа логов
└── LoRA для code review

---

# Можно ли объединить LoRA с основными весами

Да.

После обучения можно выполнить операцию:

Базовые веса
        +
LoRA-поправки
        ↓
Объединённые веса модели

Этот процесс часто называется:

merge

После объединения модель можно запускать без отдельного файла адаптера.

Преимущества:

• проще развёртывание;
• не нужен отдельный LoRA-механизм;
• модель можно дополнительно квантовать.

Недостатки:

• создаётся полная копия модели;
• требуется много оперативной памяти;
• теряется удобство быстрого переключения адаптеров.

---

# Почему нельзя открыть веса и прочитать знания

Файл весов содержит огромные числовые массивы.

Условно:

model.layers.0.self_attn.q_proj.weight
model.layers.0.self_attn.k_proj.weight
model.layers.0.self_attn.v_proj.weight
model.layers.0.mlp.up_proj.weight
...

Внутри находятся значения:

0.0042
-0.0187
0.0921
-0.0014
...

Они не являются текстом.

Невозможно просто открыть файл и найти строку:

Столица Франции — Париж.

Знание возникает из совместной работы множества матриц и слоёв.

Веса похожи не на книгу с готовыми ответами, а на устройство искусственного мозга, сформированное в процессе обучения.

---

# Можно ли извлечь обучающие данные из весов

Модель обычно не хранит полный датасет как обычный архив.

Но в некоторых случаях она может запомнить:

• часто повторяющиеся фрагменты;
• уникальные строки;
• персональные данные;
• секреты;
• длинные участки кода;
• редкие последовательности.

Особенно это возможно, если данные:

• многократно повторялись;
• были уникальными;
• модель была переобучена;
• датасет был небольшим;
• пример встречался много раз.

Поэтому в обучающие данные нельзя добавлять:

• пароли;
• API-ключи;
• приватные ключи;
• seed-фразы;
• персональные данные;
• конфиденциальные документы.

---

# Можно ли изменить один факт внутри весов

Это сложно.

Допустим, модель считает:

Внутренний сервис работает на порту 8085.

Но порт изменился:

8086

Дообучение одному новому факту не гарантирует, что модель всегда будет отвечать правильно.

Могут возникнуть проблемы:

• конфликт старого и нового знания;
• неправильный ответ в другом контексте;
• необходимость множества примеров;
• ухудшение связанных ответов;
• забывание других навыков.

Для изменяемых сведений лучше использовать RAG.

Изменяемые факты и документация
→ RAG

Стиль и поведение
→ LoRA

Базовые навыки и знания
→ основные веса модели

---

# Чем веса отличаются от RAG, LoRA и контекста

| Компонент | Что содержит | Когда используется |
|---|---|---|
| Основные веса | Базовые способности и закономерности | При каждом токене |
| LoRA | Обученные поправки к поведению | При подключённом адаптере |
| RAG | Найденные внешние документы | Перед конкретным запросом |
| Контекст | Текущий разговор и материалы | В текущей генерации |
| Системный prompt | Правила поведения модели | В текущем запросе |
| KV-кеш | Промежуточные данные контекста | Во время генерации |

---

# Что такое KV-кеш и почему это не веса

KV-кеш хранит промежуточные представления уже обработанных токенов текущего контекста.

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

Веса
└── Постоянны и загружаются при запуске модели

KV-кеш
└── Создаётся для текущего запроса или разговора

Чем длиннее контекст, тем больше KV-кеш.

Поэтому модель может помещаться в VRAM по размеру весов, но завершаться с ошибкой памяти при очень длинном контексте.

---

# Веса плотной и MoE-модели

В плотной, или dense-модели, при обработке токена используются практически все основные блоки каждого слоя.

Dense-модель
└── Все параметры слоя участвуют в вычислении

В MoE-модели присутствует множество экспертов, но для конкретного токена активируется только часть.

MoE-модель
├── Все эксперты хранятся в памяти
└── Для токена выбирается несколько экспертов

Например:

Общее количество параметров: 30 млрд
Активных параметров:          3 млрд

Это означает:

• хранить необходимо веса всей 30-миллиардной модели;
• при обработке одного токена вычисления использует только часть параметров.

Поэтому объём памяти определяется общими параметрами, а вычислительная нагрузка — активными.

---

# Почему больше весов не всегда означает лучшую модель

Большая модель может быть хуже маленькой, если:

• использовались плохие обучающие данные;
• архитектура неэффективна;
• дообучение выполнено неправильно;
• модель сильно квантована;
• задача не соответствует её специализации;
• системная инструкция составлена плохо.

Например, специализированная модель на 14 млрд параметров может писать код лучше универсальной модели на 32 млрд.

Оценивать необходимо по реальным тестам.

---

# Веса и лицензия модели

Файлы весов могут распространяться отдельно от программного кода.

Для использования модели необходимо проверить:

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

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

---

# Аналогия с человеком

Систему можно представить следующим образом:

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

LoRA
= дополнительный профессиональный курс

RAG
= справочник или база документов

Контекст
= текущий разговор

Системный prompt
= инструкция, как нужно вести себя сейчас

KV-кеш
= кратковременная рабочая память разговора

Например:

Человек уже умеет программировать
        ↓
Проходит курс по безопасной разработке
        ↓
Перед ответом читает документацию проекта
        ↓
Получает конкретную задачу
        ↓
Формирует ответ

В этой аналогии:

Умение программировать → основные веса
Курс безопасности      → LoRA
Документация проекта   → RAG
Конкретная задача      → контекст

---

# Часто задаваемые вопросы

## Веса — это файлы модели?

Да.

Файлы .safetensors обычно содержат числовые тензоры весов.

Но для запуска также нужны:

• конфигурация;
• tokenizer;
• код архитектуры;
• inference-библиотеки.

## Хранится ли история разговоров в весах?

Нет, не автоматически.

История обычно передаётся как контекст.

Чтобы она попала в веса, потребовалось бы отдельное обучение на этих данных.

## Запоминает ли модель мой вопрос после ответа?

Само вычисление ответа не изменяет локальные веса.

Вопрос может сохраняться приложением или AI-сервисом отдельно, но это уже вопрос хранения данных конкретным сервисом, а не работы весов.

## Меняет ли RAG веса?

Нет.

RAG добавляет найденный текст в контекст запроса.

## Меняет ли LoRA основные веса?

Обычно основные веса заморожены.

LoRA обучает отдельные дополнительные параметры.

После этого адаптер можно объединить с базовой моделью.

## Является ли LoRA частью модели?

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

Но физически адаптер может храниться отдельным файлом.

## Может ли одна модель использовать несколько LoRA?

Да.

Можно хранить несколько адаптеров для разных задач и переключать их.

Одновременное объединение нескольких адаптеров требует проверки совместимости и качества.

## Почему файлы модели весят меньше расчётного значения?

Возможные причины:

• модель квантована;
• используется 8-битный или 4-битный формат;
• некоторые веса разделяются;
• в названии указано округлённое количество параметров;
• используется MoE;
• часть параметров не входит в конкретный checkpoint.

## Почему модель занимает в VRAM больше, чем файл на диске?

Дополнительную память используют:

• KV-кеш;
• временные тензоры;
• CUDA;
• служебные буферы;
• деквантованные значения;
• inference-сервер;
• загруженный tokenizer;
• batching.

## Можно ли редактировать веса вручную?

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

Для управляемого изменения используют:

• fine-tuning;
• LoRA;
• QLoRA;
• continued pretraining;
• model merging;
• специальные методы редактирования знаний.

---

# Итоги

Веса модели — это миллиарды числовых параметров, сформированных в процессе обучения.

Они определяют:

• понимание языка;
• работу с программным кодом;
• связи между понятиями;
• стиль ответов;
• вероятности токенов;
• общие способности модели.

Основная схема:

Обучающие данные
        ↓
Предсказание токенов
        ↓
Вычисление ошибки
        ↓
Обновление весов
        ↓
Обученная модель

При обычном использовании:

Запрос пользователя
        ↓
Токенизация
        ↓
Слои с обученными весами
        ↓
Вероятности следующих токенов
        ↓
Ответ

Главные различия:

Основные веса
→ Базовые знания и способности модели

LoRA
→ Дополнительные обученные поправки к весам

RAG
→ Внешние документы, добавляемые в контекст

Контекст
→ Информация текущего разговора

KV-кеш
→ Временная память обработанного контекста

Главный вывод:

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

````