Ein Anfänger des maschinellen Lernens versuchte, mit Python ein Vorhersagemodell für Pferderennen zu erstellen

In letzter Zeit hat die Anzahl der Serviceentwicklungen, die maschinelles Lernen beinhalten, zugenommen, und ich selbst leite sie manchmal.

Es ist jedoch nicht zu leugnen, dass es eine einfache Aufgabe ist, das Lernmodell, das von Datenwissenschaftlern und ML-Ingenieuren erstellt wurde, blind zu verwenden, und es ist für Anfänger (I) einfach, ihren Wissensstand über maschinelles Lernen zu verbessern. Ich habe versucht, den Prozess zusammenzufassen, bis ich ein Lernmodell erstellen konnte.

Dieses Ziel

Wir werden zunächst eine Umgebung mit Python erstellen und dann versuchen, ein Klassifizierungsmodell durch logistische Regression zu erstellen, was am schnellsten zu sein scheint. Was das Thema betrifft, werde ich das Vorhersagemodell für Pferderennen sowohl für Hobby als auch für Profit herausfordern.

• Obwohl wir die technischen Begriffe des Pferderennens verwenden, würden wir uns freuen, wenn Sie unklare Punkte untersuchen könnten.

Umgebung

Annahme

Die implementierte Umgebung ist wie folgt.

• Python：3.7.7
• pip：20.2.2

pipenv Installation

Ich werde die Ausführungsumgebung von Python mit pipenv erstellen.

$ pip install pipenv

Erstellen Sie eine virtuelle Umgebung, um Python auszuführen.

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

PIPENV_VENV_IN_PROJECT ist eine Einstellung zum Erstellen einer virtuellen Umgebung unter dem Projektverzeichnis (./.venv/).

Bibliotheksinstallation

Hier installieren wir die minimal erforderlichen Bibliotheken.

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

Nach der Installation wurden Pipfile und Pipfile.lock im aktuellen Verzeichnis aktualisiert. Diese 4 Bibliotheken sind wichtige Elemente. Installieren Sie sie also, ohne etwas zu sagen.

So starten Sie das Jupiter-Notebook

$ 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

Durch Zugriff auf die Localhost-URL-Ausgabe des Terminals können Sie das Jupyter-Notizbuch auf Ihrem lokalen Server durchsuchen.

Damit ist der Umgebungsaufbau abgeschlossen.

Modellbau

Es gibt verschiedene Arten des maschinellen Lernens, wie z. B. überwachtes Lernen, unbeaufsichtigtes Lernen, erweitertes Lernen und tiefes Lernen. Diesmal jedoch, wie eingangs erwähnt, um ein einfaches Lernmodell erstellen zu können. Erstellen Sie ein Klassifizierungsmodell für überwachtes Lernen.

Workflow für maschinelles Lernen

Der AWS-Artikel war leicht zu verstehen, daher sollten Sie hier darauf verweisen. Was ist der Workflow für maschinelles Lernen? Erläutern der AWS-Dienste für maschinelles Lernen in Grareco Ich denke, dass der obige Ablauf kurz zusammengefasst wird, daher werden wir das Lernmodell in dieser Reihenfolge erstellen.

1. Datenerfassung

Wenn wir ein Vorhersagemodell für Pferderennen erstellen, benötigen wir zunächst frühere Pferderenndaten. Es gibt auch Informationen darüber, wie man Informationsseiten zu Pferderennen im Internet abkratzt. Im Vorgriff auf zukünftige Operationen werden wir jedoch offizielle JRA-Daten erwerben und erhalten. Erfasste Daten: JRA-VAN Data Lab

Sie können ein Programm erstellen, um die Daten selbst abzurufen, aber Sie können die Daten auch mit der im Voraus bereitgestellten kostenlosen Pferderennsoftware in eine Datei ausgeben. (Da es nicht die Hauptgeschichte ist, werde ich die Details weglassen.)

Dieses Mal habe ich die folgenden zwei Arten von Datendateien erhalten. Der Zielzeitraum der Daten beträgt 5 Jahre von 2015 bis 2019.

2. Datenvorverarbeitung

Was ist Datenvorverarbeitung?

