【競馬AI 13】作成したモデルを使って2023年の回収率を計算する

import lightgbm as lgb
import pandas as pd
from sklearn.metrics import roc_curve, roc_auc_score
import ast
from sklearn import metrics

# 割合に応じでデータを分割
def split_date(df, test_size):
    sorted_id_list = df.sort_values('race_id').index.unique()
    train_id_list = sorted_id_list[:round(len(sorted_id_list) * (1-test_size))]
    test_id_list = sorted_id_list[round(len(sorted_id_list) * (1-test_size)):]
    train = df.loc[train_id_list]
    test = df.loc[test_id_list]
    return train, test

# 2023年を境にテストデータに分割
def split_date_by_year(df):
    # race_idの先頭4桁を取得し、整数型に変換して年として扱う
    df['year'] = df['race_id'].astype(str).str[:4].astype(int)
    
    # 2023年のデータをテストセットとして選択
    test = df[df['year'] == 2023]
    # print(len(test['race_id'].unique()))
    # 2023年以外のデータをトレーニングセットとして選択
    train = df[df['year'] != 2023]
    
    # 年を表す一時的な列を削除
    train = train.drop(columns=['year'])
    test = test.drop(columns=['year'])
    
    return train, test

# 馬番が含まれる文字列（例: "1-3"）を分割して整数リストに変換する関数
def parse_horse_numbers(horse_number_str):
    return [int(num) for num in horse_number_str.split('-')]

# モデルファイル
model_file = 'model/model.txt'
model_file2 = 'model/model_ana.txt'

# データの読み込み
data = pd.read_csv('encoded/encoded_data.csv')
data['着順'] = data['着順'].map(lambda x: 1 if x == 1 else 0)

# 特徴量とターゲットの分割
# train, test = split_date(data, 0.2)
# 特徴量とターゲットを2023年で分割
train, test = split_date_by_year(data)

race_ids = test['race_id']
drop_arr=[
'race_id','着順','上がり','走破時間','通過順','人気','オッズ','騎手','レース名','開催','馬の平均着順', '馬の3着内率','最終追切_評価']
X_test = test.drop(drop_arr, axis=1)
# 既に訓練したモデル 'model' を読み込む
model = lgb.Booster(model_file=model_file)
model2 = lgb.Booster(model_file=model_file2)

# テストデータに対する予測確率を求める
y_pred = model.predict(X_test)
y_pred2 = model2.predict(X_test)

X_test.insert(0, 'race_id', race_ids)
X_test.insert(1, '予測結果', y_pred)
X_test.insert(2, '予測結果2', y_pred2)
X_test.insert(3, '着順', test['着順'])

#レース数
race_count = X_test['race_id'].nunique()

# 各 race_id ごとに最大の予測値を持つ行を抽出
max_predictions_per_race = X_test.groupby('race_id')['予測結果'].idxmax()
X_test_new = X_test.loc[max_predictions_per_race]

# 年度のリストを生成
years = range(2005, 2024)
# 各年度のCSVファイルを読み込み、一つのデータフレームに結合
df = []
for year in years:
    path = f"payback/{year}.csv"
    data = pd.read_csv(path, encoding="SHIFT-JIS", header=None)
    df.append(data)

betting_data = pd.concat(df, ignore_index=True)
betting_data.set_index(betting_data.iloc[:, 0].astype(str).str.strip(), inplace=True)

# 単勝と複勝の回収金額を計算
win_return_amount = 0  # 単勝の回収金額
place_return_amount = 0  # 複勝の回収金額
betting_count = 0  # 賭けた回数
umaren_return_amount = 0 # 馬連の回収金額
wide_return_amount = 0 # 馬連の回収金額
total_betting_amount = 0  # 賭けた合計金額
total_betting_amount_umaren = 0  # 賭けた合計金額
total_betting_amount_wide = 0  # 賭けた合計金額
umaren_hit_count = 0
wide_hit_count = 0

