Classification - Introduction

Introduction à la classification

La classification peut être définie comme le processus de prédiction d'une classe ou d'une catégorie à partir de valeurs observées ou de points de données donnés. La sortie catégorisée peut avoir la forme «noire» ou «blanche» ou «spam» ou «pas de spam».

Mathématiquement, la classification est la tâche d'approximer une fonction de mappage (f) des variables d'entrée (X) aux variables de sortie (Y). Il appartient essentiellement à l'apprentissage automatique supervisé dans lequel des cibles sont également fournies avec l'ensemble de données d'entrée.

Un exemple de problème de classification peut être la détection de spam dans les e-mails. Il ne peut y avoir que deux catégories de sortie, «spam» et «pas de spam»; il s'agit donc d'une classification de type binaire.

Pour implémenter cette classification, nous devons d'abord former le classificateur. Pour cet exemple, les e-mails «spam» et «pas de spam» seraient utilisés comme données d'entraînement. Après avoir entraîné avec succès le classificateur, il peut être utilisé pour détecter un e-mail inconnu.

Types d'apprenants en classification

Nous avons deux types d'apprenants en ce qui concerne les problèmes de classification -

Apprenants paresseux

Comme son nom l'indique, ce type d'apprenants attend que les données de test apparaissent après le stockage des données de formation. La classification est effectuée uniquement après avoir obtenu les données de test. Ils passent moins de temps à s'entraîner mais plus à prévoir. Des exemples d'apprenants paresseux sont le K-plus proche voisin et le raisonnement basé sur des cas.

Apprenants avides

Contrairement aux apprenants paresseux, les apprenants enthousiastes construisent un modèle de classification sans attendre que les données de test apparaissent après le stockage des données de formation. Ils passent plus de temps à s'entraîner mais moins à prévoir. Les arbres de décision, les bayes naïves et les réseaux de neurones artificiels (ANN) sont des exemples d'apprenants enthousiastes.

Construire un classificateur en Python

Scikit-learn, une bibliothèque Python pour l'apprentissage automatique peut être utilisée pour créer un classificateur en Python. Les étapes de construction d'un classificateur en Python sont les suivantes -

Étape 1: importation du package python nécessaire

Pour créer un classificateur à l'aide de scikit-learn, nous devons l'importer. Nous pouvons l'importer en utilisant le script suivant -

import sklearn

Étape 2: importation du jeu de données

Après avoir importé le package nécessaire, nous avons besoin d'un ensemble de données pour créer un modèle de prédiction de classification. Nous pouvons l'importer à partir du jeu de données sklearn ou en utiliser un autre selon nos besoins. Nous allons utiliser la base de données de diagnostic du cancer du sein du Wisconsin de sklearn. Nous pouvons l'importer à l'aide du script suivant -

from sklearn.datasets import load_breast_cancer

Le script suivant chargera le jeu de données;

data = load_breast_cancer()

Nous devons également organiser les données et cela peut être fait à l'aide des scripts suivants -

label_names = data['target_names']
   labels = data['target']
   feature_names = data['feature_names']
   features = data['data']

La commande suivante imprimera le nom des étiquettes, 'malignant' et 'benign'dans le cas de notre base de données.

print(label_names)

La sortie de la commande ci-dessus est les noms des étiquettes -

['malignant' 'benign']

Ces étiquettes sont mappées aux valeurs binaires 0 et 1. Malignant le cancer est représenté par 0 et Benign le cancer est représenté par 1.

Les noms et valeurs de caractéristiques de ces étiquettes peuvent être vus à l'aide des commandes suivantes -

print(feature_names[0])

La sortie de la commande ci-dessus est les noms des fonctionnalités pour l'étiquette 0 ie Malignant cancer -

mean radius

De même, les noms des caractéristiques pour l'étiquette peuvent être produits comme suit -

print(feature_names[1])

La sortie de la commande ci-dessus est les noms des fonctionnalités pour l'étiquette 1 ie Benign cancer -

mean texture

Nous pouvons imprimer les caractéristiques de ces étiquettes à l'aide de la commande suivante -

print(features[0])

Cela donnera la sortie suivante -

[
   1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
   1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
   6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
   1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
   4.601e-01 1.189e-01
]

Nous pouvons imprimer les caractéristiques de ces étiquettes à l'aide de la commande suivante -

print(features[1])

Cela donnera la sortie suivante -

[
   2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
   7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
   5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
   2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
   2.750e-01 8.902e-02
]

Étape 3: Organisation des données dans des ensembles de formation et de test

Comme nous devons tester notre modèle sur des données invisibles, nous allons diviser notre ensemble de données en deux parties: un ensemble d'apprentissage et un ensemble de test. Nous pouvons utiliser la fonction train_test_split () du package python sklearn pour diviser les données en ensembles. La commande suivante importera la fonction -

from sklearn.model_selection import train_test_split

Maintenant, la prochaine commande divisera les données en données d'entraînement et de test. Dans cet exemple, nous utilisons 40% des données à des fins de test et 60% des données à des fins de formation -

train, test, train_labels, test_labels = train_test_split(
   features,labels,test_size = 0.40, random_state = 42
)

Étape 4: évaluation du modèle

Après avoir divisé les données en formation et en tests, nous devons construire le modèle. Nous utiliserons l'algorithme Naïve Bayes à cet effet. Les commandes suivantes importeront le module GaussianNB -

