PyTorch-Intro

Ce este PyTorch?

PyTorch este o biblioteca de deep learning construita in limbajul de programare Python. Aceasta ofera accelerare GPU, grafuri de calculare dinamice si o interfata intuitiva pentru cercetatori si dezvoltatorii din domeniul deep learning. PyTorch urmeaza o abordare "define-by-run", ceea ce inseamna ca grafurile sale de calcul sunt construite din mers, permitand o depanare mai buna si o personalizare mai usoara a modelelor.

Caracteristici cheie ale PyTorch:

• Foloseste grafuri dinamice, oferind flexibilitate in executia si depanarea modelelor. 
• Ofera un motor de diferentiere automata care simplifica calculul gradientilor pentru deep learning.
• Suporta CUDA, permitand efectuarea eficienta a calculelor pe GPU-uri.

PyTorch poate sa fie instalat pe Windows, macOS si Linux. Acesta se instaleaza folosind comanda:

"!pip install torch torchvision torchaudio"

PyTorch Tensors

Tensori sunt structurile fundamentale de date in PyTorch, similare cu array-urile din NumPy, dar cu capabilitati de accelerare pe GPU. Tensorii PyTorch suporta diferentiere automata, ceea ce ii face potriviti pentru sarcini de deep learning.

import torch

x = torch.tensor([1.0, 2.0, 3.0])
print('1D Tensor: \n', x)

y = torch.zeros((3, 3))
print('2D Tensor: \n', y)

In consola o sa vedem:

Operatii pe tensori

a = torch.tensor([1.0, 2.0])
b = torch.tensor([3.0, 4.0])

print('Element Wise Addition of a & b: \n', a + b)

print('Matrix Multiplication of a & b: \n', 
      torch.matmul(a.view(2, 1), b.view(1, 2)))

In consola o sa vedem:

Reshape si Transpunerea Tensorilor

import torch 
t = torch.tensor([[1, 2, 3, 4],
                 [5, 6, 7, 8],
                 [9, 10, 11, 12]])

print("Reshaping")
print(t.reshape(6, 2))

print("\nResizing")
print(t.view(2, 6))

print("\nTransposing")
print(t.transpose(0, 1))

In consola o sa vedem:

Autograd si grafurile computationale

Modul autograd automatizeaza calculul gradientilor pentru backpropagation. Acest lucru este esential in antrenarea retelelor neuronale profunde.

x = torch.tensor(2.0, requires_grad=True)
y = x ** 2
y.backward()
print(x.grad) 

In consola o sa vedem:

tensor(4.)

PyTorch creeaza dinamic un graf computational care urmareste operatiile si gradientii pentru backpropagation.

Construim o retea neuronala cu PyTorch

In PyTorch, retelele neuronale sunt construite folosind modulul torch.nn, unde:

• nn.Linear(in_features, out_features) defineste un strat complet conectat(dense).
• Functiile de activare precum torch.relu, torch.sigmoid sau torch.softmax sunt aplicate intre straturi.
• Metoda forward() defineste modul in care datele trec prin retea.

Pentru a construi o retea neuronala in PyTorch, cream o clasa care mosteneste din torch.nn.Module si defineste straturile si propagarea inainte (forward pass).

import torch
import torch.nn as nn

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.fc1 = nn.Linear(10, 16)  # First layer
        self.fc2 = nn.Linear(16, 8)   # Second layer
        self.fc3 = nn.Linear(8, 1)    # Output layer

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

model = NeuralNetwork()
print(model)

In consola o sa vedem:

Definirea functiei de pierdere si a optimizerului

Dupa ce definim modelul trebuie sa specificam:

• O functie de pierdere pentru a masura eroarea
• Un optimizer pentru a actualiza ponderile pe baza gradientilor calculati

Folosim nn.BCELoss() pentru pierderea de tip entropie incrucisata binara si optim.Adam() pentru optimizerul Adam care combina baneficiile momentului si ale ratelor de invatare adaptive.

model = NeuralNetwork()
criterion = nn.BCELoss()  
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

Antrenarea modelului

1.Generarea de date fictive (100 de esantioane, fiecare cu 10 caracteristici)

2.Rularea buclei de antrenare unde:

• optimizer.zero_grad(): sterge gradientii acumulati din pasul anterior.
• Forward Pass (model(inputs)): trimite datele de intrare prin model pentru a genera predictii.
• Calculul pierderii (criterion(outputs, targets)): calculeaza diferenta dintre predictii si etichetele reale.
• Backpropagation (loss.backward()): calculeaza gradientii pentru toate ponderile.
• Pasul optimizerului (optimizer.step()): actualizeaza ponderile pe baza gradientilor calculati.

inputs = torch.randn((100, 10)) 
targets = torch.randint(0, 2, (100, 1)).float()  
epochs = 20

for epoch in range(epochs):
    optimizer.zero_grad()  # Reset gradients
    outputs = model(inputs)  # Forward pass
    loss = criterion(outputs, targets)  # Compute loss
    loss.backward()  # Compute gradients
    optimizer.step()  # Update weights

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

In consola o sa vedem: