Python Machine Learning : Tutoriel Scikit-Learn

L'apprentissage automatique est un sous-domaine de l'intelligence artificielle consacré à la compréhension et à l'élaboration de méthodes permettant d'imiter la façon dont les humains apprennent. Ces méthodes comprennent l'utilisation d'algorithmes et de données pour améliorer les performances d'un ensemble de tâches et relèvent souvent de l'un des trois types d'apprentissage les plus courants : 

• Apprentissage supervisé: un type d'apprentissage automatique qui apprend la relation entre l'entrée et la sortie. 
• Apprentissage non supervisé: un type d'apprentissage automatique qui apprend la structure sous-jacente d'un ensemble de données non étiquetées.   
• Apprentissage par renforcement: méthode d'apprentissage automatique dans laquelle l'agent logiciel apprend à effectuer certaines actions dans un environnement qui le conduisent à une récompense maximale.

Scikit-learn, également connu sous le nom de sklearn, est une bibliothèque d'apprentissage automatique Python robuste et open-source. Il a été créé pour aider à simplifier le processus de mise en œuvre de l'apprentissage automatique et des modèles statistiques en Python. 

La bibliothèque permet aux praticiens de mettre rapidement en œuvre une vaste gamme d'algorithmes d'apprentissage automatique supervisés et non supervisés par le biais d'une interface cohérente. Sklearn a été construit au-dessus de SciPy et fonctionne sur tous les types de données numériques stockées soit sous forme de tableaux NumPy, de matrices éparses SciPy, et tous les autres types de données qui peuvent être convertis en tableaux numériques tels que les DataFrame de Pandas.  

Dans ce tutoriel pratique sur Sklearn, nous aborderons différents aspects du cycle de vie de l'apprentissage automatique, tels que le traitement des données, l'entraînement des modèles et l'évaluation des modèles.  

Consultez cet espace de travail DataCamp pour suivre le code. 

Data

Le premier aspect de Scikit-learn que nous allons explorer est celui des données. Scikit-learn est livré avec des ensembles de données d'apprentissage automatique standard, ce qui signifie que vous n'avez pas besoin de les télécharger à partir d'un site web ou d'une base de données externe. 

Exemples de jeux de données jeux de données-jouets disponibles dans sklearn comprennent l'ensemble de données de l'iris pour la classification et l'ensemble de données du diabète pour la régression. Pour notre exemple, nous utiliserons l'ensemble de données sur le vin.

Chargeons-le dans la mémoire :

from sklearn.datasets import load_wine

wine_data = load_wine() 

L'exécution du code ci-dessus renvoie un objet de type dictionnaire contenant les données ainsi que des métadonnées sur les données qu'il contient. 

Les données dont nous avons besoin se trouvent dans le fichier .data de l'objet de type dictionnaire, mais comme il ne s'agit pas d'un véritable dictionnaire, nous pouvons y accéder en tant qu'attribut de l'instance wine_data comme suit :

wine_data.data

Cette méthode renvoie un tableau N x M où N est le nombre d'échantillons et M le nombre de caractéristiques.  

Utilisons ces connaissances pour charger nos données dans un DataFrame DataFrame pandasqui est beaucoup plus facile à manipuler et à analyser.

import pandas as pd
from sklearn.datasets import load_wine

wine_data = load_wine()

# Convert data to pandas dataframe
wine_df = pd.DataFrame(wine_data.data, columns=wine_data.feature_names)

# Add the target label
wine_df["target"] = wine_data.target

# Take a preview
wine_df.head()

Vous êtes maintenant prêt à explorer les données. 

Exploration des données

Les DataFrame de Pandas sont définies comme des structures de données étiquetées bidimensionnelles composées de colonnes, qui peuvent contenir différentes étapes de données. La façon la plus simple de conceptualiser un DataFrame est de le considérer comme trois composants fusionnés ensemble ; ces composants sont 1) les données, 2) un index et 3) les colonnes. 

L'exploration des données n'est pas le sujet principal de cet article, mais il s'agit d'une étape extrêmement importante dans tout projet de données - vous pouvez en apprendre davantage à ce sujet dans notre Didacticiel sur l'analyse exploratoire des données en Python. Nous ferons une brève exploration pour avoir une meilleure idée de ce que contient notre ensemble de données ; cela nous donnera une meilleure idée de la façon de traiter les données. 

La première chose que nous allons faire est d'appeler la fonction info() sur notre DataFrame pandas ; cela permettra d'imprimer un résumé concis des données sur le vin contenues dans la DataFrame.

wine_df.info()

"""

RangeIndex: 178 entries, 0 to 177
Data columns (total 14 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   alcohol                       178 non-null    float64
 1   malic_acid                    178 non-null    float64
 2   ash                           178 non-null    float64
 3   alcalinity_of_ash             178 non-null    float64
 4   magnesium                     178 non-null    float64
 5   total_phenols                 178 non-null    float64
 6   flavanoids                    178 non-null    float64
 7   nonflavanoid_phenols          178 non-null    float64
 8   proanthocyanins               178 non-null    float64
 9   color_intensity               178 non-null    float64
 10  hue                           178 non-null    float64
 11  od280/od315_of_diluted_wines  178 non-null    float64
 12  proline                       178 non-null    float64
 13  target                        178 non-null    int64  
dtypes: float64(13), int64(1)
memory usage: 19.6 KB
"""

