import pathlib
import warnings
import lightgbm as lgbm
import pandas as pd
from typing import Literal
import tqdm
import datetime

import sys
sys.path.append(".")
sys.path.append("..")
from src.model_manager.lgbm_manager import LightGBMDataset  # noqa
from src.model_manager.lgbm_manager import LightGBMModelManager  # noqa
from src.core.meta.bet_name_meta import BetName  # noqa
from src.data_manager.preprocess_tools import DataPreProcessor  # noqa
from src.data_manager.data_loader import DataLoader  # noqa
from src.core.db.controller import getDataFrame, getTableList  # noqa

warnings.filterwarnings("ignore")

root_dir = pathlib.Path(".").absolute().parent
dbpath = root_dir / "data" / "keibadata.db"
start_year = 2000  # DBが持つ最古の年を指定
split_year = 2014  # 学習対象期間の開始年を指定
target_year = 2019  # テスト対象期間の開始年を指定
end_year = 2023  # テスト対象期間の終了年を指定 (当然DBに対象年のデータがあること)

# 各種インスタンスの作成
data_loader = DataLoader(
    start_year,
    end_year,
    dbpath=dbpath  # dbpathは各種環境に合わせてパスを指定してください。絶対パス推奨
)

dataPreP = DataPreProcessor()

df = data_loader.load_racedata()
df = dataPreP.exec_pipeline(df)

horseblood_list = [tbl for tbl in getTableList(dbpath) if "horseblood" in tbl]
horseblood_list.sort(key=lambda x: int(x[-4:]))
dfblood = pd.concat(
    [getDataFrame(tbl, dbpath) for tbl in horseblood_list], ignore_index=True)

