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

Современная модель ИИ умеет писать на Python, узнавать собаку, переводить с японского, пересказывать договор, подражать Шекспиру и время от времени сообщать вам полную неправду с уверенностью человека, которому ни разу не приходило в голову проверить что-нибудь в Google.

В основе всей этой сложности лежит нечто удивительно обыкновенное:

числа.

Миллиарды чисел.

Когда в описании модели вы видите 8B, 30B или 70B, B означает миллиарды параметров.

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

Именно эти числа обычно имеют в виду, когда говорят о весах модели.

Это не маленькие предложения, хранящиеся где-то внутри компьютера.

Там нет скрытой строки:

Франция → Париж

Нет папки с названием:

Всё, что я знаю о собаках

И ни у одного отдельного веса нет должности вроде:

Старший вице-президент по сарказму.

Знания в нейронной сети распределены по огромным сочетаниям чисел.

Звучит загадочно.

Но основная идея проста.

На самом деле эта история началась больше восьмидесяти лет назад.

До того, как ИИ стал модным — и даже электронным

В 1943 году нейрофизиолог Уоррен Маккаллок и математик Уолтер Питтс опубликовали влиятельную математическую модель искусственного нейрона.

Это было до современного ИИ.

До GPU.

До Python.

Даже до изобретения транзистора.

Их вопрос был дерзко прост:

Можно ли представить нечто, вдохновлённое биологическим нейроном, математически — как вычислительную единицу?

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

Но появилась важная идея:

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

Современные нейронные сети несравнимо сложнее.

Но под всей этой сложностью всё ещё узнаётся та исходная идея.

Начнём с одного искусственного нейрона

Забудем на минуту о восьми миллиардах параметров.

Построим один крошечный искусственный нейрон.

Предположим, он получает три числовых значения:

Буква $x$ просто означает входное значение.

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

Каждое входное значение умножается на другое число:

Буква $w$ обозначает вес.

Вес определяет, насколько сильно конкретное входное значение влияет на вычисление нейрона.

Нейрон объединяет значения так:

Формула выглядит страшнее, чем само действие.

Обычными словами она говорит:

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

Смещение — это:

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

После вычисления взвешенной суммы нейронная сеть обычно пропускает результат через нелинейную функцию:

Здесь $f$ просто означает:

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

Зачем?

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

Нелинейность позволяет сети представлять гораздо более сложные зависимости.

Итак, основной путь такой:

входные значения → веса → взвешенная сумма → нелинейное преобразование → следующий слой

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

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

Появляется перцептрон — а вместе с ним и шумиха вокруг ИИ

В конце 1950-х психолог Фрэнк Розенблатт разработал перцептрон — одну из первых обучаемых нейросетевых систем.

Ключевое слово — обучаемых.

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

Сила этих связей и была весами.

Основная идея звучала на удивление современно:

Сделай предсказание.
Узнай, было ли оно ошибочным.
Подправь числа.
Попробуй снова.

Газеты пришли в необычайное возбуждение.

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

Компьютеры были несколько менее удобными.

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

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

Прогресс порой жесток к старому оборудованию.

Гигантский микшерный пульт

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

Поступает сигнал.

Один регулятор усиливает какую-то его часть.

Другой что-то ослабляет.

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

А теперь представьте не двадцать регуляторов.

Не двадцать тысяч.

Миллиарды.

Итоговое поведение зависит от их совместных настроек.

Но у этой аналогии есть важная оговорка.

Конкретный вес обычно не соответствует аккуратно одному человеческому понятию.

Нельзя открыть модель 8B, найти параметр номер 4 827 112 391 и объявить:

«Отлично. Мы нашли левое ухо собаки».

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

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

Смысл распределён.

Интеллект — в сочетании.

А не в одном волшебном регуляторе.

До обучения: очень дорогой идиот

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

В этот момент у сети есть архитектура.

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

Но полезным зависимостям она ещё не научилась.

Можно построить огромную модель и всё равно получить нечто по большей части бесполезное.

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

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

В тетрадях должно быть что-то написано.

Обучение — это процесс, который меняет числа.

