熬了一晚上，我从零实现了Transformer模型，把代码讲给你听

迈不过友情╰ 2022-09-17 00:59 72阅读 0赞

作者丨伟大是熬出来的@知乎

编辑 | 极市平台

自从彻底搞懂`Self_Attention`机制之后，笔者对`Transformer`模型的理解直接从地下一层上升到大气层，任督二脉呼之欲出。夜夜入睡之前，那句柔情百转的"Attention is all you need"时常在耳畔环绕，情到深处不禁拍床叫好。于是在肾上腺素的驱使下，笔者熬了一个晚上，终于实现了`Transformer`模型。

## 1. 模型总览 ##

代码讲解之前，首先放出这张经典的模型架构图。下面的内容中，我会将每个模块的实现思路以及笔者在Coding过程中的感悟知无不答。没有代码基础的读者不要慌张，笔者也是最近才入门的，所写Pytorch代码没有花里胡哨，所用变量名词尽量保持与论文一致，对新手十分友好。

![84455fecca04fa5f552bfe01e93dcad7.png][]

我们观察模型的结构图，Transformer模型包含哪些模块？笔者将其分为以下几个部分：

![8b0f80fc04b294fed477d0e42ae69498.png][]

接下来我们首先逐个讲解，最后将其拼接完成模型的复现。

## 2. config ##

下面是这个Demo所用的库文件以及一些超参的信息。**单独实现一个Config类保存的原因是，方便日后复用。直接将模型部分复制，所用超参保存在新项目的Config类中即可**。这里不过多赘述。

import torch
    import torch.nn as nn
    import numpy as np
    import math
    
    
    class Config(object):
        def __init__(self):
            self.vocab_size = 6
    
            self.d_model = 20
            self.n_heads = 2
    
            assert self.d_model % self.n_heads == 0
            dim_k  = d_model % n_heads
            dim_v = d_model % n_heads
    
            self.padding_size = 30
            self.UNK = 5
            self.PAD = 4
    
            self.N = 6
            self.p = 0.1
    
    config = Config()

## 3. Embedding ##

Embedding部分接受原始的文本输入(batch\_size\*seq\_len,例:\[\[1,3,10,5\],\[3,4,5\],\[5,3,1,1\]\])，叠加一个普通的Embedding层以及一个Positional Embedding层，输出最后结果。

![9180e556788e5c00add0d964f5013b13.png][]

在这一层中，输入的是一个list: \[batch\_size \* seq\_len\]，输出的是一个tensor:\[batch\_size \* seq\_len \* d\_model\]

普通的 Embedding 层想说两点：

*  采用`torch.nn.Embedding`实现embedding操作。需要关注的一点是论文中提到的Mask机制，包括padding\_mask以及sequence\_mask(具体请见文章开头给出的理论讲解那篇文章)。在文本输入之前，我们需要进行padding统一长度，padding\_mask的实现可以借助`torch.nn.Embedding`中的`padding_idx`参数。
 *  在padding过程中，短补长截

class Embedding(nn.Module):
        def __init__(self,vocab_size):
            super(Embedding, self).__init__()
            # 一个普通的 embedding层，我们可以通过设置padding_idx=config.PAD 来实现论文中的 padding_mask
            self.embedding = nn.Embedding(vocab_size,config.d_model,padding_idx=config.PAD)
    
    
        def forward(self,x):
            # 根据每个句子的长度，进行padding，短补长截
            for i in range(len(x)):
                if len(x[i]) < config.padding_size:
                    x[i].extend([config.UNK] * (config.padding_size - len(x[i]))) # 注意 UNK是你词表中用来表示oov的token索引，这里进行了简化，直接假设为6
                else:
                    x[i] = x[i][:config.padding_size]
            x = self.embedding(torch.tensor(x)) # batch_size * seq_len * d_model
            return x

关于Positional Embedding，我们需要参考论文给出的公式。说一句题外话，在作者的实验中对比了Positional Embedding与单独采用一个Embedding训练模型对位置的感知两种方式，模型效果相差无几。

![cfcb9257cff0d26d76aae4395983ea6e.png][] ![7ecd93ccb2217502477756b6d06c7f4e.png][]

