Transformer 一起动手编码学原理

手撸Transformer Transformer 关于Transformer的理论学习:Transformer详解 本文的源代码地址:Transformer代码地址 Colab实验地址:Colab 0. 架构图 1. 数据准备 import torch import numpy as np import torch.nn as nn import torch.optim as optim import torch.utils.data as Data # Encoder_input Decode 阅读详情

‍图片

导读

学习Transformer,快来跟着作者动手写一个。

作为工程同学,学习Transformer中,不动手写一个,总感觉理解不扎实。纸上得来终觉浅,绝知此事要躬行,抽空多debug几遍!

注:不涉及算法解释,仅是从工程代码实现去加强理解。

一、准备知识

以预测二手房价格的模型,先来理解机器学习中的核心概念。

1.1、手撸版

1、准备训练数据
# 样本数
num_examples = 1000
# 特征数:房屋大小、新旧
num_input = 2
# 线性回归模型,2个W参数值:2,-3.4
true_w = [2, -3.4]
# 1个b参数值
true_b = 4.2

# 随机生成样本:特征值
features = torch.randn(num_examples, num_input, dtype=torch.float32)
# print(features[0]) 

# 随机生成样本:y值
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
# print(labels[0])
# 随机生成一批数据,给y值再随机化下
_temp = torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float32)
labels = labels + _temp
# print(labels[0])
2、定义模型
# 模型参数 w:w1、w2,b:b,设了初始值
w = torch.tensor(np.random.normal(0, 0.01, (num_input, 1)), dtype=torch.float32)
b = torch.zeros(1, dtype=torch.float32)
# 设置要求计算梯度w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

# 线性回归模型:定义 torch.mm(X, w) + b,mm是矩阵乘法(m:multiply缩写)
def linreg(X, w, b):
    return torch.mm(X, w) + b

# 定义损失函数:y_pred=预测值、y=真实值,最简单的 平方误差
def squared_loss(y_pred, y):
    return (y_pred - y.view(y_pred.size())) ** 2 / 2

# 定义梯度下降算法:sgd
# params是参数(data 是参数值、grad 是梯度值),lr是学习率,batch是数量
# 为什么要除batch?因为这个梯度值,是在batch个数据上累加算的
def sgd(params, lr, batch):
    for param in params:    
        # 注意这里更改param时用的param.data        
        param.data -= lr * param.grad / batch
3、训练模型

在这里插入图片描述

辅助函数:by batch & 随机,读取样本数据

# 定义随机读取数据 by batch
def data_iter(batch, features, labels):
    nums = len(features)    
    # 生成 0-1000 数组    
    indices = list(range(nums))    
    # 打乱下标的读取顺序    
    random.shuffle(indices)    
    # 生成:start=0,stop=1000,step=batch=10    
    for i in range(0, nums, batch):    
        # 截取一段下标,size=batch        
        t_ind = indices[i: min(i + batch, num_examples)]  # 最后一次可能不足一个batch        
        # 转换为torch要求格式:tensor        
        j = torch.LongTensor(t_ind)        
        # 按照下标从向量中找        
        # yield:生成一个迭代器返回,有点类似闭包,每调用一次返回一次,且下次调用时会从上次暂停的位置继续        
        yield features.index_select(0, j), labels.index_select(0, j)

1.2、pytorch版

1、准备训练数据

同上

2、定义模型

在这里插入图片描述

3、训练模型

在这里插入图片描述

batch 读取数据

在这里插入图片描述

在用torch框架,进一步要理解:

a、nn.Module 和 forward() 函数:表示神经网络中的一个层,覆写 init 和 forward 方法(提问:实现2层网络怎么做?)

b、debug 观察下数据变化,和 手撸版 对比着去理解

二、手写Transformer

图片

上面这是一个"逻辑"示意图。印象中,第1次看时,以为 “inputs & outputs” 是并行计算、但上面又有依赖,很糊涂。

这不是一个技术架构图,上图有很多概念,attention、multi-head等。先尝试转换为面向对象的类图,如下:

图片

2.1、例子:翻译