#閾値（この予測値を超えた馬を買う基準）
threshold = 0.85
# 予測値が0.85以上の行のインデックスを取得
high_pred_indices = [i for i, (pred, cls) in enumerate(zip(X_test_new['予測結果'], X_test_new['クラス'])) if pred >= threshold and cls != 3]
for index in high_pred_indices:
    # X_testの該当行にアクセス
    row = X_test_new.iloc[index]
    race_id = str(int(float(row['race_id'])))

    horse_number = str(int(float(row['馬番'])))  # 馬番を文字列に変換
    race = int(race_id[-2:])

    # race_idでX_testにアクセスし、予測結果2の最大値が-0.4以上の行を取得
    race_rows = X_test[X_test['race_id'] == row['race_id']]  # race_idに対応する行を取得
    race_rows_max_pred2 = race_rows[race_rows['予測結果2'] >= -0.3]  # 予測結果2の最大値が-0.3以上の行をフィルタリング
    horse_number2 = "99"
    if not race_rows_max_pred2.empty:
        row2 = race_rows_max_pred2.loc[race_rows_max_pred2['予測結果2'].idxmax()]  # 予測結果2が最大の行を取得
        if horse_number != str(int(float(row2['馬番']))):
            total_betting_amount_umaren += bet
            total_betting_amount_wide += bet
            horse_number2 = str(int(float(row2['馬番'])))
        
    bet = 100

    betting_count += 1
    total_betting_amount += bet

    if race_id in betting_data.index:
        race_data = betting_data.loc[race_id]  # 対応するレースのデータを取得
        race_data_list = ast.literal_eval(race_data[1])
        win_data = race_data_list[0]  # 単勝のデータを取得
        place_data = race_data_list[1]  # 複勝のデータを取得
        umaren_data = race_data_list[2]  # 馬連のデータを取得
        wide_data = race_data_list[3]  # ワイドのデータを取得

        for j in range(0, len(win_data), 2):
            if win_data[j] == horse_number:  # 賭けた馬が単勝した場合
                win_return_amount += int(win_data[j + 1].replace(',', '')) * bet / 100  # 回収金額を加算

        for j in range(0, len(place_data), 2):
            if place_data[j] == horse_number:  # 賭けた馬が複勝した場合
                place_return_amount += int(place_data[j + 1].replace(',', '')) * bet / 100  # 回収金額を加算
        
        for j in range(0, len(umaren_data), 2):
            if all(hn in parse_horse_numbers(umaren_data[j]) for hn in [int(horse_number), int(horse_number2)]):
                umaren_hit_count += 1
                umaren_return_amount += int(umaren_data[j + 1].replace(',', '')) * bet / 100  # 回収金額を加算

        for j in range(0, len(wide_data), 2):
            if all(hn in parse_horse_numbers(wide_data[j]) for hn in [int(horse_number), int(horse_number2)]):
                wide_hit_count += 1
                wide_return_amount += int(wide_data[j + 1].replace(',', '')) * bet / 100  # 回収金額を加算
    else:
        print(f"Race ID {race_id} not found in betting data.")

# 単勝と複勝の回収率を計算
win_return_rate = win_return_amount / total_betting_amount *100 # 単勝の回収率
place_return_rate = place_return_amount / total_betting_amount *100 # 複勝の回収率
umaren_return_rate = umaren_return_amount / total_betting_amount_umaren *100 # 馬連の回収率
wide_return_rate = wide_return_amount / total_betting_amount_wide *100 # 馬連の回収率

TP = (X_test_new['着順'] == 1) & (X_test_new['予測結果'] >= threshold) & (X_test_new['クラス'] != 3)# True positives
FP = (X_test_new['着順'] == 0) & (X_test_new['予測結果'] >= threshold) & (X_test_new['クラス'] != 3) # False positives

TP_count = sum(TP)
FP_count = sum(FP)

accuracy_TP = TP_count / betting_count * 100
misclassification_rate_FP = FP_count / betting_count * 100

print("Race count:", race_count)
print("Betting cases:", betting_count)
print("True positives:", TP_count, "(", "{:.2f}".format(accuracy_TP), "%)")
print("False positives:", FP_count, "(", "{:.2f}".format(misclassification_rate_FP), "%)")

print("単勝回収率:", round(win_return_rate,3))
print("複勝回収率:", round(place_return_rate,3))
print("馬連的中率:", str(umaren_hit_count) + '/' + str(int(total_betting_amount_umaren / 100)) + '(' + str(round(umaren_hit_count / int(total_betting_amount_umaren / 100),3) * 100) + '%)')
print("馬連回収率:", round(umaren_return_rate,3))
print("ワイド的中率:", str(wide_hit_count) + '/' + str(int(total_betting_amount_wide / 100)) + '(' + str(round(wide_hit_count / int(total_betting_amount_wide / 100),3) * 100) + '%)')
print("ワイド回収率:", round(wide_return_rate,3))

# 割合に応じでデータを分割
def split_date(df, test_size):
    sorted_id_list = df.sort_values('race_id').index.unique()
    train_id_list = sorted_id_list[:round(len(sorted_id_list) * (1-test_size))]
    test_id_list = sorted_id_list[round(len(sorted_id_list) * (1-test_size)):]
    train = df.loc[train_id_list]
    test = df.loc[test_id_list]
    return train, test

# 2023年を境にテストデータに分割
def split_date_by_year(df):
    # race_idの先頭4桁を取得し、整数型に変換して年として扱う
    df['year'] = df['race_id'].astype(str).str[:4].astype(int)
    
    # 2023年のデータをテストセットとして選択
    test = df[df['year'] == 2023]
    # print(len(test['race_id'].unique()))
    # 2023年以外のデータをトレーニングセットとして選択
    train = df[df['year'] != 2023]
    
    # 年を表す一時的な列を削除
    train = train.drop(columns=['year'])
    test = test.drop(columns=['year'])
    
    return train, test

#閾値（この予測値を超えた馬を買う基準）
threshold = 0.85

race_rows_max_pred2 = race_rows[race_rows['予測結果2'] >= -0.3]  # 予測結果2の最大値が-0.3以上の行をフィルタリング