0Pricing
Learn AI with Python · Lekcja

Tensory PyTorch i Autograd

torch.Tensor, requires_grad, backward(), obliczanie gradientów, operacje na tensorach.

Tensory PyTorch i Autograd to bezpłatna lekcja Learn AI with Python na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn AI with Python, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Czym jest PyTorch

PyTorch to framework uczenia głębokiego oparty na tensorach, czyli wielowymiarowych tablicach z obsługą GPU i automatycznym różniczkowaniem. Dwa filary, które należy najpierw opanować, to tensory i autograd.

pip install torch

import torch

Tworzenie tensorów

Tensor przypomina tablicę NumPy, ale może znajdować się na GPU i śledzić gradienty. Należy utworzyć go za pomocą torch.tensor. Tensory mają shape i dtype.

x = torch.tensor([1.0, 2.0, 3.0])
print(x.shape)   # torch.Size([3])
print(x.dtype)   # torch.float32

Operacje na tensorach

Tensory obsługują arytmetykę element po elemencie, mnożenie macierzy i zmianę kształtu. Operacje są zwektoryzowane i wykonywane szybko przez sprzęt. To podstawa obliczeniowa każdej sieci neuronowej.

a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
print(a + b)
print(a @ b)  # matrix multiply

requires_grad: śledzenie gradientów

Aby obliczać gradienty, należy utworzyć tensor z requires_grad=True. PyTorch rejestruje wtedy każdą operację wykonywaną na tym tensorze, budując graf obliczeniowy, który można później różniczkować.

x = torch.tensor([2.0, 3.0], requires_grad=True)
print(x.requires_grad)  # True

Budowanie obliczenia

Należy zastosować operacje do tensora śledzącego gradienty, aby uzyskać wynik skalarny. W tym przykładzie podnosimy każdy element do kwadratu i sumujemy elementy, otrzymując pojedynczą liczbę, którą można różniczkować względem x.

x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x.pow(2).sum()   # y = x0^2 + x1^2
print(y)             # tensor(13., grad_fn=...)

Wywoływanie backward()

Należy wywołać .backward() na skalarze, aby obliczyć gradienty za pomocą propagacji wstecznej. PyTorch przechodzi wstecz po zarejestrowanym grafie, automatycznie uzupełniając pochodne.

y.backward()

Odczytywanie .grad

Po wywołaniu backward() każdy tensor wejściowy przechowuje swój gradient w .grad. Dla y = sum(x^2) pochodna wynosi 2x, więc gradient to [4, 6].

print(x.grad)  # tensor([4., 6.])

Gradienty się akumulują

Ważna pułapka: gradienty sumują się przy wielu wywołaniach backward(). W pętli treningowej należy zerować je w każdym kroku za pomocą x.grad.zero_() lub metody zero_grad() optymalizatora.

x.grad.zero_()  # reset before the next backward()

torch.no_grad() podczas inferencji

Podczas inferencji gradienty nie są potrzebne, a ich śledzenie marnuje pamięć. Kod predykcji należy umieścić w with torch.no_grad():, aby wyłączyć budowanie grafu i przyspieszyć działanie.

with torch.no_grad():
    preds = x.pow(2).sum()
    print(preds.requires_grad)  # False

detach() do zatrzymywania przepływu gradientów

.detach() zwraca tensor współdzielący dane, ale odłączony od grafu obliczeniowego. Należy użyć go, aby wykorzystać wartość bez przepuszczania przez nią gradientów, na przykład podczas rejestrowania logów lub zamrażania części sieci.

z = x.detach()
print(z.requires_grad)  # False

Dlaczego autograd ma znaczenie

Autograd sprawia, że uczenie głębokie jest praktyczne: definiuje się obliczenia w przód, a PyTorch automatycznie wyznacza gradienty potrzebne do propagacji wstecznej. Każda tworzona pętla treningowa opiera się na requires_grad, backward i .grad.

Szybkie sprawdzenie

Proszę sprawdzić znajomość autograd.

Podsumowanie: tensory i autograd

Utworzono tensory za pomocą torch.tensor i włączono śledzenie gradientów przez requires_grad=True. Obliczono wynik, wywołano .backward() i odczytano pochodne z .grad. Poznano sposób akumulowania gradientów, użyto torch.no_grad() podczas inferencji oraz .detach() do odcięcia przepływu gradientów.

Często zadawane pytania

Czy lekcja „Tensory PyTorch i Autograd” jest bezpłatna?

Tak — pełny tekst „Tensory PyTorch i Autograd” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn AI with Python, przejdź na CoddyKit PRO. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Co nauczysz się w „Tensory PyTorch i Autograd”?

torch.Tensor, requires_grad, backward(), obliczanie gradientów, operacje na tensorach. Ćwiczysz Learn AI with Python z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn AI with Python?

Nie wymagamy żadnego doświadczenia. Learn AI with Python w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Tensory PyTorch i Autograd”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn AI with Python?

Tak. Każda lekcja Learn AI with Python zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Tensory PyTorch i Autograd
  2. Własne zbiory danych i moduły DataLoader
  3. Tworzenie i trenowanie sieci CNN w PyTorch
  4. Wykrywanie obiektów za pomocą YOLOv8
← Powrót do Learn AI with Python