随机森林超参数优化

文章目录

• 总体思路分为三部

• 1.查看数据，对数据进行清洗，规约

• 1.1 查看数据
• 1.2 数据清洗,规约
• 1.3 删除不相关的特征
• 1.4 数据one-hot处理*

• 2.建立模型，挑选出最优参数

• 2.1 准备数据集,训练集，测试集
• 2.2 建立随机森林模型
• 2.3 通过树的大小和K折验证得到log_loss最小的值和最优树的数量
• 2.4 通过树的深度和K折验证得到log_loss最小的值和最大深度的最优值

• 3.绘制模型训练过程的损失值改变的图
• 4.训练模型

总体思路分为三部

1.查看数据，对数据进行清洗，规约

1.1 查看数据

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
%matplotlib inline

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import KFold
filename= "data.csv"
raw = pd.read_csv(filename)
print (raw.shape)
raw.head()

1.2 查看 loc_x and loc_y，# lat and lon的关系

#plt.subplot(211) first is raw second Column
alpha = 0.02
plt.figure(figsize=(10,10))

# loc_x and loc_y
plt.subplot(121)
plt.scatter(kobe.loc_x, kobe.loc_y, color='R', alpha=alpha)
plt.title('loc_x and loc_y')

# lat and lon
plt.subplot(122)
plt.scatter(kobe.lon, kobe.lat, color='B', alpha=alpha)
plt.title('lat and lon')

1.2 数据清洗,规约

raw['dist'] = np.sqrt(raw['loc_x']**2 + raw['loc_y']**2)#将坐标转为距离
loc_x_zero = raw['loc_x'] == 0
#print (loc_x_zero)
raw['angle'] = np.array([0]*len(raw))
raw['angle'][~loc_x_zero] = np.arctan(raw['loc_y'][~loc_x_zero] / raw['loc_x'][~loc_x_zero])
raw['angle'][loc_x_zero] = np.pi / 2   #得到坐标的角度
#统一时间
raw['remaining_time'] = raw['minutes_remaining'] * 60 + raw['seconds_remaining']
#查看各类型的唯一值
print(kobe.action_type.unique())
print(kobe.combined_shot_type.unique())
print(kobe.shot_type.unique())
print(kobe.shot_type.value_counts())

打印结果：

season值

kobe['season'].unique()

得到有用的season值

raw['season'] = raw['season'].apply(lambda x: int(x.split('-')[1]) )
raw['season'].unique()

print(kobe['team_id'].unique()) 
print(kobe['team_name'].unique())

team_id，team_name特征太少，需要删除

比赛球队信息

pd.DataFrame({'matchup':kobe.matchup, 'opponent':kobe.opponent})

kobe.matchup特征少，需删除

plt.figure(figsize=(5,5))
plt.scatter(raw.dist, raw.shot_distance, color='blue')
plt.title('dist and shot_distance')

将dist和 shot_distance作比较，发现特征类似，删除一个即可

shot_zone_area：

gs = kobe.groupby('shot_zone_area')
print (kobe['shot_zone_area'].value_counts())
print (len(gs))

import matplotlib.cm as cm
plt.figure(figsize=(20,10))

def scatter_plot_by_category(feat):
    alpha = 0.1
    gs = kobe.groupby(feat)
    cs = cm.rainbow(np.linspace(0, 1, len(gs)))
    for g, c in zip(gs, cs):
        plt.scatter(g[1].loc_x, g[1].loc_y, color=c, alpha=alpha)

# shot_zone_area
plt.subplot(131)
scatter_plot_by_category('shot_zone_area')
plt.title('shot_zone_area')

# shot_zone_basic
plt.subplot(132)
scatter_plot_by_category('shot_zone_basic')
plt.title('shot_zone_basic')

# shot_zone_range
plt.subplot(133)
scatter_plot_by_category('shot_zone_range')
plt.title('shot_zone_range')

1.3 删除不相关的特征

drops = ['shot_id', 'team_id', 'team_name', 'shot_zone_area', 'shot_zone_range', 'shot_zone_basic', \
         'matchup', 'lon', 'lat', 'seconds_remaining', 'minutes_remaining', \
         'shot_distance', 'loc_x', 'loc_y', 'game_event_id', 'game_id', 'game_date']