Hier ist der wichtigste Schritt beim maschinellen Lernen. Führen Sie die folgende Verarbeitung gemäß den erfassten Daten durch.

Datenbereinigung

Sie können Rauschdaten entfernen oder fehlende Werte mit unterschiedlichen Werten füllen.

Datenintegration

Es ist selten, dass die für das Training erforderlichen Daten von Anfang an gesammelt werden und durch die Integration der verteilten Daten konsistente Daten generiert werden.

Datenkonvertierung

Der Prozess der Konvertierung von Daten in ein bestimmtes Format, um die Qualität des Modells zu verbessern. Beispiel: Verarbeiten verschiedener Daten, z. B. Standardisieren numerischer Daten in Daten, die in den Bereich von -1 bis 1 passen, oder Konvertieren von Kategoriedaten, bei denen entweder Hund oder Katze ausgewählt sind, in Dummy-Variablen und Konvertieren in numerische Werte. Wird hinausgetragen werden.

Vorverarbeitung von Pferderenndaten

Von hier aus werden wir die Vorverarbeitung von Pferderenndaten tatsächlich implementieren. Wenn Sie jedoch das gestartete Jupyter-Notizbuch verwenden, können Sie programmieren, während Sie den Datenstatus interaktiv überprüfen.

Laden Sie zuerst die erfassten Pferderenndaten in den DataFrame von Pandas, aber als Ergebnis der Vorverarbeitung der Daten werde ich die Daten schließlich in die folgende Struktur verarbeiten.

Dieses Mal verwenden wir die Gesamtmenge der Preise, die jedes Pferd bisher gewonnen hat, als Feature-Betrag, um die Fähigkeit der laufenden Pferde zu messen. Wir haben auch den Namen des Jockeys übernommen, da es je nach Können des Jokers einen großen Unterschied gibt. Lassen Sie uns versuchen, wie viel Vorhersagegenauigkeit nur mit diesen beiden erklärenden Variablen erreicht werden kann.

build.ipynb

import os
import pandas as pd

#Renntabellendaten
syutsuba_path = './data/sample/syutsuba_data.csv'
df_syutsuba = pd.read_csv(syutsuba_path, encoding='shift-jis')
df_syutsuba = df_syutsuba[['Race ID', 'Dieser Preis', 'Name des Reiters']]

#Notendaten
seiseki_path = './data/sample/seiseki_data.csv'
df_seiseki = pd.read_csv(seiseki_path, encoding='shift-jis')
df_seiseki = df_seiseki[['Race ID', 'Bestätigte Reihenfolge der Ankunft']]

In DataFrame sind die Daten wie folgt organisiert.

Referenz) Race ID-Datenformat

Als Nächstes werden wir die erfassten Daten integrieren und eine Datenbereinigung und -konvertierung durchführen.

build.ipynb

#Führen Sie die Daten der Renntabelle und der Klasse zusammen
df = pd.merge(df_syutsuba, df_seiseki, on = 'Race ID')

#Entfernen Sie Datensätze mit fehlenden Werten
df.dropna(how='any', inplace=True)

#Fügen Sie eine Spalte hinzu, um festzustellen, ob die Reihenfolge der Ankunft innerhalb von 3 liegt
f_ranking = lambda x: 1 if x in [1, 2, 3] else 0
df['Innerhalb von 3'] = df['Bestätigte Reihenfolge der Ankunft'].map(f_ranking)

#Dummy-Variable generieren
df = pd.get_dummies(df, columns=['Name des Reiters'])

#Index festlegen (bis zum 16. Byte nur Rasse angeben)
df['race_index'] = df['Race ID'].astype(str).str[0:16]
df.set_index('race_index', inplace=True)

#Löschen Sie nicht benötigte Spalten
df.drop(['Race ID', 'Bestätigte Reihenfolge der Ankunft'], axis=1, inplace=True)

Wenn Sie den DataFrame überprüfen, können Sie sehen, dass die Spalten, die zu Dummy-Variablen gemacht wurden, durch neue Spalten für die Anzahl der dazugehörigen Kategorien ersetzt werden und das Flag 0 oder 1 gesetzt ist. Wenn Sie den Namen des Reiters zu einer Dummy-Variablen machen, hat sich die Anzahl der Spalten auf 295 erhöht. Beachten Sie jedoch, dass das Erstellen einer Spalte mit einer großen Anzahl von Kategorien zu einer Dummy-Variablen zu Überlernen führen kann.

