Machine Learning - Step-by-Step Guide To Implement Machine Learning Algorithms With Python (PDFDrive)

Machine Translated by Google
Apprentissage automatique
Guide étape par étape pour la mise en œuvre
Algorithmes d'apprentissage automatique avec Python
Auteur
Rodolphe Russel
© Copyright 2018 Tous droits réservés.
Si vous souhaitez partager ce livre avec une autre personne, veuillez acheter un
exemplaire supplémentaire pour chaque destinataire. Merci de respecter le travail
acharné de cet auteur. Dans le cas contraire, la transmission, la duplication ou la
reproduction de l'un des travaux suivants, y compris des informations spécifiques, sera
considérée comme un acte illégal, qu'il soit effectué par voie électronique ou imprimée.
Cela s'étend à la création d'une copie secondaire ou tertiaire de l'œuvre ou d'une copie
enregistrée et n'est autorisée qu'avec l'accord écrit exprès de l'éditeur. Tous droits supplémentaires réser
Table des matières
CHAPITRE 1
INTRODUCTION À L'APPRENTISSAGE MACHINE
Théorie
Qu'estce que l'apprentissage automatique ?
Pourquoi l'apprentissage automatique ?
Quand utiliser l'apprentissage automatique ?
Types de systèmes d'apprentissage automatique
Apprentissage supervisé et non supervisé
Apprentissage supervisé
Les algorithmes supervisés les plus importants
Apprentissage non supervisé
Les algorithmes non supervisés les plus importants
Caractéristiques non pertinentes
Ingénierie des fonctionnalités
Essai
Surajustement des données
Solutions
Sousajustement des données
Solutions
DES EXERCICES
RÉSUMÉ
LES RÉFÉRENCES
CHAPITRE 2
CLASSIFICATION
Installation
Le MNIST
Mesures de performance
Matrice de confusion
Rappel
Compromis de rappel
ROC
Classification multiclasses
Formation d'un classificateur de forêt aléatoire
Erreur d'analyse
Classifications multiétiquettes
Classification multisorties
DES EXERCICES
LES RÉFÉRENCES
CHAPITRE 3
COMMENT ENTRAÎNER UN MODÈLE
Régression linéaire
Complexité informatique
Descente graduelle
Descente de dégradé par lot
Descente de gradient stochastique
Descente de gradient en minilot
Régression polynomiale
Courbes d'apprentissage
Modèles linéaires régularisés
Régression de crête
Régression au lasso
DES EXERCICES
RÉSUMÉ
LES RÉFÉRENCES
Chapitre 4
Différentes combinaisons de modèles
Implémentation d'un classificateur majoritaire simple
Combinaison de différents algorithmes pour la classification avec vote majoritaire
Des questions
CHAPITRE 1
INTRODUCTION À L'APPRENTISSAGE MACHINE
Théorie Si
je vous pose des questions sur « l'apprentissage automatique », vous imaginerez probablement un
robot ou quelque chose comme le Terminator. En réalité, l'apprentissage automatique est impliqué non
seulement dans la robotique, mais aussi dans de nombreuses autres applications. Vous pouvez
également imaginer quelque chose comme un filtre antispam comme étant l'une des premières
applications de l'apprentissage automatique, ce qui contribue à améliorer la vie de millions de personnes.
Dans ce chapitre, je vais vous présenter ce qu'est l'apprentissage automatique et comment il fonctionne.
Qu'estce que l'apprentissage automatique ?
L'apprentissage automatique est la pratique consistant à programmer des ordinateurs pour apprendre à partir de données.
Dans l'exemple cidessus, le programme pourra facilement déterminer si les données sont importantes ou sont des "spam".
Dans l'apprentissage automatique, les données sont appelées ensembles d'apprentissage ou exemples.
Pourquoi l'apprentissage automatique ?
Supposons que vous souhaitiez écrire le programme de filtrage sans utiliser de méthodes
d'apprentissage automatique. Dans ce cas, vous devrez effectuer les étapes suivantes :
∙ Au début, vous examineriez à quoi ressemblent les spams. Vous pouvez les sélectionner pour
les mots ou expressions qu'ils utilisent, comme "carte de débit", "gratuit", etc., et également à
partir de modèles utilisés dans le nom de l'expéditeur ou dans le corps de l'email.
∙ Deuxièmement, vous écririez un algorithme pour détecter les modèles que vous avez vus,
puis le logiciel signalerait les emails comme spam si un certain nombre de ces modèles sont
détectés.
∙ Enfin, vous testez le programme, puis refaites les deux premières étapes jusqu'à ce que les
résultats soient suffisamment bons.
Parce que le programme n'est pas un logiciel, il contient une très longue liste de règles difficiles à
maintenir. Mais si vous avez développé le même logiciel en utilisant ML, vous pourrez le maintenir
correctement.
De plus, les expéditeurs d'emails peuvent modifier leurs modèles d'emails afin qu'un mot comme
"4U" soit désormais "pour vous", car leurs emails ont été déterminés comme étant du spam. Le
programme utilisant des techniques traditionnelles aurait besoin d'être mis à jour, ce qui signifie
que, s'il y avait d'autres changements, vous auriez besoin de mettre à jour votre code encore et
encore et encore.
D'un autre côté, un programme qui utilise des techniques de ML détectera automatiquement ce
changement par les utilisateurs, et il commencera à les signaler sans que vous le lui disiez manuellement.
En outre, nous pouvons utiliser l'apprentissage automatique pour résoudre des problèmes très
complexes pour les logiciels d'apprentissage non automatique. Par exemple, la reconnaissance
vocale : lorsque vous dites « un » ou « deux », le programme doit être capable de distinguer la différence. Donc pour
cette tâche, vous devrez développer un algorithme qui mesure le son.
En fin de compte, l'apprentissage automatique nous aidera à apprendre, et les algorithmes
d'apprentissage automatique peuvent nous aider à voir ce que nous avons appris.
Quand utiliser l'apprentissage automatique ? • Lorsque
vous avez un problème qui nécessite de nombreuses longues listes de règles pour trouver la solution.
Dans ce cas, les techniques d'apprentissage automatique peuvent simplifier votre code et améliorer les
performances.
• Problèmes très complexes pour lesquels il n'y a pas de solution avec une approche
traditionnelle.
• Environnements instables : les logiciels d'apprentissage automatique peuvent s'adapter aux nouvelles données.
Types de systèmes d'apprentissage
automatique Il existe différents types de systèmes d'apprentissage automatique. Nous
pouvons les diviser en catégories, selon que
• Ils ont été entraînés avec des humains ou non
Supervisé
Non surveillé
Semiencadré
Apprentissage par renforcement •
S'ils peuvent apprendre progressivement
• S'ils travaillent simplement en comparant de nouveaux points de données pour trouver des points de données, ou
peuvent détecter de nouveaux modèles dans les données, ils construiront ensuite un modèle.
Apprentissage supervisé et non supervisé Nous
pouvons classer les systèmes d'apprentissage automatique selon le type et la quantité de supervision
humaine pendant la formation. Vous pouvez trouver quatre grandes catégories, comme nous l'avons
expliqué précédemment.
Apprentissage supervisé
Apprentissage non supervisé
Apprentissage semisupervisé
Apprentissage par renforcement
Apprentissage supervisé Dans
ce type de système d'apprentissage automatique, les données que vous introduisez dans
l'algorithme, avec la solution souhaitée, sont appelées "étiquettes".
L'apprentissage supervisé regroupe une tâche de classement. Le programme cidessus en est un bon
exemple car il a été formé avec de nombreux emails en même temps que leur classe.
Un autre exemple consiste à prédire une valeur numérique comme le prix d'un appartement, compte tenu
d'un ensemble de caractéristiques (emplacement, nombre de pièces, installations) appelées prédicteurs ;
ce type de tâche est appelé régression.
Vous devez garder à l'esprit que certains algorithmes de régression peuvent également être utilisés
pour les classifications, et vice versa.
Les algorithmes supervisés les plus importants
Kse rapproche des voisins
Régression linéaire
Les réseaux de neurones
Soutenir les machines vectorielles
Régression logistique
Arbres de décision et forêts aléatoires
Apprentissage non supervisé Dans
ce type de système d'apprentissage automatique, vous pouvez deviner que les données ne sont pas étiquetées.
Les algorithmes non supervisés les plus importants
Clustering : kmeans, analyse de cluster hiérarchique
Apprentissage des règles d'association : Eclat, a priori
Visualisation et réduction de dimensionnalité : kernel PCA, tdistributed,
APC
Par exemple, supposons que vous disposiez de nombreuses données sur l'utilisation par les visiteurs de l'un de nos
algorithmes de détection de groupes avec des visiteurs similaires. Il se peut que 65 % de vos
visiteurs soient des hommes qui aiment regarder des films le soir, tandis que 30 % regardent
des pièces de théâtre le soir ; dans ce cas, en utilisant un algorithme de clustering, il divisera
chaque groupe en sousgroupes plus petits.
Il existe des algorithmes très importants, comme les algorithmes de visualisation ; ce sont des
algorithmes d'apprentissage non supervisés. Vous devrez leur donner de nombreuses données
et des données non étiquetées en entrée, puis vous obtiendrez une visualisation 2D ou 3D
en sortie.
Le but ici est de rendre la sortie aussi simple que possible sans perdre aucune des informations.
Pour gérer ce problème. il combinera plusieurs fonctionnalités connexes en une seule fonctionnalité :
par exemple, il combinera la marque d'une voiture avec son modèle. C'est ce qu'on appelle
l'extraction de caractéristiques.
Apprentissage par renforcement
L'apprentissage par renforcement est un autre type de système d'apprentissage automatique. Un
agent "système d'IA" observera l'environnement, effectuera des actions données, puis recevra
des récompenses en retour. Avec ce type, l'agent doit apprendre par luimême. Les liens sont
appelés une politique.
Vous pouvez trouver ce type d'apprentissage dans de nombreuses applications robotiques qui
apprennent à marcher
Apprentissage par
lots Dans ce type de systèmes d'apprentissage automatique, le système ne peut pas apprendre de
manière incrémentielle : le système doit obtenir toutes . Cela signifie qu'il faudra beaucoup
les ressources de données nécessaires et beaucoup de temps, donc cela se fait toujours hors ligne.
Donc, pour travailler avec ce type d'apprentissage, la première chose à faire est de former le
système, puis de le lancer sans aucun apprentissage.
Apprentissage en ligne
Ce type d'apprentissage est à l'opposé de l'apprentissage par lots. Je veux dire que, ici, le système peut
apprendre progressivement en fournissant au système toutes les données disponibles en tant qu'instances
(groupes ou individuellement), puis le système peut apprendre à la volée.
Vous pouvez utiliser ce type de système pour les problèmes qui nécessitent un flux continu de données, qui
doit également s'adapter rapidement à tout changement. En outre, vous pouvez utiliser ce type de système
pour travailler avec de très grands ensembles de données,
Vous devez savoir à quelle vitesse votre système peut s'adapter à toute modification du « taux
d'apprentissage » des données. Si la vitesse est élevée, cela signifie que le système apprendra assez
rapidement, mais qu'il oubliera également rapidement les anciennes données.
Apprentissage basé sur les
instances C'est le type d'apprentissage le plus simple que vous devriez apprendre par cœur. En
utilisant ce type d'apprentissage dans notre programme de messagerie, il signalera tous les emails
signalés par les utilisateurs.
.
Apprentissage basé sur des modèles
Il existe un autre type d'apprentissage dans lequel l'apprentissage à partir d'exemples permet à la construction de
faire des prédictions
Mauvaise et quantité insuffisante de données de formation
Les systèmes d'apprentissage automatique ne sont pas comme les enfants, qui peuvent distinguer
les pommes et les oranges de toutes sortes de couleurs et de formes, mais ils nécessitent
beaucoup de données pour fonctionner efficacement, que vous travailliez avec des programmes
très simples et problèmes ou des applications complexes comme le traitement d'images et la
reconnaissance vocale. Voici un exemple de l'efficacité déraisonnable des données, montrant
le projet MS, qui comprend des données simples et le problème complexe de la PNL.
Données de mauvaise
qualité Si vous travaillez avec des données d'entraînement pleines d'erreurs et de valeurs aberrantes, il
sera très difficile pour le système de détecter des modèles , il ne fonctionnera donc pas correctement.
Donc, si vous voulez que votre programme fonctionne bien, vous devez passer plus de temps à nettoyer
vos données d'entraînement.
Fonctionnalités non pertinentes
Le système ne pourra apprendre que si les données d'entraînement contiennent suffisamment de fonctionnalités
et de données qui ne sont pas trop non pertinentes. La partie la plus importante de tout projet ML est de développer de
bonnes fonctionnalités "d'ingénierie de fonctionnalités".
Ingénierie des fonctionnalités
Le processus d'ingénierie des fonctionnalités se déroule comme suit :
. Sélection des fonctionnalités : sélection des fonctionnalités les plus utiles.
. Extraction de fonctionnalités : combinaison de fonctionnalités existantes pour fournir des fonctionnalités plus utiles.
. Création de nouvelles fonctionnalités : création de nouvelles fonctionnalités, basées sur des données.
Test Si
vous souhaitez vous assurer que votre modèle fonctionne bien et que ce modèle peut être
généralisé avec de nouveaux cas, vous pouvez essayer de nouveaux cas en plaçant le
modèle dans l'environnement, puis en surveillant ses performances. C'est une bonne
méthode, mais si votre modèle est inadéquat, l'utilisateur se plaindra.
Vous devez diviser vos données en deux ensembles, un ensemble pour la formation et le
second pour les tests, afin que vous puissiez former votre modèle en utilisant le premier et
le tester en utilisant le second. L'erreur de généralisation est le taux d'erreur par évaluation
de votre modèle sur l'ensemble de test. La valeur que vous obtenez vous dira si votre modèle
est assez bon et s'il fonctionnera correctement.
Si le taux d'erreur est faible, le modèle est bon et fonctionnera correctement. En revanche, si
votre taux est élevé, cela signifie que votre modèle fonctionnera mal et ne fonctionnera
pas correctement. Mon conseil est d'utiliser 80 % des données pour la formation et 20 % à
des fins de test, de sorte qu'il soit très simple de tester ou d'évaluer un modèle.
Surajustement des données
Si vous êtes dans un pays étranger et que quelqu'un vous vole quelque chose, vous pourriez dire que tout
le monde est un voleur. Il s'agit d'une surgénéralisation, et, dans l'apprentissage automatique, on
l'appelle "surajustement". Cela signifie que les machines font la même chose : elles peuvent bien
fonctionner lorsqu'elles travaillent avec les données d'apprentissage, mais elles ne peuvent pas les
généraliser correctement. Par exemple, dans la figure suivante, vous trouverez un modèle de degré élevé
de satisfaction à l'égard de la vie qui dépasse les données, mais qui fonctionne bien avec les données
d'entraînement.
Quand cela se produitil ?
Le surajustement se produit lorsque le modèle est très complexe pour la quantité de données
d'apprentissage fournies.
Solutions
Pour résoudre le problème de surajustement, vous devez procéder comme suit :
Recueillir plus de données pour les "données d'entraînement"
Réduire le niveau de bruit
Sélectionnezen un avec moins de paramètres
Sousajustement des données
D'après son nom, le sousajustement est l'opposé du surajustement, et vous le rencontrerez lorsque le modèle
est très simple à apprendre. Par exemple, en utilisant l'exemple de la qualité de vie, la vie réelle est plus complexe
que votre modèle, donc les prédictions ne donneront pas la même chose, même dans les exemples de
formation.
Solutions
Pour résoudre ce problème :
Sélectionnez le modèle le plus puissant, qui a de nombreux paramètres.
Alimentez les meilleures fonctionnalités dans votre algorithme. Ici, je fais référence à l'ingénierie des
fonctionnalités.
Réduisez les contraintes sur votre modèle.
DES EXERCICES
Dans ce chapitre, nous avons couvert de nombreux concepts d'apprentissage automatique. Les
chapitres suivants seront très pratiques et vous écrirez du code, mais vous devez répondre aux questions
suivantes juste pour vous assurer que vous êtes sur la bonne voie.
1. Définir l'apprentissage automatique
2. Décrire les quatre types de systèmes d'apprentissage automatique.
3. Quelle est la différence entre l'apprentissage supervisé et non supervisé.
4. Nommez les tâches non supervisées.
5. Pourquoi les tests et la validation sontils importants ?
6. En une phrase, décrivez ce qu'est l'apprentissage en ligne.
7. Quelle est la différence entre l'apprentissage par lots et hors ligne ?
8. Quel type de système d'apprentissage automatique devriezvous utiliser pour faire un
robot apprend à marcher ?
RÉSUMÉ
Dans ce chapitre, vous avez appris de nombreux concepts utiles, alors passons en revue certains concepts avec
lesquels vous pourriez vous sentir un peu perdu. Apprentissage automatique : le ML consiste à faire en sorte
que les machines fonctionnent mieux pour certaines tâches, en utilisant des données données.
. L'apprentissage automatique se décline en plusieurs types, tels que l'apprentissage
supervisé, par lots, non supervisé et en ligne.
. Pour réaliser un projet ML, vous devez collecter des données dans un ensemble d'apprentissage, puis
feed qui définit un algorithme d'apprentissage pour obtenir une sortie, des "prédictions".
. Si vous voulez obtenir le bon résultat, votre système doit utiliser des données claires, c'estàdire
pas trop petit et qui n'a pas de caractéristiques non pertinentes.
LES RÉFÉRENCES
.
http://static.googleusercontent.com/media/research.google.com/fr//pubs/archive/35179.pdf
CHAPITRE 2
CLASSIFICATION
Installation
Vous devrez installer Python, Matplotlib et Scikitlearn pour ce chapitre. Allez
simplement à la section des références et suivez les étapes indiquées.
Le MNIST Dans
ce chapitre, vous approfondirez les systèmes de classification et travaillerez avec l'ensemble
de données MNIST. Il s'agit d'un ensemble de 70 000 images de chiffres écrits à la main par des
étudiants et des employés. Vous constaterez que chaque image a une étiquette et un chiffre qui la
représente. Ce projet est comme l'exemple "Hello, world" de la programmation traditionnelle.
Ainsi, chaque débutant en apprentissage automatique devrait commencer par ce projet pour
en savoir plus sur l'algorithme de classification. ScikitLearn a de nombreuses fonctions, dont le
MNIST. Jetons un œil au code :
>>> à partir de sklearn.data sets import fetch_mldata >>>
mn= fetch_mldata('MNIST original')
>>> mn
{'COL_NAMES' : ['label', 'data'],
'Description' : 'ensemble de données mldata.org : mn
original', 'data' : array([[0, 0, 0,..., 0 , 0,
0], [0, 0, 0,..., 0, 0, 0],
[0, 0, 0,..., 0, 0, 0],
...,
[0, 0, 0,..., 0, 0, 0], [0,
0, 0,..., 0, 0, 0], [0, 0,
0,..., 0, 0 , 0]], dataType=uint8), 'tar' :
array([ 0., 0., 0.,..., 9., 9., 9.])} de
. Description est une clé qui décrit l'ensemble de données.
. La clé de données ici contient un tableau avec une seule ligne par exemple et une
colonne pour chaque fonctionnalité.
. Cette clé cible contient un tableau avec des étiquettes.
Travaillons avec une partie du code :
>>> X, y = mn["données"], mn["goudron"]
>>> X.forme
(70000, 784)
>>> y.forme
(70000,)
. 7000 signifie ici qu'il y a 70 000 images, et chaque image a plus de
700 fonctionnalités : « 784 ». Parce que, comme vous pouvez le voir, chaque image est de 28 x 28 pixels, vous
pouvez imaginer que chaque pixel est une caractéristique.
Prenons un autre exemple à partir de l'ensemble de données. Vous n'aurez qu'à saisir la fonctionnalité
d'une instance, puis en faire des tableaux 26 x 26, puis les afficher à l'aide de la fonction imshow :
%matplotlib importation
en ligne matplotlib import
matplotlib.pyplot as plt yourDigit = X[36000]
Your_image = your_image.reshape(26, 26)
plt.imshow(Your_image, cmap = matplotlib.cm.binary, interpolation="nearest")
plt.axis("off") plt.show()
Comme vous pouvez le voir dans l'image suivante, il ressemble au chiffre cinq, et nous pouvons lui donner
une étiquette qui nous dit que c'est cinq.
Dans la figure suivante, vous pouvez voir des tâches de classification plus complexes à partir de l'ensemble
de données MNIST.
De plus, vous devez créer un jeu de test et le faire avant que vos données ne soient inspectées.
L'ensemble de données MNIST est divisé en deux ensembles, un pour la formation et un pour les tests.
x_tr, x_tes, y_tr, y_te = x[:60000], x[60000:], y[:60000], y[60000:]
Jouons avec votre ensemble d'entraînement comme suit pour que la validation croisée soit similaire
(sans aucun chiffre manquant)
Importer numpy en tant que np
mesDonnées = np.radom.permutaion(50000)
x_tr, y_tr = x_tr[mesDonnées], y_tr[mesDonnées]
Maintenant, il est temps de faire assez simple, nous allons essayer d'identifier un seul chiffre, par
exemple le nombre 6. Ce "détecteur 6" sera un exemple du classificateur binaire, pour distinguer
entre 6 et non 6, donc nous' allons créer les vecteurs pour cette tâche :
Y_tr_6 = (y_tr == 6) // cela signifie que ce sera vrai pour 6s, et faux pour tout autre nombre
Y_tes_6 = (Y_tes == 6)
Après cela, nous pouvons choisir un classificateur et l'entraîner. Commencez avec le
classificateur SGD (Stochastic Gradient Descent).
La classe ScikitLearn a l'avantage de gérer de très grands ensembles de données. Dans cet exemple,
le SGD traitera les instances séparément, comme suit.
à partir de sklearn.linear_model importer SGDClassifier
mycl = SGDClassifier (random_state = 42)
mycl.fit(x_tr, y_tr_6)
l'utiliser pour détecter les 6
>>>mycl.prdict([any_digit)]
Mesures de performance Si vous
voulez évaluer un classificateur, ce sera plus difficile qu'un régresseur, alors expliquons comment
évaluer un classificateur.
Dans cet exemple, nous utiliserons la validation croisée pour évaluer notre modèle.
à partir de sklearn.model_selection importer StratifiedKFold
formulaire clone d'importation sklearn.base
sf = StratifiedKFold(n=2, ran_state = 40)
pour train_index, test_index dans sf.split(x_tr, y_tr_6) :
cl = cloner(sgd_clf)
x_tr_fd = x_tr[train_index]
y_tr_fd = (y_tr_6[train_index])
x_tes_fd = x_tr[index_test]
y_tes_fd = (y_tr_6[test_index])
cl.fit(x_tr_fd, y_tr_fd)
y_p = cl.predict(x_tes_fd)
print(n_correct / len(y_p))
. Nous utilisons la classe StratifiedFold pour effectuer un échantillonnage stratifié qui produit des
plis contenant une ration pour chaque classe. Ensuite, chaque itération dans le code créera un
clone du classificateur pour faire des prédictions sur le test fold. Et enfin, il comptera le nombre de
prédictions correctes et leur ratio
. Nous allons maintenant utiliser la fonction cross_val_score pour évaluer le SGDClassifier par
validation croisée Kfold. La validation croisée k fold divisera l'ensemble d'apprentissage en 3 plis,
puis il fera une prédiction et une évaluation sur chaque pli.
depuis sklearn.model_selection importer cross_val_score
cross_val_score(sgd_clf, x_tr, y_tr_6, cv = 3, scoring = "précision")
Vous obtiendrez le rapport de précision des "prédictions correctes" sur tous les plis.
Classifions chaque classificateur à chaque image dans le non6
depuis sklearn.base importer BaseEstimator
classe never6Classifier(BaseEstimator):
def fit(self, X, y=Aucun):
passer
def prédire (soi, x):
return np.zeros((len(X), 1), dtype=bool)
Examinons la précision de ce modèle avec le code suivant :
>>> never_6_cl = Never6Classifier()
>>> cross_val_score(never_6_cl, x_tr, y_tr_6, cv = 3, scoring = "précision")
Sortie : tableau ("["num", "num", "num"])
Pour la sortie, vous obtiendrez pas moins de 90% : seulement 10% des images sont des 6s,
donc on peut toujours imaginer qu'une image n'est pas un 6. On aura raison environ 90%
du temps.
Gardez à l'esprit que la précision n'est pas la meilleure mesure de performance pour les classificateurs, si vous
travaillez avec des ensembles de données asymétriques.
Matrice de confusion Il
existe une meilleure méthode pour évaluer les performances de votre classifieur : la matrice de
confusion.
Il est facile de mesurer les performances avec la matrice de confusion, simplement en comptant le nombre
de fois où les instances de la classe X sont classées dans la classe Y, par exemple. Pour obtenir le
nombre de fois des classificateurs d'images de 6s avec 2s, vous devez regarder dans le th 6
rangée et 2 ème colonne de la matrice de confusion.
Calculons la matrice de confusion en utilisant la fonction cross_val_predict().
de sklearn.model_selection importer cross_Val_predict
y_tr_pre = cross_val_predict (sgd_cl, x_tr, y_tr_6, cv = 3)
Cette fonction, comme la fonction cross_val_score(), effectue la validation croisée k fold et renvoie
également des prédictions sur chaque fold. Il renvoie également une prédiction propre pour chaque
instance de votre ensemble d'entraînement.
Nous sommes maintenant prêts à obtenir la matrice en utilisant le code suivant.
depuis sklearn.metrics importer confusion_matrix
confusion_matrix (y_tr_6, y_tr_pred)
Vous obtiendrez un tableau de 4 valeurs, "chiffres".
Chaque ligne représente une classe dans la matrice et chaque colonne représente une classe
prédite.
La première ligne est la ligne négative : qui « contient des images non6 ». Vous pouvez apprendre
beaucoup de la matrice.
Mais il y en a aussi un bon avec lequel il est intéressant de travailler si vous souhaitez obtenir la
précision des prédictions positives, qui est la précision du classificateur utilisant cette équation.
Précision = (TP)/ (TP+FP)
TP : nombre de vrais positifs
FP : nombre de faux positifs
Rappel = (TP) /(TP+FN) "sensibilité" : il mesure le ratio d'instances positives.
Rappel
>>> de sklearn.metrics import precision_score, rappel_score
>>> précision_score(y_tr_6, y_pre)
>>>recall_score(y_tr_6, y_tr_pre)
Il est très courant de combiner précision et rappel en une seule métrique, qui est le
score F1.
F1 est la moyenne de la précision et du rappel. On peut calculer le score F1 avec
l'équation suivante :
F1 = 2 / ((1/précision) + (1)/rappel)) = 2 * (précision * rappel) / (précision + rappel)
= (TP) / ((TP) + (FN+FP)/2)
Pour calculer le score F1, utilisez simplement la fonction suivante :
>>> depuis sklearn.metrics importer f1_score
>>>f1_score (y_tr_6, y_pre)
Recall Tradeoff
Pour arriver à ce point, vous devriez jeter un coup d'œil au SGDClassifier et
à la façon dont il prend des décisions concernant les classifications. Il calcule
le score en fonction de la fonction de décision, puis il compare le score au
seuil. S'il est supérieur à ce score, il affectera l'instance au « positif ou négatif ».
classe
Par exemple, si le seuil de décision est au centre, vous trouverez 4 vrais + sur le
côté droit du seuil, et un seul faux. Ainsi, le taux de précision ne sera que de 80 %.
Dans ScikitLearn, vous ne pouvez pas définir directement un seuil. Vous devrez
accéder aux scores de décision, qui utilisent des prédictions, et en appelant la fonction de
décision, ().
>>> y_sco = sgd_clf.decision_funciton([n'importe quel chiffre])
>>> y_sco
>>> seuil = 0
>>>y_any_digit_pre = (y_sco > seuil)
Dans ce code, le SGDClassifier contient un seuil, = 0, pour renvoyer le même
résultat que la fonction predict ().
>>> seuil = 20000
>>>y_any_digit_pre = (y_sco > seuil)
>>> y_any_digit_pre
Ce code confirmera que, lorsque le seuil augmente, le rappel diminue.
y_sco = cross_val_predict (sgd_cl, x_tr, y_tr_6, cv =3, method= »fonction de
décision)
Il est temps de calculer toutes les précisions et rappels possibles pour le seuil en appelant
la fonction precision_recall_curve() de
sklearn.metrics import precision_recall_curve
précisions, rappels, seuil = precision_recall_curve (y_tr_6, y_sco)
et maintenant traçons la précision et le rappel en utilisant Matplotlib
def plot_pre_re(pre, re, thr):
plt.plot(thr, pre[:1], "b—", label = "précision")
plt.plot(thr, re[:1], "g", label="Rappeler")
plt.xlabel("Seuil")
plt.legend(loc="gauche")
plt.ylim([0,1])
plot_pre_re(pre, re, thr)
plt.show
ROC
ROC signifie caractéristique de fonctionnement du récepteur et c'est un outil utilisé avec les
classificateurs binaires.
Cet outil est similaire à la courbe de rappel, mais il ne trace pas la précision et le rappel : il trace
le taux positif et le taux de
faux. Vous travaillerez également avec FPR, qui est le rapport des échantillons
négatifs. Vous pouvez imaginer si c'est comme (1 taux négatif. Un autre concept est le TNR
et c'est la spécificité. Rappel = 1 spécificité.
Jouons avec la courbe ROC. Tout d'abord, nous devrons calculer le TPR et le FPR,
simplement en appelant la fonction roccurve(),
de sklearn.metrics importer roc_curve
fp,tp, thers = roc_curve (y_tr_6, y_sco)
Après cela, vous allez tracer le FPR et le TPR avec Matplotlib selon les instructions
suivantes.
def_roc_plot (fp, tp, label=none):
plt.plot(fp, tp, linewidth=2, label = label)
plt.plot([0,1)], [0,1], "k")
plt.axe([0,1,0,1])
plt.xlabel('C'est le faux taux')
plt.ylabel('C'est le vrai taux') roc_plot
(fp, tp)
plt.show
Classification multiclasses Nous
utilisons des classificateurs binaires pour faire la distinction entre deux classes, mais que se passetil
si vous souhaitez en distinguer plus de deux ?
Vous pouvez utiliser quelque chose comme des classificateurs de forêt aléatoires ou des classificateurs
Bayes, qui peuvent comparer plus de deux. Mais, d'un autre côté, SVM (Support Vector Machine) et les
classificateurs linéaires fonctionnent comme des classificateurs binaires.
Si vous souhaitez développer un système qui classe les images de chiffres en 12 classes (de 0 à 11),
vous devrez former 12 classificateurs binaires et en créer un pour chaque classificateur (tel que 4
détecteur, 5 détecteur, 6détecteur et ainsi de suite), puis vous devrez obtenir le DS, le "score de décision",
de chaque classificateur pour l'image. Ensuite, vous choisirez le classificateur de score le plus élevé. Nous
appelons cela la stratégie OvA : "un contre tous".
L'autre méthode consiste à former un classificateur binaire pour chaque paire de chiffres ; par
exemple, un pour 5s et 6s et un autre pour 5s et 7s. nous appelons cette méthode OvO, "un contre un"
pour compter le nombre de classificateurs dont vous aurez besoin, en fonction du nombre de classes qui
utilisent l'équation suivante : "N = nombre de classes".
N * (N1)/2. Si vous souhaitez utiliser cette technique avec le MNIST 10 * (101)/2, la sortie sera de 45
classificateurs, « classificateurs binaires ».
Dans ScikitLearn, vous exécutez OvA automatiquement lorsque vous utilisez un algorithme de
classification binaire.
>>> sgd_cl.fit(x_tr, y_tr)
>>>sgd_cl.Predict([n'importe quel chiffre])
De plus, vous pouvez appeler la decision_function () pour renvoyer les scores "10 scores pour une classe"
>>>any_digit_scores = sgd_cl.decision_function([any_digit])
>>> n'importe quel_chiffre_score
Tableau(["num", "num", "num", "num", "num", "num", "num", "num", "num" ,"num"]])
Formation d'un classificateur de forêt aléatoire >>>
forest.clf.fit(x_tr, y_tr)
>>> forest.clf.predict([n'importe quel chiffre])
tableau([num])
Comme vous pouvez le voir, former un classificateur de forêt aléatoire avec seulement deux lignes de code
est très facile.
Le ScikitLearn n'a exécuté aucune fonction OvA ou OvO, car ce type d'algorithme "classificateurs de forêts
aléatoires" peut automatiquement fonctionner sur plusieurs classes. Si vous souhaitez jeter un œil à la
liste des possibilités de classificateur, vous pouvez appeler la fonction predict_oroba ().
>>> forest_cl.predict_proba([any_digit])
tableau([[0.1, 0, 0, 0.1, 0, 0.8, 0, 0, 0]])
Le classificateur est très précis avec sa prédiction, comme vous pouvez le voir dans la sortie ; il y a 0,8 au
numéro d'indice 5.
Évaluons le classifieur en utilisant la fonction cross_val_score().
>>> cross_val_score(sgd_cl, x_tr, y_tr, cv=3, scoring = "précision")
tableau([0.84463177, 0.859668, 0.8662669])
Vous obtiendrez 84% de plus dans les plis. Lorsque vous utilisez un classificateur aléatoire, vous obtiendrez,
dans ce cas, 10 % pour le score de précision. Gardez à l'esprit que plus cette valeur est élevée, mieux c'est.
Erreur d'analyse
Tout d'abord, lors du développement d'un projet d'apprentissage automatique :
1. Déterminez le problème ; 2.
Collectez vos données ;
3. Travaillez sur vos données et explorez
les ; 4. Nettoyer les
données 5. Travailler avec plusieurs modèles et choisir le
meilleur ; 6. Combinez vos modèles dans la
solution ; 7. Montrez votre
solution ; 8. Exécutez et testez votre système.
Tout d'abord, vous devez travailler avec la matrice de confusion et faire des prédictions
par la fonction crossval. Ensuite, vous appellerez la fonction de matrice de confusion :
>>> y_tr_pre = cross_val_prediciton(sgd_cl, x_tr_scaled, y_tr, cv=3) >>> cn_mx =
confusion_matrix(y_tr, y_tr_pre) >>> cn_mx
tableau([[5625, 2, 25, 8, 11, 44, 52, 12, 34, 6],
[ 2, 2415, 41, 22, 8, 45, 10, 10, 9],
[52, 43, 7443, 104, 89, 26, 87, 60, 166, 13],
[47, 46, 141, 5342, 1, 231, 40, 50, 141, 92],
[19, 29, 41, 10, 5366, 9, 56, 37, 86, 189],
[73, 45, 36, 193, 64, 4582, 111, 30, 193, 94],
[ 29, 34, 44, 2, 42, 85, 5627, 10, 45, 0],
[25, 24, 74, 32, 54, 12, 6, 5787, 15, 236],
[52, 161, 73, 156, 10, 163, 61, 25, 5027, 123],
[ 50, 24, 32, 81, 170, 38, 5, 433, 80, 4250]])
Plt.matshow(cn_mx, cmap=plt.cm.gray)
Plt.show()
Tout d'abord, vous devez diviser chaque valeur de la matrice par le nombre d'images de
la classe, puis vous comparerez les taux d'erreur.
rw_sm = cn_mx.sum(axe=1, keepdims=True)
nm_cn_mx = cn_mx / rw_sum
L'étape suivante consiste à faire tous les zéros sur la diagonale, et cela empêchera
les erreurs de se produire.
np.fill_diagonal (nm_cn_mx, 0)
plt.matshow(nm_cn_mx, cmap=plt.cm.gray)
plt.show()
Les erreurs sont faciles à repérer dans le schéma cidessus. Une chose à garder à l'esprit
est que les lignes représentent les classes et les colonnes représentent les valeurs prédites.
Classifications multiétiquettes
Dans les exemples cidessus, chaque classe n'a qu'une seule instance. Mais que se passetil si nous
voulons attribuer les instances à plusieurs classes la reconnaissance faciale, par exemple.
Supposons que vous souhaitiez trouver plusieurs visages sur la même photo. Il y aura une étiquette
pour chaque visage. Pratiquons avec un exemple simple.
y_tr_big = (y_tr >= 7)
y_tr_odd = (y_tr %2 ==1)
y_multi = np.c [y_tr_big, y_tr_odd]
kng_cl = KNeighborsClassifier()
kng_cl.fit (x_tr, y_m,ulti)
Dans ces instructions, nous avons créé un tableau y_mullti qui contient deux étiquettes pour chaque
image.
Et le premier contient des informations indiquant si le chiffre est "grand" (8,9,.), et le second vérifie
s'il est impair ou non.
Ensuite, nous ferons une prédiction en utilisant l'ensemble d'instructions suivant.
>>>kng_cl.predict([n'importe quel chiffre])
Array([false, true], dataType=bool)
Vrai signifie ici que c'est impair et faux, que ce n'est pas grand.
Classification multisorties
À ce stade, nous pouvons couvrir le dernier type de tâche de classification, qui est la
classification à sorties multiples.
C'est juste un cas général de classification multiétiquettes, mais chaque étiquette aura une
multiclasse. En d'autres termes, il aura plus d'une valeur.
Soyons clairs avec cet exemple, en utilisant les images MNIST, et en ajoutant du bruit à
l'image avec les fonctions NumPy.
Non = rnd.randint (0, 101, (len(x_tr), 785)))
Non = rnd.randint(0, 101, (len(x_tes), 785))
x_tr_mo = x_tr + non
x_tes_mo = x_tes + non
y_tr_mo = x_tr
y_tes_mo = x_tes
kng_cl.fit(x_tr_mo, y_tr_mo)
cl_digit = kng_cl.predict(x_tes_mo[anyindex]])
plot_digit(cl_digit)
DES EXERCICES
1. Construire un classifieur pour l'ensemble de données MNIST. Essayez
d'obtenir plus de
96 % de précision sur votre ensemble de test.
2. Ecrire une méthode pour décaler une image du MNIST (droite ou gauche) de 2
pixels.
3. Développez votre propre programme ou classificateur antispam.
Téléchargez des exemples de spam de Google.
Extraire le jeu de données.
Diviser l'ensemble de données en formation pour un ensemble de test.
Écrire un programme pour convertir chaque email en un vecteur de caractéristiques.
Jouez avec les classificateurs et essayez de construire le meilleur possible, avec des valeurs élevées de rappel
et de précision.
RÉSUMÉ
Dans ce chapitre, vous avez appris de nouveaux concepts utiles et implémenté de nombreux
types d'algorithmes de classification. Vous avez également travaillé avec de nouveaux concepts, comme :
ROC : la caractéristique de fonctionnement du récepteur, l'outil utilisé avec les
classificateurs binaires.
Analyse d'erreurs : optimisation de vos algorithmes.
Comment former un classificateur de forêt aléatoire à l'aide de la fonction de forêt dans
Scikit Learn.
Comprendre la classification multisorties.
Comprendre les classifications multilabels.
LES RÉFÉRENCES
http://scikitlearn.org/stable/install.html
https://www.python.org
https://matplotlib.org/2.1.0/users/installing.html
http://yann.lecun.com/exdb/mnist/
CHAPITRE 3
COMMENT ENTRAÎNER UN MODÈLE
Après avoir travaillé avec de nombreux modèles d'apprentissage automatique et algorithmes de
formation, qui ressemblent à des boîtes noires insondables. nous avons pu optimiser un
système de régression, avons également travaillé avec des classificateurs d'images. Mais nous
avons développé ces systèmes sans comprendre ce qu'il y a à l'intérieur et comment ils fonctionnent,
nous devons donc maintenant approfondir afin de pouvoir comprendre comment ils fonctionnent et
comprendre les détails de la mise en œuvre.
Acquérir une compréhension approfondie de ces détails vous aidera à choisir le bon modèle et à choisir
le meilleur algorithme d'entraînement. En outre, cela vous aidera dans le débogage et l'analyse
des erreurs.
Dans ce chapitre, nous travaillerons avec la régression polynomiale, qui est un modèle complexe
qui fonctionne pour les ensembles de données non linéaires. De plus, nous travaillerons avec plusieurs
techniques de régularisation qui réduisent l'entraînement qui encourage le surajustement.
Régression linéaire À
titre d'exemple, nous prendrons l_S = θ0 + θ1 × GDP_per_cap. Il s'agit d'un modèle simple
pour une fonction linéaire de l'entité en entrée, "GPD_per_cap". (θ0 et θ1) sont les
paramètres du modèle,
En général, vous utiliserez un modèle linéaire pour faire une prédiction en calculant une
somme pondérée des entités en entrée, ainsi qu'un « biais » constant, comme vous pouvez le
voir dans l'équation suivante.
. Y est la valeur du prédicteur.
. N représente les caractéristiques
. X1 est la valeur de la caractéristique.
. Θj est le paramètre de modèle de j thêta.
Aussi, on peut écrire l'équation sous forme vectorisée, comme dans l'exemple suivant :
. Θ est la valeur qui minimise le coût.
. Y contient les valeurs y (1) à y (m).
Écrivons du code pour nous entraîner.
Importer numpy en tant que np
V1_x = 2 * np.random.rand (100, 1)
V2_y = 4 + 3 * V1_x + np.random.randn (100, 1)
Après cela, nous calculerons la valeur Θ en utilisant notre équation. Il est temps d'utiliser la
fonction inv() de notre module d'algèbre linéaire de numpy (np.linalg) pour calculer
l'inverse de n'importe quelle matrice, ainsi que la fonction dot() pour multiplier notre matrice
Valeur1 = np.c_[np.ones((100, 1)), V1_x]
myTheta = np.linalg.inv(Valeur1.T.dot(Valeur1)).dot(Valeur1.T).dot(V2_y)
>>> mon Thêta
Tableau([[num], [num]])
Cette fonction utilise l'équation suivante y = 4 + 3x + bruit "Gaussien" pour générer nos
données.
Faisons maintenant nos prédictions.
>>>V1_new = np.array([[0],[2]])
>>>V1_new_2 = np.c_[np.ones((2,1)), V1_new]
>>>V2_predicit = V1_new_2.dot(myTheta)
>>>V2_predict
Tableau([[ 4.219424], [9.74422282]])
Maintenant, il est temps de tracer le modèle.
Plt.plot(V1_new, V2_predict, "r")
Plt.plot(V1_x, V2_y, "b.")
Axe plt([0,2,0,15])
Plt.show()
Complexité de calcul Avec la formule
normale, nous pouvons calculer l'inverse de M^T. M — c'estàdire une matrice an*n (n = le
nombre de caractéristiques). La complexité de cette inversion est quelque chose comme
O(n^2.5) à O(n^3.2), qui est basée sur l'implémentation.
En fait, si vous augmentez le nombre d'entités comme deux fois, vous ferez en sorte que le temps
de calcul atteigne entre 2 ^ 2,5 et 2 ^ 3,2.
La bonne nouvelle ici est que l'équation est une équation linéaire. Cela signifie qu'il peut facilement
gérer d'énormes ensembles d'entraînement et intégrer la mémoire.
Après avoir formé votre modèle, les prédictions ne seront pas lentes et la complexité sera simple,
grâce au modèle linéaire. Il est temps d'approfondir les méthodes de formation d'un modèle de
régression linéaire, qui est toujours utilisé lorsqu'il y a un grand nombre de fonctionnalités et
d'instances dans la mémoire.
Gradient Descent
Cet algorithme est un algorithme général utilisé pour l'optimisation et pour fournir
la solution optimale à divers problèmes. L'idée de cet algorithme est de travailler avec
les paramètres de manière itérative, pour rendre la fonction de coût aussi simple que
possible.
L'algorithme de descente de gradient calcule le gradient de l'erreur à l'aide du
paramètre thêta et fonctionne avec la méthode du gradient descendant. Si le gradient
est égal à zéro, vous atteindrez le minimum.
De plus, vous devez garder à l'esprit que la taille des étapes est très importante pour cet
algorithme, car si elle est très petite "c'estàdire que le taux d'apprentissage" est lent il
faudra beaucoup de temps pour couvrir tout ce dont il a besoin pour .
Mais lorsque le taux d'apprentissage est élevé, il faudra peu de temps pour couvrir ce qui
est nécessaire et cela fournira une solution optimale.
À la fin, vous ne trouverez pas toujours que toutes les fonctions de coût sont faciles, comme vous
pouvez le voir, mais vous trouverez également des fonctions irrégulières qui rendent très difficile
l'obtention d'une solution optimale. Ce problème se produit lorsque le minimum local et le
minimum global ressemblent à ceux de la figure suivante.
Si vous affectez any à deux points quelconques de votre courbe, vous constaterez que le
segment de la ligne ne les rejoindra pas sur la même courbe. Cette fonction de coût
ressemblera à un bol, ce qui se produira si les entités ont de nombreuses échelles,
comme dans l'image suivante
Batch Gradient Descent Si
vous souhaitez implémenter cet algorithme, vous devez d'abord calculer le gradient de votre
fonction de coût à l'aide du paramètre thêta. Si la valeur du paramètre thêta a changé,
vous devez connaître le taux de variation de votre fonction de coût.
Nous pouvons appeler ce changement par une dérivée
partielle. Nous pouvons calculer la dérivée partielle à l'aide de l'équation suivante :
Mais nous utiliserons également l'équation suivante pour calculer ensemble les dérivées
partielles et le vecteur gradient.
Implémentons l'algorithme.
Lr = 1 # Lr pour le taux d'apprentissage
Num_it = 1000 # nombre d'itérations
L = 100
myTheta = np.random.randn (2,1)
pour cela dans la plage (Num_it):
gr = 2/L * Valeur1.T.dot(Valeur1.dot(myTheta) – V2_y)
monThêta = monThêta – Lr * gr
>>> mon Thêta
Tableau([[num],[num]])
Si vous essayez de modifier la valeur du taux d'apprentissage, vous obtiendrez différentes formes, comme
dans la figure suivante.
Descente de gradient stochastique
Vous rencontrerez un problème lorsque vous utilisez la descente de gradient par lots : elle doit
utiliser l'ensemble d'apprentissage complet afin de calculer la valeur à chaque étape, ce qui
affectera la "vitesse" des performances.
Mais lors de l'utilisation de la descente de gradient stochastique, l'algorithme choisira au hasard
une instance de votre ensemble d'apprentissage à chaque étape, puis il calculera la valeur. De cette
façon, l'algorithme sera plus rapide que la descente de gradient par lots, car il n'a pas besoin
d'utiliser l'ensemble complet pour calculer la valeur. D'autre part, en raison du caractère aléatoire de
cette méthode, elle sera irrégulière par rapport à l'algorithme par lots.
Implémentons l'algorithme.
Nombres = 50
L1, L2 = 5, 50
Déf lr_sc(s) :
renvoie L1 / (s + L2)
myTheta = np.random.randn(2,1)
pour Num dans la plage (Nums):
pour l dans la gamme (f)
monIndex = np.random.randint(f)
V1_Xi = Valeur1[monIndex:monIndex+1]
V2_yi = V2_y[monIndex:monIndex+1]
gr = 2 * V1_xi.T.dot(V1_xi.dot(myTheta) – V2_yi)
Lr = lr_sc(Num * f + i)
monThêta = monThêta – Lr * gr
>>> mon Thêta
Tableau ([[num], [num]])
MiniBatch Gradient Descent
Parce que vous connaissez déjà le lot et les algorithmes stochastiques, ce type
. vous le savez,
d'algorithmes est très facile à comprendre et à utiliser. Comme
les deux algorithmes calculent la valeur des gradients, sur la base de l'ensemble
d'apprentissage ou d'un seul exemple. Cependant, le minilot calcule ses algorithmes
sur la base de petits ensembles aléatoires et fonctionne mieux que les deux autres algorithmes.
Régression polynomiale Nous
utiliserons cette technique lorsque nous travaillerons avec des données plus complexes, en particulier
dans le cas de données linéaires et non linéaires. Après avoir ajouté les pouvoirs de chaque
fonctionnalité, nous pouvons entraîner le modèle avec de nouvelles fonctionnalités. C'est ce qu'on appelle
la régression polynomiale.
Maintenant, écrivons du code.
L = 100
V1 = 6*np.aléatoire.rand(L, 1) – 3
V2 = 0,5 * V1**2 + V1 + 2 + np.random.randn(L, 1)
Comme tu peux le voir. la ligne droite ne représentera jamais les données de la manière la plus
efficace. Nous allons donc utiliser la méthode polynomiale pour travailler sur ce problème.
>>> à partir de sklearn.preprocession importer PolynomialFeatures
>>>P_F = PolynomialFeatures(degré = 2, include_bias=False)
>>>V1_P = P_F.fit_transform(V1)
>>>V1[0]
Tableau([num])
>>>V1_P[0]
Maintenant, faisons en sorte que cette fonction fonctionne correctement avec nos données et modifions la ligne
droite.
>>> ln_r = Régression Linéaire()
>>>ln_r.fit(V1_P, V2)
>>>ln_r.intercept_, ln_r.coef
Courbes d'apprentissage
Supposons que vous travaillez avec une régression polynomiale et que vous souhaitez qu'elle s'adapte
mieux aux données qu'avec la régression linéaire
. Dans l'image suivante, vous trouverez un modèle à 300
degrés . On peut aussi comparer le résultat final avec l'autre type de régression : « linéaire normale ».
Dans la figure cidessus, vous pouvez voir le surajustement des données lorsque vous utilisez le
polynôme. D'un autre côté, avec un linéaire, vous pouvez voir que les données sont évidemment
sousajustées.
Modèles linéaires régularisés
Nous avons travaillé, dans les premier et deuxième chapitres, sur la façon de réduire le
surajustement en régularisant un peu le modèle, par exemple, si vous souhaitez
régulariser un modèle polynomial. Dans ce cas, pour résoudre le problème, vous
devez diminuer le nombre de degrés.
Régression Ridge La
régression Ridge est une autre version de la régression linéaire, mais, après l'avoir
régularisée et ajouté du poids à la fonction de coût, cela l'adapte aux données et rend
même le poids du modèle aussi simple que possible. Voici la fonction de coût de la
régression ridge :
Comme exemple de régression de crête, jetez un œil aux figures suivantes.
Régression au lasso
La régression "Lasso" signifie la régression "Least Absolute Shrinkage and Selection
Operator". Il s'agit d'un autre type de version régularisée de la régression linéaire.
Cela ressemble à une régression de crête, mais avec une petite différence dans l'équation, comme
dans les figures suivantes
La fonction de coût de la régression au lasso :
Comme vous pouvez le voir dans la figure suivante, la régression au lasso utilise des valeurs plus
petites que la crête.
DES EXERCICES
1. Si vous avez un ensemble qui contient un grand nombre de fonctionnalités (des millions
d'entre elles), quel algorithme de régression devriezvous utiliser et pourquoi ?
2. Si vous utilisez la descente de gradient par lots pour tracer l'erreur à chaque période, et
soudainement le taux d'erreurs augmente, comment régleriezvous ce problème ?
3. Que devezvous faire si vous remarquez que les erreurs augmentent lorsque vous
utilisez la méthode des minilots ? Pourquoi?
4. Parmi ces paires, quelle méthode est la meilleure ? Pourquoi? :
. Régression Ridge et régression linéaire ?
. Régression au lasso et régression en crête ?
5. Écrivez le lot Algorithme de descente de gradient.
RÉSUMÉ
Dans ce chapitre, vous avez appris de nouveaux concepts et appris à former un modèle à
l'aide de différents types d'algorithmes. Vous avez également appris quand utiliser chaque
algorithme, notamment les suivants :
Descente de dégradé par lots
Descente de dégradé en minilot
Régression polynomiale
Modèles linéaires régularisés.
Régression de crête
. Régression au lasso
De plus, vous connaissez maintenant la signification de certains termes : régression
linéaire, complexité de calcul et descente de gradient.
LES RÉFÉRENCES
https://docs.scipy.org/doc/numpydev/user/quickstart.html
http://scikit
learn.org/stable/auto_examples/linear_model/plot_polynomial_interpolation.html
Chapitre 4
Différentes combinaisons de modèles
Classificateurs d'arbres.
L'image suivante illustrera la définition d'un objectif général de fonctions de collecte qui consiste
simplement à fusionner différents classificateurs dans un classificateur One qui a une meilleure
performance de généralisation que chaque classificateur individuel seul.
Par exemple, supposons que vous ayez recueilli les prédictions de nombreux experts.
Les méthodes d'ensemble nous permettraient de fusionner ces prédictions par les lots d'experts
pour obtenir une prédiction plus appropriée et plus robuste que les prédictions de chaque expert
individuel. Comme vous pouvez le voir plus loin dans cette partie, il existe de nombreuses méthodes
différentes pour créer un ensemble de classificateurs. Dans cette partie, nous présenterons
une perception de base du fonctionnement des ensembles et pourquoi ils sont
généralement reconnus pour produire une bonne performance de généralisation.
Dans cette partie, nous travaillerons avec la méthode d'ensemble la plus populaire qui utilise le
principe du vote majoritaire. Beaucoup de vote signifie simplement que nous choisissons
l'étiquette qui a été prédite par la majorité des classificateurs ; c'estàdire, a reçu plus de
50 pour cent des votes. À titre d'exemple, le terme ici est comme vote se réfère
uniquement aux paramètres de classe binaires uniquement. Cependant, il n'est pas difficile
de générer le principe du vote majoritaire dans des contextes multiclasses, appelé vote à
la pluralité. Après cela, nous choisirons l'étiquette de classe qui a reçu le plus de votes. Le
diagramme suivant illustre le concept de vote à la majorité et à la pluralité pour un
ensemble de 10 classificateurs où chaque symbole unique (triangle, carré et cercle)
représente une étiquette de classe unique :
En utilisant l'ensemble d'apprentissage, nous commençons par former m différents classificateurs … m).
(CC 1, , Sur la base de la méthode, l'ensemble peut être construit à partir de nombreux
algorithmes de classification ; par exemple, des arbres de décision, des machines à vecteurs de
support, des classificateurs de régression logistique, etc. En fait, vous pouvez utiliser le même algorithme
de classification de base en ajustant différents sousensembles de l'ensemble d'apprentissage. Un
exemple de cette méthode serait l'algorithme de forêt aléatoire, qui fusionne de nombreuses façons
d'ensemble de décision en utilisant le vote à la majorité.
Pour prédire une étiquette de classe via un vote à la majorité simple ou à la pluralité, nous combinons
les étiquettes de classe prédites de chaque classificateur individuel C j et sélectionnons l'étiquette de
classe yˆ qui a reçu le plus de votes :
ˆ
y m = ode{C C 1 2 ( ) X X , , ( ) …,Cm ( ) X }
Par exemple, dans une tâche de classification binaire où class1 1 = − et class2 1 = +, nous pouvons
écrire la prédiction du vote majoritaire.
Pour illustrer pourquoi les méthodes d'ensemble peuvent mieux fonctionner que les classificateurs
individuels seuls, appliquons les concepts simples de combinatoire. Pour l'exemple suivant,
nous supposons que tous les classificateurs de base n pour une tâche de classification
binaire ont un taux d'erreur égal, ε. De plus, nous supposons que les classificateurs sont
indépendants et que les taux d'erreur ne sont pas corrélés. Comme vous pouvez le voir, nous pouvons
simplement expliquer les statistiques d'erreur d'un ensemble de classificateurs de base comme une
probabilité.
Fonction de masse d'une distribution binomiale :
Ici, n. k est le coefficient binomial n choisissez k. Comme vous pouvez le voir, vous pouvez
calculer la probabilité que la prédiction de l'ensemble soit erronée. Voyons maintenant un exemple
plus concret de 11 classificateurs de base (n =11) avec un taux d'erreur de 0,25 (ε = 0,25) :
Vous pouvez remarquer que le taux d'erreur de l'ensemble (0,034) est inférieur au taux d'erreur
de chaque classificateur individuel (0,25) si toutes les hypothèses sont remplies. Notez que dans
cette image simplifiée, une division 5050 par un nombre pair de classificateurs n est traitée comme
une erreur, alors que ce n'est vrai que la moitié du temps. Pour comparer un tel classificateur
d'ensemble idéaliste à un classificateur de base sur une plage de taux d'erreur de base différents,
implémentons la fonction de masse de probabilité en Python :
>>> importer des mathématiques
>>> def ensemble_error(n_classifier, error):
... q_start = math.ceil(n_classifier / 2.0)
... Probabilité = [comb(n_class, q) *
... erreur**q *
... (1erreur)**(n_classificateur q)
... pour q dans la plage (q_start, l_classifier + 2)]
... somme de retour (probabilité)
>>> ensemble_error(n_classifier=11, error=0.25)
0.034327507019042969
Écrivons du code pour calculer les taux des différentes erreurs visualisons la relation entre les
erreurs d'ensemble et de base dans un graphique linéaire :
>>> importer numpy comme np
>>> error_range = np.arange(0.0, 1.01, 0.01)
>>> en_error = [en_er(n_classifier=11, er=er)
... pour er dans er_range]
>>> importer matplotlib.pyplot en tant que plt
>>> plt.plot(er_range, en_error,
... label='Erreur d'ensemble',
... largeur de ligne=2)
>>> plt.plot(er_range, er_range,
... ls='', label='B_ euh',
>>> plt.xlabel('B_er')
>>> plt.label('B/En_er')
>>> plt.legend(loc='en haut à gauche')
>>> plt.grille()
>>> plt.show()
Comme nous pouvons le voir dans le graphique résultant, la probabilité d'erreur d'un
ensemble est toujours meilleure que l'erreur d'un classificateur de base individuel tant que les
classificateurs de base fonctionnent mieux que l'estimation aléatoire (ε < 0,5 ). Vous devriez
remarquer que l'axe des ordonnées représente l'erreur de base ainsi que l'erreur d'ensemble (ligne continue) :
Implémentation d'un classificateur majoritaire simple
Comme nous l'avons vu dans l'introduction à l'apprentissage par fusion dans la dernière section, nous
allons travailler avec une formation d'échauffement puis développer un classificateur simple pour le vote
majoritaire en programmation Python. Comme vous pouvez le voir, le prochain algorithme fonctionnera
sur des paramètres multiclasses via le vote à la pluralité ; vous utiliserez le terme vote majoritaire
pour simplifier, comme cela se fait aussi souvent dans la littérature.
Dans le programme suivant, nous développerons et combinerons également différents
programmes de classification associés à des poids individuels pour la confiance. Notre objectif est
de construire un métaclassificateur plus fort qui équilibre les faiblesses des classificateurs
individuels sur un ensemble de données particulier. En termes mathématiques plus précis, nous
pouvons écrire le vote à la majorité pondérée.
Pour traduire le concept de vote majoritaire pondéré en code Python, nous pouvons utiliser les
fonctions pratiques argmax et bincount de NumPy :
>>> importer numpy comme np
>>> np.argmax(np.bincount([0, 0, 1],
... poids=[0.2, 0.2, 0.6]))
Ici, pij est la probabilité prédite du jième classificateur pour l'étiquette de classe i. Pour
continuer avec notre exemple précédent, supposons que nous ayons un problème de
classification binaire avec des étiquettes de classe i { } 0,1 et un ensemble de trois
classificateurs C j ( j { } 1,2,3 ). Supposons que le classificateur C j renvoie les probabilités
d'appartenance à la classe suivantes pour un échantillon particulier x :
C1 ( ) x → [ ] 0,9,0,1 , C2 ( ) x → [ ] 0,8,0,2 , C3 ( ) x → [ ] 0,4,0,6
Pour implémenter le vote majoritaire pondéré basé sur les probabilités de classe, nous pouvons à
nouveau utiliser NumPy en utilisant numpy.average et np.argmax :
>>> ex = np.tableau([[0.9, 0.1],
... [0.8, 0.2],
... [0.4, 0.6]])
>>> p = np.average(ex, axe=0, poids=[0.2, 0.2, 0.6])
>>> p
tableau([ 0.58, 0.42])
>>> np.argmax(p)
En mettant tout ensemble, implémentons maintenant un MajorityVoteClassifier dans
Python:
de sklearn.base importer ClassifierMixin
depuis sklearn.pre_processing import Label_En
de sklearn.ext importer six
à partir de sklearn.ba importer un clone
depuis sklearn.pipeline importer _name_estimators
importer numpy en tant que np
opérateur d'importation
classe MVClassifier(BaseEstimator,
ClassificateurMixin):
""" Un classificateur d'ensemble à vote majoritaire
Paramètres

cl : semblable à un tableau, forme = [n_classificateurs]
Différents classificateurs pour le vote d'ensemble : str, {'cl_label', 'prob'}
Par défaut : 'cl_label'
Si 'cl_label', la prédiction est basée sur l'argmax des étiquettes de classe. Elif 'prob', l'argument du
total des probs est utilisé pour prédire l'étiquette de classe (recommandé pour les
classificateurs calibrés).
w : comme arr, s = [n_cl]
Facultatif, par défaut : aucun
Si une liste de valeurs ̀int` ou ̀float` est fournie, les classificateurs sont pondérés par """
def __init__(s, cl,
v='cl_label', w=Aucun) :
s.cl = cl
s.named_cl = {clé : valeur pour
clé, valeur dans
_nom_estimateurs(cl)}
v = v
sw=w
def fit_cl(s, X, y):
""" Fit_cl.
Paramètres

X : {tableau, matrice creuse},
s = [n_échantillons, n_caractéristiques]
Matrice des échantillons d'apprentissage.
y : arr_like, sh = [n_échantillons]
Vecteur d'étiquettes de classe cible.
Retour

s : objet
"""
# Utilisez LabelEncoder pour vous assurer que les étiquettes de classe commencent
# avec 0, ce qui est important pour np.argmax
# appel dans s.predict
s.l_ = LabelEncoder()
sl_.fit(y)
s.cl_ = self.lablenc_.classes_
s.cl_ = []
pour cl dans s.cl :
fit_cl = clone(cl).fit(X,
s.la_.transform(y))
s.cl_.append(fit_cl)
Retour
J'ai ajouté beaucoup de commentaires au code pour mieux comprendre les différentes parties.
Cependant, avant d'implémenter les méthodes restantes, faisons une petite pause et discutons du
code qui peut sembler déroutant au premier abord. Nous avons utilisé les classes parentes
BaseEstimator et ClassifierMixin pour obtenir gratuitement certaines fonctionnalités de base, notamment
les méthodes get_params et set_params pour définir et renvoyer les paramètres du classificateur
ainsi que la méthode de score pour calculer la prédiction.
précision, respectivement. Notez également que nous en avons importé six pour rendre
le MajorityVoteClassifier compatible avec Python 2.7.
Ensuite, nous ajouterons la méthode predict pour prédire l'étiquette de classe via un vote majoritaire
basé sur les étiquettes de classe si nous initialisons un nouvel objet MajorityVoteClassifier avec
vote='classlabel'. Alternativement, nous pourrons initialiser le classificateur d'ensemble avec
vote='probability' pour prédire l'étiquette de classe en fonction des probabilités d'appartenance à
la classe. De plus, nous ajouterons également une méthode predict_proba pour renvoyer les probabilités
moyennes, ce qui est utile pour calculer la zone caractéristique de l'opérateur du récepteur sous
la courbe (ROC AUC).
def pre(s, X):
""" Étiquettes de préclasse pour X.
Paramètres

X : {arrlike, spar mat},
Sh = [n_échantillons, n_caractéristiques]
Matrice des échantillons d'apprentissage.
Retour

ma_v : comme un arr, sh = [n_échantillons]
Étiquettes de classe prédites.
"""
si se.v == 'probabilité' :
ma_v = np.argmax(spredict_prob(X),
axe=1)
sinon : # 'cl_label' v
prédictions = np.asarr([cl.predict(X)
pour cl dans
s.cl_]).T
ma_v = np.ap_al_ax(
lambdax :
np.argmax(np.bincount(x, poids=sw)),
axe=1,
arr=prédictions)
ma_v = s.l_.inverse_transform(ma_v)
retourner ma_v
def predict_proba(self, X):
""" Prédiction pour X.
Paramètres

X : {arrlike, sp mat},
sh = [n_échantillons, n_caractéristiques]
Vecteurs d'apprentissage, où n_samples est le nombre d'échantillons et n_features est le nombre
d'entités.
Retour

av_prob : semblable à un tableau,
sh = [n_échantillons, n_classes]
Probabilité moyenne pondérée pour chaque classe par échantillon.
"""
probs = np.asarr([cl.predict_prob(X)
pour cl dans s.cl_])
av_prob = np.av(probs,
axe=0, poids=sw)
retourner av_prob
def get_ps(self, deep=True):
""" Obtenir les noms des paramètres de classificateur pour GridSearch"""
si pas profond :
renvoie super(MVC,
self).get_ps(deep=False)
autre:
ou = s.n_cl.copy()
pour n, entrez\
six.iteritems(s.n_cl):
pour k, valeur en six.iteritems(
step.get_ps(deep=True)):
ou['%s__%s' % (n, k)] = valeur
reviens
Combiner différents algorithmes de classification avec vote majoritaire Maintenant, il est temps de
mettre en action le MVC que nous avons implémenté dans la section précédente. Vous devez d'abord
préparer un ensemble de données sur lequel vous pouvez le tester.
Étant donné que nous connaissons déjà les techniques de chargement de jeux de données à partir de fichiers CSV,
nous allons prendre un raccourci et charger le jeu de données Iris à partir du jeu de données de scikitlearn
module.
De plus, nous ne sélectionnerons que deux caractéristiques, la largeur des sépales et la longueur des
pétales, pour rendre la tâche de classification plus difficile. Bien que notre
MajorityVoteClassifier, ou MVC, se généralise aux problèmes multiclasses, nous ne classifierons que les
échantillons de fleurs des deux classes, IrVersicolor et IrVirginica, pour calculer le ROC AUC. Le code est
comme suit:
>>> importer sklearn en tant que sk
>>> importer sklearn.cross_validation comme cv
>>> ir = jeux de données.load_ir()
>>> X, y = ir.data[50:, [1, 2]], ir.target[50:]
>>> le = LabelEncoder()
>>> y = le.fit_transform(y)
Ensuite, nous divisons les échantillons Iris en 50 % de données d'entraînement et 50 % de données de test :
>>> X_train, X_test, y_train, y_test =\
... train_test_split(X, y,
... test_size=0.5,
... état_aléatoire=1)
En utilisant l'ensemble de données de formation, nous allons maintenant former trois classificateurs
différents un classificateur de régression logistique, un classificateur d'arbre de décision et un classificateur
des kplus proches voisins et examiner leurs performances individuelles via une validation croisée 10
sur l'ensemble de données d'entraînement avant de les fusionner en un ensemble :
importer les éléments suivants
sklearn.cross_validation
sklearn.linear_model
sklearn.tree
sklearn.pipeline
Pipeline
numpy comme np
>>> clf1 = LogisticRegression(penalty='l2',
...C=0.001,
>>> clf2 = DTCl(profondeur_max=1,
... critère='entropie',
>>> cl = KNC(n_nb=1,
...p=2,
... met='minsk')
>>> pipe1 = Pipeline([['sc', StandardScaler()],
... ['clf', clf1]])
>>> pipe3 = Pipeline([['sc', StandardScaler()],
... ['clf', clf3]])
>>> clf_labels = ['Régression logistique', 'Arbre de décision', 'KNN']
>>> print('Validation croisée 10 fois :\n')
>>> pour clf, étiquette dans zip([pipe1, clf2, pipe3], clf_labels) :
... sc = crossVSc(estimator=clf,
>>> X=X_train,
>>> y=y_train,
>>> CV=10,
>>> scoring='roc_auc')
>>> print("ASC ROC : %0.2f (+/ %0.2f) [%s]"
... % (scores.mean(), scores.std(), étiquette))
La sortie que nous recevons, comme indiqué dans l'extrait de code suivant, montre que le
les performances prédictives des classificateurs individuels sont presque égales :
Validation croisée 10 fois :
ROC AUC : 0,92 (+/ 0,20) [régression logistique]
ROC AUC : 0,92 (+/ 0,15) [Arbre de décision]
ROC ASC : 0,93 (+/ 0,10) [KNN]
Vous vous demandez peutêtre pourquoi nous avons formé la régression logistique et le
classificateur des k plus proches voisins dans le cadre d'un pipeline. La cause ici est que,
comme nous l'avons dit, la régression logistique et les algorithmes des k plus proches voisins
(utilisant la métrique de distance euclidienne) ne sont pas invariants d'échelle contrairement aux arbres
de décision. Cependant, les avantages Ir se mesurent tous sur la même échelle ; c'est une bonne habitude de travailler
avec des fonctionnalités standardisées.
Passons maintenant à la partie la plus excitante et combinons les classificateurs individuels
pour le vote à la majorité dans notre M_V_C :
>>> mv_cl = M_V_C(
... cl=[tuyau1, clf2, tuyau3])
>>> cl_labels += ['Vote à la majorité']
>>> all_cl = [pipe1, clf2, pipe3, mv_clf]
>>> pour cl, étiquette dans zip(all_clf, clf_labels) :
... sc = cross_val_score(est=cl,
... X=X_train,
... y=y_train,
... CV=10,
... score='roc_auc')
... % (scores.mean(), scores.std(), étiquette))
R_AUC : 0,92 (+/ 0,20) [Régression logistique]
R_AUC : 0,92 (+/ 0,15) [D_T]
R_AUC : 0,93 (+/ 0,10) [KNN]
R_AUC : 0,97 (+/ 0,10) [Vote à la majorité]
De plus, la sortie de MajorityVotingClassifier s'est considérablement améliorée par rapport
aux classificateurs individuels dans l'évaluation de validation croisée 10 fois.
Classificateur
Dans cette partie, vous allez calculer les courbes R_C à partir de l'ensemble de test pour vérifier si
le MV_Classifier se généralise bien aux données invisibles. Nous devons nous rappeler que
l'ensemble de test ne sera pas utilisé pour la sélection du modèle ; le seul but est de rapporter
une estimation de la précision d'un système de classification. Jetons un coup d'œil à l'importation
métrique.
importer roc_curve à partir de sklearn.metrics importer auc
cls = ['noir', 'orange', 'bleu', 'vert']
ls = [':', '', '.', '']
pour cl, étiquette, cl, l \
... dans zip(all_cl, cl_labels, cls, ls):
... y_pred = clf.fit(X_train,
... y_train).predict_proba(X_test)[:, 1]
... fpr, tpr, seuils = rc_curve(y_t=y_tes,
... y_sc=y_pr)
... rc_auc = ac(x=fpr, y=tpr)
... plt.plot(fpr, tpr,
... couleur=clr,
... style de ligne=ls,
... la='%s (ac = %0.2f)' % (la, rc_ac))
>>> plt.lg(lc='en bas à droite')
>>> plt.plot([0, 1], [0, 1],
... style de ligne='',
... couleur='gris',
>>> plt.xlim([0.1, 1.1])
>>> plt.ylim([0.1, 1.1])
>>> plt.grille()
>>> plt.xlb('Taux de faux positifs')
>>> plt.ylb('Taux positif réel')
>>> plt.show()
Comme nous pouvons le voir dans le ROC résultant, le classificateur d'ensemble fonctionne
également bien sur l'ensemble de test (ROC AUC = 0,95), alors que le classificateur des k plus
proches voisins semble surajuster les données d'apprentissage (entraînement ROC AUC = 0,93,
test ROC ASC = 0,86) :
Vous ne choisissez que deux fonctionnalités pour les tâches de classification. Il sera intéressant de
montrer à quoi ressemble réellement la région de décision du classificateur d'ensemble.
Bien qu'il ne soit pas nécessaire de normaliser les fonctionnalités d'apprentissage avant l'ajustement
du modèle, car nos pipelines de régression logistique et de kplus proches voisins s'en
chargeront automatiquement, vous ferez l'ensemble d'apprentissage de sorte que les régions de
décision de l'arbre de décision soient sur la même échelle à des fins visuelles.
Nous allons jeter un coup d'oeil:
>>> sc = SS()
X_tra_std = sc.fit_transform(X_train)
À partir d'itertools, importez le produit
x_mi= X_tra_std[:, 0].mi() 1
x_ma = X_tra_std[:, 0].ma() + 1
y_mi = X_tra_std[:, 1].mi() 1
y_ma = X_tra_std[:, 1].ma() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
... np.arrange(y_mi, y_ma, 0.1))
f, axarr = plt.subplots(nrows=2, ncols=2,
sharex='col',
sharey='ligne',
figure=(7, 5))
pour ix, cl, tt dans zip(product([0, 1], [0, 1]),
all_cl, cl_lb) :
... cl.fit(X_tra_std, y_tra)
... Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
... Z = Z.resh(xx.forme)
... axarr[idx[0], idx[1]].contou(_xx, _yy, Z, alph=0.3)
... axarr[idx[0], idx[1]].scatter(X_tra_std[y_tra==0, 0],
... X_tra_std[y_tra==0, 1],
... c='bleu',
... marque='^',
...s=50)
... axarr[idx[0], idx[1]].scatt(X_tra_std[y_tra==1, 0],
... X_tra_std[y_tra==1, 1],
... c='rouge',
... marqueur='o',
...s=50)
... axarr[idx[0], idx[1]].set_title(tt)
>>> plt.text(3.5, 4.5,
... z='Sl wid [normalisé]',
... ha='centre', va='centre', ftsize=12)
>>> texte plt(10.5, 4.5,
... z='P_longueur [normalisé]',
... ha='centre', va='centre',
... taille_f=13, rotation=90)
>>> plt.show()
Fait intéressant, mais aussi comme prévu, les régions de décision du classificateur d'ensemble
semblent être un hybride des régions de décision des classificateurs individuels. À première
vue, la limite de décision du vote majoritaire ressemble beaucoup à la limite de décision
du classificateur k plus proche voisin. Cependant, nous pouvons voir qu'il est orthogonal
à l'axe des y pour une largeur de sépale ≥1, tout comme le tronçon d'arbre de décision :
Avant d'apprendre à ajuster les paramètres de classificateur individuels pour la classification
d'ensemble, appelons la méthode get_ps pour trouver une idée essentielle de la façon dont nous
pouvons accéder aux paramètres individuels à l'intérieur d'un objet GridSearch :
>>> mv_clf.get_params()
{'decisiontreeclassifier' : DecisionTreeClassifier(class_weight=Aucun,
critère='entropie', max_depth=1,
max_features=Aucun, max_leaf_nodes=Aucun, min_samples_
feuille=1,
min_samples_split=2, min_weight_fraction_leaf=0.0,
random_state=0, splitter='best'),
'decisiontreeclassifier__class_weight' : aucun,
'decisiontreeclassifier__criterion' : 'entropie',
[...]
'decisiontreeclassifier__random_state' : 0,
'decisiontreeclassifier__splitter' : 'meilleur',
'pipeline1' : Pipeline(steps=[('sc', StandardScaler(copy=True, with_
mean=True, with_std=True)), ('clf', LogisticRegression(C=0.001, class_
poids=Aucun, double=Faux, fit_intercept=Vrai,
intercept_scaling=1, max_iter=100, multi_class='ovr',
pénalité='l2', random_state=0, solveur='liblinear',
tol=0.0001,
verbeux=0))]),
'pipeline1__clf': LogisticRegression(C=0.001, class_weight=None,
dual=Faux, fit_intercept=Vrai,
intercept_scaling=1, max_iter=100, multi_class='ovr',
pénalité='l2', random_state=0, solveur='liblinear',
tol=0.0001,
verbeux=0),
'pipeline1__clf__C' : 0,001,
'pipeline1__clf__class_weight' : aucun,
'pipeline1__clf__dual' : faux,
[...]
'pipeline1__sc__with_std' : Vrai,
'pipeline2' : Pipeline(steps=[('sc', StandardScaler(copy=True, with_
mean=True, with_std=True)), ('clf', KNeighborsClassifier(algorithm='au
to', leaf_size=30, metric='minkowski',
metric_params=Aucun, n_neighbors=1, p=2,
w='uniforme'))]),
'p2__cl' : KNC(algorithme='auto', feuille_
size=30, met='miski',
met_ps=Aucun, n_voisins=1, p=2,
w='uniforme'),
'p2__cl__algorithme' : 'auto',
[...]
'p2__sc__with_std' : T}
En fonction des valeurs renvoyées par la méthode get_ps, vous savez maintenant comment
accéder aux attributs du classificateur individuel. Travaillons avec l'inverse
paramètre de régularisation C du classifieur de régression logistique et la profondeur de l'arbre
de décision via une grille de recherche à des fins de démonstration. Jetons un coup d'œil à :
>>> depuis sklearn.grid_search importer GdSearchCV
>>> paramètres = {'dtreecl__max_depth' : [0.1, .02],
... 'p1__clf__C' : [0.001, 0.1, 100.0]}
>>> gd = GdRechercheCV(estimateur=mv_cl,
... param_grid=params,
... CV=10,
... score='roc_auc')
>>> gd.fit(X_tra, y_tra)
Une fois la recherche de grille terminée, nous pouvons imprimer les différentes
combinaisons de valeurs d'hyperparamètres et les scores moyens R_C AC calculés par
validation croisée 10 fois. Le code est comme suit:
>>> pour params, mean_sc, scores dans grid.grid_sc_ :
... print("%0.3f+/%0.2f %r"
... % (mean_sc, sc.std() / 2, paramètres))
0.967+/0.05 {'p1__cl__C' : 0.001, 'dtreeclassifier__
ma_profondeur' : 1}
0.967+/0.05 {'p1__cl__C' : 0.1, 'dtreeclassifier__ma_
profondeur' : 1}
ma_profondeur' : 1}
ma_profondeur' : 2}
0.967+/0.05 {'p1__cl__C' : 0.1, 'dtreeclassifier__ma_
profondeur' : 2}
ma_profondeur' : 2}
>>> print('Meilleurs paramètres : %s' % gd.best_ps_)
Meilleurs paramètres : {'p1__cl__C' : 100.0,
'dtreeclassifier__ma_depth' : 1}
>>> print('Précision : %.2f' % gd.best_sc_)
Précision : 1,00
Des questions
1. Expliquez comment combiner différents modèles en détail.
2. Quels sont les objectifs et les avantages de combiner des modèles ?

Machine Learning - Step-by-Step Guide To Implement Machine Learning Algorithms With Python (PDFDrive)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Machine Learning - Step-by-Step Guide To Implement Machine Learning Algorithms With Python (PDFDrive)

Transféré par

Droits d'auteur :

Formats disponibles

Machine Translated by Google

Machine Translated by Google

Vous aimerez peut-être aussi