Что значит «научиться»: правило против примера

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

Два способа решить одну задачу

Возьмём задачу, которую вы решали руками сотни раз: по светодиодной лампе определить, что в ней сгорело.

Когда правила выигрывают

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

Три вида обучения

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

Главный вопрос: что значит «научилась»

Здесь прячется самое важное недопонимание. Модель не «поняла» задачу. Она нашла функцию, которая на обучающих примерах даёт правильные ответы. Это совсем не одно и то же.

Классический пример провала

История, которую рассказывают на каждом курсе, потому что она идеально показывает проблему. Сеть учили отличать волков от собак. Точность на тестах — отличная. Потом посмотрели, на что сеть на самом деле смотрит.

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

Что такое модель физически

Слово «модель» звучит абстрактно, хотя вещь предельно конкретная. Модель — это файл с числами. Те самые 5, 14 или 70 миллиардов параметров — это миллиарды чисел, записанных подряд.

• Архитектура — как эти числа связаны между собой и в каком порядке применяются. Обычно сотня строк кода.
• Веса — сами числа. Гигабайты. Это и есть всё, что модель «знает».
• Обучение — процесс подбора этих чисел. Дорого, долго, один раз.
• Работа — прогон данных через готовые числа. Дёшево, быстро, миллионы раз.

Что дальше

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

Нейрон: три операции, из которых состоит всё

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

Один нейрон целиком

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

1. Умножает каждый входной сигнал на свой коэффициент — вес.
2. Складывает всё это, добавляя постоянную поправку — смещение.
3. Пропускает сумму через нелинейную функцию — активацию.

вход:      x₁     x₂     x₃
вес:       w₁     w₂     w₃

сумма  =  x₁·w₁ + x₂·w₂ + x₃·w₃ + b
                                  ↑ смещение

выход  =  f(сумма)
              ↑ активация

Всё. Больше внутри нейрона ничего нет.

Знакомая аналогия

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

Конкретный пример

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

напряжение в норме?    x₁ = 1     w₁ = +2.0    → сильный довод «исправен»
пульсации высокие?     x₂ = 1     w₂ = -3.0    → сильный довод «неисправен»
перегрев?              x₃ = 0     w₃ = -2.5    → не сработал

сумма = 1·2.0 + 1·(-3.0) + 0·(-2.5) + 0.5  =  -0.5

выход: отрицательно → «неисправен»

Обратите внимание: знак веса — это направление довода, а модуль — его сила. Пульсации весят −3.0, то есть перевешивают нормальное напряжение с его +2.0. Именно такие соотношения и подбираются при обучении.

Зачем нужна нелинейность

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

Практический смысл: линейная модель может провести только прямую границу. Задачи вроде «исправно, если напряжение в норме и пульсации низкие, но при перегреве всё равно нет» прямой не разделяются. Нелинейность даёт возможность гнуть границу.

Какие бывают активации

Softmax — стоит понять отдельно

Она вам ещё встретится и во внимании (глава 08), и при генерации текста. Задача: превратить произвольные числа в вероятности.

сеть выдала оценки:   драйвер 3.2   кристалл 1.1   конденсатор 0.4

после softmax:        драйвер 0.79  кристалл 0.16  конденсатор 0.05
                                    в сумме ровно 1.0

Обратите внимание на важное свойство: softmax усиливает разрыв. Разница между 3.2 и 1.1 была троекратной, стала почти пятикратной. Это потому, что внутри стоит возведение в степень. Свойство пригодится, когда будем говорить о температуре при генерации текста.

Сколько нейронов нужно

«7B» из названия модели — это и есть количество весов и смещений, сложенных вместе. Семь миллиардов чисел, каждое из которых участвует в описанных трёх операциях.

Проверьте, что поняли

• Я могу назвать три операции внутри нейрона
• Я понимаю, что знак веса — направление довода, а модуль — его сила
• Я могу объяснить, почему без нелинейности глубина бесполезна
• Я знаю, что делает softmax и почему усиливает разрыв
• Я понимаю, что «7B» — это количество подбираемых чисел

Что дальше

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

Сеть: слои, веса и откуда берутся миллиарды

Один нейрон проводит прямую. Слой нейронов ищет признаки. Стопка слоёв строит признаки из признаков — и отсюда берётся всё остальное.

Слой

Слой — это просто несколько нейронов, которые смотрят на одни и те же входы, но с разными весами. Каждый ищет своё.

              ┌─ нейрон 1 → «напряжение просело»
вход x₁ ──┬───┼─ нейрон 2 → «пульсации выше нормы»
вход x₂ ──┼───┼─ нейрон 3 → «греется»
вход x₃ ──┴───└─ нейрон 4 → «всё в допуске»

каждый видит все входы, но у каждого свои веса

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

Глубина: признаки из признаков

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

Откуда миллиарды

Считается просто. Между соседними слоями каждый нейрон связан с каждым, то есть число весов — это произведение размеров слоёв.

слой из 1000 нейронов → слой из 1000 нейронов
= 1 000 × 1 000 = 1 000 000 весов   (один переход!)

языковая модель: ширина слоя ~4096, слоёв ~32, плюс внимание

итог: миллиарды. Отсюда «7B», «14B», «70B».

Разные формы связей

«Каждый с каждым» — не единственный вариант, и для разных данных придуманы разные схемы.

Две детали, без которых глубокие сети не обучались

Остаточные связи

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

Обходной путь даёт ошибке «короткую дорогу» назад. Именно это позволило перейти от десятков слоёв к сотням, и это есть в каждом современном трансформере.

Нормализация

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

Чем занята память при работе

Проверьте, что поняли

• Я понимаю, что слой — это нейроны с разными весами на одних входах
• Я могу объяснить, зачем нужна глубина
• Я знаю, откуда берутся миллиарды параметров
• Я понимаю идею разделения весов в свёртке
• Я знаю, зачем остаточные связи и нормализация
• Я понимаю, почему обучение требует в разы больше памяти