3. Modelllernen

Als nächstes lernen wir das Modell. Zunächst werden die Daten für jede erklärende Variable und objektive Variable in Trainingsdaten und Bewertungsdaten unterteilt.

build.ipynb

from sklearn.model_selection import train_test_split

#Speichern Sie erklärende Variablen in dataX
dataX = df.drop(['Innerhalb von 3'], axis=1)

#Speichern Sie die Zielvariable in dataY
dataY = df['Innerhalb von 3']

#Teilen Sie die Daten (Lerndaten 0.8 Bewertungsdaten 0.2）
X_train, X_test, y_train, y_test = train_test_split(dataX, dataY, test_size=0.2, stratify=dataY)

Kurz gesagt, es ist in die folgenden vier Datentypen unterteilt.

Dieses Mal wird train_test_split verwendet, um die Trainingsdaten und die Bewertungsdaten einfach zu teilen, jedoch für Daten mit dem Konzept von Zeitreihen wie Pferderennen, ** (Vergangenheit) -> Trainingsdaten-> Es scheint, dass die Genauigkeit verbessert wird, wenn die Daten so aufgeteilt werden, dass die Reihenfolge Bewertungsdaten-> (aktuell) ** ist.

Als nächstes werden wir die vorbereiteten Daten trainieren. Der grundlegende Algorithmus ist in sklearn enthalten, und dieses Mal werden wir ** logistische Regression ** verwenden.

build.ipynb

from sklearn.linear_model import LogisticRegression

#Klassifikator erstellen (logistische Regression)
clf = LogisticRegression()

#Lernen
clf.fit(X_train, y_train)

Das ist es. Es ist sehr leicht.

4. Modellbewertung

Lassen Sie uns zunächst die Bewertungsdaten vorhersagen und anhand des Ergebnisses die richtige Antwortrate überprüfen.

build.ipynb

#Prognose
y_pred = clf.predict(X_test)

#Richtige Antwortrate anzeigen
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, y_pred))
0.7874043003746538

Die richtige Antwortrate ist "0,7874043003746538", was bedeutet, dass 78% korrekt vorhergesagt werden können. Auf den ersten Blick könnten Sie glücklich sein zu sagen: "Oh, großartig! Es ist wirklich profitabel!", Aber seien Sie vorsichtig mit dieser Genauigkeit. Versuchen Sie dann, den folgenden Code auszuführen.

build.ipynb

#Verwirrungsmatrix anzeigen
from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[  339 10031]
 [  410 38332]]

Dieses zweidimensionale Array wird als Verwirrungsmatrix bezeichnet, repräsentiert jedoch Folgendes.

Von diesen ist die korrekte Antwortrate die Summe aus ** Vorhersage: 3. Platz oder weniger x Ist: 3. Platz oder weniger ** und ** Vorhersage: 4. Platz oder weniger x Tatsächlich: 4. Platz oder weniger **.

** Richtige Antwortrate **: 0,78 = (339 + 38332) / (339 + 38332 + 410 + 10031)

Aus diesem Ergebnis ist ersichtlich, dass die Anzahl der Fälle, von denen vorhergesagt wird, dass sie innerhalb des 3. Platzes liegen, an erster Stelle zu gering ist, und die korrekte Antwortrate wird durch die Vorhersage erhöht, dass die meisten von ihnen den 4. Platz oder weniger belegen.

Nachdem Sie nun wissen, dass Sie mit der Genauigkeitsrate vorsichtig sein müssen, was sollte zur Bewertung der Genauigkeit des Modells verwendet werden? Eine Möglichkeit, diese Verwirrungsmatrix zu verwenden, besteht darin, den F-Wert zu überprüfen.

Was ist der F-Wert?

Es ist eine Kombination von 1 und 2 unten.

1. Prozentsatz der Läufer, die voraussichtlich auf dem 3. Platz liegen (Präzisionsrate genannt)
2. Der Prozentsatz der Pferde, die tatsächlich den 3. Platz belegt haben und richtig geantwortet haben (sogenannte Rückrufquote)

