這是一學習《Hands-On Machine Learning with Scikit-Learn and TensorFlow》的筆記，如果此筆記對該書有侵權內容，請聯絡我，將其刪除。 部落格出自：https://www.cnblogs.com/endlesscoding/p/9901539.html，未經博主同意，請忽轉載。 這裡面的內容目前條理還不是特別清析，後面有時間會更新整理一下。 下面的程式碼執行環境為jupyter + python3.6

獲取資料

# from sklearn.datasets import fetch_mldata
# from sklearn import datasets

# mnist = fetch_mldata('MNIST   original') 
# mnist
 

好像下載不到它的資料，直接從網上找到它的資料，放到當面目錄下的\datasets\mldata目錄下。MNIST data的百度網盤連結: https://pan.baidu.com/s/1Np4r6uepYkPDHZsdMU4l-w 提取碼: 9dq2，如果連結失效，可在下面評論區告知我，或者自己去網上找一樣的，相信各位小夥伴的能力呀。

輸入如下程式碼：

from sklearn.datasets import fetch_mldata
from sklearn import datasets
import numpy as np

mnist = fetch_mldata('mnist-original', data_home = './datasets/') 
mnist
 

上面的程式碼中的data_home表示你的資料集的檔案路徑，寫的是一個相對路徑，如果你沒有將你的資料集放在你當前程式碼的目錄下，你可能需要使用絕對路徑。

輸出：

