Почему нужно много данных и видеокарт

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

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

Зачем вообще столько данных и железа

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

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

К концу урока ты будешь понимать, почему фразу «мы обучили модель на миллиардах текстов и потратили на это месяцы работы тысяч видеокарт» не стоит воспринимать как маркетинговое преувеличение. Это честная цена за то, чтобы машина перестала зубрить и начала обобщать.

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

Данные: почему десяти картинок мало

Вернёмся к кошкам и собакам

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

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

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

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

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

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

Текстовый пример: «Кошка пьёт ...»

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

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

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

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

Каждый пример — это куча умножений

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

Теперь главное: при обучении сеть прогоняет через себя КАЖДЫЙ пример, смотрит, насколько ошиблась, и чуть-чуть подкручивает все веса. И так не один раз, а десятки раз по всему набору данных. Перемножь в голове: миллиарды связей × миллионы примеров × десятки повторов. Получаются астрономические числа операций.

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

// Грубая прикидка: сколько умножений в обучении
const svyazi = 1000000;        // связей в небольшой сети (1 млн)
const primery = 50000;         // обучающих картинок (50 тыс.)
const povtory = 20;            // сколько раз прогоняем весь набор

// при каждом показе примера задействованы все связи
const operacii = svyazi * primery * povtory;

console.log("Связей:", svyazi.toLocaleString("ru-RU"));
console.log("Примеров:", primery.toLocaleString("ru-RU"));
console.log("Повторов:", povtory);
console.log("Всего операций:", operacii.toLocaleString("ru-RU"));

Вывод:

Связей: 1 000 000
Примеров: 50 000
Повторов: 20
Всего операций: 1 000 000 000 000

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

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

Почему обычный процессор не справляется

В компьютере есть процессор (CPU) — это как очень умный отличник, который решает задачи по одной, но каждую — блестяще и быстро. Проблема в том, что наших задач-умножений триллионы, а делать их по очереди — это как мыть посуду после праздника одной тарелкой за раз. Технически возможно, но ты состаришься.

Видеокарты: армия середнячков вместо одного гения

Что такое GPU и почему он тут главный

Видеокарта (по-английски GPU, graphics processing unit — «графический процессор») изначально придумана для игр: чтобы рисовать картинку на экране, нужно одновременно посчитать цвет миллионов точек-пикселей. Это куча одинаковых простых вычислений, которые удобно делать параллельно.

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

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

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

Грубая прикидка времени

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

// Сравним время на CPU и GPU (очень грубо)
const operacii = 1000000000000;   // тот самый триллион операций

const cpuVSekundu = 50000000000;  // CPU: ~50 млрд операций/сек
const gpuVSekundu = 5000000000000; // GPU: ~5 трлн операций/сек

const sekundCPU = operacii / cpuVSekundu;
const sekundGPU = operacii / gpuVSekundu;

console.log("На CPU, секунд:", sekundCPU);
console.log("На GPU, секунд:", sekundGPU);
console.log("GPU быстрее в", sekundCPU / sekundGPU, "раз");

Вывод:

На CPU, секунд: 20
На GPU, секунд: 0.2
GPU быстрее в 100 раз

Двадцать секунд против пятой доли секунды — на нашем игрушечном примере. А теперь представь, что операций не триллион, а в миллион раз больше. На CPU обучение растянулось бы на годы, а на ферме из видеокарт укладывается в недели. Вот почему компании вроде той, что делает ChatGPT, скупают видеокарты тысячами и строят под них целые дата-центры.

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

Связь объёма вычислений и качества

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

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

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

Тут уместно сравнение с прокачкой персонажа в игре. Поднять уровень с 1-го до 2-го легко: пара боёв — и готово. А вот докинуть последний уровень до максимума требует в разы больше опыта, чем все предыдущие вместе взятые. С моделями так же: выжать ещё пару процентов качества из и без того сильной модели стоит в разы дороже, чем сделать слабую модель приличной. Поэтому за каждым крошечным шагом вперёд в мире ИИ стоят гигантские вложения, которые большинству из нас даже трудно вообразить.

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

Частые ошибки и заблуждения

• «Больше данных всегда лучше». Не совсем. Важно не только количество, но и разнообразие и чистота. Миллион почти одинаковых фоток рыжих котов хуже, чем тысяча РАЗНЫХ кошек. Мусорные или однотипные данные не спасают от переобучения.

• «Видеокарта умнее процессора». Нет. GPU не умнее, он просто умеет делать много простых вещей разом. На сложной логике по шагам обычный процессор его обгонит. Это разные инструменты под разные задачи.

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

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

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

Мини-практика: посчитай свою ферму

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

// Твоя задача: посчитать время обучения на ферме видеокарт
const operacii = 100000000000000000; // 100 квадриллионов операций (большая модель)
const gpuVSekundu = 5000000000000;   // одна видеокарта: 5 трлн операций/сек

// 1) сколько секунд на ОДНОЙ видеокарте?
const sekundOdna = operacii / gpuVSekundu;
console.log("На 1 видеокарте, секунд:", sekundOdna);

// 2) ДОБАВЬ переменную kolvoGPU = 1000 и посчитай время на ферме
// 3) переведи результат в дни и выведи через console.log

Подсказки: чтобы получить дни, раздели секунды на 60 (минуты), потом на 60 (часы), потом на 24 (дни). Сравни, во сколько раз тысяча видеокарт ускоряет дело против одной — и ты на пальцах почувствуешь, зачем нужны дата-центры. Попробуй менять количество видеокарт и смотреть, как меняется ответ.

Итоги

• Нейросети нужны тысячи и миллионы примеров, иначе они зубрят, а не учатся обобщать (переобучение).
• Каждый пример прогоняется через все связи много раз — отсюда астрономическое число вычислений.
• Видеокарты (GPU) делают тысячи простых умножений одновременно, поэтому обгоняют обычные процессоры в десятки и сотни раз.
• Больше данных, весов и вычислений — обычно умнее модель, но каждый шаг вверх стоит резко дороже.
• Это не делает ИИ «разумным»: масштаб даёт точность, а не сознание.

Мы разобрались, ИЗ ЧЕГО состоит сеть и НА ЧЁМ её обучают. Но мы всё ещё работали с картинками и отдельными словами как с набором чисел «в лоб». Дальше начинается самое интересное: как превратить слово «кошка» в точку в пространстве смыслов, чтобы похожие слова лежали рядом. В следующих уроках мы займёмся эмбеддингами и токенами — и наш пример «Кошка пьёт ...» заиграет новыми красками.