使用PyTorch从头实现Transformer

使用Pytorch从零实现Transformer模型 2017年Google在论文《Attention is All You Need》中提出了Transformer模型,并成功应用到NLP领域。该模型完全基于自注意力机制Attention mechanism实现,弥补了传统的RNN模型的不足。本文笔者将详解使用Pytorch从零开始逐步实现Transformer模型。 阅读详情

前言

  • 本文使用Pytorch从头实现Transformer,原论文Attention is all you need paper,最佳解读博客,学习视频
  • GitHub项目地址Some-Paper-CN。本项目是译者在学习长时间序列预测、CV、NLP和机器学习过程中精读的一些论文,并对其进行了中文翻译。还有部分最佳示例教程。
  • 如果有帮助到大家,请帮忙点亮Star,也是对译者莫大的鼓励,谢谢啦~

SelfAttention

  • 整篇论文中,最核心的部分就是SelfAttention部分,SelfAttention模块架构图如下。
    请添加图片描述

规范化公式:
A t t e n t i o n ( Q , K , V ) = s o f t m a x ( Q K T d k ) V Attention(Q,K,V) = softmax(\frac{QK^T}{\sqrt{d_k}})V Attention(Q,K,V)=softmax(dk​ ​QKT​)V

class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads

        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)

    def forward(self, values, keys, query, mask):
        # batch_size
        N = query.shape[0]
        value_len, keys_len, query_len = values.shape[1], keys.shape[1], query.shape[1]

        values = values.reshape(N, value_len, self.heads, self.head_dim)
        keys = keys.reshape(N, keys_len, self.heads, self.head_dim)
        queries = query.reshape(N, query_len, self.heads, self.head_dim)
        # values, keys, queries shape:(N, seq_len, heads, head_dim)

        values = self.values(values)
        keys = self.keys(keys)
        queries = self.queries(queries)

        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        # queries shape:(N, query_len, heads, heads_dim)
        # keys shape:(N, key_len, heads, heads_dim)
        # energy shape:(N, heads, query_len, key_len)

        if mask is not None:
            energy = energy.masked_fill(mask == 0 ,float("-1e20"))

        attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3)
        # attention shape:(N, heads, seq_len, seq_len)
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(
            N, query_len, self.heads*self.head_dim
        )
        # attention shape:(N, heads, query_len, key_len)
        # values shape:(N, values_len, heads, head_dim)
        # after einsum (N, query_len, heads, head_dim) then flatten lash two dimensions

        out = self.fc_out(out)
        return out
  • 请注意values、 keys和 query的Linear层是不带偏置的!
  • 上述代码中,较难理解的是torch.einsum(),爱因斯坦求和约定,nqhd,nkhd->nhqk可以理解为维度是 ( n , q , h , d ) (n,q,h,d) (n,q,h,d)的张量与 ( n , k , h , d ) (n,k,h,d) (n,k,h,d)的张量沿着维度 d d d相乘,得到维度 ( n , q , d , h ) (n,q,d,h) (n,q,d,h)重新排列后变成 ( n , h , q , k ) (n,h,q,k) (n,h,q,k)。
  • 传入mask矩阵是因为每个句子的长度不一样,为了保证维度相同,在长度不足的句子后面使用padding补齐,而padding是不用计算损失的,所以需要mask告诉模型哪些位置需要计算损失。被mask遮掩的地方,被赋予无限小的值,这样在softmax以后概率就几乎为0了。
  • mask这个地方后面也会写到,如果不理解的话,先有这个概念,后面看完代码就会理解了。

TransformerBlock

  • 实现完SelfAttention,开始实现基本模块TransformerBlock,架构图如下。

请添加图片描述

