Ваша лаборатория (4×GPU)

У вас машина, на которой можно пройти весь курс без облаков. Ступени 0–3 идут на процессоре, а с 4-й видеокарты превращают «учебные игрушки» в настоящие эксперименты: свою LLM, LoRA на 7–14B-моделях, GRPO и сервер с моделью уровня 70B в 4-битном квантовании.

Ваше железо и что оно значит

Компонент	Что у вас	Что это значит для ИИ
GPU	4× NVIDIA RTX 4080, 32 ГБ каждая	128 ГБ видеопамяти в сумме. Архитектура Ada Lovelace: BF16 и FP8 на тензорных ядрах
Связь GPU	PCIe 4.0 x16, без NVLink	Обмен между картами идёт по PCIe (~32 ГБ/с в одну сторону теоретически). На GeForce прямой обмен P2P обычно отключён драйвером, поэтому данные часто идут через память процессора
CPU	AMD EPYC 7H43, 48 ядер / 96 потоков	Быстрая подготовка данных и токенизация. Инференс больших MoE-моделей частично на CPU
RAM	128 ГБ DDR4-3200, 8 каналов	~200 ГБ/с теоретической пропускной способности. Сюда можно выгрузить часть весов огромной модели
Диски	3× Samsung 990 Pro 1 ТБ (NVMe)	Быстрая загрузка датасетов и чекпоинтов. Держите данные и чекпоинты на разных дисках

Вы в положении DeepSeek — в миниатюре

DeepSeek обучал V3 на видеокартах H800: вычислительная мощность там почти как у H100, но связь между картами урезана экспортными ограничениями. Поэтому инженеры придумали DualPipe и прятали обмен данными за вычислениями (модуль 5.4). У вас похожая ситуация: четыре мощные карты, соединённые «узким» PCIe. Многие оптимизации из китайских техотчётов вы сможете почувствовать на своём железе.

Что можно делать на каждой ступени

Ступень	На CPU (базовый путь курса)	На вашей машине (GPU-трек)
0–3. Основы	Всё: Python, NumPy, свой автоград, PyTorch на маленьких данных	GPU не обязателен. Можно сравнить скорость одного и того же обучения на CPU и GPU
4. Трансформер	GPT на ~1M параметров за минуты	GPT на 10–50M параметров на русском корпусе за десятки минут на одной карте
5. Большие модели	Крошечные эксперименты с MLA/MoE	Свой MiniMind (26–100M параметров) за часы. DDP и FSDP на 4 картах через torchrun. Опыты с FP8 (Ada поддерживает FP8)
6. Пост-трейнинг	Логика LoRA/DPO/GRPO на игрушечных моделях	LoRA и QLoRA для Qwen 7–14B. Полное дообучение моделей 0.5–1.5B. GRPO для Qwen 0.5–3B: одна карта генерирует ответы (vLLM), три обучают
7. Инференс	llama.cpp с маленькими моделями	vLLM/SGLang с тензорным параллелизмом на 4 картах: 32B в BF16 или ~70B в 4 битах. Замеры токенов/с
8. Приложения	Через API (DeepSeek, Qwen)	Свой локальный «ChatGPT» для RAG и агентов: Qwen3-30B-A3B или 32B-модели в 4 битах, эмбеддинги BGE-M3
10. Выпускной	Упрощённая версия	Полный цикл: токенизатор → претрейн → SFT → GRPO → квантование → сервер → агент

Какие открытые модели брать (октябрь 2026). Команды в уроках написаны для Qwen3 (апрель 2025): она поддерживается везде и хороша для учёбы. В тех же классах размеров есть модели новее: Qwen3.5 (от 0.8B до 9B, 27B, 35B-A3B), Qwen3.6-27B и Qwen3.6-35B-A3B, Qwen3.8-27B (QwenLM/Qwen3.8) и Gemma 4 от Google — E2B, E4B, 26B-A4B (MoE) и 31B (описание в Transformers). Qwen3.6, Qwen3.8-27B и Gemma 4 выпущены под Apache-2.0, их поддерживают vLLM и Ollama (qwen3.6, qwen3.8, gemma4). Команды курса те же, меняется имя модели; для вызова инструментов у Qwen3.5 и новее в vLLM нужен парсер qwen3_coder вместо hermes.

Оценки ориентировочные

Сколько памяти и времени нужно, зависит от длины контекста, размера батча и библиотеки. В уроках мы учимся считать это заранее (калькулятор KV-кэша и калькулятор стоимости обучения есть в лаборатории), а в уроке 11.2.1 — как прикинуть всё «на салфетке».

