手动实现BERT

news2024/12/23 0:46:03

  本文重点介绍了如何从零训练一个BERT模型的过程，包括整体上BERT模型架构、数据集如何做预处理、MASK替换策略、训练模型和保存、加载模型和测试等。

一.BERT架构
  BERT设计初衷是作为一个通用的backbone，然后在下游接入各种任务，包括翻译任务、分类任务、回归任务等。BERT模型架构如下所示：

1.输入层
  BERT每次计算时输入两句话。
2.数据预处理
  包括移除不能识别的字符、将所有字母小写、多余的空格等。

3.随机将一些词替换为MASK
  BERT模型的训练过程包括两个子任务，其中一个即为预测被遮掩的词的原本的词，所以在计算之前，需要把句子中的一些词替换为MASK交给BERT预测。


4.编码句子
  把句子编码成向量，BERT同样也有位置编码层，以让处于不同位置的相同的词有不同的向量表示。与Transformer位置编码固定常量不同，BERT位置编码是一个可学习的参数。

5.编码器
  此处的编码器即为Transformer中的编码器，BERT使用了Transformer中的编码器来抽取文本特征。
6.预测两个句子的关系
  BERT的计算包括两个子任务，预测两个句子的关系为其中一个子任务，BERT要计算出输入的两个句子的关系，这一般是二分类任务。
7.预测MASK词
  这是BERT的另外一个子任务，要预测出句子中的MASK原本的词。

二.数据集介绍和预处理
1.数据集介绍
  数据集使用微软提供的MSR Paraphrase数据集进行训练，第1列的数字表示了这2个句子的意思是否相同，2列ID对于训练BERT模型没有用处，只需关注第1列和另外2列String。部分样例如下所示：

2.数据集预处理
  数据集预处理代码参考文献[2]，处理后包括msr_paraphrase_data.csv和msr_paraphrase_vocab.csv这2个文件，样例数据如下所示：



三.PyTorch中的Transformer工具层
  本部分不再手工实现Transformer编解码器，更多的使用PyTorch中已实现的Transformer工具层，从而专注于BERT模型的构建。
1.定义测试数据
  模拟虚拟了2句话，每句话8个词，每句话的末尾有一些PAD，如下所示：

# 虚拟数据
import torch
# 假设有两句话，8个词
x = torch.ones(2, 8)
# 两句话中各有一些PAD
x[0, 6:] = 0
x[1, 7:] = 0
print(x)

  输出结果如下所示：

tensor([[1., 1., 1., 1., 1., 1., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 0.]])

2.各个MASK的含义解释
  key_padding_mask作用是遮挡数据中的PAD位置，减少计算量；encode_attn_mask定义是否要忽略输入语句中某些词与词间的注意力，在编码器中是不需要的；decode_attn_mask定义是否忽略输出语句中某些词与词之间的注意力，在解码器中是需要的。如下所示：

# 2.各个MASK的含义解释
# 定义key_padding_mask
# key_padding_mask的定义方式，就是x中是pad的为True，否则是False
key_padding_mask = x == 0
print(key_padding_mask)

# 定义encode_attn_mask
# 在encode阶段不需要定义encode_attn_mask
# 定义为None或者全False都可以
encode_attn_mask = torch.ones(8, 8) == 0
print(encode_attn_mask)

# 定义decode_attn_mask
# 在decode阶段需要定义decode_attn_mask
# decode_attn_mask的定义方式是对角线以上为True的上三角矩阵
decode_attn_mask = torch.tril(torch.ones(8, 8)) == 0
print(decode_attn_mask)

  输出结果如下所示：

tensor([[False, False, False, False, False, False,  True,  True],
        [False, False, False, False, False, False, False,  True]])
tensor([[False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False],
        [False, False, False, False, False, False, False, False]])
tensor([[False,  True,  True,  True,  True,  True,  True,  True],
        [False, False,  True,  True,  True,  True,  True,  True],
        [False, False, False,  True,  True,  True,  True,  True],
        [False, False, False, False,  True,  True,  True,  True],
        [False, False, False, False, False,  True,  True,  True],
        [False, False, False, False, False, False,  True,  True],
        [False, False, False, False, False, False, False,  True],
        [False, False, False, False, False, False, False, False]])

