Comment connecter les données d'entrée du modèle aux prédictions pour l'apprentissage automatique
Ajuster un modèle à un ensemble de données de formation est si simple aujourd'hui avec des bibliothèques comme scikit-learn.
Un modèle peut être ajusté et évalué sur un ensemble de données en quelques lignes de code seulement. C'est si simple que c'est devenu un problème.
Les mêmes quelques lignes de code sont répétées encore et encore et il n'est peut-être pas évident de savoir comment utiliser réellement le modèle pour faire une prédiction. Ou, si une prédiction est effectuée, comment relier les valeurs prédites aux valeurs d'entrée réelles.
Je sais que c'est le cas car je reçois de nombreux e-mails avec la question :
Comment puis-je connecter les valeurs prédites aux données d'entrée ?
C'est un problème courant.
Dans ce didacticiel, vous découvrirez comment associer les valeurs prédites aux entrées d'un modèle d'apprentissage automatique.
Après avoir terminé ce tutoriel, vous saurez :
- Comment ajuster et évaluer le modèle sur un ensemble de données d'entraînement.
- Comment utiliser le modèle d'ajustement pour effectuer des prédictions une par une et par lots.
- Comment connecter les valeurs prédites aux entrées du modèle.
Démarrez votre projet avec mon nouveau livre Machine Learning Mastery With Python, comprenant des tutoriels étape par étape et les fichiers code source Python pour tous les exemples.
Commençons.
- Mise à jour de janvier 2020 : mise à jour pour les modifications apportées à l'API scikit-learn v0.22.
Présentation du didacticiel
Ce didacticiel est divisé en trois parties : ils sont:
- Préparer un ensemble de données de formation
- Comment ajuster un modèle sur l'ensemble de données de formation
- Comment connecter les prédictions aux entrées du modèle
Préparer un ensemble de données de formation
Commençons par définir un ensemble de données que nous pouvons utiliser avec notre modèle.
Vous pouvez avoir votre propre ensemble de données dans un fichier CSV ou dans un tableau NumPy en mémoire.
Dans ce cas, nous utiliserons un simple problème de classification à deux classes ou binaire avec deux variables d'entrée numériques.
- Entrées : deux variables d'entrée numériques :
- Sorties : une étiquette de classe sous la forme 0 ou 1.
Nous pouvons utiliser la fonction scikit-learn make_blobs() pour créer cet ensemble de données avec 1 000 exemples.
L'exemple ci-dessous crée l'ensemble de données avec des tableaux séparés pour l'entrée (X) et les sorties (y).
# example of creating a test dataset
from sklearn.datasets import make_blobs
# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=2)
# summarize the shape of the arrays
print(X.shape, y.shape)
L'exécution de l'exemple crée l'ensemble de données et imprime la forme de chacun des tableaux.
Nous pouvons voir qu’il y a 1 000 lignes pour les 1 000 échantillons dans l’ensemble de données. Nous pouvons également voir que les données d'entrée comportent deux colonnes pour les deux variables d'entrée et que le tableau de sortie est un long tableau d'étiquettes de classe pour chacune des lignes des données d'entrée.
(1000, 2) (1000,)
Ensuite, nous ajusterons un modèle sur cet ensemble de données de formation.
Comment ajuster un modèle sur l'ensemble de données de formation
Maintenant que nous disposons d’un ensemble de données d’entraînement, nous pouvons adapter un modèle aux données.
Cela signifie que nous fournirons toutes les données d'entraînement à un algorithme d'apprentissage et laisserons l'algorithme d'apprentissage découvrir le mappage entre les entrées et l'étiquette de classe de sortie qui minimise l'erreur de prédiction.
Dans ce cas, comme il s’agit d’un problème à deux classes, nous essaierons l’algorithme de classification par régression logistique.
Ceci peut être réalisé en utilisant la classe LogisticRegression de scikit-learn.
Tout d’abord, le modèle doit être défini avec toute configuration spécifique dont nous avons besoin. Dans ce cas, nous utiliserons le solveur efficace 'lbfgs'.
Ensuite, le modèle est ajusté à l'ensemble de données d'entraînement en appelant la fonction fit() et en transmettant l'ensemble de données d'entraînement.
Enfin, nous pouvons évaluer le modèle en l'utilisant d'abord pour faire des prédictions sur l'ensemble de données d'entraînement en appelant predict(), puis en comparant les prédictions aux étiquettes de classe attendues et en calculant la précision.
L’exemple complet est répertorié ci-dessous.
# fit a logistic regression on the training dataset
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_blobs
from sklearn.metrics import accuracy_score
# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=2)
# define model
model = LogisticRegression(solver='lbfgs')
# fit model
model.fit(X, y)
# make predictions
yhat = model.predict(X)
# evaluate predictions
acc = accuracy_score(y, yhat)
print(acc)
L'exécution de l'exemple ajuste le modèle à l'ensemble de données d'entraînement, puis imprime la précision de la classification.
Dans ce cas, nous pouvons voir que le modèle a une précision de classification de 100 % sur l'ensemble de données d'entraînement.
1.0
Maintenant que nous savons comment ajuster et évaluer un modèle sur l'ensemble de données d'entraînement, passons au fond de la question.
Comment connecter les entrées du modèle aux sorties ?
Comment connecter les prédictions aux entrées du modèle
Un modèle d'apprentissage automatique adapté prend en compte les entrées et effectue une prédiction.
Il peut s'agir d'une ligne de données à la fois ; Par exemple:
- Entrée : 2,12309797 -1,41131072
- Sortie : 1
C'est simple avec notre modèle.
Par exemple, nous pouvons faire une prédiction avec une entrée de tableau et obtenir une sortie et nous savons que les deux sont directement connectées.
L'entrée doit être définie comme un tableau de nombres, en particulier 1 ligne avec 2 colonnes. Nous pouvons y parvenir en définissant l'exemple comme une liste de lignes avec une liste de colonnes pour chaque ligne ; Par exemple:
...
# define input
new_input = [[2.12309797, -1.41131072]]
Nous pouvons ensuite fournir cela comme entrée au modèle et faire une prédiction.
...
# get prediction for new input
new_output = model.predict(new_input)
En associant cela à l’ajustement du modèle de la section précédente, l’exemple complet est répertorié ci-dessous.
# make a single prediction with the model
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_blobs
# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=2)
# define model
model = LogisticRegression(solver='lbfgs')
# fit model
model.fit(X, y)
# define input
new_input = [[2.12309797, -1.41131072]]
# get prediction for new input
new_output = model.predict(new_input)
# summarize input and output
print(new_input, new_output)
L'exécution de l'exemple définit la nouvelle entrée et effectue une prédiction, puis imprime à la fois l'entrée et la sortie.
Nous pouvons voir que dans ce cas, le modèle prédit l’étiquette de classe 1 pour les entrées.
[[2.12309797, -1.41131072]] [1]
Si nous utilisions le modèle dans notre propre application, cette utilisation du modèle nous permettrait de relier directement les entrées et les sorties pour chaque prédiction effectuée.
Si nous devions remplacer les étiquettes 0 et 1 par quelque chose de significatif comme « spam » et « pas de spam », nous pourrions le faire avec une simple instruction if.
Jusqu'ici, tout va bien.
Que se passe-t-il lorsque le modèle est utilisé pour effectuer plusieurs prédictions à la fois ?
Autrement dit, comment relier les prédictions aux entrées lorsque plusieurs lignes ou plusieurs échantillons sont fournis au modèle à la fois ?
Par exemple, nous pourrions faire une prédiction pour chacun des 1 000 exemples de l’ensemble de données d’entraînement, comme nous l’avons fait dans la section précédente lors de l’évaluation du modèle. Dans ce cas, le modèle effectuerait 1 000 prédictions distinctes et renverrait un tableau de 1 000 valeurs entières. Une prédiction pour chacune des 1 000 lignes de données d’entrée.
Il est important de noter que l'ordre des prédictions dans le tableau de sortie correspond à l'ordre des lignes fournies en entrée du modèle lors de la réalisation d'une prédiction. Cela signifie que la ligne d'entrée à l'index 0 correspond à la prédiction à l'index 0 ; il en va de même pour l'index 1, l'index 2, jusqu'à l'index 999.
Par conséquent, nous pouvons relier les entrées et les sorties directement en fonction de leur index, en sachant que l'ordre est préservé lors de la réalisation d'une prédiction sur de nombreuses lignes d'entrées.
Rendons cela concret avec un exemple.
Tout d’abord, nous pouvons faire une prédiction pour chaque ligne d’entrée dans l’ensemble de données d’entraînement :
...
# make predictions on the entire training dataset
yhat = model.predict(X)
Nous pouvons ensuite parcourir les index et accéder à l’entrée et à la sortie prévue pour chacun.
Cela montre précisément comment connecter les prédictions aux lignes d'entrée. Par exemple, l'entrée à la ligne 0 et la prédiction à l'index 0 :
...
print(X[0], yhat[0])
Dans ce cas, nous examinerons simplement les 10 premières lignes et leurs prédictions.
...
# connect predictions with outputs
for i in range(10):
print(X[i], yhat[i])
En reliant cela ensemble, l'exemple complet de réalisation d'une prédiction pour chaque ligne des données d'entraînement et de connexion des prédictions avec les entrées est répertorié ci-dessous.
# make a single prediction with the model
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_blobs
# create the inputs and outputs
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=2)
# define model
model = LogisticRegression(solver='lbfgs')
# fit model
model.fit(X, y)
# make predictions on the entire training dataset
yhat = model.predict(X)
# connect predictions with outputs
for i in range(10):
print(X[i], yhat[i])
En exécutant l'exemple, le modèle effectue 1 000 prédictions pour les 1 000 lignes de l'ensemble de données d'entraînement, puis connecte les entrées aux valeurs prédites pour les 10 premiers exemples.
Cela fournit un modèle que vous pouvez utiliser et adapter pour vos propres projets de modélisation prédictive afin de connecter les prédictions aux lignes d'entrée via leur index de ligne.
[ 1.23839154 -2.8475005 ] 1
[-1.25884111 -8.57055785] 0
[ -0.86599821 -10.50446358] 0
[ 0.59831673 -1.06451727] 1
[ 2.12309797 -1.41131072] 1
[-1.53722693 -9.61845366] 0
[ 0.92194131 -0.68709327] 1
[-1.31478732 -8.78528161] 0
[ 1.57989896 -1.462412 ] 1
[ 1.36989667 -1.3964704 ] 1
Lectures complémentaires
Cette section fournit plus de ressources sur le sujet si vous souhaitez approfondir.
Messages
- Votre premier projet d'apprentissage automatique en Python étape par étape
- Comment faire des prédictions avec scikit-learn
Apis
- API sklearn.datasets.make_blobs
- API sklearn.metrics.accuracy_score
- API sklearn.linear_model.LogisticRegression
Résumé
Dans ce didacticiel, vous avez découvert comment associer les valeurs prédites aux entrées d'un modèle d'apprentissage automatique.
Concrètement, vous avez appris :
- Comment ajuster et évaluer le modèle sur un ensemble de données d'entraînement.
- Comment utiliser le modèle d'ajustement pour effectuer des prédictions une par une et par lots.
- Comment connecter les valeurs prédites aux entrées du modèle.
Avez-vous des questions ?
Posez vos questions dans les commentaires ci-dessous et je ferai de mon mieux pour y répondre.