第3章 線性分類

線性回歸和線性分類之間有著很大的聯系，從某種意義上來說，線性分類就是線性回歸函數使用激活函數的結果。同時也可以看成是線性回歸降維的結果。對于一個線性回歸函數，我們可以通過添加全局函數的形式來將其轉換為線性分類函數，

????????????????????????????????????????????????????????????????????????????

3.1 基于Logistic回歸的二分類任務

Logistic回歸，是一種廣義的線性回歸分析模型，屬于機器學習中的監督學習。其推導過程與計算方式類似于回歸的過程，但實際上主要是用來解決二分類問題（也可以解決多分類問題）。通過給定的n組數據（訓練集）來訓練模型，并在訓練結束后對給定的一組或多組數據（測試集）進行分類。其中每一組數據都是由p 個指標構成。

在本節中，我們實現一個Logistic回歸模型，并對一個簡單的數據集進行二分類實驗。

3.1.1 數據集構建

我們首先構建一個簡單的分類任務，并構建訓練集、驗證集和測試集。
本任務的數據來自帶噪音的兩個彎月形狀函數，每個彎月對一個類別。我們采集1000條樣本，每個樣本包含2個特征。

數據集的構建函數make_moons的代碼實現如下：

import math import copy import torchdef make_moons(n_samples=1000, shuffle=True, noise=None):"""生成帶噪音的彎月形狀數據輸入：- n_samples：數據量大小，數據類型為int- shuffle：是否打亂數據，數據類型為bool- noise：以多大的程度增加噪聲，數據類型為None或float，noise為None時表示不增加噪聲輸出：- X：特征數據，shape=[n_samples,2]- y：標簽數據, shape=[n_samples]"""n_samples_out = n_samples // 2n_samples_in = n_samples - n_samples_out# 采集第1類數據，特征為(x,y)# 使用'torch.linspace'在0到pi上均勻取n_samples_out個值# 使用'torch.cos'計算上述取值的余弦值作為特征1，使用'torch.sin'計算上述取值的正弦值作為特征2outer_circ_x = torch.cos(torch.linspace(0, math.pi, n_samples_out))outer_circ_y = torch.sin(torch.linspace(0, math.pi, n_samples_out))inner_circ_x = 1 - torch.cos(torch.linspace(0, math.pi, n_samples_in))inner_circ_y = 0.5 - torch.sin(torch.linspace(0, math.pi, n_samples_in))print('outer_circ_x.shape:', outer_circ_x.shape, 'outer_circ_y.shape:', outer_circ_y.shape)print('inner_circ_x.shape:', inner_circ_x.shape, 'inner_circ_y.shape:', inner_circ_y.shape)# 使用'torch.concat'將兩類數據的特征1和特征2分別延維度0拼接在一起，得到全部特征1和特征2# 使用'torch.stack'將兩類特征延維度1堆疊在一起X = torch.stack([torch.cat([outer_circ_x, inner_circ_x]),torch.cat([outer_circ_y, inner_circ_y])],dim=1)print('after concat shape:', torch.cat([outer_circ_x, inner_circ_x]).shape)print('X shape:', X.shape)# 使用'torch. zeros'將第一類數據的標簽全部設置為0# 使用'torch. ones'將第一類數據的標簽全部設置為1y = torch.cat([torch.zeros(size=[n_samples_out]), torch.ones(size=[n_samples_in])])print('y shape:', y.shape)# 如果shuffle為True，將所有數據打亂if shuffle:# 使用'torch.randperm'生成一個數值在0到X.shape[0]，隨機排列的一維Tensor做索引值，用于打亂數據idx = torch.randperm(X.shape[0])X = X[idx]y = y[idx]# 如果noise不為None，則給特征值加入噪聲if noise is not None:# 使用'torch.normal'生成符合正態分布的隨機Tensor作為噪聲，并加到原始特征上X += torch.normal(mean=0.0, std=noise, size=X.shape)return X, y# 采樣1000個樣本 n_samples = 1000 X, y = make_moons(n_samples=n_samples, shuffle=True, noise=0.5) # 可視化生產的數據集，不同顏色代表不同類別 import matplotlib.pyplot as pltplt.figure(figsize=(5,5)) plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist()) plt.xlim(-3,4) plt.ylim(-3,4) plt.savefig('linear-dataset-vis.pdf') plt.show()

outer_circ_x.shape: torch.Size([500]) outer_circ_y.shape: torch.Size([500])
inner_circ_x.shape: torch.Size([500]) inner_circ_y.shape: torch.Size([500])
after concat shape: torch.Size([1000])
X shape: torch.Size([1000, 2])
y shape: torch.Size([1000])

將1000條樣本數據拆分成訓練集、驗證集和測試集，其中訓練集640條、驗證集160條、測試集200條。代碼實現如下：

num_train = 640 #訓練集 num_dev = 160 #驗證集 num_test = 200 #測試集X_train, y_train = X[:num_train], y[:num_train] X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev] X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]y_train = y_train.reshape([-1,1]) y_dev = y_dev.reshape([-1,1]) y_test = y_test.reshape([-1,1])# 打印X_train和y_train的維度 print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)# 打印一下前5個數據的標簽 print (y_train[:5])

X_train shape: ?torch.Size([640, 2]) y_train shape: ?torch.Size([640, 1])
tensor([[1.],
? ? ? ? [0.],
? ? ? ? [1.],
? ? ? ? [0.],
? ? ? ? [1.]])

3.1.2 模型構建

Logistic函數

Logistic函數的代碼實現如下：

def logistic(x):return 1/(1+torch.exp(-x))# 在[-10,10]的范圍內生成一系列的輸入值，用于繪制函數曲線 x = torch.linspace(-10, 10, 10000) plt.figure() plt.plot(x, logistic(x),label="Logistic Function") # 設置坐標軸 ax = plt.gca() # 取消右側和上側坐標軸 ax.spines['top'].set_color('none') ax.spines['right'].set_color('none') # 設置默認的x軸和y軸方向 ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('left') # 設置坐標原點為(0,0) ax.spines['left'].set_position(('data',0)) ax.spines['bottom'].set_position(('data',0)) # 添加圖例 plt.legend() plt.savefig('linear-logistic.pdf') plt.show()

這個logistic函數也就是我們常說的sigmoid函數?

?

問題1：Logistic回歸在不同的書籍中，有許多其他的稱呼，具體有哪些？你認為哪個稱呼最好？

logistic regression 翻譯成中文的譯本卻是有幾個，邏輯回歸（大家常說的），對數幾率回歸（周志華機器學習書籍），邏輯斯諦回歸（Understanding Machine Learning：From Theory to Algorithms中譯本）。
從單詞（詞根）的角度：

logistic adj.邏輯的；n.數理（符號）邏輯，邏輯斯蒂↓ logic 譯為 n.邏輯 adj.邏輯的，這詞是個舶來品，是音譯 大家常說的的【邏輯回歸算法】中的【邏輯】不是中文常說的【邏輯思維】這種邏輯。或譯成：邏輯斯蒂回歸。以避免誤導性。 logistic指的是 logistic函數-------------------------------------------------------------regression = re + gress + sion↓ ↓ ↓回/向后/相反 | to go/walk行走，來自拉丁語 | 名詞后綴 =>翻譯：向后走

?根據上述推導過程，我認為最準確的翻譯應該是：對數幾率回歸

問題2：什么是激活函數？為什么要用激活函數？常見激活函數有哪些？

如“激活”一詞所示，激活函數的作用在于決定如何來激活輸入信號的總和。

關于激活函數的作用，借用齋藤老師的魚書上的一段話

?上述非線性函數的作用就是激活函數的作用。

常見的激活函數有：階躍函數、sigmoid函數（logistic函數）、softmax函數、ReLU函數、tanh函數。

Logistic回歸算子

Logistic回歸模型其實就是線性層與Logistic函數的組合，通常會將 Logistic回歸模型中的權重和偏置初始化為0，同時，為了提高預測樣本的效率，我們將N個樣本歸為一組進行成批地預測。

