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

旧城等待， 2023-09-30 23:35 14阅读 0赞

![在这里插入图片描述][1083b2c6353d46ee88917176dc0dcacc.png]

### 一、前言 ###

> 简介线性支持向量机,并使用线性支持向量机实现文本分类, 输入文本通过词嵌入方法转换成浮点张量,给出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将被忽略，即不计入损失函数中。

[1083b2c6353d46ee88917176dc0dcacc.png]: https://img-blog.csdnimg.cn/1083b2c6353d46ee88917176dc0dcacc.png