Не записывая в них предложения.

А создавая полезные числовые связи.

Пусть один нейрон ошибётся

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

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

Первое:

Второе:

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

Текущий первый вес:

Второй:

А смещение:

Теперь вычислим нашу взвешенную сумму:

Вместо того чтобы просто смотреть на формулу, разберём её по частям.

Первое входное значение вносит вклад:

Второе входное значение вносит вклад:

А смещение добавляет ещё:

Складываем три части:

Итак, наш нейрон выдаёт:

Маленькая крышечка над $y$ означает:

предсказание модели

Теперь предположим, что правильное целевое значение в этом обучающем примере:

Модель предсказала:

Правильный результат:

Значит, предсказание занижено на:

Нейрон ошибся.

Это отличная новость.

Ошибки — это, по сути, система образования нейронных сетей.

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

Функция потерь: математический измеритель неловкости

Теперь системе обучения нужен формальный способ ответить на вопрос:

Насколько ошибочным было предсказание?

Этим занимается функция потерь.

В нашем игрушечном примере можно использовать простую квадратичную функцию потерь:

Расшифруем каждый символ.

$L$ означает потери.

$\hat y$ означает предсказание модели.

$y$ означает правильное целевое значение.

То есть формула говорит:

Вычтите правильный ответ из предсказания, затем возведите разность в квадрат.

Наше предсказание:

Целевое значение:

Вычитаем:

Теперь возводим результат в квадрат:

Итак, наши потери:

Зачем возводить ошибку в квадрат?

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

Занизить результат на 0.30 — тоже ошибка.

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

Представьте потери как математический измеритель неловкости.

Большие потери:

Получилось плохо.

Меньшие потери:

Уже не так неловко.

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

С ней мы познакомимся позже.

Пока главная идея такая:

предсказание → измерение ошибки

Следующий вопрос сложнее.

В нашем маленьком примере всего два веса.

У настоящей модели их могут быть миллиарды.

Какие веса отвечали за ошибку?

И в какую сторону их нужно изменить?

1986 год: математика учится распределять вину

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

Математические идеи, лежащие в его основе, имеют более долгую историю, но влиятельная работа Дэвида Румельхарта, Джеффри Хинтона и Рональда Уильямса 1986 года помогла сделать обратное распространение ошибки центральным методом обучения современных нейронных сетей.

Задачу легко сформулировать.

Результат оказался неверным.

Но в его получении участвовало много слоёв и много параметров.

Как определить, какие изменения улучшили бы результат?

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

Можно представить это как необычайно эффективную бухгалтерию.

Произошла ошибка.

Теперь подсчитывается вклад каждого.

Никому не удастся сказать:

«Почти уверен, что это был слой 17».

У математического анализа все чеки сохранены.

Обратное распространение ошибки: что означает формула?

Одно из выражений, которые вам встретятся:

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

Идея значительно проще символа.

Она спрашивает:

Если я совсем немного изменю именно этот вес, как изменятся потери?

Это значение — часть того, что мы называем градиентом.

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

Полезная информация.

Предположим, его увеличение уменьшает ошибку.

Тоже полезная.

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

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

Сеть не думает:

«Я перепутала собаку с кошкой, потому что слишком много внимания уделила шерсти».

Ничего столь литературного не происходит.

Она вычисляет, как изменения одних чисел влияют на другие.

Очень много чисел.

Градиентный спуск: теперь идём вниз

Когда обратное распространение вычислило градиенты, у оптимизатора появляется основа для действия.

Упрощённое обновление веса выглядит так:

Снова расшифруем формулу, прежде чем пользоваться ею.

$w_{\text{old}}$ — вес, который у нас есть сейчас.

$w_{\text{new}}$ — вес после шага обучения.

Градиент:

показывает, как меняются потери при изменении этого веса.

А греческая буква:

которая произносится эта, — это скорость обучения.

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

Итак, вся формула означает:

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

Почему в противоположную?

Потому что цель — заставить потери уменьшаться.

Представьте, что стоите на горе в густом тумане.

Долину не видно.

Но можно определить, в какую сторону склон идёт вверх.