import opclass model_LR(op.Op):def __init__(self, input_dim):super(model_LR, self).__init__()self.params = {}# 將線性層的權重參數全部初始化為0self.params['w'] = torch.zeros(size=[input_dim, 1])# self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])# 將線性層的偏置參數初始化為0self.params['b'] = torch.zeros(size=[1])def __call__(self, inputs):return self.forward(inputs)def forward(self, inputs):"""輸入：- inputs: shape=[N,D], N是樣本數量，D為特征維度輸出：- outputs：預測標簽為1的概率，shape=[N,1]"""# 線性計算score = torch.matmul(inputs, self.params['w']) + self.params['b']# Logistic 函數outputs = logistic(score)return outputs

模型測試

# 固定隨機種子，保持每次運行結果一致 torch.manual_seed(0) # 隨機生成3條長度為4的數據 inputs = torch.randn(size=[3,4]) print('Input is:', inputs) # 實例化模型 model = model_LR(4) outputs = model(inputs) print('Output is:', outputs)

Input is: tensor([[ 1.5410, -0.2934, -2.1788, ?0.5684],
? ? ? ? [-1.0845, -1.3986, ?0.4033, ?0.8380],
? ? ? ? [-0.7193, -0.4033, -0.5966, ?0.1820]])
Output is: tensor([[0.5000],
? ? ? ? [0.5000],
? ? ? ? [0.5000]])

3.1.3 損失函數

二分類任務的交叉熵損失函數的代碼實現如下：

class BinaryCrossEntropyLoss(op.Op):def __init__(self):self.predicts = Noneself.labels = Noneself.num = Nonedef __call__(self, predicts, labels):return self.forward(predicts, labels)def forward(self, predicts, labels):"""輸入：- predicts：預測值，shape=[N, 1]，N為樣本數量- labels：真實標簽，shape=[N, 1]輸出：- 損失值：shape=[1]"""self.predicts = predictsself.labels = labelsself.num = self.predicts.shape[0]loss = -1. / self.num * (torch.matmul(self.labels.t(), torch.log(self.predicts)) + torch.matmul((1-self.labels.t()), torch.log(1-self.predicts)))loss = torch.squeeze(loss, dim=1)return loss

測試交叉熵損失函數

# 生成一組長度為3，值為1的標簽數據 labels = torch.ones(size=[3,1]) # 計算風險函數 bce_loss = BinaryCrossEntropyLoss() print('交叉熵損失為：',bce_loss(outputs, labels))

交叉熵損失為： tensor([0.6931])

3.1.4 模型優化

不同于線性回歸中直接使用最小二乘法即可進行模型參數的求解，Logistic回歸需要使用優化算法對模型參數進行有限次地迭代來獲取更優的模型，從而盡可能地降低風險函數的值。
在機器學習任務中，最簡單、常用的優化算法是梯度下降法。

使用梯度下降法進行模型優化，首先需要初始化參數W和?b，然后不斷地計算它們的梯度，并沿梯度的反方向更新參數。

3.1.4.1 梯度計算

在Logistic回歸中，風險函數R(w,b)關于參數w和b的偏導數為：

?通常將偏導數的計算過程定義在Logistic回歸算子的backward函數中，代碼實現如下:

def backward(self, labels):"""輸入：- labels：真實標簽，shape=[N, 1]"""N = labels.shape[0]# 計算偏導數self.grads['w'] = -1 / N * torch.matmul(self.X.t(), (labels - self.outputs))self.grads['b'] = -1 / N * torch.sum(labels - self.outputs)

3.1.4.2 參數更新

在計算參數的梯度之后，我們按照下面公式更新參數：

?

首先定義一個優化器基類Optimizer，方便后續所有的優化器調用。在這個基類中，需要初始化優化器的初始學習率init_lr，以及指定優化器需要優化的參數。代碼實現如下：

class Optimizer(object):def __init__(self, init_lr, model):"""優化器類初始化"""# 初始化學習率，用于參數更新的計算self.init_lr = init_lr# 指定優化器需要優化的模型self.model = model@abstractmethoddef step(self):"""定義每次迭代如何更新參數"""pass

然后實現一個梯度下降法的優化器函數SimpleBatchGD來執行參數更新過程。其中step函數從模型的grads屬性取出參數的梯度并更新。代碼實現如下：

class SimpleBatchGD(Optimizer):def __init__(self, init_lr, model):super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)def step(self):# 參數更新# 遍歷所有參數，按照公式(3.8)和(3.9)更新參數if isinstance(self.model.params, dict):for key in self.model.params.keys():self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]

3.1.5 評價指標

在分類任務中，通常使用準確率（Accuracy）作為評價指標。如果模型預測的類別與真實類別一致，則說明模型預測正確。準確率即正確預測的數量與總的預測數量的比值：

?

def accuracy(preds, labels):"""輸入：- preds：預測值，二分類時，shape=[N, 1]，N為樣本數量，多分類時，shape=[N, C]，C為類別數量- labels：真實標簽，shape=[N, 1]輸出：- 準確率：shape=[1]"""# 判斷是二分類任務還是多分類任務，preds.shape[1]=1時為二分類任務，preds.shape[1]>1時為多分類任務if preds.shape[1] == 1:data_float = torch.randn(preds.shape[0], preds.shape[1])# 二分類時，判斷每個概率值是否大于0.5，當大于0.5時，類別為1，否則類別為0# 使用'torch.cast'將preds的數據類型轉換為float32類型preds = (preds>=0.5).type(torch.float32)else:# 多分類時，使用'torch.argmax'計算最大元素索引作為類別data_float = torch.randn(preds.shape[0], preds.shape[1])preds = torch.argmax(preds,dim=1, dtype=torch.int32)return torch.mean(torch.eq(preds, labels).type(torch.float32))

測試一下

# 假設模型的預測值為[[0.],[1.],[1.],[0.]]，真實類別為[[1.],[1.],[0.],[0.]]，計算準確率 preds = torch.tensor([[0.],[1.],[1.],[0.]]) labels = torch.tensor([[1.],[1.],[0.],[0.]]) print("accuracy is:", accuracy(preds, labels))

accuracy is: tensor(0.5000)

3.1.6 完善Runner類

基于RunnerV1，本章的RunnerV2類在訓練過程中使用梯度下降法進行網絡優化，模型訓練過程中計算在訓練集和驗證集上的損失及評估指標并打印，訓練過程中保存最優模型。代碼實現如下：

# 用RunnerV2類封裝整個訓練過程 class RunnerV2(object):def __init__(self, model, optimizer, metric, loss_fn):self.model = modelself.optimizer = optimizerself.loss_fn = loss_fnself.metric = metric# 記錄訓練過程中的評價指標變化情況self.train_scores = []self.dev_scores = []# 記錄訓練過程中的損失函數變化情況self.train_loss = []self.dev_loss = []def train(self, train_set, dev_set, **kwargs):# 傳入訓練輪數，如果沒有傳入值則默認為0num_epochs = kwargs.get("num_epochs", 0)# 傳入log打印頻率，如果沒有傳入值則默認為100log_epochs = kwargs.get("log_epochs", 100)# 傳入模型保存路徑，如果沒有傳入值則默認為"best_model.pdparams"save_path = kwargs.get("save_path", "best_model.pdparams")# 梯度打印函數，如果沒有傳入則默認為"None"print_grads = kwargs.get("print_grads", None)# 記錄全局最優指標best_score = 0# 進行num_epochs輪訓練for epoch in range(num_epochs):X, y = train_set# 獲取模型預測logits = self.model(X)# 計算交叉熵損失trn_loss = self.loss_fn(logits, y).item()self.train_loss.append(trn_loss)# 計算評價指標trn_score = self.metric(logits, y).item()self.train_scores.append(trn_score)# 計算參數梯度self.model.backward(y)if print_grads is not None:# 打印每一層的梯度print_grads(self.model)# 更新模型參數self.optimizer.step()dev_score, dev_loss = self.evaluate(dev_set)# 如果當前指標為最優指標，保存該模型if dev_score > best_score:self.save_model(save_path)print(f"best accuracy performence has been updated: {best_score:.5f} --> {dev_score:.5f}")best_score = dev_scoreif epoch % log_epochs == 0:print(f"[Train] epoch: {epoch}, loss: {trn_loss}, score: {trn_score}")print(f"[Dev] epoch: {epoch}, loss: {dev_loss}, score: {dev_score}")def evaluate(self, data_set):X, y = data_set# 計算模型輸出logits = self.model(X)# 計算損失函數loss = self.loss_fn(logits, y).item()self.dev_loss.append(loss)# 計算評價指標score = self.metric(logits, y).item()self.dev_scores.append(score)return score, lossdef predict(self, X):return self.model(X)def save_model(self, save_path):torch.save(self.model.params, save_path)def load_model(self, model_path):self.model.params = torch.load(model_path)