Что дальше

Самое интересное: как именно подбираются эти миллиарды чисел. Оказывается, довольно простым приёмом.

Как сеть находит веса: ошибка, градиент, шаг

Никакого волшебства: измерить ошибку, понять, в какую сторону её уменьшить, сделать маленький шаг. Повторить миллион раз. Это весь алгоритм.

Три шага, которые повторяются

1. Прогон вперёд. Подать пример на вход, получить ответ сети.
2. Ошибка. Сравнить с правильным ответом, получить число — насколько промахнулись.
3. Шаг назад. Понять, как надо изменить каждый вес, чтобы ошибка стала чуть меньше. Изменить. Чуть-чуть.

Всё. Дальше — следующий пример, и так миллионы раз.

Аналогия, которая объясняет градиент

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

Ошибка — это число

Чтобы улучшать, надо мерить. Функция потерь превращает «сеть ошиблась» в конкретное число, которое можно уменьшать.

Обратное распространение

Главная техническая идея всего глубокого обучения, и по сути — школьное правило производной сложной функции.

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

вперёд:   вход → слой1 → слой2 → слой3 → ответ → ошибка

назад:    ошибка → вклад слоя3 → вклад слоя2 → вклад слоя1
          и для каждого веса: «подвинуть сюда, на столько»

Скорость обучения — самый важный параметр

Насколько большой шаг делать в найденном направлении.

На практике шаг делают переменным: сначала побольше, чтобы быстро прийти в нужную область, потом всё меньше, для тонкой настройки. Это расписание скорости обучения, и оно вам встретится в главе 13, когда будете обучать LoRA.

Почему по одному примеру не учат

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

Почему обучение получается вообще

Это до сих пор не до конца объяснено теоретически, и честно это сказать стоит. Поверхность ошибки в пространстве миллиардов параметров чудовищно сложна, и нет гарантии, что простой спуск придёт куда-то хорошее.

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

Сколько это стоит

Проверьте, что поняли

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

Что дальше

Сеть научилась давать правильные ответы на обучающих примерах. Это ещё ничего не значит — и следующая глава объясняет почему.

Переобучение: выучить, ничего не поняв

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

Зубрёжка против понимания

Студент выучил наизусть ответы к тридцати задачам из методички. На экзамене по этим задачам — отлично. Дали тридцать первую, немного другую — ноль. Он не решал задачи, он запоминал пары «условие — ответ».

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

Обязательное разделение данных

Как поймать по графику

ошибка
  │
  │╲                             ← обучающая: падает всегда
  │ ╲___________________________
  │╲
  │ ╲______                      ← проверочная: сначала падает,
  │        ‾‾‾───────────           потом разворачивается вверх
  │              ↑
  │         здесь надо было остановиться
  └──────────────────────────────► шаги обучения

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

Шесть способов лечения

Обратная беда: недообучение

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

Почему это важно знать, даже не обучая модели

Вы будете дообучать LoRA в главах 13 и 17 — там это встретится напрямую. Но есть и более общий смысл.

Практический вывод: когда модель уверенно ошибается на чём-то простом, это обычно не «глупость», а признак, который она выучила вместо настоящего. И ваш способ это обойти — переформулировать задачу так, чтобы ложный признак не срабатывал.

Признаки переобучения в вашей LoRA

Пригодится, когда дойдёте до глав 13 и 17.

• Модель дословно воспроизводит куски обучающих данных
• Для изображений: генерирует почти копии обучающих картинок
• Работает отлично на знакомых формулировках и рассыпается на чуть иных
• Потеряла общие способности, которые были до дообучения
• Ошибка на проверочных данных пошла вверх, а вы продолжали учить

Проверьте, что поняли

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

Что дальше

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

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

Сеть умеет только умножать числа. Значит, слово, картинку и звук надо сначала превратить в числа — причём так, чтобы близкие по смыслу оказались рядом. Это и есть главный трюк.

Задача

Нейрон умножает и складывает. Слово «конденсатор» умножать нельзя. Значит нужен способ сопоставить каждому понятию набор чисел.

Наивный вариант: пронумеровать все слова. Конденсатор — 1, резистор — 2, кошка — 3. Работать не будет: из такой нумерации следует, что конденсатор ближе к резистору, чем к кошке, только случайно, а ещё что «кошка минус резистор равно конденсатор». Числа появились, смысла в них нет.

Решение: много чисел вместо одного

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

                   электронный  пассивный  накопитель  живой
конденсатор            0.9         0.9        0.9       0.0
резистор               0.9         0.9        0.1       0.0
аккумулятор            0.7         0.3        0.9       0.0
кошка                  0.0         0.0        0.0       1.0

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

Что значит «рядом»

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

Знаменитая арифметика над смыслом

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

король − мужчина + женщина  ≈  королева
Париж  − Франция  + Грузия  ≈  Тбилиси
идти   − настоящее+ прошлое ≈  шёл

Направление «мужское → женское» оказалось одним и тем же направлением в пространстве для множества пар слов. Модель никто этому не учил — оно возникло само, как экономный способ описать язык.

Один вектор на слово — недостаточно

Слово «ключ» — это гаечный ключ, ключ от двери, ключ шифрования или родник. Один вектор не может отражать все смыслы сразу.

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

Векторы есть у всего

Что это даёт вам практически

• Поиск по смыслу в ваших книгах: запрос «почему мигает лампа» найдёт главу про пульсации, где слова «мигает» может не быть вообще.
• Автоматическая группировка статей по темам без ручной разметки.
• Похожие материалы на сайте — без правил и тегов.
• Дедупликация: найти тексты, которые про одно и то же, но написаны разными словами.
• Своя память для модели — то самое RAG. Следующая глава.

Проверьте, что поняли

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

Что дальше

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

Эмбеддинги на практике: поиск по своим книгам

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

Что построим