class TransformerBlock(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(TransformerBlock, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)

        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size)
        )

        self.dropout = nn.Dropout(dropout)

    def forward(self, value, key, query, mask):
        attention = self.attention(value, key, query, mask)
        # attention shape:(N, seq_len, emb_dim)
        x = self.dropout(self.norm1(attention + query))
        forward = self.feed_forward(x)
        out = self.dropout(self.norm2(forward + x))
        return out
  • Feed Forward部分由两层带偏置的Linear层和ReLU激活函数

  • 注意,Norm层是LayerNorm层,不是BatchNorm层。原因主要有:

    • 在进行BatchNorm操作时,同一个batch中的所有样本都会被考虑在内。这意味着一个样本的输出可能会受到同一批次其他样本的影响。然而,我们在处理文本数据时,通常希望每个样本(在此例中,是一个句子或一个句子段落)都是独立的。因此,LayerNorm是一个更好的选择,因为它只对单个样本进行操作。
    • 文本通常不是固定长度的,这就意味着每个batch的大小可能会有所不同。BatchNorm需要固定大小的batch才能正常工作,LayerNorm在这点上更为灵活。
  • forward_expansion是为了扩展embedding的维度,使Feed Forward包含更多参数量。

Encoder

  • 实现完TransformerBlock,就可以实现模型的Encoder部分,模块架构图如下。

请添加图片描述

class Encoder(nn.Module):
    def __init__(
            self,
            src_vocab_size,
            embed_size,
            num_layers,
            heads,
            device,
            forward_expansion,
            dropout,
            max_length
    ):
        super(Encoder, self).__init__()
        self.embed_size = embed_size
        self.device = device
        self.word_embedding = nn.Embedding(src_vocab_size, embed_size)
        self.position_embedding = nn.Embedding(max_length, embed_size)

        self.layers = nn.ModuleList(
            [
                TransformerBlock(
                    embed_size,
                    heads,
                    dropout=dropout,
                    forward_expansion=forward_expansion
                ) for _ in range(num_layers)
            ]
        )
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask):
        N, seq_length = x.shape
        positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
        # positions shape:(N, seq_len)
        out = self.dropout(self.word_embedding(x) + self.position_embedding(positions))
        # out shape:(N, seq_len, emb_dim)
        for layer in self.layers:
            out = layer(out, out, out, mask)
        return out
  • 为了更好的理解positions并没有按照论文中使用sin和cos构造,但这一部分并不困难,后面大家有兴趣可以进行替换。

  • positions是为句子的每个字从0开始编号,假设有2个句子,第一个句子有3个字,第二个句子有4个字,即positions = [[0,1,2],[0,1,2,3]]

  • positions和x进入embedding层后相加,然后进入dropout层

  • 因为TransformerBlock可能有多个串联,所以使用ModuleList包起来

  • 注意残差连接部分的操作。

DecoderBlock

  • 实现完Encoder部分,整个模型就已经完成一半了,接下来实现Decoder基本单元DecoderBlock,模块架构图如下。

请添加图片描述

class DecoderBlock(nn.Module):
    def __init__(self, embed_size, heads, forward_expansion, dropout, device):
        super(DecoderBlock, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm = nn.LayerNorm(embed_size)
        self.transformer_block = TransformerBlock(
            embed_size, heads, dropout, forward_expansion)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, value, key, src_mask, trg_mask):
        attention = self.attention(x, x, x, trg_mask)
        query = self.dropout(self.norm(attention + x))
        out = self.transformer_block(value, key, query, src_mask)
        return out
  • 注意!这里有两个Attention模块,首先输入x要进入Masked Attention得到query,然后与Encoder部分的输出组成新的v,k,q。
  • 第二部分是基本单元transformer_block,可以直接调用。
  • 注意残差连接部分即可。

Decoder

  • 实现完Decoder基本单元DecoderBlock后,就可以正式开始实现Decoder部分了,模块架构图如下。

请添加图片描述