# 定义词典
source_vocab = {'E': 0, '我': 1, '吃': 2, '肉': 3}
target_vocab = {'E': 0, 'I': 1, 'eat': 2, 'meat': 3, 'S': 4}

# 样本数据
encoder_input = torch.LongTensor([[1, 2, 3, 0]]).to(device)  # 我 吃 肉 E, E代表结束词
decoder_input = torch.LongTensor([[4, 1, 2, 3]]).to(device)  # S I eat meat, S代表开始词, 并右移一位,用于并行训练
target = torch.LongTensor([[1, 2, 3, 0]]).to(device)  # I eat meat E, 翻译目标

2.2、定义模型

按照上面类图,我们来一点点实现

1、Attention

在这里插入图片描述

图片

图片

2、MultiHeadAttention

通用变量定义

d_model = 6  # embedding size
# d_model = 3  # embedding size
d_ff = 12  # feedforward nerual network  dimension
d_k = d_v = 3  # dimension of k(same as q) and v
n_heads = 2  # number of heads in multihead attention# n_heads = 1  
# number of heads in multihead attention【注:为debug更简单,可以先改为1个head】
p_drop = 0.1  # propability of dropout
device = "cpu"

注1:按惯性会想,会有多个head、串行循环计算,不是,多个head是一个张量输入

注2:FF 全连接、残差连接、归一化,35、38 行业代码,pytorch框架带来的简化

class MultiHeadAttention(nn.Module):    
    def __init__(self):     
       super(MultiHeadAttention, self).__init__()        
       self.n_heads = n_heads        
       self.W_Q = nn.Linear(d_model, d_k * n_heads, bias=False)        
       self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)        
       self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)        
       self.fc = nn.Linear(d_v * n_heads, d_model, bias=False)  # ff 全连接        
       self.layer_norm = nn.LayerNorm(d_model)  # normal 归一化    
       
    def forward(self, input_Q, input_K, input_V, attn_mask):        
    # input_Q:1*4*6,每批1句 * 每句4个词 * 每词6长度编码        
    # residual 先临时保存下:原始值,后面做残差连接加法        
    residual, batch = input_Q, input_Q.size(0)        
    
    # 乘上 W 矩阵。注:W 就是要训练的参数        
    # 注意:维度从2维变成3维,增加 head 维度,也是一次性并行计算        
    Q = self.W_Q(input_Q)  # 乘以 W(6*6) 变为 1*4*6        
    Q = Q.view(batch, -1, n_heads, d_k).transpose(1, 2)  # 切开为2个Head 变为 1*2*4*3 1批 2个Head 4词 3编码        
    K = self.W_K(input_K).view(batch, -1, n_heads, d_k).transpose(1, 2)        
    V = self.W_V(input_V).view(batch, -1, n_heads, d_v).transpose(1, 2)    
        
    # 1*2*4*4,2个Head的4*4,最后一列为true        
    # 因为最后一列是 E 结束符        
    attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)   
         
    # 返回1*2*4*3,2个头,4*3为带上关注关系的4词        
    prob = ScaledDotProductAttention()(Q, K, V, attn_mask)   
         
    # 把2头重新拼接起来,变为 1*4*6        
    prob = prob.transpose(1, 2).contiguous()        
    prob = prob.view(batch, -1, n_heads * d_v).contiguous()     
       
    # 全连接层:对多头注意力的输出进行线性变换,从而更好地提取信息        
    output = self.fc(prob)        
    
    # 残差连接 & 归一化        
    res = self.layer_norm(residual + output) # return 1*4*6        
    return res
3、Encoder

在 attention 概念中,有很关键的 “遮盖” 概念,先不细究,你debug一遍会更理解

def get_attn_pad_mask(seq_q, seq_k):  # 本质是结尾E做注意力遮盖,返回 1*4*4,最后一列为True    
    batch, len_q = seq_q.size()  # 1, 4    
    batch, len_k = seq_k.size()  # 1, 4    
    pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)  # 为0则为true,变为f,f,f,true,意思是把0这个结尾标志为true    
    return pad_attn_mask.expand(batch, len_q, len_k)  # 扩展为1*4*4,最后一列为true,表示抹掉结尾对应的注意力
    
