Apprentissage automatique - Entraînement/Tests

Évaluer le modèle

En apprentissage automatique, nous créons des modèles pour prédire les résultats de certains événements, comme dans le chapitre précédent, lorsque nous avons compris le poids et la cylindrée du moteur, nous avons prédit les émissions de CO2 des voitures.

Pour évaluer si le modèle est suffisamment bon, nous pouvons utiliser une méthode appelée entraînement/test.

Qu'est-ce que l'entraînement/test

L'entraînement/test est une méthode pour mesurer l'exactitude du modèle.

C'est pourquoi on l'appelle entraînement/test, car nous divisons l'ensemble de données en deux groupes : le jeu d'entraînement et le jeu de test.

80% sont utilisés pour l'entraînement, 20% pour le test.

Vous pouvez utiliser le jeu d'entraînement pour entraîner le modèle.

Vous pouvez utiliser le jeu de test pour tester le modèle.

Entraîner le modèle signifie créer le modèle.

Tester le modèle signifie tester l'exactitude du modèle.

Commencez par l'ensemble de données.

Commencez par l'ensemble de données à tester.

Notre ensemble de données montre 100 clients dans les magasins 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 l'achat.

L'axe des y représente le montant dépensé lors de l'achat.


Exécuter l'instance

Diviser l'entraînement et le test

Le jeu d'entraînement devrait être une sélection aléatoire de 80% des données originales.

Le jeu de test devrait être le reste de 20%.

train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]

Afficher le jeu d'entraînement

Afficher le graphique de dispersion identique au jeu d'entraînement :

Exemple

plt.scatter(train_x, train_y)
plt.show()

Résultat :

Il semble être similaire à l'ensemble de données original, donc cela semble être une choix raisonnable :


Exécuter l'instance

Afficher le jeu de test

Pour nous assurer que le jeu de test n'est pas complètement différent, nous devons également jeter un coup d'œil au jeu de test.

Exemple

plt.scatter(test_x, test_y)
plt.show()

Résultat :

Le jeu de test semble aussi être similaire à l'ensemble de données original :


Exécuter l'instance

Ajuster les données

Quelles sont les données ? Je pense que la régression polynomiale est la plus appropriée pour les ajuster, donc nous allons dessiner une ligne de régression polynomiale.

Pour tracer une ligne passant par les points de données, nous utilisons le module matplotlib : plott() Méthode :

Exemple

tracer une ligne 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 :


Exécuter l'instance

Ce résultat peut soutenir notre recommandation de faire une régression polynomiale sur l'ensemble de données, même si nous essayons de prédire des valeurs en dehors de l'ensemble de données, cela peut nous donner des résultats étranges. Par exemple : cette ligne indique que si un client passe 6 minutes dans le magasin, il achètera pour 200. Cela pourrait être un signe de surapprentissage.

Mais que dire du score R-squared ? Le score R-squared indique bien l'aptitude de mon ensemble de données au modèle.

R2

Souvenez-vous de R2, également connu sous le nom de R carré (R-squared) ?

Il mesure la relation entre les axes x et y, avec une plage de valeurs allant de 0 à 1, où 0 signifie qu'il n'y a pas de relation et 1 signifie une corrélation complète.

Le module sklearn contient un nom rs_score() Cette méthode, qui nous aidera à trouver cette relation.

Ici, nous devons mesurer la relation entre le temps que le client reste dans le magasin et l'argent qu'il dépense.

Exemple

Comment notre données d'entraînement se situe-t-elle en termes de fitness pour la 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)

Exécuter l'instance

Remarque :Le résultat 0.799 montre une bonne relation.

Introduire le jeu de test

Actuellement, au moins en ce qui concerne les données d'entraînement, nous avons construit un modèle assez bon.

Puis, nous devons utiliser des données de test pour tester le modèle, afin de vérifier si les résultats sont identiques.

Exemple

Permettons de déterminer le coefficient R2 en utilisant les 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)

Exécuter l'instance

Remarque :Le résultat 0,809 indique que ce modèle est également adapté au jeu de test, et nous sommes convaincus que nous pouvons utiliser ce modèle pour prédire des valeurs futures.

Valeur de prévision

Maintenant que nous avons déterminé que notre modèle est bon, nous pouvons commencer à prédire de nouvelles valeurs.

Exemple

Combien coûtera au client qui achète s'il reste dans la boutique pendant 5 minutes ?

print(mymodel(5))

Exécuter l'instance

Ce cas prédit que le client a dépensé 22,88 dollars, ce qui semble correspondre au graphique :