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

Неофициальный курс AI University по открытому коду (MIT). В уроке приводится код из karpathy/micrograd © Andrej Karpathy, лицензия MIT; комментарии переведены на русский, объяснения написаны нашей командой. Курс не связан с автором кода и не одобрен им.

Откуда взялся этот курс

Курс «Нейросети с нуля: по открытому коду Андрея Карпати» написан командой AI University на основе четырёх открытых репозиториев: micrograd, makemore, nanoGPT и minbpe. Все они распространяются по лицензии MIT, которая разрешает брать код, изменять его и объяснять в образовательных целях. Мы пользуемся именно этим правом: цитируем оригинальные файлы, переводим комментарии на русский и дополняем код собственными примерами.

Важное уточнение: курс неофициальный. Мы не связаны с Андреем Карпати, и он не проверял и не одобрял эти материалы. Сам Карпати, если нужен контекст: исследователь, один из основателей OpenAI, в разное время руководил направлением искусственного интеллекта в Tesla. Нас в этом курсе интересует не биография, а код, который он выложил в открытый доступ, и то, чему по нему можно научиться.

Что вы соберёте за 16 уроков

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

micrograd (уроки 2-4): движок автоматического дифференцирования на скалярных числах, ядро которого умещается примерно в 100 строк. Вы увидите, как из отдельных арифметических операций строится граф вычислений, и как по этому графу обратным проходом считаются градиенты. На этом же движке вы соберёте нейрон, слой и целую сеть, и обучите её на игрушечной задаче.

makemore (уроки 5-8): набор символьных языковых моделей, обучаемых на списке имён. Здесь градиенты уже не самодельные, а PyTorch-овские, зато появляется то, без чего не обходится ни одна языковая модель: вероятностное распределение над следующим символом. Вы пройдёте путь от простой биграммной модели до MLP с эмбеддингами, разберётесь, почему инициализация весов и нормализация активаций критически важны для обучения, и в конце соберёте иерархическую архитектуру, которая читает контекст не целиком, а слоями, как это делает WaveNet.

nanoGPT (уроки 9-13): компактная, но полноценная реализация GPT на PyTorch. Здесь вы разберёте self-attention с нуля, соберёте блок трансформера и модель целиком, запустите обучение и генерацию текста, а в конце посмотрите, как те же компоненты масштабируются от игрушечной модели до GPT-2.

minbpe (уроки 14-15): токенизатор на основе byte pair encoding. Формально это последний репозиторий в списке, но по смыслу он стоит в начале любого конвейера: прежде чем текст попадёт в трансформер, его нужно превратить в последовательность токенов. Вы разберёте, как устроен алгоритм BPE, и соберёте собственный токенизатор с поддержкой регулярного разбиения текста и специальных токенов.

Если смотреть на всё это как на одну линию: сначала вы учитесь считать градиенты (micrograd), затем используете их для языкового моделирования (makemore), затем заменяете простую архитектуру на трансформер с вниманием (nanoGPT), и наконец разбираетесь, как устроен первый шаг любого языкового пайплайна: разбиение текста на токены (minbpe).

Что нужно знать заранее

Курс продвинутый, и мы не будем останавливаться на основах Python или линейной алгебры. Понадобится:

Уверенный Python: классы и объекты, магические методы вроде __add__ и __mul__, списковые выражения (list comprehensions), работа с функциями как с объектами первого класса.
Математика на уровне numpy: векторы и матрицы, умножение матриц, производная и частная производная, логарифм и экспонента, понятие вероятностного распределения.
Желателен, но не обязателен опыт работы с тензорами PyTorch: мы будем напоминать нужные операции по ходу курса, когда они впервые встретятся.

Если какой-то из этих пунктов вызывает сомнение, не страшно: в первых уроках математика и код будут простыми, сложность будет нарастать постепенно.

Как подготовить рабочее место

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

Вариант 1: локальный запуск (рекомендуется)

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

python -m venv neurozero
source neurozero/bin/activate   # на Windows: neurozero\Scripts\activate
pip install torch numpy matplotlib jupyter tiktoken regex

Библиотеки tiktoken и regex понадобятся позже, в уроках про токенизацию, но удобнее поставить их сразу.

Репозитории клонируются обычной командой git:

git clone https://github.com/karpathy/micrograd.git
git clone https://github.com/karpathy/makemore.git
git clone https://github.com/karpathy/nanoGPT.git
git clone https://github.com/karpathy/minbpe.git

Для работы с кодом и графиками удобен Jupyter:

jupyter lab

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

python train.py config/train_shakespeare_char.py --device=cpu --compile=False \
  --eval_iters=20 --log_interval=1 --block_size=64 --batch_size=12 \
  --n_layer=4 --n_head=4 --n_embd=128 --max_iters=2000 \
  --lr_decay_iters=2000 --dropout=0.0

Если у вас Mac с процессором Apple Silicon (M1, M2, M3 и так далее), вместо --device=cpu попробуйте --device=mps: это задействует встроенный GPU и заметно ускорит обучение.

Вариант 2: Google Colab

