Einführung

Dieser Artikel ist eine interne Code-Erklärung der dreifachen Vorhersage-Website für Bootsrennen "Haben Sie heute eine gute Vorhersage?", die von mir erstellt und im Web veröffentlicht wurde. Es wird sein. Dieses Mal werde ich das Modell des maschinellen Lernens zusammenfassen. Zunächst werde ich einen separaten Artikel zur Datenerfassung und -formatierung erstellen. Bitte beziehen Sie sich darauf.

Erstellen Sie einen Datenrahmen aus den erfassten Textdaten des Bootsrennens

Der Code ist auf meine eigene Weise geschrieben, daher würde ich mich freuen, wenn Sie mir einen Rat geben könnten.

Was ist Ranking-Lernen?

Ich habe sehr viel auf die folgenden Artikel verwiesen, als ich sie verwenden konnte.

・ Horse Racing Prediction AI Again -Part 1- ~ Lambda Rank ~

Das Ranking-Lernen soll eine Methode zum Lernen relativer Ordnungsbeziehungen sein. Wie der obige Link dachte ich, dass es geeignet wäre, die relative Stärke mehrerer Personen (Pferde) wie Pferderennen und Bootsrennen zu lernen.

Das Papier wird noch gelesen (lacht), aber ich werde es zuerst versuchen. Die verwendete Bibliothek ist lightgbm.

Bereiten Sie das Abfrage-Dataset vor

Dieses Mal werden die Trainingsdaten von Januar bis April 2020 sein, und die Verifizierungsdaten werden die Daten von Mai 2020 sein.

Eines der Merkmale des Ranking-Lernens sind "Abfragedaten". Diese Abfragedaten geben die Anzahl der Trainingsdaten an, die in einem Rennen enthalten sind. Wenn es beim Bootsrennen keine Probleme gibt, wird das Rennen mit 6 Booten ausgetragen

Abfrage-Datenfeld = [6,6,6, ..., 6]

Sie sollten eine Liste mit "6" für die Anzahl der Rennen haben (wenn keine Abwesenden vorhanden sind).

Daher erstellen wir ein Abfragedatenfeld mit dem folgenden Code.

%%time #Messzeit
target_cols = ["Position"]
feature_cols = ["Name","Lane","Round","Month","Place"]

train = pd.read_csv(train_file)
train_shuffle = pd.DataFrame([],columns=train.columns)

train_group =[]
for i,k in enumerate(train["Round"]):
    if i == 0:
        temp = k
        temp2 = i
        
    else:
        if k == temp:
            pass
        else:
            train_group.append(i-temp2)
            #↓ .Machen Sie die Daten mit Probe gemischt.
            train_shuffle=train_shuffle.append(train[temp2:i].sample(frac=1))
            temp = k
            temp2 = i

#Hinzugefügt, da das letzte Paar nicht enthalten ist
train_group.append(i+1-temp2)
train_shuffle=train_shuffle.append(train[temp2:i+1].sample(frac=1))

train_y = train_shuffle[target_cols].astype(int)
train = train_shuffle[feature_cols]
print(train.shape)

Die von read_csv gelesene Zugdatei basiert auf dem Artikel Erstellen eines Datenrahmens aus den erfassten Textdaten des Bootsrennens.

Die Nummer desselben Rennens (Runde) wird gezählt und in der Liste von train_group gespeichert. Und als ich den Referenzartikel las, war es ** gefährlich, wenn ich die Reihenfolge in dieser Gruppe nicht mischte **. Wenn Sie sie also in train_shuffle speichern, mischen Sie die Verarbeitung mit .sample tun.

Wenden Sie den obigen Code auf das Validierungsdatensatz an, um ein Validierungsabfragedatensatz zu erstellen.

Verwenden Sie LightGBM

Ich werde fehlende Verarbeitung, Feature-Engineering, One-Hot-Codierung usw. weglassen, aber wenn der Trainingsdatensatz und der Abfragedatensatz bereit sind, ist es in der heutigen Welt einfach, maschinelles Lernen auszuführen. Der einzige Punkt ist, dass es sich um eine LightGBM-Spezifikation handelt und ein Fehler auftritt, wenn sich Japanisch in der Spalte befindet. Daher wurde die folgende Verarbeitung hinzugefügt.

column_list = []
for i in range(len(comb_onehot.columns)):
    column_list.append(str(i)+'_column')

comb_onehot.columns = column_list

