Word2Vec 实践
gensim库使用
这里的Word2Vec借助 gensim 库实现，首先安装pip install gensim==3.8.3
from gensim.models.word2vec import Word2Vec
model = Word2Vec(
sentences=None,
size=100,
alpha=0.025,
window=5,
min_count=5,
max_vocab_size=None,
sample=1e-3,
seed=1,
workers=3,
min_alpha=0.0001,
sg=0, hs=0,
negative=5,
cbow_mean=1,
hashfxn=hash,
iter=5,
null_word=0,
trim_rule=None,
sorted_vocab=1,
batch_words=MAX_WORDS_IN_BATCH
)
参数说明：
- sentences：可以是一个list，对于大语料集，建议使用BrownCorpus,Text8Corpus或lineSentence构建。
- size：是指特征向量的维度，默认为100
- alpha: 是初始的学习速率，在训练过程中会线性地递减到min_alpha
- window：窗口大小，表示当前词与预测词在一个句子中的最大距离是多少
- min_count: 可以对字典做截断，词频少于min_count次数的单词会被丢弃掉, 默认值为5
- max_vocab_size: 设置词向量构建期间的RAM限制，设置成None则没有限制
- sample: 高频词汇的随机降采样的配置阈值，默认为1e-3，范围是(0,1e-5)
- seed：用于随机数发生器。与初始化词向量有关
- workers：用于控制训练的并行数
- min_alpha：学习率的最小值
- sg： 用于设置训练算法，默认为0，对应CBOW算法；sg=1则采用skip-gram算法
- hs: 如果为1则会采用hierarchica·softmax技巧。如果设置为0（默认），则使用negative sampling
- negative: 如果>0,则会采用negativesampling，用于设置多少个noise words（一般是5-20）
- cbow_mean: 如果为0，则采用上下文词向量的和，如果为1（default）则采用均值，只有使用CBOW的时候才起作用
- hashfxn： hash函数来初始化权重，默认使用python的hash函数
- iter： 迭代次数，默认为5
- trim_rule： 用于设置词汇表的整理规则，指定那些单词要留下，哪些要被删除。可以设置为None（min_count会被使用）
- sorted_vocab： 如果为1（默认），则在分配word index 的时候会先对单词基于频率降序
- batch_words：每一批的传递给线程的单词的数量，默认为10000
关于sentences参数的更多说明： 中文的或者英文的文章都可以，一般一篇文章就是一行，要经过预处理才能使用，将文本语料进行分词，以空格,tab隔开都可以。可以是读入数据以后为list的语料，一般是二维list，每一个子list是一篇文章切词后的形式 。
from gensim.models.word2vec import LineSentence
LineSentence(file_path)
LinSentence 函数在使用之前需要对待处理的文本数据进行分词，并以空格分隔；函数在运行时，按行读取已经以空格分隔的文档。
保存和加载训练得到的词向量：
# 二进制形式
model.save('word2vec.model') # 保存
model = Word2Vec.load('word2vec.model') # 加载
# 文本文件形式
model.wv.save_word2vec_format('word2vec.txt', binary=False) # 保存
# 加载txt词向量
model = gensim.models.KeyedVectors.load_word2vec_format('word2vec.txt')
获取训练得到的词表
vocab = wv_model.wv.vocab
本部分参考博客链接：https://blog.csdn.net/weixin_41097516/article/details/103320098
数据预处理
有这样一批来自汽车大师的文本信息，包括问题ID（QID）、品牌(Brand)、车型(Model)、用户问题(Question)、Dialogue(对话)和解决方法(Report)。
这里截图来自pycharm的展示，因为文本内容过大，展示不完整，具体拿出来两条数据看下：
QID: Q5001
Brand: 福特
Model: 福克斯
Question: 长安福特福克斯，突然打不着车
Dialogue: 技师说：你好车主，根据提供图片，这是车辆防盗系统起作用了，需要从新匹配车辆的所有的钥匙。|车主说：哦|技师说：需要联系当地4s店，或者专业做汽车钥匙的|车主说：OK
Report: 根据提供图片，这是车辆防盗起作用了，需要从新匹配钥匙。
QID: Q5002
Brand: 路虎
Model: 揽胜运动版
Question: 路虎电动脚踏板无反应，请问是什么原因，如何解决？
Dialogue：技师说：电机接触不良吧|车主说：不是，是因为车主右边踏板底盘被刮了，踏板支架被挂断了，现在修复了，但是感觉电机在响，电动踏板不回位，请问如何复位或者匹配脚踏板？|技师说：是不是与踏板脱槽了|车主说：是的，电机之前和踏板脱槽了，现在已经修复上了，但是踏板不正常，开关门几次后现在再开关门有电机声音，但是不复位|技师说：踏板变形了吗？|车主说：现在如何解决？需要匹配电机|车主说：吗|车主说：踏板没变形|技师说：他这个有专门的开关吗？|车主说：16款运动揽胜|技师说：你按开关十秒左右看看能匹配上不|车主说：开关在什么位置|技师说：它开关是怎么控制的|车主说：开门和关门控制的|车主说：[图片]|车主说：这个是开关控制吗|技师说：你常按10秒以上这个开关能学习上不能|车主说：这个是减震放气的|车主说：我按了，就放气|技师说：你按遥控器上的按键试下|车主说：车架号是 SALGA3FV9HA334882|车主说：[图片]|技师说：你找个电脑匹配一下试试|车主说：没反应|车主说：用了，电脑里面关于脚踏板只有维修模式启用和禁用|车主说：都试了，没有用|技师说：那你找当地的专业维修这款车的人员给你看看|车主说：没有复位匹配的方法吗|车主说：我自己就是学修车的，不找别人，咨询可以，要靠自己修|技师说：没有，我修这车也不多
Report: 检查踏板与电机是否托槽
训练集 77943条数据，测试集 5000条数据
项目的最终目标是做一个文本摘要的模型，但是第一步要训练生成词向量，本篇文章研究词向量如何生成。
预处理包括以下步骤：
- 使用pandas加载cvs格式的训练数据和测试数据；
- 剔除report字段为空的数据，之后将所有空值替换为空字符串；
- 对文本进行分词（这里使用jieba分词），并先加载自定义词表，避免这些词被分割；
- 过滤掉停用词。
自定义词表部分示例
语音
图片
车主说
技师说
档位
长安
冲击感
漏机油
故障码
安全码
钣金
双离合
油底壳
翼子板
擦车
值
拓下来
副作用
扎胎
分泵轴
双闪
不客气
外球笼
一控三
中控
宝马X1
奔驰
宝马
Jeep
雪佛兰
丰田
昌河
长安
吉利汽车
因为对话中包含图片、语音这类数据，但是被[图片]、[语音]标签替代了，所以在分词时，要考虑到这种情况，在分词后把这些词和字符删掉。
以下代码预处理步骤3、4的实现
import jieba
# 配置文件中存储了一系列路径
from src.utils import config
# 自定义词表
jieba.load_userdict(config.user_dict)
def load_stop_words(stop_word_path):
"""加载停用词
:param stop_word_path:停用词路径
:return: 停用词表 list
"""
# 打开文件
file = open(stop_word_path, 'r', encoding='utf-8')
# 读取所有行
stop_words = file.readlines()
# 去除每一个停用词前后 空格 换行符
stop_words = [stop_word.strip() for stop_word in stop_words]
return stop_words
# 加载停用词
stop_words = load_stop_words(config.stop_word_path)
remove_words = ['|', '[', ']', '语音', '图片']
def filter_words(sentence):
"""过滤停用词
:param sentence: 分好词的句子，以空格做分割
:return: 过滤后的停用词
"""
words = sentence.split(' ')
# 去掉多余空字符
words = [word for word in words if word and word not in remove_words]
# 去掉停用词 包括一下标点符号也会去掉
words = [word for word in words if word not in stop_words]
return words
def seg_proc(sentence):
tokens = sentence.split('|')
result = []
for t in tokens:
result.append(cut_sentence(t))
return ' | '.join(result)
def cut_sentence(line):
# 切词，默认精确模式，全模式cut参数cut_all=True
tokens = jieba.cut(line)
return ' '.join(tokens)
def sentence_proc(sentence):
"""预处理模块
:param sentence:待处理字符串
:return: 处理后的字符串
"""
# 清除无用词
# sentence = clean_sentence(sentence)
# 分段切词
sentence = seg_proc(sentence)
# 过滤停用词
words = filter_words(sentence)
# 拼接成一个字符串,按空格分隔
return ' '.join(words)
if __name__ == '__main__':
# 单条测试
text = "技师说：电机接触不良吧|车主说：不是，是因为车主右边踏板底盘被刮了，踏板支架被挂断了，现在修复了，但是感觉电机在响，电动踏板不回位，请问如何复位或者匹配脚踏板？|技师说：是不是与踏板脱槽了|车主说：是的，电机之前和踏板脱槽了，现在已经修复上了，但是踏板不正常，开关门几次后现在再开关门有电机声音，但是不复位|技师说：踏板变形了吗？|车主说：现在如何解决？需要匹配电机|车主说：吗|车主说：踏板没变形|技师说：他这个有专门的开关吗？|车主说：16款运动揽胜|技师说：你按开关十秒左右看看能匹配上不|车主说：开关在什么位置|技师说：它开关是怎么控制的|车主说：开门和关门控制的|车主说：[图片]|车主说：这个是开关控制吗|技师说：你常按10秒以上这个开关能学习上不能|车主说：这个是减震放气的|车主说：我按了，就放气|技师说：你按遥控器上的按键试下|车主说：车架号是 SALGA3FV9HA334882|车主说：[图片]|技师说：你找个电脑匹配一下试试|车主说：没反应|车主说：用了，电脑里面关于脚踏板只有维修模式启用和禁用|车主说：都试了，没有用|技师说：那你找当地的专业维修这款车的人员给你看看|车主说：没有复位匹配的方法吗|车主说：我自己就是学修车的，不找别人，咨询可以，要靠自己修|技师说：没有，我修这车也不多 "
print(sentence_proc(text))
输出结果：
技师说 电机 接触不良 车主说 不是 ， 是因为 车主 右边 踏板 底盘 刮 ， 踏板 支架 挂断 ， 现在 修复 ， 感觉 电机 响 ， 电动 踏板 不 回位 ， 请问 复位 匹配 脚踏板 ？ 技师说 是不是 踏板 脱槽 车主说 ， 电机 之前 踏板 脱槽 ， 现在 已经 修复 上 ， 踏板 不 正常 ， 开关门 几次 后 现在 再 开关门 电机 声音 ， 不 复位 技师说 踏板 变形 ？ 车主说 现在 解决 ？ 需要 匹配 电机 车主说 车主说 踏板 没 变形 技师说 专门 开关 ？ 车主说 16 款 运动 揽胜 技师说 开关 十秒 左右 看看 匹配 上 不 车主说 开关 位置 技师说 开关 控制 车主说 开门 关门 控制 车主说 车主说 开关 控制 技师说 你常 10 秒 以上 开关 学习 上 不能 车主说 减震 放气 车主说 ， 放气 技师说 遥控器 上 按键 试下 车主说 车架号 SALGA3FV9HA334882 车主说 技师说 找个 电脑 匹配 一下 试试 车主说 没 反应 车主说 ， 电脑 里面 脚踏板 维修 模式 启用 禁用 车主说 都 试 ， 没有 技师说 找 当地 专业 维修 这款 车 人员 看看 车主说 没有 复位 匹配 方法 车主说 学 修车 ， 不 找 别人 ， 咨询 ， 修 技师说 没有 ， 我修 这车 不
加载数据并训练
我们的数据"Question"、"Dialogue"和"Report"字段都包含文本信息，所以可以把这些字段分词后的结果全部合并到一起来训练词向量
import re
import os
import jieba
import logging
import numpy as np
import pandas as pd
from gensim.models.word2vec import LineSentence, Word2Vec
from src.utils import config
from src.utils.wv_loader import Vocab
from src.utils.file_utils import save_dict
from src.utils.multi_proc_utils import parallelize, cores
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
# 自定义词表
jieba.load_userdict(config.user_dict)
def build_dataset(train_data_path, test_data_path):
"""数据加载+预处理
:param train_data_path:训练集路径
:param test_data_path: 测试集路径
:return: 训练数据 测试数据 合并后的数据
"""
# 1.加载数据
train_df = pd.read_csv(train_data_path)
test_df = pd.read_csv(test_data_path)
print('train data size {},test data size {}'.format(len(train_df), len(test_df)))
# pd.set_option('display.max_columns', None)
# pd.set_option('display.max_rows', None)
# pd.set_option('max_colwidth', 1000)
# print(train_df.head())
# print(train_df[["QID", "Brand", "Model", "Question", "Dialogue", "Report"]])
# 2. 空值剔除
train_df.dropna(subset=['Report'], inplace=True)
test_df.dropna(subset=['Report'], inplace=True)
train_df.fillna('', inplace=True)
test_df.fillna('', inplace=True)
# 3.多线程, 批量数据处理
train_df = parallelize(train_df, sentences_proc)
test_df = parallelize(test_df, sentences_proc)
# 4. 合并训练测试集合
train_df['merged'] = train_df[['Question', 'Dialogue', 'Report']].apply(lambda x: ' '.join(x), axis=1)
test_df['merged'] = test_df[['Question', 'Dialogue', 'Report']].apply(lambda x: ' '.join(x), axis=1)
merged_df = pd.concat([train_df[['merged']], test_df[['merged']]], axis=0)
print('train data size {},test data size {},merged_df data size {}'.format(len(train_df),
len(test_df),
len(merged_df)))
# 5.保存处理好的 训练 测试集合
train_df = train_df.drop(['merged'], axis=1)
test_df = test_df.drop(['merged'], axis=1)
train_df.to_csv(config.train_seg_path, index=False, header=False)
test_df.to_csv(config.test_seg_path, index=False, header=False)
# 6. 保存合并数据
merged_df.to_csv(config.merger_seg_path, index=False, header=False)
# 7. 训练词向量
print('start build w2v model')
wv_model = Word2Vec(LineSentence(config.merger_seg_path),
size=config.embedding_dim,
sg=1,
workers=cores,
iter=config.wv_train_epochs,
window=5,
min_count=5)
if __name__ == '__main__':
# 数据集批量处理
build_dataset(config.train_data_path, config.test_data_path)
多进程处理代码
import numpy as np
import pandas as pd
from multiprocessing import cpu_count, Pool
# cpu 数量
cores = cpu_count()
# 分块个数
partitions = cores
def parallelize(df, func):
"""多核并行处理模块
:param df: DataFrame数据
:param func: 预处理函数
:return: 处理后的数据
"""
# 数据切分
data_split = np.array_split(df, partitions)
# 线程池
pool = Pool(cores)
# 数据分发 合并
data = pd.concat(pool.map(func, data_split))
# 关闭线程池
pool.close()
# 执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
pool.join()
return data
保存词向量文件&标签数据分离
标签和数据分离其实已经不属于词向量训练部分，但是属于整体预处理的一部分，均在为后续正式训练相关模型做准备，所以合并在这一节。
训练完成之后，保存词向量，下面代码依然属于上面的build_dataset方法内。
# 8. 分离数据和标签
train_df['X'] = train_df[['Question', 'Dialogue']].apply(lambda x: ' '.join(x), axis=1)
test_df['X'] = test_df[['Question', 'Dialogue']].apply(lambda x: ' '.join(x), axis=1)
train_df['X'].to_csv(config.train_x_seg_path, index=None, header=False)
train_df['Report'].to_csv(config.train_y_seg_path, index=None, header=False)
test_df['X'].to_csv(config.test_x_seg_path, index=None, header=False)
test_df['Report'].to_csv(config.test_y_seg_path, index=None, header=False)
# 9. 填充开始结束符号,未知词填充 oov, 长度填充
# 使用GenSim训练得出的vocab
vocab = wv_model.wv.vocab
# 训练集X处理
# 获取适当的最大长度
train_x_max_len = get_max_len(train_df['X'])
test_X_max_len = get_max_len(test_df['X'])
X_max_len = max(train_x_max_len, test_X_max_len)
train_df['X'] = train_df['X'].apply(lambda x: pad_proc(x, X_max_len, vocab))
# 测试集X处理
# 获取适当的最大长度
test_df['X'] = test_df['X'].apply(lambda x: pad_proc(x, X_max_len, vocab))
# 训练集Y处理
# 获取适当的最大长度
train_y_max_len = get_max_len(train_df['Report'])
train_df['Y'] = train_df['Report'].apply(lambda x: pad_proc(x, train_y_max_len, vocab))
test_y_max_len = get_max_len(test_df['Report'])
test_df['Y'] = test_df['Report'].apply(lambda x: pad_proc(x, test_y_max_len, vocab))
# 10. 保存pad oov处理后的,数据和标签
train_df['X'].to_csv(config.train_x_pad_path, index=False, header=False)
train_df['Y'].to_csv(config.train_y_pad_path, index=False, header=False)
test_df['X'].to_csv(config.test_x_pad_path, index=False, header=False)
test_df['Y'].to_csv(config.test_y_pad_path, index=False, header=False)
# 11. 保存词向量模型
if not os.path.exists(os.path.dirname(config.save_wv_model_path)):
os.makedirs(os.path.dirname(config.save_wv_model_path))
wv_model.save(config.save_wv_model_path)
print('finish retrain w2v model')
print('final w2v_model has vocabulary of ', len(wv_model.wv.vocab))
# 12. 更新vocab
vocab = {word: index for index, word in enumerate(wv_model.wv.index2word)}
reverse_vocab = {index: word for index, word in enumerate(wv_model.wv.index2word)}
# 保存字典
save_dict(config.vocab_path, vocab)
save_dict(config.reverse_vocab_path, reverse_vocab)
# 13. 保存词向量矩阵
embedding_matrix = wv_model.wv.vectors
np.save(config.embedding_matrix_path, embedding_matrix)
# 14. 数据集转换 将词转换成索引 [<START> 方向机 重 ...] -> [2, 403, 986, 246, 231
vocab = Vocab()
train_ids_x = train_df['X'].apply(lambda x: transform_data(x, vocab))
train_ids_y = train_df['Y'].apply(lambda x: transform_data(x, vocab))
test_ids_x = test_df['X'].apply(lambda x: transform_data(x, vocab))
test_ids_y = test_df['Y'].apply(lambda x: transform_data(x, vocab))
# 15. 数据转换成numpy数组
# 将索引列表转换成矩阵 [2, 403, 986, 246, 231] --> array([[2, 403, 986 , 246, 231]]
train_X = np.array(train_ids_x.tolist())
train_Y = np.array(train_ids_y.tolist())
test_X = np.array(test_ids_x.tolist())
test_Y = np.array(test_ids_y.tolist())
# 保存数据
np.save(config.train_x_path, train_X)
np.save(config.train_y_path, train_Y)
np.save(config.test_x_path, test_X)
np.save(config.test_y_path, test_Y)
return train_X, train_Y, test_X, test_Y
这里是吧"Question"和"Dailogue"作为数据(X)，"Report"作为标签(Y)进行分割。
以上代码中使用的方法在这里，主要目的是得到最大长度的句子（不一定是实际最长），并且长度不是按照字符数量计算，而是根据词的数量；然后将所有句子补成一样的长度。
import numpy as np
from gensim.models.word2vec import Word2Vec
from src.utils.config import embedding_matrix_path, vocab_path, save_wv_model_path
class Vocab:
PAD_TOKEN = '<PAD>'
UNKNOWN_TOKEN = '<UNK>'
START_DECODING = '<START>'
STOP_DECODING = '<STOP>'
MASKS = [PAD_TOKEN, UNKNOWN_TOKEN, START_DECODING, STOP_DECODING]
MASK_COUNT = len(MASKS)
PAD_TOKEN_INDEX = MASKS.index(PAD_TOKEN)
UNKNOWN_TOKEN_INDEX = MASKS.index(UNKNOWN_TOKEN)
START_DECODING_INDEX = MASKS.index(START_DECODING)
STOP_DECODING_INDEX = MASKS.index(STOP_DECODING)
def __init__(self, vocab_file=vocab_path, vocab_max_size=None):
"""Vocab 对象,vocab基本操作封装
:param vocab_file: Vocab 存储路径
:param vocab_max_size: 最大字典数量
"""
self.word2id, self.id2word = self.load_vocab(vocab_file, vocab_max_size)
self.count = len(self.word2id)
@staticmethod
def load_vocab(file_path, vocab_max_size=None):
"""读取字典
:param file_path: 文件路径
:param vocab_max_size:
:return: 返回读取后的字典
"""
vocab = {mask: index
for index, mask in enumerate(Vocab.MASKS)}
reverse_vocab = {index: mask
for index, mask in enumerate(Vocab.MASKS)}
for line in open(file_path, "r", encoding='utf-8').readlines():
word, index = line.strip().split("\t")
index = int(index)
# 如果vocab 超过了指定大小
# 跳出循环 截断
if vocab_max_size and index > vocab_max_size - Vocab.MASK_COUNT:
print("max_size of vocab was specified as %i; we now have %i words. Stopping reading." % (
vocab_max_size, index))
break
vocab[word] = index + Vocab.MASK_COUNT
reverse_vocab[index + Vocab.MASK_COUNT] = word
return vocab, reverse_vocab
def word_to_id(self, word):
if word not in self.word2id:
return self.word2id[self.UNKNOWN_TOKEN]
return self.word2id[word]
def id_to_word(self, word_id):
if word_id not in self.id2word:
raise ValueError('Id not found in vocab: %d' % word_id)
return self.id2word[word_id]
def size(self):
return self.count
def get_max_len(data):
"""获得合适的最大长度值
:param data: 待统计的数据 train_df['Question']
:return: 最大长度值
"""
max_lens = data.apply(lambda x: x.count(' ') + 1)
return int(np.mean(max_lens) + 2 * np.std(max_lens))
def pad_proc(sentence, max_len, vocab):
"""填充字段
< start > < end > < pad > < unk > max_lens
"""
# 0.按空格统计切分出词
words = sentence.strip().split(' ')
# 1. 截取规定长度的词数
words = words[:max_len]
# 2. 填充< unk > ,判断是否在vocab中, 不在填充 < unk >
sentence = [word if word in vocab else Vocab.UNKNOWN_TOKEN for word in words]
# 3. 填充< start > < end >
sentence = [Vocab.START_DECODING] + sentence + [Vocab.STOP_DECODING]
# 4. 判断长度，填充 < pad >
sentence = sentence + [Vocab.PAD_TOKEN] * (max_len - len(words))
return ' '.join(sentence)
def save_dict(save_path, dict_data):
"""保存字典
:param save_path: 保存路径
:param dict_data: 字典路径
"""
with open(save_path, 'w', encoding='utf-8') as f:
for k, v in dict_data.items():
f.write("{}\t{}\n".format(k, v))
src.utils.config文件
import os
import pathlib
# 预处理数据 构建数据集
is_build_dataset = True
# 获取项目根目录
root = pathlib.Path(os.path.abspath(__file__)).parent.parent.parent
# 训练数据路径
train_data_path = os.path.join(root, 'data', 'train.csv')
# 测试数据路径
test_data_path = os.path.join(root, 'data', 'test.csv')
# 停用词路径
# stop_word_path = os.path.join(root, 'data', 'stopwords/哈工大停用词表.txt')
stop_word_path = os.path.join(root, 'data', 'stopwords/stopwords.txt')
# 自定义切词表
user_dict = os.path.join(root, 'data', 'user_dict.txt')
# 0. 预处理
# 预处理后的训练数据
train_seg_path = os.path.join(root, 'data', 'train_seg_data.csv')
# 预处理后的测试数据
test_seg_path = os.path.join(root, 'data', 'test_seg_data.csv')
# 合并训练集测试集数据
merger_seg_path = os.path.join(root, 'data', 'merged_train_test_seg_data.csv')
# 1. 数据标签分离
train_x_seg_path = os.path.join(root, 'data', 'train_X_seg_data.csv')
train_y_seg_path = os.path.join(root, 'data', 'train_Y_seg_data.csv')
test_x_seg_path = os.path.join(root, 'data', 'test_X_seg_data.csv')
test_y_seg_path = os.path.join(root, 'data', 'test_Y_seg_data.csv')
# 2. pad oov处理后的数据
train_x_pad_path = os.path.join(root, 'data', 'train_X_pad_data.csv')
train_y_pad_path = os.path.join(root, 'data', 'train_Y_pad_data.csv')
test_x_pad_path = os.path.join(root, 'data', 'test_X_pad_data.csv')
test_y_pad_path = os.path.join(root, 'data', 'test_Y_pad_data.csv')
# 3. numpy 转换后的数据
train_x_path = os.path.join(root, 'data', 'train_X')
train_y_path = os.path.join(root, 'data', 'train_Y')
test_x_path = os.path.join(root, 'data', 'test_X')
test_y_path = os.path.join(root, 'data', 'test_Y')
# 词向量路径
save_wv_model_path = os.path.join(root, 'data', 'wv_new', 'word2vec.model')
# 词向量矩阵保存路径
embedding_matrix_path = os.path.join(root, 'data', 'wv_new', 'embedding_matrix')
# 字典路径
vocab_path = os.path.join(root, 'data', 'wv_new', 'vocab.txt')
reverse_vocab_path = os.path.join(root, 'data', 'wv_new', 'reverstest_save_dire_vocab.txt')
# 词向量训练轮数
wv_train_epochs = 5
# 模型保存文件夹
# checkpoint_dir = os.path.join(root, 'data', 'checkpoints', 'training_checkpoints_pgn_cov_not_clean')
checkpoint_dir = os.path.join(root, 'data', 'checkpoints', 'training_checkpoints_seq2seq_backed')
# checkpoint_dir = os.path.join(root, 'data', 'checkpoints', 'training_checkpoints_seq2seq')
seq2seq_checkpoint_dir = os.path.join(root, 'data', 'checkpoints', 'training_checkpoints_seq2seq')
transformer_checkpoint_dir = os.path.join(root, 'data', 'checkpoints', 'training_checkpoints_pgn_tfs')
checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt')
# 结果保存文件夹
save_result_dir = os.path.join(root, 'result')
# 词向量维度
embedding_dim = 300
sample_total = 82871
batch_size = 32
# batch_size = 4
epochs = 20
vocab_size = 30000
上面保存了训练后得到的词向量模型和词表之后，又进一步保存了词向量矩阵，并且将X和Y数据也保存为npy文件，不过因为X和Y都是词，需要转换为其在词表中的索引。
def transform_data(sentence, vocab):
"""word 2 index
:param sentence: [word1,word2,word3, ...] ---> [index1,index2,index3 ......]
:param vocab: 词表
:return: 转换后的序列
"""
# 字符串切分成词
words = sentence.split(' ')
# 按照vocab的index进行转换 # 遇到未知词就填充unk的索引
ids = [vocab.word2id[word] if word in vocab.word2id else vocab.UNKNOWN_TOKEN_INDEX for word in words]
return ids
自此word2vec词向量训练和其他的数据预处理全部完成。