Параметры и размер модели

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

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

Зачем вообще считать эти миллиарды

Ты наверняка видел заголовки вроде «новая модель на 405 миллиардов параметров» или «крошечная модель всего на 3 миллиарда работает прямо в телефоне». Звучит внушительно, но что эти числа реально означают? Это как сказать «у машины 600 лошадиных сил» — цифра что-то обещает, но сама по себе не делает тебя чемпионом гонки.

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

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

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

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

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

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

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

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

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

Откуда берётся столько ручек

Вспомни нейросеть из урока про слои. Каждый нейрон одного слоя соединён с нейронами следующего слоя, и у каждой связи свой вес. Посчитаем на маленьком примере. Если в одном слое 1000 нейронов, и в следующем тоже 1000, то связей между ними: 1000 × 1000 = 1 000 000. Уже миллион параметров на одной паре слоёв! А в больших моделях таких слоёв десятки, и нейронов в них куда больше тысячи.

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

Считаем масштаб на пальцах

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

// Сколько времени крутить ручки модели по одной в секунду
const sizes = {
  "маленькая (телефон)": 3_000_000_000,    // 3 млрд
  "средняя": 70_000_000_000,               // 70 млрд
  "очень большая": 400_000_000_000         // 400 млрд
};

const secondsInYear = 60 * 60 * 24 * 365;

for (const name in sizes) {
  const params = sizes[name];
  const years = params / secondsInYear;
  console.log(name + ": " + params.toLocaleString("ru-RU") + " параметров");
  console.log("  по 1 в секунду это ~" + Math.round(years) + " лет");
}

Вывод:

маленькая (телефон): 3 000 000 000 параметров
  по 1 в секунду это ~95 лет
средняя: 70 000 000 000 параметров
  по 1 в секунду это ~2 220 лет
очень большая: 400 000 000 000 параметров
  по 1 в секунду это ~12 683 лет

Разберём по шагам. Объект sizes хранит три модели и число их параметров (символ _ внутри числа в JavaScript — просто разделитель для читаемости, на значение он не влияет). Мы считаем, сколько секунд в году, а потом для каждой модели делим число параметров на это значение. Метод toLocaleString("ru-RU") расставляет пробелы в больших числах, чтобы их было легче читать.

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

Параметры — это не объём прочитанного текста

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

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

Есть и третье число, которое тоже путают с первыми двумя, — размер файла модели на диске. Он связан с числом параметров, но не равен ему. Грубо: один параметр обычно хранят как число в 2 байта. Значит, модель на 7 миллиардов параметров весит примерно 14 гигабайт — как большая игра. Но инженеры умеют сжимать веса, огрубляя их до 1 байта и меньше; тогда тот же файл усыхает вдвое и больше, а число параметров при этом не меняется ни на одну ручку. Так что «параметры», «прочитанные данные» и «вес файла» — три разных числа, и смешивать их не стоит.

Наши сквозные примеры через призму параметров

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

Кошка против собаки

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

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

«Кошка пьёт ...»

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

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

Больше — не всегда лучше

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

Вот почему гонка за параметрами имеет предел:

• Деньги и энергия. Каждый параметр надо хранить и тысячи раз пересчитывать при обучении. Чем их больше, тем дороже обучение и тем больше видеокарт оно требует.
• Скорость ответа. Большая модель отвечает медленнее. Маленькая модель на 3 миллиарда параметров может работать прямо в твоём телефоне без интернета, а гигантская — только на сервере.
• Переобучение. Если у модели слишком много ручек, а данных мало, она начинает зубрить примеры вместо того, чтобы понимать суть.

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

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

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

Частые ошибки и подводные камни

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

• «Параметры = размер файла модели». Связь есть, но это не одно и то же. Один параметр обычно занимает 2 байта, и его ещё можно сжимать. Число параметров — про устройство модели, а размер файла — про то, как её упаковали для хранения.
• «Параметры = объём прочитанного интернета». Нет. Это две разные величины, мы разбирали их в таблице выше: ручки внутри модели против количества прочитанного текста.
• «Чем больше параметров, тем умнее». Не всегда. Качество данных, способ обучения и тот самый RLHF влияют не меньше. Большая модель на плохих данных проиграет аккуратной маленькой.
• «Один параметр хранит один факт». Нет. Знания размазаны по тысячам весов сразу, и один и тот же параметр участвует в куче разных ответов. Нельзя ткнуть в ручку и сказать «вот тут живёт слово кошка».
• «Модель сама добавляет себе параметры, когда узнаёт новое». Нет. Число ручек задаётся заранее, до обучения, и не меняется. Обучение только крутит уже существующие ручки, а не приделывает новые.

Мини-практика: прикинь свою модель

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

// Размеры слоёв нашей учебной модели (число нейронов)
const layers = [4, 8, 8, 2];

let total = 0;

// Подсказка: связи между слоем i и i+1 это layers[i] * layers[i+1]
for (let i = 0; i < layers.length - 1; i++) {
  const between = layers[i] * layers[i + 1];
  console.log("Слой " + i + " -> " + (i + 1) + ": " + between + " связей");
  total = total + between;
}

console.log("Всего параметров: " + total);

Вывод:

Слой 0 -> 1: 32 связей
Слой 1 -> 2: 64 связей
Слой 2 -> 3: 16 связей
Всего параметров: 112

Когда разберёшься, попробуй сам поиграть: поменяй массив layers, например на [1000, 1000, 1000], и посмотри, как быстро total прыгает в миллионы. Так ты ногами почувствуешь, почему миллиарды набираются легко. Это та же арифметика «каждый с каждым», что и в реальных моделях, — просто у них слои шире и их больше.

Итоги и переход дальше

Соберём всё в одну картину:

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

Теперь у тебя есть чувство масштаба: ты знаешь, что прячется за фразой «модель на 70 миллиардов параметров». Но мы пока говорили о ручках вообще, не заглядывая внутрь самой умной части ChatGPT. В следующих уроках раздела мы разберём трансформер и механизм внимания — то, как модель решает, на какие слова в «Кошка пьёт ...» смотреть внимательнее, чтобы достроить фразу правильно. Именно там миллиарды наших параметров наконец-то складываются в осмысленный ответ.