錦織選手からブレイクをもぎ取りたい！〜MLPによるサーブコースの予測〜

import numpy as np
import pandas as pd
import requests
from bs4 import BeautifulSoup

#データの取得（サーフェスデータあり）
 r = requests.get("http://datatennis.net/archives/4611/")
 soup = BeautifulSoup(r.text,"lxml")

 df_serve_2018 = pd.DataFrame()

#０アウトドアハード1インドアハード２アウトドアグラス3アウトドアクレー
 surface_list = [1,1,0,1,1,0,0,0,2,2,3,3,3,3,0,1,1]
 url = soup.find_all("a")
 for i in range(17):
     df =    pd.read_csv(url[i+19].get("href"),encoding='shift_jis')
     df["Surface"] = surface_list[i]
     df_serve_2018 = pd.concat([df_serve_2018,df],axis =0

#データの整形
 df_serve_2018 = df_serve_2018[(df_serve_2018["Server"] == "圭") 
& (df_serve_2018["Cource"] !="n") 
& (df_serve_2018["Cource"] !="o")]
 df_serve_2018 = df_serve_2018.drop(["Unnamed: 0","index","AceDbF","OpponentPlayer","Server","Speed","Tournament","WinLose","WonA","WonB"],axis=1)
 for i in range(len(df_serve_2018)):
     if not df_serve_2018.iloc[i,0] in ['w','b','c']:
         df_serve_2018.iloc[i,0] = np.nan
 df_serve_2018 = df_serve_2018.dropna(how="any")
 df_serve_2018.reset_index()
 X = df_serve_2018.iloc[:,1:8]
 y = df_serve_2018["Cource"]
 for i in range(len(X)):
     X.iloc[i,5] = 0 if X.iloc[i,5] == "Deuce" else 1
     X.iloc[i,4] = 45 if X.iloc[i,4] == "Ad" else int(X.iloc[i,4])
     X.iloc[i,3] = 45 if X.iloc[i,3] == "Ad" else int(X.iloc[i,3])
     X.iloc[i,0] = int(X.iloc[i,0]) if X.iloc[i,0] in ['1','2',1,2] else 1

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler

#トレーニングデータ、テストデータに分ける
 train_X,test_X,train_y,test_y = train_test_split(X,y,random_state=42)
#データのスケーリング
 scaler = MinMaxScaler(feature_range=(0, 1))
 scaler_train = scaler.fit(train_X)
 train_X = scaler_train.transform(train_X)
 test_X = scaler_train.transform(test_X)

from sklearn.neural_network import MLPClassifier
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import RandomizedSearchCV

#モデルの作成と学習
 model_param_set_random ={MLPClassifier(): {
     "hidden_layer_sizes":[(i,j,k) for i in range(1,101) for j in range(1,101) for k in range(1,101)],
     "activation":["identity","logistic","tanh","relu"],
     "solver":["lbfgs","sgd","adam"],
     "random_state":[42]}}
 max_score = 0
 best_param = None
 best_confusion_matrix = None
 best_clf = None
 
#ランダムサーチでパラメーターサーチ
 for model, param in model_param_set_random.items():
     clf = RandomizedSearchCV(model, param)
     clf.fit(train_X, train_y)
     pred_y = clf.predict(test_X)
     score = f1_score(test_y, pred_y, average="micro")
     if max_score < score:
         max_score = score
         best_param = clf.best_params_
         best_confusion_matrix = confusion_matrix(test_y,pred_y)
         best_clf = clf
 print("パラメーター:{}".format(best_param))
 print("ベストスコア:",max_score)
 print("混合行列:",best_confusion_matrix)

#出力-----------------------------------------------------
ベストスコア: 0.5432873274780426
 混合行列:
 [[  0  28  76]
  [  0  85 230]
  [  0  30 348]]

得点率: 0.37641154328732745

table = np.array(best_clf.predict_proba(test_X))
answers = test_y.values.tolist()
def cource_to_number(cource):
     if cource == "b":
         return 0
     elif cource == "c":
         return 1
     else:
         return 2
 won_count = 0
 for i in range(len(answers)):
     point_prob = 0
     if test_X[i,0] == 1:
         point_prob = 3*0.29*table[i][cource_to_number(answers[i])]
     else:
         point_prob = 3*0.44*table[i][cource_to_number(answers[i])]
 p = np.random.uniform() if p < point_prob:     won_count += 1
 print("得点率:",won_count/len(test_y))

＃出力---------------------------------------------------
得点率: 0.4893350062735257

...
from imblearn.over_sampling import SMOTE
#SMOTEによる不均衡の是正
 sm = SMOTE(random_state=42)
 train_X, train_y = sm.fit_sample(X,y)
...
#出力-----------------------------------------------------
パラメーター:{'solver': 'lbfgs', 'random_state': 42, 'hidden_layer_sizes': (76, 39, 20), 'activation': 'tanh'}
 ベストスコア: 0.37515683814303635
 混合行列: 
[[ 38  38  28]
  [101 113 101]
  [118 112 148]]
 0.437892095357591

from bayes_opt import BayesianOptimization
＃最適化の下準備
 def cource_to_number(cource):
     if cource == "b":
         return 0
     elif cource == "c":
         return 1
     else:
         return 2
 table = np.array(clf.predict_proba(test_X))
 answers = test_y.values.tolist()
 ＃最適化する関数の定義
 def validate(h1,h2,h3,activation,solver,random_state):
     # 与えられたパラメータでMLPのモデルを初期化
     h1 = int(np.round(h1))
     h2 = int(np.round(h2))
     h3 = int(np.round(h3))
     activation_list = ["identity","logistic","tanh","relu"]
     solver_list = ["sgd","adam"]
     activation = activation_list[int(np.round(activation))]
     solver = solver_list[int(np.round(solver))]
     random_state = int(np.round(random_state))
     model = MLPClassifier(hidden_layer_sizes=(h1,h2,h3),activation=activation,solver=solver,random_state=random_state,max_iter=1000,shuffle=True,early_stopping=True)
     # 10-Foldで交差検証
     iterater = KFold(n_splits=10)
     results = []
     for train_indexes, test_indexes in iterater.split(train_X):
         new_X = pd.DataFrame(train_X).iloc[train_indexes]
         new_y = train_y[train_indexes]
         clf = model
         clf.fit(new_X,new_y)
　　　　  
         
    
 
 最適化するパラメータの下限・上限 (Cとgamma)
 pbounds = {
     'h1': (1,100),
     'h2': (1,100),
     'h3': (1,100),
     "activation":(-0.5,3.49999),
     "solver":(-0.5,1.49999),
     "random_state":(1,100)
 }
 関数と最適化するパラメータを渡す
 optimizer = BayesianOptimization(f=validate, pbounds=pbounds)
 最適化
 optimizer.maximize(init_points=10, n_iter=100,acq='ucb')

|   iter    |  target   | activa... |    h1     |    h2     |    h3     | random... |  solver   |
-------------------------------------------------------------------------------------------------
・・・
|  27       |  0.5041   |  2.752    |  99.41    |  7.51     |  99.78    |  5.415    | -0.2478   |
・・・