我們在用訓練數據對模型進行擬合時會得到模型的一些參數，但將模型用于新數據時需重設這些參數，并且還需要評估這個模型的實用性。我們可以利用scikit-learn中的一些方法來達到這么目的。
我們本次所用到的數據是威斯康星乳腺癌數據（滿大街了都）
先加載數據吧。可以利用pandas直接去UCI網站讀取
import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data',header=None)
接下來我們可以觀察下數據
df.head()
可以看到該數據有32列，第二列是關于樣本的診斷結果（M代表惡性，B代表良性），第3列-32列包含了30個從細胞核照片中提取、用實數值標識的特征
#觀察缺失值,可以看到沒有缺失值
import missingno
missingno.matrix(df)
對于分類模型來講，目標變量值最好為數值，比如男為1，女為0。我們可以觀察到該數據集的目標變量為M和B,要將其轉化為0,1.而我們該興趣的是惡性的，所以要將M變為1，B變為0
#先將數據分為特征列和目標列
X=df.loc[:,2:].values
y=df.loc[:,1].values
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y=le.fit_transform(y)
被sklearn的LabelEncoder轉換器轉換之后，類標被存儲在一個數組y中，此時M被標識為1，B為0.我們可以通過transform方法來顯示虛擬類標
le.transform(['M','B'])
Out:array([1, 0], dtype=int64)
也可以查看下類的比例情況
pd.Series.value_counts(y)
接下來將數據分為訓練集和測試集
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1)
1.基于流水線的工作流
接下來我們可以利用Pipeline類來進行工作流
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
pipe_lr = Pipeline([('scl',StandardScaler()),('pca',PCA(n_components=2)),('clf',LogisticRegression(random_state=1))])
pipe_lr.fit(X_train,y_train)
print("Test Accuracy:%.3f"%pipe_lr.score(X_test,y_test))
Out:Test Accuracy: 0.947
Pipeline對象采用元組的序列作為輸入，其中每個元組中的第一個值為一個字符串，可以是任意的標識符，我們通過它來訪問流水線中的元素，而元組的第二個值則為scikit-learn中的一個轉換器或者評估器。我們以上的例子的執行順序是先用StandardScaler將數據集標準化，然后將數據集降維到2維空間，然后再用邏輯回歸擬合訓練集。
2.使用K折交叉驗證評估模型性能
如果一個模型過于簡單，可能會面試欠擬合（高偏差）問題，但是如果模型太過復雜，又會面臨過擬合（高方差）問題。所以我們必須要借助一些手段對模型進行評估。其中最常用的就是K折交叉驗證，該方法魯棒性好。可以比較好的應對噪聲等問題
k折交叉驗證的原理就是我們不重復地隨機將訓練數據集劃分為K個，其中K-1個用于模型的訓練，剩余的1個用于測試。重復此過程K次，我們就可以得到K個模型對模型性能的評價
K折交叉驗證使用無重復抽樣技術.通常情況下，我們將K折交叉驗證用于模型的調優，也就是找到使得模型泛化性能最優的超參值。一旦我們找到了滿意的超參值，我們就可以在全部的訓練集上重新訓練模型，并使用獨立的測試集對模型性能做出最終評價。k折交叉驗證中K的值一般是10，對于大多數數據來說是比較合理的。但是如果數據集比較小，建議加大K值。這可以是模型評價時得到較小的偏差（不怎么會欠擬合），但是方差會變大（過擬合）。當數據集非常小時，建議用留一交叉驗證。留一交叉驗證是將數據集劃分的數量等同于樣本量（k=n）,這樣每次只有一個樣本用于測試。如果數據集較大，可以減少K值。在scikit-learn中可以用KFold來進行k折交叉驗證。但是當類別比例相差較大時，建議用分層交叉驗證。在分層交叉驗證中，類別比例在每個分塊中得以保持，這使得每個分塊中的類別比例與訓練集的整體比例一致。
#分層K折交叉驗證
#當我們使用kfold迭代器在k個塊中進行循環時，使用train中返回的索引去擬合邏輯斯底回歸流水線。通過流水線，我們可以保證
#每次迭代時樣本都得到標準化縮放，然后使用test索引計算模型的準確性和f1值，并存放到兩個列表中，用于計算平均值和標準差
import numpy as np
from sklearn.model_selection import StratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import f1_score
pipe_lr = Pipeline([('scl',StandardScaler()),('clf',LogisticRegression(random_state=1))])
kfold = StratifiedKFold(n_splits=10,random_state=1) #通過n_splits來設置塊的數量
scores=[]
f1_scores=[]
for k,(train,test) in enumerate(kfold.split(X_train,y_train)):
pipe_lr.fit(X_train[train],y_train[train])
p_pred = pipe_lr.predict(X_train[test])
f1_sc = f1_score(y_true=y_train[test],y_pred=p_pred)
f1_scores.append(f1_sc)
score=pipe_lr.score(X_train[test],y_train[test])
scores.append(score)
print('Fold: %s, Class dist.: %s,Acc: %.3f,f1 score:%.3f' %(k+1,np.bincount(y_train[train]),score,f1_sc))
得到的結果為：
print('CV accuracy: %.3f +/- %.3f' %(np.mean(scores),np.std(scores)))
print("CV f1 score:%.3f +/- %.3f"%(np.mean(f1_scores),np.std(f1_scores)))
也可以使用sklearn中的cross_val_score直接將上述的結果計算出來
#sklearn方法求分成k折交叉驗證
#cross_val_score可以將不同分塊的性能評估分布到多個CPU上處理。如果將n_jobs參數設置為1，則與StratifiedKFold一樣，
#只使用一個CPU對性能進行評估，如果設置為-1，則可利用計算機所有的CPU并行地進行計算。還可通過scoring參數來計算
#不同的評估指標
from sklearn.model_selection import cross_val_score
scores=cross_val_score(estimator=pipe_lr,
X=X_train,
y=y_train,
scoring="accuracy",
cv=10,
n_jobs=1)
print("CV accuracy scores: %s" % scores)
print('CV accurary:%.3f +/- %.3f'%(np.mean(scores),np.std(scores)))
- cross_val_score中scoring參數可以取以下這些：Valid options are ['accuracy', 'adjusted_mutual_info_score', 'adjusted_rand_score', 'average_precision', 'completeness_score', 'explained_variance', 'f1', 'f1_macro', 'f1_micro', 'f1_samples', 'f1_weighted', 'fowlkes_mallows_score', 'homogeneity_score', 'mutual_info_score', 'neg_log_loss', 'neg_mean_absolute_error', 'neg_mean_squared_error', 'neg_mean_squared_log_error', 'neg_median_absolute_error', 'normalized_mutual_info_score', 'precision', 'precision_macro', 'precision_micro', 'precision_samples', 'precision_weighted', 'r2', 'recall', 'recall_macro', 'recall_micro', 'recall_samples', 'recall_weighted', 'roc_auc', 'v_measure_score']
計算f1值
from sklearn.model_selection import cross_val_score
f1_scores = cross_val_score(estimator=pipe_lr,X=X_train,y=y_train,scoring='f1',cv=10,n_jobs=-1)
print('CV f1 scores:%s'%f1_scores)
計算auc值
from sklearn.model_selection import cross_val_score
aucs = cross_val_score(estimator=pipe_lr,X=X_train,y=y_train,scoring='roc_auc',cv=10,n_jobs=-1)
print('CV auc scores:%s'%aucs)
3.通過學習及驗證曲線來調試算法
3.1通過學習曲線，我們可以判定算法偏差和方差問題。
將模型的訓練及準確性驗證看做是訓練數據集大小的函數，并繪制圖像，我們可以比較容易的看出模型是高偏差還是高方差的問題，以及收集更多的數據是否有助于解決問題
上圖中左一是個高偏差模型，準確率和交叉驗證準確率都很低，表示模型并沒有很好地擬合數據。解決辦法：增加模型中參數的數量。比如收集或構建額外特征，或者降低線性模型比如邏輯回歸和線性SVM的正則化程度。正則化是解決共線性（特征間高度相關）的一個好辦法，他可以過濾掉噪聲，并最終防止過擬合。正則化是引入額外的信息來對極端參數做出懲罰。最常用的是L2正則化，也有L1正則化。特征縮放（標準化，歸一化）之所以重要，其中原因之一就是正則化，為了使得正則化起作用，需要確保所有特征的衡量標準保持統一。
在以上的例子中，我們使用的是Logistic回歸分類器，在該分類器中，我們可以調整的超參有：
- penalty：正則懲罰項，可以選L1或者L2.默認是L2
- C:正則化倒數，C越小，代表正則化程度越高
- solver:有四個值可選：'netton-cg','lbfgs',liblinear','sag'.默認是liblinear，該方法對數據量小的數據效果較好，且只能處理兩分類。sag在數據量比較大的時候速度 較快。面對多分類的話，除了liblinear之外其他都可以，且另外幾個只能支持L2懲罰項。
上圖中右一是個高方差模型，訓練準確率和交叉驗證準確率之間有很大差距。針對此問題的解決方案是：收集更多的訓練數據（降低模型過擬合的概率）或者降低模型的復雜度，比如增加正則化程度，降低特征的數量等。
對于不適合正則化的模型，可以通過特征選擇或者特征提取降低特征的數量
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
from sklearn.model_selection import learning_curve
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
pipe_lr = Pipeline([('scl',StandardScaler()),('clf',LogisticRegression(penalty='l2',random_state=0))])
train_sizes,train_scores,test_scores = learning_curve(
estimator=pipe_lr,
X=X_train,
y=y_train,
train_sizes = np.linspace(0.1,1.0,10),
cv=10,
n_jobs=-1)
train_mean = np.mean(train_scores,axis=1)
train_std = np.std(train_scores,axis=1)
test_mean = np.mean(test_scores,axis=1)
test_std = np.std(test_scores,axis=1)
plt.plot(train_sizes,train_mean,color='blue',marker='o',markersize=5,label='training accuracy')
plt.fill_between(train_sizes,train_mean+train_std,train_mean-train_std,alpha=0.15,color='blue')
plt.plot(train_sizes,test_mean,color='green',linestyle='--',markersize=5,label='validation accuracy')
plt.fill_between(train_sizes,test_mean+test_std,test_mean-test_std,color='green',alpha=0.15)
plt.grid()
plt.xlabel('Number of training samples')
plt.ylabel('Accuracy')
plt.legend(loc='best')
plt.ylim([0.8,1.0])
通過上面的代碼，我們可以得到下面的學習曲線
通過learning_curve中的train_size參數，我們可以控制用于生成學習曲線的樣本的絕對或相對數量。在此，通過設置train_size=np.linspace(0.1,1,10)來使用訓練集上等距間隔的10個樣本。默認情況下，learning_curve函數使用分層K折交叉驗證來計算準確率。
3.2通過驗證曲線，我們可以判定算法欠擬合和過擬合問題。
驗證曲線和學習曲線相似，不過繪制的不是樣本大小和訓練準確率、測試準確率之間的函數關系，而是準確率與模型參數之間的關系
from sklearn.model_selection import validation_curve
param_range = [0.001,0.01,0.1,1.0,10.0,100.0]
pipe_lr = Pipeline([('scl',StandardScaler()),('clf',LogisticRegression(penalty='l2',random_state=0))])
train_scores,test_scores = validation_curve(
estimator=pipe_lr,
X=X_train,
y=y_train,
param_name='clf__C',
param_range=param_range,
cv=10)
train_mean = np.mean(train_scores,axis=1)
train_std = np.std(train_scores,axis=1)
test_mean = np.mean(test_scores,axis=1)
test_std = np.std(test_scores,axis=1)
plt.plot(param_range,train_mean,color='blue',marker='o',markersize=5,label='training accuracy')
plt.fill_between(param_range,train_mean+train_std,train_mean-train_std,color='blue',alpha=0.15)
plt.plot(param_range,test_mean,color='green',linestyle='--',markersize=5,label='validation accuracy')
plt.fill_between(param_range,test_mean+test_std,test_mean-test_std,color='green',alpha=0.15)
plt.grid()
plt.xscale('log') #設置X軸的縮放比例，可以用'log','linear','logit','symlog'
plt.legend(loc='best')
plt.xlabel('Parameter C')
plt.ylabel('Accuracy')
plt.ylim([0.8,1])
通過上面的代碼，得到下面的圖形：
4.使用網絡搜索調優模型
在機器學習中，有兩類參數：一是通過訓練數據學習得到的參數，如Logistic回歸中的回歸系數；二是算法中需要單獨進行優化的參數，即調優參數，也稱超參，如邏輯回歸中的正則化系數，決策樹中的深度系數。
我們之前是通過驗證曲線來得到較優的C值，但是通過圖形來得出最優值會帶點主觀性，所以我們可以利用網格搜索，通過明確的結果尋找最優的超參值的組合
from sklearn.model_selection import GridSearchCV
pipe_lr = Pipeline([('scl',StandardScaler()),('clf',LogisticRegression(random_state=0))])
param_range=[0.0001,0.001,0.01,0.1,1,10,100,1000]
param_penalty=['l1','l2']
param_grid=[{'clf__C':param_range,'clf__penalty':param_penalty}]
gs = GridSearchCV(estimator=pipe_lr,
param_grid=param_grid,
scoring='f1',
cv=10,
n_jobs=-1)
gs = gs.fit(X_train,y_train)
print(gs.best_score_)
print(gs.best_params_)
得到的結果為：
0.970063106828
{'clf__C': 0.1, 'clf__penalty': 'l2'}
可以看到C值和penalty的最優組合是0.1和l2。
在上述代碼中，我們是在流水線中調優的，所以在GridSearchCV的param_grid參數以字典的方式定義待調優的參數時，我們填寫的是clf__C(英文狀態下兩個下劃線)和clf__penalty,這個clf在流水線中代表定義的邏輯回歸，后面代表的是要調優的參數。
在訓練數據集上完成網格搜索后，可以通過best_score_屬性得到你在scoring參數中指定的指標的最優值，而具體的待調優的參數信息可通過best_params_屬性得到
最后我們可以通過GridSearchCV對象的best_estimator_屬性對最優模型進行性能評估
from sklearn.metrics import f1_score
clf = gs.best_estimator_
clf.fit(X_train,y_train)
y_pred = clf.predict(X_test)
print('Test f1 score:%.3f'%f1_score(y_true=y_test,y_pred=y_pred))
得到的結果為：
Test f1 score:0.963
也可以這樣：
from sklearn.model_selection import cross_val_score
clf=gs.best_estimator_
clf.fit(X_train,y_train)
f1_scores = cross_val_score(estimator=clf,X=X,y=y,scoring='f1',cv=10,n_jobs=-1)
print("CV f1 score:%.3f"%np.mean(f1_scores))
網格搜索雖然很給力，但是計算速度不怎么好。因為它通過對我們指定的不同超參列表進行暴力窮舉搜索，并計算評估每個組合對模型性能的影響，以獲得參數的最優組合在sklearn中，還有其他的方法，具體可以參考：http://scikit-learn.org/stable/modules/grid_search.html#exhaustive-grid-search
5.通過嵌套交叉驗證選擇算法
在嵌套交叉驗證的外圍循環中，我們將數據劃分為訓練塊和測試塊，用于模型選擇的內部循環中，我們基于外圍的訓練塊使用K折交叉驗證。在完成模型的選擇后，測試塊用于模型性能的評估。在上圖中是5X2交叉驗證，適用于計算性能要求比較高的大規模數據集。
接下來我們使用邏輯回歸和隨機森林來對這個數據集進行嵌套交叉驗證
#邏輯回歸
from sklearn.model_selection import cross_val_score,GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
pipe_lr = Pipeline([('scl',StandardScaler()),('clf',LogisticRegression(random_state=0))])
param_range=[0.0001,0.001,0.01,0.1,1,10,100,1000]
param_penalty=['l1','l2']
param_grid = [{'clf__C':param_range,'clf__penalty':param_penalty}]
clf_gs = GridSearchCV(estimator=pipe_lr,param_grid=param_grid,scoring='f1',cv=10,n_jobs=-1)
clf_f1_scores = cross_val_score(estimator=clf_gs,X=X,y=y,scoring='f1',cv=5)
print('CV clf f1 score:%.3f +/- %.3f'%(np.mean(clf_f1_scores),np.std(clf_f1_scores)))
結果為：
CV clf f1 score:0.969 +/- 0.012
#隨機森林
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier(random_state=0)
#在bootstap為True和False的情況下的參數組合
rfc_grid=[{'n_estimators':[3,10,15],'max_depth':[1,2,3,4,5,6,7,None]},
{'bootstrap':[False],'n_estimators':[3,10],'max_depth':[1,2,3,4,5,6,7,None]}]
rfc_gs = GridSearchCV(estimator=rfc,param_grid=rfc_grid,cv=10,scoring='f1',n_jobs=-1)
rfc_f1_scores = cross_val_score(estimator=rfc_gs,X=X,y=y,scoring='f1',cv=5)
print('CV clf f1 score:%.3f +/- %.3f'%(np.mean(rfc_f1_scores),np.std(rfc_f1_scores)))
結果為：
CV clf f1 score:0.948 +/- 0.023
從結果來看，邏輯回歸的效果似乎更好一點哦
- 既然用到了隨機森林，那我們講一下隨機森林（屬于bagging集成學習）
隨機森林可以視為多顆決策樹的集成，魯棒性更強，泛化能力更好，不易產生過擬合現象。但是噪聲比較大的情況下會過擬合。可以簡單的將隨機森林算法概括為四個簡單步驟：
- 使用bootstrap抽樣方法隨機選擇N個樣本用于訓練（從訓練集中隨機可重復地選擇N個樣本）
2.使用第1步選定的樣本來構造一個決策樹。節點劃分規則如下：
（1）不重復地隨機選擇d個特征
（2）根據目標函數的要求，如最大化信息增益，使用選定的特征對節點進行劃分
3.重復上述過程1~2000次
4.匯總每棵樹的類標進行多數投票。比如對于二分類類標，總共有15棵樹，有10棵樹分為1,5棵樹分為0，則多數服從少數，最終結果為1
隨機森林相對于決策樹來講沒有那么好的可解釋性，但其顯著優勢在于不必擔心超參值的選擇.不需要對隨機森林進行剪枝，因為相對于單棵決策樹來講，集成模型對噪聲的魯棒性更好
在實踐中，我們真正需要關心的參數是為構建隨機森林所需的決策樹數量（即第3步驟）。通常情況下，決策樹的數量越多，隨機森林整體的分類表現越好，但這會增加計算成本。其他可調的參數有：
1.n_estimators : 隨機森林中樹的數量，也就是弱分類器的數量
2.criterion: 兩種衡量分割效果的方法，有基尼系數法和熵法(entropy)。
3.max_features : 尋找最佳分割時要考慮特征變量的個數
4.max_depth ：設置決策樹最大深度，如果不設置該變量，決策樹一直延伸直至每個葉節點都完美分類，或者所有葉節點內數量達到min_samples_split指定的樣本數量。
5.min_samples_split: 分割一個內部節點所要求的最低樣本含量，低于這個數量就不再分割了。
6.max_leaf_nodes : 葉節點最大數目，默認不限制葉節點的最大數量。
7.min_impurity_split: 如果純度還高于閾值，繼續分割，如果達到閾值，成為葉節點。
8.bootstrap : 在生長樹的時候是否采用bootstrap的方法,默認是是True
6.不同的性能評價指標
理論部分可以看下這個分類算法模型評估理論篇
6.1混淆矩陣
先利用網格搜索算出最優的參數
from sklearn.metrics import confusion_matrix,classification_report
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
pipe_lr = Pipeline([('scl',StandardScaler()),('clf',LogisticRegression(random_state=0))])
param_range = [0.00001,0.0001,0.001,0.01,0.1,1,10,100,1000]
param_penalty = ['l1','l2']
param_grid=[{'clf__C':param_range,'clf__penalty':param_penalty}]
clf_gs = GridSearchCV(estimator=pipe_lr,param_grid=param_grid,scoring='f1',cv=10,n_jobs=-1)
gs = clf_gs.fit(X_train,y_train)
print(gs.best_params_)
結果為：
{'clf__C': 0.1, 'clf__penalty': 'l2'}
clf = clf_gs.best_estimator_
clf.fit(X_train,y_train)
y_pred = clf.predict(X_test)
confmat=confusion_matrix(y_true=y_test,y_pred=y_pred)
class_report = classification_report(y_true=y_test,y_pred=y_pred)
print(confmat)
print('******************************')
print(class_report)
圖片上的就是混淆矩陣
我們還可以可視化混淆矩陣
fig,ax=plt.subplots(figsize=(2.5,2.5))
ax.matshow(confmat,cmap=plt.cm.Blues,alpha=0.3)
for i in range(confmat.shape[0]):
for j in range(confmat.shape[1]):
ax.text(x=j,y=i,s=confmat[i,j],va='center',ha='center')
plt.xlabel('predicted label')
plt.ylabel('true label')
結果如下：
6.2精度和召回率
from sklearn.metrics import precision_score #精度
from sklearn.metrics import recall_score,f1_score #召回率,f1分數
print('Precision:%.3f'%precision_score(y_true=y_test,y_pred=y_pred))
print('Recall:%.3f'%recall_score(y_true=y_test,y_pred=y_pred))
print('f1:%.3f'%f1_score(y_true=y_test,y_pred=y_pred))
結果：
Precision:1.000
Recall:0.929
f1:0.963
#因為scikit-learn中將正類類標標識為1.如果想指定一個不同的正類類標來評分的話，可以如下操作
from sklearn.metrics import make_scorer,f1_score
scorer = make_scorer(f1_score,pos_label=0)
gs = GridSearchCV(estimator=pipe_svc,param_grid=param_grid,scoring=scorer,cv=10)
以上這些也可以通過cross_val_score中的scoring參數指定計算出來
6.ROC曲線
from sklearn.metrics import roc_curve,auc
from scipy import interp
X_train2=X_train[:,[4,14]]
cv = StratifiedKFold(y_train,n_folds=3,random_state=1)
fig=plt.figure(figsize=(7,5))
mean_tpr = 0.0
mean_fpr = np.linspace(0,1,100)
all_tpr=[]
for i,(train,test) in enumerate(cv):
probas = pipe_lr.fit(X_train2[train],
y_train[train]).predict_proba(X_train2[test])
fpr,tpr,thresholds = roc_curve(y_train[test],probas[:,1],pos_label=1)
mean_tpr+=interp(mean_fpr,fpr,tpr)
mean_tpr[0]=0.0
roc_auc=auc(fpr,tpr)
plt.plot(fpr,tpr,lw=1,label='ROC fold %d (area=%0.2f)'%(i+1,roc_auc))
plt.plot([0,1],[0,1],linestyle='--',color=(0.6,0.6,0.6),label='random guessing')
mean_tpr/=len(cv)
mean_tpr[-1]=1.0
mean_auc=auc(mean_fpr,mean_tpr)
plt.plot(mean_fpr,mean_tpr,'k--',label='mean ROC(area=%0.2f)'%mean_auc,lw=2)
plt.plot([0,0,1],[0,1,1],lw=2,linestyle=':',color="black",label='perfect performance')
plt.xlim([-0.05,1.05])
plt.ylim([-0.05,1.05])
plt.xlabel('false positive tate')
plt.ylabel('true positive rate')
plt.title('Receiver Operator Characteristic')
plt.legend(loc='best')
plt.show()
結果為：