def add_blood_info_to_df(
    df: pd.DataFrame,
    mode: Literal[
        "s", "ss", "sb", "b", "bs", "bb",
        "sss", "ssb", "sbs", "sbb", "bss", "bsb", "bbs", "bbb",
        "ssss", "sssb", "ssbs", "ssbb", "sbss", "sbsb", "sbbs", "sbbb",
        "bsss", "bssb", "bsbs", "bsbb", "bbss", "bbsb", "bbbs", "bbbb",
        "sssss", "ssssb", "sssbs", "sssbb", "ssbss", "ssbsb", "ssbbs", "ssbbb",
        "sbsss", "sbssb", "sbsbs", "sbsbb", "sbbss", "sbbsb", "sbbbs", "sbbbb",
        "bssss", "bsssb", "bssbs", "bssbb", "bsbss", "bsbsb", "bsbbs", "bsbbb",
        "bbsss", "bbssb", "bbsbs", "bbsbb", "bbbss", "bbbsb", "bbbbs", "bbbbb",
    ]
):
    index_map = {
        # region Stallion 1gen, 2gen  3gen
        "s": (0, "stallion", "gen1"),
        "ss": (0, "sStallion", "gen2"), "sb": (8, "sBreed", "gen2"),
        "sss": (0, "s2Stallion", "gen3"), "ssb": (4, "s2Breed", "gen3"),
        "sbs": (8, "sbStallion", "gen3"), "sbb": (12, "sbBreed", "gen3"),
        # endregion
        # region Stallion 4gen
        "ssss": (0, "s3Stallion", "gen4"), "sssb": (2, "s3Breed", "gen4"),
        "ssbs": (4, "s2bStallion", "gen4"), "ssbb": (6, "s2bBreed", "gen4"),
        "sbss": (8, "sbsStallion", "gen4"), "sbsb": (10, "sbsBreed", "gen4"),
        "sbbs": (12, "sb2Stallion", "gen4"), "sbbb": (14, "sb2Breed", "gen4"),
        # endregion
        # region Stallion 5gen
        "sssss": (0, "s4Stallion", "gen5"), "ssssb": (1, "s4Breed", "gen5"),
        "sssbs": (2, "s3bStallion", "gen5"), "sssbb": (3, "s3bBreed", "gen5"),
        "ssbss": (4, "s2bsStallion", "gen5"), "ssbsb": (5, "s2bsBreed", "gen5"),
        "ssbbs": (6, "s2b2Stallion", "gen5"), "ssbbb": (7, "s2b2Breed", "gen5"),
        "sbsss": (8, "sbs2Stallion", "gen5"), "sbssb": (9, "sbs2Breed", "gen5"),
        "sbsbs": (10, "sbsbStallion", "gen5"), "sbsbb": (11, "sbsbBreed", "gen5"),
        "sbbss": (12, "sb2sStallion", "gen5"), "sbbsb": (13, "sb2sBreed", "gen5"),
        "sbbbs": (14, "sb3Stallion", "gen5"), "sbbbb": (15, "sb3Breed", "gen5"),
        # endregion
        # region Breed 1gen, 2gen 3gen
        "b": (16, "breed", "gen1"),
        "bs": (16, "bStallion", "gen2"), "bb": (24, "bBreed", "gen2"),
        "bss": (16, "bsStallion", "gen3"), "bsb": (20, "bsBreed", "gen3"),
        "bbs": (24, "b2Stallion", "gen3"), "bbb": (28, "b2Breed", "gen3"),
        # endregion
        # region Breed 4gen
        "bsss": (16, "bs2Stallion", "gen4"), "bssb": (18, "bs2Breed", "gen4"),
        "bsbs": (20, "bsbStallion", "gen4"), "bsbb": (22, "bsbBreed", "gen4"),
        "bbss": (24, "b2sStallion", "gen4"), "bbsb": (26, "b2sBreed", "gen4"),
        "bbbs": (28, "b3Stallion", "gen4"), "bbbb": (30, "b3Breed", "gen4"),
        # endregion
        # region Breed 5gen
        "bssss": (16, "bs3Stallion", "gen5"), "bsssb": (17, "bs3Breed", "gen5"),
        "bssbs": (18, "bs2bStallion", "gen5"), "bssbb": (19, "bs2bBreed", "gen5"),
        "bsbss": (20, "bsbsStallion", "gen5"), "bsbsb": (21, "bsbsBreed", "gen5"),
        "bsbbs": (22, "bsb2Stallion", "gen5"), "bsbbb": (23, "bsb2Breed", "gen5"),
        "bbsss": (24, "b2s2Stallion", "gen5"), "bbssb": (25, "b2s2Breed", "gen5"),
        "bbsbs": (26, "b2sbStallion", "gen5"), "bbsbb": (27, "b2sbBreed", "gen5"),
        "bbbss": (28, "b3sStallion", "gen5"), "bbbsb": (29, "b3sBreed", "gen5"),
        "bbbbs": (30, "b4Stallion", "gen5"), "bbbbb": (31, "b4Breed", "gen5"),
        # endregion
    }
    idx, prefix, genCol = index_map[mode]
    idf = dfblood.iloc[idx::32].reset_index(drop=True)
    idf[genCol] = idf[genCol].str.split("\n", expand=True)[
        0].str.replace("\n", "")
    df[f"{prefix}Id"] = df["horseId"].map(
        idf.set_index("horseId")[f"{genCol}ID"])
    df[f"{prefix}Name"] = df["horseId"].map(idf.set_index("horseId")[genCol])
    return df, idf[["horseId", genCol, f"{genCol}ID"]].rename(columns={genCol: "GenName", f"{genCol}ID": "GenID"})

df, _ = add_blood_info_to_df(df, "s")  # 父
df, _ = add_blood_info_to_df(df, "b")  # 母
df, _ = add_blood_info_to_df(df, "sb")  # 父母
df, _ = add_blood_info_to_df(df, "ss")  # 父父
df, _ = add_blood_info_to_df(df, "bs")  # 母父
df, _ = add_blood_info_to_df(df, "bbs")  # 母母父
df, _ = add_blood_info_to_df(df, "bbbs")  # 母母母父
df, _ = add_blood_info_to_df(df, "bbbbs")  # 母母母母父
df, _ = add_blood_info_to_df(df, "sbs")  # 父母父
df, _ = add_blood_info_to_df(df, "sbbs")  # 父母母父
df, _ = add_blood_info_to_df(df, "sbbbs")  # 父母母母父