def get_attn_subsequent_mask(seq):  # decoder的自我顺序注意力遮盖,右上三角形区为true的遮盖
    attn_shape = [seq.size(0), seq.size(1), seq.size(1)]    
    subsequent_mask = np.triu(np.ones(attn_shape), k=1)    
    subsequent_mask = torch.from_numpy(subsequent_mask)    
    return subsequent_mask

在这里插入图片描述

4、Decoder

class Decoder(nn.Module):

    def __init__(self):    
        super(Decoder, self).__init__()        
        self.target_embedding = nn.Embedding(len(target_vocab), d_model)        
        self.attention = MultiHeadAttention()    
        
    # 三入参形状分别为 1*4, 1*4, 1*4*6,前两者未被embedding,注意后面这个是 encoder_output    
    def forward(self, decoder_input, encoder_input, encoder_output):    
        # 编码为1*4*6        
        decoder_embedded = self.target_embedding(decoder_input)    
            
        # 1*4*4 全为false,表示没有结尾词        
        decoder_self_attn_mask = get_attn_pad_mask(decoder_input, decoder_input)        
        # 1*4*4 右上三角区为1,其余为0        
        decoder_subsequent_mask = get_attn_subsequent_mask(decoder_input)        
        # 1*4*4 右上三角区为true,其余为false        
        decoder_self_mask = torch.gt(decoder_self_attn_mask + decoder_subsequent_mask, 0)        
        
        # 1*4*6 带上注意力的4词矩阵【注:decoder里面,第1个attention】        
        decoder_output = self.attention(decoder_embedded, decoder_embedded, decoder_embedded, decoder_self_mask)        
        
        # 1*4*4 最后一列为true,表示E结尾词        
        decoder_encoder_attn_mask = get_attn_pad_mask(decoder_input, encoder_input)        
        # 输入均为 1*4*6,Q表示"S I eat meat"、K表示"我吃肉E"、V表示 "我吃肉E"        
        #【注:decoder里面,第2个attention】        
        decoder_output = self.attention(decoder_output, encoder_output, encoder_output, decoder_encoder_attn_mask)        
        return decoder_output
5、Transformer
class Transformer(nn.Module):
    def __init__(self):    
        super(Transformer, self).__init__()        
        self.encoder = Encoder()        
        self.decoder = Decoder()        
        self.fc = nn.Linear(d_model, len(target_vocab), bias=False)    
        
    def forward(self, encoder_input, decoder_input):    
        # 入 1*4,出 1*4*6,作用:"我吃肉E",并带上三词间的关注力信息        
        encoder_output = self.encoder(encoder_input)        
        # 入 1*4, 1*4, 1*4*6=encoder_output        
        decoder_output = self.decoder(decoder_input, encoder_input, encoder_output)        # 预测出4个词,每个词对应到词典中5个词的概率,如下        
        # tensor([[[ 0.0755, -0.2646,  0.1279, -0.3735, -0.2351],[-1.2789,  0.6237, -0.6452,  1.1632,  0.6479]]]        
        decoder_logits = self.fc(decoder_output)        
        res = decoder_logits.view(-1, decoder_logits.size(-1))        
        return res

2.3、训练模型

在这里插入图片描述

2.4、使用模型

# 预测目标是5个单词
target_len = len(target_vocab)  
# 1*4*6 输入"我吃肉E",先算【自注意力】
encoder_output = model.encoder(encoder_input)  
# 1*5 全是0,表示EEEEE
decoder_input = torch.zeros(1, target_len).type_as(encoder_input.data)  
# 表示S开始字符
next_symbol = 4  

# 5个单词逐个预测【注意:是一个个追加词,不断往后预测的】
for i in range(target_len):
    # 譬如i=0第一轮,decoder输入为SEEEE,第二轮为S I EEE,把预测 I 给拼上去,继续循环    
    decoder_input[0][i] = next_symbol      
    # decoder 输出    
    decoder_output = model.decoder(decoder_input, encoder_input, encoder_output)    
    # 负责将解码器的输出映射到目标词汇表,每个元素表示对应目标词汇的分数    
    # 取出最大的五个词的下标,譬如[1, 3, 3, 3, 3] 表示 i,meat,meat,meat,meat    
    logits = model.fc(decoder_output).squeeze(0)    
    prob = logits.max(dim=1, keepdim=False)[1]    
    next_symbol = prob.data[i].item()  # 只取当前i    
    
    for k, v in target_vocab.items():    
        if v == next_symbol:      
            print('第', i, '轮:', k)            
            break    
    if next_symbol == 0:  # 遇到结尾了,那就完成翻译    
        break