3.1.7 模型訓練

下面進行Logistic回歸模型的訓練，使用交叉熵損失函數和梯度下降法進行優化。
使用訓練集和驗證集進行模型訓練，共訓練 500個epoch，每隔50個epoch打印出訓練集上的指標。
代碼實現如下：

# 固定隨機種子，保持每次運行結果一致 torch.manual_seed(102)# 特征維度 input_dim = 2 # 學習率 lr = 0.1# 實例化模型 model = model_LR(input_dim=input_dim) # 指定優化器 optimizer = SimpleBatchGD(init_lr=lr, model=model) # 指定損失函數 loss_fn = BinaryCrossEntropyLoss() # 指定評價方式 metric = accuracy# 實例化RunnerV2類，并傳入訓練配置 runner = RunnerV2(model, optimizer, metric, loss_fn)runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_epochs=50, save_path="best_model.pdparams")

best accuracy performence has been updated: 0.00000 --> 0.77500
[Train] epoch: 0, loss: 0.6931460499763489, score: 0.5218750238418579
[Dev] epoch: 0, loss: 0.6839450001716614, score: 0.7749999761581421
best accuracy performence has been updated: 0.77500 --> 0.78125
[Train] epoch: 50, loss: 0.4823344349861145, score: 0.7953125238418579
[Dev] epoch: 50, loss: 0.5100909471511841, score: 0.768750011920929
[Train] epoch: 100, loss: 0.43836650252342224, score: 0.792187511920929
[Dev] epoch: 100, loss: 0.4771150052547455, score: 0.7562500238418579
[Train] epoch: 150, loss: 0.420661062002182, score: 0.796875
[Dev] epoch: 150, loss: 0.4678696095943451, score: 0.762499988079071
[Train] epoch: 200, loss: 0.41160938143730164, score: 0.7953125238418579
[Dev] epoch: 200, loss: 0.46574288606643677, score: 0.78125
[Train] epoch: 250, loss: 0.4063630700111389, score: 0.796875
[Dev] epoch: 250, loss: 0.46621155738830566, score: 0.78125
[Train] epoch: 300, loss: 0.40308570861816406, score: 0.796875
[Dev] epoch: 300, loss: 0.46767398715019226, score: 0.78125
best accuracy performence has been updated: 0.78125 --> 0.78750
[Train] epoch: 350, loss: 0.4009374678134918, score: 0.800000011920929
[Dev] epoch: 350, loss: 0.46947580575942993, score: 0.7875000238418579
[Train] epoch: 400, loss: 0.3994828760623932, score: 0.800000011920929
[Dev] epoch: 400, loss: 0.4713282585144043, score: 0.7875000238418579
[Train] epoch: 450, loss: 0.39847469329833984, score: 0.8031250238418579
[Dev] epoch: 450, loss: 0.47310104966163635, score: 0.7875000238418579
best accuracy performence has been updated: 0.78750 --> 0.79375

可視化觀察訓練集與驗證集的準確率和損失的變化情況。

# 可視化觀察訓練集與驗證集的指標變化情況 def plot(runner,fig_name):plt.figure(figsize=(10,5))plt.subplot(1,2,1)epochs = [i for i in range(len(runner.train_scores))]# 繪制訓練損失變化曲線plt.plot(epochs, runner.train_loss, color='#e4007f', label="Train loss")# 繪制評價損失變化曲線plt.plot(epochs, runner.dev_loss, color='#f19ec2', linestyle='--', label="Dev loss")# 繪制坐標軸和圖例plt.ylabel("loss", fontsize='large')plt.xlabel("epoch", fontsize='large')plt.legend(loc='upper right', fontsize='x-large')plt.subplot(1,2,2)# 繪制訓練準確率變化曲線plt.plot(epochs, runner.train_scores, color='#e4007f', label="Train accuracy")# 繪制評價準確率變化曲線plt.plot(epochs, runner.dev_scores, color='#f19ec2', linestyle='--', label="Dev accuracy")# 繪制坐標軸和圖例plt.ylabel("score", fontsize='large')plt.xlabel("epoch", fontsize='large')plt.legend(loc='lower right', fontsize='x-large')plt.tight_layout()plt.savefig(fig_name)plt.show()plot(runner,fig_name='linear-acc.pdf')

3.1.8 模型評價

使用測試集對訓練完成后的最終模型進行評價，觀察模型在測試集上的準確率和loss數據。代碼實現如下：

score, loss = runner.evaluate([X_test, y_test]) print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

[Test] score/loss: 0.7650/0.4378

調整學習率為0.5后：

[Test] score/loss: 0.8250/0.4047

發現score上升，loss下降，

調整學習率為0.01后：

[Test] score/loss: 0.7100/0.5410

從自己和其他人一般的經驗來看，學習率可以設置為3、1、0.5、0.1、0.05、0.01、0.005，0.005、0.0001、0.00001具體需結合實際情況對比判斷，小的學習率收斂慢，還會將loss值升高。

調整epoch為5000后：

[Test] score/loss: 0.8050/0.4063

發現score上升，loss下降

調整epoch為10000后：

[Test] score/loss: 0.7850/0.4704

發現score下降，loss上升

此時模型應該發生了過擬合導致準確率下降。

可視化觀察擬合的決策邊界 。

def decision_boundary(w, b, x1):w1, w2 = wx2 = (- w1 * x1 - b) / w2return x2plt.figure(figsize=(5,5)) # 繪制原始數據 plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist())w = model.params['w'] b = model.params['b'] x1 = torch.linspace(-2, 3, 1000) x2 = decision_boundary(w, b, x1) # 繪制決策邊界 plt.plot(x1.tolist(), x2.tolist(), color="red") plt.show()

3.2 基于Softmax回歸的多分類任務

Logistic回歸可以有效地解決二分類問題，但在分類任務中，還有一類多分類問題，即類別數C大于2 的分類問題。Softmax回歸就是Logistic回歸在多分類問題上的推廣。

使用Softmax回歸模型對一個簡單的數據集進行多分類實驗。

3.2.1 數據集構建

我們首先構建一個簡單的多分類任務，并構建訓練集、驗證集和測試集。
本任務的數據來自3個不同的簇，每個簇對一個類別。我們采集1000條樣本，每個樣本包含2個特征。

數據集的構建函數make_multi的代碼實現如下：

