AI avec Python - Apprentissage supervisé: classification

Dans ce chapitre, nous nous concentrerons sur la mise en œuvre de l'apprentissage supervisé - classification.

La technique ou le modèle de classification tente de tirer des conclusions à partir des valeurs observées. Dans le problème de classification, nous avons les résultats catégorisés tels que «noir» ou «blanc» ou «enseignement» et «non-enseignement». Lors de la création du modèle de classification, nous avons besoin d'un jeu de données d'entraînement contenant des points de données et les étiquettes correspondantes. Par exemple, si nous voulons vérifier si l'image est celle d'une voiture ou non. Pour vérifier cela, nous allons construire un jeu de données de formation ayant les deux classes liées à «voiture» et «pas de voiture». Ensuite, nous devons former le modèle à l'aide des exemples d'apprentissage. Les modèles de classification sont principalement utilisés dans la reconnaissance faciale, l'identification des spams, etc.

Étapes de construction d'un classificateur en Python

Pour créer un classificateur en Python, nous allons utiliser Python 3 et Scikit-learn qui est un outil d'apprentissage automatique. Suivez ces étapes pour créer un classificateur en Python -

Étape 1 - Importez Scikit-learn

Ce serait la toute première étape pour construire un classificateur en Python. Dans cette étape, nous installerons un package Python appelé Scikit-learn qui est l'un des meilleurs modules d'apprentissage automatique en Python. La commande suivante nous aidera à importer le package -

Import Sklearn

Étape 2 - Importez l'ensemble de données de Scikit-learn

Dans cette étape, nous pouvons commencer à travailler avec l'ensemble de données pour notre modèle d'apprentissage automatique. Ici, nous allons utiliserthe Base de données de diagnostic du cancer du sein au Wisconsin. L'ensemble de données comprend diverses informations sur les tumeurs du cancer du sein, ainsi que des étiquettes de classificationmalignant ou benign. L'ensemble de données contient 569 instances, ou données, sur 569 tumeurs et comprend des informations sur 30 attributs ou caractéristiques, tels que le rayon de la tumeur, la texture, la douceur et la surface. À l'aide de la commande suivante, nous pouvons importer le jeu de données sur le cancer du sein de Scikit-learn -

from sklearn.datasets import load_breast_cancer

Maintenant, la commande suivante chargera l'ensemble de données.

data = load_breast_cancer()

Voici une liste des clés de dictionnaire importantes -

• Noms des étiquettes de classification (target_names)
• Les étiquettes réelles (cible)
• Les noms d'attributs / d'entités (noms_fonctionnalités)
• L'attribut (données)

Maintenant, à l'aide de la commande suivante, nous pouvons créer de nouvelles variables pour chaque ensemble important d'informations et affecter les données. En d'autres termes, nous pouvons organiser les données avec les commandes suivantes -

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

Maintenant, pour clarifier les choses, nous pouvons imprimer les étiquettes de classe, l'étiquette de la première instance de données, les noms de nos fonctionnalités et la valeur de la fonctionnalité à l'aide des commandes suivantes -

print(label_names)

La commande ci-dessus affichera les noms de classe qui sont respectivement malins et bénins. Il est affiché comme la sortie ci-dessous -

['malignant' 'benign']

Maintenant, la commande ci-dessous montrera qu'ils sont mappés aux valeurs binaires 0 et 1. Ici, 0 représente un cancer malin et 1 représente un cancer bénin. Vous recevrez la sortie suivante -

print(labels[0])
0

Les deux commandes données ci-dessous produiront les noms des fonctionnalités et leurs valeurs.

print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

À partir de la sortie ci-dessus, nous pouvons voir que la première instance de données est une tumeur maligne dont le rayon est de 1,7990000e + 01.

Étape 3 - Organisation des données en ensembles

Dans cette étape, nous diviserons nos données en deux parties, à savoir un ensemble d'apprentissage et un ensemble de test. La division des données en ces ensembles est très importante car nous devons tester notre modèle sur les données invisibles. Pour diviser les données en ensembles, sklearn a une fonction appelée letrain_test_split()fonction. À l'aide des commandes suivantes, nous pouvons diviser les données dans ces ensembles -