class Positional_Encoding(nn.Module):
    
        def __init__(self,d_model):
            super(Positional_Encoding,self).__init__()
            self.d_model = d_model
    
    
        def forward(self,seq_len,embedding_dim):
            positional_encoding = np.zeros((seq_len,embedding_dim))
            for pos in range(positional_encoding.shape[0]):
                for i in range(positional_encoding.shape[1]):
                    positional_encoding[pos][i] = math.sin(pos/(10000**(2*i/self.d_model))) if i % 2 == 0 else math.cos(pos/(10000**(2*i/self.d_model)))
            return torch.from_numpy(positional_encoding)

## 4. Encoder ##

![ce0ba4bd352f66ee7eae5a3a42608d1b.png][]

### Muti\_head\_Attention ###

这一部分是模型的核心内容，理论部分就不过多讲解了，读者可以参考文章开头的第一个传送门，文中有基础的代码实现。

Encoder 中的 Muti\_head\_Attention 不需要Mask，因此与我们上一篇文章中的实现方式相同。

为了避免模型信息泄露的问题，Decoder 中的 Muti\_head\_Attention 需要Mask。这一节中我们重点讲解Muti\_head\_Attention中Mask机制的实现。

如果读者阅读了我们的上一篇文章，可以发现下面的代码有一点小小的不同，主要体现在 `forward` 函数的参数。

*  `forward` 函数的参数从 x 变为 x,y：请读者观察模型架构，Decoder需要接受Encoder的输入作为公式中的`V`,即我们参数中的y。在普通的自注意力机制中，我们在调用中设置`y=x`即可。
 *  requires\_mask：是否采用Mask机制，在Decoder中设置为True