У вас полтора десятка книг в HTML. Задача: спросить «почему лампа мигает после включения» и получить нужные куски текста — даже если слова «мигает» там нет, а есть «пульсации выпрямленного напряжения».

ваши книги → нарезка на куски → эмбеддинг каждого куска → база векторов
                                                                 ↓
              ваш вопрос → эмбеддинг вопроса → поиск ближайших ──┘
                                                                 ↓
                                                        куски текста
                                                                 ↓
                                            (необязательно) языковая модель
                                                                 ↓
                                                             ответ

Шаг 1. Нарезка — от неё зависит всё

Самый недооценённый шаг. Слишком крупные куски — в ответ попадает много лишнего и смысл размывается. Слишком мелкие — теряется контекст, и кусок становится непонятен сам по себе.

Шаг 2. Модель эмбеддингов

Это отдельная модель, не та, что генерирует текст. Её единственная работа — превращать текст в вектор.

ollama pull nomic-embed-text

Шаг 3. Где хранить

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

Шаг 4. Поиск

Считаем косинусную близость вопроса с каждым куском и берём лучшие. Дальше — нюансы, которые отличают работающий поиск от игрушки.

Шаг 5. Ответ языковой модели

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

Ответь на вопрос, используя ТОЛЬКО приведённые ниже фрагменты.
Если в них нет ответа — так и скажи, не придумывай.
После каждого утверждения укажи, из какого фрагмента оно взято.

ФРАГМЕНТЫ:
[1] (Учебник по электрике, гл. 9) ...
[2] (LED, гл. 10) ...

ВОПРОС: почему лампа мигает после включения?

Что пойдёт не так и почему

Как проверить, что получилось хорошо

Заведите два десятка вопросов, на которые вы знаете правильный ответ и знаете, в какой главе он лежит. Прогоняйте их после каждого изменения настроек.

• Составлен список из 20 контрольных вопросов с известными ответами
• Для каждого записано, какая глава должна найтись
• Меряю долю вопросов, где нужный кусок попал в первые 5
• Есть вопросы, ответа на которые в книгах НЕТ — проверяю, что система это признаёт
• Сравниваю настройки по одному и тому же списку, а не по впечатлению

Что дальше

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

Внимание: как сеть решает, на что смотреть

Одна идея, опубликованная в 2017 году, стоит за всеми современными моделями — текстовыми, графическими, звуковыми. Разберём её без формул.

Задача, которую не удавалось решить

Предложение: «Ключ на тринадцать лежал рядом с платой, и он был нужен, чтобы открутить радиатор». Что такое «он»?

Чтобы понять, сеть должна связать «он» с «ключ» через восемь слов. Старые архитектуры читали последовательно, слово за словом, и к концу предложения начало уже размывалось. Чем дальше связь, тем хуже.

Три роли каждого слова

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

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

Как это работает по шагам

1. Берём ЗАПРОС слова «он»

2. Сравниваем его с КЛЮЧОМ каждого слова предложения
   (скалярное произведение — мера совпадения направлений)

   ключ       ████████████  0.82
   плата      ████          0.21
   радиатор   ███           0.15
   лежал      █             0.04
   ...

3. Пропускаем оценки через softmax → веса внимания,
   в сумме дающие единицу

4. Складываем ЗНАЧЕНИЯ всех слов с этими весами

5. Результат: новый вектор «он», в который
   в основном подмешано слово «ключ»

Несколько голов

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

Порядок слов

Обратите внимание на неприятность: механизм смотрит на все слова одинаково, без учёта позиции. «Собака укусила человека» и «человека укусила собака» для него неразличимы.

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

Почему это дало взрывной рост

Цена

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

Проверьте, что поняли

• Я могу объяснить задачу, которую решает внимание
• Я знаю три роли: запрос, ключ, значение — и что каждая означает
• Я понимаю, как получаются веса внимания и зачем там softmax
• Я понимаю, зачем несколько голов
• Я знаю, зачем кодируют позицию
• Я понимаю, почему длинный контекст дорог, и могу это объяснить

Что дальше

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

Трансформер: собираем целиком

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

Один блок

Трансформер — это стопка одинаковых блоков. Внутри блока всего две содержательные части.

вход
 │
 ├──────────────┐
 │              │
 ↓              │
нормализация    │
 ↓              │
ВНИМАНИЕ        │  ← слова смотрят друг на друга
 ↓              │
 ⊕ ←────────────┘  ← остаточная связь
 │
 ├──────────────┐
 │              │
 ↓              │
нормализация    │
 ↓              │
ПОЛНОСВЯЗНЫЙ    │  ← каждое слово обрабатывается отдельно
 ↓              │
 ⊕ ←────────────┘
 │
выход → на вход следующего такого же блока

Интересная деталь: в полносвязной части обычно больше параметров, чем во внимании — её внутренний слой в несколько раз шире. То есть большая часть «знаний» модели физически лежит именно там, а внимание отвечает за то, как эти знания связываются.

Модель целиком

текст
  ↓  разбиение на токены
[1284, 97, 3301, ...]
  ↓  таблица эмбеддингов + кодирование позиции
векторы
  ↓
блок 1
блок 2
  ...
блок 32           ← глубина модели
  ↓
финальная нормализация
  ↓
проекция на словарь → оценка для каждого возможного токена
  ↓  softmax
вероятности → выбор следующего токена

Всё. Ширина вектора и число блоков определяют размер модели: у 7B это примерно 4096 и 32, у моделей покрупнее — больше и того и другого.

Почему модель пишет по одному слову

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

«Паяльник надо»            → «держать»
«Паяльник надо держать»    → «за»
«Паяльник надо держать за» → «ручку»

Маска: почему модель не подглядывает

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

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

Как выбирается токен

На выходе — вероятности всех токенов словаря. Дальше нужно выбрать один, и здесь есть настройки, которые вы видели в интерфейсах.

Разновидности одной конструкции

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

Одна архитектура для всего

Самое удивительное свойство: то же самое работает не только с текстом.

Проверьте, что поняли

