Apprentissage automatique - Former/Tester
Évaluez votre modèle
En Machine Learning, nous créons des modèles pour prédire le résultat de certains événements, comme dans le chapitre précédent où nous avons prédit l'émission de CO2 d'une voiture lorsque nous connaissions le poids et la cylindrée du moteur.
Pour mesurer si le modèle est assez bon, nous pouvons utiliser une méthode appelée Train/Test.
Qu'est-ce que l'entraînement/le test ?
Train/Test est une méthode pour mesurer la précision de votre modèle.
Il s'appelle Train/Test car vous divisez l'ensemble de données en deux ensembles : un ensemble d'apprentissage et un ensemble de test.
80 % pour la formation et 20 % pour les tests.
Vous entraînez le modèle à l'aide de l'ensemble d'entraînement.
Vous testez le modèle à l'aide de l'ensemble de test.
Former le modèle signifie créer le modèle.
Tester le modèle signifie tester la précision du modèle.
Commencez avec un ensemble de données
Commencez avec un ensemble de données que vous souhaitez tester.
Notre ensemble de données illustre 100 clients dans un magasin et leurs habitudes d'achat.
Exemple
import numpy
import matplotlib.pyplot as plt
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
plt.scatter(x, y)
plt.show()
Résultat:
L'axe des x représente le nombre de minutes avant de faire un achat.
L'axe y représente le montant d'argent dépensé pour l'achat.
Fractionner en train/test
L' ensemble d'apprentissage doit être une sélection aléatoire de 80 % des données d'origine.
L' ensemble de test devrait être les 20 % restants.
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
Afficher l'ensemble d'entraînement
Affichez le même nuage de points avec l'ensemble d'apprentissage :
Exemple
plt.scatter(train_x,
train_y)
plt.show()
Résultat:
Il ressemble à l'ensemble de données d'origine, il semble donc être une sélection équitable :
Afficher l'ensemble de test
Pour nous assurer que l'ensemble de test n'est pas complètement différent, nous examinerons également l'ensemble de test.
Exemple
plt.scatter(test_x,
test_y)
plt.show()
Résultat:
L'ensemble de test ressemble également à l'ensemble de données d'origine :
Adapter l'ensemble de données
À quoi ressemble l'ensemble de données ? À mon avis, je pense que le meilleur ajustement serait une régression polynomiale , alors traçons une ligne de régression polynomiale.
Pour tracer une ligne à travers les points de données, nous utilisons la
plot()méthode du module matplotlib :
Exemple
Tracez une droite de régression polynomiale passant par les points de données :
import numpy
import
matplotlib.pyplot as plt
numpy.random.seed(2)
x =
numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40, 100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y =
y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y, 4))
myline = numpy.linspace(0, 6, 100)
plt.scatter(train_x, train_y)
plt.plot(myline, mymodel(myline))
plt.show()
Résultat:
Le résultat peut étayer ma suggestion selon laquelle l'ensemble de données correspond à une régression polynomiale, même si cela nous donnerait des résultats étranges si nous essayions de prédire des valeurs en dehors de l'ensemble de données. Exemple : la ligne indique qu'un client passant 6 minutes dans le magasin effectuerait un achat d'une valeur de 200. C'est probablement un signe de surajustement.
Mais qu'en est-il du score R au carré ? Le score R au carré est un bon indicateur de la mesure dans laquelle mon ensemble de données correspond au modèle.
R2
Vous souvenez-vous de R2, également connu sous le nom de R-carré ?
Il mesure la relation entre l'axe des x et l'axe des y, et la valeur varie de 0 à 1, où 0 signifie aucune relation et 1 signifie totalement lié.
Le module sklearn a une méthode appelée r2_score()
qui nous aidera à trouver cette relation.
Dans ce cas, nous aimerions mesurer la relation entre les minutes qu'un client reste dans le magasin et combien d'argent il dépense.
Exemple
Dans quelle mesure mes données d'entraînement s'intègrent-elles dans une régression polynomiale ?
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y,
4))
r2 = r2_score(train_y, mymodel(train_x))
print(r2)
Remarque : Le résultat 0,799 indique qu'il existe une relation OK.
Apportez le kit de test
Nous avons maintenant créé un modèle qui est correct, du moins en ce qui concerne les données d'entraînement.
Maintenant, nous voulons également tester le modèle avec les données de test, pour voir si cela nous donne le même résultat.
Exemple
Trouvons le score R2 lors de l'utilisation des données de test :
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y,
4))
r2 = r2_score(test_y, mymodel(test_x))
print(r2)
Remarque : Le résultat 0,809 montre que le modèle correspond également à l'ensemble de test, et nous sommes convaincus que nous pouvons utiliser le modèle pour prédire les valeurs futures.
Prédire les valeurs
Maintenant que nous avons établi que notre modèle est OK, nous pouvons commencer à prédire de nouvelles valeurs.
Exemple
Combien d'argent un client acheteur dépensera-t-il s'il reste 5 minutes dans le magasin ?
print(mymodel(5))
L'exemple prédit que le client dépensera 22,88 dollars, comme cela semble correspondre au schéma :