Если цель — спуститься, идите в другую сторону.

Это основная интуиция градиентного спуска.

Настоящий ландшафт оптимизации современной нейронной сети может иметь миллиарды измерений.

Из-за этого гору несколько трудно нарисовать на салфетке.

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

Современное обучение обычно использует более сложные оптимизаторы, например Adam или AdamW: они отслеживают дополнительную информацию и разумно корректируют процесс обновления.

Но главная идея остаётся прежней:

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

А теперь действительно это сделаем.

Одно крошечное обновление — с настоящими вычислениями

Ранее наш игрушечный нейрон получал:

и:

Его веса были:

и:

Смещение было:

Нейрон предсказал:

Желаемый результат:

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

Наша ошибка предсказания с учётом знака:

Минус говорит нам:

Предсказание модели ниже целевого значения.

Наша квадратичная функция потерь была:

то есть:

Теперь вычислим, как эти потери реагируют на каждый вес.

Находим градиент для первого веса

Для этого простого нейрона градиент потерь по первому весу равен:

Выглядит технически.

Но все значения уже известны.

Ошибка:

Первое входное значение:

Подставляем эти значения:

Перемножаем:

Что означает минус 0.60?

Это говорит нам, что в этой точке увеличение $w_1$ должно уменьшить потери.

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

Градиентный спуск движется в противоположную сторону.

Находим градиент для второго веса

Теперь делаем то же самое для второго веса:

Ошибка всё ещё равна:

Но второе входное значение составляет лишь:

Подставляем:

и получаем:

Заметьте кое-что полезное.

Величина второго градиента вдвое меньше первого.

Почему?

Потому что второе входное значение:

вдвое меньше первого:

В этом крошечном примере изменение первого веса сильнее влияет на итоговый результат.

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

Выбираем скорость обучения

Теперь мы знаем направление.

Осталось решить, насколько большим будет шаг.

Для нашей демонстрации выберем:

Это означает, что в этом упрощённом шаге оптимизатор сдвинет вес на одну десятую величины градиента.

Для объяснения это удобное круглое число.

Настоящие системы обучения гораздо тщательнее выбирают скорость обучения и её изменение со временем.

Слишком маленькая — и обучение может стать мучительно медленным.

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

Обновляем первый вес

Правило обновления:

Для первого веса:

Сначала умножаем скорость обучения на градиент:

Значит:

Вычесть отрицательное число — значит прибавить:

Теперь мы точно знаем, откуда взялось 0.26.

Никто не выбрал его потому, что оно красиво выглядит.

Никакой инженер не напечатал:

Давайте попробуем 0.26.

Его дали градиент и скорость обучения.

Обновляем второй вес

Теперь повторим ровно тот же процесс для $w_2$:

Умножаем:

Значит:

и получаем:

Вот откуда взялось 0.43.

В этом учебном примере оставим смещение неизменным:

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

Запускаем нейрон снова

Входные значения не изменились.

Первое по-прежнему:

Но его вес теперь:

Поэтому его вклад:

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

Его новый вес:

Поэтому его вклад становится:

Смещение остаётся:

Складываем всё:

Новое предсказание нейрона:

До шага обучения он предсказывал:

Теперь предсказывает:

Целевое значение остаётся:

Он всё ещё ошибается.

Но обратите внимание на то, что произошло.

До обновления расстояние до цели было:

После обновления:

Ошибка стала меньше.

Можно также вычислить новые квадратичные потери:

Сначала:

Затем возводим в квадрат:

Итак, потери снизились с:

до:

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

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

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

Но наш крошечный пример показал один полный шаг обучения, ничего не скрыв:

Словами:

Нейрон сделал предсказание.
Функция потерь измерила ошибку.
Математический анализ определил вклад весов в ошибку.
Оптимизатор изменил веса.
Новое предсказание приблизилось к цели.
Потери стали меньше.

Ничего волшебного не произошло.

Математика изменила числа.

Затем система делает это снова.

И снова.

И снова.

В нашем примере два веса, потому что два веса ещё удобно помещаются на странице.

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

Здесь в историю вступают вычисления промышленного масштаба.

