Un débutant en apprentissage automatique a essayé de créer un modèle de prédiction de courses de chevaux avec python

Récemment, le nombre de développements de services intégrant l'apprentissage automatique a commencé à augmenter et je le dirige parfois moi-même.

Cependant, il est indéniable qu'il s'agit d'une tâche simple d'utiliser aveuglément le modèle d'apprentissage créé par des personnes appelées data scientists et ingénieurs ML, et il est facile pour les débutants (I) d'élever leur niveau de connaissance de l'apprentissage automatique. J'ai essayé de résumer le processus jusqu'à ce que je sois capable de créer un modèle d'apprentissage.

Ce but

Nous allons commencer par construire un environnement avec python, puis essayer de construire un modèle de classification par régression logistique, ce qui semble être le plus rapide. En ce qui concerne le sujet, je vais contester le modèle de prédiction des courses de chevaux pour les loisirs et le profit.

• Bien que nous utilisions les termes techniques des courses de chevaux, nous vous serions reconnaissants si vous pouviez enquêter sur des points peu clairs.

Environnement

supposition

L'environnement mis en œuvre est le suivant.

• Python：3.7.7
• pip：20.2.2

installation de pipenv

Je vais construire l'environnement d'exécution de python en utilisant pipenv.

$ pip install pipenv

Créez un environnement virtuel pour exécuter python.

$ export PIPENV_VENV_IN_PROJECT=true
$ cd <project_dir>
$ pipenv --python 3.7

PIPENV_VENV_IN_PROJECT est un paramètre pour créer un environnement virtuel sous le répertoire du projet (./.venv/).

Installation de la bibliothèque

Ici, nous installerons les bibliothèques minimales requises.

$ pipenv install pandas
$ pipenv install sklearn
$ pipenv install matplotlib
$ pipenv install jupyter

Après l'installation, Pipfile et Pipfile.lock dans le répertoire actuel ont été mis à jour. Ces 4 bibliothèques sont des éléments essentiels, alors installons-les sans rien dire.

Comment démarrer le notebook Jupyter

$ cd <project_dir>
$ pipenv run jupyter notebook
...
    To access the notebook, open this file in a browser:
        file:///Users/katayamk/Library/Jupyter/runtime/nbserver-4261-open.html
    Or copy and paste one of these URLs:
        http://localhost:8888/?token=f809cb2bcb716ba5726912d43738dd51992d3d7f20942d71
     or http://127.0.0.1:8888/?token=f809cb2bcb716ba5726912d43738dd51992d3d7f20942d71

En accédant à la sortie de l'URL localhost vers le terminal, vous pourrez parcourir le notebook jupyter sur votre serveur local.

Ceci termine la construction de l'environnement.

Construction de modèles

Il existe différents types d'apprentissage automatique, tels que l'apprentissage supervisé, l'apprentissage non supervisé, l'apprentissage amélioré et l'apprentissage en profondeur, mais cette fois, comme mentionné au début, afin de pouvoir créer un modèle d'apprentissage simple. Construisez un modèle de classification pour l'apprentissage supervisé.

Flux de travail d'apprentissage automatique

L'article AWS était facile à comprendre, je pense donc que vous devriez vous y référer ici. Qu'est-ce que le flux de travail d'apprentissage automatique? Explication des services d'apprentissage automatique AWS dans Grareco Je pense que le flux ci-dessus sera résumé brièvement, nous allons donc construire le modèle d'apprentissage dans cet ordre.

1. Acquisition de données

En construisant un modèle de prédiction des courses de chevaux, nous avons d'abord besoin de données passées sur les courses de chevaux. Il existe également des informations sur la manière de récupérer des sites d'informations sur les courses de chevaux sur Internet, mais en prévision des opérations futures, nous achèterons et obtiendrons des données officielles de la JRA. Données acquises: JRA-VAN Data Lab

Vous pouvez créer un programme pour obtenir les données vous-même, mais vous pouvez également utiliser le logiciel gratuit de courses de chevaux fourni à l'avance pour générer les données dans un fichier. (Comme ce n'est pas l'histoire principale, je vais omettre les détails.)