• Я знаю две части блока и за что каждая отвечает
• Я понимаю, почему текст генерируется по одному токену
• Я знаю, откуда берётся кэш контекста и почему он ест память
• Я понимаю, зачем нужна маска
• Я знаю, что делает температура, и какую ставить для кода
• Я понимаю, что та же архитектура работает с картинками и звуком

Что дальше

Устройство понятно. Теперь самый интересный вопрос: почему из «угадай следующее слово» получается что-то, похожее на понимание.

Почему предсказание слова даёт разум — и где граница

Задача «угадай следующее слово» выглядит примитивно. Почему её решение даёт модель, которая пишет код и объясняет схемы — и где у этого проходит граница.

Почему это не примитивная задача

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

«Пульсации на выходе драйвера были высокими, поэтому лампа...»
                                                         → «мигала»
   требуется: причинно-следственная связь в электронике

«Гурам починил лампу, потому что он...»
                                                         → «электрик»
   требуется: отслеживание, кто есть кто

«2 + 2 * 3 = ...»
                                                         → «8»
   требуется: порядок операций

«def factorial(n): if n <= 1: return 1; return n *...»
                                                    → «factorial(n-1)»
   требуется: понимание рекурсии

Предсказание как сжатие

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

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

Что возникает само по себе

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

Почему помогает «рассуждай вслух»

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

Когда модель пишет промежуточные шаги, каждый шаг — это новые токены, то есть новые вычисления. Она буквально выделяет себе больше времени на подумать, и предыдущие рассуждения становятся частью контекста для следующих.

Где граница

Теперь честно о том, чего механизм не даёт — и это следует прямо из устройства, а не из недоработок.

«Понимает» или нет

Вопрос, на который нет согласованного ответа, и стоит держать обе позиции в голове.

Проверьте, что поняли

• Я понимаю, почему хорошее предсказание требует понимания
• Я понимаю связь между сжатием и обобщением
• Я знаю, почему «рассуждай по шагам» реально помогает
• Я могу назвать шесть ограничений и объяснить причину каждого
• Я понимаю, что уверенность в тоне ничего не означает

Что дальше

Самое практически важное следствие из всего сказанного — почему модель врёт и почему это невозможно полностью починить.

Механизм галлюцинаций: почему модель не может не врать

Не баг и не «недоученность». Прямое следствие устройства из предыдущих глав. Разберём механизм — и станет ясно, что можно сделать, а что нет.

Почему слово «галлюцинация» вводит в заблуждение

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

Как рождается вымысел

Вопрос: «Какой ключ у ollama показывает температуру видеокарты?»

Что происходит внутри:
  • похожие тексты в обучении: «ollama --help», «ollama ps», «--verbose»
  • шаблон «команда + ключ + понятное слово» встречался тысячи раз
  • слово «температура» тянет за собой «--temp», «--temperature»

Результат: «ollama ps --temperature»

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

Обратите внимание: модель не «решила соврать». Она построила самое вероятное продолжение. Отсутствие такого ключа в реальности — информация, которой у неё просто нет.

Четыре источника вымысла

Почему дообучение сделало ситуацию хуже

Неприятный поворот. Модели дообучают быть полезными: отвечать, а не уклоняться. Люди при оценке ставят высокие баллы уверенным развёрнутым ответам и низкие — осторожным «не знаю».

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

Где риск максимален

Что реально снижает вымысел

Как распознать вымысел

• Подозрительно конкретное число там, где вы не ждали точности
• Ссылка или цитата, которую вы не можете найти
• Ключ команды, функция или параметр, которых нет в документации
• Ответ идеально подходит под форму вопроса — особенно если вопрос был с подвохом
• Ровно столько пунктов, сколько вы попросили
• При повторном вопросе другими словами ответ изменился
• Тема узкая, а уверенность высокая

Правильное отношение

Проверьте, что поняли

• Я понимаю, что механизм правды и вымысла — один и тот же
• Я знаю четыре источника и какие два провоцирую сам
• Я знаю категории максимального риска и проверяю их всегда
• Я использую формулировку «только по тексту, иначе — нет ответа»
• Я понимаю, почему «не галлюцинируй» не работает
• Я ставлю низкую температуру там, где нужна точность

Что дальше

Мы несколько раз упомянули дообучение. Разберём, что оно на самом деле меняет внутри — и чего от него ждать не стоит.

Дообучение: что на самом деле меняют SFT, RLHF и DPO

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

Три этапа

Этап 2: обучение инструкциям

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

ЗАДАНИЕ: Объясни, почему светодиодной лампе нужен драйвер.

ОТВЕТ: Светодиод — токовый прибор: его яркость и срок службы
зависят от тока, а не от напряжения. В сети переменное
напряжение 220 В, и оно нестабильно. Драйвер выпрямляет
его и стабилизирует ток...

Этап 3: настройка по предпочтениям

Проблема этапа 2: «хороший ответ» трудно определить. Правильных ответов много, и они разного качества. Решение — не показывать образец, а сравнивать.

1. Модель генерирует несколько вариантов ответа.
2. Человек указывает, какой лучше.
3. На множестве таких сравнений обучается вторая модель — оценщик.
4. Основную модель подкручивают так, чтобы оценщик ставил выше.

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

Побочные эффекты

Что дообучение может, а что нет

Когда дообучение оправдано

Проверьте, что поняли

• Я знаю три этапа и что даёт каждый
• Я понимаю, что обучение инструкциям меняет формат, а не знания
• Я понимаю, откуда берётся уверенный тон и подхалимство
• Я знаю, что дообучение не вкладывает факты
• Я понимаю разницу: дообучение — как, RAG — что
• Я знаю правильный порядок: запрос → RAG → дообучение

Что дальше

Практика: как дообучить модель на вашем ноутбуке, не имея дата-центра.

LoRA: дообучить модель на своём ноутбуке