def make_multiclass_classification(n_samples=100, n_features=2, n_classes=3, shuffle=True, noise=0.1):"""生成帶噪音的多類別數據輸入：- n_samples：數據量大小，數據類型為int- n_features：特征數量，數據類型為int- shuffle：是否打亂數據，數據類型為bool- noise：以多大的程度增加噪聲，數據類型為None或float，noise為None時表示不增加噪聲輸出：- X：特征數據，shape=[n_samples,2]- y：標簽數據, shape=[n_samples,1]"""# 計算每個類別的樣本數量n_samples_per_class = [int(n_samples / n_classes) for k in range(n_classes)]for i in range(n_samples - sum(n_samples_per_class)):n_samples_per_class[i % n_classes] += 1# 將特征和標簽初始化為0X = torch.zeros([n_samples, n_features])y = torch.zeros([n_samples], dtype=torch.int32)# 隨機生成3個簇中心作為類別中心centroids = torch.randperm(2 ** n_features)[:n_classes]centroids_bin = np.unpackbits(centroids.numpy().astype('uint8')).reshape((-1, 8))[:, -n_features:]centroids = torch.tensor(centroids_bin, dtype=torch.float32)# 控制簇中心的分離程度centroids = 1.5 * centroids - 1# 隨機生成特征值X[:, :n_features] = torch.randn(size=[n_samples, n_features])stop = 0# 將每個類的特征值控制在簇中心附近for k, centroid in enumerate(centroids):start, stop = stop, stop + n_samples_per_class[k]# 指定標簽值y[start:stop] = k % n_classesX_k = X[start:stop, :n_features]# 控制每個類別特征值的分散程度A = 2 * torch.rand(size=[n_features, n_features]) - 1X_k[...] = torch.matmul(X_k, A)X_k += centroidX[start:stop, :n_features] = X_k# 如果noise不為None，則給特征加入噪聲if noise > 0.0:# 生成noise掩膜，用來指定給那些樣本加入噪聲noise_mask = torch.rand([n_samples]) < noisefor i in range(len(noise_mask)):if noise_mask[i]:# 給加噪聲的樣本隨機賦標簽值y[i] = torch.randint(n_classes, size=[1]).type(torch.int32)# 如果shuffle為True，將所有數據打亂if shuffle:idx = torch.randperm(X.shape[0])X = X[idx]y = y[idx]return X, y

隨機采集1000個樣本，并進行可視化。

# 固定隨機種子，保持每次運行結果一致 torch.manual_seed(102) # 采樣1000個樣本 n_samples = 1000 X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)import matplotlib.pyplot as plt# 可視化生產的數據集，不同顏色代表不同類別 plt.figure(figsize=(5,5)) plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist()) plt.savefig('linear-dataset-vis2.pdf') plt.show()

將實驗數據拆分成訓練集、驗證集和測試集。其中訓練集640條、驗證集160條、測試集200條。

num_train = 640 num_dev = 160 num_test = 200X_train, y_train = X[:num_train], y[:num_train] X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev] X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]# 打印X_train和y_train的維度 print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)

X_train shape: ?torch.Size([640, 2]) y_train shape: ?torch.Size([640])

3.2.2 模型構建

在Softmax回歸中，對類別進行預測的方式是預測輸入屬于每個類別的條件概率。與Logistic 回歸不同的是，Softmax回歸的輸出值個數等于類別數C，而每個類別的概率值則通過Softmax函數進行求解。

3.2.2.1 Softmax函數

首先我們先建立一個如下標準的softmax

?

# x為tensor def softmax(X):"""輸入：- X：shape=[N, C]，N為向量數量，C為向量維度"""x_exp = torch.exp(X)partition = torch.sum(x_exp, dim=1, keepdim=True)#N,1return x_exp / partition

但是這個softmax不夠好，會出錯，下面再次借用齋藤老師魚書上的一些東西：

?

?

所以我們用pytorch實現改良后的softmax函數?

# x為tensor def softmax(X):"""輸入：- X：shape=[N, C]，N為向量數量，C為向量維度"""x_max = torch.max(X, dim=1, keepdim=True)[0]#N,1x_exp = torch.exp(X - x_max)partition = torch.sum(x_exp, dim=1, keepdim=True)#N,1return x_exp / partition

?x_max的類型不是tensor，是由最大值和最大值下標組成的，我們只要最大值tensor，所以加個[0]

softmax函數其實是從hardmax演變而來的，hardmax函數其實是我們生活中很常見的一種函數，表達式是：

表達的意思很清楚，從寫，y和x中取較大的那個值，為了方便后續比較，我們將hardmax的形式換一下：

此時，函數本質功能沒變，我們只是對定義域做了一個限制，即：

?其圖形如下：

?很顯然這個函數在 x = 1 處是連續不可導的，可導能幫我們做很多事，那我們有沒有辦法對他變形，找到一個連續可導的近似函數？

此時就有了softmax函數：

我們先來看一下這個代數表達式的數學特性。指數函數有一個特點，就是變化率非常快。當x>y時，通過指數的放大作用，會使得二者差距進一步變大，即：

所以有：

所以g(x，y)表達式有：

因此根據上面的推導過程，g(x，y)約等于x，y中較大的值，即：

所以我們得出一個結論，g(x，y)是max{x，y}的近似函數，兩個函數有相似的數學特性。我們再來看一下softmax函數的圖像：

?

很顯然這是一個連續且處處可導的函數，這是一個非常重要的特性，g(x，y)即具有與max{x，y}的相似性，又避免了max{x，y}函數不可導的缺點。

我們把兩張圖疊加到一起來看看，紅色的折線是hardmax函數，他有一個尖尖的棱角，看起來很"hard"。藍色的弧線看起來就平滑的多，不那么"hard"，這就是softmax函數了。這就時softmax函數名稱的由來。

從圖上可以看出，當x，y的差別越大時，softmax和hardmax函數吻合度越高。

?

?思考題：Logistic函數是激活函數。Softmax函數是激活函數么？談談你的看法。

咱們繼續來看看魚書

?SoftMax定義了神經網絡新型的輸出方法，其實這一過程主要是增加神經網絡對訓練集的擬合程度，將線性（隱層第一步的WX+b）轉變成非線性，不改變神經網絡的加權輸入，從而加大了神經網絡的靈活度。

3.2.2.2 Softmax回歸算子

我們根據公式

實現Softmax回歸算子，代碼實現如下：

class model_SR(op.Op):def __init__(self, input_dim, output_dim):super(model_SR, self).__init__()self.params = {}# 將線性層的權重參數全部初始化為0self.params['W'] = torch.zeros(size=[input_dim, output_dim])# self.params['W'] = torch.normal(mean=0, std=0.01, shape=[input_dim, output_dim])# 將線性層的偏置參數初始化為0self.params['b'] = torch.zeros(size=[output_dim])self.outputs = Nonedef __call__(self, inputs):return self.forward(inputs)def forward(self, inputs):"""輸入：- inputs: shape=[N,D], N是樣本數量，D是特征維度輸出：- outputs：預測值，shape=[N,C]，C是類別數"""# 線性計算score = torch.matmul(inputs, self.params['W']) + self.params['b']# Softmax 函數self.outputs = softmax(score)return self.outputs# 隨機生成1條長度為4的數據 inputs = torch.randn(size=[1,4]) print('Input is:', inputs) # 實例化模型，這里令輸入長度為4，輸出類別數為3 model = model_SR(input_dim=4, output_dim=3) outputs = model(inputs) print('Output is:', outputs)

Input is: tensor([[-0.6014, -1.0122, -0.3023, -1.2277]])
Output is: tensor([[0.3333, 0.3333, 0.3333]])

3.2.3 損失函數

Softmax回歸同樣使用交叉熵損失作為損失函數，并使用梯度下降法對參數進行優化。

因此，多類交叉熵損失函數的代碼實現如下：

class MultiCrossEntropyLoss(op.Op):def __init__(self):self.predicts = Noneself.labels = Noneself.num = Nonedef __call__(self, predicts, labels):return self.forward(predicts, labels)def forward(self, predicts, labels):"""輸入：- predicts：預測值，shape=[N, 1]，N為樣本數量- labels：真實標簽，shape=[N, 1]輸出：- 損失值：shape=[1]"""self.predicts = predictsself.labels = labelsself.num = self.predicts.shape[0]loss = 0for i in range(0, self.num):index = self.labels[i]loss -= torch.log(self.predicts[i][index])return loss / self.num# 假設真實標簽為第1類 labels = torch.tensor([0]) # 計算風險函數 mce_loss = MultiCrossEntropyLoss() print(mce_loss(outputs, labels))

tensor(1.0986)

3.2.4 模型優化