from sklearn.model_selection import train_test_split

La commande ci-dessus importera le train_test_splitLa fonction de sklearn et la commande ci-dessous diviseront les données en données d'entraînement et de test. Dans l'exemple ci-dessous, nous utilisons 40% des données pour les tests et les données restantes seraient utilisées pour la formation du modèle.

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

Étape 4 - Construction du modèle

Dans cette étape, nous construirons notre modèle. Nous allons utiliser l'algorithme Naïve Bayes pour construire le modèle. Les commandes suivantes peuvent être utilisées pour construire le modèle -

from sklearn.naive_bayes import GaussianNB

La commande ci-dessus importera le module GaussianNB. Maintenant, la commande suivante vous aidera à initialiser le modèle.

gnb = GaussianNB()

Nous allons entraîner le modèle en l'ajustant aux données en utilisant gnb.fit ().

model = gnb.fit(train, train_labels)

Étape 5 - Évaluer le modèle et sa précision

Dans cette étape, nous allons évaluer le modèle en faisant des prédictions sur nos données de test. Ensuite, nous découvrirons également sa précision. Pour faire des prédictions, nous utiliserons la fonction prédire (). La commande suivante vous aidera à le faire -

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

[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 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 de 0 et 1 ci-dessus sont les valeurs prédites pour les classes de tumeurs - malignes et bénignes.

Maintenant, en comparant les deux tableaux à savoir test_labels et preds, nous pouvons connaître la précision de notre modèle. Nous allons utiliser leaccuracy_score()fonction pour déterminer la précision. Considérez la commande suivante pour cela -

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

Le résultat montre que le classifieur NaïveBayes est précis à 95,17%.

De cette façon, à l'aide des étapes ci-dessus, nous pouvons construire notre classificateur en Python.

Construire un classificateur en Python

Dans cette section, nous allons apprendre à créer un classificateur en Python.

Classificateur Naïve Bayes

Naïve Bayes est une technique de classification utilisée pour construire un classificateur en utilisant le théorème de Bayes. L'hypothèse est que les prédicteurs sont indépendants. En termes simples, cela suppose que la présence d'une fonctionnalité particulière dans une classe n'est pas liée à la présence d'une autre fonctionnalité. Pour construire le classificateur Naïve Bayes, nous devons utiliser la bibliothèque python appelée scikit learn. Il existe trois types de modèles Naïve Bayes nommésGaussian, Multinomial and Bernoulli sous scikit learn package.

Pour créer un modèle de classifieur d'apprentissage automatique Naïve Bayes, nous avons besoin des éléments suivants & minus

Base de données

Nous allons utiliser l'ensemble de données nommé Breast Cancer Wisconsin Diagnostic Database. L'ensemble de données comprend diverses informations sur les tumeurs du cancer du sein, ainsi que des étiquettes de classificationmalignant ou benign. L'ensemble de données contient 569 instances, ou données, sur 569 tumeurs et comprend des informations sur 30 attributs ou caractéristiques, tels que le rayon de la tumeur, la texture, la douceur et la surface. Nous pouvons importer cet ensemble de données à partir du package sklearn.

Modèle naïf de Bayes

Pour construire le classificateur Naïve Bayes, nous avons besoin d'un modèle Naïve Bayes. Comme indiqué précédemment, il existe trois types de modèles Naïve Bayes nommésGaussian, Multinomial et Bernoullisous scikit learn package. Ici, dans l'exemple suivant, nous allons utiliser le modèle Gaussian Naïve Bayes.

En utilisant ce qui précède, nous allons créer un modèle d'apprentissage automatique Naïve Bayes pour utiliser les informations sur la tumeur pour prédire si une tumeur est maligne ou bénigne.

Pour commencer, nous devons installer le module sklearn. Cela peut être fait à l'aide de la commande suivante -

Import Sklearn

Maintenant, nous devons importer l'ensemble de données nommé Breast Cancer Wisconsin Diagnostic Database.

from sklearn.datasets import load_breast_cancer

Maintenant, la commande suivante chargera l'ensemble de données.

data = load_breast_cancer()

Les données peuvent être organisées comme suit -

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

Maintenant, pour clarifier les choses, nous pouvons imprimer les étiquettes de classe, l'étiquette de la première instance de données, les noms de nos fonctionnalités et la valeur de la fonctionnalité à l'aide des commandes suivantes -

print(label_names)

La commande ci-dessus affichera les noms de classe qui sont respectivement malins et bénins. Il est affiché comme la sortie ci-dessous -

['malignant' 'benign']

Maintenant, la commande donnée ci-dessous montrera qu'ils sont mappés aux valeurs binaires 0 et 1. Ici, 0 représente un cancer malin et 1 représente un cancer bénin. Il est affiché comme la sortie ci-dessous -

print(labels[0])
0

Les deux commandes suivantes produiront les noms et les valeurs des caractéristiques.

print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

À partir de la sortie ci-dessus, nous pouvons voir que la première instance de données est une tumeur maligne dont le rayon principal est 1,7990000e + 01.

Pour tester notre modèle sur des données invisibles, nous devons diviser nos données en données d'entraînement et de test. Cela peut être fait à l'aide du code suivant -

from sklearn.model_selection import train_test_split

La commande ci-dessus importera le train_test_splitLa fonction de sklearn et la commande ci-dessous diviseront les données en données d'entraînement et de test. Dans l'exemple ci-dessous, nous utilisons 40% des données pour les tests et les données restantes seraient utilisées pour entraîner le modèle.

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

Maintenant, nous construisons le modèle avec les commandes suivantes -

from sklearn.naive_bayes import GaussianNB

La commande ci-dessus importera le GaussianNBmodule. Maintenant, avec la commande donnée ci-dessous, nous devons initialiser le modèle.

gnb = GaussianNB()

Nous allons former le modèle en l'ajustant aux données en utilisant gnb.fit().

model = gnb.fit(train, train_labels)

Maintenant, évaluez le modèle en faisant des prédictions sur les données de test et cela peut être fait comme suit -

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

[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 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 de 0 et de 1 ci-dessus sont les valeurs prédites pour les classes de tumeurs, c'est-à-dire malignes et bénignes.

Maintenant, en comparant les deux tableaux à savoir test_labels et preds, nous pouvons connaître la précision de notre modèle. Nous allons utiliser leaccuracy_score()fonction pour déterminer la précision. Considérez la commande suivante -

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

Le résultat montre que le classificateur NaïveBayes est précis à 95,17%.

C'était un classificateur d'apprentissage automatique basé sur le modèle gaussien Naïve Bayse.

Machines vectorielles de soutien (SVM)

Fondamentalement, Support Vector Machine (SVM) est un algorithme d'apprentissage automatique supervisé qui peut être utilisé à la fois pour la régression et la classification. Le concept principal de SVM est de tracer chaque élément de données comme un point dans un espace à n dimensions, la valeur de chaque entité étant la valeur d'une coordonnée particulière. Ici n seraient les fonctionnalités que nous aurions. Voici une représentation graphique simple pour comprendre le concept de SVM -

Dans le diagramme ci-dessus, nous avons deux fonctionnalités. Par conséquent, nous devons d'abord tracer ces deux variables dans un espace à deux dimensions où chaque point a deux coordonnées, appelées vecteurs de support. La ligne divise les données en deux groupes classés différents. Cette ligne serait le classificateur.

Ici, nous allons créer un classificateur SVM en utilisant les jeux de données scikit-learn et iris. La bibliothèque Scikitlearn a lesklearn.svmmodule et fournit sklearn.svm.svc pour la classification. Le classificateur SVM pour prédire la classe de l'usine d'iris basé sur 4 caractéristiques est présenté ci-dessous.

Base de données

Nous utiliserons le jeu de données iris qui contient 3 classes de 50 instances chacune, où chaque classe fait référence à un type de plante iris. Chaque instance a les quatre caractéristiques à savoir la longueur des sépales, la largeur des sépales, la longueur des pétales et la largeur des pétales. Le classificateur SVM pour prédire la classe de l'usine d'iris basé sur 4 caractéristiques est illustré ci-dessous.

Noyau

C'est une technique utilisée par SVM. Fondamentalement, ce sont les fonctions qui prennent un espace d'entrée de faible dimension et le transforment en un espace de dimension supérieure. Il convertit un problème non séparable en problème séparable. La fonction noyau peut être n'importe laquelle parmi les fonctions linéaire, polynomiale, rbf et sigmoïde. Dans cet exemple, nous utiliserons le noyau linéaire.

Importons maintenant les packages suivants -

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Maintenant, chargez les données d'entrée -

iris = datasets.load_iris()

Nous prenons les deux premières fonctionnalités -

X = iris.data[:, :2]
y = iris.target

Nous tracerons les limites de la machine vectorielle de support avec les données originales. Nous créons un maillage à tracer.

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

Nous devons donner la valeur du paramètre de régularisation.

C = 1.0

Nous devons créer l'objet classificateur SVM.

Svc_classifier = svm_classifier.SVC(kernel='linear', 
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')

Régression logistique

Fondamentalement, le modèle de régression logistique est l'un des membres de la famille d'algorithmes de classification supervisée. La régression logistique mesure la relation entre les variables dépendantes et les variables indépendantes en estimant les probabilités à l'aide d'une fonction logistique.

Ici, si nous parlons de variables dépendantes et indépendantes, alors la variable dépendante est la variable de classe cible que nous allons prédire et de l'autre côté les variables indépendantes sont les fonctionnalités que nous allons utiliser pour prédire la classe cible.

Dans la régression logistique, estimer les probabilités signifie prédire la probabilité d'occurrence de l'événement. Par exemple, le propriétaire de la boutique aimerait prédire que le client qui est entré dans la boutique achètera la station de lecture (par exemple) ou non. Il y aurait de nombreuses caractéristiques du client - sexe, âge, etc. qui seraient observées par le commerçant pour prédire l'occurrence probable, c'est-à-dire acheter une station de jeu ou non. La fonction logistique est la courbe sigmoïde qui est utilisée pour construire la fonction avec divers paramètres.

Conditions préalables

Avant de construire le classificateur à l'aide de la régression logistique, nous devons installer le package Tkinter sur notre système. Il peut être installé à partir dehttps://docs.python.org/2/library/tkinter.html.

Maintenant, avec l'aide du code donné ci-dessous, nous pouvons créer un classificateur en utilisant la régression logistique -

Tout d'abord, nous importerons quelques packages -

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

Maintenant, nous devons définir les exemples de données qui peuvent être effectués comme suit -

X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
              [3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

Ensuite, nous devons créer le classificateur de régression logistique, ce qui peut être fait comme suit -

Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)

Dernier point mais non le moindre, nous devons former ce classificateur -

Classifier_LR.fit(X, y)

Maintenant, comment pouvons-nous visualiser la sortie? Cela peut être fait en créant une fonction nommée Logistic_visualize () -

Def Logistic_visualize(Classifier_LR, X, y):
   min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
   min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0

Dans la ligne ci-dessus, nous avons défini les valeurs minimales et maximales X et Y à utiliser dans la grille de maillage. De plus, nous définirons la taille du pas pour tracer la grille de maillage.

mesh_step_size = 0.02

Définissons la grille de maillage des valeurs X et Y comme suit -

x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
                 np.arange(min_y, max_y, mesh_step_size))

À l'aide du code suivant, nous pouvons exécuter le classificateur sur la grille de maillage -

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
 
plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black', 
linewidth=1, cmap = plt.cm.Paired)

La ligne de code suivante spécifiera les limites du tracé

plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()

Maintenant, après avoir exécuté le code, nous obtiendrons la sortie suivante, classificateur de régression logistique -

Classificateur d'arbre de décision

Un arbre de décision est essentiellement un organigramme d'arbre binaire où chaque nœud divise un groupe d'observations en fonction d'une variable caractéristique.

Ici, nous construisons un classificateur d'arbre de décision pour prédire l'homme ou la femme. Nous prendrons un très petit ensemble de données contenant 19 échantillons. Ces échantillons comprendraient deux caractéristiques - «hauteur» et «longueur des cheveux».

Prérequis

Pour construire le classificateur suivant, nous devons installer pydotplus et graphviz. Fondamentalement, graphviz est un outil pour dessiner des graphiques à l'aide de fichiers de points etpydotplusest un module du langage Dot de Graphviz. Il peut être installé avec le gestionnaire de packages ou pip.

Maintenant, nous pouvons construire le classificateur d'arbre de décision à l'aide du code Python suivant -

Pour commencer, importons quelques bibliothèques importantes comme suit -

import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections

Maintenant, nous devons fournir le jeu de données comme suit -

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)