class Decoder(nn.Module):
    def __init__(
            self,
            trg_vocab_size,
            embed_size,
            num_layers,
            heads,
            forward_expansion,
            dropout,
            device,
            max_length,
    ):
        super(Decoder, self).__init__()
        self.device = device
        self.word_embedding = nn.Embedding(trg_vocab_size, embed_size)
        self.position_embedding = nn.Embedding(max_length, embed_size)

        self.layers = nn.ModuleList(
            [DecoderBlock(embed_size, heads, forward_expansion, dropout, device)
            for _ in range(num_layers)]
        )

        self.fc_out = nn.Linear(embed_size, trg_vocab_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, enc_out, src_mask, trg_mask):
        N, seq_length = x.shape
        positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
        x = self.dropout(self.word_embedding(x) + self.position_embedding(positions))

        for layer in self.layers:
            x = layer(x, enc_out, enc_out, src_mask, trg_mask)

        out = self.fc_out(x)
        return out
  • Decoder部分的embedding部分和Encoder部分差不多,word_embedding和position_embedding相加进入dropout层。
  • 基本单元DecoderBlock会重复多次,用ModuleList包裹。
  • enc_out是Encoder部分的输出,变成了value和key。

Transformer

  • 在实现完Encoder和Decoder后,就可以实现整个Transformer结构了,架构图如下。
    请添加图片描述
class Transformer(nn.Module):
    def __init__(
            self,
            src_vocab_size,
            trg_vocab_size,
            src_pad_idx,
            trg_pad_idx,
            embed_size=256,
            num_layers=6,
            forward_expansion=4,
            heads=8,
            dropout=0,
            device='cpu',
            max_length=64
    ):
        super(Transformer, self).__init__()

        self.encoder = Encoder(
            src_vocab_size,
            embed_size,
            num_layers,
            heads,
            device,
            forward_expansion,
            dropout,
            max_length
        )

        self.decoder = Decoder(
            trg_vocab_size,
            embed_size,
            num_layers,
            heads,
            forward_expansion,
            dropout,
            device,
            max_length
        )

        self.src_pad_idx = src_pad_idx
        self.trg_pad_idx = trg_pad_idx
        self.device = device

    def mask_src_mask(self, src):
        src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)
        # src_mask shape:(N, 1, 1, src_len)
        return src_mask.to(self.device)

    def mask_trg_mask(self, trg):
        N, trg_len = trg.shape
        trg_mask = torch.tril(torch.ones((trg_len, trg_len))).expand(
            N, 1, trg_len, trg_len
        )
        # trg_mask shape:(N, 1, 1, trg_len)
        return trg_mask.to(self.device)

    def forward(self, src, trg):
        src_mask = self.mask_src_mask(src)
        trg_mask = self.mask_trg_mask(trg)
        enc_src = self.encoder(src, src_mask)
        # enc_src shape:(N, seq_len, emb_dim)
        out = self.decoder(trg, enc_src, src_mask, trg_mask)
        return out
  • 需要注意的是输入的mask构造方法mask_src_mask,和输出的mask构造方法mask_trg_mask。mask_src_mask是对输入的padding部分进行mask。mask_trg_mask根据输出构建下三角矩阵想象一下,当模型预测第一个字的时候,后面的所有内容都是不可见的,当模型预测第二个字的时候,仅第一个字可见,后面的内容都不可见…

检验

  • 构建完成后,使用一个简单的小例子检验一下模型是否可以正常运行。
if __name__ == "__main__":
    device = 'cpu'
    # x shape:(N, seq_len)
    x = torch.tensor([[1, 5, 6, 4, 3, 9, 5, 2, 0],
                      [1, 8, 7, 3, 4, 5, 6, 7, 2]]).to(device)
    trg = torch.tensor([[1, 7, 4, 3, 5, 9, 2, 0],
                        [1, 5, 6, 2, 4, 7, 6, 2]]).to(device)

    src_pad_idx = 0
    trg_pad_idx = 0
    src_vocab_size = 10
    trg_vocab_size = 10

    model = Transformer(src_vocab_size, trg_vocab_size, src_pad_idx, trg_pad_idx).to(device)
    out = model(x, trg[:, :-1])
    print(out.shape)
  • 输出:(2, 7, 10),完整代码放在GitHub项目Some-Paper-CN中。
