PyTorch et programmation orientée objet

Deep learning intermédiaire avec PyTorch

Michal Oleszak

Machine Learning Engineer

Ce que nous allons apprendre

Comment entraîner des modèles robustes :

Améliorer l’entraînement avec des optimiseurs
Atténuer les gradients qui s’annulent/explosent
Réseaux de neurones convolutionnels (CNN)
Réseaux de neurones récurrents (RNN)
Modèles à entrées et sorties multiples

Logo PyTorch

Prérequis

Le cours suppose que vous maîtrisez :

Entraînement des réseaux de neurones :
- Passage avant (forward)
- Calcul de la perte
- Passage arrière (rétropropagation)
Entraîner des modèles avec PyTorch :
- Datasets et DataLoaders
- Boucle d’entraînement
- Évaluation du modèle
Cours préalable : Introduction to Deep Learning with PyTorch

Programmation orientée objet (POO)

Nous utiliserons la POO pour définir :
- Datasets PyTorch
- Modèles PyTorch
En POO, nous créons des objets avec :
- Capacités (méthodes)
- Données (attributs)

Programmation orientée objet (POO)

class BankAccount:
    def __init__(self, balance):
        self.balance = balance

__init__ est appelé lors de la création d’un objet BankAccount
balance est l’attribut de l’objet BankAccount

account = BankAccount(100)
print(account.balance)

Programmation orientée objet (POO)

Méthodes : fonctions Python pour exécuter des tâches
La méthode deposit augmente le solde

class BankAccount:
    def __init__(self, balance):
        self.balance = balance


    def deposit(self, amount):
        self.balance += amount

account = BankAccount(100)
account.deposit(50)
print(account.balance)

Jeu de données sur la potabilité de l’eau

DataFrame Pandas montrant quelques premières et dernières lignes des données de potabilité de l’eau.

Dataset PyTorch

from torch.utils.data import Dataset

class WaterDataset(Dataset):

    def __init__(self, csv_path):
        super().__init__()
        df = pd.read_csv(csv_path)
        self.data = df.to_numpy()


    def __len__(self):
        return self.data.shape[0]


    def __getitem__(self, idx):
        features = self.data[idx, :-1]
        label = self.data[idx, -1]
        return features, label

init : charge les données, stockées en tableau numpy
- super().__init__() garantit que WaterDataset se comporte comme Dataset de torch
len : renvoie la taille du jeu de données
getitem :
- prend un argument idx
- renvoie les features et le label d’un échantillon à l’index idx

DataLoader PyTorch

dataset_train = WaterDataset(
    "water_train.csv"
)

from torch.utils.data import DataLoader

dataloader_train = DataLoader(
    dataset_train,
    batch_size=2,
    shuffle=True,
)

features, labels = next(iter(dataloader_train))
print(f"Features: {features},\nLabels: {labels}")

Features: tensor([
  [0.4899, 0.4180, 0.6299, 0.3496, 0.4575,
   0.3615, 0.3259, 0.5011, 0.7545],
  [0.7953, 0.6305, 0.4480, 0.6549, 0.7813,
   0.6566, 0.6340, 0.5493, 0.5789]
]),
Labels: tensor([1., 0.])

Modèle PyTorch

Définition d’un modèle séquentiel :

net = nn.Sequential(
  nn.Linear(9, 16),
  nn.ReLU(),
  nn.Linear(16, 8),
  nn.ReLU(),
  nn.Linear(8, 1),
  nn.Sigmoid(),
)

Définition d’un modèle basé sur une classe :

class Net(nn.Module):

    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(9, 16)
        self.fc2 = nn.Linear(16, 8)
        self.fc3 = nn.Linear(8, 1)


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

net = Net()

Passons à la pratique !

Deep learning intermédiaire avec PyTorch