如何学习大模型 AI ?

由于新岗位的生产效率,要优于被取代岗位的生产效率,所以实际上整个社会的生产效率是提升的。

但是具体到个人,只能说是:

“最先掌握AI的人,将会比较晚掌握AI的人有竞争优势”。

这句话,放在计算机、互联网、移动互联网的开局时期,都是一样的道理。

我在一线互联网企业工作十余年里,指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家,也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑,所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限,很多互联网行业朋友无法获得正确的资料得到学习提升,故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

在这里插入图片描述

第一阶段(10天):初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识,对大模型 AI 的理解超过 95% 的人,可以在相关讨论时发表高级、不跟风、又接地气的见解,别人只会和 AI 聊天,而你能调教 AI,并能用代码将大模型和业务衔接。

  • 大模型 AI 能干什么?
  • 大模型是怎样获得「智能」的?
  • 用好 AI 的核心心法
  • 大模型应用业务架构
  • 大模型应用技术架构
  • 代码示例:向 GPT-3.5 灌入新知识
  • 提示工程的意义和核心思想
  • Prompt 典型构成
  • 指令调优方法论
  • 思维链和思维树
  • Prompt 攻击和防范
  • …

第二阶段(30天):高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习,学会构造私有知识库,扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架,抓住最新的技术进展,适合 Python 和 JavaScript 程序员。

  • 为什么要做 RAG
  • 搭建一个简单的 ChatPDF
  • 检索的基础概念
  • 什么是向量表示(Embeddings)
  • 向量数据库与向量检索
  • 基于向量检索的 RAG
  • 搭建 RAG 系统的扩展知识
  • 混合检索与 RAG-Fusion 简介
  • 向量模型本地部署
  • …

第三阶段(30天):模型训练

恭喜你,如果学到这里,你基本可以找到一份大模型 AI相关的工作,自己也能训练 GPT 了!通过微调,训练自己的垂直大模型,能独立训练开源多模态大模型,掌握更多技术方案。

到此为止,大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗?

  • 为什么要做 RAG
  • 什么是模型
  • 什么是模型训练
  • 求解器 & 损失函数简介
  • 小实验2:手写一个简单的神经网络并训练它
  • 什么是训练/预训练/微调/轻量化微调
  • Transformer结构简介
  • 轻量化微调
  • 实验数据集的构建
  • …

第四阶段(20天):商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知,可以在云端和本地等多种环境下部署大模型,找到适合自己的项目/创业方向,做一名被 AI 武装的产品经理。

  • 硬件选型
  • 带你了解全球大模型
  • 使用国产大模型服务
  • 搭建 OpenAI 代理
  • 热身:基于阿里云 PAI 部署 Stable Diffusion
  • 在本地计算机运行大模型
  • 大模型的私有化部署
  • 基于 vLLM 部署大模型
  • 案例:如何优雅地在阿里云私有部署开源大模型
  • 部署一套开源 LLM 项目
  • 内容安全
  • 互联网信息服务算法备案
  • …

学习是一个过程,只要学习就会有挑战。天道酬勤,你越努力,就会成为越优秀的自己。

如果你能在15天内完成所有的任务,那你堪称天才。然而,如果你能完成 60-70% 的内容,你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】
机器翻译实战(英译汉)Transformer代码学习详解 任务目标 基于Transformer实现英语翻译汉语。如有疏忽请多指教 数据 Hi. 嗨。 Hi. 你好。 Run. 你用跑的。 Wait! 等等! Hello! 你好。 I try. 让我来。 I won! 我赢了。 Oh no! 不会吧。 Cheers! 乾杯! Got it? 你懂了吗? He ran. 他跑了。 Hop in. 跳进来。 I lost. 我迷失了。 I quit. 我退出。 I'm OK. 我沒事。 Listen. 听着。 No way! 不可能! No way! 没门! Reall 阅读详情

