深度学习NLP - 优化器、文本转向量

孟船长

发布于 2024-04-25 16:07:19

710

发布于 2024-04-25 16:07:19

文章被收录于专栏：自动化测试实战自动化测试实战

优化器

Adam

实现简单，计算高效，对内存需求少
超参数具有很好的解释性，且通常无需调整或仅需很少的微调
更新的步长能够被限制在大致的范围内(初始学习率)
能够表现出自动调整学习率
很适合应用于大规模的数据及参数的场景
适用于不稳定的目标函数
适用于梯度稀疏或梯度存在很大噪声的问题

SGD

将字符转换为向量

看一段代码，如果你有Python基础，理解起来应该不难，下面也会有相应的解释

import torch
import torch.nn as nn

num_embedding = 6
embedding_dim = 5

embedding_layer = nn.Embedding(num_embedding, embedding_dim)
print(embedding_layer)
print("随机初始化权重")
print(embedding_layer.weight)
print("----------")

# 构造字符表
vocab = {
    "a": 0,
    "b": 1,
    "c": 2,
    "d": 3,
    "e": 4,
    "f": 5,
}

def str_to_sequence(string, vocab):
    return [vocab[s] for s in string]

string1 = "abcd"
string2 = "ddcb"

sequence1 = str_to_sequence(string1, vocab)
sequence2 = str_to_sequence(string2, vocab)

print(sequence1)
print(sequence2)

x = torch.LongTensor([sequence1, sequence2])
print(x.shape)
embedding_out = embedding_layer(x)
print("=====embedding out========\n")
print(embedding_out)
print(embedding_out.shape)
print("=============\n")

# padding
def padding(max_length, sequence):
  if len(sequence) >= max_length:
    return sequence[:max_length]
  else:
    return sequence + [0] * (max_length - len(sequence))
    
sequence1_padded = padding(7, sequence1)
sequence2_padded = padding(7, sequence2)

print(sequence1_padded)
print(sequence2_padded)

输出

# 这里随机生成了一个6行5列的矩阵
Embedding(6, 5)
随机初始化权重
# .weight为查看具体参数的方法，下面就是随机生成的6*5矩阵
Parameter containing:
tensor([[-0.6262, -0.7895,  1.8018, -0.2507,  0.1408],
        [ 0.0910,  0.0198, -0.0213, -0.0097, -1.9152],
        [ 1.1196, -0.9804,  0.7937, -1.0394,  1.3744],
        [-0.0711, -1.0276, -0.1151, -0.3702, -1.8915],
        [ 0.5694,  0.0614, -1.7227,  0.1700,  0.0654],
        [ 1.6826, -1.2739, -0.4829,  1.3280, -0.5684]], requires_grad=True)
################
# 这里是根据字符表，把abcd转换成了对应的字符表里的数字
[0, 1, 2, 3]
[3, 3, 2, 1]
torch.Size([2, 4])
======embedding out=======
# 解释在下面
tensor([[[-0.6262, -0.7895,  1.8018, -0.2507,  0.1408],
         [ 0.0910,  0.0198, -0.0213, -0.0097, -1.9152],
         [ 1.1196, -0.9804,  0.7937, -1.0394,  1.3744],
         [-0.0711, -1.0276, -0.1151, -0.3702, -1.8915]],

        [[-0.0711, -1.0276, -0.1151, -0.3702, -1.8915],
         [-0.0711, -1.0276, -0.1151, -0.3702, -1.8915],
         [ 1.1196, -0.9804,  0.7937, -1.0394,  1.3744],
         [ 0.0910,  0.0198, -0.0213, -0.0097, -1.9152]]],
       grad_fn=<EmbeddingBackward0>)
torch.Size([2, 4, 5])
=============

[0, 1, 2, 3, 0, 0, 0]
[3, 3, 2, 1, 0, 0, 0]

embedding out解释：

把转化成的矩阵先转化成LongTensor类型后(代码要求类型，所以必须转换成LongTensor类型，或者说至少要转换成torch类型)，然后过定义好的embedding层，仔细观察就会发现，这里是按照字表值把embedding层随机生成的行取过来，即0取embedding第0行，1取第一行，所以abcd对应的0123，就去取出了embedding里的第0123行

padding解释:

定义了一个最大长度7，如果字数小于7，那么就补充0，如果字的长度超过7，就进行截断。因为我们在进行文本处理时或者叫输入时，很难确定输入文本的长度，所以我们根据一般情况，取大部分文本长度作为标准处理，当然，你肯定不能取少了，基本都在90%或者95%以上，比如有三句话：

我今天写代码

我今天做功能测试

我今天休息，因为我请了年假

这时候最大长度就可以取第二句话的长度，而第三句话即使截断(相当于删除)了后面的“我请了年假”，整体意思没有出现太大的丢失，但也可以看出，截断会造成语义丢失。但一般文本量都是巨大的，比如一共有20万句话，如果有5%的句子丢失了一部分语义信息，那这个模型仍然是可以训练的。

本文参与?腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2024-04-24，如有侵权请联系?cloudcommunity@tencent.com 删除

embedding