機器學習_ML_模型評估與超參數調校
預處理_標準化_降維_模型評估指標可搭配閱讀
利用pipeline來簡化作業
載入威斯康辛乳癌數據
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data', header=None)
# 透過numpy與labelencoder來轉換後面30個特徵
X = df.loc[:, 2:].values #第一個參數是數據量，第二個參數是欄位數
y = df.loc[:, 1].values
le = LabelEncoder()
y = le.fit_transform(y)
# 記得print出來看，才知道數值的變化!
惡性為1，良性為0!
le.transform(['M', 'B'])
透過呼叫LabelEncoder的transform來完成類別標籤字串轉換對應數字!
接著一樣將資料拆分成訓練資料集與測試資料集!
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)
利用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))
透過pipeline，我們不需要再將資料先標準化，再降維，再來訓練，而是可以直接一個流程完成!
在pipeline中，首先會將資料透過StandardScaler做fit與transform，然後將轉換資料給PCA做fit與transform再將資料給LogisticRegression做fit!
這中間是沒有限制流程階數，只有限制中間過程要能fit與transform，最後要能fit即可!
使用k折交叉驗證評估模型效能
- 保留交叉驗證法
- 拆分原始數據為訓練資料與驗證資料
- 較好的方式，分為訓練、驗證、測試三個資料集
- k折交叉驗證法
- 使用k個訓練集的子集合，重複k次保留法
- 分層k折交叉驗證法(stratified k-fold cross-vlidation)
- 可以產生較好的偏誤與變異數估計，特別在類別的大小不一致的時候
- 每折數據中的類別大小比例與原始訓練數據集中的類別大小比率相同
在k折交叉驗證法中，會隨機分割訓練資料集成k份，其中樣本不放回。k-1折當做訓練資料，1折用於測試，並且重覆k次，會得到k個模型跟k個模型的效能評估!
在取得最好最滿意的超參數值之後，就可以將所有的訓練資料集重新以該參數訓練過，再用測試資料集做最後的驗證!
一般來說，k值會是10，一般!!當數據小的時候，加大折數會是一個不錯的方式!
只是k過大，相對的會造成變異數也較大!並且執行成本也會增大!
實作分層k折交叉驗證法
from sklearn.cross_validation import StratifiedKFold
kfold = StratifiedKFold(y=y_train, n_folds=10, random_state=1)
scores = []
for k, (train, test) in enumerate(kfold):
pipe_lr.fit(X_train[train], y_train[train])
score = pipe_lr.score(X_train[test], y_train[test])
scores.append(score)
print('Fold: %s, Class dist.: %s, Acc: %.3f' % (k+1,
np.bincount(y_train[train]), score))
print('cv accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))
# 平均正確率與估計標準差
n_fold = 定義折數
實作計分器(scorer)
from sklearn.cross_validation import cross_val_score
scores = cross_val_score(estimator=pipe_lr,
X=X_train,
y=y_train,
cv=10,
n_jobs=1)
print('cv accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))
當然你也可以設置k=20(20折)
利用學習曲線與驗證曲線來對演算法除錯
| 類型 | 說明 | 解法 |
|---|---|---|
| 高偏誤 | 對訓練資料集與驗證資料集的正確率都非常低 | 增加模型參數個數(如收集或增加額外的特徵或降低正規化程度) |
| 高變異性(過適) | 訓練資料與驗證資料正確率差異過大 | 收集更多訓練數據或是增加正規化、降維 |
實作學習曲線
學習曲線用來診斷是否有過適的問題!import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve
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='--',
marker='s', markersize=5,
label='validation accuracy')
plt.fill_between(train_sizes,
test_mean + test_std,
test_mean - test_std,
alpha=0.15, color='green')
plt.grid()
plt.xlabel('number of training samples')
plt.ylabel('accuracy')
plt.legend(loc='lower right')
plt.ylim([0.8, 1.0])
plt.show()
train_sizes = np.linspace(0.1, 1.0, 10):表示用10個相對均勻的區間來分隔訓練集
預設情況下learning_curvead會使用分層k折交叉驗證來計算準確性!
實作驗證曲線
from sklearn.model_selection import validation_curve
param_range = [0.001, 0.01, 0.1, 1.0, 10.0, 100.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, alpha=0.15,
color='blue')
plt.plot(param_range, test_mean,
color='green', linestyle='--',
marker='s', markersize=5,
label='validation accuracy')
plt.fill_between(param_range,
test_mean + test_std,
test_mean - test_std,
alpha=0.15, color='green')
plt.grid()
plt.xscale('log')
plt.legend(loc='lower right')
plt.xlabel('parameter C')
plt.ylabel('accuracy')
plt.ylim([0.8, 1.0])
plt.tight_layout()
plt.show()
validation_curve函數預設為分層k折交叉驗證法，而我們指定了LogisticRegression的C參數(反正規化參數)，再透過param_range來設置反正規化參數的範圍值
透過圖面也可以發現，提高正規化強度(即C值較小)的時候會造成低度過適的問題，而降低的話會造成高度過適，故C=0.1的時候較合適!
利用網格搜尋微調機器學習模型
機器學習中有兩種參數，從訓練數據得知的參數(邏輯斯回歸)與用來最佳化學習演算法的參數(超參數)。模型的超參數亦指調校參數，如決策樹的深度與邏輯斯迴歸的正規化參數網格搜尋的觀念就是暴力破解，就跟你在破人家的密碼一樣，我給他100萬個組合讓他去一個一個TRY!
網格搜尋會依著你給的參數群去做計算，找出最好的超參數值組!
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
pipe_svc = Pipeline([('scl', StandardScaler()),
('clf', SVC(random_state=1))])
param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]
param_grid = [{'clf__C': param_range,
'clf__kernel': ['linear']},
{'clf__C': param_range,
'clf__gamma': param_range,
'clf__kernel': ['rbf']}]
gs = GridSearchCV(estimator=pipe_svc,
param_grid=param_grid,
scoring='accuracy',
cv=10,
n_jobs=-1)
gs = gs.fit(X_train, y_train)
print(gs.best_score_)
print(gs.best_params_)
計算之後得知，C為0.1的時候且使用kernel為linear的時候得到正確率最佳!
準確率為0.97!
print(gs.best_estimator_)
這是透過網格搜尋產生的最佳模型!
我們再透過最佳模型來做測試數據的計算!
clf = gs.best_estimator_
clf.fit(X_train, y_train)
print('test accuracy: %.3f' % clf.score(X_test, y_test))
利用巢狀交叉驗證選擇演算法
透過網格搜尋結合k折可以找到超參值的最佳模型!而透過巢狀交叉驗證可以讓我們從不同演算法中取得選擇。
巢狀交叉驗證又稱5x2交叉驗證法()外折(outer fold) 將資料分訓練折與測試折
內折(inner fold) 使用訓練折來選擇模型，將訓練折再分訓練折與驗證折
模型選擇之後就用測試資料集來評估模型效能。
gs = GridSearchCV(estimator=pipe_svc,
param_grid=param_grid,
scoring='accuracy',
cv=5,
n_jobs=-1)
scores = cross_val_score(gs, X, y, scoring='accuracy', cv=5) scores
np.mean(scores)
np.std(scores)
from sklearn.tree import DecisionTreeClassifier
gs = GridSearchCV(
estimator = DecisionTreeClassifier(random_state=0),
param_grid=[
{'max_depth':[1, 2, 3, 4, 5, 6, 7, None]}],
scoring = 'accuracy',
cv=5)
scores = cross_val_score(gs,
X_train,
y_train,
scoring = 'accuracy',
cv=5)
scores
np.mean(scores)
np.std(scores)
這邊可以看到，在巢狀交叉驗證的SVM模型效能是高於決策樹!
混淆矩陣
這是一個描述演算法效能的矩陣真的真(左上TP)，真的假(右下TN)，假的真(左下FP)，假的假(右上FN)!
from sklearn.metrics import confusion_matrix
pipe_svc.fit(X_train, y_train)
y_pred = pipe_svc.predict(X_test)
confmat = confusion_matrix(y_true=y_test, y_pred=y_pred)
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')
plt.tight_layout()
plt.show()
錯誤率(ERR):所有假/總預測數
(FP+FN)/(FP+FN+TP+TN)
正確率(ACC):所有真/總預測數
(TP+TN)/(FP+FN+TP+TN) 或 1-ERR
真真率(TPR)與假真率(FPR)處理不平衡類別有效的能效指標
TPR=TP/(FN+TP)
FPR=FP/(FP+TN)
精準度(PRE)
PRE=TP/(TP+FP)
召回率(REC)
REC=TP/(FN+TP)
F1分數
F1 = 2*(PRE*REC/(PRE+REC))
from sklearn.metrics import precision_score,recall_score,f1_score
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))
另外可籍由設置scoring參數來使用GridSearchCV裡面的計分指標!
要注意一點，在scikit-learn中，類別標籤為1的是屬正類!
如果需要有非1的分類器，就要調用另一個lib
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)
接收操作特徵圖(ROC)
用來選擇分類模型的一個工具主要針對假的真與真的真的機率來做選擇!
ROC圖的對角線可被解釋成隨機猜測低於對角線的分類器模型就是效能比隨機猜測更差的模型。
一個完美的分類器，應該要落在圖的左上角，真的真率為1!
再利用ROC圖來計算AUC(曲線下面積)做效能特徵。
利用上面的邏輯斯迴歸管線，我們來做ROC曲線，並且將驗證折數減為三折!
from sklearn.metrics import roc_curve, auc
from scipy import interp
X_train2 = X_train[:,[4, 14]]
cv = StartifiedKFold(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 (arec = %0.2f)' % mean_auc, lw=2)
plt.plot([0, 0, 1], [0, 1, 1], lw=2, linestyle=':', color='black', label='performance')
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
plt.xlabel('false positive rate')
plt.ylabel('true positive rate')
plt.legend(loc='lower right')
plt.show()
在每次的分折迭代中，我們利用了roc_curve來計算pipe_lr管線中邏輯斯迴歸的效能。
再用scipy中interp函數來繪製平均ROC曲線，並叫用auc來計算曲線下面積!
計算ROC曲線下面積
pipe_svc = pipe_svc.fit(X_train2, y_train)
y_pred2 = pipe_svc.predict(X_test[:, [4,14]])
from sklearn.metrics import roc_auc_score
from sklearn.metrics import accuracy_score
roc_auc_score(y_true=y_test, y_score=y_pred2)
accuracy_score(y_true=y_test, y_pred=y_pred2)
多類別分類的計分指標
宏觀平均與微觀平均為多類別分類的計分指標微觀平均由系統中各別樣本的混淆矩陣所計算出來!
精準度得分的微觀平均=(TP1…+TPk)/(TP1…+TPk+FP1…+FPk)
宏觀平均=(PRE1+…+PREk)/k
假如每個樣本實例都有一定的重要性，那就用微觀，而宏觀則視所有類別都有相同的重要性!
scikit-learn中用二元效能指標來評估多元的話，預設為加權宏觀平均!
pre_scorer = make_scorer(score_func=precision_score, pos_label=1, greater_is_better=True, average='micro')
沒有留言:
張貼留言