Сколько памяти занимают модели (только веса)

Правило: число параметров × байты на параметр.

Модель	BF16 (2 байта)	8 бит	4 бита	На вашей машине
0.5B	1 ГБ	0.5 ГБ	0.25 ГБ	легко, даже полное обучение
7–8B	14–16 ГБ	7–8 ГБ	~4 ГБ	одна карта: инференс и LoRA
14B	28 ГБ	14 ГБ	~7 ГБ	одна карта в 8/4 битах, в BF16 — две
32B	64 ГБ	32 ГБ	~16 ГБ	4 карты в BF16, одна-две в 4 битах
70B	140 ГБ	70 ГБ	~35–40 ГБ	в 4 битах на 2–4 картах

При обучении памяти нужно в разы больше, чем на одни веса: градиенты, состояния оптимизатора (Adam хранит ещё два числа на параметр) и активации. Поэтому полное обучение 7B-модели на вашей машине — уже на пределе. Для неё правильный инструмент — LoRA.

Настройка: шаг за шагом

Заметка

Эти шаги понадобятся к ступени 4. Если вы только начинаете курс, отложите их: на ступенях 0–3 хватает обычного Python.

1. Операционная система. Для нескольких GPU берите Linux (Ubuntu 22.04 или 24.04 LTS). Библиотека NCCL, через которую карты обмениваются данными при распределённом обучении, работает только на Linux.

2. Драйвер NVIDIA. Установите проприетарный драйвер (в Ubuntu: «Программы и обновления → Дополнительные драйверы» или sudo ubuntu-drivers install). Перезагрузитесь и проверьте:

   nvidia-smi

   Вы должны увидеть 4 карты, объём памяти каждой и версию драйвера.

3. Python-окружение с PyTorch. Отдельно ставить CUDA Toolkit не нужно: сборки PyTorch для Linux уже содержат нужные библиотеки CUDA.

   python3 -m venv ~/venvs/ai && source ~/venvs/ai/bin/activate
   pip install torch numpy
   python -c "import torch; print(torch.cuda.is_available(), torch.cuda.device_count(), torch.cuda.get_device_name(0))"

   Ожидаемый вывод: True 4 NVIDIA GeForce RTX 4080 (название может отличаться).

4. Топология. Посмотрите, как карты соединены между собой:

   nvidia-smi topo -m

   В таблице увидите обозначения вроде PHB, NODE или SYS: связь через PCIe и процессор. NV# означало бы NVLink, на GeForce 40-й серии его нет.

5. Проверка распределённого обмена. Сохраните скрипт ниже как ddp_check.py и запустите на всех 4 картах:

   torchrun --nproc_per_node=4 ddp_check.py

# ddp_check.py — проверка связи между GPU: all-reduce 256 МБ (то, что делает DDP на каждом шаге)
import time

import torch
import torch.distributed as dist

dist.init_process_group("nccl")
rank, world = dist.get_rank(), dist.get_world_size()
torch.cuda.set_device(rank)

x = torch.ones(64 * 1024 * 1024, device="cuda")  # 64M float32 = 256 МБ
for _ in range(3):  # прогрев
    dist.all_reduce(x)
torch.cuda.synchronize()

n = 10
t0 = time.time()
for _ in range(n):
    dist.all_reduce(x)
torch.cuda.synchronize()
dt = (time.time() - t0) / n

size = x.numel() * 4
bus_bw = size * 2 * (world - 1) / world / dt / 1e9  # «шинная» пропускная способность, как в nccl-tests
if rank == 0:
    print(f"GPU: {world}, all_reduce 256 МБ: {dt * 1000:.1f} мс, bus bandwidth ≈ {bus_bw:.1f} ГБ/с")
dist.destroy_process_group()

Запишите полученную пропускную способность в журнал. В модуле 5.4 вы сравните её с NVLink в дата-центрах (сотни ГБ/с) и поймёте, почему обмен данными так важен при обучении больших моделей.

Проверьте свою лабораторию

Команды из блоков «🖥 На вашей машине (4×GPU)» и оценки времени в уроках посчитаны по паспортным характеристикам RTX 4080 и формулам из уроков. На настоящей машине с четырьмя такими картами их ещё никто не запускал. Скрипт tools/lab_check.py из репозитория курса за несколько минут проверит, что всё настроено, измерит вашу машину и сравнит цифры с тем, что обещает курс. Отчёт нужен и вам (цифры для журнала и поправка к оценкам времени), и авторам курса: по нему они уточнят уроки.