{'DESCR': 'mldata.org dataset: mnist-original',
 'COL_NAMES': ['label', 'data'],
 'target': array([0., 0., 0., ..., 9., 9., 9.]),
 'data': array([[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}
 

可以看出，我們成功讀到了它的資料，網上有很多的說法是錯誤的，沒有辦法讀成功，只有這個才是正解?。

上面的資料給出了一些基本的描述資訊，裡面有target, data，分別是標籤和資料內容。進一步地我們可以看看資料和標籤的維度資訊。

輸入如下程式碼：

X, y = mnist['data'], mnist['target']
print(X.shape)
print(y.shape)

輸出：

(70000, 784)
(70000,)

從上面看出來，X是一個\(7000\times784\)的一個矩陣，一般來說，7000行表示有7000個樣本，784列，表示樣本有784這麼多個屬性。

%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt

some_digit = X[36000]
some_digit_image = some_digit.reshape(28,28)

plt.imshow(some_digit_image, cmap=matplotlib.cm.binary, interpolation="nearest")
plt.axis('off')
plt.show()

說個數看起來像是5，我覺得更像是6，我們可檢視一下它的標籤。

y[36000]

輸出：

5.0

好吧，它的標籤是5，可能這個標籤寫錯了都不一定，我們得新寫一下這個標籤，說不定可以提高模型的準確率呢。這只是我個人在這裡開玩笑說的，不用當真哈?。

# EXTRA
def plot_digits(instances, images_per_row=10, **options):
    size = 28
    images_per_row = min(len(instances), images_per_row)
    images = [instance.reshape(size,size) for instance in instances]
    n_rows = (len(instances) - 1) // images_per_row + 1
    row_images = []
    n_empty = n_rows * images_per_row - len(instances)
    images.append(np.zeros((size, size * n_empty)))
    for row in range(n_rows):
        rimages = images[row * images_per_row : (row + 1) * images_per_row]
        row_images.append(np.concatenate(rimages, axis=1))
    image = np.concatenate(row_images, axis=0)
    plt.imshow(image, cmap = matplotlib.cm.binary, **options)
    plt.axis("off")

plt.figure(figsize=(9,9))
example_images = np.r_[X[:12000:600], X[13000:30600:600], X[30600:60000:590]]
plot_digits(example_images, images_per_row=10)
# save_fig("more_digits_plot")
plt.show()

輸出如下圖片：

在做資料的訓練前，應該找出測試集，這裡MNIST已經幫我們把測試集做好了。前面60000個當作訓練集，後面10000個當測試集。

X_train, X_test, y_train, y_test = X[:60000],X[60000:],y[:60000],y[60000:]

MNIST的資料是按數字大小順序排列的，所我們先要打亂它的順序，這樣可以保證我們的交叉驗證是每一次都是相似的。

import numpy as np

shuffle_index = np.random.permutation(60000)
shuffle_index

輸出：

array([52603, 56601, 42625, ..., 17778, 24267, 29358])

注： np.random.permutation 是隨機排列一個序列。上面的例子就是從0~60000的隨機序列

輸入如下程式碼，打亂它的順序。

X_train, y_train = X_train[shuffle_index],y_train[shuffle_index]

訓練一個二分類器

先不做一個多類器，我們不去識別裡面的手寫數字是0~9中的某一個數。目前做一個最簡單的，判斷它是否是5，即將資料分成兩個類別：“5”和“非5”

首先地，我們需要將標籤更改一下，改成“是5”和“非5”的標籤，很簡單。

輸出下面程式碼，形成一個了一個邏輯陣列：

# 這是一個邏輯陣列，5：True, 非5：False
y_train_5 = (y_train == 5)
y_test_5 = (y_test == 5)

現在開始用一個分類器去訓練它。用隨機梯度下降分類器SGD。用Scikit-Learn的SGDClassifier類。這個分類器有一個好處是能夠高效地處理非常大的資料集。部分原因是它每次只處理一條資料。

注： 我們暫時不用過多地在意SGD是個什麼樣的分類器，只需要知道它是一個分類器就好啦?

輸入如下程式碼：

from sklearn.linear_model import SGDClassifier

sgd_clf = SGDClassifier(random_state = 32)
sgd_clf.fit(X_train, y_train_5)

就這樣子，我們訓練好了一個分類器了，就是這麼簡單，實在是太容易了，也許你都還沒有反應過來，就做了一件聽起來這麼牛逼的事情?。

對上面的程式碼簡單介紹一下，第3行，就是生成一個分類器，然後給一個random_state的引數，因為這個分類器有一定的隨機性，所以它需一個隨機種子。第4行，就是將我們的訓練資料與我們的訓練標籤進行訓練（擬合/迴歸）。

下面是它的輸出：

SGDClassifier(alpha=0.0001, average=False, class_weight=None,
       early_stopping=False, epsilon=0.1, eta0=0.0, fit_intercept=True,
       l1_ratio=0.15, learning_rate='optimal', loss='hinge', max_iter=None,
       n_iter=None, n_iter_no_change=5, n_jobs=None, penalty='l2',
       power_t=0.5, random_state=32, shuffle=True, tol=None,
       validation_fraction=0.1, verbose=0, warm_start=False)

接下來，我們用這個訓練好的模型來預測一下，看看它到底怎麼樣。

輸入如下程式碼：

sgd_clf.predict([some_digit])

輸出：

array([ True])

這裡面的some_digit是我前的數字5，不信可以翻到前面去看看。從輸出的結果True可以看出來，這個模型預測正確了，確實是個5，看起來還不錯。

這個模型的準確度你為似乎受隨機種子的影響比較大，如果我將模型的隨機種改為42，我們再來看一下它預測的結果是不是正確的

sgd_clf = SGDClassifier(random_state = 42)
sgd_clf.fit(X_train, y_train_5)
sgd_clf.predict([some_digit])

輸出：

array([ True])

嗯，還是正確的，但是在你的電腦上，可能不一定，可以試試看。

對效能的評估

下面來整體評估一下這個分類的效能。上面我們只是讓我們這個模型預測了一個數字，並不能代表什麼，說不定是那個模型運氣好，猜中了。我們接下來得整體看一下它的準確率，這樣子才有說服力。

使用交叉驗證測量準確性

交叉驗證，簡單來講就是將我們的訓練集又細分成好幾份，比如說我們將它分成3份，使其中的2份來訓練，1份用於測試，計算出它的準確率（或者其它指標）。這裡每一份都需要用作測試，也需要被當作訓練，所以要交叉3次，如果你對此還有所疑問，請百度或google一下。

在交叉驗證過程中，有時候我們會需要更多的控制權，相較於函式cross_val_score()或者其他相似函式所提供的功能。下面程式碼做了和cross_val_score()相同的事情

from sklearn.model_selection import StratifiedKFold
from sklearn.base import clone

skfolds = StratifiedKFold(n_splits = 3, random_state = 42)
clone_clf = clone(sgd_clf)
for train_index, test_index in skfolds.split(X_train, y_train_5):
    X_train_folds = X_train[train_index]
    y_train_folds = (y_train_5[train_index])
    X_test_fold = X_train[test_index]
    y_test_fold = (y_train_5[test_index])
    clone_clf.fit(X_train_folds, y_train_folds)
    y_pred = clone_clf.predict(X_test_fold)
    n_correct = sum(y_pred == y_test_fold)
    print(n_correct / len(y_pred))

注： StratfiedKFold 類實現了分層取樣，生成的折包含了各類相應比例的樣例。在每一次迭代，上述程式碼生成分類器的一個克隆，在克隆的模型上訓練，在測試折上進行預測

輸出：

0.9612

0.9531

0.9688

從上面的輸出可以看出來，它的準確在95%以上，看起來還不錯。

下面直接使用sklearn中的庫進行交叉評估。使用cross_val_score函式來評估SGDClassifier模型。

from sklearn.model_selection import cross_val_score

cross_val_score(sgd_clf, X_train, y_train_5, cv = 3, scoring = "accuracy")

輸出：

array([0.9612, 0.9531, 0.9688])

這精度看起來還不錯，有大於95%的精度，有點讓人興奮，感覺做個分類還是挺容易的，一點都不難。但是不要高興得太早。

我們再來看下一個非常簡單的分類器去分類，看看它在“非5”這個類上的表現。

from sklearn.base import BaseEstimator
# 這個模型的預測的策略就是將所有的資料都認為是'非5'
class Never5Classifier(BaseEstimator):
    def fit(self,X,y=None):
        pass
    def predict(self,X):
        return np.zeros((len(X),1), dtype=bool)

這個分類器就是，不管青紅皁白，都認為這個數字不是5，即將它歸為非5。

never_5_clf = Never5Classifier()
cross_val_score(never_5_clf, X_train, y_train_5, cv = 3, scoring = "accuracy")

輸出：

array([0.90815, 0.9124 , 0.9084 ])

這麼一個簡單的分類器也有90%的精度?，我們費了大半天勁，好像也只比這個準確率高那麼一點點，有點掇敗感。

這是因為只有10%的樣本是5，其它都是非5，所以只我們一直猜這個影象不是5，當然有90%的精度，這叫資料不平衡。就像我們如果在日本，站到大街上，見到人就猜他是一個日本人，我們幾乎肯定是正確的。

所以精度並不是一個好的效能度量指標，特別是在我們資料不平衡的時候。

混淆矩陣

對一般分類器來說，一人好得多的效能評估指標是混淆矩陣。大體思路是：輸出類別A被分成類別B的次數。

為了計算混淆矩陣，首先你需要有一系列的預測值，這樣才能將預測值與真實值做比較。你或許想在測試集上做預測。

from sklearn.model_selection import cross_val_predict

y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv = 3)

from sklearn.metrics import confusion_matrix

confusion_matrix(y_train_5, y_train_pred)

array([[54306,   273],
       [ 2065,  3356]], dtype=int64)

混淆矩陣中的每一行表示一個實際的類，而每一列表一個預測的類。該矩陣的第一行認為"非5"中的53993張被正確地歸類為非5（這被稱為真反例，true negatives）,而其餘586被錯誤歸類為5（這被稱為假正例，false positive），其餘3905正確分類為"5"類（真正例，true positive）。一個完美的分類器將只有真反例和真正例，所混淆矩陣的非零值僅在其主對角線（左上至右下）。

# confusion_matrix(y_train_5, y_train_perfect_predictions)

混淆矩陣可以提供很多資訊。有時候你會想要更加簡明的指標。一個有趣的指標是正例預測的精度，也叫做分類器的準確率(precision)

\[ precision = \frac{TP}{TP + FP} \tag{3-1} \]

其中\(TP\)是真正例的數目，\(FP\)是假正例的數目。

以準確率一般會伴隨另一個指標一起使用，這個指標叫做召回率（recall），也叫做敏感度（sensitivity）或者真正例率（true positive rate, TPR）。這是正例被分類器正確探測出的比率。

\[ recall = \frac{TP}{TP+FN} \tag{3-2} \]

\(FN\)是假反例的數目。

from sklearn.metrics import precision_score, recall_score

print(precision_score(y_train_5, y_train_pred))
print(recall_score(y_train_5, y_train_pred))

輸出：

0.924772664645908
0.6190739715919572

這樣看起，這個分類器的準確率並不高，只有56.8%左右，而且只是分成兩類的一個分類器，這跟我們猜差不多。

通常結合準確率和召回率會更加方便，這個指標叫做F1值，特別是當你需要一個簡單的方法去比較兩個分類器的優劣的時時候。F1值是準確率和召回率的調和平均。

\[ F1 = \frac{2}{\frac{1}{precision}+\frac{1}{recall}} = 2 \times \frac{precision \times recall}{precision + recall} = \frac{TP}{TP + \frac{FN+FP}{2}} \tag{3-3} \]

計算F1值，簡單呼叫f1_score()即可。

from sklearn.metrics import f1_score

f1_score(y_train_5, y_train_pred)

0.7416574585635358

F1支援那些有著相近準確率和召回率的分類（意思是隻有當準確率和召回率一樣大的時個，F1值才會大）。但並不是所的時候，我們都關心F1值，有時候我們只關心準確率（precision），或者有時候我們只關心召回率（recall）。

這裡，我們再次理解一下準確率的含義：如果一個分類器的每次幾乎都能把我們所要分的類別準確地分類出來，那麼無疑，這個分類器的準確率是高的；什麼時候準備率低呢，就是它把我們所要分的類，預測錯了。比如我們這裡的例子，我們要預測這張手寫圖片的數字是否是5，如果那張圖真的是5，而我們的分類器預測它是5，那麼它預測對了，當然預測對了，不是我們區分準確率與召回率的情況。如果將一張不是5的圖片預測成5，那麼我們會說它個分類器不是很準，它有低準確率。

什麼是召回率？當我們將一張是5的圖片預測成不是5，說明這個分類器還是比較嚴格的，那和它有較低的如回率。

總的來說，準確率低的原因就產將那些看起來像5（只是像，實際並不是5）的預測成了5；而召回率低的原因是把那些看起來不像5（實際上是5，只是可能那個5寫得比較醜）預測成不是5。

在這裡，我以自己的理解，舉兩個例子，比如公司想找個人當總經理，有一群人來應聘它。我們這時候的目標是，找到的這個人肯定是能夠當總經理的，就算有的人看起來像是能當總經理，但是為了確保萬無一失，我們要找一個看起來非常非常像能夠當總經理的人。這個時候我們當然有著很高的準確率，因為我們找的人幾乎肯定是能夠當總經理的，但是此時，我們會犯另一個錯誤，就是有些人確實有能力當總經理，只是我們沒有看出來（人不可貌像），所以我們拒絕他，因此我們有低的召回率，這在統計學上被稱為犯了第一類錯誤，即棄真。這樣做是合理的，因為即使棄真，但我們保真了。

另一種情況是，比如警察在一群人中想找出幾個犯罪的人，這個時候我們就不能要超高的準確率了，因為有可能把真正的犯人放走。找犯人的原則一般是，只要他看起來像個犯人，都應該審查一下，即使最後真像大白後，他真的不是一個犯人。我們平時聽到的寧可錯殺一千，不可放走一個說的就是這個道理，因此這有著比較低的準確率，但是有高的召回率，這在統計學上被稱為犯了第二類錯誤，即取偽。

準備率/召回率之間的折中

y_scores = sgd_clf.decision_function([some_digit])
y_scores

輸出： array([15905.22111141])

threshold = 0
y_some_digit_pred = (y_scores > threshold)
y_some_digit_pred

輸出： array([ True])

y_scores = cross_val_predict(sgd_clf, X_train,y_train_5,cv=3,
                             method = "decision_function")

from sklearn.metrics import precision_recall_curve
precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)

def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):
    plt.plot(thresholds, precisions[:-1], "b--", label = "Precision")
    plt.plot(thresholds, recalls[:-1], "g-", label = "Recall")
    plt.xlabel("Threshold")
    plt.legend(loc="upper left")
    plt.ylim([0,1.1])
    