3.编码数据
  将x编码为2×8×12，表示2句话、每句话8个词、每个词用12维的Embedding向量表示：

# 编码x
x = x.unsqueeze(2) # 在第2维增加一个维度
x = x.expand(-1, -1, 12) # 在第2维复制12份
print(x, x.shape)

  输出结果如下所示：

tensor([[[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],

        [[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]]) torch.Size([2, 8, 12])

4.多头注意力计算函数
  在计算多头注意力机制市需要做2次线性变化，一次是对入参的Q、K和V矩阵分别做线性变换，另一次是对注意力分数做线性变换，2次线性变换分别需要2组weight合bias参数，如下所示：

# 定义multi_head_attention_forward()所需要的参数
# in_proj就是Q、K、V线性变换的参数
in_proj_weight = torch.nn.Parameter(torch.randn(3 * 12, 12))
in_proj_bias = torch.nn.Parameter(torch.zeros((3 * 12)))
# out_proj就是输出时做线性变换的参数
out_proj_weight = torch.nn.Parameter(torch.randn(12, 12))
out_proj_bias = torch.nn.Parameter(torch.zeros(12))
print(in_proj_weight.shape, in_proj_bias.shape)
print(out_proj_weight.shape, out_proj_bias.shape)

# 使用工具函数计算多头注意力
data = {
    # 因为不是batch_first的，所以需要进行变形
    'query': x.permute(1, 0, 2), # x原始为[2, 8, 12]，x.permute为[8, 2, 12]
    'key': x.permute(1, 0, 2),
    'value': x.permute(1, 0, 2),
    'embed_dim_to_check': 12, # 用于检查维度是否正确
    'num_heads': 2, # 多头注意力的头数
    'in_proj_weight': in_proj_weight, # Q、K、V线性变换的参数
    'in_proj_bias': in_proj_bias, # Q、K、V线性变换的参数
    'bias_k': None,
    'bias_v': None,
    'add_zero_attn': False,
    'dropout_p': 0.2, # dropout的概率
    'out_proj_weight': out_proj_weight, # 输出时做线性变换的参数
    'out_proj_bias': out_proj_bias, # 输出时做线性变换的参数
    'key_padding_mask': key_padding_mask,
    'attn_mask': encode_attn_mask,
}
score, attn = torch.nn.functional.multi_head_attention_forward(**data)
print(score.shape, attn, attn.shape)

（1）bias_k、bias_v：是否要对K和V矩阵单独添加bias，一般设置为None。
（2）add_zero_attn：如果设置为True，那么会在Q、K的注意力结果中单独加一列0，一般设置为默认值False。
（3）key_padding_mask：是否要忽略语句中的某些位置，一般只需忽略PAD的位置。
（4）attn_mask：是否要忽略每个词之间的注意力，在编码器中一般只用全False的矩阵，在解码器中一般使用对角线以上全True的矩阵。
  输出结果如下所示：

torch.Size([36, 12]) torch.Size([36])
torch.Size([12, 12]) torch.Size([12])
torch.Size([8, 2, 12]) tensor([[[0.2083, 0.2083, 0.2083, 0.1042, 0.2083, 0.0000, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.1042, 0.2083, 0.2083, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.1042, 0.1042, 0.1042, 0.2083, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.1042, 0.1042, 0.2083, 0.2083, 0.1042, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.2083, 0.1042, 0.2083, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.1042, 0.2083, 0.2083, 0.1042, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.2083, 0.1042, 0.2083, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.1042, 0.2083, 0.1042, 0.1042, 0.2083, 0.0000, 0.0000]],

        [[0.0893, 0.1786, 0.0893, 0.1786, 0.1786, 0.1786, 0.1786, 0.0000],
         [0.1786, 0.1786, 0.1786, 0.1786, 0.1786, 0.1786, 0.1786, 0.0000],
         [0.1786, 0.0000, 0.1786, 0.1786, 0.1786, 0.1786, 0.0893, 0.0000],
         [0.1786, 0.1786, 0.1786, 0.1786, 0.0893, 0.1786, 0.0893, 0.0000],
         [0.1786, 0.1786, 0.1786, 0.0000, 0.1786, 0.0893, 0.1786, 0.0000],
         [0.1786, 0.1786, 0.1786, 0.1786, 0.1786, 0.1786, 0.0893, 0.0000],
         [0.1786, 0.0893, 0.0893, 0.1786, 0.1786, 0.0893, 0.0000, 0.0000],
         [0.1786, 0.1786, 0.0893, 0.0893, 0.1786, 0.1786, 0.1786, 0.0000]]],
       grad_fn=<MeanBackward1>) torch.Size([2, 8, 8])

5.多头注意力层
  封装程度更高的多头注意力层实现方式如下所示：

# 使用多头注意力工具层
multihead_attention = torch.nn.MultiheadAttention(embed_dim=12, num_heads=2, dropout=0.2, batch_first=True)
data = {
    'query': x,
    'key': x,
    'value': x,
    'key_padding_mask': key_padding_mask,
    'attn_mask': encode_attn_mask,
}
score, attn = multihead_attention(**data)
print(score.shape, attn, attn.shape)

  输出结果如下所示：

torch.Size([2, 8, 12]) tensor([[[0.1042, 0.2083, 0.0000, 0.1042, 0.1042, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.1042, 0.2083, 0.0000, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.2083, 0.2083, 0.0000, 0.2083, 0.0000, 0.0000],
         [0.1042, 0.2083, 0.2083, 0.1042, 0.2083, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.2083, 0.1042, 0.1042, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.2083, 0.1042, 0.2083, 0.1042, 0.0000, 0.0000],
         [0.1042, 0.0000, 0.2083, 0.1042, 0.2083, 0.2083, 0.0000, 0.0000],
         [0.2083, 0.2083, 0.2083, 0.1042, 0.2083, 0.2083, 0.0000, 0.0000]],

        [[0.1786, 0.1786, 0.0893, 0.0000, 0.1786, 0.1786, 0.1786, 0.0000],
         [0.1786, 0.1786, 0.1786, 0.0893, 0.1786, 0.0893, 0.0893, 0.0000],
         [0.0893, 0.0893, 0.0893, 0.0893, 0.1786, 0.1786, 0.1786, 0.0000],
         [0.1786, 0.0893, 0.0893, 0.1786, 0.1786, 0.1786, 0.0893, 0.0000],
         [0.1786, 0.0893, 0.1786, 0.1786, 0.0893, 0.0893, 0.0000, 0.0000],
         [0.1786, 0.1786, 0.1786, 0.1786, 0.0000, 0.1786, 0.0893, 0.0000],
         [0.1786, 0.0000, 0.1786, 0.0893, 0.1786, 0.0893, 0.1786, 0.0000],
         [0.1786, 0.0893, 0.0893, 0.0893, 0.0893, 0.1786, 0.0893, 0.0000]]],
       grad_fn=<MeanBackward1>) torch.Size([2, 8, 8])

  其中，batch_first=True，表示input和output张量的shape为(batch, seq, feature)。默认为False，input和output张量的shape为(seq, batch, feature)。
6.编码器层
  编码器包含多个编码器层，其中batch_first表示输入的第1维度是否是batch_size，norm_first通过该参数指定是否将标准化层前置计算。如下所示：

# 使用单层编码器工具层
encoder_layer = torch.nn.TransformerEncoderLayer(
                        d_model=12,                          # 词向量的维度
                        nhead=2,                             # 多头注意力的头数
                        dim_feedforward=24,                  # 前馈神经网络的隐层维度
                        dropout=0.2,                         # dropout的概率
                        activation=torch.nn.functional.relu, # 激活函数
                        batch_first=True,                    # 输入数据的第一维是batch
                        norm_first=True)                     # 归一化层在前
data = {
    'src': x,                                 # 输入数据
    'src_mask': encode_attn_mask,             # 输入数据的mask
    'src_key_padding_mask': key_padding_mask, # 输入数据的key_padding_mask
}
out = encoder_layer(**data)
print(out.shape) #torch.Size([2, 8, 12])

# 使用编码器工具层
encoder = torch.nn.TransformerEncoder(
    encoder_layer=encoder_layer,                  # 编码器层
    num_layers=3,                                 # 编码器层数
    norm=torch.nn.LayerNorm(normalized_shape=12)) # 归一化层
data = {
    'src': x, # 输入数据
    'mask': encode_attn_mask,                     # 输入数据的mask
    'src_key_padding_mask': key_padding_mask,     # 输入数据的key_padding_mask
}
out = encoder(**data)
print(out.shape) #torch.Size([2, 8, 12])

7.解码器层
  BERT当中不会用到Transformer的解码器，解码器包含多个解码器层，如下所示：

# 7.解码器层
#  使用单层解码器工具层
decoder_layer = torch.nn.TransformerDecoderLayer(    # 解码器层
                d_model=12,                          # 词向量的维度
                nhead=2,                             # 多头注意力的头数
                dim_feedforward=24,                  # 前馈神经网络的隐层维度
                dropout=0.2,                         # dropout的概率
                activation=torch.nn.functional.relu, # 激活函数
                batch_first=True,                    # 输入数据的第一维是batch
                norm_first=True)                     # 归一化层在前
data = {
    'tgt': x,                                        # 解码输出的目标语句，即target
    'memory': x,                                     # 编码器的编码结果，即解码器解码时的根据数据
    'tgt_mask': decode_attn_mask,                    # 定义是否要忽略词与词之间的注意力，即decode_attn_mask
    'memory_mask': encode_attn_mask,                 # 定义是否要忽略memory内的部分词与词之间的注意力，一般不需要要忽略
    'tgt_key_padding_mask': key_padding_mask,        # 定义target内哪些位置是PAD，以忽略对PAD的注意力
    'memory_key_padding_mask': key_padding_mask,     # 定义memory内哪些位置是PAD，以忽略对PAD的注意力
}
out = decoder_layer(**data)
print(out.shape) #(2,8,12)

# 使用编码器工具层
decoder = torch.nn.TransformerDecoder(    # 解码器层
    decoder_layer=decoder_layer,          # 解码器层
    num_layers=3,                         # 解码器层数
    norm=torch.nn.LayerNorm(normalized_shape=12))
data = {
    'tgt': x,
    'memory': x,
    'tgt_mask': decode_attn_mask,
    'memory_mask': encode_attn_mask,
    'tgt_key_padding_mask': key_padding_mask,
    'memory_key_padding_mask': key_padding_mask,
}
out = decoder(**data)
print(out.shape) #(2,8,12)

8.完整的Transformer模型
  Transformer主模型由编码器和解码器组成，如下所示：

# 使用Transformer工具模型
transformer = torch.nn.Transformer(d_model=12,               # 词向量的维度
                        nhead=2,                             # 多头注意力的头数
                        num_encoder_layers=3,                # 编码器层数
                        num_decoder_layers=3,                # 解码器层数
                        dim_feedforward=24,                  # 前馈神经网络的隐层维度
                        dropout=0.2,                         # dropout的概率
                        activation=torch.nn.functional.relu, # 激活函数
                        custom_encoder=encoder,              # 自定义编码器，如果指定为None，那么会使用默认的编码器层堆叠num_encoder_layers层组成编码器
                        custom_decoder=decoder,              # 自定义解码器，如果指定为None，那么会使用默认的解码器层堆叠num_decoder_layers层组成解码器
                        batch_first=True,                    # 输入数据的第一维是batch
                        norm_first=True)                     # 归一化层在前
data = {
    'src': x,
    'tgt': x,
    'src_mask': encode_attn_mask,
    'tgt_mask': decode_attn_mask,
    'memory_mask': encode_attn_mask,
    'src_key_padding_mask': key_padding_mask,
    'tgt_key_padding_mask': key_padding_mask,
    'memory_key_padding_mask': key_padding_mask,
}
out = transformer(**data)
print(out.shape) #torch.Size([2, 8, 12])

四.手动实现BERT模型
  因为这部分代码较长，就不放出来了，详细参考文献[4]。需要说明的是BERT在训练阶段有两个子任务，分别为预测两句话的意思是否一致，以及被遮掩的词的原本的词。把编码器抽取的文本特征分别输入两个线性神经网络，并且以此计算这两个输出。重点说下random_replace()函数对所有句子的替换策略，如下所示：

# 定义随机替换函数
def random_replace(sent):
    # sent = [b,63]
    # 不影响原来的sent
    sent = sent.clone()
    # 替换矩阵，形状和sent一样，被替换过的位置是True，其他位置是False
    replace = sent == -1
    # 遍历所有的词
    for i in range(len(sent)):
        for j in range(len(sent[i])):
            # 如果是符号就不操作了，只替换词
            if sent[i, j] <= 10:
                continue
            # 以0.15的概率进行操作
            if random.random() > 0.15:
                pass
            # 对被操作过的位置进行标记，这里的操作包括什么也不做
            replace[i, j] = True
            # 分概率做不同的操作
            p = random.random()
            # 以O.8的概率替换为MASK
            if p < 0.8:
                sent[i, j] = vocab.loc['<MASK>'].token
            # 以0.1的概率不替换
            elif p < 0.9:
                continue
            # 以0.1的概率替换成随机词
            else:
                # 随机生成一个不是符号的词
                rand_word = 0
                while rand_word <= 10:
                    rand_word = random.randint(0, len(vocab) - 1)
                sent[i, j] = rand_word
    return sent, replace

  每个句子中的每个词都有15%的概率被替换，而替换也不仅有替换为MASK这一种情况。在被判定为当前词要替换后，该词有80%的概率被替换为MASK，有10%的概率被替换为一个随机词，有10%的概率不替换为任何词。如下所示：


参考文献：
[1]《HuggingFace自然语言处理详解：基于BERT中文模型的任务实战》
[2]https://github.com/ai408/nlp-engineering/blob/main/20230625_HuggingFace自然语言处理详解/第14章：手动实现BERT_数据预处理.py
[3]https://github.com/ai408/nlp-engineering/blob/main/20230625_HuggingFace自然语言处理详解/第14章：手动实现BERT_PyTorch中的Transformer工具层.py
[4]https://github.com/ai408/nlp-engineering/blob/main/20230625_HuggingFace自然语言处理详解/第14章：手动实现BERT_训练和测试.py
[5]Bert模型的细节到底是怎么样的：https://www.zhihu.com/question/534763354
[6]BERT模型参数量：https://zhuanlan.zhihu.com/p/452267359
[7]HuggingFace Transformers最新版本源码解读：https://zhuanlan.zhihu.com/p/360988428
[8]NLP Course：https://huggingface.co/learn/nlp-course/zh-CN/chapter1/1

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1051484.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Azure Arc 概要：功能、管理和应用场景详解，AZ900 考点示例

Azure Arc 概要：功能、管理和应用场景详解，AZ900 考点示例

文章目录 本文大纲一、什么是 Azure Arc二、使用 Azure Arc 可以做什么操作三、使用 Azure Arc 可以管理什么资源3.1 如何使用Azure Arc与服务器? 四、Azure Arc 支持的主要场景五、在 AZ900 中的考点示例5.1 示例题 15.2 示例题 2 本文大纲 本文思维导图概述的主要内容&…
阅读更多...
【C/C++】C/C++面试八股

【C/C++】C/C++面试八股

C/C面试八股 C和C语言的区别简单介绍一下三大特性多态的实现原理虚函数的构成原理虚函数的调用原理虚表指针在什么地方进行初始化的&#xff1f;构造函数为什么不能是虚函数虚函数和纯虚函数的区别抽象类类对象的对象模型内存对齐是什么&#xff1f;为什么要内存对齐static关键…
阅读更多...
嵌入式Linux应用开发-第十章LED模板总线设备驱动模型

嵌入式Linux应用开发-第十章LED模板总线设备驱动模型

嵌入式Linux应用开发-第十章LED模板总线设备驱动模型 第十章 LED模板驱动程序的改造&#xff1a;总线设备驱动模型10.1 原来的框架10.2 要实现的框架10.3 写代码10.3.1 注意事项10.3.2 实现 platform_device结构体10.3.3 实现 platform_driver结构体 10.4 课后作业 第十章 LED模…
阅读更多...
CCF CSP认证 历年题目自练Day13

CCF CSP认证 历年题目自练Day13

CCF CSP认证 历年题目自练Day13 题目一 试题编号&#xff1a; 201612-1 试题名称&#xff1a; 中间数 时间限制&#xff1a; 1.0s 内存限制&#xff1a; 256.0MB 问题描述&#xff1a; 问题描述 　　在一个整数序列a1, a2, …, an中&#xff0c;如果存在某个数&#xff0c;大…
阅读更多...
web：[极客大挑战 2019]BabySQL

web：[极客大挑战 2019]BabySQL

题目 点进页面显示如下 查看源代码 先尝试一下万能密码 没用&#xff0c;or被过滤了 试着双写看看 回显一串&#xff0c;也不是flag 先查询列数尝试一下&#xff0c;把union select过滤了&#xff0c;使用双写 构造payload /check.php?usernameadmin&password1 %27 ununi…
阅读更多...
基于Java的医院住院管理系统设计与实现(源码+lw+部署文档+讲解等)

基于Java的医院住院管理系统设计与实现(源码+lw+部署文档+讲解等)

文章目录 前言系统功能具体实现截图论文参考详细视频演示为什么选择我自己的网站自己的小程序&#xff08;小蔡coding&#xff09;有保障的售后福利 代码参考源码获取 前言 &#x1f497;博主介绍&#xff1a;✌全网粉丝10W,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域…
阅读更多...
ShowDoc部署与应用：文档管理的最佳实践

ShowDoc部署与应用：文档管理的最佳实践

在项目开发和协作中&#xff0c;文档管理扮演着至关重要的角色。ShowDoc作为一款卓越的开源文档管理工具&#xff0c;不仅提供强大的文档管理功能&#xff0c;还具备简单易用的协作和部署特性。我们的项目团队最初选择了ShowDoc作为文档管理工具&#xff0c;用以促进前后端协作…
阅读更多...
【超分：光谱响应函数】

【超分：光谱响应函数】

Spectral Response Function-Guided Deep Optimization-Driven Network for Spectral Super-Resolution &#xff08;光谱响应函数引导的深度优化驱动网络光谱超分辨&#xff09; 高光谱图像&#xff08;HSI&#xff09;是许多研究工作的关键。光谱超分辨率&#xff08;SSR&a…
阅读更多...
mysql面试题5：索引、主键、唯一索引、联合索引的区别？什么情况下设置了索引但无法使用？并且举例说明

mysql面试题5：索引、主键、唯一索引、联合索引的区别？什么情况下设置了索引但无法使用？并且举例说明

该文章专注于面试，面试只要回答关键点即可，不需要对框架有非常深入的回答，如果你想应付面试，是足够了，抓住关键点 面试官：说一说索引、主键、唯一索引、联合索引的区别？ 索引、主键、唯一索引和联合索引是数据库中常用的索引类型，它们有以下区别： 索引：索引是一种数…
阅读更多...
时序分解 | Matlab实现SSA-VMD麻雀算法优化变分模态分解时间序列信号分解

时序分解 | Matlab实现SSA-VMD麻雀算法优化变分模态分解时间序列信号分解

时序分解 | Matlab实现SSA-VMD麻雀算法优化变分模态分解时间序列信号分解 目录 时序分解 | Matlab实现SSA-VMD麻雀算法优化变分模态分解时间序列信号分解效果一览基本介绍程序设计参考资料 效果一览 基本介绍 SSA-VMD麻雀搜索算法SSA优化VMD变分模态分解 可直接运行 分解效果好…
阅读更多...
JavaScript Web APIs第二天笔记

JavaScript Web APIs第二天笔记

Web APIs - 第2天 学会通过为DOM注册事件来实现可交互的网页特效。 能够判断函数运行的环境并确字 this 所指代的对象理解事件的作用&#xff0c;知道应用事件的 3 个步骤 学习会为 DOM 注册事件&#xff0c;实现简单可交互的网页特交。 事件 事件是编程语言中的术语&#xff…
阅读更多...
笔试强训Day7

笔试强训Day7

T1&#xff1a;合法括号序列判断 链接&#xff1a;合法括号序列判断__牛客网 给定一个字符串A和其长度n&#xff0c;请返回一个bool值代表它是否为一个合法的括号串&#xff08;只能由括号组成&#xff09;。 经典括号匹配问题&#xff0c;考察栈的使用 #include<iostre…
阅读更多...
freertos中函数调用和启动第一个任务(栈相关!!!!!!）

freertos中函数调用和启动第一个任务(栈相关!!!!!!）

本内容仅就一些较难理解的点讲解&#xff0c;请结合其它文章实用 在函数调用时&#xff0c;m3的处理器使用r0-r3共四个寄存器传参&#xff0c;其余的使用栈传参。 但是&#xff0c;如果传入的参数是全局变量&#xff0c;则不需传参&#xff0c;因为全局变量在函数内部是可见的…
阅读更多...
YOLO训练心得

YOLO训练心得

文件框架 通过简单的模型训练&#xff0c;对于YOLO的理解更加透彻了。 detect.py文件 如上图所示&#xff0c;weights表示权重。source表示识别图像的位置。 train.py文件 如上图所示&#xff0c;weights是权重&#xff0c;我们通常使用YOLO提供的训练权重进行训练。data是训…
阅读更多...
ADworld reverse wp easyre-153

ADworld reverse wp easyre-153

逆向分析 做逆向题先查壳, 就像做pwn先checksec一样 用PEid查不出来, 用Exeinfo PE可以查出ELF文件的壳 用工具直接脱upx壳, kali自带的工具或者手动安装一个windows的upx工具 脱壳之后拖入IDA32 int __cdecl main(int argc, const char **argv, const char **envp) {int …
阅读更多...
SLAM从入门到精通（amcl定位使用）

SLAM从入门到精通（amcl定位使用）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 学习slam&#xff0c;一般就是所谓的边定位、边制图的知识。然而在实际生产过程中&#xff0c;比如扫地机器人、agv、巡检机器人、农业机器人&…
阅读更多...
Sentinel学习——sentinel的使用，引入依赖和配置 对消费者进行流控 对生产者进行熔断降级

Sentinel学习——sentinel的使用，引入依赖和配置 对消费者进行流控 对生产者进行熔断降级

前言 Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件&#xff0c;主要以流量为切入点&#xff0c;从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。 本篇博客介绍sentinel的使用&#x…
阅读更多...
Bug：elementUI样式不起作用

Bug：elementUI样式不起作用

前端问题合集&#xff1a;VueElementUI 1. Vue引用Element-UI时&#xff0c;组件无效果解决方案 前提&#xff1a; 已经安装好elementUI依赖 //安装依赖 npm install element-ui //main.js中导入依赖并在全局中使用 import ElementUI from element-ui Vue.use(ElementUI)如果此…
阅读更多...
电压提前/滞后电路 —— 电赛综测备赛

电压提前/滞后电路 —— 电赛综测备赛

电容可以让交流波形提前或滞后&#xff0c;不过很多人不知道用法 电压滞后电路 我们从中间输出给示波器 波形&#xff08;红色&#xff09; 电容越大电阻越大&#xff0c;波形越滞后 电压提前电路 波形&#xff08;红色&#xff09;提前 电容越小电阻越小&#xff0c;波形…
阅读更多...
【python】numpy库

【python】numpy库

文章目录 简单介绍功能示例代码 简单介绍 NumPy&#xff08;Numerical Python的简称&#xff09;是Python数值计算最重要的基础包。大多数提供科学计算的包都是用NumPy的数组作为构建基础。 NumPy是在一个连续的内存块中存储数据&#xff0c;独立于其他Python内置对象。NumPy…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023