Cette fois, j'ai obtenu les deux types de fichiers de données suivants. La période cible des données est de 5 ans de 2015 à 2019.

2. Prétraitement des données

Qu'est-ce que le prétraitement des données?

Voici l'étape la plus importante de l'apprentissage automatique. Effectuez le traitement suivant en fonction des données acquises.

Nettoyage des données

Vous pouvez supprimer les données de bruit ou remplir les valeurs manquantes avec des valeurs différentes.

Intégration de données

Les données nécessaires à la formation sont rarement intégrées dès le début et les données distribuées sont intégrées pour générer des données cohérentes.

Conversion de données

Processus de conversion des données dans un format spécifié pour améliorer la qualité du modèle. Par exemple, le traitement de diverses données telles que la standardisation des données numériques en données comprises entre -1 et 1, ou la conversion des données de catégorie dans lesquelles un chien ou un chat est sélectionné en une variable factice et leur conversion en valeur numérique. Sera réalisée.

Prétraitement des données de courses de chevaux

À partir de là, nous mettrons en œuvre le prétraitement des données de courses de chevaux, mais si vous utilisez le notebook jupyter démarré, vous pouvez programmer tout en vérifiant le statut des données de manière interactive.

Tout d'abord, chargez les données de courses de chevaux acquises dans le DataFrame des pandas, mais à la suite du prétraitement des données, je vais enfin traiter les données dans la structure suivante.

Cette fois-ci, nous utiliserons le montant total des prix que chaque cheval a gagné jusqu'à présent comme un montant de fonction pour mesurer la capacité des chevaux de course. Nous avons également adopté le nom du cavalier car nous pensions qu'il y aurait une grande différence en fonction de l'habileté du cavalier. Essayons de voir à quel point la prédiction peut être précise avec ces deux variables explicatives seules.

build.ipynb

import os
import pandas as pd

#Données de la table de course
syutsuba_path = './data/sample/syutsuba_data.csv'
df_syutsuba = pd.read_csv(syutsuba_path, encoding='shift-jis')
df_syutsuba = df_syutsuba[['ID de course', 'Ce prix', 'Nom du cavalier']]