** Konformitätsrate **: 0,45 = 339 / (339 + 410) ** Rückruf **: 0,03 = 339 / (339 + 10031)

build.ipynb

#F-Wert anzeigen
from sklearn.metrics import f1_score
print(f1_score(y_test, y_pred))
0.06097670653835776

Als ich diesmal den F-Wert überprüfte, war er "0.06097670653835776". In Bezug auf den F-Wert hat er im Fall einer zufälligen Aufteilung in 0 und 1 die Eigenschaft, gegen 0,5 zu konvergieren, sodass Sie sehen können, dass der Wert von 0,06 diesmal ein extrem niedriger Wert ist.

Korrigieren Sie das Datenungleichgewicht

build.ipynb

print(df['Innerhalb von 3'].value_counts())
0    193711
1     51848

Das Verhältnis der Zielvariablen innerhalb des 3. und 4. Platzes oder weniger beträgt 1: 4, und die Daten weisen eine leichte Verzerrung auf. Korrigieren wir dies also ein wenig.

Installieren Sie zunächst die folgenden zusätzlichen Bibliotheken.

$ pipenv install imbalanced-learn

Untersuchen Sie das Datenverhältnis der Trainingsdaten innerhalb des 3. und 4. Platzes oder weniger auf 1: 2. Unterabtastung bedeutet, die Anzahl der großen Datenmengen zufällig einzugrenzen, um sie an die kleine Anzahl von Daten anzupassen.

build.ipynb

from imblearn.under_sampling import RandomUnderSampler

#Trainingsdaten unterabtasten
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)

Nachdem wir einige Datenungleichgewichte korrigiert haben, werden wir das Modell erneut trainieren und bewerten.

build.ipynb

#Lernen
clf.fit(X_train_rus, y_train_rus)

#Prognose
y_pred = clf.predict(X_test)

#Richtige Antwortrate anzeigen
print(accuracy_score(y_test, y_pred))
0.7767958950969214

#Verwirrungsmatrix anzeigen
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[ 1111  9259]
 [ 1703 37039]]

#F-Wert anzeigen
print(f1_score(y_test, y_pred))
0.1685376213592233

Der F-Wert beträgt "0,1685376213592233", was eine erhebliche Verbesserung darstellt.

Erklären Sie erklärende Variablen

Es gibt zwei erklärende Variablen, den Hauptpreis und den Namen des Reiters, aber der Name des Reiters hat aufgrund der Dummy-Variablenkonvertierung den Wert 0 oder 1, während der Hauptpreis die folgende Verteilung von Merkmalen aufweist.

build.ipynb

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

Da die Werte zu unterschiedlich sind, ist es sehr wahrscheinlich, dass der Preis und der Name des Reiters nicht gleichberechtigt verglichen werden können, und es ist erforderlich, jedes Merkmal auf den gleichen Bereich zu skalieren. Eine der Methoden ist die Standardisierung.

build.ipynb

from sklearn.preprocessing import StandardScaler

#Erklären Sie erklärende Variablen
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)

Durch die Standardisierung wurden die Werte aller erklärenden Variablen so konvertiert, dass sie in einen bestimmten Bereich fallen, sodass das Modell erneut trainiert und bewertet wird.

build.ipynb

#Lernen
clf.fit(X_train_rus_std, y_train_rus)

#Prognose
y_pred = clf.predict(X_test_std)

#Richtige Antwortrate anzeigen
print(accuracy_score(y_test, y_pred))
0.7777732529727969

#Verwirrungsmatrix anzeigen
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[ 2510  7860]
 [ 3054 35688]]

#F-Wert anzeigen
print(f1_score(y_test, y_pred))
0.3150495795155014

Der F-Wert wurde zu "0,3150495795155014", und die Genauigkeit wurde gegenüber dem vorherigen Zeitpunkt weiter verbessert und erreichte das 30% -Niveau. Darüber hinaus beträgt die Präzisionsrate 0,45 und die Rückrufrate 0,24, sodass ich das Vorhersageergebnis von Pferderennen für angemessen halte.

Überprüfen Sie das Gewicht des Regressionskoeffizienten

