Статья Автор: Деникина Н.В., Деникин А.В.

PyTorch

PyTorch - это открытая библиотека машинного обучения на Python, разработанная командой Facebook AI Research (Meta AI). Используется для построения, обучения и развёртывания нейронных сетей.

Зачем библиотека, если всё уже работает

Библиотека не добавляет ни одной новой идеи - она делает то же самое, но быстрее и умеет считать на видеокарте.

Тензор PyTorch

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

Скопируй локально на свой компьютер и запусти. Запуск программы на сервере не всегда укладывается в разрешенное время

import numpy as np
import torch

x = np.array([[4.0, 2.0, 6.0],
              [1.0, 8.0, 2.0]])

# последний параметр device='cuda' - видеокарта
# device='cpu' - процессор
t = torch.tensor(x, dtype=torch.float32, device='cpu')   

print(t.shape)
print(t.dtype)
print(t.ndim)
print(t[:, 0])

Вывод

torch.Size([2, 3])
torch.float32
2
tensor([4., 1.])

shape, ndim и срезы работают точно так же, как в numpy. Переучиваться не нужно.

Слой: nn.Linear

nn.Linear(входов, нейронов) — это ровно наш слой: умножение на матрицу весов плюс смещение. Ничего больше.

Одна ловушка: PyTorch хранит матрицу весов перевёрнутой, формой (нейронов, входов), а не (входов, нейронов). Поэтому при переносе своих весов матрицу надо транспонировать.

import numpy as np
import torch

X = np.array([[4.0, 2.0, 6.0],
              [1.0, 8.0, 2.0]])
W = np.array([[3.0,   0.5],
              [1.5,   0.25],
              [-0.5, -1.5]])
b = np.array([8.0, 12.0])

mine = X @ W + b                              # наш слой из прошлых разборов

layer = torch.nn.Linear(3, 2)                 # тот же слой в PyTorch
with torch.no_grad():
    layer.weight.copy_(torch.tensor(W.T))     # weight хранится как (выход, вход)
    layer.bias.copy_(torch.tensor(b))

theirs = layer(torch.tensor(X, dtype=torch.float32)).detach().numpy()

print(layer.weight.shape)
print(mine)
print(theirs)
print(np.allclose(mine, theirs, atol=1e-6))

Вывод

torch.Size([2, 3])
[[20.   5.5]
 [22.  11.5]]
[[20.   5.5]
 [22.  11.5]]
True

Форма weight - (2, 3), наоборот к нашей (3, 2). Нужно транспонировать.

torch.no_grad() — это контекстный менеджер (блок кода), который отключает вычисление градиентов (производных).

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

Сеть: nn.Sequential

nn.Sequential - стопка слоёв, применяются по очереди.

import numpy as np
import torch

X = np.array([[4.0, 2.0, 6.0],
              [1.0, 8.0, 2.0]])
W1 = np.array([[-0.5, -0.5,  0.25,  2.0],
               [-0.5,  0.0,  0.0,   1.0],
               [-0.25, -0.5, -0.5, -0.25]])
b1 = np.array([-0.5, 0.0, 3.75, 4.25])
W2 = np.array([[-0.25, 0.25],
               [0.5,  -0.25],
               [0.0,   3.0],
               [1.5,   0.0]])
b2 = np.array([1.25, 1.0])

y_np = np.maximum(X @ W1 + b1, 0) @ W2 + b2      # своя версия

net = torch.nn.Sequential(                        # та же сеть в PyTorch
    torch.nn.Linear(3, 4),
    torch.nn.ReLU(),
    torch.nn.Linear(4, 2),
)

with torch.no_grad():                             # кладём свои веса внутрь
    net[0].weight.copy_(torch.tensor(W1.T))
    net[0].bias.copy_(torch.tensor(b1))
    net[2].weight.copy_(torch.tensor(W2.T))
    net[2].bias.copy_(torch.tensor(b2))

y_torch = net(torch.tensor(X, dtype=torch.float32))

print(y_np)
print(y_torch.detach().numpy())
print(np.allclose(y_np, y_torch.detach().numpy(), atol=1e-6))

Вывод

[[20.375  6.25 ]
 [21.875 10.   ]]
[[20.375  6.25 ]
 [21.875 10.   ]]
True

И ещё одно

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

import torch

g = torch.Generator().manual_seed(0)

# 200 заказов: расстояние в км, светофоры на маршруте, свободные курьеры рядом
X = torch.rand(200, 3, generator=g) * torch.tensor([11.5, 15.0, 29.0])
X = X + torch.tensor([0.5, 0.0, 1.0])

# правило, по которому мы посчитали время; модель его не увидит
w_true = torch.tensor([3.0, 1.5, -0.5])
b_true = 8.0
y = (X @ w_true + b_true).reshape(200, 1)
y = y + torch.randn(200, 1, generator=g) * 1.0      # разброс в реальных данных

model = torch.nn.Linear(3, 1)                       # чёрный ящик на эту пару
with torch.no_grad():                               # старт с нуля: модель не знает ничего
    model.weight.zero_()
    model.bias.zero_()

opt = torch.optim.Adam(model.parameters(), lr=0.05)

for step in range(6000):
    loss = ((model(X) - y) ** 2).mean()
    opt.zero_grad()
    loss.backward()
    opt.step()

print("правило, по которому считали мы:")
print("  веса", w_true.tolist(), "  смещение", b_true)
print("что нашла модель, видя только заказы:")
print("  веса", [round(v, 2) for v in model.weight[0].tolist()],
      "  смещение", round(model.bias.item(), 2))

new = torch.tensor([[4.0, 2.0, 6.0]])               # 4 км, 2 светофора, 6 курьеров
print("прогноз для нового заказа, минут:", round(model(new).item(), 1))

Вывод

правило, по которому считали мы:
  веса [3.0, 1.5, -0.5]   смещение 8.0
что нашла модель, видя только заказы:
  веса [3.0, 1.48, -0.49]   смещение 7.97
прогноз для нового заказа, минут: 20.0

Программа увидела только заказы и время и восстановила правило почти точно. Прогноз для заказа 4 километра, 2 светофора, 6 курьеров — те же 20 минут, что мы считали вручную в паре 3.

Что здесь новое

Первые строки — знакомое умножение и сложение. Linear(3, 1) — слой из этой же пары, только с одним нейроном и обнулёнными весами: модель стартует, не зная ничего.

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

Печать