introduction

Cet article est une explication du code interne du site de triple prédiction de course de bateaux "Aujourd'hui, avez-vous une bonne prédiction?" qui a été créé par moi-même et publié sur le Web. Ce sera. Cette fois, je vais résumer le modèle d'apprentissage automatique. En premier lieu, je vais créer un article séparé sur l'acquisition et le formatage des données, veuillez donc vous y référer.

・ Créez un cadre de données à partir des données textuelles acquises sur la course de bateaux

Le code est écrit à ma manière, donc j'apprécierais que vous me donniez quelques conseils.

Qu'est-ce que l'apprentissage du classement?

J'ai beaucoup fait référence aux articles suivants lorsque j'ai pu l'utiliser.

・ Prédiction de courses de chevaux AI à nouveau -Partie 1- ~ Classement Lambda ~

On dit que l'apprentissage du classement est une méthode d'apprentissage des relations d'ordre relatif. Comme le lien ci-dessus, j'ai pensé qu'il conviendrait pour apprendre la force relative de plusieurs personnes (chevaux) comme les courses de chevaux et les courses de bateaux.

Le journal est toujours en cours de lecture (rires), mais je vais essayer de l'utiliser d'abord. La bibliothèque utilisée est lightgbm.

Préparer le jeu de données de requête

Cette fois, les données de formation seront de janvier à avril 2020, et les données de vérification seront les données de mai 2020.

L'une des fonctionnalités de l'apprentissage du classement est la "requête de données". Ces données de requête représentent le nombre de données d'entraînement contenues dans une course. Dans le cas d'une course de bateaux, s'il n'y a pas de problème, la course se déroulera avec 6 bateaux, donc

Boîte de données de requête = [6,6,6, ..., 6]

Vous devriez avoir une liste de "6" pour le nombre de courses (s'il n'y a pas d'absent).

Nous allons donc créer une boîte de données de requête avec le code suivant.

%%time #Mesurer le temps
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)
            #↓ .Rendez les données mélangées avec l'échantillon.
            train_shuffle=train_shuffle.append(train[temp2:i].sample(frac=1))
            temp = k
            temp2 = i

#Ajouté car la dernière paire n'est pas incluse
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)

Le fichier de train lu par read_csv est basé sur l'article Créer une trame de données à partir des données textuelles acquises sur la course de bateaux.

Le nombre des mêmes tours est compté et stocké dans la liste de train_group. Et quand j'ai lu l'article de référence, c'était ** qu'il serait dangereux de ne pas mélanger l'ordre dans ce groupe, **, donc lorsque vous le stockez dans train_shuffle, mélangez le traitement avec .sample Faire.

Appliquez le code ci-dessus à l'ensemble de données de validation pour créer un ensemble de données de requête de validation.

Utilisez LightGBM

J'omettrai le traitement manquant, l'ingénierie des fonctionnalités, le codage à chaud, etc., mais si l'ensemble de données d'entraînement et l'ensemble de données de requête sont prêts, il est facile d'exécuter l'apprentissage automatique dans le monde actuel. Le seul point est qu'il s'agit d'une spécification lightgbm, et une erreur se produira si le japonais est dans la colonne. Par conséquent, le traitement suivant a été ajouté.

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

comb_onehot.columns = column_list

Le type DataFrame appelé comb_onehot est une trame de données créée lorsque le jeu de données Train et le jeu de données valide sont combinés et que l'encodage One-hot est traité. Après ce processus

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

Re-séparé pour l'apprentissage et la vérification. Maintenant, effectuons l'apprentissage automatique.

import lightgbm as lgb

lgbm_params =  {
    'task': 'train',
    'boosting_type': 'gbdt',
    'objective': 'lambdarank', #← Désigné comme apprentissage de classement ici!
    'metric': 'ndcg',   # for lambdarank
    'ndcg_eval_at': [1,2,3],  #Je veux prédire les triplets
    'max_position': 6,  #La course de bateaux n'est qu'à la 6ème place
    '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
)

Les hyper paramètres tels que num_leaves doivent être ajustés, mais procédons sans réfléchir ici. La prédiction des données de vérification ressemble à ceci. C'est un moment vraiment opportun ...

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

Le résultat est ...

La prédiction de la triade en classant l'apprentissage est la suivante. Le triple simple est de 8,15% .. !!

Au fait, afin d'obtenir le taux de réussite ci-dessus (en particulier les 2e et 3e), j'ai écrit le code suivant. Hmmm, redondant!

#Calcul du taux de réussite des données valides
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("Taux gagnant:",round(solo_count/len(val_group)*100,2),"%")
print("Double valeur prédictive simple:",round(doub_count/len(val_group)*100,2),"%")
print("Triple valeur prédictive unique:",round(tri_count/len(val_group)*100,2),"%")

à la fin

Le résultat ci-dessus est un taux de réussite plus élevé que d'acheter sans réfléchir. (La combinaison de triplets la plus fréquente est "1-2-3", et la fréquence est d'environ 7%)

Cependant, ce résultat à lui seul est inacceptable en tant que taux de réussite, j'ai donc estimé qu'un autre appareil était nécessaire. Je voudrais résumer cela dans un autre article.