相关推荐

Transformer机器翻译模型(代码实现案例)

¶# 定义特殊字符及其对应的索引值# 确保标记按其索引的顺序正确插入到词汇表中# 训练数据集的迭代器,# 数据集是用英文描述图像的英文语句, 然后人工将其翻译为德文的语句,有两个文件, 一个是train.de 一个是train.en文件,# 然后将其构建为(德文, 英文)的形式# 创建torchtext的vocab对象, 即词汇表。

m0_60657960的博客 4507

基于 pytorch 的手写 transformer + tokenizer

纯手工分模块实现一个 transformer 模型

大家好~我是SP_FA~ 3113

AUTOSAR E2E通信保护协议:从原理到实战的完整解析

在车载通信中,数据完整性是功能安全的核心要求。E2E通信保护协议通过CRC校验、滚动计数器与Data ID等机制,检测数据损坏、丢失、重复、延迟等通信故障,确保安全相关信号在传输过程中的可信性。该机制在AUTOSAR架构中横跨BSW与RTE层,支持多种Profile适配不同总线场景。从CAN到以太网,E2E保护为域控制器与整车通信提供了端到端的安全保障,是功能安全体系中不可或缺的一环。

weixin_34090562的博客 440

【模型学习之路】手写+分析Transformer

attention is all you need!

wwl412095144的博客 2477

Setup&Hold互卡问题和Useful Skew的影响

setup和hold互卡问题分析

godping的博客 5100

CANoe基础讲解01:从零开始使用CANoe轻松搭建你的第一个CAN网络

本文是一篇CANoe软件入门实操指南,逐步演示了如何从零创建并运行一个CAN FD仿真工程。内容包括:启动软件、配置硬件通道与网络、加载DBC数据库、使用CAPL编写仿真节点发送CAN报文,最终启动测量并在Trace窗口中查看通信结果。通过七个清晰步骤,帮助初学者快速掌握CANoe基本操作,完成首个可运行的仿真网络搭建

车载网络小D的博客 1575

多智能体强化学习:编码校正双深度Q网络原理与工程实践

强化学习是机器学习的重要分支,通过智能体与环境的交互学习最优策略。在多智能体系统中,环境非平稳性和信用分配是核心挑战。编码校正双深度Q网络(Encoded Corrective Double DQN)通过编码器建模智能体间关系,利用校正机制稳定Q值学习,在双深度Q网络框架下实现高效协同。该技术结合了Transformer等现代编码架构,能有效处理多机器人、智能交通等复杂场景中的协作与竞争问题。其核心价值在于提升训练稳定性与策略表达能力,为工业自动化和集群控制等工程实践提供了系统化解决方案。

weixin_30924087的博客 332

绝对旋转编码器学习笔记(基本原理,与PC通信等,不定期更新中)

前言 最近开始学习编码器相关内容,目的在于搞清楚编码器的原理,与上位机的联系等问题。笔记资料来源为网络,整理的同时也会有一些总结和感悟。由于研究方向需求,主要研究数字旋转编码器。 1.编码器的定义 编码器(encoder)是将信号(如比特流)或数据进行编制、转换为可用以通讯、传输和存储的信号形式的设备。——摘自《百度百科》 通常来说,编码器可以将角度位移、直线位移、转速等物理量转换为电信号。这里的电信号根据不同原理的编码器输出脉冲、二进制数码等不同的类型,下面会提到。 2.编码器的分类 编.

黑化咸鱼的博客 1万+

Transformer学习笔记(下),手写实现Transformer

x语言的所有词汇就7个词,说任何话都是用这7个词采样概率是模仿自然语言中有些词经常被说到(热门词),有些词很难被说到(生僻词)以概率在词汇表中进行采样,采一个随机长度transformer的作用是将x翻译成y,也就说y和x之间要有一定的关联性,y可以根据x推导出来的x和y的关联规则:y当中的每一词都是x当中的词进行逆序之后的结果,小写字母变大写字母,y当中的数字是用9减去x当中的数字得到的虚线的箭头表明y当中的第一位取决于x的最后一位(9-x),即y当中第一位和第二位是相同的。