Запускайте из корня репозитория, в окружении с PyTorch из шага 3:

cd ~/ChinaAI                      # папка с курсом; у вас путь может быть другим
source ~/venvs/ai/bin/activate    # окружение с PyTorch
python tools/lab_check.py

Скрипту нужны только Python и PyTorch. Пакеты transformers, peft, bitsandbytes, vLLM, flash-attn и Triton он проверяет, если они установлены, а если нет, так и пишет. Модели из интернета скрипт не скачивает: для тестов он создаёт маленькую Llama со случайными весами прямо в памяти.

Команда	Что делает	Сколько идёт (оценка)
python tools/lab_check.py	полная проверка: окружение, бенчмарки, all-reduce, смоук-тесты	3–10 минут
python tools/lab_check.py --quick	окружение и по одному короткому замеру, без смоук-тестов	около минуты
python tools/lab_check.py --skip-dist	без torch.distributed: пригодится, если all-reduce или DDP зависает	на пару минут меньше
python tools/lab_check.py --out ~/lab.md	сохранить отчёт в другое место	как полная
python tools/lab_check.py --json-only	напечатать только JSON, без таблиц и Markdown	как полная

Что проверяется, по порядку:

1. Окружение. ОС, Python, версии PyTorch, CUDA и драйвера. Каждая карта: память, compute capability, число SM, поддержка BF16 и подключение по PCIe (по nvidia-smi). RAM, процессор, свободное место на диске с курсом и в кэше моделей Hugging Face, версии пакетов курса.
2. Каждая карта отдельно. Умножение матриц в BF16 и FP16, пропускная способность памяти, копирование между процессором и картой, прямой обмен P2P и копирование между картами.
3. Связь между картами. All-reduce через NCCL на всех картах (то, что DDP делает на каждом шаге) для сообщений от 1 до 256 МБ. Это ddp_check.py из шага 5, только по всем размерам, с проверкой правильности суммы и с тем, каким путём NCCL передаёт данные.
4. Смоук-тесты курса. DDP и FSDP2 на всех картах: результат обязан совпасть с обучением в одном процессе. Llama в BF16 с замером токенов в секунду, LoRA, 4-битная загрузка и шаг QLoRA, FlashAttention, своё ядро на Triton, torch.compile и импорт vLLM. Каждый тест получает PASS, FAIL (с текстом ошибки и подсказкой) или SKIP (с причиной).

Таблицы печатаются в терминал, а полный отчёт сохраняется в journal/lab-report.md (его удобно читать и пересылать) и в journal/lab-report.json.

Видеокарт пока нет

Скрипт работает и без GPU: проверит окружение, DDP и FSDP на процессоре (два процесса через gloo) и маленькую Llama, а GPU-часть честно пометит как SKIP. Так окружение можно проверить заранее, ещё до ступени 4.

Как читать отчёт

Главная таблица отчёта называется «Ожидалось в курсе → у вас». Ориентиры для 4× RTX 4080 по PCIe 4.0:

Строка отчёта	Что измеряет	Ориентир	Где в курсе
Матмул BF16 и FP16, TFLOPS	скорость тензорных ядер на умножении матриц 8192×8192	паспорт 97.5; реально 68–83 (70–85% паспорта)	уроки 5.7.1, 5.7.3
Память, ГБ/с	копирование большого тензора внутри карты	паспорт 716.8; реально 570–650 (80–90%)	урок 5.7.1
CPU→GPU и GPU→CPU, ГБ/с	загрузка данных в карту по PCIe	предел PCIe 4.0 x16 около 32; на практике обычно 20–26. Около 12–13 — признак PCIe 3.0 или x8	эта страница
P2P	может ли карта читать память соседней напрямую	на GeForce обычно «нет», это нормально	урок 5.7.4
GPU→GPU, ГБ/с	копирование между двумя картами	без P2P данные идут через память процессора и обычно не быстрее, чем CPU→GPU	урок 5.7.4
all-reduce, bus bandwidth, ГБ/с	скорость синхронизации градиентов в DDP	в расчётах уроков подставлено условное W = 10; предел PCIe около 32	уроки 5.4.3, 5.7.4, 10.1.1
Обучение Llama, TFLOPS	реальная скорость обучения модели на ~170M параметров в BF16 на одной карте	в оценках времени уроков 20–40	урок 10.1.1

Bus bandwidth считается так же, как в ddp_check.py: размер сообщения × 2(n − 1)/n, делённый на время. Так цифры для двух и для четырёх карт можно сравнивать между собой и с NVLink из модуля 5.4.