import gc
del dfblood
gc.collect()

def create_model(df: pd.DataFrame, lgbm_model_manager: LightGBMModelManager):
    dataset_mapping = lgbm_model_manager.make_dataset_mapping(df)
    dataset_mapping = lgbm_model_manager.setup_dataset(dataset_mapping)
    params = {
        'boosting_type': 'gbdt',
        # 二値分類
        'objective': 'binary',
        'metric': 'auc',
        'verbose': 0,
        'seed': 77777,
        'learning_rate': 0.01,
        "n_estimators": 10000
    }

    lgbm_model_manager.train_all(
        params,
        dataset_mapping,
        stopping_rounds=500,  # ここで指定した値を超えるまでは、early stopさせない
        val_num=250  # ログを出力するスパン
    )
    for dataset_dict in dataset_mapping.values():
        lgbm_model_manager.load_model(dataset_dict.name)
        lgbm_model_manager.predict(dataset_dict)

    bet_mode = BetName.tan
    for dataset_dict in dataset_mapping.values():
        lgbm_model_manager.set_bet_column(dataset_dict, bet_mode)
    _, dfbetva, dfbette = lgbm_model_manager.merge_dataframe_data(
        dataset_mapping, mode=True)

    dfbetva, dfbette = lgbm_model_manager.generate_profit_loss(
        dfbetva, dfbette, bet_mode)

    lgbm_model_manager.basic_analyze(dataset_mapping)

    dftrain, dfvalid, dftest = lgbm_model_manager.merge_dataframe_data(
        dataset_mapping,
        mode=True
    )
    summary_dict = lgbm_model_manager.gegnerate_odds_graph(
        dftrain, dfvalid, dftest, bet_mode)

    lgbm_model_manager.export_model_info()

stllIdEnc = {hId: idx for idx, hId in enumerate(df["stallionId"].unique())}
df["stallionId_en"] = df["stallionId"].map(stllIdEnc).astype("category")
brdIdEnc = {hId: idx for idx, hId in enumerate(df["breedId"].unique())}
df["breedId_en"] = df["breedId"].map(brdIdEnc).astype("category")
del brdIdEnc, stllIdEnc

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part1",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

sStllIdEnc = {hId: idx for idx, hId in enumerate(df["sStallionId"].unique())}
df["sStallionId_en"] = df["sStallionId"].map(sStllIdEnc).astype("category")
del sStllIdEnc

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part2",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en", "sStallionId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

sStllIdEnc = {hId: idx for idx, hId in enumerate(df["bStallionId"].unique())}
df["bStallionId_en"] = df["bStallionId"].map(sStllIdEnc).astype("category")
del sStllIdEnc

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part3",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en", "bStallionId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

sStllIdEnc = {hId: idx for idx, hId in enumerate(df["b2StallionId"].unique())}
df["b2StallionId_en"] = df["b2StallionId"].map(sStllIdEnc).astype("category")
del sStllIdEnc

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part4",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en",
                    "bStallionId_en", "b2StallionId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

sStllIdEnc = {hId: idx for idx, hId in enumerate(df["b3StallionId"].unique())}
df["b3StallionId_en"] = df["b3StallionId"].map(sStllIdEnc).astype("category")
sStllIdEnc = {hId: idx for idx, hId in enumerate(df["b4StallionId"].unique())}
df["b4StallionId_en"] = df["b4StallionId"].map(sStllIdEnc).astype("category")
del sStllIdEnc

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part5",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en", "bStallionId_en",
                    "b2StallionId_en", "b3StallionId_en", "b4StallionId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part6",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en", "bStallionId_en",
                    "b2StallionId_en", "b3StallionId_en", "b4StallionId_en", "sStallionId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