Как языковая модель учится таким способом?

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

Париж = столица Франции

Собака = млекопитающее

Python = отступы имеют значение

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

Предскажи следующий токен.

Так что останемся с Парижем и пройдём пример до конца.

Предположим, обучающий текст содержит:

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

В какой-то момент обучения модель получает:

Столица Франции —

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

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

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

Лондон — 18%
Париж — 5%
Лион — 4%
Рим — 3%
Берлин — 2%

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

Но обучающий текст говорит нам, что настоящий следующий токен:

Париж

Следовательно, модель сделала плохое предсказание.

Она дала Парижу всего пять процентов вероятности, отдав предпочтение Лондону.

Теперь при обучении нужно измерить эту ошибку.

Кросс-энтропия: потери языковой модели

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

Для одного правильного токена упрощённое выражение можно записать так:

Снова расшифруем, прежде чем считать.

$P_{\text{correct}}$ означает:

вероятность, которую модель присвоила токену, действительно шедшему следующим

В нашем примере:

Пять процентов в десятичной записи:

Подставляем:

Результат примерно равен:

Запоминать 2.996 не нужно.

Важно то, что делает логарифм.

Низкая вероятность правильного ответа даёт относительно большие потери.

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

Тогда:

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

Итак:

Париж с вероятностью 5% → относительно большие потери

Париж с вероятностью 70% → гораздо меньшие потери

Функция потерь не знает, что такое Париж.

Она не знает, что такое Франция.

Она не понимает политического понятия столицы.

Она просто говорит:

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

Этого числового сигнала достаточно.

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

Как «Париж» на самом деле добирается до весов?

Предсказание появилось не из одного веса.

Слова:

Столица Франции —

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

Эти представления прошли через множество слоёв Transformer.

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

В конце концов модель выдала исходные оценки возможных следующих токенов.

Эти исходные оценки называются логитами.

Представьте предельно упрощённый вариант:

Это ещё не вероятности.

Это исходные оценки предпочтения.

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

Допустим, после softmax мы получаем:

Лондон — 18%
Париж — 5%
Лион — 4%
Рим — 3%

Обучающие данные говорят нам:

Должен был победить Париж.

Кросс-энтропия даёт нам потери.

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

Оптимизатор обновляет их.

Не одно гигантское изменение.

Огромное количество микроскопических изменений.

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

Одно предложение не научит географии

Модель не видит:

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

один раз, чтобы тут же объявить:

«География освоена».

В её обучающих данных также могут быть:

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

Столичный город Франции — Париж.

Французское правительство находится в Париже.

Париж — крупный европейский город.

Франция — страна в Западной Европе.

Сена протекает через Париж.

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

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

Каждое предсказание порождает потери.

Каждая величина потерь даёт градиенты.

Каждый шаг обучения немного изменяет параметры.

Со временем перекрывающиеся связи постепенно вплетаются в сеть.

Это слово — вплетаются — полезно.

Факт не кладут в коробку с надписью:

Франция → Париж

Он становится частью распределённого математического полотна.

После достаточного обучения

В конце концов модель видит:

Столица Франции —

и теперь её выходное распределение может выглядеть примерно так:

Париж — 92%
Лион — 1.2%
Марсель — 0.7%
Лондон — 0.3%

Теперь Париж легко побеждает.

Так где же хранится факт?

Не в одном весе.

Не в одном нейроне.

Не в одной скрытой текстовой записи.

Связь распределена по сети.

И именно поэтому модель может также ответить:

Какой город является столицей Франции?

или:

Как называется столица Франции?

Само предложение изменилось.

Но лежащие в его основе связи между понятиями всё ещё полезны.

Модель не просто ищет точное предложение из обучения.

Она выполняет вычисления через выученную сеть числовых связей.

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

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

Смысл.

Факты.

Связи.

Стиль.

Структуру.

Закономерности рассуждений.

Цель проста:

Предскажи, что будет дальше.

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

И в конечном счёте эти выученные связи отражаются в её весах.

Собаки, кошки и почему «важность признаков» может ввести в заблуждение