使用梯度下降法進行參數學習。

3.2.4.1 梯度計算

計算風險函數R(W,b)關于參數W和b的偏導數。在Softmax回歸中，計算方法為：

def backward(self, labels):"""輸入：- labels：真實標簽，shape=[N, 1]，其中N為樣本數量"""# 計算偏導數N =labels.shape[0]labels = torch.nn.functional.one_hot(labels, self.output_dim)self.grads['W'] = -1 / N * torch.matmul(self.X.t(), (labels-self.outputs))self.grads['b'] = -1 / N * torch.matmul(torch.ones(size=[N]), (labels-self.outputs))

?此函數使用torch.nn.functional.one_hot時會報錯：

one_hot is only applicable to index tensor.

原因是創建數據集時

y = torch.zeros([n_samples], dtype=torch.int32)

這樣轉化過來的tensor，pytorch是不會為其構建索引的,所以要將int32改為int64

3.2.4.2 參數更新

在計算參數的梯度之后，我們使用3.1.4.2中實現的梯度下降法進行參數更新。

from abc import abstractmethod# 優化器基類 class Optimizer(object):def __init__(self, init_lr, model):"""優化器類初始化"""# 初始化學習率，用于參數更新的計算self.init_lr = init_lr# 指定優化器需要優化的模型self.model = model@abstractmethoddef step(self):"""定義每次迭代如何更新參數"""passclass SimpleBatchGD(Optimizer):def __init__(self, init_lr, model):super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)def step(self):# 參數更新# 遍歷所有參數，按照公式(3.8)和(3.9)更新參數if isinstance(self.model.params, dict):for key in self.model.params.keys():self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]

?

3.2.5 模型訓練

實例化RunnerV2類，并傳入訓練配置。使用訓練集和驗證集進行模型訓練，共訓練500個epoch。每隔50個epoch打印訓練集上的指標。代碼實現如下：

# 固定隨機種子，保持每次運行結果一致 torch.manual_seed(102)# 特征維度 input_dim = 2 # 類別數 output_dim = 3 # 學習率 lr = 0.1# 實例化模型 model = model_SR(input_dim=input_dim, output_dim=output_dim) # 指定優化器 optimizer = SimpleBatchGD(init_lr=lr, model=model) # 指定損失函數 loss_fn = MultiCrossEntropyLoss() # 指定評價方式 metric = accuracy # 實例化RunnerV2類 runner = RunnerV2(model, optimizer, metric, loss_fn)# 模型訓練 runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_eopchs=50, eval_epochs=1, save_path="best_model.pdparams")# 可視化觀察訓練集與驗證集的準確率變化情況 plot(runner,fig_name='linear-acc2.pdf')

best accuracy performence has been updated: 0.00000 --> 0.70625
[Train] epoch: 0, loss: 1.0986149311065674, score: 0.3218750059604645
[Dev] epoch: 0, loss: 1.0805636644363403, score: 0.706250011920929
best accuracy performence has been updated: 0.70625 --> 0.71250
best accuracy performence has been updated: 0.71250 --> 0.71875
best accuracy performence has been updated: 0.71875 --> 0.72500
best accuracy performence has been updated: 0.72500 --> 0.73125
best accuracy performence has been updated: 0.73125 --> 0.73750
best accuracy performence has been updated: 0.73750 --> 0.74375
best accuracy performence has been updated: 0.74375 --> 0.75000
best accuracy performence has been updated: 0.75000 --> 0.75625
best accuracy performence has been updated: 0.75625 --> 0.76875
best accuracy performence has been updated: 0.76875 --> 0.77500
best accuracy performence has been updated: 0.77500 --> 0.78750
[Train] epoch: 100, loss: 0.7155234813690186, score: 0.768750011920929
[Dev] epoch: 100, loss: 0.7977758049964905, score: 0.7875000238418579
best accuracy performence has been updated: 0.78750 --> 0.79375
best accuracy performence has been updated: 0.79375 --> 0.80000
[Train] epoch: 200, loss: 0.6921818852424622, score: 0.784375011920929
[Dev] epoch: 200, loss: 0.8020225763320923, score: 0.793749988079071
best accuracy performence has been updated: 0.80000 --> 0.80625
[Train] epoch: 300, loss: 0.6840380430221558, score: 0.7906249761581421
[Dev] epoch: 300, loss: 0.81141597032547, score: 0.8062499761581421
best accuracy performence has been updated: 0.80625 --> 0.81250
[Train] epoch: 400, loss: 0.680213987827301, score: 0.807812511920929
[Dev] epoch: 400, loss: 0.8198073506355286, score: 0.8062499761581421

3.2.6 模型評價

使用測試集對訓練完成后的最終模型進行評價，觀察模型在測試集上的準確率。代碼實現如下：

score, loss = runner.evaluate([X_test, y_test]) print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

[Test] score/loss: 0.8400/0.7014

可視化觀察類別劃分結果。

# 均勻生成40000個數據點 x1, x2 = torch.meshgrid(torch.linspace(-3.5, 2, 200), torch.linspace(-4.5, 3.5, 200)) x = torch.stack([torch.flatten(x1), torch.flatten(x2)], dim=1) # 預測對應類別 y = runner.predict(x) y = torch.argmax(y, dim=1) # 繪制類別區域 plt.ylabel('x2') plt.xlabel('x1') plt.scatter(x[:,0].tolist(), x[:,1].tolist(), c=y.tolist(), cmap=plt.cm.Spectral)torch.manual_seed(102) n_samples = 1000 X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist()) plt.show()

3.3 實踐：基于Softmax回歸完成鳶尾花分類任務

在本節，我們用入門深度學習的基礎實驗之一“鳶尾花分類任務”來進行實踐，使用經典學術數據集Iris作為訓練數據，實現基于Softmax回歸的鳶尾花分類任務。

實踐流程主要包括以下7個步驟：數據處理、模型構建、損失函數定義、優化器構建、模型訓練、模型評價和模型預測等，

• 數據處理：根據網絡接收的數據格式，完成相應的預處理操作，保證模型正常讀取；
• 模型構建：定義Softmax回歸模型類；
• 訓練配置：訓練相關的一些配置，如：優化算法、評價指標等；
• 組裝Runner類：Runner用于管理模型訓練和測試過程；
• 模型訓練和測試：利用Runner進行模型訓練、評價和測試。

3.3.1 數據處理

3.3.1.1 數據集介紹

Iris數據集，也稱為鳶尾花數據集，包含了3種鳶尾花類別（Setosa、Versicolour、Virginica），每種類別有50個樣本，共計150個樣本。其中每個樣本中包含了4個屬性：花萼長度、花萼寬度、花瓣長度以及花瓣寬度，本實驗通過鳶尾花這4個屬性來判斷該樣本的類別。

3.3.1.2 數據清洗

• 缺失值分析

from sklearn.datasets import load_iris import pandas import numpy as npiris_features = np.array(load_iris().data, dtype=np.float32) iris_labels = np.array(load_iris().target, dtype=np.int32) print(pandas.isna(iris_features).sum()) print(pandas.isna(iris_labels).sum())

0
0

從輸出結果看，鳶尾花數據集中不存在缺失值的情況。

• 異常值處理

通過箱線圖直觀的顯示數據分布，并觀測數據中的異常值。

import matplotlib.pyplot as plt #可視化工具# 箱線圖查看異常值分布 def boxplot(features):feature_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']# 連續畫幾個圖片plt.figure(figsize=(5, 5), dpi=200)# 子圖調整plt.subplots_adjust(wspace=0.6)# 每個特征畫一個箱線圖for i in range(4):plt.subplot(2, 2, i+1)# 畫箱線圖plt.boxplot(features[:, i], showmeans=True, whiskerprops={"color":"#E20079", "linewidth":0.4, 'linestyle':"--"},flierprops={"markersize":0.4},meanprops={"markersize":1})# 圖名plt.title(feature_names[i], fontdict={"size":5}, pad=2)# y方向刻度plt.yticks(fontsize=4, rotation=90)plt.tick_params(pad=0.5)# x方向刻度plt.xticks([])plt.savefig('ml-vis.pdf')plt.show()boxplot(iris_features)