Überprüfen Sie abschließend den Regressionskoeffizienten, um festzustellen, welcher Wert der erklärenden Variablen einen starken Einfluss auf die Vorhersage des Pferderennsports hat.

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())

Name des Reiters_Unteres Prinzip-0.092015
Name des Reiters_Seiji Sakai-0.088886
Name des Reiters_Teruo Eda-0.081689
Name des Reiters_Hayashi Mitsuya-0.078886
Name des Reiters_Satoshi Yamamoto-0.075083
Name des Reiters_Mikamimoto Kun-0.073361
Name des Reiters_Keita Ban-0.072113
Name des Reiters_Junji Iwabe-0.070202
Name des Reiters_Samurai Sawa Tomo-0.069766
Name des Reiters_Mitsuyuki Miyazaki-0.068009
...(Kürzung)
Name des Reiters_Yasumasa Iwata 0.065899
Name des Reiters_Hironobu Tanabe 0.072882
Name des Reiters_Moreira 0.073010
Name des Reiters_Taketoyo 0.084130
Name des Reiters_Yuichi Fukunaga 0.107660
Name des Reiters_Masamasa Kawada 0.123749
Name des Reiters_Keita Tosaki 0.127755
Name des Reiters_M. Dem 0.129514
Name des Reiters_Lemer 0.185976
Endpreis 0.443854

Sie können sehen, dass dieser Preis den positivsten Einfluss hat, der voraussichtlich auf dem dritten Platz liegt, gefolgt von den großen Jockeys, die die Spitze des Einflusses bilden.

5. Modellbetrieb

Mit der bisherigen Arbeit ist es uns gelungen, das Modell zu erstellen. Als nächstes betrachten wir die eigentliche Operation. Pferderennen finden regelmäßig jede Woche statt, aber ich möchte vorhersagen, welche Pferde in den Top 3 jedes Rennens stehen und hoffentlich reich werden.

Führen Sie den Workflow für maschinelles Lernen jede Woche von Anfang an in der richtigen Reihenfolge aus? [1. Datenerfassung](https://qiita.com/drafts#1-%E3%83%87%E3%83%BC%E3%82%BF%E3%81%AE%E5%8F%96 % E5% BE% 97) muss jedes Mal ausgeführt werden, um die neuesten Renntabellendaten zu erhalten, aber 2. Datenvorverarbeitung 83% 87% E3% 83% BC% E3% 82% BF% E3% 81% AE% E5% 89% 8D% E5% 87% A6% E7% 90% 86) und 3. Model Learning //qiita.com/drafts#3-%E3%83%A2%E3%83%87%E3%83%AB%E3%81%AE%E5%AD%A6%E7%BF%92) jedes Mal Stattdessen sollten Sie das einmal erstellte Modell wiederverwenden können (obwohl regelmäßige Modellaktualisierungen erforderlich sind). Führen wir diese Operation aus.

build.ipynb

import pickle

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

Auf diese Weise können Sie mithilfe einer Bibliothek namens pickle das erstellte Modell serialisieren und in einer Datei speichern.

Und so stellen Sie das gespeicherte Modell wieder her.

restore.ipynb

import pickle

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

#Prognose
y_pred = clf.predict(Erklärende Variablendaten für das vorherzusagende Rennen)

Sie können das Modell einfach wiederherstellen und damit zukünftige Rennen vorhersagen. Dies ermöglicht einen effizienten Betrieb ohne Datenvorverarbeitung oder Modelltraining.

schließlich

Mit dem oben Gesagten konnten wir eine Reihe von Arbeiten Schritt für Schritt vom Umgebungsbau bis zum Modellbau durchführen. Es wird eine schlechte Erklärung für Anfänger sein, aber ich hoffe, es wird für Menschen mit ähnlichen Umständen hilfreich sein.

Das nächste Mal möchte ich einen anderen Algorithmus verwenden, um zu versuchen, einen Mechanismus zu erstellen, der einen Schritt weiter geht, nicht nur im Vergleich und in der Überprüfung mit dem diesmal erstellten Modell und der Vorhersagegenauigkeit, sondern auch in Bezug auf das tatsächliche Gleichgewicht.