#Données de note
seiseki_path = './data/sample/seiseki_data.csv'
df_seiseki = pd.read_csv(seiseki_path, encoding='shift-jis')
df_seiseki = df_seiseki[['ID de course', 'Ordre d'arrivée confirmé']]

Dans DataFrame, les données sont organisées comme suit.

Référence) Format de données Race ID

Ensuite, nous intégrerons les données acquises et effectuerons le nettoyage et la conversion des données.

build.ipynb

#Fusionner les données de la table de course et les données de grade
df = pd.merge(df_syutsuba, df_seiseki, on = 'ID de course')

#Supprimer les enregistrements avec des valeurs manquantes
df.dropna(how='any', inplace=True)

#Ajoutez une colonne pour voir si l'ordre d'arrivée est dans les 3
f_ranking = lambda x: 1 if x in [1, 2, 3] else 0
df['Dans les 3'] = df['Ordre d'arrivée confirmé'].map(f_ranking)

#Générer une variable factice
df = pd.get_dummies(df, columns=['Nom du cavalier'])

#Définir l'index (utilisez jusqu'à 16 octets pour spécifier la race uniquement)
df['race_index'] = df['ID de course'].astype(str).str[0:16]
df.set_index('race_index', inplace=True)

#Supprimer les colonnes inutiles
df.drop(['ID de course', 'Ordre d'arrivée confirmé'], axis=1, inplace=True)

Si vous vérifiez le DataFrame, vous pouvez voir que les colonnes qui ont été transformées en variables factices sont remplacées par de nouvelles colonnes pour le nombre de catégories qui leur appartiennent et que l'indicateur 0 ou 1 est défini. En faisant du nom du cavalier une variable factice, le nombre de colonnes est passé à 295, mais veuillez noter que faire d'une colonne avec un grand nombre de catégories une variable factice peut entraîner un surapprentissage.

3. Apprentissage de modèles

Ensuite, apprenons le modèle. Premièrement, les données sont divisées en données d'apprentissage et données d'évaluation pour chaque variable explicative et variable objective.

build.ipynb

from sklearn.model_selection import train_test_split

#Stocker les variables explicatives dans dataX
dataX = df.drop(['Dans les 3'], axis=1)

#Stocker la variable d'objectif dans dataY
dataY = df['Dans les 3']

#Divisez les données (données d'apprentissage 0.8 Données d'évaluation 0.2）
X_train, X_test, y_train, y_test = train_test_split(dataX, dataY, test_size=0.2, stratify=dataY)

En bref, il est divisé en quatre types de données suivants.

Cette fois, train_test_split est utilisé pour diviser facilement les données d'entraînement et les données d'évaluation, mais pour les données avec le concept de série temporelle comme les courses de chevaux, ** (passé) -> données d'entraînement-> Il semble que la précision sera améliorée si les données sont divisées de manière à ce que l'ordre soit des données d'évaluation-> (en cours) **.

Ensuite, nous formerons les données préparées. L'algorithme de base est contenu dans sklearn, et cette fois nous utiliserons la ** régression logistique **.

build.ipynb

from sklearn.linear_model import LogisticRegression

#Créer un classificateur (régression logistique)
clf = LogisticRegression()

#Apprentissage
clf.fit(X_train, y_train)

C'est tout. C'est très facile.

4. Évaluation du modèle

Tout d'abord, prédisons les données d'évaluation et vérifions le taux de réponse correct en fonction du résultat.

build.ipynb

#Prévoir
y_pred = clf.predict(X_test)

#Afficher le taux de réponse correct
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, y_pred))
0.7874043003746538

Le taux de réponse correct est "0,7874043003746538", ce qui signifie que 78% peuvent être prédits correctement. À première vue, vous pourriez être heureux de dire: "Oh génial! C'est vraiment rentable!", Mais soyez prudent avec ce score de précision. Essayez ensuite d'exécuter le code suivant.

build.ipynb

#Afficher la matrice de confusion
from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[  339 10031]
 [  410 38332]]

Ce tableau à deux dimensions est appelé une matrice de confusion, mais il représente ce qui suit.

Parmi ceux-ci, le taux de réponse correcte est le total de ** Prédiction: 3e place ou moins x Réel: 3e place ou moins ** et ** Prédiction: 4e place ou moins x Réel: 4e place ou moins **.

** Taux de réponse correcte **: 0,78 = (339 + 38332) / (339 + 38332 + 410 + 10031)

À partir de ce résultat, on peut voir que le nombre de cas prévus pour se situer à la 3e place est trop petit en premier lieu, et le taux de réponse correcte est augmenté en prédisant que la plupart d'entre eux occupent la 4e place ou moins.

Maintenant que vous savez que vous devez faire attention au taux de précision, que faut-il utiliser pour évaluer la précision du modèle? Une façon d'utiliser cette matrice de confusion est de vérifier la valeur F.

Quelle est la valeur F?

C'est une combinaison de 1 et 2 ci-dessous.

1. Pourcentage de coureurs prédits à la 3e place (appelé taux de précision)
2. Le pourcentage de chevaux qui ont effectivement terminé à la 3e place qui ont répondu correctement (appelé taux de rappel)

** Taux de conformité **: 0,45 = 339 / (339 + 410) ** rappel **: 0,03 = 339 / (339 + 10031)

build.ipynb

#Afficher la valeur F
from sklearn.metrics import f1_score
print(f1_score(y_test, y_pred))
0.06097670653835776

Quand j'ai vérifié la valeur F cette fois, c'était "0.06097670653835776". En ce qui concerne la valeur F, dans le cas d'une division aléatoire en 0 et 1, elle a la propriété de converger vers 0,5, vous pouvez donc voir que la valeur de 0,06 cette fois est une valeur extrêmement faible.

Corriger le déséquilibre des données

build.ipynb

print(df['Dans les 3'].value_counts())
0    193711
1     51848

Le ratio des variables objectives entre la 3ème place et la 4ème place ou moins est de 1: 4, et il y a un léger biais dans les données, corrigeons donc un peu cela.

Tout d'abord, installez les bibliothèques supplémentaires suivantes.

$ pipenv install imbalanced-learn

Sous-échantillonnez le ratio de données des données d'entraînement entre la 3ème place et la 4ème place ou moins à 1: 2. Le sous-échantillonnage signifie réduire au hasard le nombre de grands nombres de données pour correspondre au petit nombre de données.

build.ipynb

from imblearn.under_sampling import RandomUnderSampler

#Sous-échantillonnage des données d'entraînement
f_count = y_train.value_counts()[1] * 2
t_count = y_train.value_counts()[1]
rus = RandomUnderSampler(sampling_strategy={0:f_count, 1:t_count})
X_train_rus, y_train_rus = rus.fit_sample(X_train, y_train)

Maintenant que nous avons corrigé certains des déséquilibres de données, nous allons entraîner et évaluer à nouveau le modèle.

build.ipynb

#Apprentissage
clf.fit(X_train_rus, y_train_rus)

#Prévoir
y_pred = clf.predict(X_test)

#Afficher le taux de réponse correct
print(accuracy_score(y_test, y_pred))
0.7767958950969214

#Afficher la matrice de confusion
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[ 1111  9259]
 [ 1703 37039]]

