一遏乔、背景

The Game Awards頒獎典禮式曲，是由索尼妨托、微軟、任天堂以及維爾福贊助的新活動吝羞，取代了以往的VGA以及VGX兰伤，The Game Awards被喻為游戲界的奧斯卡。（來自百度百科）

The Game Awards 2018

TGA的的提名幾天前已經(jīng)公布钧排。今年最佳游戲的提名包括《刺客信條：奧德賽》敦腔、《蔚藍(lán)》、《戰(zhàn)神》恨溜、《漫威蜘蛛俠》符衔、《怪物獵人：世界》以及《荒野大鏢客2》。

刺客信條:奧德賽

蔚藍(lán)

戰(zhàn)神

蜘蛛俠

怪物獵人:世界

荒野大鏢客2

目前來看糟袁，呼聲較高的應(yīng)當(dāng)是《荒野大鏢客2》判族，雖然此前金搖桿獎頒給了《堡壘之夜》，但是畢竟金搖桿更來自玩家投票项戴，基數(shù)大是有優(yōu)勢的形帮。可能從媒體的角度周叮，大部分人還是認(rèn)為大表哥有較大幾率斬獲今年的最佳游戲辩撑。那么通過前幾年的數(shù)據(jù)能否預(yù)測出今年的最佳游戲呢，這里嘗試用一些基本的模型做一個預(yù)測仿耽。

當(dāng)然合冀，我只是個學(xué)社科類專業(yè)的，并不是學(xué)CS的项贺，文章里所用的模型都是以前旁聽的課程或者現(xiàn)在學(xué)的數(shù)學(xué)統(tǒng)計課里學(xué)到的水慨，所以肯定有諸多問題，這個只是完成一個課程作業(yè)的嘗試敬扛，僅供自己記錄用。

解決思路大概是這樣的朝抖，收集數(shù)據(jù)--基本的數(shù)據(jù)描述--隨機森林選擇屬性--使用模型進(jìn)行預(yù)測（KNN啥箭、決策樹、隨機森林治宣、邏輯斯蒂回歸LR急侥、支持向量機SVM砌滞、樸素貝葉斯NB、神經(jīng)網(wǎng)絡(luò)坏怪、XGBoost)--綜合所有模型投票結(jié)果贝润，得到最終預(yù)測。

游戲數(shù)據(jù)預(yù)測The Game Awards獎項

結(jié)果劇透：
Red Dead: Redemption 2> Monster Hunter: World =Celeste
中間都是廢話铝宵，結(jié)果直接拉到最后打掘。

二、數(shù)據(jù)

由于14年開始TGA才叫這個名字鹏秋，有的屬性也不太好收集尊蚁，所以我們的訓(xùn)練集就用14到17，四年的數(shù)據(jù)侣夷，其實有一些問題横朋，之后也能看出來。

下圖展示了部分?jǐn)?shù)據(jù)百拓。

數(shù)據(jù)概覽

屬性

Year:就是獲獎的年份琴锭，只有2014到2018年這個范圍。
Platform:游戲運行的平臺衙传，但是數(shù)據(jù)太少了决帖，也沒分太清，如果同時上了Xbox和PS就當(dāng)他是全平臺吧粪牲。也許有寫錯平臺的古瓤。
Developer:開發(fā)商，我們都知道好的開發(fā)商大概率做出好的游戲腺阳。不過由于數(shù)據(jù)量較少落君，所以出現(xiàn)過兩次以上的開發(fā)商并不多。
Publisher：發(fā)行商亭引，有時候開發(fā)商和發(fā)行商就一個绎速，育碧、任天堂焙蚓、暴雪有幾款游戲就是這樣纹冤。
Gamerankings:GameRankings是一個著名的電子游戲評分網(wǎng)站GameRankings綜合其他電子游戲評分網(wǎng)站對每一款電子游戲的評分，并且收集各玩家對每一款游戲的意見及批評购公。(來自百度百科)如果一個游戲有多平臺的得分萌京，選評論數(shù)最多的得分作為該屬性的值。

Gamerankings評分

Metacritic評分

初步統(tǒng)計

平臺

