公司及企业如何建立自己的购物网站,官方商城下载,福州公关公司,青羊区定制网站建设报价1、词向量训练
1.1 CBOW#xff08;两边预测中间#xff09;
一、CBOW 基本概念
CBOW 是一种用于生成词向量的方法#xff0c;属于神经网络语言模型的一种。其核心思想是根据上下文来预测中心词。在 CBOW 中#xff0c;输入是目标词的上下文词汇#xff0c;输出是该目标…
1、词向量训练
1.1 CBOW两边预测中间
一、CBOW 基本概念
CBOW 是一种用于生成词向量的方法属于神经网络语言模型的一种。其核心思想是根据上下文来预测中心词。在 CBOW 中输入是目标词的上下文词汇输出是该目标词。
二、CBOW 的网络结构
1、输入层
对于给定的一个窗口大小 通常是一个奇数例如n5 考虑目标词wt及其前后各(n-1)/2个词作为上下文。假设我们的词汇表大小为V每个词都可以表示为一个V维的 one-hot 向量。对于上下文词和其中 它们的 one-hot 向量被输入到网络中。 2、投影层
输入层的多个 one-hot 向量会被映射到一个投影层。对于每个输入的 one-hot 向量它会激活隐藏层中的一个神经元而隐藏层的权重矩阵W维度为V x N 其中N是词向量的维度将这些输入进行加权求和得到一个N维的向量。 从数学上看如果xi是第i个上下文词的 one-hot 向量那么投影层的向量h可以表示为 其中C n-1是上下文词的数量。
3、隐藏层
投影层的结果作为隐藏层的输入隐藏层通常不进行非线性变换直接将结果传递给输出层。
4、输出层
输出层是一个 softmax 层其神经元的数量等于词汇表的大小V 。输出层的权重矩阵为 维度为 N x V使用 softmax 函数将隐藏层的输出转换为概率分布 其中 。
三、训练过程 损失函数 通常使用交叉熵损失函数 其中 yj是真实目标词的 one-hot 向量, p(wj)是预测词的概率。 优化算法 常用的优化算法是随机梯度下降SGD或其变种如 Adagrad、Adadelta 等。在训练过程中通过反向传播算法更新权重矩阵 和 以最小化损失函数。
四、CBOW 的优点 考虑上下文信息 CBOW 利用了上下文信息来预测中心词能够捕捉到词与词之间的语义关系。 计算效率 对于每个训练样本由于使用了上下文词的平均作为输入CBOW 比 Skip-gram 在训练时计算量相对较小尤其是在处理大规模语料库时CBOW 可以更快地训练出较为不错的词向量。
五、CBOW 的缺点
对低频词不敏感
CBOW 侧重于根据上下文预测中心词对于低频词由于它们在语料库中出现的频率低在训练过程中得到的学习机会相对较少因此生成的词向量可能不能很好地表示低频词的语义信息。 六、应用场景 词向量初始化 CBOW 可以为下游的 NLP 任务提供预训练的词向量如文本分类、情感分析、命名实体识别等。将文本中的词替换为其对应的 CBOW 词向量可以将文本表示为一个向量序列为后续任务提供良好的输入表示。 词相似度计算 训练好的词向量可以计算词与词之间的相似度例如使用余弦相似度 七、与 Skip-gram 的对比
Skip-gram 与 CBOW 的区别在于Skip-gram 是根据中心词预测上下文词而 CBOW 是根据上下文词预测中心词。Skip-gram 更适合处理少量数据和低频词因为它为每个中心词 - 上下文词对都进行单独的训练而 CBOW 更适合处理大规模数据因为它在计算上更高效。
八、示例代码使用 gensim
from gensim.models import Word2Vec
sentences [[I, love, natural, language, processing],[Word, embeddings, are, useful],[This, is, an, example, sentence]]
# CBOW 模型训练window 是窗口大小min_count 是最小词频sg0 表示 CBOW 算法
model Word2Vec(sentences, vector_size100, window5, min_count1, sg0)
# 获取词向量
vector model.wv[love]
print(vector)
#coding:utf8import torch
import torch.nn as nn
import numpy as np
基于pytorch的词向量CBOW
模型部分
class CBOW(nn.Module):def __init__(self, vocab_size, embedding_size, window_length):super(CBOW, self).__init__()self.word_vectors nn.Embedding(vocab_size, embedding_size)self.pooling nn.AvgPool1d(window_length)self.projection_layer nn.Linear(embedding_size, vocab_size)def forward(self, context):context_embedding self.word_vectors(context) #batch_size * max_length * embedding size 1*4*4#transpose: batch_size * embedding size * max_length - pool: batch_size * embedding_size * 1 - squeeze:batch_size * embeddig_sizecontext_embedding self.pooling(context_embedding.transpose(1, 2)).squeeze()#batch_size * embeddig_size - batch_size * vocab_sizepred self.projection_layer(context_embedding)return predvocab_size 8 #词表大小
embedding_size 4 #人为指定的向量维度
window_length 4 #窗口长度
model CBOW(vocab_size, embedding_size, window_length)
#假如选取一个词窗口【1,2,3,4,5】·
context torch.LongTensor([[1,2,4,5]]) #输入1,2,4,5, 预期输出3, 两边预测中间
pred model(context)
print(预测值, pred)# print(词向量矩阵)
# print(model.state_dict()[word_vectors.weight]) 1.2 简单词向量模型自主选择 CBOW or SkipGram 方法 import json
import jieba
import numpy as np
import gensim
from gensim.models import Word2Vec
from collections import defaultdict
词向量模型的简单实现
#训练模型
#corpus: [[cat, say, meow], [dog, say, woof]]
#corpus: [[今天, 天气, 不错], [你, 好, 吗]]
#dim指定词向量的维度如100
def train_word2vec_model(corpus, dim):model Word2Vec(corpus, vector_sizedim, sg1)model.save(model.w2v)return model#输入模型文件路径
#加载训练好的模型
def load_word2vec_model(path):model Word2Vec.load(path)return modeldef main():sentences []with open(corpus.txt, encodingutf8) as f:for line in f:sentences.append(jieba.lcut(line))model train_word2vec_model(sentences, 128)return modelif __name__ __main__:# model main() #训练model load_word2vec_model(model.w2v) #加载print(model.wv.most_similar(positive[男人, 母亲], negative[女人])) #类比while True: #找相似string input(input:)try:print(model.wv.most_similar(string))except KeyError:print(输入词不存在)
函数部分
train_word2vec_model 函数
功能使用 Word2Vec 类训练一个词向量模型。参数 corpus输入的语料库应该是一个由词汇列表组成的列表例如 [[cat, say, meow], [dog, say, woof]]。dim词向量的维度例如 128。实现细节 model Word2Vec(corpus, vector_sizedim, sg1)创建一个 Word2Vec 模型其中 vector_size 表示词向量的维度sg1 表示使用 Skip-gram 算法进行训练sg0 表示使用 CBOW 算法。model.save(model.w2v)将训练好的模型保存到文件 model.w2v 中。
load_word2vec_model 函数
功能从文件中加载已经训练好的 Word2Vec 模型。参数 path存储 Word2Vec 模型的文件路径例如 model.w2v。实现细节 model Word2Vec.load(path)从指定的文件路径加载 Word2Vec 模型。
main 函数
实现细节 sentences []初始化一个空列表用于存储分词后的句子。with open(corpus.txt, encodingutf8) as f以 UTF-8 编码打开文件 corpus.txt。for line in f: sentences.append(jieba.lcut(line))逐行读取文件并使用 jieba.lcut 对每行进行分词将分词结果添加到 sentences 列表中。model train_word2vec_model(sentences, 128)调用 train_word2vec_model 函数使用分词后的 sentences 作为语料库维度为 128 训练词向量模型。
1.3 基于pytorch的语言模型 核心算法
y Wx Utanh(hxd) b
#coding:utf8import torch
import torch.nn as nn
import numpy as np
基于pytorch的语言模型
与基于窗口的词向量训练本质上非常接近
只是输入输出的预期不同
不使用向量的加和平均而是直接拼接起来
class LanguageModel(nn.Module):def __init__(self, vocab_size, max_len, embedding_size, hidden_size):super(LanguageModel, self).__init__()self.word_vectors nn.Embedding(vocab_size, embedding_size)self.inner_projection_layer nn.Linear(embedding_size * max_len, hidden_size)self.outter_projection_layer nn.Linear(hidden_size, hidden_size)self.x_projection_layer nn.Linear(embedding_size * max_len, hidden_size)self.projection_layer nn.Linear(hidden_size, vocab_size)def forward(self, context):#context shape batch_size, max_lengthcontext_embedding self.word_vectors(context) #output shape batch_size, max_length, embedding_size#总体计算 y bWxUtanh(dHx) 其中x为每个词向量的拼接#词向量的拼接x context_embedding.view(context_embedding.shape[0], -1) #shape batch_size, max_length*embedding_size#hx dinner_projection self.inner_projection_layer(x) #shape batch_size, hidden_size#tanh(hxd)inner_projection torch.tanh(inner_projection) #shape batch_size, hidden_size#U * tanh(hxd) boutter_project self.outter_projection_layer(inner_projection) # shape batch_size, hidden_size#Wxx_projection self.x_projection_layer(x) #shape batch_size, hidden_size#y Wx Utanh(hxd) by x_projection outter_project #shape batch_size, hidden_size#softmax后输出预测概率, 训练的目标是让y_pred对应到字表中某个字y_pred torch.softmax(y, dim-1) #shape batch_size, hidden_sizereturn y_predvocab_size 8 #词表大小
embedding_size 5 #人为指定的向量维度
max_len 4 #输入长度
hidden_size vocab_size #由于最终的输出维度应当是字表大小的所以这里hidden_size vocab_size
model LanguageModel(vocab_size, max_len, embedding_size, hidden_size)
#假如选取一个文本窗口“天王盖地虎”
#输入“天王盖地” — 输出虎
#假设词表embedding中, 天王盖地虎 对应位置 12345
context torch.LongTensor([[1,2,3,4]]) #shape 1, 4 batch_size 1, max_length 4
pred model(context)
print(预测值, pred)
print(loss可以使用交叉熵计算, nn.functional.cross_entropy(pred, torch.LongTensor([5])))print(词向量矩阵)
matrix model.state_dict()[word_vectors.weight]print(matrix.shape) #vocab_size, embedding_size
print(matrix) 2、KMeans(词向量的应用——聚类)
1将一句话或一段文本分成若干个词
2找到每个词对应的词向量
3所有词向量加和求平均或通过各种网络模型得到文本向量
4使用文本向量计算相似度或进行聚类等
KMeans
随机选择k个点作为初始质心
repeat
将每个点指派到最近的质心形成k个簇
重新计算每个簇的质心
until
质心不发生变化 KMeans优点
1.速度很快可以支持很大量的数据
2.样本均匀特征明显的情况下效果不错 KMeans缺点
1.人为设定聚类数量
2.初始化中心影响效果导致结果不稳定
3.对于个别特殊样本敏感会大幅影响聚类中心位置
4.不适合多分类或样本较为离散的数据 KMeans一些使用技巧
1.先设定较多的聚类类别
2.聚类结束后计算类内平均距离
3.排序后舍弃类内平均距离较长的类别
4.计算距离时可以尝试欧式距离、余弦距离或其他距离
5.短文本的聚类记得先去重以及其他预处理 代码实例
import numpy as np
import random
import sysKmeans算法实现
原文链接https://blog.csdn.net/qingchedeyongqi/article/details/116806277
class KMeansClusterer: # k均值聚类def __init__(self, ndarray, cluster_num):self.ndarray ndarrayself.cluster_num cluster_numself.points self.__pick_start_point(ndarray, cluster_num)def cluster(self):result []for i in range(self.cluster_num):result.append([])for item in self.ndarray:distance_min sys.maxsizeindex -1for i in range(len(self.points)):distance self.__distance(item, self.points[i])if distance distance_min:distance_min distanceindex iresult[index] result[index] [item.tolist()]new_center []for item in result:new_center.append(self.__center(item).tolist())# 中心点未改变说明达到稳态结束递归if (self.points new_center).all():sum self.__sumdis(result)return result, self.points, sumself.points np.array(new_center)return self.cluster()def __sumdis(self,result):#计算总距离和sum0for i in range(len(self.points)):for j in range(len(result[i])):sumself.__distance(result[i][j],self.points[i])return sumdef __center(self, list):# 计算每一列的平均值return np.array(list).mean(axis0)def __distance(self, p1, p2):#计算两点间距tmp 0for i in range(len(p1)):tmp pow(p1[i] - p2[i], 2)return pow(tmp, 0.5)def __pick_start_point(self, ndarray, cluster_num):if cluster_num 0 or cluster_num ndarray.shape[0]:raise Exception(簇数设置有误)# 取点的下标indexes random.sample(np.arange(0, ndarray.shape[0], step1).tolist(), cluster_num)points []for index in indexes:points.append(ndarray[index].tolist())return np.array(points)x np.random.rand(100, 8)
kmeans KMeansClusterer(x, 10)
result, centers, distances kmeans.cluster()
print(result:, result)
print(centers:, centers)
print(distances:, distances)
#!/usr/bin/env python3
#coding: utf-8#基于训练好的词向量模型进行聚类
#聚类采用Kmeans算法
import math
import re
import json
import jieba
import numpy as np
from gensim.models import Word2Vec
from sklearn.cluster import KMeans
from collections import defaultdict#输入模型文件路径
#加载训练好的模型
def load_word2vec_model(path):model Word2Vec.load(path)return modeldef load_sentence(path):sentences set()with open(path, encodingutf8) as f:for line in f:sentence line.strip()sentences.add( .join(jieba.cut(sentence)))print(获取句子数量, len(sentences))return sentences#将文本向量化
def sentences_to_vectors(sentences, model):vectors []for sentence in sentences:words sentence.split() #sentence是分好词的空格分开vector np.zeros(model.vector_size)#所有词的向量相加求平均作为句子向量for word in words:try:vector model.wv[word]except KeyError:#部分词在训练中未出现用全0向量代替vector np.zeros(model.vector_size)vectors.append(vector / len(words))return np.array(vectors)def main():model load_word2vec_model(rmodel.w2v) #加载词向量模型sentences load_sentence(titles.txt) #加载所有标题vectors sentences_to_vectors(sentences, model) #将所有标题向量化n_clusters int(math.sqrt(len(sentences))) #指定聚类数量print(指定聚类数量, n_clusters)kmeans KMeans(n_clusters) #定义一个kmeans计算类kmeans.fit(vectors) #进行聚类计算sentence_label_dict defaultdict(list)for sentence, label in zip(sentences, kmeans.labels_): #取出句子和标签sentence_label_dict[label].append(sentence) #同标签的放到一起for label, sentences in sentence_label_dict.items():print(cluster %s : % label)for i in range(min(10, len(sentences))): #随便打印几个太多了看不过来print(sentences[i].replace( , ))print(---------)if __name__ __main__:main()
#coding: utf-8#基于训练好的词向量模型进行聚类
#聚类采用Kmeans算法
#Kmeans基础上实现按照类内距离排序
import math
import re
import json
import jieba
import numpy as np
from gensim.models import Word2Vec
from sklearn.cluster import KMeans
from collections import defaultdict#输入模型文件路径
#加载训练好的模型
def load_word2vec_model(path):model Word2Vec.load(path)return modeldef load_sentence(path):sentences set()with open(path, encodingutf8) as f:for line in f:sentence line.strip()sentences.add( .join(jieba.cut(sentence)))print(获取句子数量, len(sentences))return sentences#将文本向量化
def sentences_to_vectors(sentences, model):vectors []for sentence in sentences:words sentence.split() #sentence是分好词的空格分开vector np.zeros(model.vector_size)#所有词的向量相加求平均作为句子向量for word in words:try:vector model.wv[word]except KeyError:#部分词在训练中未出现用全0向量代替vector np.zeros(model.vector_size)vectors.append(vector / len(words))return np.array(vectors)def main():model load_word2vec_model(model.w2v) #加载词向量模型sentences load_sentence(titles.txt) #加载所有标题vectors sentences_to_vectors(sentences, model) #将所有标题向量化n_clusters int(math.sqrt(len(sentences))) #指定聚类数量print(指定聚类数量, n_clusters)kmeans KMeans(n_clusters) #定义一个kmeans计算类kmeans.fit(vectors) #进行聚类计算sentence_label_dict defaultdict(list)for sentence, label in zip(sentences, kmeans.labels_): #取出句子和标签sentence_label_dict[label].append(sentence) #同标签的放到一起#计算类内距离density_dict defaultdict(list)for vector_index, label in enumerate(kmeans.labels_):vector vectors[vector_index] #某句话的向量center kmeans.cluster_centers_[label] #对应的类别中心向量distance cosine_distance(vector, center) #计算距离density_dict[label].append(distance) #保存下来for label, distance_list in density_dict.items():density_dict[label] np.mean(distance_list) #对于每一类将类内所有文本到中心的向量余弦值取平均density_order sorted(density_dict.items(), keylambda x: x[1], reverseTrue) #按照平均距离排序向量夹角余弦值越接近1距离越小#按照余弦距离顺序输出for label, avg_distance in density_order:print(cluster %s , avg distance %s: % (label, avg_distance))sentences sentence_label_dict[label]for i in range(min(10, len(sentences))): #随便打印几个太多了看不过来print(sentences[i].replace( , ))print(---------)#向量余弦距离
def cosine_distance(vec1, vec2):vec1 vec1 / np.sqrt(np.sum(np.square(vec1))) #A/|A|vec2 vec2 / np.sqrt(np.sum(np.square(vec2))) #B/|B|return np.sum(vec1 * vec2)#欧式距离
def eculid_distance(vec1, vec2):return np.sqrt((np.sum(np.square(vec1 - vec2))))if __name__ __main__:main() 3、 词向量训练总结
一、根据词与词之间关系的某种假设制定训练目标
二、设计模型以词向量为输入
三、随机初始化词向量开始训练
四、训练过程中词向量作为参数不断调整获取一定的语义信息
五、使用训练好的词向量做下游任务 词向量总结
1.质变将离散的字符转化为连续的数值
2.通过向量的相似度代表语义的相似度
3.词向量的训练基于很多不完全正确的假设但是据此训练的词向量是有意义的
4.使用无标注的文本的一种好方法 词向量存在的问题
1)词向量是“静态”的。每个词使用固定向量没有考虑前后文
2)一词多义的情况。西瓜 - 苹果 - 华为
3影响效果的因素非常多
维度选择、随机初始化、skip-gram/cbow/glove、分词质量、词频截断、未登录词、窗口大小、迭代轮数、停止条件、语料质量等
4没有好的直接评价指标。常需要用下游任务来评价
