Word2vec处理文本分类的pytroch实现

Word2vec是一种在自然语言处理中广泛使用的技术，它可以将单词映射到向量空间中，从而可以更好地处理文本数据。在文本分类任务中，我们可以使用Word2vec来将文本数据转换为向量表示，从而更好地进行分类。

下面是一个使用PyTorch实现Word2vec来处理文本分类的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from collections import Counter

#定义Word2Vec模型
class Word2Vec(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super(Word2Vec, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.linear1 = nn.Linear(embedding_dim, 128)
        self.linear2 = nn.Linear(128, vocab_size)

    def forward(self, x):
        x = self.embedding(x)
        x = torch.mean(x, dim=1)
        x = nn.functional.relu(self.linear1(x))
        x = self.linear2(x)
        return x

#定义数据预处理函数
def preprocess(text):
    words = text.lower().split()
    word_counts = Counter(words)
    sorted_vocab = sorted(word_counts, key=word_counts.get, reverse=True)
    int_to_vocab = {k: w for k, w in enumerate(sorted_vocab)}
    vocab_to_int = {w: k for k, w in int_to_vocab.items()}
    int_words = [vocab_to_int[w] for w in words]
    return int_words, vocab_to_int, int_to_vocab

#定义训练函数
def train(model, optimizer, criterion, data):
    for i in range(0, len(data), batch_size):
        inputs = np.array(data[i:i+batch_size])
        inputs = torch.from_numpy(inputs)
        targets = inputs.clone().detach()
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

#定义测试函数
def test(model, vocab_to_int, int_to_vocab, test_word):
    test_word_id = vocab_to_int[test_word]
    test_word_tensor = torch.from_numpy(np.array([test_word_id]))
    model.eval()
    with torch.no_grad():
        test_word_vector = model.embedding(test_word_tensor)
    similarities = []
    for i in range(len(vocab_to_int)):
        if i != test_word_id:
            word_tensor = torch.from_numpy(np.array([i]))
            with torch.no_grad():
                word_vector = model.embedding(word_tensor)
            similarity = torch.cosine_similarity(test_word_vector, word_vector)
            similarities.append((int_to_vocab[i], similarity.item()))
    similarities.sort(key=lambda x: x[1], reverse=True)
    for word, sim in similarities[:10]:
        print(word, sim)

#定义参数和数据
text = "Natural language processing is a subfield of linguistics, computer science, and artificial intelligence concerned with the interactions between computers and human language."
embedding_dim = 300
batch_size = 64
epochs = 100
lr = 0.001
data, vocab_to_int, int_to_vocab = preprocess(text)
vocab_size = len(int_to_vocab)
model = Word2Vec(vocab_size, embedding_dim)
optimizer = optim.Adam(model.parameters(), lr=lr)
criterion = nn.CrossEntropyLoss()

#训练模型
for epoch in range(epochs):
    train(model, optimizer, criterion, data)
    print("Epoch: {} / {}...".format(epoch+1, epochs))

#测试模型
test_word = "processing"
test(model, vocab_to_int, int_to_vocab, test_word)

在这个示例中，我们首先定义了一个Word2Vec模型，它包括一个嵌入层、一个线性层和一个ReLU激活函数。然后我们定义了一个数据预处理函数，它将原始文本转换为数字列表，并生成一些辅助的词汇表。接下来我们定义了一个训练函数，它将数据分成小批量，对模型进行训练。最后，我们定义了一个测试函数，它使用余弦相似度比较某个单词与词汇表中的其他单词之间的相似度，并打印出最相似的10个单词。

在这个示例中，我们使用了一个简单的文本数据，并对其进行了训练和测试。如果你想处理更大的数据集，你可以将代码稍微修改一下，例如使用数据加载器来加载数据，或者使用更复杂的模型来获得更好的性能。