Comment construire un classificateur d'apprentissage automatique en Python avec Scikit-learn
Introduction
L'apprentissage automatique est un domaine de recherche en informatique, en intelligence artificielle et en statistiques. L'objectif de l'apprentissage automatique est de former des algorithmes à apprendre des modèles et à faire des prédictions à partir de données. L'apprentissage automatique est particulièrement précieux car il nous permet d'utiliser des ordinateurs pour automatiser les processus de prise de décision.
Vous trouverez des applications d'apprentissage automatique partout. Netflix et Amazon utilisent l'apprentissage automatique pour faire de nouvelles recommandations de produits. Les banques utilisent l'apprentissage automatique pour détecter des activités frauduleuses dans les transactions par carte de crédit, et les entreprises de santé commencent à utiliser l'apprentissage automatique pour surveiller, évaluer et diagnostiquer les patients.
Dans ce tutoriel, vous allez implémenter un algorithme d'apprentissage automatique simple en Python en utilisant Scikit-learn, un outil d'apprentissage automatique pour Python. À l'aide d'une base de données d'informations sur les tumeurs du cancer du sein, vous utiliserez un classificateur Naive Bayes (NB) qui prédit si une tumeur est maligne ou bénigne.
À la fin de ce tutoriel, vous saurez comment créer votre propre modèle d'apprentissage automatique en Python.
Conditions préalables
Pour compléter ce tutoriel, vous aurez besoin de :
Python 3 et un environnement de programmation local configuré sur votre ordinateur. Vous pouvez suivre le guide d'installation et de configuration approprié pour votre système d'exploitation.
- Si vous êtes nouveau en Python, vous pouvez explorer Comment coder en Python 3 pour vous familiariser avec le langage.
Étape 1 — Importer Scikit-learn
Commençons par installer le module Python Scikit-learn, l'une des meilleures bibliothèques de machine learning pour Python et la mieux documentée.
Pour commencer notre projet de codage, activons notre environnement de programmation Python 3. Assurez-vous d'être dans le répertoire où se trouve votre environnement et exécutez la commande suivante :
- . my_env/bin/activate
Avec notre environnement de programmation activé, vérifiez si le module Sckikit-learn est déjà installé :
- python -c "import sklearn"
Si sklearn est installé, cette commande se terminera sans erreur. Si ce n'est pas installé, vous verrez le message d'erreur suivant :
Traceback (most recent call last): File "<string>", line 1, in <module> ImportError: No module named 'sklearn'
Le message d'erreur indique que sklearn n'est pas installé, alors téléchargez la bibliothèque en utilisant pip:
- pip install scikit-learn[alldeps]
Une fois l'installation terminée, lancez Jupyter Notebook :
- jupyter notebook
Dans Jupyter, créez un nouveau Notebook Python appelé Tutoriel ML. Dans la première cellule du Notebook, importez le module sklearn :
import sklearn
Votre carnet devrait ressembler à la figure suivante :
Maintenant que nous avons sklearn importé dans notre notebook, nous pouvons commencer à travailler avec l'ensemble de données pour notre modèle d'apprentissage automatique.
Étape 2 — Importation du jeu de données de Scikit-learn
Le jeu de données avec lequel nous allons travailler dans ce tutoriel est la Base de Données Diagnostique du Cancer du Sein du Wisconsin. Ce jeu de données inclut diverses informations sur les tumeurs du sein, ainsi que des étiquettes de classification malignes ou bénignes. Le jeu de données comprend 569 instances, ou données, sur 569 tumeurs et contient des informations sur 30 attributs, ou caractéristiques, telles que le rayon de la tumeur, la texture, la douceur, et la surface.
En utilisant cet ensemble de données, nous allons construire un modèle d'apprentissage automatique pour utiliser les informations sur les tumeurs afin de prédire si une tumeur est maligne ou bénigne.
Scikit-learn est livré avec divers ensembles de données que nous pouvons charger dans Python, et l'ensemble de données dont nous avons besoin est inclus. Importez et chargez l'ensemble de données :
...
from sklearn.datasets import load_breast_cancer
Load dataset
data = load_breast_cancer()
La variable data représente un objet Python qui fonctionne comme un dictionnaire. Les clés de dictionnaire importantes à considérer sont les noms des étiquettes de classification (target_names), les étiquettes réelles (target), les noms des attributs/caractéristiques (feature_names), et les attributs (data).
Les attributs sont une partie essentielle de tout classificateur. Les attributs capturent des caractéristiques importantes sur la nature des données. Étant donné l'étiquette que nous essayons de prédire (tumeur maligne versus tumeur bénigne), les attributs utiles possibles incluent la taille, le rayon et la texture de la tumeur.
Créez de nouvelles variables pour chaque ensemble d'informations importantes et assignez les données :
...
Organize our data
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
Nous avons maintenant des listes pour chaque ensemble d'informations. Pour mieux comprendre notre ensemble de données, examinons nos données en imprimant nos étiquettes de classe, l'étiquette de la première instance de données, nos noms de caractéristiques et les valeurs des caractéristiques pour la première instance de données :
...
Look at our data
print(label_names)
print(labels[0])
print(feature_names[0])
print(features[0])
Vous verrez les résultats suivants si vous exécutez le code :
Comme l'image le montre, nos classes sont malin et bénin, qui sont ensuite associés aux valeurs binaires de 0 et 1, où 0 représente les tumeurs malignes et 1 représente les tumeurs bénignes. Par conséquent, notre première instance de données est une tumeur maligne dont le rayon moyen est de 1.79900000e+01.
Maintenant que nous avons nos données chargées, nous pouvons travailler avec nos données pour construire notre classificateur d'apprentissage automatique.
Étape 3 — Organisation des données en ensembles
Pour évaluer les performances d'un classificateur, vous devez toujours tester le modèle sur des données non vues. Par conséquent, avant de construire un modèle, divisez vos données en deux parties : un ensemble d'entraînement et un ensemble de test.
Vous utilisez l'ensemble d'entraînement pour entraîner et évaluer le modèle lors de la phase de développement. Vous utilisez ensuite le modèle entraîné pour faire des prédictions sur l'ensemble de test non vu. Cette approche vous donne une idée de la performance et de la robustesse du modèle.
Heureusement, sklearn a une fonction appelée train_test_split(), qui divise vos données en ces ensembles. Importez la fonction et utilisez-la ensuite pour diviser les données :
...
from sklearn.model_selection import train_test_split
Split our data
train, test, train_labels, test_labels = train_test_split(features,
labels,
test_size=0.33,
random_state=42)
La fonction divise aléatoirement les données en utilisant le paramètre test_size. Dans cet exemple, nous avons maintenant un jeu de test (test) qui représente 33% de l'ensemble de données original. Les données restantes (train) constituent alors les données d'entraînement. Nous avons également les étiquettes respectives pour les variables d'entraînement/de test, c'est-à-dire train_labels et test_labels.
Nous pouvons maintenant passer à l'entraînement de notre premier modèle.
Étape 4 — Construction et évaluation du modèle
Il existe de nombreux modèles pour l'apprentissage automatique, et chaque modèle a ses propres forces et faiblesses. Dans ce tutoriel, nous allons nous concentrer sur un algorithme simple qui fonctionne généralement bien dans les tâches de classification binaire, à savoir Naive Bayes (NB).
Tout d'abord, importez le module GaussianNB. Ensuite, initialisez le modèle avec la fonction GaussianNB(), puis entraînez le modèle en l'ajustant aux données en utilisant gnb.fit():
...
from sklearn.naive_bayes import GaussianNB
Initialize our classifier
gnb = GaussianNB()
Train our classifier
model = gnb.fit(train, train_labels)
Après avoir entraîné le modèle, nous pouvons ensuite utiliser le modèle entraîné pour faire des prédictions sur notre ensemble de test, ce que nous faisons en utilisant la fonction predict(). La fonction predict() renvoie un tableau de prédictions pour chaque instance de données de l'ensemble de test. Nous pouvons ensuite imprimer nos prédictions pour avoir une idée de ce que le modèle a déterminé.
Utilisez la fonction predict() avec le jeu de données test et imprimez les résultats :
...
Make predictions
preds = gnb.predict(test)
print(preds)
Exécutez le code et vous verrez les résultats suivants :
Comme vous pouvez le voir dans la sortie du Jupyter Notebook, la fonction predict() a renvoyé un tableau de 0s et de 1s qui représentent nos valeurs prédites pour la classe de tumeur (maligne vs bénigne).
Maintenant que nous avons nos prévisions, évaluons la performance de notre classificateur.
Étape 5 — Évaluer la précision du modèle
En utilisant l'ensemble des étiquettes de classes réelles, nous pouvons évaluer la précision des valeurs prédites par notre modèle en comparant les deux tableaux (test_labels contre preds). Nous utiliserons la fonction accuracy_score() de sklearn pour déterminer la précision de notre classificateur d'apprentissage automatique.
...
from sklearn.metrics import accuracy_score
Evaluate accuracy
print(accuracy_score(test_labels, preds))
Vous verrez les résultats suivants :
Comme vous pouvez le voir dans le résultat, le classificateur NB est précis à 94,15 %. Cela signifie que 94,15 % du temps, le classificateur est capable de faire la bonne prédiction quant à savoir si la tumeur est maligne ou bénigne. Ces résultats suggèrent que notre ensemble de caractéristiques de 30 attributs est un bon indicateur de la classe de la tumeur.
Vous avez réussi à construire votre premier classificateur d'apprentissage automatique. Réorganisons le code en plaçant toutes les instructions import en haut du Notebook ou du script. La version finale du code devrait ressembler à ceci :
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score
Load dataset
data = load_breast_cancer()
Organize our data
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
Look at our data
print(label_names)
print('Class label = ', labels[0])
print(feature_names)
print(features[0])
Split our data
train, test, train_labels, test_labels = train_test_split(features,
labels,
test_size=0.33,
random_state=42)
Initialize our classifier
gnb = GaussianNB()
Train our classifier
model = gnb.fit(train, train_labels)
Make predictions
preds = gnb.predict(test)
print(preds)
Evaluate accuracy
print(accuracy_score(test_labels, preds))
Vous pouvez maintenant continuer à travailler sur votre code pour voir si vous pouvez rendre votre classificateur encore plus performant. Vous pourriez expérimenter avec différents sous-ensembles de caractéristiques ou même essayer des algorithmes complètement différents. Consultez le site Web de Scikit-learn pour plus d'idées sur l'apprentissage machine.
Conclusion
Dans ce tutoriel, vous avez appris à construire un classificateur d'apprentissage automatique en Python. Maintenant, vous pouvez charger des données, organiser des données, entraîner, prédire et évaluer des classificateurs d'apprentissage automatique en Python en utilisant Scikit-learn. Les étapes de ce tutoriel devraient vous aider à faciliter le processus de travail avec vos propres données en Python.