class Mutihead_Attention(nn.Module):
        def __init__(self,d_model,dim_k,dim_v,n_heads):
            super(Mutihead_Attention, self).__init__()
            self.dim_v = dim_v
            self.dim_k = dim_k
            self.n_heads = n_heads
    
            self.q = nn.Linear(d_model,dim_k)
            self.k = nn.Linear(d_model,dim_k)
            self.v = nn.Linear(d_model,dim_v)
    
            self.o = nn.Linear(dim_v,d_model)
            self.norm_fact = 1 / math.sqrt(d_model)
    
        def generate_mask(self,dim):
            # 此处是 sequence mask ，防止 decoder窥视后面时间步的信息。
            # padding mask 在数据输入模型之前完成。
            matirx = np.ones((dim,dim))
            mask = torch.Tensor(np.tril(matirx))
    
            return mask==1
    
        def forward(self,x,y,requires_mask=False):
            assert self.dim_k % self.n_heads == 0 and self.dim_v % self.n_heads == 0
            # size of x : [batch_size * seq_len * batch_size]
            # 对 x 进行自注意力
            Q = self.q(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.n_heads) # n_heads * batch_size * seq_len * dim_k
            K = self.k(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.n_heads) # n_heads * batch_size * seq_len * dim_k
            V = self.v(y).reshape(-1,y.shape[0],y.shape[1],self.dim_v // self.n_heads) # n_heads * batch_size * seq_len * dim_v
            # print("Attention V shape : {}".format(V.shape))
            attention_score = torch.matmul(Q,K.permute(0,1,3,2)) * self.norm_fact
            if requires_mask:
                mask = self.generate_mask(x.shape[1])
                attention_score.masked_fill(mask,value=float("-inf")) # 注意这里的小Trick，不需要将Q,K,V 分别MASK,只MASKSoftmax之前的结果就好了
            output = torch.matmul(attention_score,V).reshape(y.shape[0],y.shape[1],-1)
            # print("Attention output shape : {}".format(output.shape))
    
            output = self.o(output)
            return output

### Feed Forward ###

![38d39ef0ba7b0436a6b4ddf8dfd4fe12.png][] img

这一部分实现很简单，两个Linear中连接Relu即可，目的是为模型增添非线性信息，提高模型的拟合能力。

class Feed_Forward(nn.Module):
        def __init__(self,input_dim,hidden_dim=2048):
            super(Feed_Forward, self).__init__()
            self.L1 = nn.Linear(input_dim,hidden_dim)
            self.L2 = nn.Linear(hidden_dim,input_dim)
    
        def forward(self,x):
            output = nn.ReLU()(self.L1(x))
            output = self.L2(output)
            return output

### Add & LayerNorm ###

这一节我们实现论文中提出的残差连接以及LayerNorm。

论文中关于这部分给出公式：

![d66fc1ddc4475d7b3ec45463015d4a2e.png][]

代码中的dropout，在论文中也有所解释，对输入layer\_norm的tensor进行dropout，对模型的性能影响还是蛮大的。

代码中的参数`sub_layer` ，可以是Feed Forward，也可以是Muti\_head\_Attention。

class Add_Norm(nn.Module):
        def __init__(self):
            self.dropout = nn.Dropout(config.p)
            super(Add_Norm, self).__init__()
    
        def forward(self,x,sub_layer,**kwargs):
            sub_output = sub_layer(x,**kwargs)
            # print("{} output : {}".format(sub_layer,sub_output.size()))
            x = self.dropout(x + sub_output)
    
            layer_norm = nn.LayerNorm(x.size()[1:])
            out = layer_norm(x)
            return out

OK，Encoder中所有模块我们已经讲解完毕，接下来我们将其拼接作为Encoder

class Encoder(nn.Module):
        def __init__(self):
            super(Encoder, self).__init__()
            self.positional_encoding = Positional_Encoding(config.d_model)
            self.muti_atten = Mutihead_Attention(config.d_model,config.dim_k,config.dim_v,config.n_heads)
            self.feed_forward = Feed_Forward(config.d_model)
    
            self.add_norm = Add_Norm()
    
    
        def forward(self,x): # batch_size * seq_len 并且 x 的类型不是tensor，是普通list
    
            x += self.positional_encoding(x.shape[1],config.d_model)
            # print("After positional_encoding: {}".format(x.size()))
            output = self.add_norm(x,self.muti_atten,y=x)
            output = self.add_norm(output,self.feed_forward)
    
            return output

## 5.Decoder ##

在 Encoder 部分的讲解中，我们已经实现了大部分Decoder的模块。Decoder的Muti\_head\_Attention引入了Mask机制，Decoder与Encoder 中模块的拼接方式不同。以上两点读者在Coding的时候需要注意。

class Decoder(nn.Module):
        def __init__(self):
            super(Decoder, self).__init__()
            self.positional_encoding = Positional_Encoding(config.d_model)
            self.muti_atten = Mutihead_Attention(config.d_model,config.dim_k,config.dim_v,config.n_heads)
            self.feed_forward = Feed_Forward(config.d_model)
            self.add_norm = Add_Norm()
    
        def forward(self,x,encoder_output): # batch_size * seq_len 并且 x 的类型不是tensor，是普通list
            # print(x.size())
            x += self.positional_encoding(x.shape[1],config.d_model)
            # print(x.size())
            # 第一个 sub_layer
            output = self.add_norm(x,self.muti_atten,y=x,requires_mask=True)
            # 第二个 sub_layer
            output = self.add_norm(output,self.muti_atten,y=encoder_output,requires_mask=True)
            # 第三个 sub_layer
            output = self.add_norm(output,self.feed_forward)
    
    
            return output

## 6.Transformer ##

至此，所有内容已经铺垫完毕，我们开始组装Transformer模型。论文中提到，Transformer中堆叠了6个我们上文中实现的Encoder 和 Decoder。这里笔者采用`nn.Sequential`实现了堆叠操作。

Output模块的 Linear 和 Softmax 的实现也包含在下面的代码中

class Transformer_layer(nn.Module):
        def __init__(self):
            super(Transformer_layer, self).__init__()
            self.encoder = Encoder()
            self.decoder = Decoder()
    
        def forward(self,x):
            x_input,x_output = x
            encoder_output = self.encoder(x_input)
            decoder_output = self.decoder(x_output,encoder_output)
            return (encoder_output,decoder_output)
    
    
    class Transformer(nn.Module):
        def __init__(self,N,vocab_size,output_dim):
            super(Transformer, self).__init__()
            self.embedding_input = Embedding(vocab_size=vocab_size)
            self.embedding_output = Embedding(vocab_size=vocab_size)
    
            self.output_dim = output_dim
            self.linear = nn.Linear(config.d_model,output_dim)
            self.softmax = nn.Softmax(dim=-1)
            self.model = nn.Sequential(*[Transformer_layer() for _ in range(N)])
    
    
        def forward(self,x):
            x_input , x_output = x
            x_input = self.embedding_input(x_input)
            x_output = self.embedding_output(x_output)
    
            _ , output = self.model((x_input,x_output))
    
            output = self.linear(output)
            output = self.softmax(output)
    
            return output

## 完整代码 ##

# @Author:Yifx
    # @Contact: Xxuyifan1999@163.com
    # @Time:2021/9/16 20:02
    # @Software: PyCharm
    
    """
    文件说明：
    """
    
    import torch
    import torch.nn as nn
    import numpy as np
    import math
    
    
    class Config(object):
        def __init__(self):
            self.vocab_size = 6
    
            self.d_model = 20
            self.n_heads = 2
    
            assert self.d_model % self.n_heads == 0
            dim_k  = self.d_model // self.n_heads
            dim_v = self.d_model // self.n_heads
    
    
    
            self.padding_size = 30
            self.UNK = 5
            self.PAD = 4
    
            self.N = 6
            self.p = 0.1
    
    config = Config()
    
    
    class Embedding(nn.Module):
        def __init__(self,vocab_size):
            super(Embedding, self).__init__()
            # 一个普通的 embedding层，我们可以通过设置padding_idx=config.PAD 来实现论文中的 padding_mask
            self.embedding = nn.Embedding(vocab_size,config.d_model,padding_idx=config.PAD)
    
    
        def forward(self,x):
            # 根据每个句子的长度，进行padding，短补长截
            for i in range(len(x)):
                if len(x[i]) < config.padding_size:
                    x[i].extend([config.UNK] * (config.padding_size - len(x[i]))) # 注意 UNK是你词表中用来表示oov的token索引，这里进行了简化，直接假设为6
                else:
                    x[i] = x[i][:config.padding_size]
            x = self.embedding(torch.tensor(x)) # batch_size * seq_len * d_model
            return x
    
    
    
    class Positional_Encoding(nn.Module):
    
        def __init__(self,d_model):
            super(Positional_Encoding,self).__init__()
            self.d_model = d_model
    
    
        def forward(self,seq_len,embedding_dim):
            positional_encoding = np.zeros((seq_len,embedding_dim))
            for pos in range(positional_encoding.shape[0]):
                for i in range(positional_encoding.shape[1]):
                    positional_encoding[pos][i] = math.sin(pos/(10000**(2*i/self.d_model))) if i % 2 == 0 else math.cos(pos/(10000**(2*i/self.d_model)))
            return torch.from_numpy(positional_encoding)
    
    
    class Mutihead_Attention(nn.Module):
        def __init__(self,d_model,dim_k,dim_v,n_heads):
            super(Mutihead_Attention, self).__init__()
            self.dim_v = dim_v
            self.dim_k = dim_k
            self.n_heads = n_heads
    
            self.q = nn.Linear(d_model,dim_k)
            self.k = nn.Linear(d_model,dim_k)
            self.v = nn.Linear(d_model,dim_v)
    
            self.o = nn.Linear(dim_v,d_model)
            self.norm_fact = 1 / math.sqrt(d_model)
    
        def generate_mask(self,dim):
            # 此处是 sequence mask ，防止 decoder窥视后面时间步的信息。
            # padding mask 在数据输入模型之前完成。
            matirx = np.ones((dim,dim))
            mask = torch.Tensor(np.tril(matirx))
    
            return mask==1
    
        def forward(self,x,y,requires_mask=False):
            assert self.dim_k % self.n_heads == 0 and self.dim_v % self.n_heads == 0
            # size of x : [batch_size * seq_len * batch_size]
            # 对 x 进行自注意力
            Q = self.q(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.n_heads) # n_heads * batch_size * seq_len * dim_k
            K = self.k(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.n_heads) # n_heads * batch_size * seq_len * dim_k
            V = self.v(y).reshape(-1,y.shape[0],y.shape[1],self.dim_v // self.n_heads) # n_heads * batch_size * seq_len * dim_v
            # print("Attention V shape : {}".format(V.shape))
            attention_score = torch.matmul(Q,K.permute(0,1,3,2)) * self.norm_fact
            if requires_mask:
                mask = self.generate_mask(x.shape[1])
                # masked_fill 函数中，对Mask位置为True的部分进行Mask
                attention_score.masked_fill(mask,value=float("-inf")) # 注意这里的小Trick，不需要将Q,K,V 分别MASK,只MASKSoftmax之前的结果就好了
            output = torch.matmul(attention_score,V).reshape(y.shape[0],y.shape[1],-1)
            # print("Attention output shape : {}".format(output.shape))
    
            output = self.o(output)
            return output
    
    
    class Feed_Forward(nn.Module):
        def __init__(self,input_dim,hidden_dim=2048):
            super(Feed_Forward, self).__init__()
            self.L1 = nn.Linear(input_dim,hidden_dim)
            self.L2 = nn.Linear(hidden_dim,input_dim)
    
        def forward(self,x):
            output = nn.ReLU()(self.L1(x))
            output = self.L2(output)
            return output
    
    class Add_Norm(nn.Module):
        def __init__(self):
            self.dropout = nn.Dropout(config.p)
            super(Add_Norm, self).__init__()
    
        def forward(self,x,sub_layer,**kwargs):
            sub_output = sub_layer(x,**kwargs)
            # print("{} output : {}".format(sub_layer,sub_output.size()))
            x = self.dropout(x + sub_output)
    
            layer_norm = nn.LayerNorm(x.size()[1:])
            out = layer_norm(x)
            return out
    
    
    class Encoder(nn.Module):
        def __init__(self):
            super(Encoder, self).__init__()
            self.positional_encoding = Positional_Encoding(config.d_model)
            self.muti_atten = Mutihead_Attention(config.d_model,config.dim_k,config.dim_v,config.n_heads)
            self.feed_forward = Feed_Forward(config.d_model)
    
            self.add_norm = Add_Norm()
    
    
        def forward(self,x): # batch_size * seq_len 并且 x 的类型不是tensor，是普通list
    
            x += self.positional_encoding(x.shape[1],config.d_model)
            # print("After positional_encoding: {}".format(x.size()))
            output = self.add_norm(x,self.muti_atten,y=x)
            output = self.add_norm(output,self.feed_forward)
    
            return output
    
    # 在 Decoder 中，Encoder的输出作为Query和KEy输出的那个东西。即 Decoder的Input作为V。此时是可行的
    # 因为在输入过程中，我们有一个padding操作，将Inputs和Outputs的seq_len这个维度都拉成一样的了
    # 我们知道，QK那个过程得到的结果是 batch_size * seq_len * seq_len .既然 seq_len 一样，那么我们可以这样操作
    # 这样操作的意义是，Outputs 中的 token 分别对于 Inputs 中的每个token作注意力
    
    class Decoder(nn.Module):
        def __init__(self):
            super(Decoder, self).__init__()
            self.positional_encoding = Positional_Encoding(config.d_model)
            self.muti_atten = Mutihead_Attention(config.d_model,config.dim_k,config.dim_v,config.n_heads)
            self.feed_forward = Feed_Forward(config.d_model)
            self.add_norm = Add_Norm()
    
        def forward(self,x,encoder_output): # batch_size * seq_len 并且 x 的类型不是tensor，是普通list
            # print(x.size())
            x += self.positional_encoding(x.shape[1],config.d_model)
            # print(x.size())
            # 第一个 sub_layer
            output = self.add_norm(x,self.muti_atten,y=x,requires_mask=True)
            # 第二个 sub_layer
            output = self.add_norm(x,self.muti_atten,y=encoder_output,requires_mask=True)
            # 第三个 sub_layer
            output = self.add_norm(output,self.feed_forward)
            return output
    
    class Transformer_layer(nn.Module):
        def __init__(self):
            super(Transformer_layer, self).__init__()
            self.encoder = Encoder()
            self.decoder = Decoder()
    
        def forward(self,x):
            x_input,x_output = x
            encoder_output = self.encoder(x_input)
            decoder_output = self.decoder(x_output,encoder_output)
            return (encoder_output,decoder_output)
    
    class Transformer(nn.Module):
        def __init__(self,N,vocab_size,output_dim):
            super(Transformer, self).__init__()
            self.embedding_input = Embedding(vocab_size=vocab_size)
            self.embedding_output = Embedding(vocab_size=vocab_size)
    
            self.output_dim = output_dim
            self.linear = nn.Linear(config.d_model,output_dim)
            self.softmax = nn.Softmax(dim=-1)
            self.model = nn.Sequential(*[Transformer_layer() for _ in range(N)])
    
    
        def forward(self,x):
            x_input , x_output = x
            x_input = self.embedding_input(x_input)
            x_output = self.embedding_output(x_output)
    
            _ , output = self.model((x_input,x_output))
    
            output = self.linear(output)
            output = self.softmax(output)
    
            return output

本文仅做学术分享，如有侵权，请联系删文。

**3D视觉精品课程推荐：**

[1.面向自动驾驶领域的多传感器数据融合技术][1.]

[2.面向自动驾驶领域的3D点云目标检测全栈学习路线！(单模态+多模态/数据+代码)][2._3D]  
[3.彻底搞透视觉三维重建：原理剖析、代码讲解、及优化改进][3.]  
[4.国内首个面向工业级实战的点云处理课程][4.]  
[5.激光-视觉-IMU-GPS融合SLAM算法梳理和代码讲解][5._-_-IMU-GPS_SLAM]  
[6.彻底搞懂视觉-惯性SLAM：基于VINS-Fusion正式开课啦][6._-_SLAM_VINS-Fusion]  
[7.彻底搞懂基于LOAM框架的3D激光SLAM: 源码剖析到算法优化][7._LOAM_3D_SLAM_]  
[8.彻底剖析室内、室外激光SLAM关键算法原理、代码和实战(cartographer+LOAM +LIO-SAM)][8._SLAM_cartographer_LOAM _LIO-SAM]

[9.从零搭建一套结构光3D重建系统\[理论+源码+实践\]][9._3D]

##  ##

**重磅！****3DCVer-****学术论文写作投稿** **交流群****已成立**

扫码添加小助手微信，可**申请加入3D视觉工坊-学术论文写作与投稿 微信交流群，旨在交流顶会、顶刊、SCI、EI等写作与投稿事宜。**

**同时**也可申请加入我们的细分方向交流群，目前主要有**3D视觉**、**CV&深度学习**、**SLAM**、**三维重建**、**点云后处理**、**自动驾驶、多传感器融合、CV入门、三维测量、VR/AR、3D人脸识别、医疗影像、缺陷检测、行人重识别、目标跟踪、视觉产品落地、视觉竞赛、车牌识别、硬件选型、学术交流、求职交流、ORB-SLAM系列源码交流、深度估计**等微信群。

一定要备注：**研究方向+学校/公司+昵称**，例如：”3D视觉 + 上海交大 + 静静“。请按照格式备注，可快速被通过且邀请进群。**原创投稿**也请联系。

![836daacfe8939da62e4b4d28d6757cb5.png][]

▲长按加微信群或投稿

![037b56b28ab5a06e10f65d5718e5dc5b.png][]

▲长按关注公众号

##  ##

**3D视觉从入门到精通知识星球**：针对3D视觉领域的**视频课****程（[三维重建系列][Link 1][三维点云系列][Link 2][结构光系列][Link 3]、[手眼标定][Link 4]、[相机标定][Link 5]、****激光/视觉SLAM****、****自动****驾驶等****）、****知识点汇总、入门进阶学习路线、最新paper分享、疑问解答**五个方面进行深耕，更有各类大厂的算法工程人员进行技术指导。与此同时，星球将联合知名企业发布3D视觉相关算法开发岗位以及项目对接信息，打造成集技术与就业为一体的铁杆粉丝聚集区，近4000星球成员为创造更好的AI世界共同进步，知识星球入口：

##  ##

学习3D视觉核心技术，扫描查看介绍，3天内无条件退款

![12f7be934bb2228b46f4475f201db1e5.png][]

圈里有高质量教程资料、答疑解惑、助你高效解决问题

**觉得有用，麻烦给个赞和在看~**

[84455fecca04fa5f552bfe01e93dcad7.png]: /images/20220828/226b10e3b6824dcf90c677a09411d299.png
[8b0f80fc04b294fed477d0e42ae69498.png]: /images/20220828/355873d4dee9483393d80614332890d1.png
[9180e556788e5c00add0d964f5013b13.png]: /images/20220828/5529e18eb2af4c54a3a7e996dbbb812a.png
[cfcb9257cff0d26d76aae4395983ea6e.png]: https://img-blog.csdnimg.cn/img_convert/cfcb9257cff0d26d76aae4395983ea6e.png
[7ecd93ccb2217502477756b6d06c7f4e.png]: /images/20220828/bc148be48e6441fa93d12bf446e18988.png
[ce0ba4bd352f66ee7eae5a3a42608d1b.png]: /images/20220828/5597973446dd4587b1feea976f9136a2.png
[38d39ef0ba7b0436a6b4ddf8dfd4fe12.png]: /images/20220828/3aaa6142adf646998a1f6835b430d797.png
[d66fc1ddc4475d7b3ec45463015d4a2e.png]: /images/20220828/61d20cef080f4d038b528c83c377f9ad.png
[1.]: https://blog.csdn.net/Yong_Qi2015/article/details/119284035
[2._3D]: http://mp.weixin.qq.com/s?__biz=MzU1MjY4MTA1MQ==&mid=2247580753&idx=1&sn=174f87726a07cc67247c528de0e924ca&chksm=fbfd9765cc8a1e732c08cbaedaa78b35df43c1cb47ef94bad9ec1c942b9be63cf63a64e8c53f&scene=21#wechat_redirect
[3.]: https://blog.csdn.net/Yong_Qi2015/article/details/117828998
[4.]: https://blog.csdn.net/Yong_Qi2015/article/details/119066819
[5._-_-IMU-GPS_SLAM]: https://blog.csdn.net/Yong_Qi2015/article/details/119975746
[6._-_SLAM_VINS-Fusion]: https://blog.csdn.net/Yong_Qi2015/article/details/119047545
[7._LOAM_3D_SLAM_]: https://blog.csdn.net/Yong_Qi2015/article/details/120793104
[8._SLAM_cartographer_LOAM _LIO-SAM]: https://blog.csdn.net/Yong_Qi2015/article/details/120328880
[9._3D]: https://blog.csdn.net/biaoshu2/article/details/106665145
[836daacfe8939da62e4b4d28d6757cb5.png]: /images/20220828/f8e3ebcfc1ef4e7e819312b34f693bbf.png
[037b56b28ab5a06e10f65d5718e5dc5b.png]: /images/20220828/f9f07dd43be94456a0e59d6c862edd3f.png
[Link 1]: https://blog.csdn.net/DDWDDZY/article/details/105608179
[Link 2]: https://blog.csdn.net/pikachu_777/article/details/82992991
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzU1MjY4MTA1MQ==&mid=2247546284&idx=2&sn=d067a98047192a04f21489aca338a5d6&chksm=fbfc1e98cc8b978e5fb6b2afd1a473c89e2861374542421b9972f87a6fdfcd47eb50c443042e&scene=21#wechat_redirect
[Link 4]: http://mp.weixin.qq.com/s?__biz=MzU1MjY4MTA1MQ==&mid=2247554670&idx=2&sn=cf3323178d5d1960476208e6303a8479&chksm=fbfc3d5acc8bb44c184084dcf447a5981d297815d62bef699129338d99a0472c622f96ee71d8&scene=21#wechat_redirect
[Link 5]: http://mp.weixin.qq.com/s?__biz=MzU1MjY4MTA1MQ==&mid=2247486422&idx=1&sn=381ab793959aed0eb6f01019dea522d4&chksm=fbff20e2cc88a9f456b80e23d2482fb319b08e89da071b39597bc51942a6aa7b756a6749856c&scene=21#wechat_redirect
[12f7be934bb2228b46f4475f201db1e5.png]: /images/20220828/80a528bba017454f856c042bab554f60.png