一、前言
简介线性支持向量机,并使用线性支持向量机实现文本分类, 输入文本通过词嵌入方法转换成浮点张量,给出torch案例
线性支持向量机（Linear Support Vector Machine，简称Linear SVM）是一种常用的分类算法，它通过一个超平面来将数据分成两类。对于线性可分的数据集，线性SVM能够找到一个最优的超平面，使得距离最近的数据点到这个超平面的距离最大化，从而使得分类边界更加稳定。
二、项目介绍
在文本分类任务中，我们可以使用线性SVM来将文本分成两类，比如正面和负面。首先需要将文本转换成数字表示，这可以通过词嵌入（Word Embedding）方法来实现。词嵌入是将单词转换成向量表示的一种技术，它可以将单词之间的语义关系表达为向量之间的距离关系。在文本分类任务中，我们可以将每个单词转换成一个固定长度的向量，然后将所有单词的向量按照一定的顺序组合成一个文本向量，从而得到文本的数字表示。
三、Toy demo 项目展示
下面是使用PyTorch实现文本分类任务的示例代码，其中使用了线性SVM作为分类器：
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
class LinearSVM(nn.Module):
def __init__(self, input_size):
super(LinearSVM, self).__init__()
self.linear = nn.Linear(input_size, 1)
def forward(self, x):
out = self.linear(x)
return out
class TextDataset(torch.utils.data.Dataset):
def __init__(self, texts, labels, word_embedding):
self.texts = texts
self.labels = labels
self.word_embedding = word_embedding
def __getitem__(self, index):
text = self.texts[index]
label = self.labels[index]
text_vec = np.mean([self.word_embedding[word] for word in text.split() if word in self.word_embedding], axis=0)
text_vec = torch.from_numpy(text_vec).float()
return text_vec, label
def __len__(self):
return len(self.labels)
# 定义超参数
embedding_size = 50
lr = 0.01
num_epochs = 10
# 加载数据集
train_texts = ['good movie', 'not a good movie', 'bad movie', 'an excellent movie', 'i loved it', 'could have been better', 'completely ridiculous', 'not worth watching', 'it was okay', 'awesome movie']
train_labels = [1., -1, -1, 1, 1, -1, -1, -1, 0, 1]
word_embedding = {'good': np.random.rand(embedding_size), 'movie': np.random.rand(embedding_size), 'not': np.random.rand(embedding_size), 'bad': np.random.rand(embedding_size), 'an': np.random.rand(embedding_size), 'excellent': np.random.rand(embedding_size), 'i': np.random.rand(embedding_size), 'loved': np.random.rand(embedding_size), 'it': np.random.rand(embedding_size), 'could': np.random.rand(embedding_size), 'have': np.random.rand(embedding_size), 'been': np.random.rand(embedding_size), 'better': np.random.rand(embedding_size), 'completely': np.random.rand(embedding_size), 'ridiculous': np.random.rand(embedding_size), 'worth': np.random.rand(embedding_size), 'watching': np.random.rand(embedding_size), 'was': np.random.rand(embedding_size), 'okay': np.random.rand(embedding_size), 'awesome': np.random.rand(embedding_size)}
train_dataset = TextDataset(train_texts, train_labels, word_embedding)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=2, shuffle=True)
# 定义模型、损失函数和优化器
model = LinearSVM(embedding_size)
criterion = nn.HingeEmbeddingLoss()
optimizer = optim.SGD(model.parameters(), lr=lr)
# 训练模型
for epoch in range(num_epochs):
for batch_data in train_dataloader:
# print(batch_data)
x, y = batch_data
print("这里这里", y)
x = x.unsqueeze(1)
model.zero_grad()
out = model(x)
loss = criterion(out.squeeze(), y.float())
loss.backward()
optimizer.step()
print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
# 测试模型
test_texts = ['good film', 'bad film']
test_labels = [1, -1]
test_dataset = TextDataset(test_texts, test_labels, word_embedding)
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=2, shuffle=False)
with torch.no_grad():
for batch_data in test_dataloader:
x, y = batch_data
x = x.unsqueeze(1)
out = model(x)
predicted = torch.sign(out.squeeze())
print('Predicted:', predicted)
print('True:', y)
四、运行结果
这里这里 tensor([-1, 1])
这里这里 tensor([ 1, -1])
这里这里 tensor([1., 1.], dtype=torch.float64)
这里这里 tensor([ 0, -1])
这里这里 tensor([-1, -1])
Epoch [1/10], Loss: 0.8326
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([-1, -1])
这里这里 tensor([-1, -1])
这里这里 tensor([ 1, -1])
这里这里 tensor([1, 1])
这里这里 tensor([1., 0.], dtype=torch.float64)
Epoch [2/10], Loss: 0.7192
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([1., 1.])
这里这里 tensor([-1, 0])
这里这里 tensor([-1, -1])
这里这里 tensor([1, 1])
这里这里 tensor([-1, -1])
Epoch [3/10], Loss: 0.7749
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([-1, 1])
这里这里 tensor([ 1, -1])
这里这里 tensor([ 0, -1])
这里这里 tensor([-1, 1])
这里这里 tensor([ 1., -1.], dtype=torch.float64)
Epoch [4/10], Loss: 0.5134
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([ 1., -1.], dtype=torch.float64)
这里这里 tensor([-1, 1])
这里这里 tensor([-1, -1])
这里这里 tensor([0, 1])
这里这里 tensor([-1, 1])
Epoch [5/10], Loss: 0.3517
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([-1, 1])
这里这里 tensor([1., 0.], dtype=torch.float64)
这里这里 tensor([ 1, -1])
这里这里 tensor([-1, -1])
这里这里 tensor([-1, 1])
Epoch [6/10], Loss: 0.4878
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([-1, 1])
这里这里 tensor([1, 1])
这里这里 tensor([-1, -1])
这里这里 tensor([-1., 1.])
这里这里 tensor([ 0, -1])
Epoch [7/10], Loss: 0.6830
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([-1, 1])
这里这里 tensor([-1, -1])
这里这里 tensor([-1, 1])
这里这里 tensor([0., 1.])
这里这里 tensor([ 1, -1])
Epoch [8/10], Loss: 0.5232
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([0, 1])
这里这里 tensor([ 1, -1])
这里这里 tensor([-1, -1])
这里这里 tensor([ 1, -1])
这里这里 tensor([ 1., -1.], dtype=torch.float64)
Epoch [9/10], Loss: 0.4531
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
这里这里 tensor([-1, -1])
这里这里 tensor([1, 1])
这里这里 tensor([-1, 1])
这里这里 tensor([-1, 0])
这里这里 tensor([-1., 1.])
Epoch [10/10], Loss: 0.3971
Predicted: tensor([1., 1.])
True: tensor([ 1, -1])
五、损失函数
介绍
nn.HingeEmbeddingLoss并使用
nn.HingeEmbeddingLoss是PyTorch中用于计算支持向量机的损失函数之一。它的作用是通过一个间隔边界将正样本和负样本分开。具体来说，该损失函数使用了一个margin参数，表示正负样本之间的间隔边界，然后计算正样本与该边界之间的距离和负样本与该边界之间的距离，并将它们相加。
该损失函数的数学公式如下：
l o s s ( x , y ) = 1 N ∑ i = 1 N max ( 0 , − y i ( x i ⋅ w − b ) + m a r g i n ) loss(x,y) = \frac{1}{N}\sum_{i=1}^{N} \max(0, -y_i(x_i\cdot w - b) + margin) loss(x,y)=N1i=1∑Nmax(0,−yi(xi⋅w−b)+margin)
其中， x x x表示输入样本， y y y表示对应的标签， w w w表示模型的权重， b b b表示模型的偏置， N N N表示样本数量， m a r g i n margin margin表示间隔边界。
在计算损失时，如果一个样本被正确地分类，则该样本的损失为0，否则根据该样本的标签和预测值，计算出该样本的距离，然后与 m a r g i n margin margin进行比较，得到该样本的损失值。
下面是一个使用nn.HingeEmbeddingLoss进行二分类任务的例子，其中使用的数据集为sklearn中的鸢尾花数据集：
import torch
import torch.nn as nn
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# 加载数据集并进行预处理
iris = load_iris()
X, y = iris.data, iris.target
scaler = StandardScaler()
X = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# 定义模型、损失函数和优化器
model = nn.Linear(4, 1)
criterion = nn.HingeEmbeddingLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# 训练模型
num_epochs = 100
batch_size = 16
for epoch in range(num_epochs):
for i in range(0, len(X_train), batch_size):
inputs = torch.FloatTensor(X_train[i:i+batch_size])
labels = torch.FloatTensor(y_train[i:i+batch_size])
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs.squeeze(), labels.float())
loss.backward()
optimizer.step()
# 计算测试集准确率
with torch.no_grad():
inputs = torch.FloatTensor(X_test)
labels = torch.FloatTensor(y_test)
outputs = model(inputs).squeeze()
predicted = torch.sign(outputs)
accuracy = (predicted == labels).sum().item() / len(y_test)
print(f"Epoch {epoch+1}: Loss={loss.item():.4f}, Accuracy={accuracy:.4f}")
在上面的例子中，首先加载鸢尾花数据集并进行标准化处理。然后定义了一个包含一个线性层的模型，使用nn.HingeEmbeddingLoss是一个PyTorch中的损失函数，用于支持向量机（SVM）学习。在SVM中，目标是将两个类别的数据分开，并且在最大化间隔的同时最小化错误分类的数量。Hinge损失函数是一种常用的SVM损失函数，它对正确分类的样本给予0损失，对于错误分类的样本给予一个非零的损失，损失随着距离正确分类边界的距离线性增加。
HingeEmbeddingLoss需要输入一个标量值作为阈值，将大于等于该阈值的样本视为正样本，将小于该阈值的样本视为负样本。具体而言，对于一个大小为
N
N
N的批次，标签
y
y
y应该是一个大小为
N
N
N的张量，其中1表示正类，-1表示负类。如果
y
i
=
0
y_i = 0
yi=0，则样本
i
i
i将被忽略，即不计入损失函数中。