Распространённое объяснение весов нейронной сети использует классификацию изображений.

Предположим, модель обучают отличать собак от кошек.

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

Для интуитивного понимания это полезно.

Но воспринимать это буквально не стоит.

Современная сеть обычно не содержит:

Вес ушей = 0.84

Вес цвета шерсти = 0.17

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

Более поздние слои могут объединять их в текстуры и формы.

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

Итоговая классификация возникает из взаимодействий множества слоёв и параметров.

Так что, когда мы говорим:

модель научилась тому, что форма ушей имеет значение

мы переводим сложный распределённый числовой процесс на человеческий язык.

Регулятора с надписью УХО нет.

2012 год: в историю вступает GPU

Нейронные сети существовали десятилетиями.

Почему их возможности вдруг начали так быстро расти?

Одной из главных причин было оборудование.

В 2012 году Алекс Крижевский, Илья Суцкевер и Джеффри Хинтон продемонстрировали то, что стало известно как AlexNet, — глубокую сеть распознавания изображений примерно с шестьюдесятью миллионами параметров.

Ключевым компонентом стало использование графических процессоров, или GPU.

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

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

Нейронные сети посмотрели на это оборудование и, по сути, сказали:

«Эта машина для умножения выглядит полезной».

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

Где-то виртуальный дракон заслуживает долю признания за современный ИИ.

От отдельных весов к тензорам

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

и:

Настоящей сети неудобно управлять миллиардами параметров таким способом.

Вместо этого числа организованы в структуры, которые называются тензорами.

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

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

Многомерные наборы тоже являются тензорами.

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

Расшифруем и эту.

$X$ представляет набор входных чисел.

$W$ представляет матрицу обученных весов.

Умножение:

означает объединение множества входных значений с множеством обученных весов по правилам матричного умножения.

Результат:

— новый набор преобразованных числовых значений.

Запись выглядит крошечной.

Настоящее вычисление может содержать миллионы или миллиарды отдельных операций умножения и сложения.

Вот почему GPU так ценны.

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

Пока ИИ, кажется, спокойно рассуждает о Достоевском, GPU умножает в промышленных масштабах.

Беседа выглядит интеллектуальной.

Оборудование видит арифметику.

2017 год: внимание меняет архитектуру

В 2017 году статья «Attention Is All You Need» представила архитектуру Transformer.

Трансформеры стали основой большинства современных больших языковых моделей.

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

Но появление внимания не отменило веса.

Совсем наоборот.

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

Внимание использует обученные матрицы проекций.

Слои прямого распространения используют обученные матрицы.

Системы эмбеддингов содержат обученные параметры.

Архитектура стала значительно сложнее.

Основной валютой остались числа.

2020 год: 175 миллиардов попадают в заголовки

Затем пришёл масштаб.

В 2020 году представили GPT-3 с:

175 миллиардами параметров.

Сравните это примерно с шестьюдесятью миллионами параметров AlexNet всего восемью годами ранее.

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

Основная идея оставалась узнаваемой:

Учить полезные числовые параметры на данных.

Исследователи улучшали архитектуру.

Методы обучения совершенствовались.

Наборы данных росли.

Кластеры GPU стали огромными.

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

Что физически содержит модель 8B?

Теперь количество параметров перестаёт быть абстракцией.

Оно становится физической задачей хранения.

Предположим, модель содержит:

параметров.

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

Предположим, каждый параметр хранится в шестнадцати битах.

Шестнадцать бит равны:

Тогда примерный объём хранения самих параметров:

что даёт:

или примерно:

Откуда взялись эти шестнадцать гигабайтов?

Никакой загадки.

У нас восемь миллиардов чисел.

Каждому нужно два байта.

Восемь миллиардов умножить на два — примерно шестнадцать миллиардов байтов.

Теперь рассмотрим модель с семьюдесятью миллиардами параметров при той же точности.

Расчёт такой:

что даёт примерно:

только на хранение самих параметров.

Внезапно:

«Модель 70B»

уже не просто название модели.

Это задача для оборудования.

Ваша GPU начинает интересоваться.

Ваша системная RAM тоже может заинтересоваться.