qq_35975367的博客 2780

别再为倍福EL6021/EL6022的RS485接线头疼了!手把手教你硬件跳线与软件配置(附Modbus RTU主站例程)

本文详细解析了倍福EL6021/EL6022模块的RS485硬件跳线与软件配置方法,包括Modbus RTU主站编程实战。从端子定义、跳线操作到TwinCAT 3环境设置,提供完整的通信例程和故障排查技巧,帮助工程师快速解决工业现场通信问题。

weixin_30634661的博客 593

PCB制造工艺参数到AD规则设置

本文提供了PCB设计与制造的落地指南,强调需先了解PCB厂的工艺参数,再在Altium Designer中设置相应规则。核心步骤包括:获取PCB厂的关键工艺参数(线宽/线距、过孔尺寸等),在AD中设置电气规则、布线规则、阻焊规则等,并进行DRC检查。文章还给出了常见问题避坑建议和快速落地模板,帮助设计师确保设计符合生产要求,避免因工艺不匹配导致的报废或成本增加。

qq_37999850的博客 294

最简单、通俗地理解GPT的Transformer架构:从零开始编写 Transformer

模型参数 w:w1、w2,b:b,设了初始值# 设置要求计算梯度# 线性回归模型:定义 torch.mm(X, w) + b,mm是矩阵乘法(m:multiply缩写)# 定义损失函数:y_pred=预测值、y=真实值,最简单的 平方误差# 定义梯度下降算法:sgd# params是参数(data 是参数值、grad 是梯度值),lr是学习率,batch是数量# 为什么要除batch?因为这个梯度值,是在batch个数据上累加算的# 注意这里更改param时用的param.data。

2301_78285120的博客 621

S32K144 UDSdoCAN 升级刷写实现笔记

本篇旨在描述如何开发“车规级”的软件升级程序,通过在S32K144平台上实现基于UDSdoCAN的刷写升级功能,带你一步步建立安全升级的“工程思维”,在这里既能收获经验还能获得工程源码、测试脚本,助你起飞,避坑提速!

汽车电子软件领域知识分享 813

手写简易 Transformer(附大白话对比)

自注意力机制:让模型具备「理解关系」的能力,知道哪些信息更重要。位置编码:弥补了linear无法处理顺序的缺陷,让模型懂「语序」。多层叠加:通过残差连接和层归一化,能训练极深层网络(如 GPT-4 有 96 层),捕捉复杂语义。如果把比作「单目相机」,Transformer 就是「带 AI 分析的多镜头摄像机」,不仅能看到画面,还能理解画面中物体的关系和动态~

mayaohao的博客 1388

Qwen大模型参数解析

Qwen系列模型的参数主要分为(决定模型结构)和(控制生成行为)两类。由于该系列已迭代多个版本,参数设计也在不断演进,我会结合最新版本为你进行分层梳理。

yeyiboy的博客 170

069_死区效应对输出电压畸变的补偿思路

死区效应导致逆变器输出电压在过零点出现台阶畸变,引发THD升高。其本质是死区期间续流二极管钳位造成的非线性误差,与电流方向、负载大小、母线电压耦合。补偿需结合前馈(基于电流方向自适应调整偏置)与反馈(抑制残余谐波),关键在于准确判断电流方向(采用滞环滤波避免跳变)、合理设置补偿量(随负载动态调整),并注意补偿位置、极性及限幅防漂移。调试应通过差分探头、FFT频谱等手段验证效果,最终实现全负载范围内的低畸变输出。

2401_88858637的博客 22

Transformer详解与案例

记录自己的Transformer学习过程

t1274171989的博客 2907

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

简单手写Transformer:原理与代码详解

