Préparer les données pour analyse

Dans l’étape précédente de ce tutoriel, nous avons installé PyTorch sur votre ordinateur. À présent, nous allons l’utiliser pour configurer notre code avec les données que nous allons utiliser pour créer notre modèle.

Ouvrez un nouveau projet dans Visual Studio.

1. Ouvrez Visual Studio et choisissez create a new project.

2. Dans la barre de recherche, tapez Python et sélectionnez Python Application comme modèle de projet.

3. Dans la fenêtre de configuration :

• Nommez votre projet. Ici, nous l’appelons DataClassifier.
• Choisissez l’emplacement du projet.
• Si vous utilisez VS 2019, vérifiez que la case Create directory for solution est cochée.
• Si vous utilisez VS2017, vérifiez que la case Place solution and project in the same directory n’est pas cochée.

Appuyez sur create pour créer votre projet.

Créer un interpréteur Python

Maintenant, vous devez définir un nouvel interpréteur Python. Cela doit inclure le package PyTorch que vous avez récemment installé.

1. Accédez à sélection de l’interpréteur, puis sélectionnez Add Environment :

2. Dans la fenêtre Add Environment, sélectionnez Existing environment, puis choisissez Anaconda3 (3.6, 64-bit). Cela inclut le package PyTorch.

Pour tester le nouvel interpréteur Python et le nouveau package PyTorch, entrez le code suivant dans le fichier DataClassifier.py :

from __future__ import print_function 

import torch 

x=torch.rand(2, 3) 

print(x) 

La sortie doit être un tenseur 5x3 aléatoire semblable à celle ci-dessous.

Remarque

Vous voulez en savoir plus ? Visitez le site web officiel de PyTorch.

Vue d’ensemble des données

Nous allons entraîner le modèle sur le jeu de données de fleurs appelé « Iris de Fisher ». Ce célèbre jeu de données contient 50 entrées sur chacune de ces trois espèces d’iris : Iris setosa, Iris virginica et Iris versicolor.

Plusieurs versions de ce jeu de données ont été publiées. Vous pouvez utiliser le jeu de données Iris disponible dans le dépôt UCI Machine Learning Repository, importer le jeu de données directement de la bibliothèque Python Scikit-learn ou encore choisir une autre version précédemment publiée. Pour en savoir plus sur le jeu de données Iris, consultez cette page Wikipédia.

Dans ce tutoriel, pour apprendre comment entraîner le modèle avec le type d’entrée tabulaire, vous allez utiliser le jeu de données Iris exporté dans le fichier Excel.

Chaque ligne du tableau Excel indique quatre caractéristiques des iris : la longueur des sépales en cm (sepal length in cm), la largeur de sépales en cm (sepal width in cm), la longueur des pétales en cm (petal length in cm) et la largeur des pétales en cm (petal width in cm). Ces caractéristiques feront office d’entrée. La dernière colonne contient le type d’iris correspondant à ces paramètres et représente la sortie de la régression. Au total, le jeu de données comprend 150 entrées pour les quatre caractéristiques, chacune étant associée au type d’iris correspondant.

L’analyse de régression examine la relation entre les variables d’entrée et le résultat. À partir de l’entrée, le modèle apprend à prédire le type de sortie correct, à savoir l’un de ces trois types d’iris : Iris-setosa, Iris-versicolor, Iris-virginica.

Important

Si vous choisissez d’utiliser un autre jeu de données pour créer votre propre modèle, vous devez spécifier les variables d’entrée et la sortie de votre modèle correspondant à votre scénario.

Chargez le jeu de données.

1. Téléchargez le jeu de données Iris au format Excel. Vous le trouverez ici.

2. Dans le fichier DataClassifier.py du dossier Fichiers de l’Explorateur de solutions, ajoutez l’instruction import suivante pour accéder à tous les packages dont nous aurons besoin.

import torch 
import pandas as pd 
import torch.nn as nn 
from torch.utils.data import random_split, DataLoader, TensorDataset 
import torch.nn.functional as F 
import numpy as np 
import torch.optim as optim 
from torch.optim import Adam 

Comme vous le voyez, vous allez utiliser le package pandas (analyse de données Python) pour charger et manipuler les données, ainsi que le package torch.nn qui contient des modules et des classes extensibles permettant de créer des réseaux neuronaux.