Après avoir fourni l'ensemble de données, nous devons ajuster le modèle, ce qui peut être fait comme suit -

clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

La prédiction peut être faite à l'aide du code Python suivant -

prediction = clf.predict([[133,37]])
print(prediction)

Nous pouvons visualiser l'arbre de décision à l'aide du code Python suivant -

dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
            out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')

Il donnera la prédiction pour le code ci-dessus comme [‘Woman’] et créez l'arbre de décision suivant -

Nous pouvons modifier les valeurs des fonctionnalités dans la prédiction pour la tester.

Classificateur de forêt aléatoire

Comme nous le savons, les méthodes d'ensemble sont les méthodes qui combinent des modèles d'apprentissage automatique en un modèle d'apprentissage automatique plus puissant. Random Forest, une collection d'arbres de décision, en fait partie. C'est mieux qu'un arbre de décision unique car tout en conservant les pouvoirs prédictifs, il peut réduire le surajustement en faisant la moyenne des résultats. Ici, nous allons mettre en œuvre le modèle de forêt aléatoire sur l'ensemble de données scikit learn sur le cancer.

Importez les packages nécessaires -

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np

Maintenant, nous devons fournir le jeu de données qui peut être fait comme suit et moins

cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

Après avoir fourni l'ensemble de données, nous devons ajuster le modèle, ce qui peut être fait comme suit -

forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)

Maintenant, obtenez la précision sur la formation ainsi que sur le sous-ensemble de test: si nous augmentons le nombre d'estimateurs, la précision du sous-ensemble de test sera également augmentée.

print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))

Production

Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965

Maintenant, comme l'arbre de décision, la forêt aléatoire a le feature_importancemodule qui fournira une meilleure vue du poids des fonctionnalités que l'arbre de décision. Il peut être tracé et visualisé comme suit -

n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()

Performance d'un classificateur

Après avoir implémenté un algorithme d'apprentissage automatique, nous devons déterminer l'efficacité du modèle. Les critères de mesure de l'efficacité peuvent être basés sur des ensembles de données et des mesures. Pour évaluer différents algorithmes d'apprentissage automatique, nous pouvons utiliser différentes mesures de performance. Par exemple, supposons que si un classificateur est utilisé pour distinguer les images de différents objets, nous pouvons utiliser les métriques de performance de classification telles que la précision moyenne, AUC, etc. Dans un sens ou dans un autre, la métrique que nous choisissons pour évaluer notre modèle d'apprentissage automatique est très important car le choix des métriques influence la façon dont les performances d'un algorithme d'apprentissage automatique sont mesurées et comparées. Voici quelques-unes des mesures -

Matrice de confusion