#Afficher la valeur F
print(f1_score(y_test, y_pred))
0.1685376213592233

La valeur F est "0,1685376213592233", ce qui est une amélioration considérable.

Standardiser les variables explicatives

Il y a deux variables explicatives, le prix principal et le nom du cavalier, mais le nom du cavalier a une valeur de 0 ou 1 en raison de la conversion de variable fictive, tandis que le prix principal a la distribution suivante des caractéristiques.

build.ipynb

import matplotlib.pyplot as plt
plt.xlabel('prize')
plt.ylabel('freq')
plt.hist(dataX['Ce prix'], range=(0, 20000), bins=20)

Étant donné que les valeurs sont trop différentes, il est fort probable que le prix et le nom du cavalier ne puissent pas être comparés sur un pied d'égalité, et il est nécessaire de redimensionner chaque élément sur la même plage. L'une des méthodes est la normalisation.

build.ipynb

from sklearn.preprocessing import StandardScaler

#Standardiser les variables explicatives
sc = StandardScaler()
X_train_rus_std = pd.DataFrame(sc.fit_transform(X_train_rus), columns=X_train_rus.columns)
X_test_std = pd.DataFrame(sc.transform(X_test), columns=X_test.columns)

En normalisant, les valeurs de toutes les variables explicatives ont été converties afin qu'elles tombent dans une certaine plage, de sorte que le modèle est formé et évalué à nouveau.

build.ipynb

#Apprentissage
clf.fit(X_train_rus_std, y_train_rus)

#Prévoir
y_pred = clf.predict(X_test_std)

#Afficher le taux de réponse correct
print(accuracy_score(y_test, y_pred))
0.7777732529727969

#Afficher la matrice de confusion
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[ 2510  7860]
 [ 3054 35688]]

#Afficher la valeur F
print(f1_score(y_test, y_pred))
0.3150495795155014

La valeur F est devenue "0,3150495795155014", et la précision a été encore améliorée par rapport au temps précédent, et elle a atteint le niveau de 30%. De plus, le taux de précision est de 0,45 et le taux de rappel est de 0,24, donc je pense que le résultat de la prédiction des courses de chevaux est raisonnable.

Vérifiez le poids du coefficient de régression

Enfin, vérifiez le coefficient de régression pour voir quelle valeur de la variable explicative a une forte influence sur la prédiction des courses de chevaux.

build.ipynb

