Kurs Python · Moduł 9: Machine Learning

PyTorch - dwa filary deep learningu

4 min czytania ·
W tej lekcji4

Klasyczne modele ze scikit-learn miały granicę. Gdy dane są ogromne i skomplikowane - miliony zdjęć zwierząt - potrzebujesz sieci neuronowych, a do nich narzędzia cięższego kalibru: PyTorch. Zanim zaczniesz, poznaj dwa filary, na których stoi cała biblioteka - tensor i autograd. Reszta to szczegóły.

pip install torch torchvision

Filar pierwszy: tensor

Tensor to podstawowe pudełko na dane w PyTorch - jak tablica NumPy, ale z dwiema supermocami, które poznasz za chwilę: umie liczyć na karcie graficznej i umie zapamiętać, jak powstał. Na razie potraktuj go jak znajomą tablicę liczb.

import torch

tensor = torch.tensor([1, 2, 3, 4, 5])
matrix = torch.tensor([[1, 2], [3, 4], [5, 6]])

zeros = torch.zeros(3, 4)   # macierz 3x4 zer
random = torch.rand(3, 3)   # losowe wartości 0-1

print(tensor.shape)    # rozmiar
print(tensor.device)   # cpu czy cuda (GPU)

Tworzysz tensory prawie tak jak w NumPy, ale zwróć uwagę na ostatni atrybut - device. To on zdradza pierwszą supermoc: tensor wie, czy leży w pamięci procesora (cpu), czy karty graficznej (cuda). Do tego zaraz wrócimy.

Operacje na tensorach też przypominają NumPy - dodajesz, mnożysz, liczysz statystyki:

a = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)
b = torch.tensor([[5, 6], [7, 8]], dtype=torch.float32)

c = a + b        # dodawanie element po elemencie
c = a @ b        # mnożenie macierzowe (operator @)

print(a.mean())  # średnia
print(a.argmax())  # indeks największej wartości

reshaped = torch.arange(12).reshape(3, 4)  # zmiana kształtu

Ważne rozróżnienie: + i * działają element po elemencie, a @ to prawdziwe mnożenie macierzy - w sieciach neuronowych używasz głównie tego drugiego. reshape zmienia kształt bez ruszania danych, co przyda się przy przepychaniu obrazów przez sieć.

Supermoc tensora: obliczenia na GPU

Oto dlaczego deep learning w ogóle jest możliwy w rozsądnym czasie. Sieci wykonują miliardy mnożeń macierzy, a karta graficzna (GPU) robi je setki razy szybciej niż procesor. Tensor przenosisz na GPU jedną metodą.

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

tensor = torch.tensor([1, 2, 3]).to(device)   # przenieś na GPU (jeśli jest)
tensor_gpu = torch.rand(3, 3, device='cuda')  # albo od razu tam stwórz

Wzorzec device = 'cuda' if ... else 'cpu' to standard: kod działa na GPU, gdy jest dostępne, a na zwykłym procesorze, gdy go nie ma - bez przepisywania. Zapamiętaj jedną zasadę: żeby tensory mogły się dodać czy pomnożyć, muszą leżeć na tym samym urządzeniu. Mieszanie CPU i GPU to najczęstszy błąd początkującego.

Filar drugi: autograd

Teraz druga supermoc - ta, dzięki której model w ogóle potrafi się uczyć. Uczenie to poprawianie parametrów w stronę mniejszego błędu, a do tego trzeba pochodnych (gradientów). Autograd liczy je za Ciebie: gdy oznaczysz tensor requires_grad=True, PyTorch zapamiętuje każdą operację i potrafi cofnąć rachunek.

x = torch.tensor([2.0], requires_grad=True)
y = x ** 2 + 3 * x + 1

y.backward()      # policz pochodną wstecz
print(x.grad)     # dy/dx = 2x + 3 = 7

To jest sedno PyTorcha. Ty zapisałeś tylko wzór "w przód" (y = x**2 + 3x + 1), a backward() sam wyliczył pochodną - 7, dokładnie jak z kartki. Nigdzie nie różniczkowałeś ręcznie. W prawdziwym modelu ten sam mechanizm liczy, jak zmienić każdą wagę, by błąd zmalał:

w = torch.tensor([1.0], requires_grad=True)
b = torch.tensor([0.0], requires_grad=True)

y_pred = w * torch.tensor([2.0]) + b   # przewidywanie modelu
loss = (y_pred - torch.tensor([5.0])) ** 2  # jak bardzo się mylimy

loss.backward()
print(w.grad, b.grad)   # w którą stronę poprawić w i b

Prześledź logikę: liczysz przewidywanie, liczysz błąd (loss), wołasz backward() - a w.grad i b.grad mówią, w którą stronę pchnąć każdy parametr, żeby błąd zmalał. Cała nauka sieci to powtarzanie tego kroku tysiące razy. To dlatego autograd jest filarem, nie ciekawostką.

Podawanie danych: Dataset i DataLoader

Zostało praktyczne pytanie: jak karmić model danymi? Sieci uczą się na małych porcjach (batystach), więc PyTorch daje dwa klocki - Dataset opakowuje Twoje dane, a DataLoader porcjuje je i miesza.

from torch.utils.data import Dataset, DataLoader

class SafariDataset(Dataset):
    def __init__(self, X, y):
        self.X = torch.tensor(X, dtype=torch.float32)
        self.y = torch.tensor(y, dtype=torch.long)

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

dataset = SafariDataset(X_train, y_train)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

for batch_X, batch_y in dataloader:
    print(batch_X.shape, batch_y.shape)
    break

Twój Dataset musi umieć dwie rzeczy: powiedzieć, ile ma przykładów (__len__) i zwrócić jeden po numerze (__getitem__). DataLoader bierze to i podaje w paczkach po 32 (batch_size), za każdą epoką tasując kolejność (shuffle=True) - dzięki czemu model nie uczy się przypadkowej kolejności danych.

Pamiętaj z tej lekcji dwa filary: tensor to dane, które liczą na GPU, a autograd sam wylicza pochodne, dzięki którym model się uczy. Gdy to rozumiesz, budowa samej sieci jest już tylko układaniem warstw.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest Tensor w PyTorch?

  2. 2. Jak przenieść tensor na GPU w PyTorch?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż import PyTorch z aliasem:

  • Edytor kodu

    Utwórz tensor z listy, wykonaj operacje matematyczne i sprawdź shape.

  • Klikanie w kolejności

    Kliknij w przyciski, aby stworzyć tensor z listy:

  1. PytanieTensor PyTorch
  2. PytanieGPU w PyTorch
  3. Ułóż w kolejnościImport PyTorch z aliasem
  4. Zadanie z kodemTworzenie tensorów
  5. PytanieAutograd
  6. Kliknij w kolejnościTworzenie tensora

Przydatne artykuły