基于线性支持向量机的词嵌入文本分类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 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

四、运行结果

这里这里 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])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

---

五、损失函数

介绍nn.HingeEmbeddingLoss并使用

nn.HingeEmbeddingLoss是PyTorch中用于计算支持向量机的损失函数之一。它的作用是通过一个间隔边界将正样本和负样本分开。具体来说，该损失函数使用了一个margin参数，表示正负样本之间的间隔边界，然后计算正样本与该边界之间的距离和负样本与该边界之间的距离，并将它们相加。

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

$$loss(x,y)=\frac{1}{N}\sum _{i=1}^N\max (0,-y_i(x_i\cdot 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}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

在上面的例子中，首先加载鸢尾花数据集并进行标准化处理。然后定义了一个包含一个线性层的模型，使用nn.HingeEmbeddingLoss是一个PyTorch中的损失函数，用于支持向量机（SVM）学习。在SVM中，目标是将两个类别的数据分开，并且在最大化间隔的同时最小化错误分类的数量。Hinge损失函数是一种常用的SVM损失函数，它对正确分类的样本给予0损失，对于错误分类的样本给予一个非零的损失，损失随着距离正确分类边界的距离线性增加。

HingeEmbeddingLoss需要输入一个标量值作为阈值，将大于等于该阈值的样本视为正样本，将小于该阈值的样本视为负样本。具体而言，对于一个大小为$N$的批次，标签$y$应该是一个大小为$N$的张量，其中1表示正类，-1表示负类。如果$y_i=0$，则样本$i$将被忽略，即不计入损失函数中。