Der DataFrame-Typ comb_onehot ist ein Datenrahmen, der erstellt wird, wenn das Train-Dataset und das Valid-Dataset kombiniert und für die One-Hot-Codierung verarbeitet werden. Nach diesem Prozess

train_onehot = comb_onehot[:len(train)]
val_onehot = comb_onehot[len(train):]

Zum Lernen und Verifizieren neu getrennt. Lassen Sie uns nun maschinelles Lernen durchführen.

import lightgbm as lgb

lgbm_params =  {
    'task': 'train',
    'boosting_type': 'gbdt',
    'objective': 'lambdarank', #← Hier als Ranking-Lernen bezeichnet!
    'metric': 'ndcg',   # for lambdarank
    'ndcg_eval_at': [1,2,3],  #Ich möchte Dreifache vorhersagen
    'max_position': 6,  #Das Bootsrennen ist nur bis zum 6. Platz
    'learning_rate': 0.01, 
    'min_data': 1,
    'min_data_in_bin': 1,
#     'num_leaves': 31,
#     'min_data_in_leaf': 20,
#     'max_depth':35,
}
lgtrain = lgb.Dataset(train_onehot, train_y,  group=train_group)
lgvalid = lgb.Dataset(val_onehot, val_y,group=val_group)
lgb_clf = lgb.train(
    lgbm_params,
    lgtrain,
    num_boost_round=250,
    valid_sets=[lgtrain, lgvalid],
    valid_names=['train','valid'],
    early_stopping_rounds=20,
    verbose_eval=5
)

Hyperparameter wie num_leaves sollten angepasst werden, aber lassen Sie uns hier fortfahren, ohne darüber nachzudenken. Die Vorhersage für die Verifizierungsdaten sieht folgendermaßen aus. Es ist eine sehr günstige Zeit ...

y_pred = lgb_clf.predict(val_onehot,group=val_group, num_iteration=lgb_clf.best_iteration)

Ergebnis ist ...

Die Triadenvorhersage durch Rangfolge des Lernens ist wie folgt. Triple Single ist 8,15% .. !!

Übrigens habe ich den folgenden Code geschrieben, um die oben genannte Trefferquote (insbesondere 2. und 3.) zu erhalten. Hmmm, überflüssig!

#Berechnung der gültigen Datenerfolgsrate
j = 0
solo_count = 0
doub_count = 0
tri_count = 0
for i in val_group:
    result = y_pred[j:j+i]
    ans = val_y[j:j+i].reset_index()
    
    result1st = np.argmin(result)
    if len(np.where(result==sorted(result)[1])[0])>1:
        result2nd = np.where(result==sorted(result)[1])[0][0]
        result3rd = np.where(result==sorted(result)[1])[0][1]
    else:
        if i > 1:
            result2nd = np.where(result==sorted(result)[1])[0][0]
        if i > 2:
            result3rd = np.where(result==sorted(result)[2])[0][0]
    
    ans1st = int(ans[ans["Position"]==1].index.values)
    if len(ans[ans["Position"]==2].index.values)>1:
        ans2nd = int(ans[ans["Position"]==2].index.values[0])
        ans3rd = int(ans[ans["Position"]==2].index.values[1])
    else:
        if i > 1:
            ans2nd = int(ans[ans["Position"]==2].index.values[0])
        if i > 2:
            ans3rd = int(ans[ans["Position"]==3].index.values[0])
    
    if ans1st==result1st:
        #print(ans1st,result1st)
        solo_count = solo_count+1
    
    if i > 1:
        if (ans1st==result1st)&(ans2nd==result2nd):
            doub_count = doub_count+1
    
    if i > 2:
        if (ans1st==result1st)&(ans2nd==result2nd)&(ans3rd==result3rd):
            tri_count = tri_count+1 
    j=j+i

print("Gewinnrate:",round(solo_count/len(val_group)*100,2),"%")
print("Doppelter einzelner Vorhersagewert:",round(doub_count/len(val_group)*100,2),"%")
print("Dreifacher einzelner Vorhersagewert:",round(tri_count/len(val_group)*100,2),"%")

schließlich

Das obige Ergebnis ist eine höhere Trefferquote als das Kaufen ohne nachzudenken. (Die am häufigsten vorkommende Triplettkombination ist "1-2-3" und die Häufigkeit beträgt etwa 7%.)

Dieses Ergebnis allein ist jedoch als Trefferquote nicht akzeptabel, sodass ich der Meinung war, dass ein anderes Gerät benötigt wird. Ich möchte das in einem anderen Artikel zusammenfassen.