先來看看平臺。

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
df_gamedata=pd.read_csv('data.csv', encoding='gb18030')
df_train = df_gamedata[:-6]
df_test = df_gamedata[-6:]
ax = sns.countplot(x = "Platform", data = df_train)

提名游戲平臺分布

獲獎游戲平臺分布

類型

整體上看宅广，提名游戲大多是角色扮演和動作冒險游戲，這和普遍的認(rèn)識相吻合些举。
ax = sns.countplot(x = "Type", data = df_train)

提名游戲類型分布

獲獎游戲類型分布

銷量

其實驶臊，之前的兩個屬性都算是硬傷，如果可能把VGA的提名數(shù)據(jù)也加進(jìn)來叼丑，可能會使情況好轉(zhuǎn)关翎。
從銷量上看，大部分游戲當(dāng)年的銷量都集中在1000萬以內(nèi)鸠信。
sns.distplot(df_train['Sales'])

提名游戲銷量分布

評分

評分主要統(tǒng)計了Gamerankings的一個評分绰垂，Metacritic的兩個評分室奏，考察分布時，使用的值是這三個評分的加和劲装。

scorelist = np.array([])
for i in range(len(df_train)):
    score = df_train.ix[i].values[5] + df_train.ix[i].values[7] + df_train.ix[i].values[8]
    scorelist = np.append(scorelist, score)
sns.distplot(scorelist)

提名游戲得分分布

scorelist = np.array([])
for i in range(len(df_train)):
    if df_train.ix[i].values[11] == 1:
        score = df_train.ix[i].values[5] + df_train.ix[i].values[7] + df_train.ix[i].values[8]
        scorelist = np.append(scorelist, score)
sns.distplot(scorelist)

獲獎游戲得分分布

獲獎游戲的綜合評分在250-280這個區(qū)間胧沫，得分最高的沒獲獎主要還是因為去年神仙打架的結(jié)果，而每年游戲的水平其實是不均衡的占业，所以年份需要做更好的區(qū)分绒怨。

從以上的結(jié)果看獲獎游戲在平臺、游戲類型纺酸、評分等方面有一定特點窖逗。不過需要承認(rèn)的是，確實數(shù)據(jù)量比較少餐蔬。

隨機森林選取屬性

我們先用隨機森林選一下屬性碎紊，以免分不出來類，本來就這么少的屬性樊诺。直觀來看仗考，雖然我們都認(rèn)為有的開發(fā)商游戲質(zhì)量應(yīng)該是比較過硬的，比如任天堂的第一方词爬、暴雪（不朽秃嗜？），但是數(shù)據(jù)量就這么多，游戲廠商工作室太多也不能年年都有提名锅锨，所以可能沒那么重要叽赊。

from sklearn.ensemble import RandomForestClassifier
label = df_train["Awardornot"]
train = df_gamedata.iloc[:, 1:-1]
#train.head()
X = pd.get_dummies(train)[:-6]
y = label
X = X.values
y = y.values
rnd_clf = RandomForestClassifier(max_features=7,n_jobs=-1, n_estimators=40, bootstrap=True, random_state=42)
rnd_clf.fit(X, y)
f_importance=rnd_clf.feature_importances_
indices = np.argsort(f_importance)[::-1]
print("Feature ranking:")
for f in range(X.shape[1]):
    print("%d. feature %d (%f)" % (f + 1, indices[f], f_importance[indices[f]]))
plt.figure(figsize=(20,8))
plt.title("Feature importances")
plt.bar(range(X.shape[1]), f_importance[indices], color="r", align="center")
plt.xticks(range(X.shape[1]), indices)
plt.xlim([-1, X.shape[1]])
plt.show()

調(diào)參過程沒有展示。結(jié)果如下必搞。

參數(shù)重要性

對于文本屬性的數(shù)據(jù)必指，使用的是one-hot編碼。參考這一結(jié)果恕洲，確定模型使用的屬性是"Name","Year", "Platform", "Gamerankings", "Metacritic-Metascore", "Metacritic-Userscore", "Sales", "Type", "Awardornot"這幾個塔橡。雖然的確最佳游戲每年只有一個，不過Year是否真的會產(chǎn)生影響霜第，值得考慮葛家，經(jīng)過測試，有沒有這個屬性泌类，結(jié)果是一樣的癞谒。