Après avoir exécuté cette cellule, vous apprendrez : 

• Les données contiennent 178 échantillons de données
• Il y a 14 colonnes au total, y compris la colonne cible (ce que nous voulons prédire).
• Il y a 0 colonne avec des valeurs manquantes ; vous pouvez le déduire de la colonne "Non-Null Count". 
• Toutes les caractéristiques sont de type float64alors que l'étiquette cible est de type int64.
• Les données utilisent 19,6 Ko de mémoire. 

Nous pouvons également appeler la méthode describe() sur notre DataFrame pour obtenir des statistiques descriptives sur chaque caractéristique de l'ensemble de données. 

Par exemple : 

wine_df.describe() 

Vous devez également avoir une idée du type de valeurs détenues dans chaque caractéristique. Le moyen le plus rapide d'apprendre cela est d'utiliser la méthode head() pour afficher les cinq premières lignes de données ou la méthode tail() pour afficher les cinq dernières lignes de données. 

wine_df.tail()

L'exécution de ce code nous montre que nos caractéristiques se situent à des échelles différentes, ce qui peut poser des problèmes lors de l'utilisation d'algorithmes basés sur la descente de gradient, tels que la régression logistique, et lors de l'utilisation d'algorithmes basés sur la distance, tels que les machines à vecteurs de support. Cela s'explique par le fait qu'ils sont sensibles à la gamme de points de données. 

Dans un flux de travail d'apprentissage automatique normal, ce processus sera beaucoup plus long, mais nous allons passer directement au traitement des données pour revenir au sujet principal de ce tutoriel, Scikit-learn. 

Pour en savoir plus sur Pandas, consultez le sitePython Pandas Tutorial : Le guide ultime pour les débutants. 

Exemple de Scikit-learn : Prétraitement des données

Nous avons une bonne compréhension de la nature de nos données. Lorsque vous avez atteint ce stade, cela signifie généralement que vous êtes prêt à commencer à préparer les données qui seront introduites dans un modèle d'apprentissage automatique. 

Le traitement des données est une étape essentielle du flux de travail de l'apprentissage automatique, car les données du monde réel sont désordonnées. Il peut contenir : 

• Valeurs manquantes,
• Valeurs redondantes
• Valeurs aberrantes
• Erreurs
• Bruit

Vous devez traiter tous ces éléments avant de transmettre les données à un modèle d'apprentissage automatique ; sinon, le modèle intégrera ces erreurs dans sa fonction d'approximation - il apprendra à faire des erreurs sur de nouvelles instances. C'est ce qui a donné naissance au célèbre dicton de l'apprentissage automatique, "Garbage in, garbage out". 

Une autre raison est que les modèles d'apprentissage automatique nécessitent généralement des données numériques.  

Hormis le fait que nos données se situent sur des échelles différentes, il n'y a pas grand-chose d'autre qui cloche dans nos données à première vue. Pour résoudre ce problème, normalisons les caractéristiques à l'aide de laclasse StandardScaler de sklearn( ) ,ce qui permettra de s'assurer que la moyenne de chaque caractéristique est approximativement égale à zéro.

Voici le code : 

from sklearn.preprocessing import StandardScaler

# Split data into features and label 
X = wine_df[wine_data.feature_names].copy()
y = wine_df["target"].copy() 

# Instantiate scaler and fit on features
scaler = StandardScaler()
scaler.fit(X)

# Transform features
X_scaled = scaler.transform(X.values)

# View first instance
print(X_scaled[0])

"""
[ 1.51861254 -0.5622498   0.23205254 -1.16959318  1.91390522  0.80899739
  1.03481896 -0.65956311  1.22488398  0.25171685  0.36217728  1.84791957
  1.01300893]
"""

Passons maintenant à la formation du modèle. 

Exemple de Scikit-learn : Modèle de formation

Avant qu'un modèle d'apprentissage automatique puisse faire des prédictions, il doit être entraîné sur un ensemble de données pour apprendre une fonction d'approximation. 

Mais comment savoir si le modèle fonctionne bien sur des données qu'il n'a jamais vues auparavant ? Nous ne le saurons pas tant que nous ne l'aurons pas testé. 

L'un des moyens de tester un modèle d'apprentissage automatique avant de le placer dans un environnement où il aura un impact sur d'autres personnes consiste à diviser les données d'apprentissage en un ensemble d'apprentissage et un ensemble de test et à utiliser l'ensemble de test pour évaluer ce que le modèle a appris ; c'est ce que l'on appelle l'évaluation hors ligne. 