sStllIdEnc = {hId: idx for idx, hId in enumerate(df["sbStallionId"].unique())}
df["sbStallionId_en"] = df["sbStallionId"].map(sStllIdEnc).astype("category")
sStllIdEnc = {hId: idx for idx, hId in enumerate(df["sb2StallionId"].unique())}
df["sb2StallionId_en"] = df["sb2StallionId"].map(sStllIdEnc).astype("category")
sStllIdEnc = {hId: idx for idx, hId in enumerate(df["sb3StallionId"].unique())}
df["sb3StallionId_en"] = df["sb3StallionId"].map(sStllIdEnc).astype("category")
del sStllIdEnc
gc.collect()

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part7",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en", "bStallionId_en", "b2StallionId_en", "b3StallionId_en",
                    "b4StallionId_en", "sStallionId_en", "sbStallionId_en", "sb2StallionId_en", "sb3StallionId_en"]

# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

create_model(df, lgbm_model_manager)

! python ../app_keiba/manage.py makemigrations
! python ../app_keiba/manage.py migrate 
! echo server launch OK
# ! python ../app_keiba/manage.py runserver 12345

# 指定したモデルIDから最新の2023年下期(2023second)モデルを読込
# 特徴量重要度を取得
def get_model_feature_important(
    model_id: Literal[
        "blood_model_part1", "blood_model_part2",
        "blood_model_part3", "blood_model_part4", "blood_model_part5",
        "blood_model_part6", "blood_model_part8"
    ],
    model_attr="2023second",
    mode: Literal["gain", "split"] = "gain"
):
    lgbm_model_manager = LightGBMModelManager(
        # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
        # フォルダパスは絶対パスにすると安全です。
        root_dir / "models" / model_id,
        split_year,
        target_year,
        end_year
    )
    lgbm_model_manager.load_model(model_attr)

    dfimp = pd.DataFrame(
        lgbm_model_manager.model.feature_importance(
            importance_type=mode),
        index=lgbm_model_manager.feature_columns,
        columns=[model_id]
    ).sort_values(model_id)

    # 重要度が0の特徴量を削除
    return dfimp[dfimp > 0]

dfimp: pd.DataFrame = pd.concat(
    [
        get_model_feature_important(f"blood_model_part{n}")
        for n in range(1, 8)
    ],
    axis=1
).dropna(
    axis=0, how="all")

(dfimp/1000).round(1).loc[
    dfimp.mean(axis=1).sort_values().index].fillna("")

lgbm_model_manager = LightGBMModelManager(
    # modelsディレクトリ配下に作成したいモデル名のフォルダパスを指定。
    # フォルダパスは絶対パスにすると安全です。
    root_dir / "models" / "blood_model_part4-ext",
    split_year,
    target_year,
    end_year
)
# 説明変数にするカラム
feature_columns = [
    'distance',
    'number',
    'boxNum',
    'odds',
    'favorite',
    'age',
    'jweight',
    'weight',
    'gl',
    'race_span',
    "raceGrade",  # グレード情報を追加
] + dataPreP.encoding_columns

# 血統情報を追加
feature_columns += ["stallionId_en", "breedId_en",
                    "bStallionId_en", "b2StallionId_en"]
# 血統の勝率情報の追加
feature_columns += ["winR_stallion", "winR_breed",
                    "winR_bStallion", "winR_b2Stallion"]


# 目的変数用のカラム
objective_column = "label_in1"

# 説明変数と目的変数をモデル作成用のインスタンスへセット
lgbm_model_manager.set_feature_and_objective_columns(
    feature_columns, objective_column)

# 目的変数の作成: 1着のデータに正解フラグを立てる処理を実行
df = lgbm_model_manager.add_objective_column_to_df(df, "label", 1)

dataset_mapping = lgbm_model_manager.make_dataset_mapping(df)

blood_set = [["stallionId"], ["breedId"],
             ["bStallionId"], ["b2StallionId"]]

now = datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')