三、模型運用

sgamedata = df_gamedata[["Name","Year", "Platform", "Gamerankings", "Metacritic-Metascore", "Metacritic-Userscore", "Sales", "Type", "Awardornot"]]

KNN

KNN參考：https://blog.csdn.net/qq_36330643/article/details/77532161

from sklearn.preprocessing import scale
from sklearn.cross_validation import KFold
from sklearn.cross_validation import train_test_split
import numpy as np
from sklearn.metrics import accuracy_score, classification_report
from sklearn.neighbors import KNeighborsClassifier
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
#train.head()
X = pd.get_dummies(train)[:-6]
y = label
X = scale(X.values)
y = y.values

#交叉驗證測準(zhǔn)確率
def cv_estimate(k, X, y, kfold=10):
    score = 0
    total_num = 100
    for xloop in range(0, total_num):
        cv = KFold(n = X.shape[0], n_folds = kfold)
        clf = KNeighborsClassifier(n_neighbors=k,metric='euclidean')
        for train, test in cv:
            clf.fit(X[train], y[train])
            y_pred = clf.predict(X[test])
            score=score + accuracy_score(y[test], y_pred)
    score=score / (kfold * total_num)
    return score

#普通的循環(huán)測準(zhǔn)確率
def normal_estimate(k, X, y):
    score = 0
    total_num = 100
    clf = KNeighborsClassifier(n_neighbors=k,metric='euclidean')
    for i in range(total_num):
        clf.fit(X, y)
        y_pred = clf.predict(X)
        score = score + accuracy_score(y, y_pred)
    score = score / total_num
    return score

#選K值
X_train, X_test, y_train, y_test = train_test_split(X,y, stratify=y,test_size=0.20)
k_range = range(1,13)
test_accuracy = []
for k in k_range:
    test_accuracy.append(cv_estimate(k,X_train,y_train,kfold=10))

plt.plot(k_range, test_accuracy)
plt.xlabel("Value of K for KNN")
plt.ylabel("Average Accuracy of Kfold CV")
plt.show()

K和準(zhǔn)確率

#所以選個4吧
clf = KNeighborsClassifier(n_neighbors=4,metric='euclidean')
clf.fit(X, y)
test = pd.get_dummies(train)[-6:]
result = clf.predict(test)
result
-----------------------------------------------------------------------------------------------
result: array([0., 0., 0., 0., 0., 0.])

KNN覺得今年六個都不配末誓。

決策樹

決策樹參考：https://blog.csdn.net/jiaoyangwm/article/details/79525237

from sklearn.model_selection import validation_curve
from sklearn.tree import DecisionTreeClassifier
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
X = pd.get_dummies(train)[:-6]
y = label
X = X.values
y = y.values
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,stratify=y, random_state=42)
dtc=DecisionTreeClassifier() 
train_score,validation_score=validation_curve(dtc,X_train,y_train,param_name='max_depth',cv=7,param_range=np.arange(1,21,1)) 
x_axis=np.linspace(1,20,20)  
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')
my_y_ticks = np.arange(0, 20, 1)
plt.xticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

決策樹選參

dtc = DecisionTreeClassifier(max_depth=10)
dtc.fit(X, y)
test = pd.get_dummies(train)[-6:]
result = dtc.predict(test)
R.append(result)
result
----------------------------------------------------------------------------------------------
result: array([0., 1., 0., 0., 0., 1.])

這個array對應(yīng)的游戲順序是提名的排序扯俱。即《刺客信條：奧德賽》、《蔚藍(lán)》喇澡、《戰(zhàn)神》迅栅、《漫威蜘蛛俠》、《怪物獵人：世界》晴玖、《荒野大鏢客2》读存。決策樹認(rèn)為《蔚藍(lán)》和《荒野大鏢客2》有可能獲獎。

隨機森林

隨機森林參考：https://www.cnblogs.com/maybe2030/p/4585705.html

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import validation_curve
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
X = pd.get_dummies(train)[:-6]
y = label
X = X.values
y = y.values
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,stratify=y, random_state=42)
rnd_clf = RandomForestClassifier(max_features=7,n_jobs=-1, bootstrap=True, random_state=42)
train_score,validation_score=validation_curve(rnd_clf,X_train,y_train,param_name='n_estimators',cv=5,param_range=np.arange(10,101,10)) 
x_axis=np.linspace(10,100,10)  
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')  
my_y_ticks = np.arange(0.7, 1, 0.02)
plt.yticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