В конце концов заинтересуется ваш кошелёк.

Квантование: что именно мы уменьшаем?

Предположим, шестнадцать бит на параметр требуют слишком много памяти.

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

В этом основная идея квантования.

Возьмём нашу условную модель 8B.

При шестнадцати битах на параметр идеализированный объём хранения самих параметров составляет примерно:

Теперь предположим, что многие веса мы представляем примерно четырьмя битами.

Четыре бита — это половина байта:

Значит:

даёт примерно:

Важно то, чего не произошло.

Мы не превратили модель с восемью миллиардами параметров в модель с двумя миллиардами.

У модели по-прежнему примерно столько же параметров.

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

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

Можно хранить:

или:

Второе число менее точное.

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

Но главный физический компромисс остаётся:

меньше бит на вес → меньше памяти

Вот почему пользователи локального ИИ проводят удивительно большую часть жизни в спорах о Q4, Q5, Q6 и Q8.

Со стороны это похоже на разговор о моторном масле.

Обычно речь идёт о том, как вместить миллиарды чисел в видеокарту.

Веса — не активации

При разговоре об оборудовании ещё одно различие чрезвычайно важно.

Веса сохраняются.

Они хранятся как часть модели.

Выключите компьютер.

Завтра загрузите ту же модель.

Обученные веса останутся.

Активации временны.

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

Эти значения зависят от текущих входных данных.

Измените запрос — и активации изменятся.

Представьте фабрику.

Веса — это установленное оборудование.

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

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

Самому вычислению нужно рабочее пространство.

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

С ростом контекста этот кэш тоже может расти.

Поэтому:

Веса помещаются в VRAM

не означает автоматически:

Модель может комфортно работать в этой VRAM.

Диван может пройти в дверь квартиры.

Но вам всё-таки хотелось бы иметь место, где стоять.

Меняются ли веса, пока вы разговариваете с моделью?

Обычно:

Нет.

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

Инференс означает:

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

Веса считываются.

Обычно их не переписывают из-за того, что вы задали вопрос.

И это к счастью.

Иначе одного достаточно странного разговора хватило бы, чтобы навсегда перестроить сеть.

Разговор создаёт временное состояние: контекст, активации, KV cache, результаты инструментов и другую рабочую информацию.

Это не то же самое, что сохраняющиеся обученные параметры.

Самое простое объяснение:

Обучение меняет веса. Инференс использует веса.

Это предложение объясняет невероятно многое в ИИ.

Дообучение: снова меняем числа

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

Этот процесс называется дообучением.

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

Её можно дообучить на:

юридических материалах,

медицинской терминологии,

примерах программирования,

разговорах службы поддержки,

финансовом анализе,

или другой специализированной области.

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

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

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

Практическое различие важно.

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

Дообучение меняет обученные параметры.

Одно даёт временную информацию.

Другое меняет обученную модель.

Модель — это не вся система

Предположим, два человека скачивают совершенно одинаковую модель.

Один и тот же контрольный снимок.

Те же веса.

То же квантование.

Один создаёт отличную исследовательскую систему.

У другого получаются ненадёжные ответы с красивым оформлением.

Как такое возможно?

Потому что модель — лишь один компонент.

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

Эту окружающую программу иногда называют обвязкой, или агентской средой.

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

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

Те же веса.

Другая среда.

Другое поведение.

Двигатель может быть одинаковым.

Автомобиль — не обязательно.

Что такое модель с открытыми весами?

Во время обучения параметры постоянно меняются.

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

Такое сохранённое состояние называется контрольным снимком, или checkpoint.

По сути, это снимок обученного числового состояния модели в определённый момент.

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

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

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

Открытые веса не означают автоматически открытый исходный код.

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

Лицензии тоже могут налагать ограничения.

Поэтому это два разных вопроса:

Могу ли я скачать обученные веса?

и:

Открыт ли весь процесс разработки модели?

Ответы могут быть разными.

Слова имеют значение.

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

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

Обучение мощной базовой модели с нуля может требовать огромных ресурсов:

данных, кластеров GPU, электричества, инженерной работы, времени и денег.

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