with tqdm.tqdm(
    total=len(dataset_mapping),
    desc=f"Add blood win rate in 2019first ({now}) ..."
) as pbar:

    for key, dataset in dataset_mapping.items():
        now = datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')
        pbar.set_description(desc=f"Add blood win rate in {key} ({now}) ...")
        winR_map = {}

        for target_list in [["train", ["train", "valid"]], ["train", "valid", ["test"]]]:
            concat_list = target_list[:-1]
            target_set = target_list[-1]
            idf2 = pd.concat([dataset.__dict__[target]
                             for target in concat_list])
            set_columns_dict = {}
            idf = df[df["raceDate"] <= idf2["raceDate"].max()]

            for blood_cross in blood_set:
                dffilter = idf[blood_cross[0]].isin(
                    idf2[blood_cross[0]].unique())
                for bc in blood_cross[1:]:
                    dffilter &= idf[bc].isin(idf2[bc].unique())
                idf3 = idf[dffilter]
                group_columns = ["field", "dist_cat"]+blood_cross
                idfagg = idf3.groupby(group_columns)[objective_column].mean()
                set_column = "winR_"+"_".join([b[:-2] for b in blood_cross])
                set_columns_dict[set_column] = idfagg

            for t in target_set:
                winR_map[t] = set_columns_dict.copy()

        for mode, winR in winR_map.items():
            for kcol, idfagg in winR.items():
                group_columns = idfagg.reset_index().columns.tolist()[:-1]
                idf = dataset.__dict__[mode].set_index(group_columns)
                idf[kcol] = idfagg
                idf[kcol].fillna(0, inplace=True)
                dataset.__dict__[mode] = idf.reset_index()
        pbar.update()

def create_model_winR(
    dataset_mapping: dict[str, LightGBMDataset],
    lgbm_model_manager: LightGBMModelManager
):
    dataset_mapping = lgbm_model_manager.setup_dataset(dataset_mapping)
    params = {
        'boosting_type': 'gbdt',
        # 二値分類
        'objective': 'binary',
        'metric': 'auc',
        'verbose': 0,
        'seed': 77777,
        'learning_rate': 0.01,
        "n_estimators": 10000
    }

    lgbm_model_manager.train_all(
        params,
        dataset_mapping,
        stopping_rounds=500,  # ここで指定した値を超えるまでは、early stopさせない
        val_num=250  # ログを出力するスパン
    )
    for dataset_dict in dataset_mapping.values():
        lgbm_model_manager.load_model(dataset_dict.name)
        lgbm_model_manager.predict(dataset_dict)

    bet_mode = BetName.tan
    for dataset_dict in dataset_mapping.values():
        lgbm_model_manager.set_bet_column(dataset_dict, bet_mode)
    _, dfbetva, dfbette = lgbm_model_manager.merge_dataframe_data(
        dataset_mapping, mode=True)

    dfbetva, dfbette = lgbm_model_manager.generate_profit_loss(
        dfbetva, dfbette, bet_mode)

    lgbm_model_manager.basic_analyze(dataset_mapping)

    dftrain, dfvalid, dftest = lgbm_model_manager.merge_dataframe_data(
        dataset_mapping,
        mode=True
    )
    summary_dict = lgbm_model_manager.gegnerate_odds_graph(
        dftrain, dfvalid, dftest, bet_mode)

    lgbm_model_manager.export_model_info()

create_model_winR(dataset_mapping, lgbm_model_manager)

! python ../app_keiba/manage.py makemigrations
! python ../app_keiba/manage.py migrate 
! echo server launch OK
# ! python ../app_keiba/manage.py runserver 12345

dfimp: pd.DataFrame = pd.concat(
    [
        get_model_feature_important(f"first_model", mode="gain"),
        get_model_feature_important(f"blood_model_part4", mode="gain"),
        get_model_feature_important(f"blood_model_part4-ext", mode="gain")
    ],
    axis=1
).dropna(
    axis=0, how="all")

dfimp.round(2).loc[
    dfimp.mean(axis=1).sort_values().index].fillna("")