Это ориентиры, а не норма

Паспортные цифры и оценки из уроков на настоящей машине 4× RTX 4080 32 ГБ ещё не проверены. У модифицированных карт на 32 ГБ частота памяти и лимит мощности могут отличаться от штатной RTX 4080. Отклонение на 10–20% не повод для тревоги. Отклонение в 2 раза и больше — повод разобраться по таблице ниже и прислать отчёт.

В конце отчёта, в рекомендациях, скрипт печатает два коэффициента. Первый показывает, на сколько умножать оценки времени обучения в уроках: они посчитаны по формуле 6ND при 20–40 TFLOPS на карту. Второй делает то же для оценок времени обмена между картами, посчитанных при 10 ГБ/с. Запишите оба в journal/lab.md.

Если тест не прошёл

Что видите	Что делать
«GPU не найдены», хотя nvidia-smi видит карты	у вас PyTorch без CUDA или драйвер старше, чем нужно этой сборке: pip uninstall -y torch && pip install torch, при необходимости обновите драйвер (шаги 2–3)
PyTorch видит меньше 4 карт	проверьте переменную CUDA_VISIBLE_DEVICES и вывод nvidia-smi
all-reduce, DDP или FSDP зависает либо падает с ошибкой NCCL	скрипт сам повторит all-reduce с NCCL_P2P_DISABLE=1. Если так работает, добавьте строку export NCCL_P2P_DISABLE=1 в ~/.bashrc. Если нет, запустите ddp_check.py с NCCL_DEBUG=INFO и посмотрите, на чём останавливается NCCL. На машинах с EPYC частая причина — IOMMU и ACS (раздел Troubleshooting в документации NCCL)
all-reduce вернул неверную сумму	данные портятся при обмене между картами, и обучение будет ломаться без ошибок. Запустите с NCCL_P2P_DISABLE=1 и проверьте настройки IOMMU
матмул сильно ниже ориентира	карта упирается в лимит мощности или перегревается: nvidia-smi -q -d PERFORMANCE покажет причину снижения частот, nvidia-smi -q -d POWER — лимит
CPU→GPU около 12–13 ГБ/с	карта работает как PCIe 3.0 или x8: проверьте слот, райзер и настройки PCIe в BIOS
Llama и LoRA — SKIP	pip install -r homework/requirements-llm.txt
4 бита — SKIP или ошибка undefined symbol	pip install bitsandbytes; после обновления PyTorch переустановите его
Triton или torch.compile — ошибка про Python.h или компилятор	sudo apt install build-essential python3-dev
vLLM — SKIP	так и задумано: курс ставит vLLM в отдельное окружение (урок 7.1.2). Активируйте его и запустите проверку оттуда, а сервер с моделью проверьте командой из отчёта

Пришлите отчёт

1. Запишите главные цифры в journal/lab.md: TFLOPS, ГБ/с памяти, bus bandwidth all-reduce, токены в секунду. На ступени 5 вы сравните их с дата-центровыми GPU.

2. Откройте journal/lab-report.md и посмотрите колонку «Расхождение > 2×» в таблице «Ожидалось в курсе → у вас».

3. Если оценки времени в уроках расходятся с вашими цифрами больше чем в 2 раза, пришлите lab-report.md авторам: создайте issue в репозитории курса и приложите файл. Оценки поправят. Отчёт без расхождений тоже пригодится: он подтверждает, что ориентиры верны.

Что попадает в отчёт

Модели процессора и видеокарт, версии программ, свободное место на дисках и результаты замеров. Имени пользователя там нет: домашняя папка в путях заменена на ~. Перед отправкой всё равно пролистайте файл.

Полезные инструменты

nvtop / nvidia-smi

Загрузка карт, память, температура в реальном времени: nvtop или watch -n 1 nvidia-smi.

htop / btop

Загрузка 96 потоков процессора. Полезно, когда узкое место в подготовке данных.

CUDA_VISIBLE_DEVICES

Выбор карт для процесса: CUDA_VISIBLE_DEVICES=0 python train.py — только первая карта. Так можно ставить четыре разных эксперимента параллельно.

tmux

Обучение идёт часами. Запускайте его в tmux, чтобы закрытие терминала не убило процесс.

Питание и охлаждение

Четыре карты под нагрузкой потребляют больше киловатта. Следите за температурами (nvidia-smi) при первых долгих запусках. Если карты перегреваются, ограничьте мощность командой sudo nvidia-smi -pl <ватты>: потеря скорости обычно небольшая, а нагрев и шум заметно падают.