plot_precision_recall_vs_threshold(precisions,recalls,thresholds)
plt.grid()
plt

ROC曲線

受試者工作特徵(ROC)曲線是另一個二分類器常用的工具。它非常類似與準確率/召回率曲線，但不是畫出準確率對召回率的曲線，，ROC曲線是真正例率（true positive rate，另一個名字叫做召回率）對假正例率（false positive rate, FPR）的曲線。FPR是反例被錯誤分成正例的比率。它等於1減去真反例率（true negative rate，TNR）。TNR是反例被正確分類的比率。TNR也叫做特異性。

為了畫出ROC曲線，你首先需要計算各種不同閾值下的TPR、FPR，使用roc_curve()函式：

from sklearn.metrics import roc_curve
fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)

def plot_roc_curve(fpr, tpr, label = None):
    plt.plot(fpr,tpr, linewidth = 2, label = label)
    plt.plot([0,1],[0,1],'k--')
    plt.axis([0,1,0,1])
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')

plot_roc_curve(fpr,tpr)
plt

一個比較分類器之間優劣的方法是：測量ROC曲線下的面積（AUC）。一個完美的分類器的 ROC AUC 等於1，而一個純隨機分類器的ROC AUC等於0.5。Scikit-Learn提供了一個函式來計算ROC AUC：