from sklearn.naive_bayes import GaussianNB

Maintenant, initialisez le modèle comme suit -

gnb = GaussianNB()

Ensuite, à l'aide de la commande suivante, nous pouvons entraîner le modèle -

model = gnb.fit(train, train_labels)

Maintenant, à des fins d'évaluation, nous devons faire des prédictions. Cela peut être fait en utilisant la fonction prédire () comme suit -

preds = gnb.predict(test)
print(preds)

Cela donnera la sortie suivante -

[
   1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0 1
   0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1
   1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0
   0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1 1 1 1
   1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 
   1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 
   1

]

Les séries ci-dessus de 0 et 1 en sortie sont les valeurs prédites pour le Malignant et Benign classes de tumeurs.

Étape 5: Recherche de la précision

Nous pouvons trouver la précision du modèle construit à l'étape précédente en comparant les deux tableaux à savoir test_labels et preds. Nous utiliserons la fonction precision_score () pour déterminer la précision.

from sklearn.metrics import accuracy_score
   print(accuracy_score(test_labels,preds))
   0.951754385965

La sortie ci-dessus montre que le classificateur NaïveBayes est précis à 95,17%.

Mesures d'évaluation de la classification

Le travail n'est pas terminé même si vous avez terminé l'implémentation de votre application ou modèle Machine Learning. Il faut savoir dans quelle mesure notre modèle est efficace? Il peut y avoir différentes métriques d'évaluation, mais nous devons la choisir avec soin car le choix des métriques influe sur la manière dont les performances d'un algorithme d'apprentissage automatique sont mesurées et comparées.

Voici quelques-unes des mesures importantes d'évaluation de la classification parmi lesquelles vous pouvez choisir en fonction de votre ensemble de données et du type de problème:

Matrice de confusion

C'est le moyen le plus simple de mesurer les performances d'un problème de classification où la sortie peut être de deux ou plusieurs types de classes. Une matrice de confusion n'est rien d'autre qu'un tableau à deux dimensions, à savoir. "Réel" et "Prévu" et en outre, les deux dimensions ont "Vrais positifs (TP)", "Vrais négatifs (TN)", "Faux positifs (FP)", "Faux négatifs (FN)" comme indiqué ci-dessous -

L'explication des termes associés à la matrice de confusion est la suivante -

• True Positives (TP) - C'est le cas lorsque la classe réelle et la classe prévue du point de données sont égales à 1.

• True Negatives (TN) - C'est le cas lorsque la classe réelle et la classe prévue du point de données sont égales à 0.

• False Positives (FP) - C'est le cas lorsque la classe réelle du point de données est 0 et la classe prévue du point de données est 1.

• False Negatives (FN) - C'est le cas lorsque la classe réelle du point de données est 1 et la classe prévue du point de données est 0.

Nous pouvons trouver la matrice de confusion à l'aide de la fonction confusion_matrix () de sklearn. Avec l'aide du script suivant, nous pouvons trouver la matrice de confusion du classificateur binaire construit ci-dessus -

from sklearn.metrics import confusion_matrix

Production

[
   [ 73   7]
   [  4 144]
]

Précision

Il peut être défini comme le nombre de prédictions correctes faites par notre modèle ML. Nous pouvons facilement le calculer par matrice de confusion à l'aide de la formule suivante -

$$ = \ frac {+} {+++} $$

Pour le classificateur binaire construit ci-dessus, TP + TN = 73 + 144 = 217 et TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.

Par conséquent, Précision = 217/228 = 0,951754385965 qui est identique à ce que nous avons calculé après la création de notre classificateur binaire.

Précision

La précision, utilisée dans les extractions de documents, peut être définie comme le nombre de documents corrects renvoyés par notre modèle ML. Nous pouvons facilement le calculer par matrice de confusion à l'aide de la formule suivante -

$$ = \ frac {} {+ FP} $$

Pour le classificateur binaire construit ci-dessus, TP = 73 et TP + FP = 73 + 7 = 80.

Par conséquent, Précision = 73/80 = 0,915

Rappel ou sensibilité

Le rappel peut être défini comme le nombre de positifs renvoyés par notre modèle ML. Nous pouvons facilement le calculer par matrice de confusion à l'aide de la formule suivante -

$$ = \ frac {} {+ FN} $$

Pour le classificateur binaire construit ci-dessus, TP = 73 et TP + FN = 73 + 4 = 77.

Par conséquent, précision = 73/77 = 0,94805

Spécificité

La spécificité, contrairement au rappel, peut être définie comme le nombre de négatifs renvoyés par notre modèle ML. Nous pouvons facilement le calculer par matrice de confusion à l'aide de la formule suivante -

$$ = \ frac {N} {N + FP} $$

Pour le classificateur binaire construit ci-dessus, TN = 144 et TN + FP = 144 + 7 = 151.

Par conséquent, Précision = 144/151 = 0,95364

Divers algorithmes de classification ML

Voici quelques algorithmes de classification ML importants -

• Régression logistique

• Machine à vecteurs de soutien (SVM)

• Arbre de décision

• Bayes naïves

• Forêt aléatoire

Nous discuterons en détail de tous ces algorithmes de classification dans d'autres chapitres.

Applications

Certaines des applications les plus importantes des algorithmes de classification sont les suivantes:

• Reconnaissance de la parole

• Reconnaissance de l'écriture manuscrite

• Identification biométrique

• Classification des documents