基于线性支持向量机的词嵌入文本分类torch案例

一、前言

简介线性支持向量机,并使用线性支持向量机实现文本分类, 输入文本通过词嵌入方法转换成浮点张量,给出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 npclass 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 outclass TextDataset(torch.utils.data.Dataset):def __init__(self, texts, labels, word_embedding):self.texts = textsself.labels = labelsself.word_embedding = word_embeddingdef __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, labeldef __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_dataprint("这里这里", 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_datax = 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参数，表示正负样本之间的间隔边界，然后计算正样本与该边界之间的距离和负样本与该边界之间的距离，并将它们相加。

该损失函数的数学公式如下：

loss(x,y)=1N∑i=1Nmax⁡(0,−yi(xi⋅w−b)+margin)loss(x,y) = \\frac{1}{N}\\sum_{i=1}^{N} \\max(0, -y_i(x_i\\cdot w - b) + margin)loss(x,y)=N1​i=1∑N​max(0,−yi​(xi​⋅w−b)+margin)

其中，$x$表示输入样本，$y$表示对应的标签，$w$表示模型的权重，$b$表示模型的偏置，$N$表示样本数量，$margin$表示间隔边界。

在计算损失时，如果一个样本被正确地分类，则该样本的损失为0，否则根据该样本的标签和预测值，计算出该样本的距离，然后与$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$的批次，标签$y$应该是一个大小为$N$的张量，其中1表示正类，-1表示负类。如果yi=0y_i = 0yi​=0，则样本$i$将被忽略，即不计入损失函数中。

化学之窗