from sklearn.metrics import roc_auc_score
roc_auc_score(y_train_5,y_scores)

0.9623990527630832

from sklearn.ensemble import RandomForestClassifier

forest_clf = RandomForestClassifier(random_state = 42)
y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3, method = "predict_proba")

y_scores_forest = y_probas_forest[:,1]
fpr_forest, tpr_forest, thresholds_forest=roc_curve(y_train_5,y_scores_forest)
plt.plot(fpr,tpr,"b:",label="SGD") 
plot_roc_curve(fpr_forest,tpr_forest,"Random Forest") 
plt.legend(loc="bottom  right") 
plt

# 將概率大於0.5的，置為true, 否則為false
print(precision_score(y_train_5, y_scores_forest > 0.5))
print(recall_score(y_train_5, y_scores_forest > 0.5))

0.9844298245614035
0.8280760007378712

可以看出來，它的準確率還可，挺高的。

下面我們將分類出更多的數字，而不僅僅是5。

多類分類

二分類器只能分出兩個類，而多分類器能分出多於兩個類別的類。

一些演算法（比如隨機森林分類器或者樸素貝葉斯分類器）可以直接處理多類分類問題。其他一些演算法（比如SVM分類器或者線性分類器）則是嚴格的二分類器，然後有許多策略可以讓你用二分類器去執行多類分類。

