对同一个支持向量机模型进行多次拟合，得到略有不同的支持向量机模型

Question

我正在做一个数据挖掘的家庭作业，我想用投票来应用一些令人困惑的学习。因此，我希望通过逐个创建SVM模型，可以得到多个略有不同的SVM模型副本，因为我可以在RNN模型上做同样的事情。

然而，我发现，例如，我得到30个相同的模型后，拟合我的支持向量机30次，而我可以得到30个略有不同的模型后，我拟合的RNN模型。你知道吗

在支持向量机中，你能建议任何方法来做同样的事情吗？非常感谢你！你知道吗

Answer 1

最大边缘分类器

每次都得到相同的SVM模型的原因是因为SVM是max-margin分类器，或者换句话说，它们最大化了分隔+ve和-ve类的margin。所以不管你在什么样的随机状态下运行它，它总会找到一个超平面，这个超平面到+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()

如您所见，不管随机种子，支持向量机总是返回相同的决策边界，即最大化边际的决策边界。你知道吗

有了RNN，你每次都会得到一个不同的模型，因为RNN不是一个最大边际分类器。此外，RNN收敛标准是手动的，即我们决定何时停止训练过程，如果我们决定运行固定次数的历元，则取决于权重初始化，模型的最终权重将发生变化。你知道吗

LSTM公司

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()