PyTorch et programmation orientée objet

Apprentissage profond intermédiaire avec PyTorch

Michal Oleszak

Machine Learning Engineer

Ce que vous allez apprendre

Comment entraîner des modèles d'apprentissage profond robustes :

Améliorer l'entraînement avec des optimiseurs
Atténuer les gradients évanescents et explosifs
Convolutional Neural Networks (CNNs)
Recurrent Neural Networks (RNNs)
Modèles à entrées et sorties multiples

Logo PyTorch

Prérequis

Le cours suppose que vous êtes à l'aise avec :

Entraînement de réseaux de neurones :
- Passage avant
- Calcul de la perte
- Passage arrière (rétropropagation)
Entraînement de 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, on crée 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)

Ensemble de données sur la potabilité de l'eau

DataFrame pandas affichant quelques premières et dernières lignes des données sur la 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 : charger les données et les stocker en tableau numpy
- super().__init__() assure que WaterDataset se comporte comme un Dataset de torch
len : retourner la taille de l'ensemble de données
getitem :
- prend un argument nommé idx
- retourne les caractéristiques et l'étiquette pour l'échantillon à l'indice 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 !

Apprentissage profond intermédiaire avec PyTorch