Scikit-Learn可以探測出你想使用一個二分類器去完成多分類的任務，它會自動地執行OvA（除了SVM分類器，它使用OvO）。讓我們試一下SGDClassifier

sgd_clf.fit(X_train, y_train)
sgd_clf.predict([some_digit])

array([5.])

你可以呼叫decision_function()方法。不是返回每個樣例的一個數值，而是返回10個數值，一個數值對應於一個類。

some_digit_scores = sgd_clf.decision_function([some_digit])
some_digit_scores

array([[-253639.46707377, -425198.63904333, -354213.80127786,
        -229676.13263264, -376404.48500382,   15905.22111141,
        -564592.12430579, -194289.65607053, -748913.30208666,
        -597652.52038338]])

最高的數值對應類別5

np.argmax(some_digit_scores)

5

sgd_clf.classes_

array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

如果你想強制Scikit-Learn使用OvO策略或者OvA策略，你可以使用OneVsOneClassifier類或者OneVsRestClassifier類。建立一個樣例，傳遞一個二分類器給它的建構函式。舉例子，下面的程式碼會建立一個多類分類器，使用OvO策略，基於SGDClassifier。

from sklearn.multiclass import OneVsOneClassifier

ovo_clf = OneVsOneClassifier(SGDClassifier(random_state=42))
ovo_clf.fit(X_train, y_train)
ovo_clf.predict([some_digit])