隨機森林選參

將n_estimators設(shè)置為50呕屎。

rnd_clf = RandomForestClassifier(max_features=7,n_jobs=-1, n_estimators=50, bootstrap=True, random_state=42)
rnd_clf.fit(X, y)
test = pd.get_dummies(train)[-6:]
result = rnd_clf.predict(test)
result
---------------------------------------------------------------------
result: array([0., 0., 0., 0., 0., 1.])

隨機森林認(rèn)為今年的最佳游戲是《荒野大鏢客2》

Logistic回歸

LR參考:https://www.cnblogs.com/alfred2017/p/6627824.html

from sklearn.linear_model import LogisticRegressionCV, LogisticRegression
from sklearn.model_selection import validation_curve
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
X = pd.get_dummies(train)[:-6]
y = label
X = scale(X.values)
y = y.values
lr = LogisticRegressionCV(fit_intercept=True,class_weight = "balanced", cv=10,tol=0.001)
lr.fit(X, y)
test = pd.get_dummies(train)[-6:]
t = scale(test.values)
result = lr.predict(t)
R.append(result)
result
-------------------------------------------------------------------------
result: array([0., 0., 0., 0., 0., 1.])

自帶交叉驗證的認(rèn)為最佳應(yīng)該是《荒野大鏢客2》

lr=LogisticRegression()  
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,stratify=y, random_state=42)
train_score,validation_score=validation_curve(lr,X_train,y_train,param_name='C',cv=10,param_range=np.arange(1,25,1)) 
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
x_axis=np.linspace(0,25,24)  
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')
my_y_ticks = np.arange(0, 25, 1)
plt.xticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

邏輯回歸選參

C就選2吧让簿。

lr = LogisticRegression(fit_intercept=True,class_weight = "balanced",C=2,tol=0.001)
lr.fit(X, y)
test = pd.get_dummies(train)[-6:]
t = scale(test.values)
result = lr.predict(t)
result
-------------------------------------------------------------------------
result: array([0., 0., 0., 0., 0., 1.])

結(jié)果沒有太大變化。

SVM

SVM參考：https://cuijiahua.com/blog/2017/11/ml_8_svm_1.html

linear

SVM kernel參考：https://blog.csdn.net/aspirinvagrant/article/details/45306783

from sklearn.svm import SVC
from sklearn.grid_search import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
#train.head()
X = pd.get_dummies(train)[:-6]
y = label
X = scale(X.values)
y = y.values
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,stratify=y, random_state=42)
params={'gamma':list(np.arange(0.01,0.04,0.005)), 'C':list(np.arange(0.1,5,0.1))}
svm_clf = SVC(kernel="linear")
grid = GridSearchCV(svm_clf, params, cv=3, scoring="accuracy")
grid.fit(X_train,y_train)
#print('網(wǎng)格搜索-最佳度量值:',grid.best_score_) 
#print('網(wǎng)格搜索-最佳模型：',grid.best_estimator_)
print('網(wǎng)格搜索-最佳參數(shù)：',grid.best_params_)  
---------------------------------------------------------------------------
網(wǎng)格搜索-最佳參數(shù)： {'C': 0.1, 'gamma': 0.01}
svm_clf = SVC(class_weight = "balanced", gamma=0.01, C=0.1, kernel="linear")
svm_clf.fit(X,y)
test = pd.get_dummies(train)[-6:]
t = scale(test.values)
result = svm_clf.predict(t)
R.append(result)
result
---------------------------------------------------------------------------
array([0., 0., 0., 0., 0., 1.])

線性kernel預(yù)測《荒野大鏢客2》為年度最佳秀睛。

rbf