Fondamentalement, il est utilisé pour les problèmes de classification où la sortie peut être de deux ou plusieurs types de classes. C'est le moyen le plus simple de mesurer les performances d'un classificateur. Une matrice de confusion est essentiellement un tableau à deux dimensions, à savoir «Réel» et «Prévu». Les deux dimensions ont «True Positives (TP)», «True Negatives (TN)», «False Positives (FP)», «False Negatives (FN)».

Dans la matrice de confusion ci-dessus, 1 correspond à une classe positive et 0 à une classe négative.

Voici les termes associés à la matrice de confusion -

• True Positives − Les TP sont les cas où la classe réelle du point de données était 1 et la prédiction est également 1.

• True Negatives − Les TN sont les cas où la classe réelle du point de données était 0 et la prédiction est également 0.

• False Positives − Les PF sont les cas où la classe réelle du point de données était 0 et la prédiction est également 1.

• False Negatives − Les FN sont les cas où la classe réelle du point de données était 1 et la valeur prédite est également 0.

Précision

La matrice de confusion elle-même n'est pas une mesure de la performance en tant que telle, mais presque toutes les matrices de performance sont basées sur la matrice de confusion. L'un d'eux est la précision. Dans les problèmes de classification, il peut être défini comme le nombre de prédictions correctes faites par le modèle sur toutes sortes de prédictions faites. La formule de calcul de la précision est la suivante -