3. Chargez les données en mémoire et relevez le nombre de classes. En principe, vous devez voir 50 éléments de chaque type d’iris. N’oubliez pas de spécifier l’emplacement du jeu de données sur votre PC.

Ajoutez le code suivant au fichier DataClassifier.py.

# Loading the Data
df = pd.read_excel(r'C:…\Iris_dataset.xlsx') 
print('Take a look at sample from the dataset:') 
print(df.head()) 

# Let's verify if our data is balanced and what types of species we have  
print('\nOur dataset is balanced and has the following values to predict:') 
print(df['Iris_Type'].value_counts()) 

Lorsque nous exécutons ce code, la sortie attendue est la suivante :

Pour pouvoir utiliser le jeu de données et entraîner le modèle, nous devons définir une entrée et une sortie. L’entrée comprend 150 lignes de caractéristiques, et la sortie est la colonne du type d’iris. Le réseau neuronal que nous utiliserons accepte des variables numériques. Vous devez donc convertir la variable de sortie en un format numérique.

4. Créez une colonne dans le jeu de données qui représente la sortie dans un format numérique, puis définissez une entrée et une sortie de régression.

Ajoutez le code suivant au fichier DataClassifier.py.

# Convert Iris species into numeric types: Iris-setosa=0, Iris-versicolor=1, Iris-virginica=2.  
labels = {'Iris-setosa':0, 'Iris-versicolor':1, 'Iris-virginica':2} 
df['IrisType_num'] = df['Iris_Type']   # Create a new column "IrisType_num" 
df.IrisType_num = [labels[item] for item in df.IrisType_num]  # Convert the values to numeric ones 

# Define input and output datasets 
input = df.iloc[:, 1:-2]            # We drop the first column and the two last ones. 
print('\nInput values are:') 
print(input.head())   
output = df.loc[:, 'IrisType_num']   # Output Y is the last column  
print('\nThe output value is:') 
print(output.head()) 

Lorsque nous exécutons ce code, la sortie attendue est la suivante :

Pour entraîner le modèle, nous devons convertir l’entrée et la sortie du modèle au format du tenseur (Tensor) :

5. Pour effectuer cette conversion :

Ajoutez le code suivant au fichier DataClassifier.py.

# Convert Input and Output data to Tensors and create a TensorDataset 
input = torch.Tensor(input.to_numpy())      # Create tensor of type torch.float32 
print('\nInput format: ', input.shape, input.dtype)     # Input format: torch.Size([150, 4]) torch.float32 
output = torch.tensor(output.to_numpy())        # Create tensor type torch.int64  
print('Output format: ', output.shape, output.dtype)  # Output format: torch.Size([150]) torch.int64 
data = TensorDataset(input, output)    # Create a torch.utils.data.TensorDataset object for further data manipulation 

Quand nous exécutons le code, la sortie attendue affiche l’entrée et la sortie au format suivant :

Il y a 150 valeurs d’entrée. Environ 60 % de ces valeurs constituent les données d’entraînement du modèle. Vous gardez 20 % des données pour la validation et 30 % pour le test.

Dans ce tutoriel, la taille de lot d’un jeu de données d’entraînement est définie à 10. Il y a 95 éléments dans le jeu d’entraînement, ce qui signifie qu’en moyenne, il y a 9 lots complets disponibles par itération (une seule époque) sur le jeu d’entraînement. Vous conservez la taille de lot définie à 1 pour la validation et le test.

6. Divisez les données utilisées pour entraîner, valider et tester les jeux :

Ajoutez le code suivant au fichier DataClassifier.py.

# Split to Train, Validate and Test sets using random_split 
train_batch_size = 10        
number_rows = len(input)    # The size of our dataset or the number of rows in excel table.  
test_split = int(number_rows*0.3)  
validate_split = int(number_rows*0.2) 
train_split = number_rows - test_split - validate_split     
train_set, validate_set, test_set = random_split( 
    data, [train_split, validate_split, test_split])    
 
# Create Dataloader to read the data within batch sizes and put into memory. 
train_loader = DataLoader(train_set, batch_size = train_batch_size, shuffle = True) 
validate_loader = DataLoader(validate_set, batch_size = 1) 
test_loader = DataLoader(test_set, batch_size = 1)

Étapes suivantes

Une fois les données prêtes à l’emploi, il est temps d’effectuer l’entraînement de notre modèle PyTorch