svm_clf = SVC(kernel="rbf")
grid = GridSearchCV(svm_clf, params, cv=3, scoring="accuracy")
grid.fit(X_train,y_train)
#print('網(wǎng)格搜索-最佳度量值:',grid.best_score_)
#print('網(wǎng)格搜索-最佳模型：',grid.best_estimator_)
print('網(wǎng)格搜索-最佳參數(shù)：',grid.best_params_)  
---------------------------------------------------------------------------
網(wǎng)格搜索-最佳參數(shù)： {'C': 0.1, 'gamma': 0.01}
svm_clf = SVC(class_weight = "balanced", gamma=0.01, C=0.1, kernel="rbf")
svm_clf.fit(X,y)
test = pd.get_dummies(train)[-6:]
t = scale(test.values)
result = svm_clf.predict(t)
R.append(result)
result
---------------------------------------------------------------------------
array([0., 1., 0., 0., 1., 1.])

rbf kernel認(rèn)為《蔚藍(lán)》尔当、《怪物獵人：世界》、《荒野大鏢客2》都有可能是年度最佳蹂安。

sigmod

svm_clf = SVC(kernel="sigmoid")
grid = GridSearchCV(svm_clf, params, cv=3, scoring="accuracy")
grid.fit(X_train,y_train)
#print('網(wǎng)格搜索-最佳度量值:',grid.best_score_)
#print('網(wǎng)格搜索-最佳模型：',grid.best_estimator_)
print('網(wǎng)格搜索-最佳參數(shù)：',grid.best_params_)  
svm_clf = SVC(class_weight = "balanced", gamma=0.01, C=0.1, kernel="sigmoid")
svm_clf.fit(X,y)
test = pd.get_dummies(train)[-6:]
t = scale(test.values)
result = svm_clf.predict(t)
R.append(result)
result
---------------------------------------------------------------------------
array([0., 1., 0., 0., 1., 1.])

sigmod kernel分出來的結(jié)果也是《蔚藍(lán)》椭迎、《怪物獵人：世界》、《荒野大鏢客2》田盈。

樸素貝葉斯

NB參考：https://blog.csdn.net/moxigandashu/article/details/71480251?locationNum=16&fps=1

from sklearn.naive_bayes import MultinomialNB
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
#train.head()
X = pd.get_dummies(train)[:-6]
y = label
X = X.values
y = y.values
nb_clf = MultinomialNB()
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,stratify=y, random_state=42)
train_score,validation_score=validation_curve(nb_clf,X,y,param_name='alpha',cv=5,param_range=np.arange(0,0.51,0.01)) 
x_axis=np.linspace(0,0.5,51)  
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')  
my_y_ticks = np.arange(0.70, 0.85, 0.02)
plt.yticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()

alpha選擇

nb_clf = MultinomialNB(alpha = 0.1, class_prior=[1,5])
nb_clf.fit(X,y)
test = pd.get_dummies(train)[-6:]
result = nb_clf.predict(test)
R.append(result)
result
---------------------------------------------------------------------------
array([0., 1., 0., 0., 1., 1.])

NB分出來的結(jié)果同樣也是《蔚藍(lán)》畜号、《怪物獵人：世界》、《荒野大鏢客2》允瞧。

神經(jīng)網(wǎng)絡(luò)

理解神經(jīng)網(wǎng)絡(luò)：
https://www.cnblogs.com/charlotte77/p/5629865.html
https://blog.csdn.net/roguesir/article/details/79383122
不太熟简软，只是調(diào)包蛮拔。（其實都是調(diào)包）

import tensorflow as tf
from sklearn.preprocessing import scale
df_gamedata=pd.read_csv('data.csv', encoding='gb18030')
df_train = df_gamedata[:-6]
df_test = df_gamedata[-6:]
sgamedata = df_gamedata[["Name","Year", "Platform", "Gamerankings", "Metacritic-Metascore", "Metacritic-Userscore", "Sales", "Type", "Awardornot"]]
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
x = pd.get_dummies(train)[:-6]
y = label
x = scale(x.values)
Y = list()
for i in y:
    mid = list()
    mid.append(int(i))
    Y.append(mid)