array([5.])

訓練一個RandomForestClassifier同樣簡單：

forest_clf.fit(X_train,y_train)
forest_clf.predict([some_digit])

array([5.])

這次Scikit-Learn沒有必要去執行OvO或者OvA, 因為隨機森林分類器能夠直接將一個樣例分到多個類別。你可呼叫predict_proba()，得到樣例對應的類別的概率值的列表：

forest_clf.predict_proba([some_digit])

array([[0. , 0. , 0. , 0. , 0. , 0.9, 0. , 0. , 0.1, 0. ]])

接下來，我們當然想評估一下這些分類器。像以前一樣，想便用交叉驗證。讓我們用cross_val_score來評估SGDClassifier的精度。

cross_val_score(sgd_clf, X_train, y_train,cv = 3, scoring = "accuracy")

array([0.86002799, 0.8760438 , 0.88093214])

我們可以看到這個分類器有86.3%的精度，這個精度還不錯，比我們隨便亂猜的精度要高出不少（如果我們隨機猜，那麼精度只有10%）。看起來也並不差，這裡可以使輸入正則化，得到更高的精度，可以將其精度提高到90%以上。

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
cross_val_score(sgd_clf, X_train_scaled, y_train, cv = 3, scoring="accuracy")

array([0.9080184 , 0.91049552, 0.91043657])

誤差分析

分析模型產生的誤差，首先，我們可以檢查混淆矩陣。需要使用cross_val_predict()做出預測，然後呼叫confusion_matrix()函式，像以前做的那樣

y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv = 3)
conf_mx = confusion_matrix(y_train, y_train_pred)
conf_mx

array([[5739,    3,   22,    8,    9,   50,   43,    7,   38,    4],
       [   2, 6451,   50,   23,    6,   46,    5,   14,  133,   12],
       [  58,   38, 5348,   87,   76,   26,   83,   56,  169,   17],
       [  50,   40,  134, 5300,    2,  267,   37,   64,  140,   97],
       [  25,   26,   36,    7, 5356,    9,   54,   32,   83,  214],
       [  68,   37,   34,  179,   74, 4617,  106,   30,  171,  105],
       [  35,   21,   42,    2,   39,   98, 5630,    6,   44,    1],
       [  27,   18,   66,   27,   52,   10,    7, 5793,   17,  248],
       [  58,  150,   68,  140,   16,  156,   51,   29, 5050,  133],
       [  43,   29,   24,   84,  158,   36,    3,  194,   83, 5295]],
      dtype=int64)

這裡是一堆數字，使用Matplotlib的matshow()函式，將混淆矩陣以影象的方式呈現，將會更加方便。

plt.matshow(conf_mx, cmap = plt.cm.gray)
plt.show()

可以看到，幾乎所有的圖片都在對角線上，這意味著分類幾乎全部正確。現我們只看看其誤差的影象

row_sums = conf_mx.sum(axis=1, keepdims=True)
norm_conf_mx = conf_mx / row_sums

np.fill_diagonal(norm_conf_mx, 0)
plt.matshow(norm_conf_mx, cmap = plt.cm.gray)
plt.show()

現在可以清楚看出分類器的各類誤差，其中行代表實際類別，列代表預測的類別。第8、9列很亮，這說明很多圖片被誤分成數字8或者數字9。