本文详细介绍了从零开始实现Transformer模型的完整过程。首先阐述了Transformer的核心架构,包括编码器、解码器及其关键组件:自注意力机制、多头注意力、位置编码和前馈网络。随后通过代码演示了数据处理、位置编码、掩码机制等模块的具体实现,并构建了编码器和解码器层。文章还提供了模型训练和预测的完整流程,使用交叉熵损失和SGD优化器进行训练,采用贪婪解码算法生成目标序列。整个过程涵盖了Transformer从理论到实践的完整实现,为理解这一重要的NLP模型提供了清晰的代码示例。

修一的博客 1523

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

手写transformer

【代码】手写transformer。

m0_53292725的博客 1243

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

手写一层和直接调用transformer

手写实现适合深入理解 Transformer 的工作原理,或者需要对模型结构进行特殊修改的场景。直接调用适合快速实现原型或生产环境,代码更简洁且性能有保障。在实际应用中,推荐优先使用 PyTorch 的内置模块,因为它们经过了充分测试和优化。只有在需要特殊定制时,才考虑手写实现。

mayaohao的博客 668

[特殊字符] ​​从零手写Transformer​​:位置编码+层归一化+FFN+残差全实现(PyTorch代码)

本文详解Transformer编码器核心结构与实现。编码器由多层相同结构堆叠组成,每层包含多头自注意力、前馈网络两大模块,并通过残差连接和层归一化优化训练。关键技术包括:1)正弦位置编码解决序列顺序问题;2)层归一化加速收敛;3)前馈网络提供非线性能力;4)残差连接缓解梯度消失。文章给出了PyTorch实现代码,包括位置编码、层归一化、前馈网络等核心组件。Transformer通过位置信息注入、梯度保持机制和特征稳定化设计,实现了高效序列建模。完整实现还需添加词嵌入层和输出模块。

qq_30548401的博客 839

从零实现Transformer的简易版与强大版:从300多行到3000多行

transformer强大到什么程度呢,基本是17年之后绝大部分有影响力模型的基础架构都基于的transformer(比如,有200来个,包括且不限于基于decode的GPT、基于encode的BERT、基于encode-decode的T5等等)通过博客内的这篇文章《》,我们已经详细了解了transformer的原理(如果忘了,建议先务必复习下再看本文)

结构之法 算法之道 5万+

从零手写 Transformer:PyTorch 逐行实现与原理拆解

同时这里不能直接使用context_len来进行初始化nn.Embedding,因为这里面的高维特征是和词汇表的tokenID进行绑定的,所以不能简单的对每一个token进行初始化。下面给这些编码后的样本加上位置编码,注意这里的位置编码是一个常数,在训练过程中没有任何变化的。其中这个pos是字母的位置,i的话则是特征维度的位置,这里比较难写。位置除以10000的2i/d_model次方,这里2i的意思是,i只取一半,比如d_model是32,i就取16个。,通过三个独立的线性层分别学到不同的角色变换。

SuiFengL233的博客 235

教你手撸Transformer

一个手把手的教程,教你从零实现Transformer

dllsy61的博客 460

从手撸机器翻译 学习原味Transformer

项目目标:目前Transformer凭借着其强大的性能成为机器翻译的主流方法之一。因此,本项目旨在调研综述目前基于Transformer的机器翻译的现状。然后基于Pytorch框架搭建一个Transformer的Baseline网络,同时在数据方面基于CMN中英文口语双语句对数据集进行汉语分词与词典建立,最后对Transformer进行训练。 (由于可以计算资源仅有GTX1050Ti,算力有限,仅能抽取少量数据进行训练,故其泛化能力有限,故本报告更多强调实现原理及其可行性) 基于Encode-Dec

weixin_42432619的博客 499

手写Transformer实战全解析

✔️ 掌握了位置编码设计哲学(正弦+可学习)✔️ 理清了注意力机制的维度流转逻辑✔️ 学会了梯度裁剪 + 学习率调度的工程实践✔️ 能独立诊断模型瓶颈并优化✔️ 拥有了一个可复用、可调参、可部署的工业级文本分类框架。

2503_91965777的博客 710
上一篇: 小白看得懂的 Transformer (图解)
下一篇: 单GPU训练一天,Transformer在100位数字加法上就达能到99%准确率
AI大模型_学习君
博客等级 码龄3年 6138粉丝 551原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值