python - 多次拟合相同的 SVM 模型后得到略有不同的 SVM 模型

Question

我正在做数据挖掘作业，我想通过投票应用一些集成学习。因此，我希望我可以通过一个一个地创建它们来获得多个 SVM 模型的副本，它们之间存在细微的差异，因为我可以在 RNN 模型上做同样的事情。

但是，我发现，例如，在拟合我的 SVM 30 次后，我得到了 30 个相同的模型，而在我拟合 RNN 模型后，我可以得到 30 个稍微不同的 RNN 模型。

你能建议任何方法在 SVM 中做同样的事情吗？非常感谢！

标签： pythonscikit-learndeep-learningsvm

Answer 1

SVM：最大边距分类器

每次都获得相同的 SVM 模型的原因是因为 SVM 是最大边距分类器，或者换句话说，它们最大化了分隔 +ve 和 -ve 类的边距。因此，无论您从哪个随机状态开始运行它，它总是最终找到与 +ve 类和 -ve 类的边距最大的超平面。

其他非最大边距分类器，例如简单的感知器，试图最小化损失，您可以将简单损失视为错误分类的数据点的数量。我们通常使用其他类型的（可微分的）损失函数，它们对应于模型预测的可信度。

例子

感知器

X = np.r_[np.random.randn(10, 2) - [2, 2], np.random.randn(10, 2) + [2, 2]]
y = [0] * 10 + [1] * 10

def plot_it(clf, X):     
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
                         np.arange(y_min, y_max, 0.1))

    Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])

    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=.8)    
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired)
    plt.xticks([])
    plt.yticks([])


plt.close('all')
plt.figure()
seeds = [0,10,20,30,40,50]
for i in range(1,7):
    plt.subplot(2,3,i)    
    clf = Perceptron(random_state=seeds[i-1])
    clf.fit(X,y)    
    plot_it(clf, X)    
plt.tight_layout()
plt.show()

上图显示了感知器用不同的种子（初始化）识别的决策边界。如您所见，所有模型都正确分类了数据点，但哪个模型最好？当然，它概括了看不见的数据，这将是在决策边界周围有足够余量来覆盖看不见的数据的数据。这就是 SVM 过度救援的地方。

支持向量机

plt.close('all')
plt.figure()
seeds = [0,10,20,30,40,50]
for i in range(1,7):
    plt.subplot(2,3,i)    
    clf = LinearSVC(random_state=seeds[i-1])
    clf.fit(X,y)    
    plot_it(clf, X)    
plt.tight_layout()  
plt.show()

正如您所看到的，无论随机种子如何，SVM 总是返回相同的决策边界，即最大化边际的决策边界。

使用 RNN，您每次都会得到不同的模型，因为 RNN 不是最大边距分类器。此外，RNN 收敛标准是手动的，即我们决定何时停止训练过程，如果我们决定将其运行固定数量的 epoch，则取决于权重初始化，模型的最终权重会有所不同。

长短期记忆体

import torch
from torch import nn
from torch import optim

def plot_rnn(lstm, X):     
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
                         np.arange(y_min, y_max, 0.1))

    p = np.c_[xx.ravel(), yy.ravel()]
    xt = torch.FloatTensor(p.reshape(-1,1,2).transpose(1, 0, 2))

    s = nn.Sigmoid()
    Z,_ = lstm(xt)
    Z = s(Z.view(len(p)))

    Z = Z.detach().numpy().reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=.8)    
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired)
    plt.xticks([])
    plt.yticks([])

def train(X, y):
    batch_size = 20
    input_size = 2
    time_steps = 1
    output_size = 1

    xt = torch.FloatTensor(X.reshape(batch_size,time_steps,input_size).transpose(1, 0, 2))
    yt = torch.FloatTensor(y)

    lstm = nn.LSTM(input_size, output_size, 1)
    s = nn.Sigmoid()
    loss_function = nn.BCELoss()
    optimizer = optim.SGD(lstm.parameters(), lr=0.05)

    for i in range(1000):
        lstm.zero_grad()
        y_hat,_ = lstm(xt)
        y_hat = y_hat.view(20)
        y_hat = s(y_hat)
        loss = loss_function(y_hat, yt)
        loss.backward()
        optimizer.step()
        #print (loss.data)
    return lstm

plt.close('all')
plt.figure()
for i in range(1,7):
    plt.subplot(2,3,i)    
    clf = train(X,y)    
    plot_rnn(clf, X)    

plt.tight_layout()
plt.show()