PyTorch: что это за фреймворк и для чего нужен

• выполнять операции с тензорами — перемножать, складывать и преобразовывать многомерные массивы чисел;
• автоматически вычислять градиенты — находить производные, без которых невозможно обучение нейросетей;
• собирать модели — конструировать нейросети из готовых блоков, как из деталей конструктора;
• запускать вычисления на разных устройствах — на обычном процессоре, видеокарте или специализированном ускорителе.

• Классификация и обработка изображений. Модель смотрит на снимок с камеры на производстве и отмечает бракованные детали, которые человек глазами уже не успевает отследить.
• Обработка текста и речи. Голосовой помощник превращает вашу фразу «поставь будильник на семь» в текст, понимает смысл и выполняет команду.
• Рекомендательные и ранжирующие системы. Онлайн-кинотеатр анализирует, что вы смотрели раньше, и выводит на главный экран сериалы, которые вы досмотрите, а не бросите на второй серии.
• Генеративные модели. Нейросеть рисует картинку по текстовому описанию или дописывает код за программистом.
• Обучение с подкреплением. Алгоритм управляет персонажем в игре, получает награду за правильные действия и постепенно учится играть лучше человека.
• Научные и инженерные расчёты. Физики моделируют поведение молекул, а инженеры оптимизируют форму деталей, используя автоматическое дифференцирование фреймворка.

1. модель получает порцию данных;
2. выполняется прямой проход — модель считает предсказания;
3. функция потерь сравнивает предсказания с правильными ответами и выдаёт число: чем оно больше, тем сильнее модель ошиблась;
4. autograd вычисляет градиенты ошибки по всем параметрам модели;
5. оптимизатор сдвигает параметры в сторону уменьшения ошибки.

• torch — тензоры и базовые операции над ними;
• torch.nn — слои, готовые блоки и функции потерь для сборки моделей;
• torch.optim — оптимизаторы для обновления параметров;
• torch.utils.data — Dataset, DataLoader и всё для работы с наборами данных;
• torch.compile — компиляция модели для ускорения обучения и запуска;
• torch.export — экспорт модели для развёртывания вне Python;
• TorchVision — отдельная библиотека для задач компьютерного зрения: датасеты, готовые модели, преобразования картинок.

• Актуальный стабильный релиз на эту дату — PyTorch 2.12, выпущенный 13 мая 2026 года. Подробности в официальном обзоре релиза.
• Вся ветка PyTorch 2.x развивает компиляцию через torch.compile: одна строка кода ускоряет обучение и запуск модели без переписывания остального.
• TorchScript, старый механизм сериализации моделей, признан устаревшим начиная с PyTorch 2.10 — проект официально объявил об этом. Если встретите его в туториале, знайте: так больше не делают.
• Для экспорта моделей теперь рекомендуется torch.export, а для запуска на встроенных и мобильных устройствах используется ExecuTorch.
• В PyTorch 2.12 появился единый API torch.accelerator.Graph для захвата и воспроизведения вычислительных графов на разных ускорителях, а torch.export.save научился сохранять модели с MX-квантизацией.
• Команды установки и список поддерживаемых ускорителей зависят от платформы и версии сборки, поэтому перед установкой стоит свериться с официальным селектором — о нём в следующем разделе.

Как установить PyTorch и запустить первый пример

Переходим к практике: установим фреймворк PyTorch и обучим на нём первую нейросеть. Видеокарта не понадобится, всё заработает на обычном процессоре.

Подготовка окружения

Для работы понадобится установленный Python с менеджером пакетов pip. Если Python на компьютере ещё нет, у нас есть инструкция, как установить Python на компьютер на любой операционной системе. Перед установкой сверьте версию Python с требованиями в официальном селекторе PyTorch: поддерживаемые версии там указаны прямо на странице.

Пакет torch для Python лучше ставить в отдельное виртуальное окружение, чтобы его зависимости не конфликтовали с другими проектами. На Windows окружение создаётся и активируется так:

# создаём виртуальное окружение в папке .venv
python -m venv .venv

# активируем окружение
.venv\Scripts\activate

На macOS и Linux логика та же, отличается только команда активации:
source .venv/bin/activate. После активации в начале строки терминала появится приписка (.venv) — значит, окружение работает и пакеты будут ставиться в него.

Курс по нейросетям и анализу данных для новичков

Выбор сборки и установка

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

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

pip install torch

Держите в уме два момента. Первый: команда выше подходит для CPU-сборки, а для видеокарт селектор сгенерирует другую команду с указанием версии CUDA или ROCm — копируйте именно её. Второй: устанавливаемый пакет называется torch, без «py» в начале. Команда pip install pytorch поставит вам совсем другой пакет.