Обучить 7B целиком — нужны десятки гигабайт видеопамяти. Обучить крошечную добавку к ней — хватит ваших шестнадцати. Как устроен приём и как им пользоваться.

Идея

Из главы 03: при обучении помимо весов надо хранить градиенты и состояния оптимизатора — втрое-вчетверо больше памяти, чем занимает модель. Для 7B это десятки гигабайт. У вас 16.

Приём LoRA: не трогать исходные веса вообще. Заморозить их и обучить маленькую добавку, которая прибавляется к результату.

обычное дообучение:   W  →  W'        (меняем 7 млрд чисел)

LoRA:                 W  +  A·B       (W заморожен,
                      ↑     ↑          учим только A и B)
                   не трогаем    несколько миллионов чисел

Хитрость в том, что A и B — узкие матрицы. Если исходная матрица 4096×4096 (это 16 миллионов чисел), то A размером 4096×8 и B размером 8×4096 дают вместе 65 тысяч — в 250 раз меньше. А их произведение имеет тот же размер, что исходная матрица, и потому может к ней прибавляться.

Что вы получаете

Ещё экономнее: квантованный вариант

Можно пойти дальше: держать замороженную базовую модель в сжатом виде (4 бита, как в главе 10 книги «ИИ»), а обучать адаптер в обычной точности. Это то, что обычно называют QLoRA.

Экономия огромная: 7B в четырёх битах занимает около 4 ГБ вместо 14, и на ваших 16 ГБ остаётся достаточно места для самого обучения. Именно этот вариант делает дообучение на ноутбуке реальным.

Главные настройки

Данные важнее всего остального

Здесь ровно как в главе 05: результат определяется данными, а не настройками.

Формат данных — те же пары «задание — ответ», что в главе 12. Важно, чтобы ответы были единообразны: если в половине примеров вы пишете маркированным списком, а в половине сплошным текстом, модель выучит случайность.

Порядок работы

1. Сформулируйте, что именно хотите изменить. «Пусть будет лучше» — не цель. «Пусть отвечает в стиле моих учебников: короткие абзацы, без вводных слов, с примерами из электроники» — цель.
2. Соберите 200–500 примеров в едином формате. Это основная работа.
3. Отложите 10% на проверку и не показывайте их при обучении.
4. Обучите с небольшим rank и одной эпохой. Посмотрите на результат.
5. Сравните с базовой моделью на одних и тех же вопросах.
6. Меняйте что-то одно за раз и сравнивайте по тому же списку.

Что пойдёт не так

Реалистичные ожидания для вашей машины

Проверьте, что поняли

• Я понимаю идею: заморозить веса, учить узкую добавку
• Я знаю, что результат — маленький переключаемый файл
• Я понимаю, что даёт квантованный вариант
• Я знаю, что означают rank и alpha и в какую сторону их менять
• Я понимаю, что данные важнее настроек
• Я отложу часть данных на проверку
• Первую LoRA сделаю на маленькой модели

Что дальше

Языковые модели закончились. Переходим к совершенно другому классу — тому, что рисует картинки. Механизм там неожиданно изящный.

Диффузия: как из шума получается картинка

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

Идея наоборот

Как научить сеть рисовать? Прямая постановка безнадёжна: что считать правильным ответом на «нарисуй плату»? Правильных картинок бесконечно много.

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

фото платы → +шум → +шум → +шум → ... → сплошной шум
    шаг 0     шаг 1   шаг 2   шаг 3        шаг 1000

обучение: по картинке на шаге N предсказать добавленный шум

Обучили. Теперь запускаем в обратную сторону: берём случайный шум и просим сеть шаг за шагом убирать из него «шум». Из ничего проступает изображение.

Почему считать удаётся быстро

Картинка 1024×1024 — это три миллиона чисел. Прогонять их через сеть сотню раз было бы неподъёмно.

Решение: работать не с картинкой, а с её сжатым представлением. Отдельная сеть-кодировщик сжимает изображение в компактный массив в десятки раз меньше, весь процесс удаления шума происходит там, а в конце декодер разворачивает результат обратно в картинку.

текст «плата с вздутым конденсатором»
  ↓ текстовый кодировщик
векторы смысла (глава 06)
  ↓
случайный шум в сжатом пространстве
  ↓ ← сюда через внимание (глава 08) подмешивается текст
шаг 1: убрали часть шума
шаг 2: убрали ещё
  ...
шаг 25: чистое сжатое представление
  ↓ декодер
готовая картинка

Как текст управляет картинкой

Ваше описание превращается в векторы (ровно как в главе 06), и на каждом шаге удаления шума сеть смотрит на эти векторы через внимание — механизм из главы 08, только между картинкой и текстом.

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

Настройки, которые вы будете крутить

Что за модели бывают

Чем это отличается от языковой модели

Проверьте, что поняли

• Я понимаю приём: научить убирать шум, потом запустить от чистого шума
• Я знаю, зачем работать в сжатом пространстве
• Я понимаю, что текст влияет через внимание на каждом шаге
• Я понимаю, почему плохо со счётом и текстом на картинке
• Я знаю, зачем фиксировать seed при сравнении настроек

Что дальше

Практика на вашем железе: что ставить, что реально влезет в 16 ГБ и чего ожидать по скорости.

Практика: генерация изображений на 16 ГБ видеопамяти

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

Чем запускать

Что влезет в 16 ГБ

Сколько ждать

Порядок величин для вашей карты. Точные цифры зависят от модели, разрешения, числа шагов и от того, не ушла ли часть модели в оперативную память.

Как формулировать запрос

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

[что изображено] , [детали] , [окружение] , [свет] ,
[ракурс] , [стиль] , [качество]

Пример:
печатная плата крупным планом, вздутый электролитический
конденсатор, следы пайки, зелёная маска, макросъёмка,
мягкий боковой свет, малая глубина резкости,
техническая фотография, высокая детализация

Рабочий процесс

