Wprowadzenie do PyTorch: Technologia i Przykład

Rafal Gawlik

Jul 27, 2024 • 2 min read

PyTorch jest jedną z najpopularniejszych bibliotek do uczenia maszynowego, szczególnie w dziedzinie głębokiego uczenia. Opracowana przez zespół badawczy Facebooka, PyTorch oferuje dynamiczne grafy obliczeniowe, co czyni ją elastyczną i intuicyjną w użyciu dla programistów Python. W tym artykule przyjrzymy się bliżej tej technologii oraz przedstawimy praktyczny przykład implementacji modelu sieci neuronowej.

Czym jest PyTorch?

PyTorch to otwartoźródłowa biblioteka do uczenia maszynowego, która umożliwia tworzenie i trenowanie modeli sieci neuronowych. Biblioteka ta jest szczególnie ceniona za:

Łatwość użycia: PyTorch oferuje prosty i intuicyjny interfejs API, co czyni kodowanie bardziej naturalnym dla programistów Python.
Dynamiczne grafy obliczeniowe: Umożliwia modyfikowanie grafów obliczeniowych w trakcie działania programu, co jest przydatne przy eksperymentowaniu z różnymi architekturami modeli.
Wsparcie GPU: PyTorch pozwala na łatwe przenoszenie obliczeń na GPU, co znacząco przyspiesza trening modeli.

Główne Koncepcje PyTorch

Tensory

Podstawowym budulcem PyTorch są tensory, które są rozszerzeniem tablic NumPy o możliwość wykonywania obliczeń na GPU. Tensory mogą mieć dowolną liczbę wymiarów, co czyni je elastycznym narzędziem do reprezentacji danych.

import torch

# Tworzenie tensora 2x2
a = torch.Tensor([[1, 2], [3, 4]])
print(a)

Dynamiczne Grafy Obliczeniowe

PyTorch umożliwia dynamiczne tworzenie grafów obliczeniowych, co oznacza, że graf jest tworzony w trakcie wykonywania kodu. Dzięki temu można łatwo debugować i modyfikować modele.

Autograd

Jednym z kluczowych elementów PyTorch jest moduł autograd, który automatycznie oblicza gradienty. Jest to niezbędne do trenowania modeli sieci neuronowych metodą propagacji wstecznej.

# Tworzenie tensora z możliwością śledzenia gradientów
x = torch.tensor(1.0, requires_grad=True)
y = x ** 2
y.backward()
print(x.grad)  # Wyświetli: tensor(2.0000)

Przykład: Klasyfikator XOR

Przyjrzyjmy się teraz praktycznemu przykładowi implementacji prostego modelu sieci neuronowej do klasyfikacji operacji XOR.

Krok 1: Importowanie bibliotek

import torch
import torch.nn as nn
import torch.optim as optim

Krok 2: Definicja modelu

class XORModel(nn.Module):
    def __init__(self):
        super(XORModel, self).__init__()
        self.fc1 = nn.Linear(2, 2)
        self.fc2 = nn.Linear(2, 1)

    def forward(self, x):
        x = torch.sigmoid(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))
        return x

model = XORModel()

Krok 3: Przygotowanie danych

# Dane wejściowe (XOR)
inputs = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
labels = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

Krok 4: Definicja funkcji straty i optymalizatora

criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

Krok 5: Trening modelu

# Trening przez 10,000 epok
for epoch in range(10000):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 1000 == 0:
        print(f'Epoch [{epoch + 1}/10000], Loss: {loss.item():.4f}')

Krok 6: Testowanie modelu

# Testowanie modelu
with torch.no_grad():
    predicted = model(inputs)
    predicted = (predicted > 0.5).float()
    print('Predicted:\n', predicted)
    print('Labels:\n', labels)

Podsumowanie

PyTorch to potężne narzędzie do tworzenia modeli uczenia maszynowego, które oferuje elastyczność i łatwość użycia dzięki dynamicznym grafom obliczeniowym i intuicyjnemu interfejsowi. Przedstawiony przykład klasyfikatora XOR pokazuje, jak w prosty sposób można zbudować i trenować model sieci neuronowej. Zachęcam do dalszej eksploracji możliwości PyTorch poprzez oficjalne tutoriale i dokumentację.

Źródła: