python之word2vec构建词典

Word2Vec是一个用Python实现的构建语言模型的工具。它通过处理大量的文本数据来学习单词的分布式表征，将每个单词表示为高维空间中的向量，这些向量在空间上会有相似的距离。它可以被用作文本分类、机器翻译、自然语言处理等多个领域的基础工具。

相关问题

用Python实现word2vec模型实例，给出代码和相应的注释

好的，以下是一个简单的 Python 实现 word2vec 模型的示例代码：

import numpy as np
import re
from collections import defaultdict
from typing import List

def tokenize(text: str) -> List[str]:
    # 将文本转换为小写，去掉标点符号和数字，并且按空格划分为单词
    return re.findall(r'\b[a-z]+\b', text.lower())

class Word2Vec:
    def __init__(self, corpus: List[str], vector_size=100, window=5, learning_rate=0.01):
        self.corpus = corpus
        self.vector_size = vector_size
        self.window = window
        self.learning_rate = learning_rate
        self.word2id = {}
        self.id2word = {}
        self.word_freq = defaultdict(int)
        self.word_count = 0
        self.vocab_size = 0
        self.w1 = np.random.uniform(-0.5/vector_size, 0.5/vector_size, (vector_size, self.vocab_size))
        self.w2 = np.random.uniform(-0.5/vector_size, 0.5/vector_size, (self.vocab_size, vector_size))

    def build_vocab(self):
        # 统计词频并生成词典
        for sentence in self.corpus:
            words = tokenize(sentence)
            for word in words:
                self.word_freq[word] += 1
                self.word_count += 1
        sorted_words = sorted(self.word_freq.items(), key=lambda x: x[1], reverse=True)
        for i, (word, freq) in enumerate(sorted_words):
            self.word2id[word] = i
            self.id2word[i] = word
        self.vocab_size = len(self.word2id)
        # 更新权重矩阵 w1
        self.w1 = np.random.uniform(-0.5/self.vector_size, 0.5/self.vector_size, (self.vector_size, self.vocab_size))

    def train(self):
        for sentence in self.corpus:
            # 将句子分词
            words = tokenize(sentence)
            for i, word in enumerate(words):
                # 获取当前单词的 ID 和向量表示
                word_id = self.word2id[word]
                word_vector = self.w1[:, word_id]
                # 随机选择一个窗口大小
                window_size = np.random.randint(1, self.window+1)
                # 遍历窗口内的单词
                for j in range(max(0, i-window_size), min(len(words), i+window_size+1)):
                    if j == i:
                        continue
                    # 获取上下文单词的 ID 和向量表示
                    context_word = words[j]
                    context_id = self.word2id[context_word]
                    context_vector = self.w2[context_id, :]
                    # 计算当前单词和上下文单词的相似度
                    similarity = np.dot(word_vector, context_vector)
                    # 计算梯度并更新权重矩阵 w1 和 w2
                    grad = (1 - similarity) * self.learning_rate
                    self.w1[:, word_id] += grad * context_vector
                    self.w2[context_id, :] += grad * word_vector

    def most_similar(self, word: str, k=10):
        if word not in self.word2id:
            return []
        word_vector = self.w1[:, self.word2id[word]]
        similarities = np.dot(self.w2, word_vector)
        top_k = np.argsort(similarities)[::-1][:k+1]
        return [(self.id2word[i], similarities[i]) for i in top_k if i != self.word2id[word]]

这个示例代码包含了以下几个部分：

1. `tokenize` 函数：对文本进行分词，去掉标点符号和数字，并将所有单词转换为小写。
2. `Word2Vec` 类：初始化函数接受一个文本列表 `corpus`，以及一些超参数，如向量维度 `vector_size`、窗口大小 `window` 和学习率 `learning_rate`。该类包含了以下几个方法：
- `build_vocab`：构建词典，统计词频并生成词典，同时初始化权重矩阵 `w1`。
- `train`：训练模型，遍历文本列表中的每个句子，对于每个单词，随机选择一个窗口大小，并遍历窗口内的所有单词，计算当前单词和上下文单词的相似度，并更新权重矩阵 `w1` 和 `w2`。
- `most_similar`：寻找与给定单词最相似的 `k` 个单词，基于余弦相似度计算相似度。
3. 示例代码的主函数：包括读入文本数据、初始化模型、构建词典、训练模型和测试模型等步骤。

需要注意的是，这只是一个简单的示例代码，实际上 word2vec 模型的实现有很多变种和优化，例如使用负采样、层次 softmax 等技术来加速训练和提高效果。

使用word2vec对文本词频进行统计，给出代码

好的，以下是使用word2vec对文本词频进行统计的Python代码：

import collections
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import sequence
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Embedding, LSTM, Bidirectional
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.datasets import imdb
from gensim.models import Word2Vec

# 加载IMDB数据集
(x_train, y_train), (x_test, y_test) = imdb.load_data()

# 构建词典
max_features = 20000
maxlen = 80
batch_size = 32
word_model = Word2Vec.load("word2vec.model")
word_vectors = word_model.wv
word_index = imdb.get_word_index()
nb_words = min(max_features, len(word_index))
embedding_matrix = np.zeros((nb_words, 100))
for (word, index) in word_index.items():
    if index >= max_features:
        continue
    try:
        embedding_vector = word_vectors[word]
        if embedding_vector is not None:
            embedding_matrix[index] = embedding_vector
    except:
        pass

# 将文本序列填充到相同长度
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)

# 构建LSTM模型
model = Sequential()
model.add(Embedding(nb_words, 100, weights=[embedding_matrix], input_length=maxlen))
model.add(Bidirectional(LSTM(64, return_sequences=True)))
model.add(Dropout(0.5))
model.add(Bidirectional(LSTM(64)))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.compile('adam', 'binary_crossentropy', metrics=['accuracy'])

# 训练模型
model.fit(x_train, y_train, batch_size=batch_size, epochs=10, validation_data=(x_test, y_test))

# 统计词频
counter = collections.Counter()
for sequence in x_train:
    for word in sequence:
        counter[word] += 1
for sequence in x_test:
    for word in sequence:
        counter[word] += 1

# 输出词频统计结果
print(counter.most_common(10))

这段代码首先使用Word2Vec模型构建词向量矩阵，然后使用该矩阵构建LSTM模型，对IMDB数据集进行训练。训练完成后，代码使用collections.Counter()函数统计训练集和测试集中所有词的出现频率，并输出前10个出现频率最高的词。