y = Y
test = scale(pd.get_dummies(train)[-6:])
tf_x = tf.placeholder(tf.float32, [None, 14])
tf_y = tf.placeholder(tf.float32, [None, 1])
l1 = tf.layers.dense(tf_x, 40, tf.nn.tanh)
l2 = tf.layers.dense(l1, 20, tf.nn.tanh)
output = tf.layers.dense(l2, 1)
loss = tf.losses.mean_squared_error(tf_y, output)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train_op = optimizer.minimize(loss)
sess = tf.Session() 
sess.run(tf.global_variables_initializer()) 
for step in range(500):
    _, l, pred = sess.run([train_op, loss, output], {tf_x: x, tf_y: y})
    if step % 100 == 0:
        print('loss is: ' + str(l))
pred = sess.run(output,{tf_x:test})
result = list()
for i in pred:
    if i > 0.5:
        result.append(1)
    else:
        result.append(0)
R.append(result)
result
---------------------------------------------------------------------------
loss is: 0.44383866
loss is: 0.012355352
loss is: 0.0054020723
loss is: 0.0019608906
loss is: 0.0006009453

[0, 0, 0, 0, 0, 1]

神經(jīng)網(wǎng)絡(luò)預(yù)測的結(jié)果是......《荒野大鏢客2》。

XGBoost

XGBoost參考：
http://www.reibang.com/p/7467e616f227
https://www.cnblogs.com/mfryf/p/6293814.html

import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from xgboost.sklearn import XGBClassifier
from sklearn.model_selection import validation_curve
label = df_train["Awardornot"]
train = sgamedata.iloc[:, 1:-1]
#train.head()
X = pd.get_dummies(train)[:-6]
y = label
X = scale(X.values)
y = y.values
xbg_clf = XGBClassifier()
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,stratify=y, random_state=42)
train_score,validation_score=validation_curve(xbg_clf,X_train,y_train,param_name='n_estimators',cv=10,param_range=np.arange(1,201,10)) 
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
x_axis=np.linspace(0,200,20)  
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')
my_y_ticks = np.arange(0, 200, 20)
plt.xticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

xgboost n_estimators

n_estimators選擇為60痹升。

xbg_clf = XGBClassifier(n_estimators=60)
train_score,validation_score=validation_curve(xbg_clf,X_train,y_train,param_name='max_depth',cv=10,param_range=np.arange(1,16,1)) 
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
x_axis=np.linspace(1,16,15)  
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')
my_y_ticks = np.arange(0, 16, 1)
plt.xticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

xgboost max_depth

xbg_clf = XGBClassifier(n_estimators=60, max_depth=6)
train_score,validation_score=validation_curve(xbg_clf,X_train,y_train,param_name='gamma',cv=10,param_range=np.arange(0,1,0.1)) 
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
x_axis=np.linspace(0,1,10)  
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')
my_y_ticks = np.arange(0, 1, 0.1)
plt.xticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

xgboost gamma

gamma選擇0.1

xbg_clf = XGBClassifier(n_estimators=60, max_depth=6,gamma=0.1)
train_score,validation_score=validation_curve(xbg_clf,X_train,y_train,param_name='min_child_weight',cv=10,param_range=np.arange(0,10,1)) 
train_score_mean=np.mean(train_score,1)  
validation_score_mean=np.mean(validation_score,1) 
x_axis=np.linspace(0,10,10)  
plt.grid()  
plt.plot(x_axis,train_score_mean,c='r',label='train score')  
plt.plot(x_axis,validation_score_mean,c='g',label='validation score')
my_y_ticks = np.arange(0, 10, 1)
plt.xticks(my_y_ticks)
plt.legend(loc='best')  
plt.show()  

xgboost min_child_weight

可能因為樣本太少县忌，調(diào)參時候準(zhǔn)確率真是劫拗，五花八門......

xbg_clf = XGBClassifier(n_estimators=60, max_depth=6,gamma=0,min_child_weight=1)
xbg_clf.fit(X,y)
test = pd.get_dummies(train)[-6:]
t = scale(test.values)
result = xbg_clf.predict(t)
R.append(result)
result
---------------------------------------------------------------------------
array([0., 0., 0., 0., 1., 1.])

XGBoost投票給了《怪物獵人：世界》以及《荒野大鏢客2》弯予。

四嘉裤、結(jié)果

結(jié)果統(tǒng)計

votelist = list()
vote = pd.DataFrame(R)
for i in range(vote.shape[1]):
    votelist.append(sum(vote[i]))