PyTorch中Transformer 模型介绍 nhead=8,d_model:表示输入序列的特征维度。通常是嵌入向量的维度。nhead:多头注意力机制中的头数,通常是d_model可以被整除的值。:编码器层的数量。:解码器层的数量。:前馈神经网络中的隐藏层维度。dropout:dropout 概率,用于防止过拟合。activation:前馈层中的激活函数,默认是relu。PyTorch 中的模型包含了完整的编码器-解码器架构。模型基于多头自注意力机制和前馈神经网络,结合位置编码来处理序列任务。通过自定义掩码, 阅读详情

相关推荐

Transformer的Pytorch实现【1】

使用Pytorch手把手搭建一个Transformer网络结构并完成一个小型翻译任务。首先,对Transformer结构进行拆解,Transformer由编码器和解码器(Encoder-Decoder)组成,编码器由Multi-Head Attention + Feed-Forward Network组成的结构堆叠而成,解码器由Multi-Head Attention + Multi-Head Attention + Feed-Forward Network组成的结构堆叠而成。

nature_XD的专栏 1358

Pytorch Transformer

环境使用 Kaggle 里免费建立的 Notebook教程使用李沐老师的 动手学深度学习 网站和 视频讲解小技巧:当遇到函数看不懂的时候可以按 查看函数详解。数学语言表达:bbb:表示一个 batch 有多少句子,nnn:表示句子有多少个单词,ddd 表示每个单词向量的维度训练时:Decoder 第一个带掩码的多头注意力的 K,V,来自本身的 Q,第二个多头注意力的 K,V 来自 Encoder 预测时:K,V 来自 Decoder 的上一时刻的输出作为 K,V 2.1 多头注意力 使多个头并行(为了省

负负得正的博客 7123

PyTorch实现Transformer模型

所有数学公式都要用$...$或者$$...$$,比如自注意力的计算公式$Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$,这里要检查是否正确使用括号和符号。接下来,用户需要的是手把手的代码解读,所以必须详细,每一步都不能遗漏。还要考虑用户可能遇到的常见问题,比如维度不匹配,如何处理mask,训练时的损失函数选择,优化器的设置等。需要确保代码示例正确,比如在实现多头注意力时,是否正确地分割了张量,是否计算了注意力分数,并应用了mask。

liuhaoran___的博客 1380

pytorch实现transformer

pytorch实现transfomer,详细。小白入门向。

m0_61688615的博客 4555

Pytorch中 nn.Transformer的使用详解与Transformer的黑盒讲解

1. Transformer的训练过程讲解 2. Transformer的推理过程讲解 3. Transformer的入参和出参讲解 4. nn.Transformer的各个参数讲解 5. nn.Transformer的mask机制详解 6. 实战:使用nn.Transformer训练一个copy任务。

iioSnail的博客 9万+

使用Pytorch从零实现Vision Transformer

使用Pytorch从零实现Vision Transformer

穿着帆布鞋也能走猫步 664

Transformer的PyTorch实现

本文由罗周杨原创,转载请注明作者和出处。未经授权,不得用于商业用途 Google 2017年的论文 Attention is all you need 阐释了什么叫做大道至简!该论文提出了Transformer模型,完全基于Attention mechanism,抛弃了传统的RNN和CNN。 我们根据论文的结构图,一步一步使用 PyTorch 实现这个Transformer模型。 Transf...

stupid_3的博客 4万+

Calibre PEX提取HSPICE网表时如何避免‘net 0‘错误?实测解决方案分享

本文详细解析了Calibre PEX提取HSPICE网表时出现的'net 0'错误,提供了从规则文件修改到网表后处理的四步解决方案。通过实战案例和进阶调试技巧,帮助工程师有效避免节点映射错误,确保后仿真精度。特别针对SPICE netlist生成机制提出了优化建议。

weixin_29279153的博客 390

Transformer 模型的 PyTorch 实现

Google 2017年的论文阐释了什么叫做大道至简!该论文提出了模型,完全基于,抛弃了传统的和。我们根据论文的结构图,一步一步使用实现这个模型。

weixin_42907150的博客 1157

西门子 标准程序解读---> 机器手抓取和涂胶控制程序

摘要 该程序实现机械手在OP70/OP90工位的自动化控制,核心功能包括: 流程控制:分段(Seg1-Seg11)管理抓件、涂胶、放件等动作,结合DB1050/DB1250数据块监控工位状态及变位机位置反馈。 安全机制:配置干涉区(FC124)、实时检测安全光/急停信号,防止碰撞;服务程序(FB191)支持维修位触发与安全隔离。 参数配置:通过DB块关联机器人速度、节拍(FB27)、车型编码(如空过=2)及手自动模式(DB70.DBX21.2)。 应用场景:适用于汽车焊接/装配线

工控智联驿站 1239

告别混乱代码!在Arduino IDE中管理多文件项目的5个必备技巧

本文分享了在Arduino IDE中管理多文件项目的5个必备技巧,帮助开发者告别混乱代码。通过代码分割和模块化设计,提升编译效率、降低内存占用,并实现功能解耦。重点介绍了头文件设计、CPP文件实现、调试技巧和工业级目录结构,让你的Arduino项目像乐高积木一样清晰易维护。

fun88的博客 364

Transformer的Pytorch实现

使用Pytorch编程实现Transformer并进行训练和预测

ing100的博客 3170

UR10e+D435+ag95夹爪 gazebo 仿真记录(一)

学习仿真环境gazebo下利用UR10e机械臂搭建模拟平台,此博客用于记录搭建过程!!主要参考光头明明、总有一天全城的人都要高看我们和bug404_三位博主。最终自己功能包的主要参考了bug404_的ur_platform,感觉这个结构比较合理。运行环境:Ubuntu18.04+Ros-melodic+Gazebo9。

Forbiven的博客 6334

Pytorch实现Transformer

首先实现这个部分是因为不论解码器还是编码器都需要这一部分。首先我们假设归一化(LayerNorm)已经做好了。因为我们不确定是Encoder还是Decoder,所以用sublayer传入来作为上一层。接下来实现LayerNorm这一串代码很简单,就是公式的实现而已,注意要把a_2和b_2作为可以学习的变量。

2301_81989837的博客 1321

uniapp [全端兼容] - 实现人脸识别对比+人脸相似度,从相册选择或拍照上传两张图片进行人脸对比得到人脸相似度及判断是否是同一个人,人脸活体检测及对比(免费纯前端方案+调用第三方API接口方案)

uniApp人脸对比 人脸对比识别 人脸对比相似度,uniapp实现获取手机摄像头权限,调用相机拍照实现人脸识别相似度对比,uniapp实现人脸识别对比,计算两张人脸的相似度,从而判断是否同一个人,并给出相似度评分。uniapp H5网页如何实现人脸相似度比对,uniapp纯前端怎么对比两张图片的相似度,计算两幅图像的相似度,图像相似度对比方法,UNI-APP人脸相似度对比,快速识别两张照片的相似程度(用百分比)图片相似度对比在线测试,图片相似度对比,uniapp微信小程序人脸相似度对比分析,uniapp

🏆 前端领域优质创作者 5028

YOLOv8极速瘦身实战:LAMP剪枝让模型又快又准

一个庞大的模型虽然强大,但在实际部署,尤其是资源受限的边缘设备(如无人机、移动电话、嵌入式系统)上,却面临着严峻的挑战:高昂的内存占用、巨大的计算量以及随之而来的高延迟和高能耗。本教程从LAMP剪枝的深刻理论出发,详细解释了它如何通过最小化最坏情况下的L2失真,并借助巧妙的数学简化,最终推导出一种高效、无超参数、层自适应的剪枝策略。它如同为臃肿的模型进行一次精准的“瘦身手术”,通过移除网络中冗余或不重要的权重、神经元甚至整个结构,来显著降低模型的参数量和计算量(FLOPs),从而实现推理加速和资源节约。

FJN110的博客 259

Transformer模型的Pytorch实现

Transformer模型的Pytorch实现解读。

牧羊女 2682

从服务器到桌面超算:当3999美元的NVIDIA DGX Spark装上Ubuntu,普通开发者能玩出什么花?

DGX Spark的出现,标志着AI算力正在经历从"数据中心集中供给"到"个人桌面按需拥有"的范式转移。它让开发者可以在本地完成从数据预处理、模型微调到推理验证的全流程,只有在需要大规模训练时才调用云端资源。迭代速度:从按小时计费的云端调试,变成随时随地的本地实验数据主权:敏感信息永不离开本地成本可控:一次投入,长期使用,不受API调用次数限制AI算力民主化的时代,真的来了。你的下一台超级计算机,不必在云端。它就在你的桌面上,安静地等待着你的下一个创意。附录:实用资源。

QQ_778132974的博客 630

Transformer的PyTorch实现(超详细)

文本主要介绍一下如何使用 PyTorch 复现 Transformer,实现简单的机器翻译任务。请先花上 15 分钟阅读我的这篇文章 Transformer详解,再来看文本,方能达到醍醐灌顶,事半功倍的效果 数据预处理 这里我并没有用什么大型的数据集,而是手动输入了两对德语→英语的句子,还有每个字的索引也是我手动硬编码上去的,主要是为了降低代码阅读难度,我希望读者能更关注模型实现的部分 # S: Symbol that shows starting of decoding input # E: Symbol

mathor的博客 6万+

uniapp(全端兼容) - 详细实现唤起手机摄像头对商品进行拍照识别功能,在uniapp全平台小程序/h5网页/安卓苹果app做商品扫描识别效果,仿京东淘宝扫描识别功能效果(提供示例代码,开箱即用)

uniapp,微信小程序,移动端h5网页,手机H5网站,安卓苹果app软件,拍照识图功能,vue前端实现商品拍照识别,uniapp详细实现调用手机摄像头拍照识别商品,uniapp拍照识图插件组件实例代码,uni-app实现京东淘宝拼多多点击拍照识图功能,uniapp怎么做电商app的拍照识别图片上的商品功能,uniapp仿淘宝拍照识图,uniapp仿京东拍照识图,调用后置摄像头拍照扫描图片上的物品,手机摄像头拍照并拖动一个区域进行识别,前端怎么做识别图片的交互效果,uniapp(全端兼容) - 详细实现唤起

✅ 精选推荐文章 4411

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Transformer的pytorch实现

Transformer架构 Transformer模型由encoder和decoder两部分组成,decoder输出的结果,经过一个线性层,然后计算softmax。 d_model = 512 # Embedding Size d_ff = 2048 # FeedForward dimension d_k = d_v = 64 # dimension of K(=Q), V n_layers...

lbw522的博客 2500

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Transformer详解及Pytorch实现

Attention Is All You Need——“目前主要的序列转导模型基于编码器-解码器中配置的复杂循环神经网络或卷积神经网络。但通过注意力机制连接编码器和解码器可以大幅改善模型性能。我们提出了一种新的简单网络架构,它叫 Transformer,它完全基于注意力机制,完全省去了循环和卷积。”(Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., … & Polosukhin, I. (2017).

weixin_45414514的博客 1246

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

PyTorch从零开始实现Transformer

使用Pytorch实现Attention is all you need

阿正的梦工坊 4万+
上一篇: Chronos:学习时间序列的大语言模型(论文解读)
下一篇: Chronos:学习时间序列的大语言模型(代码解析)
羽星_s
博客等级 码龄12年 1554粉丝 180原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

羽星_s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址