Вы получаете обученное числовое состояние.

Вам не нужно повторять всё образование.

Исследователям это даёт возможность изучения.

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

Организациям это может дать больше контроля.

А для любителей и технически любопытных пользователей появляется нечто, ещё недавно звучавшее невероятно:

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

Обучающий кластер может занимать дата-центр.

Готовый контрольный снимок может оказаться на SSD под вашим столом рядом с тремя USB-кабелями, которые никто не помнит, как покупал.

Неплохое путешествие для тензора.

Чем веса не являются

После всего этого несколько заблуждений проще устранить.

Веса — не база данных.

В них нет строки:

capital_of_france = Paris

Отдельный вес обычно не является понятием, понятным человеку.

Найти:

внутри тензора — само по себе почти ничего вам не скажет.

Обычно веса не меняются при обычном инференсе.

Обучение их изменяет.

Инференс их использует.

Один вес обычно не равен одному признаку.

Смысл распределён по множеству параметров и слоёв.

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

Архитектура важна.

Обучающие данные важны.

Оптимизация важна.

Обучение после основного этапа важно.

Обработка контекста важна.

Окружающая среда важна.

Идиот с восемьюдесятью миллиардами параметров всё равно останется идиотом.

Просто ему понадобится более дорогая GPU.

Веса и параметры

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

В обычном разговоре это, как правило, нормально.

Технически параметр — более широкое понятие.

Веса — это параметры.

Смещения, значения нормализации и другие обучаемые значения тоже могут быть параметрами.

Поэтому, когда кто-то говорит:

«Это модель 70B»,

более точный смысл такой:

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

Большинство этих параметров находятся внутри больших обученных матриц.

Люди продолжат называть их весами.

Цивилизация, скорее всего, переживёт.

Что значит, когда мы говорим, что модель что-то «знает»?

Теперь математика начинает соприкасаться с философией.

В языковой модели нет миниатюрного библиотекаря, который ищет факты на полках.

Внутри Transformer не спрятана крошечная база SQL.

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

Спросите:

Столица Франции —

и обученная сеть сильно предпочтёт:

Париж.

Попросите код на Python — и появится другой рисунок внутренней активности.

Спросите об истории Средневековья — ещё один.

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

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

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

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

Наверное, лучше заняться им после ужина.

Вся история в двух схемах

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

Обычными словами:

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

Обучение добавляет второй цикл:

Обычными словами:

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

Затем повторите.

И повторите.

И повторите.

Или в самой короткой технически полезной версии:

Инференс использует числа. Обучение меняет числа.

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

Правда, эти четыре темы обеспечили работой немало исследователей.

Почему это важно, даже если вы никогда ничего не обучаете

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

И это нормально.

Большинство водителей тоже не вытачивают собственные коленвалы.

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

Почему модель 8B занимает несколько гигабайтов?

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

Почему Q4 требует гораздо меньше памяти, чем шестнадцатибитная точность?

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

Почему квантование может немного менять поведение?

Потому что изменилась числовая точность.

Почему дообучение может изменить модель?

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

Почему загрузка PDF не учит модель навсегда?

Потому что PDF меняет текущий контекст, а не сохраняющиеся веса.

Почему две системы с одинаковыми весами модели могут вести себя совершенно по-разному?

Потому что модель — лишь одна часть окружающей её среды.

И почему вообще можно скачать обученную модель ИИ?

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

Идея началась с крошечных математических нейронов.

Затем появились обучаемые перцептроны.

Обратное распространение ошибки сделало многослойное обучение практичным.

GPU дали невероятный объём параллельной арифметики.

Трансформеры переустроили обработку языка.

Количество параметров выросло от миллионов до миллиардов и дальше.

Масштаб изменился почти до неузнаваемости.

Главный цикл остался удивительно узнаваемым:

Сделай предсказание.

Измерь ошибку.

Вычисли, что должно измениться.

Немного измени числа.

Попробуй снова.

Повторяйте это достаточно раз, с достаточным количеством данных, математики, оборудования и электричества —

и в конце концов числа начинают отвечать.