?從輸出結果看，數據中基本不存在異常值，所以不需要進行異常值處理。

3.3.1.3 數據讀取

本實驗中將數據集劃分為了三個部分：

• 訓練集：用于確定模型參數；
• 驗證集：與訓練集獨立的樣本集合，用于使用提前停止策略選擇最優模型；
• 測試集：用于估計應用效果（沒有在模型中應用過的數據，更貼近模型在真實場景應用的效果）。

在本實驗中，將80%的數據用于模型訓練，10%的數據用于模型驗證，10%的數據用于模型測試。代碼實現如下：

import copy import torch # 加載數據集 def load_data(shuffle=True):"""加載鳶尾花數據輸入：- shuffle：是否打亂數據，數據類型為bool輸出：- X：特征數據，shape=[150,4]- y：標簽數據, shape=[150]"""# 加載原始數據X = np.array(load_iris().data, dtype=np.float32)y = np.array(load_iris().target, dtype=np.int32)X = torch.tensor(X)y = torch.tensor(y)# 數據歸一化X_min = torch.min(X, dim=0)[0]X_max = torch.max(X, dim=0)[0]X = (X-X_min) / (X_max-X_min)# 如果shuffle為True，隨機打亂數據if shuffle:idx = torch.randperm(X.shape[0])X = X[idx]y = y[idx]return X, y# 固定隨機種子 torch.manual_seed(102)num_train = 120 num_dev = 15 num_test = 15X, y = load_data(shuffle=True) print("X shape: ", X.shape, "y shape: ", y.shape) X_train, y_train = X[:num_train], y[:num_train] X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev] X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]

X shape: ?torch.Size([150, 4]) y shape: ?torch.Size([150])

# 打印X_train和y_train的維度 print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)

X_train shape: ?torch.Size([120, 4]) y_train shape: ?torch.Size([120])

# 打印前5個數據的標簽 print(y_train[:5])

tensor([1, 2, 0, 1, 2], dtype=torch.int32)

3.3.2 模型構建

使用Softmax回歸模型進行鳶尾花分類實驗，將模型的輸入維度定義為4，輸出維度定義為3。代碼實現如下：

# 輸入維度 input_dim = 4 # 類別數 output_dim = 3 # 實例化模型 model = model_SR(input_dim=input_dim, output_dim=output_dim)

3.3.3 模型訓練

實例化RunnerV2類，使用訓練集和驗證集進行模型訓練，共訓練80個epoch，其中每隔10個epoch打印訓練集上的指標，并且保存準確率最高的模型作為最佳模型。代碼實現如下：

# 學習率 lr = 0.2# 梯度下降法 optimizer = SimpleBatchGD(init_lr=lr, model=model) # 交叉熵損失 loss_fn = MultiCrossEntropyLoss() # 準確率 metric = accuracy# 實例化RunnerV2 runner = RunnerV2(model, optimizer, metric, loss_fn)# 啟動訓練 runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=200, log_epochs=10, save_path="best_model.pdparams")

best accuracy performence has been updated: 0.00000 --> 0.46667
[Train] epoch: 0, loss: 1.09861159324646, score: 0.375
[Dev] epoch: 0, loss: 1.089357614517212, score: 0.46666666865348816
[Train] epoch: 10, loss: 0.9777261018753052, score: 0.699999988079071
[Dev] epoch: 10, loss: 1.023618221282959, score: 0.46666666865348816
[Train] epoch: 20, loss: 0.8894370794296265, score: 0.699999988079071
[Dev] epoch: 20, loss: 0.9739664793014526, score: 0.46666666865348816
[Train] epoch: 30, loss: 0.8196598291397095, score: 0.699999988079071
[Dev] epoch: 30, loss: 0.9317176938056946, score: 0.46666666865348816
[Train] epoch: 40, loss: 0.7635203003883362, score: 0.699999988079071
[Dev] epoch: 40, loss: 0.8957117199897766, score: 0.46666666865348816
[Train] epoch: 50, loss: 0.7176517248153687, score: 0.7250000238418579
[Dev] epoch: 50, loss: 0.864996075630188, score: 0.46666666865348816
[Train] epoch: 60, loss: 0.679577648639679, score: 0.7416666746139526
[Dev] epoch: 60, loss: 0.8386644721031189, score: 0.46666666865348816
[Train] epoch: 70, loss: 0.6474865078926086, score: 0.7583333253860474
[Dev] epoch: 70, loss: 0.8159360289573669, score: 0.46666666865348816
[Train] epoch: 80, loss: 0.6200525760650635, score: 0.7666666507720947
[Dev] epoch: 80, loss: 0.7961668372154236, score: 0.46666666865348816
[Train] epoch: 90, loss: 0.5962967276573181, score: 0.7833333611488342
[Dev] epoch: 90, loss: 0.7788369655609131, score: 0.46666666865348816
[Train] epoch: 100, loss: 0.5754876732826233, score: 0.8166666626930237
[Dev] epoch: 100, loss: 0.7635290622711182, score: 0.46666666865348816
best accuracy performence has been updated: 0.46667 --> 0.53333
[Train] epoch: 110, loss: 0.5570722222328186, score: 0.824999988079071
[Dev] epoch: 110, loss: 0.7499087452888489, score: 0.5333333611488342
best accuracy performence has been updated: 0.53333 --> 0.60000
[Train] epoch: 120, loss: 0.5406263470649719, score: 0.824999988079071
[Dev] epoch: 120, loss: 0.7377070188522339, score: 0.6000000238418579
[Train] epoch: 130, loss: 0.525819718837738, score: 0.8500000238418579
[Dev] epoch: 130, loss: 0.726706862449646, score: 0.6000000238418579
[Train] epoch: 140, loss: 0.5123931169509888, score: 0.8583333492279053
[Dev] epoch: 140, loss: 0.716731607913971, score: 0.6000000238418579
[Train] epoch: 150, loss: 0.5001395344734192, score: 0.875
[Dev] epoch: 150, loss: 0.7076371312141418, score: 0.6000000238418579
best accuracy performence has been updated: 0.60000 --> 0.66667
[Train] epoch: 160, loss: 0.4888923764228821, score: 0.875
[Dev] epoch: 160, loss: 0.6993042826652527, score: 0.6666666865348816
[Train] epoch: 170, loss: 0.4785163700580597, score: 0.875
[Dev] epoch: 170, loss: 0.6916342973709106, score: 0.6666666865348816
[Train] epoch: 180, loss: 0.46889936923980713, score: 0.875
[Dev] epoch: 180, loss: 0.6845448613166809, score: 0.6000000238418579
[Train] epoch: 190, loss: 0.45994895696640015, score: 0.875
[Dev] epoch: 190, loss: 0.6779663562774658, score: 0.6000000238418579

可視化觀察訓練集與驗證集的準確率變化情況。

?

3.3.4 模型評價

使用測試數據對在訓練過程中保存的最佳模型進行評價，觀察模型在測試集上的準確率情況。代碼實現如下：

# 加載最優模型 runner.load_model('best_model.pdparams') # 模型評價 score, loss = runner.evaluate([X_test, y_test]) print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

?[Test] score/loss: 0.7333/0.5928

調整學習率為0.5后：

[Test] score/loss: 0.8667/0.4477

發現score上升，loss下降，

調整學習率為0.01后：

[Test] score/loss: 0.6000/1.0979

此結果和logistic回歸類似，小的學習率收斂慢，還會過擬合將loss值升高。

調整epoch為5000后：

[Test] score/loss: 0.9333/0.2399

發現score明顯上升，loss明顯下降

調整epoch為10000后：

[Test] score/loss: 0.9333/0.2399

發現score和loss較50000沒有改變

此時模型與logistic回歸不同，沒有發生過擬合。

3.3.5 模型預測