После установки проверьте, что всё получилось: импортируйте torch в Python и выведите версию.

import torch
# выводим установленную версию PyTorch
print(torch.__version__)

Программа выведет номер версии, например:

2.12.0

Проверка устройства

Теперь узнаем, на чём фреймворк будет считать. Начиная с PyTorch 2.12 для этого удобно использовать API torch.accelerator: он одинаково работает с CUDA, ROCm, MPS и XPU.

import torch

# проверяем, доступен ли какой-нибудь ускоритель
if torch.accelerator.is_available():
    # если да, выбираем его
    device = torch.accelerator.current_accelerator()
else:
    # если нет, работаем на процессоре
    device = torch.device("cpu")

# выводим выбранное устройство
print(device)

На компьютере без видеокарты программа выведет cpu, и это нормально. Ускоритель нужен для обучения больших моделей, а для изучения API, маленьких моделей и проверки кода процессора хватает с запасом. Весь код из этой статьи спокойно работает на CPU.

Обучение простой модели

Соберём всё изученное в работающий пример: обучим нейросеть отличать два класса точек на плоскости. Данные сгенерируем сами, поэтому скачивать ничего не придётся. Правило разметки простое: если сумма двух признаков объекта больше нуля, объект относится к классу 1, иначе — к классу 0. Модель этого правила не знает, и её задача — вывести его из примеров.

import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader

# фиксируем генератор случайных чисел, чтобы результат воспроизводился
torch.manual_seed(42)

# создаём 200 объектов с двумя случайными признаками
X = torch.randn(200, 2)

# размечаем классы: сумма признаков больше нуля -- класс 1
y = (X.sum(dim=1) > 0).float().unsqueeze(1)

# упаковываем признаки и метки в датасет
dataset = TensorDataset(X, y)

# нарезаем датасет на батчи по 32 объекта и перемешиваем их
loader = DataLoader(dataset, batch_size=32, shuffle=True)

# собираем модель: два линейных слоя и активация между ними
model = nn.Sequential(
    nn.Linear(2, 8),
    nn.ReLU(),
    nn.Linear(8, 1),
)

# выбираем функцию потерь для бинарной классификации
loss_fn = nn.BCEWithLogitsLoss()

# выбираем оптимизатор Adam с шагом обучения 0.01
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# обучаем модель 20 эпох
for epoch in range(20):
    for batch_X, batch_y in loader:
        # прямой проход: модель считает предсказания
        pred = model(batch_X)
        # функция потерь измеряет ошибку
        loss = loss_fn(pred, batch_y)
        # обнуляем градиенты с прошлого шага
        optimizer.zero_grad()
        # autograd считает новые градиенты
        loss.backward()
        # оптимизатор обновляет параметры модели
        optimizer.step()
    # каждые 5 эпох выводим значение ошибки
    if (epoch + 1) % 5 == 0:
        print(f"Эпоха {epoch + 1}, ошибка: {loss.item():.4f}")

# переводим модель в режим оценки
model.eval()

# считаем предсказания без расчёта градиентов
with torch.no_grad():
    # прогоняем все данные через обученную модель
    logits = model(X)
    # превращаем выходы модели в классы 0 и 1
    predictions = (torch.sigmoid(logits) > 0.5).float()
    # сравниваем предсказания с настоящими метками
    accuracy = (predictions == y).float().mean()

print(f"Точность на обучающих данных: {accuracy.item():.2%}")

Пройдёмся по логическим этапам. Сначала мы готовим данные: генерируем 200 случайных точек, размечаем их по правилу и упаковываем в связку TensorDataset и DataLoader. Затем собираем модель через nn.Sequential — контейнер, который прогоняет данные через слои по очереди: линейный слой превращает 2 признака в 8 промежуточных, активация ReLU добавляет нелинейность, второй линейный слой сводит всё к одному выходному числу.

Дальше идёт тот самый цикл обучения из пяти шагов, который мы разбирали на схеме: прямой проход, расчёт ошибки, обнуление старых градиентов через zero_grad(), обратный проход через backward() и шаг оптимизатора через step(). Цикл крутится 20 эпох, то есть модель 20 раз просматривает весь датасет.

В конце мы переводим модель в режим оценки методом eval() и считаем предсказания внутри блока torch.no_grad(): он отключает запись вычислительного графа, потому что на этапе проверки градиенты уже не нужны. Запускаем и смотрим на фактический вывод программы (проверено на PyTorch 2.12.0):

Эпоха 5, ошибка: 0.1952
Эпоха 10, ошибка: 0.1690
Эпоха 15, ошибка: 0.0174
Эпоха 20, ошибка: 0.0211
Точность на обучающих данных: 99.50%