分析混淆矩陣通常可以提供深刻的見解去改善分類器。回顧這幅圖，看樣子應該努力改善分類器在數字8和數字9上的表現，和糾正3/5的混淆。舉例子，你可以嘗試去收集更多的資料，或者你可以構造新的、有助於分類器的特徵（新的分類器的特徵，我們可以在資料裡面加一個新的列———這相當添加了一個新的屬性，比如字數8有兩個環，數字6有一個，5沒有）。

cl_a, cl_b = 3, 5
X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]
X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]
X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]
X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]

plt.figure(figsize=(8,8))
plt.subplot(221); plot_digits(X_aa[:25], images_per_row=5)
plt.subplot(222); plot_digits(X_ab[:25], images_per_row=5)
plt.subplot(223); plot_digits(X_ba[:25], images_per_row=5)
plt.subplot(224); plot_digits(X_bb[:25], images_per_row=5)
# save_fig("error_analysis_digits_plot")
plt.show()

多標籤分類

到目前為止，所有的樣例都總是被分配到僅一個類（比如我們前面訓練的分類，要麼輸出是1，要麼是2，3，...，9，一次只能輸出一個類別）。有些情況下，你也許想讓你的分類器給一個樣例輸出多個類別。比如有時候我們想識別某個人臉，想判斷它的性別，還有是否為中國人，這就有兩個類別了([gender, isChinese])。。這種輸出多個二值標籤的分類系統被叫做多標籤分類系統。

目前不打算深入臉部識別。我們可以先看一個簡單點的例子。

from sklearn.neighbors import KNeighborsClassifier
y_train_large = (y_train >=7)
y_train_odd = (y_train % 2 == 1)
y_multilabel = np.c_[y_train_large, y_train_odd]

knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train, y_multilabel)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=None, n_neighbors=5, p=2,
           weights='uniform')

這段程式碼創造了一個y_multilabel陣列，裡面包含兩個目標標籤。第一個標籤指出這個數字是否為大數（即是否為7，8，9），第二個標籤指示這個數字是否為奇數

knn_clf.predict([some_digit])

array([[False,  True]])

這個預測器預測對，我們輸入的資料代表5，5不是一個大數，但是是一個奇數。

# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_train, cv = 3)
# f1_score(y_train, y_train_knn_pred, average="macro")

多輸出分類

我們即將討論最後一種分類任務，被叫做"多輸出-多分類"（或者簡稱多輸出分類）。在這裡每一個標籤可以是多類別的（比如我們前面所舉的例子）

為了說明這點，我們建立一個系統，它可以去除圖片當中的噪音。它將一張混有噪音的圖片作為輸入，期待它輸出一張乾淨的數字圖片，用一個畫素強度的陣列表示，就像 MNIST圖片那樣。注意到這個分類器的輸出是多標籤的（一個畫素一個標籤）和每個標籤可以有多個值 （畫素強度取值範圍從0到255）。所以它是一個多輸出分類系統的例子。

我們從MNIST的圖版建立訓練集和測試集開始，然後給圖片的畫素強度新增噪聲，這裡是用NumPy的randint()函式。目標影象是原始影象。

noise = np.random.randint(0, 100, (len(X_train), 784))
X_train_mod = X_train + noise
noise = np.random.randint(0, 100, (len(X_test), 784))
X_test_mod = X_test + noise
y_train_mod = X_train
y_test_mod = X_test

def plot_digit(data):
    image = data.reshape(28, 28)
    plt.imshow(image, cmap = matplotlib.cm.binary,
               interpolation="nearest")
    plt.axis("off")
    
some_index = 5500

plt.subplot(121); plot_digit(X_test_mod[some_index])
plt.subplot(122); plot_digit(y_test_mod[some_index])
# save_fig("noisy_digit_example_plot")
plt.show()

knn_clf.fit(X_train_mod, y_train_mod)
clean_digit = knn_clf.predict([X_test_mod[some_index]])
plot_digit(clean_digit)
# save_fig("cleaned_digit_example_plot")

上面的圖片看起來還行，比較接近原圖片，去噪的效果還可以。

到這裡，分類的知識學得差不多了。