$$ Précision = \ frac {TP + TN} {TP + FP + FN + TN} $$

Précision

Il est principalement utilisé dans la récupération de documents. Il peut être défini comme le nombre de documents retournés corrects. Voici la formule pour calculer la précision -

$$ Précision = \ frac {TP} {TP + FP} $$

Rappel ou sensibilité

Il peut être défini comme le nombre de positifs renvoyés par le modèle. Voici la formule pour calculer le rappel / la sensibilité du modèle -

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

Spécificité

Il peut être défini comme le nombre de négatifs retournés par le modèle. C'est exactement l'opposé du rappel. Voici la formule pour calculer la spécificité du modèle -

$$ Spécificité = \ frac {TN} {TN + FP} $$

Problème de déséquilibre de classe

Le déséquilibre de classe est le scénario où le nombre d'observations appartenant à une classe est significativement inférieur à celles appartenant aux autres classes. Par exemple, ce problème est prédominant dans le scénario où nous devons identifier les maladies rares, les transactions frauduleuses en banque, etc.

Exemple de classes déséquilibrées

Prenons un exemple d'ensemble de données de détection de fraude pour comprendre le concept de classe déséquilibrée -

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Solution

Balancing the classes’agit comme une solution aux classes déséquilibrées. L'objectif principal de l'équilibrage des classes est soit d'augmenter la fréquence de la classe minoritaire, soit de diminuer la fréquence de la classe majoritaire. Voici les approches pour résoudre le problème des classes de déséquilibres -

Rééchantillonnage

Le rééchantillonnage est une série de méthodes utilisées pour reconstruire les ensembles de données d'échantillons - à la fois des ensembles d'apprentissage et des ensembles de test. Un rééchantillonnage est effectué pour améliorer la précision du modèle. Voici quelques techniques de rééchantillonnage -

• Random Under-Sampling- Cette technique vise à équilibrer la distribution des classes en éliminant au hasard les exemples de classes majoritaires. Ceci est fait jusqu'à ce que les instances de la classe majoritaire et minoritaire soient équilibrées.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Dans ce cas, nous prélevons 10% d'échantillons sans remplacement à partir d'instances non frauduleuses, puis nous les combinons avec les instances frauduleuses -

Observations non frauduleuses après sous-échantillonnage aléatoire = 10% de 4950 = 495

Total des observations après les avoir combinées avec des observations frauduleuses = 50 + 495 = 545

Par conséquent, le taux d'événements pour le nouvel ensemble de données après sous-échantillonnage = 9%

Le principal avantage de cette technique est qu'elle permet de réduire le temps d'exécution et d'améliorer le stockage. Mais d'un autre côté, il peut rejeter des informations utiles tout en réduisant le nombre d'échantillons de données d'apprentissage.

• Random Over-Sampling - Cette technique vise à équilibrer la distribution des classes en augmentant le nombre d'instances dans la classe minoritaire en les répliquant.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Dans le cas où nous reproduisions 50 observations frauduleuses 30 fois, les observations frauduleuses après avoir répliqué les observations de la classe minoritaire seraient de 1500. Et puis les observations totales dans les nouvelles données après suréchantillonnage seraient de 4950 + 1500 = 6450. D'où le taux d'événements pour le nouvel ensemble de données serait 1500/6450 = 23%.

Le principal avantage de cette méthode est qu'il n'y aurait aucune perte d'informations utiles. Mais d'un autre côté, il a des chances accrues de sur-ajustement parce qu'il reproduit les événements de la classe minoritaire.

Techniques d'ensemble

Cette méthodologie est essentiellement utilisée pour modifier les algorithmes de classification existants pour les rendre appropriés aux ensembles de données déséquilibrés. Dans cette approche, nous construisons plusieurs classificateurs en deux étapes à partir des données d'origine, puis agrégons leurs prédictions. Le classificateur de forêt aléatoire est un exemple de classificateur basé sur un ensemble.