wordpress改企业网站,网站后台上传图片做难吗,wordpress精品主题,网络彩票建立网站NLP基础1
深度学习中的NLP的特征输入
1.稠密编码#xff08;特征嵌入#xff09;
稠密编码#xff08;Dense Encoding#xff09;#xff1a;指将离散或者高纬的稀疏数据转化为低纬度的连续、密集向量表示
特征嵌入#xff08;Feature Embedding#xff09;
也称…NLP基础1
深度学习中的NLP的特征输入
1.稠密编码特征嵌入
稠密编码Dense Encoding指将离散或者高纬的稀疏数据转化为低纬度的连续、密集向量表示
特征嵌入Feature Embedding
也称为词嵌入,是稠密编码的一种表现形式单词映射到一个低维的连续向量空间来表示单词这些向量通常具有较低的维度并且每个维度上的值是连续的浮点数。这种表示方法能够捕捉单词之间的语义和句法关系并且在计算上更高效。
稠密编码的主要特点
低维表示 稠密编码将高维的稀疏向量如 one-hot 编码映射到低维的密集向量。这样可以减少计算复杂度并且更好地捕捉词与词之间的关系。 语义信息 稠密编码能够捕捉单词之间的语义关系。例如“king” 和 “queen” 在向量空间中可能会非常接近欧氏距离或余弦相似度因为它们有相似的语义角色。 上下文依赖 稠密编码通常是基于上下文生成的。不同的上下文可能会导致同一个单词有不同的向量表示。例如“bank” 在金融上下文中和在河流上下文中会有不同的向量表示。 可微学习 嵌入表示通常通过神经网络进行学习并且通过反向传播算法进行优化。
2.词嵌入算法
2.1 Embedding Layer
嵌入层Embedding Layer是深度学习中用于将离散的、高维的稀疏表示如 one-hot 编码转换为低维的密集向量表示的一种神经网络层。这种转换能够捕捉到输入数据中的语义信息并且在计算上更加高效。嵌入层通常用于处理文本数据例如单词或字符。
嵌入层的主要特点
低维表示 将高维的稀疏向量如 one-hot 编码映射到低维的密集向量空间。例如一个词汇表大小为 10,000 的 one-hot 编码可以被映射到 100 维的密集向量。 参数学习 嵌入层的权重是通过训练过程自动学习的。这些权重矩阵存储了每个输入项如单词的向量表示。 语义信息 通过训练嵌入层能够捕捉到输入项之间的语义关系。例如在词嵌入中相似的单词在向量空间中会非常接近。 灵活性 嵌入层可以应用于多种类型的输入包括单词、字符、用户 ID 等。
词嵌入层的使用 nn.Embedding(num_embeddings10, embedding_dim4) 参数:
num_embeddings 表示词的数量embedding_dim 表示用多少维的向量来表示每个词
尝试搭建NNLM语言模型
import torch
import torch.nn as nn
import torch.optim as optim
import jieba
import recorpus [床前明月光疑是地上霜。举头望明月低头思故乡。,春眠不觉晓处处闻啼鸟。夜来风雨声花落知多少。,千山鸟飞绝万径人踪灭。孤舟蓑笠翁独钓寒江雪。,白日依山尽黄河入海流。欲穷千里目更上一层楼。,茫茫烟水上日暮阴云飞。孤坐正愁绪湖南谁捣衣。,国破山河在城春草木深。感时花溅泪恨别鸟惊心。,烽火连三月家书抵万金。白头搔更短浑欲不胜簪。,人闲桂花落夜静春山空。月出惊山鸟时鸣春涧中。
]def remove_punctuation(tokens):return [token for token in tokens if not re.match(r[。、“”‘’《》〈〉【】〔〕…—·], token)]sentences [jieba.lcut(sen) for sen in corpus]
# print(sentences)sentences [remove_punctuation(sentence) for sentence in sentences]# 创建词表和对应的映射关系
word_list [word for sentence in sentences for word in sentence]
# 去重
word_list list(set(word_list))
# print(word_list)
word_dict {w: i for i, w in enumerate(word_list)}
number_dict {i: w for i, w in enumerate(word_list)}
# 词表大小
n_class len(word_dict)
# print(n_class)# 设置超参数
m_dim 2 # 嵌入向量的维度
n_hidden 10 # 神经元数量
n_step 1 # 输入步长数
max_lens 1 # 最大长度# 创建输入的样本和目标值
def make_batch(sentences, max_lens, word_dict):input_batch []target_batch []for sentence in sentences:if len(sentence) n_step 1:continuefor i in range(len(sentence) - n_step):input [word_dict[word] for word in sentence[i:in_step]]target word_dict[sentence[in_step]]# 填充或者裁剪确保长度等于max_lensinput [0] * (max_lens - len(input))input input[:max_lens]input_batch.append(input)target_batch.append(target)return torch.LongTensor(input_batch), torch.LongTensor(target_batch)class NNLM(nn.Module):def __init__(self, n_step, n_class, m_dim, n_hidden):super(NNLM, self).__init__()# 定义嵌入层单词索引映射为嵌入向量self.embed nn.Embedding(n_class, m_dim) # 产出为每一个词的向量为1 x m_dim的# 隐藏层输入为两个词所以采用m_dim*n_stepself.linear1 nn.Linear(m_dim*n_step, n_hidden)# 分类类别就是词表大小self.linear2 nn.Linear(n_hidden, n_class)def forward(self, x):x self.embed(x) # 通过嵌入层得到的形状batch_size, n_step, m_dim-(batch_size, n_step*m_dim)x x.view(-1, x.size(1) * x.size(2))x self.linear1(x)x torch.tanh(x)output self.linear2(x)return outputmodel NNLM(n_step, n_class, m_dim, n_hidden)
criterion nn.CrossEntropyLoss()
optimizer optim.Adam(model.parameters(), lr0.001)input_batch, target_batch make_batch(sentences, max_lens, word_dict)for epoch in range(10000):optimizer.zero_grad()output model(input_batch)loss criterion(output, target_batch)loss.backward()optimizer.step()if (epoch 1) % 1000 0:print(fEpoch:{epoch1}, Loss:{loss:.4f})# 预测
with torch.no_grad():predict model(input_batch).max(1, keepdimTrue)[1]predictions [number_dict[n.item()] for n in predict.squeeze()]# print([sen.split()[:2] for sentence in sentences for sen in sentence], -, [number_dict[n.item()] for n in predict.squeeze()])
print(输入序列 - 预测结果)
new_sentences 床前
count 5
flog True
for i in range(0, len(input_batch)):input_seq []x i 1if x len(input_batch):input_seq [number_dict[idx.item()] for idx in input_batch[x]]input_seq1 [ number_dict[ idx.item() ] for idx in input_batch[ i ] ]# 按词预测下一个词并组装诗歌new_sentences predictions[i]# 判断诗歌后是否接符号if len(new_sentences) % count 0 and flog:new_sentences ,count 6flog Falseif len(new_sentences) % count 0 and not flog:new_sentences 。count 6flog Trueif len(new_sentences) % 24 0:new_sentences input_seq[0]print(f{input_seq1} - {predictions[i]})
print(new_sentences)# 计算准确率
correct (predict.squeeze() target_batch).sum().item()
accuracy correct / len(target_batch) * 100
print(fAccuracy: {accuracy:.2f}%)
2.2 word2vec
Word2Vec 是一种用于生成词嵌入word embeddings的流行算法由 Google 在 2013 年提出。它通过在大规模文本数据上训练神经网络模型来学习单词的向量表示。这些向量能够捕捉到单词之间的语义和句法关系使得相似的单词在向量空间中具有相近的表示。
Word2Vec 的主要特点
低维表示 将高维的稀疏向量如 one-hot 编码映射到低维的密集向量空间。例如一个词汇表大小为 10,000 的 one-hot 编码可以被映射到 100 维的密集向量。 语义信息 通过训练Word2Vec 能够捕捉到输入项之间的语义关系。例如“king” 和 “queen” 在向量空间中会非常接近因为它们有相似的语义角色。 上下文依赖 Word2Vec 通常是基于上下文生成的。不同的上下文可能会导致同一个单词有不同的向量表示。例如“bank” 在金融上下文中和在河流上下文中会有不同的向量表示。
Word2Vec 包含两种主要的模型CBOW (Continuous Bag of Words) 和 Skip-gram。
CBOW (Continuous Bag of Words)
目标给定一个单词的上下文预测该单词。结构输入是上下文单词的平均向量输出是中心单词的概率分布。优点计算效率较高适合处理小规模的数据集。缺点对于罕见词的处理不如 Skip-gram 好。
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt# 定义数据类型
dtype torch.FloatTensor# 语料库包含训练模型的句子
sentences [i like dog, i like cat, i like animal,dog cat animal, apple cat dog like, cat like fish,dog like meat, i like apple, i hate apple,i like movie book music apple, dog like bark, dog friend cat]# 构建词表
word_sentences .join(sentences).split()
# 去重
word_list list(set(word_sentences))
word_dict {w: i for i, w in enumerate(word_list)}# 创建CBOW训练数据
cbow_data []
for i in range(1, len(word_sentences) - 1):context [word_dict[word_sentences[i-1]], word_dict[word_sentences[i1]]]target word_dict[word_sentences[i]]cbow_data.append([context, target])# 模型参数
voc_size len(word_dict)
# 词向量维度
embedding_size 2
# 批次
batch_size 2# 定义CBOW模型
class CBOW(nn.Module):def __init__(self):super().__init__()# 映射维度self.embed nn.Embedding(voc_size, embedding_size)# 输出矩阵self.linear nn.Linear(embedding_size, voc_size)def forward(self, x):embeds self.embed(x) # 映射矩阵 通过嵌入层得到的形状是batch_size, n_step, m_dimavg_embeds torch.mean(embeds, dim1) # 在n_step维度上平均output self.linear(avg_embeds)return outputmodel CBOW()criterion nn.CrossEntropyLoss()
optimizer optim.Adam(model.parameters(), lr0.001)def random_batch(data, size):random_labels []random_inputs []# 从数据中随机选择size个索引random_index np.random.choice(range(len(data)), size, replaceFalse)# 根据随机索引生成输入和标签批次for i in random_index:# 目标词one-hot编码random_inputs.append(data[i][0])# 上下文的词的索引作为标签random_labels.append(data[i][1])return random_inputs, random_labelsfor epoch in range(10000):inputs, labels random_batch(cbow_data, batch_size)inputs np.array(inputs)input_batch torch.LongTensor(inputs)label_batch torch.LongTensor(labels)optimizer.zero_grad()output model(input_batch)loss criterion(output, label_batch)if (epoch 1) % 1000 0:print(fEpoch:{epoch1}, Loss:{loss:.4f})loss.backward()optimizer.step()# 可视化词嵌入
for i, label in enumerate(word_list):# 获取模型参数W model.embed.weight.data.numpy()x, y float(W[i][0]), float(W[i][1])# 绘制散点图plt.scatter(x, y)plt.annotate(label, xy(x, y), xytext(5, 2), textcoordsoffset points, haright, vabottom)
plt.show()
Skip-gram
目标给定一个中心单词预测其上下文中的单词。结构输入是中心单词的向量输出是上下文单词的概率分布。优点能够更好地处理罕见词生成的词向量质量较高。缺点计算成本较高特别是在大规模数据集上。
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt# 定义数据类型
dtype torch.FloatTensor# 语料库包含训练模型的句子
sentences [i like dog, i like cat, i like animal,dog cat animal, apple cat dog like, cat like fish,dog like meat, i like apple, i hate apple,i like movie book music apple, dog like bark, dog friend cat]# 构建词表
word_sentences .join(sentences).split()
word_list list(set(word_sentences))
word_index {w: i for i, w in enumerate(word_list)}
index_word {i: w for i, w in enumerate(word_list)}
vocab_size len(word_list)# 创建skip的训练数据集
skip_grams []
for i in range(1, len(word_sentences) - 1):# 当前词对应的idcenter word_index[word_sentences[i]]# 获取当前词的前后两个上下文对应的词的idcontext [word_index[word_sentences[i-1]], word_index[word_sentences[i1]]]# 将当前词和上下文词组合成skip-gram数据集for w in context:skip_grams.append([center, w])# 定义超参数
# 词汇表维度
embed_dim 2
# 训练批次
batch_size 5# 定义skip模型
class Word2Vec(nn.Module):def __init__(self, dtype):super(Word2Vec, self).__init__()# 定义词嵌入矩阵随机初始化大小为词汇表大小词嵌入维度self.W nn.Parameter(torch.rand(vocab_size, embed_dim)).type(dtype)print(self.W.type())# 定义输出层矩阵W2, 随机初始化, 大小为词嵌入维度 词汇表大小self.W2 nn.Parameter(torch.rand(embed_dim, vocab_size)).type(dtype)self.log_softmax nn.LogSoftmax(dim1)def forward(self, x):# 映射层weights torch.matmul(x, self.W)# 输出层out_put torch.matmul(weights, self.W2)return out_putmodel Word2Vec(dtype)criterion nn.CrossEntropyLoss()
optimizer optim.Adam(model.parameters(), lr0.001)def random_batch(data, size):random_labels []random_inputs []# 从数据中随机选择size个索引random_index np.random.choice(range(len(data)), size, replaceFalse)# 根据随机索引生成输入和标签批次for i in random_index:# 目标词one-hot编码random_inputs.append(np.eye(vocab_size)[data[i][0]])# 上下文的词的索引作为标签random_labels.append(data[i][1])return random_inputs, random_labelsfor epoch in range(10000):inputs, labels random_batch(skip_grams, batch_size)inputs np.array(inputs)input_batch torch.from_numpy(inputs).float()label_batch torch.LongTensor(labels)optimizer.zero_grad()output model(input_batch)loss criterion(output, label_batch)if (epoch 1) % 1000 0:print(fEpoch:{epoch1}, Loss:{loss:.4f})loss.backward()optimizer.step()# 可视化词嵌入
for i, label in enumerate(word_list):# 获取模型参数W, W2 model.parameters()x, y float(W[i][0]), float(W[i][1])# 绘制散点图plt.scatter(x, y)plt.annotate(label, xy(x, y), xytext(5, 2), textcoordsoffset points, haright, vabottom)
plt.show()
gensim API调用
参数说明sentences可以是一个list对于大语料集建议使用BrownCorpus,Text8Corpus或lineSentence构建。vector_sizeword向量的维度默认为100。大的size需要更多的训练数据但是效果会更好。推荐值为几十到几百。alpha学习率window表示当前词与预测词在一个句子中的最大距离是多少。min_count可以对字典做截断。词频少于min_count次数的单词会被丢弃掉默认值为5。max_vocab_size设置词向量构建期间的RAM限制。如果所有独立单词个数超过这个则就消除掉其中最不频繁的一个。每一千万个单词需要大约1GB的RAM。设置成None则没有限制。sample高频词汇的随机降采样的配置阈值默认为1e-3范围是(01e-5)seed用于随机数发生器。与初始化词向量有关。workers参数控制训练的并行数。sg用于设置训练算法默认为0对应CBOW算法sg1则采用skip-gram算法。hs如果为1则会采用hierarchica·softmax技巧。如果设置为0default则negative sampling会被使用。negative如果0则会采用negative samping用于设置多少个noise words。cbow_mean如果为0则采用上下文词向量的和如果为1default则采用均值。只有使用CBOW的时候才起作用。hashfxnhash函数来初始化权重。默认使用python的hash函数。epochs迭代次数默认为5。trim_rule用于设置词汇表的整理规则指定那些单词要留下哪些要被删除。可以设置为Nonemin_count会被使用或者一个接受()并返回RULE_DISCARDutils。RULE_KEEP或者utils。RULE_DEFAULT的函数。sorted_vocab如果为1default则在分配word index 的时候会先对单词基于频率降序排序。batch_words每一批的传递给线程的单词的数量默认为10000min_alpha随着训练的进行学习率线性下降到min_alpha
import numpy as np
from gensim.models import Word2Vec
import matplotlib.pyplot as plt# 语料库包含训练模型的句子
sentences [i like dog, i like cat, i like animal,dog cat animal, apple cat dog like, cat like fish,dog like meat, i like apple, i hate apple,i like movie book music apple, dog like bark, dog friend cat]# 每个句子分成单词表word2vec api要求输入格式为二维列表: 每一个句子是一个单词列表
token_list [sentence.split() for sentence in sentences]# 定义word2vec模型
model Word2Vec(token_list, vector_size2, window1, min_count0, sg1)# 获取词汇表
word_list list(model.wv.index_to_key)# 可视化词嵌入
for i, word in enumerate(word_list):# 获取模型参数W model.wv[word]x, y float(W[0]), float(W[1])# 绘制散点图plt.scatter(x, y)plt.annotate(word, xy(x, y), xytext(5, 2), textcoordsoffset points, haright, vabottom)
plt.show()print(model.wv.most_similar(dog))
# 打印两个词的相似度
print(model.wv.similarity(dog, cat))