for drop in drops:
    raw = raw.drop(drop, 1)

1.4 数据one-hot处理*

combined_shot_type

print (raw['combined_shot_type'].value_counts())
pd.get_dummies(raw['combined_shot_type'], prefix='combined_shot_type')[0:2]#输出前两行

分类变量one-hot处理

categorical_vars = ['action_type', 'combined_shot_type', 'shot_type', 'opponent', 'period', 'season']
for var in categorical_vars:
    raw = pd.concat([raw, pd.get_dummies(raw[var], prefix=var)], 1)
    raw = raw.drop(var, 1)

2.建立模型，挑选出最优参数

2.1 准备数据集,训练集，测试集

train_kobe = raw[pd.notnull(raw['shot_made_flag'])] 
train_kobe = train_kobe.drop('shot_made_flag', 1) #x_train
train_label = train_kobe['shot_made_flag']  #y_train
test_kobe = raw[pd.isnull(raw['shot_made_flag'])]  
test_kobe = test_kobe.drop('shot_made_flag', 1)  #x_test

2.2 建立随机森林模型

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import confusion_matrix,log_loss
import time
`import numpy as np
range_m = np.logspace(0,2,num=5).astype(int)
range_m #树的深度

range_n = np.logspace(0,2,num=3).astype(int)
range_n#树的数量

2.3 通过树的大小和K折验证得到log_loss最小的值和最优树的数量

# find the best n_estimators for RandomForestClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import KFold

print('Finding best n_estimators for RandomForestClassifier...')
min_score = 100000
best_n = 0
scores_n = []

for n in range_n:
    print("the number of trees : {0}".format(n))
    t1 = time.time()
    
    rfc_score = 0.
    rfc = RandomForestClassifier(n_estimators=n)
    for train_k, test_k in KFold(len(train_kobe), n_folds=10, shuffle=True):
        rfc.fit(train_kobe.iloc[train_k], train_label.iloc[train_k])
        #rfc_score += rfc.score(train.iloc[test_k], train_y.iloc[test_k])/10
        pred = rfc.predict(train_kobe.iloc[test_k])
        rfc_score += log_loss(train_label.iloc[test_k], pred) / 10
    scores_n.append(rfc_score)
    if rfc_score < min_score:
        min_score = rfc_score
        best_n = n
        
    t2 = time.time()
    print('Done processing {0} trees ({1:.3f}sec)'.format(n, t2-t1))
print(best_n, min_score)

2.4 通过树的深度和K折验证得到log_loss最小的值和最大深度的最优值

# find best max_depth for RandomForestClassifier
print('Finding best max_depth for RandomForestClassifier...')
min_score = 100000
best_m = 0
scores_m = []
range_m = np.logspace(0,2,num=3).astype(int)
for m in range_m:
    print("the max depth : {0}".format(m))
    t1 = time.time()
    
    rfc_score = 0.
    rfc = RandomForestClassifier(max_depth=m, n_estimators=best_n)
    for train_k, test_k in KFold(len(train_kobe), n_folds=10, shuffle=True):
        rfc.fit(train_kobe.iloc[train_k], train_label.iloc[train_k])
        #rfc_score += rfc.score(train.iloc[test_k], train_y.iloc[test_k])/10
        pred = rfc.predict(train_kobe.iloc[test_k])
        rfc_score += log_loss(train_label.iloc[test_k], pred) / 10
    scores_m.append(rfc_score)
    if rfc_score < min_score:
        min_score = rfc_score
        best_m = m
    
    t2 = time.time()
    print('Done processing {0} trees ({1:.3f}sec)'.format(m, t2-t1))
print(best_m, min_score)

3.绘制模型训练过程的损失值改变的图

plt.figure(figsize=(10,5))
plt.subplot(121)
plt.plot(range_n, scores_n)
plt.ylabel('score')
plt.xlabel('number of trees')

plt.subplot(122)
plt.plot(range_m, scores_m)
plt.ylabel('score')
plt.xlabel('max depth')

4.训练模型

model = RandomForestClassifier(n_estimators=best_n, max_depth=best_m)
model.fit(train_kobe, train_label)