1. Сгенерировать пачку из 4–8 картинок с разными seed и общим запросом.
2. Выбрать ту, где композиция ближе всего к задуманному.
3. Зафиксировать её seed.
4. Дальше менять по одному параметру за раз и сравнивать.
5. Когда результат устраивает — увеличить разрешение отдельно.
6. Мелкие дефекты доправить дорисовкой по маске — глава 16.

Где это реально применимо у вас

Проверьте, что поняли

• Я выбрал инструмент и запустил первую генерацию
• Я знаю, какая модель комфортна на моих 16 ГБ
• Я понимаю приём «сначала мелко, потом увеличить»
• Я пишу запрос перечислением признаков, а не просьбой
• Я фиксирую seed при подборе настроек
• Сохранение параметров в файл включено
• Я понимаю, где сгенерированное изображение неуместно

Что дальше

Случайные картинки — это развлечение. Управление композицией превращает генерацию в инструмент.

Управление: ControlNet, маски и дорисовка

Пока вы получаете случайные картинки по описанию — это игрушка. Управление композицией, дорисовка по маске и работа от исходника превращают её в рабочий инструмент.

Четыре способа управлять

От исходника

Вместо чистого шума процесс стартует от вашей картинки, зашумлённой частично. Ключевой параметр — насколько сильно зашумлять.

Дорисовка по маске

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

Управление структурой

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

Совмещение

Способы комбинируются: можно одновременно держать контуры и глубину, добавить LoRA со своим стилем (глава 17) и работать по маске. Сила у каждого управления регулируется отдельно.

Порядок работы над конкретной картинкой

1. Задайте композицию — наброском или структурным управлением, а не описанием.
2. Сгенерируйте пачку, выберите лучшую, зафиксируйте seed.
3. Доведите общее: стиль, свет, цвет — меняя по одному параметру.
4. Почините частности дорисовкой по маске.
5. Увеличьте отдельным проходом.
6. Финальные мелочи — в обычном редакторе. Часто это быстрее, чем уговаривать модель.

Проверьте, что поняли

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

Что дальше

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

Свой стиль: обучить LoRA на своих изображениях

Тот же приём, что в главе 13, но для картинок — и здесь он на порядок доступнее: два десятка изображений и полчаса на вашей видеокарте.

Зачем

Механизм тот же

Базовая модель заморожена, обучается маленькая добавка — как в главе 13. Разница количественная и приятная: изображений нужно два десятка, а не тысячи примеров, и обучение занимает десятки минут, а не часы.

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

Данные решают всё — и здесь особенно

Подписи

К каждому изображению пишется краткое описание. Здесь есть неочевидное правило, из-за которого чаще всего не получается.

изображение 1: mystyle, печатная плата, вид сверху, светлый фон
изображение 2: mystyle, паяльник на столе, боковой ракурс
изображение 3: mystyle, светодиодная лампа в разборе, тёмный фон

Про сам стиль — ни слова. Общее у всех трёх и есть стиль,
и он привяжется к слову mystyle.

Настройки

Как проверить результат

• Сгенерировал то, чего НЕ было в обучающих данных — стиль переносится?
• Сравнил несколько промежуточных сохранений на одном seed
• Проверил на разной силе влияния — от слабой до полной
• Убедился, что не выдаёт почти копии обучающих картинок
• Проверил, что базовая модель не «сломалась» — обычные запросы работают
• Попробовал вместе с управлением структурой из главы 16

Реалистичные ожидания

Про чужие изображения — коротко и серьёзно

Что дальше

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

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

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

Почему видео на порядок труднее

Три подхода

Что реально получится на ваших 16 ГБ

Приёмы, которые улучшают результат

• Меньше движения — лучше. Модели неплохо справляются с медленным наездом камеры и плохо — с активным действием в кадре.
• Простая сцена. Один объект, спокойный фон. Много деталей — много мерцания.
• Начинать с картинки, а не с текста. Контроля над первым кадром у вас гораздо больше.
• Генерировать коротко и склеивать. Два клипа по три секунды надёжнее одного шестисекундного.
• Доводить обычным монтажом. Скорость, цветокоррекция, переходы — в видеоредакторе, а не в модели.

Недооценённая часть: обработка готового видео

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

Что будет меняться

Проверьте, что поняли

• Я понимаю, почему видео принципиально тяжелее картинок
• Я знаю про внимание вдоль времени
• Я понимаю, что на 16 ГБ реалистичны короткие клипы
• Я знаю приём «картинка плюс лёгкое движение»
• Я понимаю, что обработка готового видео полезнее генерации
• Я знаю три оси, по которым оценивать новые видеомодели

Что дальше

Звук — область, где локальные модели уже сейчас работают отлично и требуют немного. Начнём с самого полезного.

Распознавание речи: субтитры и расшифровки

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

Как устроено

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

звуковая волна
  ↓ разбиение на короткие окна, преобразование Фурье
спектрограмма — по сути изображение
  ↓ энкодер
векторы (глава 06)
  ↓ декодер с вниманием
текст, по одному токену (глава 09)

Почему получилось так хорошо

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

Отсюда и практический вывод: качество записи влияет меньше, чем кажется. Съёмка на телефон с эхом в комнате распознаётся вполне прилично.

Размеры моделей

Что вы получите на практике

Где ошибается

Как получить хорошие субтитры

1. Отделите звук от видео — модели нужен только он.
2. Уберите длинные паузы и музыкальные вставки, если их много.
3. Укажите язык явно, не полагайтесь на автоопределение.
4. Возьмите большую модель — качество того стоит.
5. Получите файл с таймкодами, а не сплошной текст.
6. Просмотрите начало и конец — там чаще всего выдуманное.
7. Прогоните через языковую модель для расстановки абзацев и исправления терминов, если делаете из этого текст.

Смежные задачи со звуком

Проверьте, что поняли

• Я понимаю, что звук превращается в спектрограмму и обрабатывается как картинка
• Я знаю, что большая модель идёт на моём железе свободно
• Я знаю про оптимизированные сборки для скорости
• Я понимаю, что модель может выдумать текст в тишине
• Я указываю язык явно
• Я проверяю начало и конец расшифровки

