Rédaction de notre première boucle d’entraînement

Introduction au deep learning avec PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Entraînement d’un réseau de neurones

Créer un modèle
Choisir une fonction de perte
Définir un jeu de données
Sélectionner un optimiseur
Exécuter une boucle d’entraînement :
- Calculer la perte (passage avant)
- Calculer les gradients (rétropropagation)
- Mise à jour des paramètres du modèle

Données sur les salaires en Data Science

 experience_level  employment_type  remote_ratio  company_size  salary_in_usd  
        0                0               0.5             1            0.036 
        1                0               1.0             2            0.133     
        2                0               0.0             1            0.234  
        1                0               1.0             0            0.076  
        2                0               1.0             1            0.170

Caractéristiques : catégoriques, cible : salaire (USD)
Sortie finale : couche linéaire
Perte : spécifique à la régression

Perte d’erreur quadratique moyenne

La perte MSE correspond à la moyenne des différences au carré entre les prédictions et la vérité terrain.

def mean_squared_loss(prediction, target):
  return np.mean((prediction - target)**2)

dans PyTorch :

criterion = nn.MSELoss()
# Prediction and target are float tensors
loss = criterion(prediction, target)

Avant la boucle d’entraînement

# Create the dataset and the dataloader
dataset = TensorDataset(torch.tensor(features).float(),
                        torch.tensor(target).float())


dataloader = DataLoader(dataset, batch_size=4, shuffle=True)


# Create the model
model = nn.Sequential(nn.Linear(4, 2), 
                      nn.Linear(2, 1))


# Create the loss and optimizer
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.001)

La boucle d’entraînement

for epoch in range(num_epochs):

    for data in dataloader:

        # Set the gradients to zero
        optimizer.zero_grad()

        # Get feature and target from the data loader
        feature, target = data

        # Run a forward pass
        pred = model(feature)
        # Compute loss and gradients
        loss = criterion(pred, target)
        loss.backward()

        # Update the parameters
        optimizer.step()

Passons à la pratique !

Introduction au deep learning avec PyTorch