Что значит «модель учится на данных»

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

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

В прошлом уроке мы разобрались, что ИИ — это не «электронный мозг», а программа, которая решает задачи вроде распознавания или перевода. Но осталась загадка: как именно эта программа становится умной? Сегодня мы откроем главный секрет. Спойлер: её никто не программирует «быть умной». Она тренируется. Как ты — перед контрольной.

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

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

Первое правило, которое приходит в голову: «У кошек острые треугольные уши». Отлично. Но у чихуахуа уши тоже острые и треугольные. А у вислоухого шотландского кота ушей-треугольников вообще нет. Правило сломалось на первом же исключении.

Окей, добавим: «У кошек усы». У собак тоже усы. «Кошки меньше». А чихуахуа меньше кошки. «У кошек морда такой-то формы»... и тут ты понимаешь, что не можешь словами описать «форму кошачьей морды» так, чтобы это работало для всех пород, ракурсов, освещения и котят-уродцев из мемов.

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

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

Два мира: программа-по-правилам и программа-по-примерам

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

Способ первый: диктовать правила

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

Способ второй: показывать примеры

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

Машинное обучение работает по второму способу. И теперь нам нужно ввести три ключевых слова, которыми этот способ описывают.

Когда мы показываем модели примеры вместе с метками (с правильными ответами), это называется обучением с учителем. «Учитель» здесь — это и есть метки: они говорят модели, где она права, а где ошиблась.

Как модель на самом деле «учится»: метафора подбора громкости

Самый частый вопрос: окей, модель смотрит на примеры — но что внутри неё меняется? Ведь «учиться» — это что-то менять в себе.

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

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

1. Модель смотрит на фото и делает догадку — например, «собака».
2. Мы сверяемся с меткой: а там написано «кошка». Ошибка!
3. Модель чуть-чуть подкручивает свои ручки-веса в сторону, которая в следующий раз даст ответ ближе к «кошке».
4. Берём следующее фото. И ещё. И ещё — тысячи раз.

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

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

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

Те же два примера, но в цифрах

Давай уйдём от картинок к простым числам — так видно сам механизм. Каждое животное опишем парой признаков (признак — это отдельная измеримая характеристика объекта, по которой принимается решение). Возьмём «остроту ушей» и «громкость звука» по шкале от 0 до 10.

// Обучающие данные: [острота ушей, громкость, метка]
// метка: "кошка" или "собака"
const данные = [
  [8, 3, "кошка"],   // острые уши, тихая
  [9, 2, "кошка"],
  [7, 4, "кошка"],
  [3, 8, "собака"],  // мягкие уши, громкая
  [2, 9, "собака"],
  [4, 7, "собака"],
];

// "Обучение": найдём среднюю остроту ушей у кошек и у собак.
// Это очень наивная модель, но идея та же — закономерность из данных.
let суммаКошек = 0, числоКошек = 0;
let суммаСобак = 0, числоСобак = 0;

for (const [уши, громкость, метка] of данные) {
  if (метка === "кошка") { суммаКошек += уши; числоКошек++; }
  else { суммаСобак += уши; числоСобак++; }
}

const центрКошек = суммаКошек / числоКошек;
const центрСобак = суммаСобак / числоСобак;

console.log("Средняя острота ушей у кошек:", центрКошек);
console.log("Средняя острота ушей у собак:", центрСобак);

Вывод:

Средняя острота ушей у кошек: 8
Средняя острота ушей у собак: 3

Смотри, что произошло. Мы нигде не написали правило «острота 8 — это кошка». Программа сама вычислила из данных, что у кошек острота ушей в среднем около 8, а у собак около 3. Это и есть микро-версия обучения: закономерность пришла из примеров, а не из нашей головы.

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

const центрКошек = 8;
const центрСобак = 3;

function предсказать(остротаУшей) {
  // К какому центру новое животное ближе — туда и относим.
  const доКошки = Math.abs(остротаУшей - центрКошек);
  const доСобаки = Math.abs(остротаУшей - центрСобак);
  return доКошки < доСобаки ? "кошка" : "собака";
}

console.log("Уши 7 →", предсказать(7));
console.log("Уши 4 →", предсказать(4));
console.log("Уши 9 →", предсказать(9));

Вывод:

Уши 7 → кошка
Уши 4 → собака
Уши 9 → кошка

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

А что с текстом? Тот же принцип

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

// "Данные": фразы, которые модель как будто прочитала
const фразы = [
  "Кошка пьёт молоко",
  "Кошка пьёт воду",
  "Кошка пьёт молоко из миски",
  "Собака пьёт воду",
  "Кошка пьёт молоко тёплое",
];

// Считаем, что идёт после "пьёт" именно у фраз про кошку
const счётчик = {};
for (const фраза of фразы) {
  const слова = фраза.split(" ");
  for (let i = 0; i < слова.length - 1; i++) {
    if (слова[i] === "пьёт" && слова[0] === "Кошка") {
      const следующее = слова[i + 1];
      счётчик[следующее] = (счётчик[следующее] || 0) + 1;
    }
  }
}

console.log("Что кошка пьёт (по данным):", счётчик);

Вывод:

Что кошка пьёт (по данным): { 'молоко': 3, 'воду': 1 }

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

Где это работает прямо в твоём телефоне

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

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

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

1. «Раз модель учится сама — данные неважны»

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

Есть даже короткая поговорка инженеров: «мусор на входе — мусор на выходе». Сколько ни настраивай ручки-веса, если в примерах были одни рыжие коты, модель выучит «кошка = рыжая», а не «кошка = кошка». И виновата будет не она — виноваты данные, которые мы ей дали.

2. Путать обучение с запоминанием

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

3. Думать, что больше примеров всегда лучше

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

4. Считать, что модель «понимает» смысл

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

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

Если показать модели тысячу фото без подписей «кошка/собака», обучение с учителем не сработает — учить-то по чему? Метка (правильный ответ) — обязательная часть этого способа обучения. Без неё модель не знает, права она или нет.

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

Возьми код с подсчётом центров и расширь его. Сейчас модель смотрит только на один признак — остроту ушей. Попробуй сам:

1. Добавь в обучение второй признак — громкость. Посчитай средний центр отдельно по ушам и отдельно по громкости для кошек и для собак.
2. Перепиши функцию предсказать так, чтобы она принимала два числа — остроту ушей и громкость — и сравнивала расстояние сразу по обоим признакам (сложи разницы по ушам и по громкости).
3. Проверь на новом животном: уши 6, громкость 5. Кто получится? Подумай, почему ответ именно такой, и что будет, если громкость поднять до 9.

Подсказка: расстояние по двум признакам можно прикинуть как Math.abs(уши - центрУшей) + Math.abs(громкость - центрГромкости). Это уже почти настоящий классификатор — он работает ровно по той идее, что мы разобрали.

Итоги

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

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