Что дальше

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

Синтез речи и клонирование голоса

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

Как получается голос

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

текст
  ↓ нормализация: «220 В» → «двести двадцать вольт»
последовательность звуков с ударениями
  ↓ модель (та же архитектура из главы 09)
спектрограмма
  ↓ вокодер
звуковая волна

Три уровня

Как работает клонирование

Модель кодирует образец голоса в вектор — тот самый приём из главы 06, только вектор описывает тембр, а не смысл. Дальше синтез идёт с оглядкой на этот вектор.

Дообучение не требуется: достаточно нескольких секунд чистой записи. Именно это делает технологию одновременно удобной и проблемной.

Право и этика — без обхода темы

Отдельно: маркировка. Растёт практика — а местами и требование — помечать синтезированный голос как синтезированный. Для вашего контента это разумно делать по умолчанию, даже где не обязательно: доверие аудитории дороже.

Практичные сценарии

Чек-лист рабочего процесса

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

Что дальше

Третья звуковая тема, и для вас — возможно, самая интересная: звук как способ диагностики.

Музыка, шум и звуковая диагностика

Генерация музыки — самая слабая из звуковых областей. Зато разделение дорожек работает отлично, а классификация звука открывает то, чего в книге ещё не было: диагностику по слуху.

Музыка: честно о состоянии дел

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

Практический вывод: для фоновой подложки под ролик — можно пробовать. Для чего-то серьёзного — библиотеки готовой музыки пока надёжнее.

Разделение дорожек: работает отлично

Здесь противоположная картина — зрелая технология, которая делает то, что ещё недавно казалось невозможным: из готовой записи выделить отдельно вокал, барабаны, бас, остальное.

Классификация звука — то, чего ещё не было

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

Как сделать такой классификатор

1. Собрать записи. Десятки коротких фрагментов на каждый класс. Один микрофон, одно расстояние, одинаковые условия.
2. Превратить в спектрограммы. Дальше это задача про картинки.
3. Взять готовую сеть и дообучить её последние слои на ваших данных — приём из главы 12, но для изображений.
4. Отложить часть записей на проверку — глава 05.
5. Проверить в реальных условиях, а не только на своих записях.

Что понадобится

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

Проверьте, что поняли

• Я понимаю, почему музыка даётся хуже картинок
• Я знаю про разделение дорожек и связку с распознаванием речи
• Я понимаю, что классификация звука — это классификация спектрограмм
• Я знаю про обнаружение аномалии и почему оно практичнее
• Я помню про одинаковые условия записи

Что дальше

От звука к изображению: как научить компьютер находить нужное на фотографии — и как это применить к плате.

Компьютерное зрение: найти объект на фото

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

Четыре задачи, а не одна

Поиск похожих — вообще без обучения

Самый недооценённый вариант. Берёте готовую сеть, прогоняете все свои фотографии и получаете вектор для каждой (глава 06). Дальше — поиск ближайших, ровно как в главе 07.

• Разметка не нужна совсем.
• Обучение не нужно совсем.
• Новый снимок → мгновенно «вот пять похожих из вашего архива».

Своя классификация: перенос обучения

Обучать сеть распознавать изображения с нуля — задача на тысячи картинок минимум. Но этого не требуется.

Берётся сеть, обученная на миллионах разных изображений. Первые её слои уже умеют то, о чём говорилось в главе 03: границы, линии, формы, текстуры. Это универсально. Нужно лишь заменить последний слой и дообучить его под ваши классы.

Детекция, если всё же нужна

Что реально получится с платами

Условия съёмки решают больше, чем модель

• Одинаковый свет — лучше рассеянный, без бликов на пайке
• Одинаковое расстояние и ракурс
• Однотонный фон, не мешающий
• Резкость по всей плате — прикрыть диафрагму
• Разные экземпляры плат, а не один в разных позах
• Условия съёмки НЕ коррелируют с классом

Последний пункт — тот самый волк на снегу. Он повторяется в этой книге трижды, потому что именно он губит больше всего проектов.

Проверьте, что поняли

• Я различаю четыре задачи и знаю, какая сколько разметки требует
• Я знаю, что поиск похожих работает вообще без обучения
• Я понимаю перенос обучения и почти никогда не учу с нуля
• Я знаю, что разметка — основная работа при детекции
• Я проверю лицензию до коммерческого использования
• Я понимаю, чего зрение принципиально не увидит

Что дальше

Из всей книги — самое близкое к вашим самоделкам: нейросеть, работающая на микроконтроллере за несколько долларов.

ИИ на микроконтроллере: TinyML в ваших самоделках

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

О чём речь

Всё предыдущее требовало видеокарты. Здесь наоборот: модель ужимается до десятков килобайт и работает на микроконтроллере с сотнями килобайт памяти, питаясь от батарейки.

Что реально помещается

Как модель ужимают

Железо

Как это делается

1. Собрать данные с того же датчика, который будет в изделии. Не с другого — характеристики отличаются, и модель этого не переживёт.
2. Записать оба состояния: нормальное и то, что надо ловить. Для обнаружения аномалии достаточно только нормального.
3. Обучить на компьютере. Модель крошечная, обучение занимает минуты.
4. Преобразовать в целочисленный вид и проверить, что качество не рухнуло.
5. Получить модель в виде массива для включения в прошивку.
6. Проверить на устройстве — в реальных условиях, а не на записанных данных.

Типичные грабли

Проверьте, что поняли

• Я понимаю, какие задачи помещаются в микроконтроллер
• Я знаю, что ограничение — память, а не скорость
• Я понимаю, зачем считать признаки на контроллере
• Я знаю про целочисленное преобразование и что качество надо проверять после него
• Я буду собирать данные тем же датчиком и в том же креплении
• У меня есть идея своего первого проекта

Что дальше

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