Обратите внимание: ошибка растёт между 15-й и 20-й эпохой в выводе программы: 0.0174 → 0.0211. Это нормально, потому что печатается loss последнего батча, а не средний по эпохе. 

Ошибка упала почти в десять раз, а модель правильно классифицирует 99,5% точек. Нейросеть сама вывела правило разметки из примеров, и на это ушло меньше 60 строк кода вместе с комментариями.

Частые ошибки при работе с PyTorch

Код из прошлого раздела работает, но стоит начать его менять, и вы быстро познакомитесь с классическими ошибками. Хорошая новость: почти все они сводятся к четырём ситуациям, и каждую легко проверить.

Тензоры находятся на разных устройствах

Представьте: вы перенесли модель на видеокарту командой model.to(device), запустили обучение и получили RuntimeError с жалобой на cuda и cpu в одном выражении. Причина в том, что модель уехала на GPU, а входные данные остались в оперативной памяти. Считать вместе они физически не могут, потому что лежат в разной памяти.

Правило простое: модель и данные должны находиться на совместимом устройстве. Если модель на GPU, каждый батч перед прямым проходом тоже нужно переносить: batch_X = batch_X.to(device). Проверить, где лежит тензор, всегда можно через атрибут .device.

Не совпадают формы или типы данных

Вторая по популярности ошибка: форма выхода модели не совпадает с тем, что ждёт функция потерь. Например, модель выдаёт тензор формы [32, 1], а метки имеют форму [32]. Некоторые функции потерь в такой ситуации упадут с ошибкой, а некоторые молча посчитают неправильно, что даже хуже.

Диагностируется это за минуту: выведите tensor.shape и tensor.dtype у предсказаний и меток перед расчётом ошибки. В нашем примере мы заранее привели метки к форме [200, 1] методом unsqueeze(1) и к типу float() именно для того, чтобы они совпали с выходом модели.

Градиенты накапливаются между итерациями

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

Спасает вызов optimizer.zero_grad() внутри цикла обучения: он обнуляет градиенты перед новым обратным проходом. В нашем примере он стоит перед loss.backward(), и это его законное место.

Режим обучения остаётся включённым при проверке

У модели есть два режима: model.train() для обучения и model.eval() для проверки. Некоторые слои, например Dropout и BatchNorm, ведут себя в них по-разному, поэтому проверка модели в режиме обучения даёт искажённые результаты. Наша маленькая модель таких слоёв не содержит, но привычку вызывать eval() перед проверкой стоит выработать сразу.

Вторая часть той же привычки: считать предсказания внутри torch.no_grad() или более строгого torch.inference_mode(). Оба блока отключают запись вычислительного графа, поэтому проверка работает быстрее и не тратит память на градиенты, которые всё равно никто не использует.

Преимущества и ограничения PyTorch

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

Преимущества PyTorch

• Привычный Python API. Код модели читается как обычный Python: циклы, условия и функции работают так, как вы привыкли.
• Удобная отладка eager-кода. Операции выполняются сразу, в момент вызова, поэтому модель можно отлаживать print-ами и обычным отладчиком, строка за строкой.
• Autograd и модульная сборка моделей. Градиенты считаются автоматически, а модели собираются из готовых блоков torch.nn.
• Поддержка разных вычислительных устройств. Один и тот же код работает на CPU, CUDA, ROCm, MPS и XPU почти без изменений.
• Развитая экосистема. Вокруг ядра выросли доменные библиотеки, а большинство открытых моделей публикуются именно в формате PyTorch.
• Инструменты для взрослых задач. torch.compile ускоряет модель, torch.export выгружает её для развёртывания, а встроенные средства распределённого обучения позволяют считать на десятках видеокарт.

• Порог входа в математику. Без понимания тензоров, форм и градиентов осмысленно работать не получится, поэтому перед серьёзными проектами придётся разобраться в основах.
• Зависимость от оборудования и сборки. Производительность упирается в железо, драйверы и правильно выбранную сборку: перепутали версию CUDA — и видеокарта простаивает.
• Аппетит к памяти. Обучение крупных моделей съедает десятки гигабайт видеопамяти, поэтому для больших архитектур нужно дорогое железо или аренда облака.
• Сервинг требует надстроек. Для промышленного запуска моделей с мониторингом и масштабированием понадобятся дополнительные инструменты поверх самого фреймворка.
• Дистанция от эксперимента до продакшена. Код исследовательского ноутбука и промышленный пайплайн — разные вещи: перенос модели в продукт потребует отдельной инженерной работы.