使用保存好的模型，對測試集中的數據進行模型預測，并取出1條數據觀察模型效果。代碼實現如下：

# 預測測試集數據 logits = runner.predict(X_test) # 觀察其中一條樣本的預測結果 pred = torch.argmax(logits[0]).numpy() # 獲取該樣本概率最大的類別 label = y_test[0].numpy() # 輸出真實類別與預測類別 print("The true category is {} and the predicted category is {}".format(label, pred))

The true category is 2 and the predicted category is 2

3.4 SVM訓練Iris

分別使用線性核、多項式核與高斯核對Iris數據集的2/3數據訓練支持向量機，剩余1/3數據進行測試，計算正確率。

import math # 數學 import random # 隨機 import numpy as np import matplotlib.pyplot as pltdef zhichi_w(zhichi, xy, a): # 計算更新 ww = [0, 0]if len(zhichi) == 0: # 初始化的0return wfor i in zhichi:w[0] += a[i] * xy[0][i] * xy[2][i] # 更新ww[1] += a[i] * xy[1][i] * xy[2][i]return wdef zhichi_b(zhichi, xy, a): # 計算更新 bb = 0if len(zhichi) == 0: # 初始化的0return 0for s in zhichi: # 對任意的支持向量有 ysf(xs)=1 所有支持向量求解平均值sum = 0for i in zhichi:sum += a[i] * xy[2][i] * (xy[0][i] * xy[0][s] + xy[1][i] * xy[1][s])b += 1 / xy[2][s] - sumreturn b / len(zhichi)def SMO(xy, m):a = [0.0] * len(xy[0]) # 拉格朗日乘子zhichi = set() # 支持向量下標loop = 1 # 循環標記（符合KKT）w = [0, 0] # 初始化 wb = 0 # 初始化 bwhile loop:loop += 1if loop == 150:print("達到早停標準")print("循環了：", loop, "次")loop = 0break# 初始化=========================================fx = [] # 儲存所有的fxyfx = [] # 儲存所有yfx-1的值Ek = [] # Ek,記錄fx-y用于啟發式搜索E_ = -1 # 貯存最大偏差，減少計算a1 = 0 # SMO a1a2 = 0 # SMO a2# 初始化結束======================================# 尋找a1,a2======================================for i in range(len(xy[0])): # 計算所有的 fx yfx-1 Ekfx.append(w[0] * xy[0][i] + w[1] * xy[1][i] + b) # 計算 fx=wx+byfx.append(xy[2][i] * fx[i] - 1) # 計算 yfx-1Ek.append(fx[i] - xy[2][i]) # 計算 fx-yif i in zhichi: # 之前看過的不看了，防止重復找某個acontinueif yfx[i] <= yfx[a1]:a1 = i # 得到偏離最大位置的下標(數值最小的)if yfx[a1] >= 0: # 最小的也滿足KKTprint("循環了：", loop, "次")loop = 0 # 循環標記（符合KKT）置零(沒有用到)breakfor i in range(len(xy[0])): # 遍歷找間隔最大的a2if i == a1: # 如果是a1，跳過continueEi = abs(Ek[i] - Ek[a1]) # |Eki-Eka1|if Ei < E_: # 找偏差E_ = Ei # 儲存偏差的值a2 = i # 儲存偏差的下標# 尋找a1,a2結束===================================zhichi.add(a1) # a1錄入支持向量zhichi.add(a2) # a2錄入支持向量# 分析約束條件=====================================# c=a1*y1+a2*y2c = a[a1] * xy[2][a1] + a[a2] * xy[2][a2] # 求出c# n=K11+k22-2*k12if m == "xianxinghe": # 線性核n = xy[0][a1] ** 2 + xy[1][a1] ** 2 + xy[0][a2] ** 2 + xy[1][a2] ** 2 - 2 * (xy[0][a1] * xy[0][a2] + xy[1][a1] * xy[1][a2])elif m == "duoxiangshihe": # 多項式核(這里是二次)n = (xy[0][a1] ** 2 + xy[1][a1] ** 2) ** 2 + (xy[0][a2] ** 2 + xy[1][a2] ** 2) ** 2 - 2 * (xy[0][a1] * xy[0][a2] + xy[1][a1] * xy[1][a2]) ** 2else: # 高斯核 取 2σ^2 = 1n = 2 * math.exp(-1) - 2 * math.exp(-((xy[0][a1] - xy[0][a2]) ** 2 + (xy[1][a1] - xy[1][a2]) ** 2))# 確定a1的可行域=====================================if xy[2][a1] == xy[2][a2]:L = max(0.0, a[a1] + a[a2] - 0.5) # 下界H = min(0.5, a[a1] + a[a2]) # 上界else:L = max(0.0, a[a1] - a[a2]) # 下界H = min(0.5, 0.5 + a[a1] - a[a2]) # 上界if n > 0:a1_New = a[a1] - xy[2][a1] * (Ek[a1] - Ek[a2]) / n # a1_New = a1_old-y1(e1-e2)/n# print("x1=",xy[0][a1],"y1=",xy[1][a1],"z1=",xy[2][a1],"x2=",xy[0][a2],"y2=",xy[1][a2],"z2=",xy[2][a2],"a1_New=",a1_New)# 越界裁剪============================================================if a1_New >= H:a1_New = Helif a1_New <= L:a1_New = Lelse:a1_New = min(H, L)# 參數更新=======================================a[a2] = a[a2] + xy[2][a1] * xy[2][a2] * (a[a1] - a1_New) # a2更新a[a1] = a1_New # a1更新w = zhichi_w(zhichi, xy, a) # 更新wb = zhichi_b(zhichi, xy, a) # 更新b# print("W=", w, "b=", b, "zhichi=", zhichi, "a1=", a[a1], "a2=", a[a2])# 標記支持向量======================================for i in zhichi:if a[i] == 0: # 選了，但值仍為0loop = loop + 1e = 'silver'else:if xy[2][i] == 1:e = 'b'else:e = 'r'plt.scatter(x1[0][i], x1[1][i], c='none', s=100, linewidths=1, edgecolor=e)print("支持向量數為：", len(zhichi), "\na為零支持向量：", loop)print("有用向量數：", len(zhichi) - loop)# 返回數據 w b =======================================return [w, b]def panduan(xyz, w_b1, w_b2):c = 0for i in range(len(xyz[0])):if (xyz[0][i] * w_b1[0][0] + xyz[1][i] * w_b1[0][1] + w_b1[1]) * xyz[2][i][0] < 0:c = c + 1continueif (xyz[0][i] * w_b2[0][0] + xyz[1][i] * w_b2[0][1] + w_b2[1]) * xyz[2][i][1] < 0:c = c + 1continuereturn (1 - c / len(xyz[0])) * 100def huitu(x1, x2, wb1, wb2, name):x = [x1[0][:], x1[1][:], x1[2][:]]for i in range(len(x[2])): # 對訓練集‘上色’if x[2][i] == [1, 1]:x[2][i] = 'r' # 訓練集 1 1 紅色elif x[2][i] == [-1, 1]:x[2][i] = 'g' # 訓練集 -1 1 綠色else:x[2][i] = 'b' # 訓練集 -1 -1 藍色plt.scatter(x[0], x[1], c=x[2], alpha=0.8) # 繪點訓練集x = [x2[0][:], x2[1][:], x2[2][:]]for i in range(len(x[2])): # 對測試集‘上色’if x[2][i] == [1, 1]:x[2][i] = 'orange' # 訓練集 1 1 橙色elif x[2][i] == [-1, 1]:x[2][i] = 'y' # 訓練集 -1 1 黃色else:x[2][i] = 'm' # 訓練集 -1 -1 紫色plt.scatter(x[0], x[1], c=x[2], alpha=0.8) # 繪點測試集plt.xlabel('x') # x軸標簽plt.ylabel('y') # y軸標簽plt.title(name) # 標題xl = np.arange(min(x[0]), max(x[0]), 0.1) # 繪制分類線一yl = (-wb1[0][0] * xl - wb1[1]) / wb1[0][1]plt.plot(xl, yl, 'r')xl = np.arange(min(x[0]), max(x[0]), 0.1) # 繪制分類線二yl = (-wb2[0][0] * xl - wb2[1]) / wb2[0][1]plt.plot(xl, yl, 'b')# 主函數======================================================= f = open('Iris.txt', 'r') # 讀文件 x = [[], [], [], [], []] # 花朵屬性，(0,1,2,3),花朵種類 while 1:yihang = f.readline() # 讀一行if len(yihang) <= 1: # 讀到末尾結束breakfenkai = yihang.split('\t') # 按\t分開for i in range(4): # 分開的四個值x[i].append(eval(fenkai[i])) # 化為數字加到x中if (eval(fenkai[4]) == 1): # 將標簽化為向量形式x[4].append([1, 1])else:if (eval(fenkai[4]) == 2):x[4].append([-1, 1])else:x[4].append([-1, -1])print('數據集=======================================================') print(len(x[0])) # 數據大小 # 選擇數據=================================================== shuxing1 = eval(input("選取第一個屬性：")) if shuxing1 < 0 or shuxing1 > 4:print("無效選項，默認選擇第1項")shuxing1 = 1 shuxing2 = eval(input("選取第一個屬性：")) if shuxing2 < 0 or shuxing2 > 4 or shuxing1 == shuxing2:print("無效選項，默認選擇第2項")shuxing2 = 2 # 生成數據集================================================== lt = list(range(150)) # 得到一個順序序列 random.shuffle(lt) # 打亂序列 x1 = [[], [], []] # 初始化x1 x2 = [[], [], []] # 初始化x2 for i in lt[0:100]: # 截取部分做訓練集x1[0].append(x[shuxing1][i]) # 加上數據集x屬性x1[1].append(x[shuxing2][i]) # 加上數據集y屬性x1[2].append(x[4][i]) # 加上數據集c標簽 for i in lt[100:150]: # 截取部分做測試集x2[0].append(x[shuxing1][i]) # 加上數據集x屬性x2[1].append(x[shuxing2][i]) # 加上數據集y屬性x2[2].append(x[4][i]) # 加上數據集c標簽 print('\n\n開始訓練==============================================') print('\n線性核==============================================') # 計算 w b============================================ plt.figure(1) # 第一張畫布 x = [x1[0][:], x1[1][:], []] # 第一次分類 for i in x1[2]:x[2].append(i[0]) # 加上數據集標簽 wb1 = SMO(x, "xianxinghe") x = [x1[0][:], x1[1][:], []] # 第二次分類 for i in x1[2]:x[2].append(i[1]) # 加上數據集標簽 wb2 = SMO(x, "xianxinghe") print("w1為：", wb1[0], " b1為：", wb1[1]) print("w2為：", wb2[0], " b2為：", wb2[1]) # 計算正確率=========================================== print("訓練集上的正確率為：", panduan(x1, wb1, wb2), "%") print("測試集上的正確率為：", panduan(x2, wb1, wb2), "%") # 繪圖 =============================================== # 圈著的是曾經選中的值，灰色的是選中但更新為0 huitu(x1, x2, wb1, wb2, "xianxinghe") print('\n多項式核============================================') # 計算 w b============================================ plt.figure(2) # 第二張畫布 x = [x1[0][:], x1[1][:], []] # 第一次分類 for i in x1[2]:x[2].append(i[0]) # 加上數據集標簽 wb1 = SMO(x, "duoxiangshihe") x = [x1[0][:], x1[1][:], []] # 第二次分類 for i in x1[2]:x[2].append(i[1]) # 加上數據集標簽 wb2 = SMO(x, "duoxiangshihe") print("w1為：", wb1[0], " b1為：", wb1[1]) print("w2為：", wb2[0], " b2為：", wb2[1]) # 計算正確率=========================================== print("訓練集上的正確率為：", panduan(x1, wb1, wb2), "%") print("測試集上的正確率為：", panduan(x2, wb1, wb2), "%") # 繪圖 =============================================== # 圈著的是曾經選中的值，灰色的是選中但更新為0 huitu(x1, x2, wb1, wb2, "duoxiangshihe") print('\n高斯核==============================================') # 計算 w b============================================ plt.figure(3) # 第三張畫布 x = [x1[0][:], x1[1][:], []] # 第一次分類 for i in x1[2]:x[2].append(i[0]) # 加上數據集標簽 wb1 = SMO(x, "gaosihe") x = [x1[0][:], x1[1][:], []] # 第二次分類 for i in x1[2]:x[2].append(i[1]) # 加上數據集標簽 wb2 = SMO(x, "gaosihe") print("w1為：", wb1[0], " b1為：", wb1[1]) print("w2為：", wb2[0], " b2為：", wb2[1]) # 計算正確率=========================================== print("訓練集上的正確率為：", panduan(x1, wb1, wb2), "%") print("測試集上的正確率為：", panduan(x2, wb1, wb2), "%") # 繪圖 =============================================== # 圈著的是曾經選中的值，灰色的是選中但更新為0 huitu(x1, x2, wb1, wb2, "gaosihe") # 顯示所有圖 plt.show() # 顯示