Мультимодальность: модель, которая видит и слышит

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

Идея

Языковая модель работает с векторами (глава 06) и внимание ей всё равно, откуда они взялись (глава 08). Значит, если научиться превращать изображение в такие же векторы, модель сможет «читать» картинку теми же механизмами.

изображение
  ↓ зрительный кодировщик (сеть из глав 03 и 22)
векторы кусочков изображения
  ↓ проектор — маленькая сеть-переходник
векторы в том же пространстве, что слова
  ↓
[вектор картинки][вектор картинки]...[«что здесь сломано?»]
  ↓
обычная языковая модель — и не различает, что откуда

Что это умеет

Практический вывод для ваших задач

Что с этим на вашем железе

Куда это движется

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

Проверьте, что поняли

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

Что дальше

Последний блок. Сначала — как честно понять, стало лучше или вам показалось.

Как оценивать модель и не обманывать себя

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

Почему это отдельная глава

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

Почему нельзя верить рейтингам

Своя проверка за час

1. Возьмите 20–30 своих настоящих задач. Не придуманных — тех, которые вы реально даёте модели.
2. Запишите для каждой, что считается хорошим ответом. Не образец дословно, а критерий: «должен упомянуть про ток, а не напряжение», «должен отказаться, если данных нет».
3. Включите заведомо трудные: задачи с подвохом, вопросы без ответа, длинный контекст, ваши термины.
4. Сохраните как файл и используйте всегда один и тот же.
5. Прогоняйте при любом изменении и записывайте результат.

Как сравнивать честно

Что мерить, кроме «хорошо ли»

Оценка моделью — осторожно

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

Минимум, который стоит делать: предъявлять пары в обоих порядках и сравнивать. Если оценка меняется от перестановки — она бесполезна.

Проверка для картинок и звука

Проверьте, что поняли

• Я знаю три ловушки восприятия и почему они работают против меня
• Я понимаю, почему рейтингам нельзя верить напрямую
• Я составил свой список из 20–30 реальных задач
• В списке есть задачи, где правильный ответ — «не знаю»
• Я сравниваю вслепую и попарно
• Я меряю не только правильность, но и выдумывание, формат и скорость
• Я понимаю, почему доля верных ответов может обманывать

Что дальше

Последняя глава: как превратить всё это в работающий инструмент под вашу задачу.

Собрать свой инструмент: от идеи до рабочего скрипта

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

Схема, которая подходит почти ко всему

ИСТОЧНИК      → откуда берутся данные
                (папка, запись, камера, микрофон, ваши книги)
     ↓
ПОДГОТОВКА    → привести к виду, который принимает модель
                (нарезка, спектрограмма, кадрирование)
     ↓
МОДЕЛЬ        → одна операция
                (эмбеддинг, распознавание, генерация, классификация)
     ↓
ПРОВЕРКА      → отсечь очевидно плохое, пометить сомнительное
     ↓
РЕЗУЛЬТАТ     → файл, база, папка, уведомление
     ↓
ЖУРНАЛ        → что сделано, с чем, когда

Пять проектов под ваши задачи

1. Поиск по вашим книгам

Почему первым: сложность низкая, польза сразу, и вы точно можете оценить качество — вы знаете свои книги.

2. Субтитры и расшифровки для роликов

Почему это стоит сделать: вероятно, наибольшая экономия времени из всего, что есть в книге.

3. Оформление статьи из наговорённого текста

Наговорить главу голосом, расшифровать проектом 2, и прогнать через языковую модель с задачей: расставить абзацы, исправить термины, убрать слова-паразиты, не меняя содержания. Последнее условие обязательно и требует проверки — модель склонна «улучшать».

4. Иллюстрации в едином стиле

Обучить LoRA на стиле (глава 17), сделать заготовку схемы в ComfyUI с управлением по наброску (глава 16), и дальше получать иллюстрации для всех книг с одинаковым видом. Сложность выше, зато результат переиспользуется годами.

5. Датчик состояния механизма

Акселерометр, обнаружение аномалии, микроконтроллер (главы 21 и 23). Самый «ваш» проект из всех: соединяет электронику, самоделки и машинное обучение, и не требует ни видеокарты, ни интернета.

С чего начинать

Где ИИ не нужен

Правила, которые сэкономят месяцы

1. Сначала вручную на десяти примерах. Поймёте задачу и получите проверочный набор из главы 25.
2. Самая простая модель, которая справляется. Не самая мощная.
3. Одна операция на инструмент. Не «универсальный помощник».
4. Сохраняйте промежуточное. Дешевле, чем пересчитывать всё после сбоя.
5. Ничего необратимого без подтверждения.
6. Замеряйте по своему списку после каждого изменения.
7. Сначала поиск и подготовка данных, потом модель. Качество чаще упирается в них.

Как не отстать

Пятнадцать правил из всей книги

1. Обучение — это вывод правил из примеров, а не программирование правил.
2. Если правило можно записать словами, пишите программу, а не обучайте модель.
3. Нейрон — это умножение, сложение и одна нелинейность. Больше ничего.
4. Без нелинейности глубина бесполезна.
5. Обучение — это измерить ошибку и сделать маленький шаг. Миллион раз.
6. Хороший результат на обучающих данных не означает ничего. Проверяйте на новых.
7. Волк на снегу: модель находит признак, а не смысл. Меняйте всё, кроме того, чему учите.
8. Смысл — это вектор. Близкое по смыслу оказывается рядом.
9. Внимание позволяет каждому элементу смотреть на все остальные. Цена — квадратичный рост.
10. Модель предсказывает правдоподобное. Отдельного механизма для правды в ней нет.
11. Дообучение меняет как отвечать. Поиск по вашим данным — что отвечать.
12. Почти никогда не учите с нуля. Берите готовое и дообучайте добавку.
13. Данные важнее настроек. Всегда.
14. Не поручайте то, результат чего не можете проверить.
15. Свой список из двадцати задач честнее любого рейтинга.