test = df_gamedata[-6:]['Name']
test = list(test)
print("Award_Predict")
for i in range(6):
    print(test[i],"------------------", str(round((votelist[i]/sum(votelist))*100,2))+"%")

Award_Predict
Assassin's Creed Odyssey ------------------ 0.0%
Celeste ------------------------------------------- 23.53%
God of War ---------------------------------------0.0%
Marvel’s Spider-Man -------------------------- 0.0%
Monster Hunter: World ----------------------- 23.53%
Red Dead: Redemption 2 -------------------- 52.94%

那么這么看起來大表哥有一半以上的可能拿到這個獎項【莨《怪物獵人：世界》以及《蔚藍(lán)》各有約四分之一的可能拿到最佳游戲獎《士妫《奧德賽》感覺上大概率是陪跑绳锅，以前幾屆都提名5個，不知道為什么今年提名6個酝掩。
《戰(zhàn)神》鳞芙、《蜘蛛俠》幾率為0，從游戲素質(zhì)上看期虾，《戰(zhàn)神》也應(yīng)該是有較高可能獲獎的原朝，但是這兩個都為0，主要原因應(yīng)該是PS獨占游戲此前沒有獲得過最佳游戲镶苞，如果進(jìn)一步調(diào)整喳坠，剔除平臺的影響，似乎又不太確切茂蚓，畢竟看影響了整個游戲業(yè)界的一些游戲確實的獨占的壕鹉。

不太確切的分析

《刺客信條：奧德賽》：育碧為這個系列注入了新的活力，從《起源》開始聋涨，他們不斷嘗試新的事物晾浴。此前TGA還是VGA的時候，《刺客信條2》牍白、《刺客信條3》都獲得過提名脊凰，但很難說未來在哪里。
《蔚藍(lán)》：如果獨立游戲獲獎茂腥，應(yīng)該挺有趣的狸涌。
《戰(zhàn)神》、《蜘蛛俠》：應(yīng)該是前幾屆PS獨占游戲沒獲獎础芍，所以預(yù)測成0了杈抢，如果今年有了新的變化，那么數(shù)據(jù)將更豐富一些仑性。
《怪物獵人:世界》：應(yīng)該是系列最佳吧惶楼，暈3D也沒在PC上體驗過。

另外钠怯，在用模型的過程中應(yīng)該也有諸多錯誤佳魔，數(shù)據(jù)量又少，最后這個結(jié)果就這樣了晦炊。

《異度之刃2》竟然連最佳音樂都沒提名鞠鲜。

The Game Awards 2018將于12月6日下午8點30（紐約），北京時間12月7日早上9點30頒獎断国。等待最終結(jié)果吧贤姆。

真實結(jié)果分析

12月7日，The Game Awards年度游戲公布稳衬，最終的獲獎游戲是《戰(zhàn)神》霞捡，這是該游戲系列革新之作，在之前的模型中薄疚，該游戲獲獎的幾率是0弄砍，在之前的分析中也提到這和游戲平臺可能有很大關(guān)系。在去除游戲平臺這一特征后输涕，再進(jìn)行預(yù)測音婶，我們發(fā)現(xiàn)《戰(zhàn)神》獲獎的幾率依然為0，如果再進(jìn)一步分析數(shù)據(jù)莱坎，可以發(fā)現(xiàn)戰(zhàn)神的銷量衣式、評分的確都存在劣勢。

將今年的結(jié)果加入到模型構(gòu)建中檐什，使用的特征不變碴卧，預(yù)測的結(jié)果為：

Assassin's Creed Odyssey ------------------ 0.0%
Celeste ------------------ 11.11%
God of War ------------------ 44.44%
Marvel’s Spider-Man ------------------ 0.0%
Monster Hunter: World ------------------ 16.67%
Red Dead: Redemption 2 ------------------ 27.78%

模型發(fā)生了改變，可能性最高的獲獎游戲依然是《戰(zhàn)神》和《荒野大鏢客2》乃正。但總結(jié)而言住册，不能實現(xiàn)較準(zhǔn)確的預(yù)測根本原因還是數(shù)據(jù)量太少，如果獲獎游戲的平臺瓮具、類型分布更加均衡荧飞，結(jié)果才能更加準(zhǔn)確凡人。