用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 等技术来加速训练和提高效果。