pd.options.display.max_rows = X_train_rus_std.columns.size
print(pd.Series(clf.coef_[0], index=X_train_rus_std.columns).sort_values())

Nom du cavalier_Principe inférieur-0.092015
Nom du cavalier_Seiji Sakai-0.088886
Nom du cavalier_Teruo Eda-0.081689
Nom du cavalier_Hayashi Mitsuya-0.078886
Nom du cavalier_Satoshi Yamamoto-0.075083
Nom du cavalier_Mikamimoto Kun-0.073361
Nom du cavalier_Keita Ban-0.072113
Nom du cavalier_Junji Iwabe-0.070202
Nom du cavalier_Samouraï Sawa Tomo-0.069766
Nom du cavalier_Mitsuyuki Miyazaki-0.068009
...(réduction)
Nom du cavalier_Yasumasa Iwata 0.065899
Nom du cavalier_Hironobu Tanabe 0.072882
Nom du cavalier_Moreira 0.073010
Nom du cavalier_Taketoyo 0.084130
Nom du cavalier_Yuichi Fukunaga 0.107660
Nom du cavalier_Masamasa Kawada 0.123749
Nom du cavalier_Keita Tosaki 0.127755
Nom du cavalier_M. Dém 0.129514
Nom du cavalier_Lemer 0.185976
Prix final 0.443854

Vous pouvez voir que le prix a l'influence la plus positive, qui devrait être à la troisième place, suivi des grands cavaliers qui forment le sommet de l'influence.

5. Fonctionnement du modèle

Avec le travail jusqu'à présent, nous avons réussi à construire le modèle. Ensuite, considérons l'opération réelle. Des courses de chevaux ont lieu régulièrement chaque semaine, mais j'espère devenir riche en prédisant quels chevaux seront parmi les trois premiers de chaque course.

Donc, chaque semaine, exécutez-vous le flux de travail d'apprentissage automatique dans l'ordre depuis le début? [1. Acquisition de données](https://qiita.com/drafts#1-%E3%83%87%E3%83%BC%E3%82%BF%E3%81%AE%E5%8F%96 % E5% BE% 97) doit être effectué à chaque fois pour obtenir les dernières données de la table d'exécution, mais 2. Prétraitement des données 83% 87% E3% 83% BC% E3% 82% BF% E3% 81% AE% E5% 89% 8D% E5% 87% A6% E7% 90% 86) et 3. Apprentissage du modèle //qiita.com/drafts#3-%E3%83%A2%E3%83%87%E3%83%AB%E3%81%AE%E5%AD%A6%E7%BF%92) à chaque fois Au lieu de le faire, vous devriez pouvoir réutiliser le modèle que vous avez créé une fois (bien que des mises à jour régulières du modèle soient nécessaires). Alors faisons cette opération.

build.ipynb

import pickle

filename = 'model_sample.pickle'
pickle.dump(clf, open(filename, 'wb'))

De cette façon, en utilisant une bibliothèque appelée pickle, vous pouvez sérialiser le modèle construit et l'enregistrer dans un fichier.

Et voici comment restaurer le modèle enregistré.

restore.ipynb

import pickle

filename = 'model_sample.pickle'
clf = pickle.load(open(filename, 'rb'))

#Prévoir
y_pred = clf.predict(Données variables explicatives pour la race à prédire)

Vous pouvez facilement restaurer le modèle et l'utiliser pour prédire les courses futures. Cela permet un fonctionnement efficace sans avoir besoin de prétraitement des données ou de formation de modèle.

à la fin

Avec ce qui précède, nous avons pu effectuer une série de travaux étape par étape, de la construction de l'environnement à la construction du modèle. Ce sera une mauvaise explication par les débutants, mais j'espère que cela sera utile pour les personnes dans des circonstances similaires.

La prochaine fois, j'aimerais utiliser un autre algorithme pour contester non seulement la vérification de la comparaison et la précision de la prédiction avec le modèle réalisé cette fois-ci, mais aussi la création d'un mécanisme qui va encore plus loin en ce qui concerne le solde réel.