Colab даёт бесплатный доступ к GPU и избавляет от локальной настройки. Но у этого варианта есть два ограничения, которые стоит знать заранее: из России Colab может быть недоступен без VPN, и для работы с ним обязательно нужен Google-аккаунт. По этой причине в курсе мы ориентируемся на локальный запуск как основной путь, а Colab упоминаем как опцию для тех, у кого есть к нему доступ.

Вариант 3: облачный сервер с GPU

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

Как устроен каждый урок

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

Сначала идёт объяснение понятия или механизма своими словами, обычно с опорой на то, что вы уже знаете. Затем мы показываем фрагмент оригинального кода из одного из четырёх репозиториев: такие блоки всегда начинаются пометкой вида «# Фрагмент: micrograd/micrograd/engine.py» и содержат код, скопированный дословно, с переведёнными на русский комментариями. Дальше идут наши собственные примеры, которые мы пишем специально для урока: они начинаются строкой «# Наш пример» и всегда рабочие, их можно скопировать и запустить. В конце урока раздел «Попробуйте сами» с заданиями, а после текста урока мы добавляем ссылку на исходный файл на GitHub и на оригинальное видео Карпати как на первоисточник.

Разогрев: класс Value

Чтобы почувствовать стиль кода, с которым вы будете работать, взгляните на самое начало файла engine.py из micrograd. Подробный разбор будет в следующем уроке, а пока просто обратите внимание на то, как компактно устроен класс.

# Фрагмент: micrograd/micrograd/engine.py

class Value:
    """ хранит одно скалярное значение и его градиент """

    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0
        # внутренние переменные для построения графа автоматического дифференцирования
        self._backward = lambda: None
        self._prev = set(_children)
        self._op = _op # операция, породившая этот узел: для graphviz, отладки и т. п.

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')

        def _backward():
            self.grad += out.grad
            other.grad += out.grad
        out._backward = _backward

        return out

Здесь всего два метода, но в них уже видна вся идея курса: обычное число data оборачивается в объект, который помнит, из чего он получен (_prev, _op), и знает, как передать свой градиент назад тем узлам, из которых он был построен (_backward). Именно эта простая конструкция, повторённая для сложения, умножения, возведения в степень и ReLU, и есть автоматическое дифференцирование. В следующем уроке мы разберём её по частям.

Попробуйте сами

Настройте окружение. Создайте виртуальное окружение, установите torch, numpy, matplotlib, jupyter, tiktoken, regex. Убедитесь, что всё работает, запустив:
```
# Наш пример
import torch
print(torch.__version__)
x = torch.tensor([1.0, 2.0, 3.0])
print(x.sum().item())
```
Критерий успеха: код выполняется без ошибок и печатает версию PyTorch и число 6.0.
Склонируйте micrograd и запустите его тесты. Установите pytest (pip install pytest), склонируйте репозиторий и из его корня выполните:
```
python -m pytest test
```
Критерий успеха: все тесты проходят (строка вида «N passed»). Если тесты падают с ошибкой импорта, проверьте, что вы находитесь в корневой папке репозитория и что в ней есть файл setup.py или pyproject.toml: иногда пакет нужно доустановить командой pip install -e ..
Проверьте производную вручную и численно. Возьмите функцию f(x) = x² + 3x. Посчитайте на бумаге производную ∂f/∂x в точке x = 2 аналитически (через правило дифференцирования степенной функции), а затем проверьте результат численно с маленьким h:
```
# Наш пример
def f(x):
    return x**2 + 3*x

x = 2.0
h = 1e-6
numeric_grad = (f(x + h) - f(x)) / h
print(numeric_grad)  # должно быть близко к аналитическому значению
```
Критерий успеха: численная оценка производной отличается от вашего аналитического ответа не более чем на 0.001. Подсказка: аналитическая производная f(x) = x² + 3x равна 2x + 3.

Итоги

Курс неофициальный и написан по открытому коду под лицензией MIT: мы объясняем и дополняем код Карпати, но не связаны с ним и не получали его одобрения.
Маршрут курса идёт от скалярных градиентов (micrograd) через символьные языковые модели (makemore) к трансформеру (nanoGPT) и токенизации (minbpe), каждая часть опирается на предыдущую.
Для курса нужен уверенный Python, базовая математика (производные, матрицы, вероятности) и желательно знакомство с тензорами PyTorch.
Основной способ работы с курсом: локальное окружение на Python 3.10+ с PyTorch, остальные варианты (Colab, облачный сервер) доступны, но требуют дополнительных условий.
Каждый урок построен одинаково: объяснение, фрагмент оригинального кода с переводом комментариев, собственный рабочий пример, задания «Попробуйте сами» и ссылки на источники.
Вы уже видели первый фрагмент кода, класс Value: его подробный разбор начнётся в следующем уроке.

Первоисточники

Первоисточник: видео Андрея Карпати (на английском): Neural Networks: Zero to Hero (плейлист)
Код урока на GitHub: github.com/karpathy/micrograd, github.com/karpathy/makemore, github.com/karpathy/nanoGPT, github.com/karpathy/minbpe

Видео приведены только как ссылки на первоисточник; текст урока не является их переводом или пересказом. Полные тексты лицензий: в уроке «Что дальше, лицензии и источники».

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