Tutoriel : entraîner un modèle PyTorch

torch
pandas
ucimlrepo
scikit-learn
pyyaml

learning_rate: 0.1
epochs: 1000
model_type: Multivariate_neural_network_classifier

import argparse
import torch
from torch import nn
import yaml
import pandas as pd
from ucimlrepo import fetch_ucirepo

from sklearn.model_selection import train_test_split

class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear_stack = nn.Sequential(
            nn.Linear(in_features=16 , out_features=16),
            nn.Sigmoid(),
            nn.Linear(in_features=16, out_features=7)
        )

    def forward(self, x):
        logits = self.linear_stack(x)
        return logits

def main(args):
    # Charger les hyperparamètres à partir du fichier de configuration fourni
    with open(args.config, 'r') as f:
        hyperparameter_config = yaml.safe_load(f)

    # récupérer le jeu de données
    zoo = fetch_ucirepo(id=111)

    # données (sous forme de dataframes pandas)
    X = zoo.data.features
    y = zoo.data.targets

    print("features: ", X.shape, "type: ", type(X))
    print("labels: ", y.shape, "type: ", type(y))

    ## Traiter les données
    # Le type de données doit correspondre à celui du modèle ; le dtype par défaut de nn.Linear est torch.float32
    dataset = torch.tensor(X.values).type(torch.float32)

    # Convertir en tenseur et mettre en forme les labels de 0 à 6 pour l'indexation
    labels = torch.tensor(y.values)  - 1

    print("dataset: ", dataset.shape, "dtype: ",dataset.dtype)
    print("labels: ", labels.shape, "dtype: ",labels.dtype)

    torch.save(dataset, "zoo_dataset.pt")
    torch.save(labels, "zoo_labels.pt")

    # Décrire comment le jeu de données d'entraînement est divisé pour référence ultérieure et reproductibilité.
    config = {
        "random_state" : 42,
        "test_size" : 0.25,
        "shuffle" : True
    }

    # Diviser le jeu de données en ensemble d'entraînement et ensemble de test
    X_train, X_test, y_train, y_test = train_test_split(
        dataset,labels,
        random_state=config["random_state"],
        test_size=config["test_size"],
        shuffle=config["shuffle"]
    )

    # Enregistrer les fichiers localement
    torch.save(X_train, "zoo_dataset_X_train.pt")
    torch.save(y_train, "zoo_labels_y_train.pt")

    torch.save(X_test, "zoo_dataset_X_test.pt")
    torch.save(y_test, "zoo_labels_y_test.pt")


    ## Définir le modèle
    model = NeuralNetwork()
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=hyperparameter_config["learning_rate"])
    print(model)

    # Définir une valeur de perte initiale fictive pour la comparaison dans la boucle d'entraînement
    prev_best_loss = 1e10

    # Boucle d'entraînement
    for e in range(hyperparameter_config["epochs"] + 1):
        pred = model(X_train)
        loss = loss_fn(pred, y_train.squeeze(1))

        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

        # Enregistrer un point de contrôle / le modèle si la perte s'améliore
        if (e % 100 == 0) and (loss <= prev_best_loss):
            print("epoch: ", e, "loss:", loss.item())

            # Enregistrer la nouvelle meilleure perte
            prev_best_loss = loss

    print("Enregistrement du modèle...")
    PATH = 'zoo_wandb.pth'
    torch.save(model.state_dict(), PATH)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Entraîner un réseau de neurones simple sur le jeu de données zoo.")
    parser.add_argument("--config", type=str, required=True, help="Chemin vers le fichier de configuration des hyperparamètres.")
    args = parser.parse_args()
    main(args)