?

線性核==============================================
循環了： 13 次
支持向量數為： 12?
a為零支持向量： 7
有用向量數： 5
循環了： 69 次
支持向量數為： 68?
a為零支持向量： 31
有用向量數： 37
w1為： [0.3172050400916382, -0.903111111111111] ?b1為： 1.423599618174875
w2為： [0.13003047759163255, -0.48005708869482205] ?b2為： 1.9588662762259441
訓練集上的正確率為： 97.0 %
測試集上的正確率為： 94.0 %

多項式核============================================
達到早停標準
循環了： 150 次
支持向量數為： 58?
a為零支持向量： 6
有用向量數： 52
達到早停標準
循環了： 150 次
支持向量數為： 88?
a為零支持向量： 16
有用向量數： 72
w1為： [-0.15104036408342042, -0.42676907221895527] ?b1為： 1.7115652617123134
w2為： [0.0016951361729040434, -0.1288161548404545] ?b2為： 0.7522268880681302
訓練集上的正確率為： 75.0 %
測試集上的正確率為： 74.0 %

高斯核==============================================
循環了： 6 次
支持向量數為： 5?
a為零支持向量： 3
有用向量數： 2
循環了： 68 次
支持向量數為： 67?
a為零支持向量： 57
有用向量數： 10
w1為： [-0.15000000000000013, -1.55] ?b1為： 4.604000000000001
w2為： [0.21169007613908675, -0.5635355081003279] ?b2為： 2.129028885189375
訓練集上的正確率為： 97.0 %
測試集上的正確率為： 92.0 %

?SVM的精度與訓練50000epoch的softmax分類模型差不多。

?心得體會：

本次實驗還是對上學期機器學習內容的復習，把上次實驗的線性回歸模型放在一起比較，

總的來說兩個問題本質上都是一致的，就是模型的擬合（匹配）。 但是分類問題的y值(也稱為label), 更離散化一些，而且， 同一個y值可能對應著一大批的x，這些x是具有一定范圍的。?
所以分類問題更多的是 (一定區域的一些x) 對應 著 (一個y)。而回歸問題的模型更傾向于 (很小區域內的x，或者一般是一個x) ?對應著 ?(一個y)，分類模型是將回歸模型的輸出離散化。

所以在把一個問題建模的時候一定要考慮好需求，讓你的模型更好的與現實問題相對應。

本次實驗還有一處問題是超參數的選擇，如何選擇學習率和訓練輪數可以使模型精度更高，模型訓練的時候一般把epoch設置多大達到模型收斂，如何設置動態學習率，這些問題都要在實驗后繼續研究。

這次寫實驗也是查閱了好多資料，抱著西瓜書、蒲公英書、魚書一起看，電腦cpu沒冒煙，我腦袋先冒煙了。

總結

以上是生活随笔為你收集整理的HBU-NNDL 实验四 线性分类的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。