# Урок 2: Как устроены LLM изнутри (нейроны, параметры, обучение)

> [HTML-версия](https://learnvibecoding.ru/publiclessons/urok-2-kak-ustroeny-llm-iznutri-neyrony-parametry-obuchenie) · [Индекс для LLM](https://learnvibecoding.ru/llms.txt) · [Политика использования материалов](https://learnvibecoding.ru/politika-materialov)
> Материалы защищены. Обучение LLM без согласия запрещено. При разрешённом использовании — обязательна прямая ссылка на страницу-источник.

**Курс:** Основы ИИ обновленный

# Урок 2: Как устроены LLM изнутри (нейроны, параметры, обучение)

## Контекст

**Что будешь уметь:** После урока ты сможешь объяснить:
- Как нейроны соединяются в сеть (архитектура)
- Что такое параметры (веса, коэффициенты)
- Как модель обучается (на примерах)
- Как модель генерирует текст (слово за словом, вероятностно)
- Что такое дообучение и RLHF (почему модель "послушная")

**Главное:** LLM это не магия, это математика. Понимание как это работает поможет тебе:
- Предсказать когда модель ошибится
- Выбрать правильный параметр для нужной задачи
- Понять границы возможного

---

## Блок 0: Когда это нужно знать

### Если ты просто пишешь промпты в ChatGPT...
...то можешь пропустить детали про нейроны. Достаточно знать: "это работает".

### Но если ты:
- Создаёшь продукт где используешь LLM
- Внедряешь AI в компанию и нужно объяснить боссу что это
- Хочешь понять почему модель иногда галлюцинирует
- Выбираешь между Claude, GPT-4, Llama и не знаешь почему один лучше

...то **обязательно** нужна база.

| Ситуация | Почему нужна механика |
|----------|----------------------|
| "Какая максимальная длина текста?" | Нужно понимать как контекст работает |
| "Почему модель придумала факт?" | Нужно знать что не отбирает, а генерирует |
| "Может ли модель считать 7 + 5?" | Нужно знать границы возможностей |
| "Зачем платить за дообучение?" | Нужно знать как это улучшает модель |

---

## Блок 1: Зачем это нужно знать

Представь что ты инженер и кто-то говорит: "Замени видеокарту, будет быстрее".

Если ты не знаешь как видеокарта работает — ты не поймёшь почему именно её, как её установить, не купишь ли ты неправильную?

То же самое с LLM.

Если ты не понимаешь как устроено изнутри — ты не сможешь:
- Выбрать модель под задачу
- Оптимизировать промпт
- Предсказать проблемы
- Объяснить лимиты

**Практический пример:**

Заказчик говорит: "Нам нужно чтобы AI анализировал документы наших клиентов (по 100 страниц каждый)".

Если ты знаешь как работает контекстное окно — ты сразу скажешь: "100 страниц = 50000 токенов, потребуется RAG или меньше документа".

Если ты не знаешь — ты скажешь: "Ладно, попробуем", вышлешь модель на 200-страничный документ, получишь мусор, потом переделываешь.

---

## Блок 2: Мозг и мозг (аналогия)

### Как работает твой мозг

Твой мозг состоит из **нейронов** (специальные клетки) и **синапсов** (связи между ними).

```
Когда ты видишь слово "кот":
  Нейрон 1 получает сигнал "вижу букву К"
    ↓ (через синапс)
  Нейрон 2 получает сигнал, усиливается/ослабляется (синапс важен!)
    ↓
  Нейрон 3 получает комбо сигналов
    ↓
  ...много нейронов и синапсов...
    ↓
  Результат: "это буква К"
  
  Позже:
  "Ко" → это может быть "кот", "коза", "код"
  "Кот" → это животное
```

**Ключевое:** сила синапса (связи) определяет что произойдет.

Если синапс сильный — сигнал пройдёт.
Если синапс слабый — сигнал затухнет.

Когда ты учишься — синапсы укрепляются (опыт = сильные связи).

### Как работает искусственный нейрон

Ученые подумали: "А давайте имитируем это в компьютере?"

И создали **искусственный нейрон** (ничего общего с биологией, просто название похоже).

```
┌─────────────────────────┐
│  Входные сигналы (input)│
│  Слово "кот"            │
│                         │
│  x₁ = 0.8 (это К)       │
│  x₂ = 0.9 (это О)       │
│  x₃ = 0.7 (это Т)       │
└──────┬──────────────────┘
       │
       │ "вес" синапса (параметр)
       ↓
┌─────────────────────────────────────────┐
│  Нейрон: умножить на вес, сложить      │
│  y = x₁*w₁ + x₂*w₂ + x₃*w₃ + смещение  │
│  y = 0.8*0.5 + 0.9*0.6 + 0.7*0.4 + 0.2 │
│  y = 0.4 + 0.54 + 0.28 + 0.2 = 1.42    │
└──────┬──────────────────────────────────┘
       │
       ↓ (активационная функция - нелинейность)
┌─────────────────────────┐
│  Выход: если > 1, то сигнал │
│  если < 1, то молчи         │
│  Выход: 1 (сигнал прошёл!)  │
└─────────────────────────┘
```

**Что такое параметр (вес)?**

Это число (w₁, w₂, w₃ в примере выше).

Каждый нейрон имеет множество параметров.

**Сколько параметров в LLM?**
- Claude 3.5: несколько триллионов
- GPT-4: триллион+
- Llama 70B: 70 миллиардов

Каждый параметр — это число которое определяет поведение модели.

**Могут ли люди изменить параметры?**

Нет. Их слишком много. 1 триллион = 1 000 000 000 000.

Ты не можешь открыть и сказать: "вот параметр 5, его сделаю -0.3".

---

## Блок 3: Нейросеть (много нейронов соединённых вместе)

### Один нейрон может очень мало

```
┌─────────┐     ┌───────┐     ┌──────┐
│ Input:  │ → │ Нейрон │ → │Output│
│ "кот"   │     │  (+весы)│  │ 0/1  │
└─────────┘     └───────┘     └──────┘

Может только: "это кот?" → "да" или "нет"
```

### Много нейронов = нейросеть

```
┌──────────┐
│  "кот"   │
└────┬─────┘
     │
  Слой 1 (10 нейронов)
     │
  ┌──┴──┬────┬────┬────┬────┬────┬────┬────┬────┐
  │     │    │    │    │    │    │    │    │    │
  N1   N2   N3   N4   N5   N6   N7   N8   N9   N10
  │     │    │    │    │    │    │    │    │    │
  └──┬──┴─┬──┴──┬─┴────┴────┴────┴────┴────┴────┘
     │    │    │
  Слой 2 (8 нейронов)
     │
  ┌──┴──┬────┬────┬────┬────┬────┬────┬────┐
  │     │    │    │    │    │    │    │    │
  N1   N2   N3   N4   N5   N6   N7   N8
  │     │    │    │    │    │    │    │    │
  └──┬──┴─┬──┴──┬─┴────┴────┴────┴────┴────┘
     │    │    │
  Слой 3 (4 нейрона)
     │
  ┌──┴──┬────┬────┬──┐
  │     │    │    │  │
  N1   N2   N3   N4
  │     │    │    │
  └──┬──┴─┬──┴──┬─┴──┘
     │
  Выход: "это слово/буква/концепция"
```

**Как это работает:**
1. Вводишь "кот"
2. Слой 1: 10 нейронов анализируют разные признаки (мягкость, форма, звук и т.д.)
3. Слой 2: 8 нейронов комбинируют эти признаки в более сложные (животное? 4-ногое?)
4. Слой 3: 4 нейрона делают финальный выбор
5. Выход: "это кот" (или "это кот с вероятностью 95%")

**Сколько слоёв в LLM?**

- Claude: 100+ слоёв
- GPT-4: 100+ слоёв
- Llama: 80 слоёв

Каждый слой добавляет абстракции:
- Слой 1: видит буквы
- Слой 5: видит слова
- Слой 15: видит идеи
- Слой 80: видит контекст всего текста

---

## Блок 4: Attention механизм (ключевой прорыв Transformer)

Мы разобрали что есть нейроны и слои.

Но есть проблема: **в длинном тексте нейросеть не может запомнить начало** (как мы говорили в уроке 1).

```
"Король поехал в замок. Там он встретил королеву. 
Они разговаривали 3 часа. После этого он..."

Когда модель дошла до "он" — какой "он"? 
На каких словах из начала нужно "сосредоточиться" (attention)?
```

### Механизм Attention (внимание)

Идея: не надо запоминать всё, нужно **сосредотачиваться** на важных словах.

```
Слово "он" → зачем нам важно помнить?
└─ Ищем какие слова связаны с "он"
   └─ "Король" (вероятность 80%)
   └─ "замок" (вероятность 15%)
   └─ "королева" (вероятность 5%)

Выбор: "он" скорее всего про "короля"
```

**Как это работает технически?**

```
Для слова "он":
1. Создаём вектор запроса (query): "ищу кого?"
2. Для каждого слова в тексте создаём вектор ключа (key): "я это слово"
3. Сравниваем: query vs все key-и
4. Получаем веса внимания:
   - "король" ← 0.8
   - "замок" ← 0.15
   - "королева" ← 0.05
5. Берём значения (value) важных слов с их весами
6. Получаем новый вектор "он" с контекстом "короля"
```

**Почему это мощно?**

Потому что модель сама решает **на какие слова обращать внимание** для каждого слова.

```
"Кот ловил рыбу. Он был очень быстрым."

Для "Он":
└─ внимание на "Кот" (не на "рыбу")

Для "быстрым":
└─ внимание на "Кот" и "Он" (они про одного)
```

Это **не** жёсткое правило ("помни слово 5 слов назад"), а **гибкое** ("зависит от контекста").

![Attention mechanism: how LLM understands context and predicts text](https://nhvwqitwebmmswnjylop.supabase.co/storage/v1/object/public/Pictures%20for%20course/AI%20basics%20new%20course/32_Under_Hood_LLM_Text_Context.png)

---

## Блок 5: Как LLM обучается (Pre-training)

![Anatomy of LLM: Pre-training, Fine-tuning, and RLHF phases](https://nhvwqitwebmmswnjylop.supabase.co/storage/v1/object/public/Pictures%20for%20course/AI%20basics%20new%20course/17_Anatomy_LLM_Training_Generation.png)

Мы разобрались как модель устроена (нейроны, слои, attention).

Теперь важный вопрос: **как модель учится?**

### Простой способ обучения: предсказание следующего слова

Представь ребёнка которого учат читать:

```
Взрослый показывает: "Кот сидит на ___"
Ребёнок угадывает: "стуле"
Взрослый: "Правильно!"

Следующее:
Взрослый: "Король ушёл в ___"
Ребёнок: "замок"
Взрослый: "Правильно!"
```

После миллионов примеров — ребёнок учится.

То же самое с моделью:

```
ДАНО текст: "Кот сидит на стуле. Кот чёрный."

ОБУЧЕНИЕ:
Текст 1: "Кот" → предсказываем "сидит" (модель выбирает слово с максимальной вероятностью)
Текст 2: "Кот сидит" → предсказываем "на"
Текст 3: "Кот сидит на" → предсказываем "стуле"
...

Если модель неправильно предсказала:
└─ ошибка = "правильное слово" - "предсказанное слово"
└─ модель сдвигает параметры чтобы ошибка уменьшилась (градиентный спуск)
└─ потом снова пробует
└─ ошибка уменьшается (с каждым примером)
```

**Как часто это повторяется?**

Модель Claude обучена на **триллионах слов**.

Если на каждое слово потратить 1 миллисекунду — это **31 миллион часов**.

Но GPU обрабатывает параллельно, поэтому реально несколько недель.

**Что при этом происходит?**

Параметры (веса в нейронах) постепенно подстраиваются:

```
ДЕНЬ 1: модель случайная, ошибается везде (точность 0%)
ДЕНЬ 7: модель учится базовой грамматике (точность 50%)
ДЕНЬ 14: модель понимает контекст, пишет правильнее (точность 80%)
ДЕНЬ 21: модель почти готова (точность 95%+)
```

### Почему модель становится умной?

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

```
Вес между "король" и "замок": большой (они часто рядом в тексте)
Вес между "король" и "помидор": маленький (редко рядом)

Вес между "красивый" и "женщина": умеренный
Вес между "красивый" и "автомобиль": тоже умеренный (но по разным причинам)
```

После триллионов примеров модель кодирует:
- Грамматику (где идут глаголы, где существительные)
- Смысл (какие слова связаны)
- Логику (если "Маша учится в школе" → скорее всего "она ученица")
- Даже некоторую физику и причинность

**Это называется "emerging capabilities" (появляющиеся способности).**

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

---

## Блок 6: Fine-tuning и RLHF (как сделать модель послушной)

### После Pre-training модель умная, но невежливая

После обучения на всех данных интернета модель может:
- Писать хорошо ✅
- Но может быть грубой ❌
- Может не отказать опасной задаче ❌
- Может галлюцинировать ❌

**Пример:**
```
Пользователь: "Напиши письмо с угрозами"
Модель (raw): "Конечно. Вот письмо 'Если не дашь денег...' "
```

Нужно модель "доучить" чтобы она была честной и безопасной.

### Fine-tuning (доучивание на специальных примерах)

```
ДАНО: примеры хороших ответов
"Q: Напиши письмо?"
"A: Конечно, какое письмо? Личное, деловое?"
(вместо просто написания письма)

ДАНО: примеры отказов
"Q: Помоги мне обмануть людей"
"A: Не могу помочь с обманом. Но я могу помочь..."

ОБУЧЕНИЕ: модель учится на этих примерах (как в pre-training)
└─ параметры подстраиваются
└─ модель теперь отказывает, уточняет, аккуратнее
```

### RLHF (Reinforcement Learning from Human Feedback)

Есть ещё мощнее техника.

Люди оценивают ответы модели:

```
Модель пишет 4 варианта ответа:
  A) "Конечно, вот..." (грубо)
  B) "Конечно, какое письмо вам нужно?" (хорошо)
  C) "Не могу помочь" (неправильно, нужно помочь)
  D) "Извините, не разумею" (тупо)

Люди выбирают: B лучше всего

Модель: "Окей, следующий раз выберу B-подобный ответ"
```

Это происходит миллионы раз, и параметры опять подстраиваются.

**Результат:** модель которая:
- Умна (из pre-training)
- Честна (из дообучение + RLHF)
- Безопасна (из RLHF)
- Отказывает опасным запросам (из RLHF)

---

## Блок 7: Как модель генерирует текст (inference)

Мы разобрали как модель обучается.

Теперь: **как модель создаёт ответ когда ты пишешь промпт?**

### Токен за токеном (авторегрессивность)

Помни что модель обучена предсказывать **следующий токен** (слово/часть слова).

Когда ты пишешь промпт, модель не выбирает готовый ответ.

Модель **генерирует текст слово за словом:**

```
ТЫ ПИШЕШЬ: "Напиши стихотворение про кота"

МОДЕЛЬ ДУМАЕТ:
"Дай посмотрю первое слово в ответе..."
└─ Смотрит все параметры
└─ Вычисляет вероятности каждого слова
└─ Кандидаты: "Вот" (30%), "Конечно" (20%), "Кот" (15%), ...
└─ Выбирает самое вероятное: "Вот"

МОДЕЛЬ: "Вот"

ДАЛЬШЕ:
"Вот __" — что дальше?
└─ Вычисляет: "стихотворение" (40%), "кот" (25%), ...
└─ Выбирает: "стихотворение"

МОДЕЛЬ: "Вот стихотворение"

ДАЛЬШЕ:
"Вот стихотворение __ " — что дальше?
└─ Вычисляет: "про" (60%), "о" (20%), ...
└─ Выбирает: "про"

И так 1000+ раз...
```

**Результат:**
```
Вот стихотворение про кота:
Кот сидит, мурлычет вот,
Усы блестят, а взгляд поёт...
```

### Почему не всегда берётся самое вероятное слово?

Если всегда выбирать максимальное — текст будет скучный.

```
ЕСЛИ ВСЕГДА БЕРЁМ МАКСИМУМ:
"Кот это" → "животное" → "которое" → "живёт" → "в" → "доме"
Результат: скучно и предсказуемо

ЕСЛИ ДОБАВЛЯЕМ СЛУЧАЙНОСТЬ (temperature):
"Кот это" → "животное" (80%) ИЛИ "магия" (10%) ИЛИ "кошмар" (5%)
Выбираем случайно с учётом вероятностей
Результат: творчески, но может быть глупо если температура высокая
```

Это управляется параметром **temperature** (будет подробнее в уроке 5).

![Text prediction process: how LLM generates text token by token](https://nhvwqitwebmmswnjylop.supabase.co/storage/v1/object/public/Pictures%20for%20course/AI%20basics%20new%20course/07_Under_Hood_Text_Prediction.png)

---

## Блок 8: Карта механики LLM

```
┌──────────────────────────────────────────────────────────┐
│                    АРХИТЕКТУРА (устройство)               │
├──────────────────────────────────────────────────────────┤
│                                                            │
│  НЕЙРОН (одна функция):                                   │
│  Input × Weights + Bias → Activation → Output            │
│  (примеры весов = параметры, триллионы штук)            │
│                                                            │
│  СЛОИ (100+ слоёв нейронов):                              │
│  Слой 1: видит буквы                                     │
│  Слой 30: видит слова                                    │
│  Слой 80: видит контекст                                 │
│                                                            │
│  ATTENTION (взаимодействие):                             │
│  Каждое слово смотрит какие слова важны                  │
│  (Query, Key, Value - вычисляют вероятности)             │
│                                                            │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│                    ОБУЧЕНИЕ (learning)                    │
├──────────────────────────────────────────────────────────┤
│                                                            │
│  PRE-TRAINING (триллионы слов из интернета):            │
│  Дано слово → предсказываем следующее                    │
│  Ошибка большая → сдвигаем параметры                     │
│  Повторяем триллион раз → параметры "умнеют"            │
│                                                            │
│  FINE-TUNING (примеры хороших ответов):                  │
│  Дано вопрос → учим отвечать как нужно                   │
│  Параметры подстраиваются для правильного стиля          │
│                                                            │
│  RLHF (люди оценивают ответы):                            │
│  Модель пишет 4 варианта → люди выбирают лучший         │
│  Модель учится на этом → становится "послушнее"          │
│                                                            │
└──────────────────────────────────────────────────────────┘
                           ↓
┌──────────────────────────────────────────────────────────┐
│                   ИСПОЛЬЗОВАНИЕ (inference)               │
├──────────────────────────────────────────────────────────┤
│                                                            │
│  ТЫ ПИШЕШЬ: "Напиши код"                                │
│      ↓                                                    │
│  МОДЕЛЬ ВЫЧИСЛЯЕТ:                                       │
│  - Проходит текст через все слои                         │
│  - Слой 1 видит "буквы"                                 │
│  - Слой 80 видит "контекст"                             │
│  - Вычисляет вероятности каждого слова                   │
│      ↓                                                    │
│  МОДЕЛЬ ГЕНЕРИРУЕТ:                                      │
│  Слово 1: "def" (самое вероятное)                        │
│  Слово 2: "function" (дальше по вероятности)            │
│  Слово 3: "name" (дальше по вероятности)                │
│  ...1000+ слов...                                        │
│      ↓                                                    │
│  РЕЗУЛЬТАТ: полный ответ (код, текст, что угодно)       │
│                                                            │
└──────────────────────────────────────────────────────────┘
```

---

## Блок 9: Основные заблуждения (исправляем)

### ❌ Заблуждение 1: "Модель просто выбирает из сохранённых ответов"

**На самом деле:** Модель **генерирует** новый текст, не извлекает сохранённый.

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

```
Модель видит: "Напиши стихотворение про красивого кота в синем свитере"
├─ Это точный вопрос она видела? Нет.
└─ Но может создать ответ потому что генерирует, не вспоминает.
```

### ❌ Заблуждение 2: "Модель запоминает обучающие данные как человек"

**На самом деле:** Модель кодирует **закономерности**, не факты.

```
Прочитала факт: "Фредди Меркьюри родился в 1946"
└─ Модель НЕ запоминает как человек ("факт номер 5739")
└─ Модель подстраивает параметры чтобы "Фредди + рождение + ~1946" имели вероятностные связи

Поэтому:
- Может ошибиться в дате (1945 или 1947)
- Может не знать очень новые факты (после обучения)
- Может "запомнить" неточное ("родился в 1946-м году в августе" но случайно генерирует "июне")
```

### ❌ Заблуждение 3: "Параметры это факты"

**На самом деле:** Параметры это коэффициенты связей между нейронами.

Они не хранят "Бергер это тип еды".

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

```
Параметры кодируют статистику из обучающих данных, не явные факты.
```

### ❌ Заблуждение 4: "Больше параметров = всегда лучше"

**На самом деле:** Больше параметров обычно лучше, но не всегда.

```
Модель с 7 млрд параметров (Llama 7B): может ошибаться на простой математике
Модель с 70 млрд параметров (Llama 70B): лучше, но может всё ещё ошибаться

Почему не просто сделать 1 триллион параметров?
└─ Стоит дорого обучить
└─ Медленнее работает (каждый токен генерировать дольше)
└─ Может переобучение (заучит мусор из данных)
```

---

## 🌉 Переход: от внутреннего к интерфейсу

✅ **Что мы знаем:**
- Как нейроны и слои кодируют знание
- Как модель обучается на примерах
- Как модель генерирует текст (слово за словом)
- Почему дообучение и RLHF делают модель лучше

✅ **Что мы НЕ знаем:**
- Как считать сколько слов в промпте (токены!)
- Как управлять поведением модели (параметры)
- Какие границы у модели (контекстное окно, knowledge cutoff)
- Как правильно писать промпты

**В следующих уроках (0.3-0.5)** разбираемся с практическими инструментами: токены, контекст, температура.

**Почему это нужно:** Чтобы не просто пользоваться моделью, а управлять ею.

---

## ✅ Финальный чеклист

- [ ] Понимаю что такое нейрон и параметр (вес)
- [ ] Понимаю как слои добавляют абстракции
- [ ] Знаю что такое Attention и почему это важно
- [ ] Понимаю как модель обучается (pre-training, дообучение, RLHF)
- [ ] Понимаю что модель генерирует текст, а не вспоминает
- [ ] Могу объяснить почему модель может ошибаться
- [ ] Знаю что параметры это коэффициенты, не факты
- [ ] Понимаю разницу между обучением и использованием модели

[Все уроки](https://learnvibecoding.ru/publiclessons.md) · HTML: https://learnvibecoding.ru/publiclessons