Il existe plusieurs façons de diviser les données en ensembles de formation et de test, mais scikit-learn dispose d'une fonction intégrée pour le faire à notre place, appelée train_test_split().

Nous utiliserons cette fonction pour diviser nos données de manière à ce que 70 % soient utilisés pour entraîner le modèle et que 30 % soient utilisés pour évaluer la capacité du modèle à se généraliser à des instances inédites. 

from sklearn.model_selection import train_test_split

# Split data into train and test
X_train_scaled, X_test_scaled, y_train, y_test = train_test_split(X_scaled,
                                                                  y,
                                                             train_size=.7,
                                                           random_state=25)

# Check the splits are correct
print(f"Train size: {round(len(X_train_scaled) / len(X) * 100)}% \n\
Test size: {round(len(X_test_scaled) / len(X) * 100)}%")

"""
Train size: 70% 
Test size: 30%

Construisons maintenant quelques modèles. 

Construire le modèle

Grâce à sklearn, la construction d'un modèle d'apprentissage automatique est extrêmement simple. 

Nous allons construire trois modèles pour prédire la classe du vin : 

1. Régression logistique
2. Machine à vecteur de support 
3. Arbre de décision

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

# Instnatiating the models 
logistic_regression = LogisticRegression()
svm = SVC()
tree = DecisionTreeClassifier()

# Training the models 
logistic_regression.fit(X_train_scaled, y_train)
svm.fit(X_train_scaled, y_train)
tree.fit(X_train_scaled, y_train)

# Making predictions with each model
log_reg_preds = logistic_regression.predict(X_test_scaled)
svm_preds = svm.predict(X_test_scaled)
tree_preds = tree.predict(X_test_scaled)

L'étape suivante consiste à évaluer la manière dont les modèles se généralisent dans les cas non vus. 

Exemple de Scikit-learn : Évaluation du modèle

L'évaluation du modèle permet de tester la capacité du modèle à s'appliquer à des cas inédits. Scikit-learn fournit un ensemble de mesures de classification et de régression pour évaluer les performances d'un modèle entraîné. 

Pour notre cas d'utilisation, nous allons utiliser rapport_classification() de la classe metrics pour créer un rapport textuel présentant les principales mesures de classification telles que la précision, le rappel, le score f1, l'exactitude, etc.

Voici comment cela se présente dans le code :

from sklearn.metrics import classification_report

# Store model predictions in a dictionary
# this makes it's easier to iterate through each model
# and print the results. 
model_preds = {
    "Logistic Regression": log_reg_preds,
    "Support Vector Machine": svm_preds,
    "Decision Tree": tree_preds
}

for model, preds in model_preds.items():
    print(f"{model} Results:\n{classification_report(y_test, preds)}", sep="\n\n")

"""
Logistic Regression Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      0.92      0.96        25
           2       0.86      1.00      0.92        12

    accuracy                           0.96        54
   macro avg       0.95      0.97      0.96        54
weighted avg       0.97      0.96      0.96        54

Support Vector Machine Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      1.00      1.00        25
           2       1.00      1.00      1.00        12

    accuracy                           1.00        54
   macro avg       1.00      1.00      1.00        54
weighted avg       1.00      1.00      1.00        54

Decision Tree Results:
              precision    recall  f1-score   support

           0       0.94      0.94      0.94        17
           1       0.96      0.88      0.92        25
           2       0.86      1.00      0.92        12

    accuracy                           0.93        54
   macro avg       0.92      0.94      0.93        54
weighted avg       0.93      0.93      0.93        54
"""

À première vue, il semble que la machine à vecteur de support soit le meilleur modèle. Dans un flux de travail classique, cela susciterait la curiosité pour le modèle - est-il vraiment aussi bon qu'il le montre, ou avons-nous fait une erreur quelque part ? Vous devriez être curieux d'en savoir plus sur vos modèles et sur ce qu'ils apprennent, car cela vous donnera une meilleure idée de leurs forces et de leurs faiblesses. 

La connaissance de ces informations est extrêmement utile aux parties prenantes, car elle leur permet de trouver des solutions pour compenser les lacunes du modèle. 

Conclusion

La bibliothèque scikit-learn se compose de plusieurs modules qui facilitent la mise en œuvre de modèles d'apprentissage automatique. Ces modules vont des outils de prétraitement pour vous aider à préparer votre modèle à être introduit dans un modèle d'apprentissage automatique aux modèles que vous pouvez utiliser pour trouver des modèles dans vos données, en passant par les mesures d'évaluation que vous pouvez utiliser pour évaluer la performance de votre modèle. 

Dans ce tutoriel, nous n'avons fait qu'effleurer les capacités de Sklearn. Pour approfondir ce que vous pouvez faire avec la bibliothèque, nous disposons de plusieurs ressources pour vous mettre sur la voie. En voici quelques-uns pour commencer : 

• Apprentissage supervisé avec scikit-learn
• Apprentissage non supervisé en Python
• Classification K-Nearest neighbors (KNN) avec scikit-learn