挑战Transformer的新架构Mamba解析以及Pytorch复现

这篇具有很好参考价值的文章主要介绍了挑战Transformer的新架构Mamba解析以及Pytorch复现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

今天我们来详细研究这篇论文“Mamba:具有选择性状态空间的线性时间序列建模”

挑战Transformer的新架构Mamba解析以及Pytorch复现,transformer,架构,pytorch,深度学习,人工智能,神经网络

Mamba一直在人工智能界掀起波澜,被吹捧为Transformer的潜在竞争对手。到底是什么让Mamba在拥挤的序列建中脱颖而出?

在介绍之前先简要回顾一下现有的模型

挑战Transformer的新架构Mamba解析以及Pytorch复现,transformer,架构,pytorch,深度学习,人工智能,神经网络

Transformer:以其注意力机制而闻名,其中序列的任何部分都可以动态地与任何其他部分相互作用,特别是具有因果注意力机制的的Transformer,擅长处理序列中的单个元素。但是它们带来了显著的计算和内存成本,与序列长度的平方(L²)成比例。

循环神经网络(rnn): rnn只考虑当前输入和最后一个隐藏状态,按顺序更新隐藏状态。这种方法允许它们潜在地处理无限序列长度和恒定的内存需求。但是rnn的简单性是一个缺点,限制了它们记住长期依赖关系的能力。此外,rnn中的时间反向传播(BPTT)是内存密集型的,并且可能遭受梯度消失或爆炸的影响,尽管有LSTM等创新部分结解决了这个问题。

State Space Models(S4):这些模型已经显示出很好的特性。它们提供了一种平衡,比rnn更有效地捕获远程依赖关系,同时比transformer更高效地使用内存。

Mamba

选择性状态空间:Mamba建立在状态空间模型的概念之上,但引入了一个新的变化。它利用选择性状态空间,支持跨长序列更高效和有效地捕获相关信息。

线性时间复杂度:与Transformer不同,Mamba在序列长度方面以线性时间运行。这个属性使得它特别适合涉及非常长的序列的任务,而传统模型在这方面会遇到困难。

挑战Transformer的新架构Mamba解析以及Pytorch复现,transformer,架构,pytorch,深度学习,人工智能,神经网络

Mamba以其选择性状态空间的概念引入了传统状态空间模型的一个有趣的改进。这种方法稍微放松了标准状态空间模型的严格状态转换,使其更具适应性和灵活性(有点类似于lstm)。并且Mamba保留了状态空间模型的高效计算特性,使其能够在一次扫描中执行整个序列的前向传递-这一特性更让人想起Transformer。

在训练期间,Mamba的行为类似于Transformer,同时处理整个序列。而lstm必须一步一步地计算前向传递,即使所有输入都是已知的。在推理中,Mamba的行为更符合传统的循环模型,提供有效的序列处理。

先验状态空间模型(ssm)的一个关键限制是其刚性的、输入不变的结构。这些模型为整个序列使用一组固定参数(我们称它们为a和B)。这种结构甚至比lstm等模型更具限制性,在lstm中,信号的转换可能依赖于先前的隐藏状态和输入。

Mamba则一种范式转换,即如何计算向下一个隐藏状态的过渡?在Mamba的体系结构中,转换依赖于当前输入,这种方法在传统ssm的固定计算和循环神经网络的输入依赖动态性之间取得了平衡。

主要组成如下:

固定主干:从一个隐藏状态到下一个隐藏状态的转换仍然是一个固定的计算(由a矩阵定义),允许跨序列的预计算。

输入相关转换:输入影响下一个隐藏状态(由B矩阵定义)的方式取决于当前输入,而不是之前的隐藏状态。与传统ssm相比,这种输入依赖性提供了更大的灵活性。

挑战Transformer的新架构Mamba解析以及Pytorch复现,transformer,架构,pytorch,深度学习,人工智能,神经网络

为了满足这种方法的计算需求,Mamba使用了一种硬件感知算法。该算法使用扫描操作而不是卷积来循环执行计算,这样在gpu上非常高效的。尽管输入依赖转换带来了算法复杂性,但这种效率对于保持高性能至关重要。

Mamba和选择性状态空间模型不是同义词。Mamba是一个使用选择性状态空间概念的实现。这种区别是至关重要的,因为它突出了Mamba的独特贡献:在保持计算效率的同时,使SSM框架更加灵活和响应输入。

SRAM和HBM

挑战Transformer的新架构Mamba解析以及Pytorch复现,transformer,架构,pytorch,深度学习,人工智能,神经网络

gpu包含两种主要类型的内存:HBM (High Bandwidth memory)和SRAM (Static Random-Access memory)。HBM虽然带宽很高,但与更快但更小的SRAM相比,它的访问时间相对较慢。Mamba则使用SRAM在矩阵乘法期间进行快速访问,这是其计算的关键。

计算中的主要瓶颈通常不是计算本身,而是数据在内存类型之间的移动。Mamba通过显著减少传输大量数据的需求来解决这个问题。它通过直接在SRAM中执行算法的关键部分(如离散化和递归计算)来实现,从而减少延迟。

还引入了一个融合选择扫描层,使其内存需求与使用flash attention的优化Transformer实现相当。这一层对于保持效率至关重要,尤其是在处理模型中依赖于输入的元素时。

结果

挑战Transformer的新架构Mamba解析以及Pytorch复现,transformer,架构,pytorch,深度学习,人工智能,神经网络

Mamba代表了序列建模的重大进步,特别是在其高效使用GPU内存和计算策略方面。它具有高效率处理长序列的能力,使其成为各种应用的有前途的模型,我们下面来使用Pytorch代码来对其进复现。

Pytorch复现

导入基本库

 import torch
 import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader, Dataset
 from torch.nn import functional as F
 from einops import rearrange
 from tqdm import tqdm
 
 import math
 import os
 import urllib.request
 from zipfile import ZipFile
 
 from transformers import AutoTokenizer
 
 torch.autograd.set_detect_anomaly(True)

设置标志和超参数

 # Configuration flags and hyperparameters
 USE_MAMBA = 1
 DIFFERENT_H_STATES_RECURRENT_UPDATE_MECHANISM = 0
 
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

定义超参数和初始化

 d_model = 8
 state_size = 128  # Example state size
 seq_len = 100  # Example sequence length
 batch_size = 256  # Example batch size
 last_batch_size = 81  # only for the very last batch of the dataset
 current_batch_size = batch_size
 different_batch_size = False
 h_new = None
 temp_buffer = None

这里的超参数,如模型维度(d_model)、状态大小、序列长度和批大小。

S6模块是Mamba架构中的一个复杂组件,负责通过一系列线性变换和离散化过程处理输入序列。它在捕获序列的时间动态方面起着关键作用,这是序列建模任务(如语言建模)的一个关键方面。这里包括张量运算和自定义离散化方法来处理序列数据的复杂需求。

 classS6(nn.Module):
     def__init__(self, seq_len, d_model, state_size, device):
         super(S6, self).__init__()
 
         self.fc1=nn.Linear(d_model, d_model, device=device)
         self.fc2=nn.Linear(d_model, state_size, device=device)
         self.fc3=nn.Linear(d_model, state_size, device=device)
 
         self.seq_len=seq_len
         self.d_model=d_model
         self.state_size=state_size
 
 
         self.A=nn.Parameter(F.normalize(torch.ones(d_model, state_size, device=device), p=2, dim=-1))
         nn.init.xavier_uniform_(self.A)
 
         self.B=torch.zeros(batch_size, self.seq_len, self.state_size, device=device)
         self.C=torch.zeros(batch_size, self.seq_len, self.state_size, device=device)
 
         self.delta=torch.zeros(batch_size, self.seq_len, self.d_model, device=device)
         self.dA=torch.zeros(batch_size, self.seq_len, self.d_model, self.state_size, device=device)
         self.dB=torch.zeros(batch_size, self.seq_len, self.d_model, self.state_size, device=device)
 
         # h  [batch_size, seq_len, d_model, state_size]
         self.h=torch.zeros(batch_size, self.seq_len, self.d_model, self.state_size, device=device)
         self.y=torch.zeros(batch_size, self.seq_len, self.d_model, device=device)
 
 
     defdiscretization(self):
 
         self.dB=torch.einsum("bld,bln->bldn", self.delta, self.B)
 
         self.dA=torch.exp(torch.einsum("bld,dn->bldn", self.delta, self.A))
 
 
         returnself.dA, self.dB
 
     defforward(self, x):
         # Algorithm 2  MAMBA paper
         self.B=self.fc2(x)
         self.C=self.fc3(x)
         self.delta=F.softplus(self.fc1(x))
 
         self.discretization()
 
         ifDIFFERENT_H_STATES_RECURRENT_UPDATE_MECHANISM:  
           
             globalcurrent_batch_size
             current_batch_size=x.shape[0]
 
             ifself.h.shape[0] !=current_batch_size:
                 different_batch_size=True
 
                 h_new=  torch.einsum('bldn,bldn->bldn', self.dA, self.h[:current_batch_size, ...]) +rearrange(x, "b l d -> b l d 1") *self.dB
 
             else:
                 different_batch_size=False
                 h_new=  torch.einsum('bldn,bldn->bldn', self.dA, self.h) +rearrange(x, "b l d -> b l d 1") *self.dB
 
             # y  [batch_size, seq_len, d_model]
             self.y=torch.einsum('bln,bldn->bld', self.C, h_new)
 
             globaltemp_buffer
             temp_buffer=h_new.detach().clone() ifnotself.h.requires_gradelseh_new.clone()
   
             returnself.y
 
         else:  
             # h [batch_size, seq_len, d_model, state_size]
             h=torch.zeros(x.size(0), self.seq_len, self.d_model, self.state_size, device=x.device)
             y=torch.zeros_like(x)
 
             h=  torch.einsum('bldn,bldn->bldn', self.dA, h) +rearrange(x, "b l d -> b l d 1") *self.dB
 
             # y  [batch_size, seq_len, d_model]
             y=torch.einsum('bln,bldn->bld', self.C, h)
 
             returny

这个S6的模块,可以处理离散化过程和正向传播。

MambaBlock类是一个定制的神经网络模块,被设计为Mamba模型的关键构建块。它封装了几个层和操作来处理输入数据。

包括线性投影、卷积、激活函数、自定义S6模块和残差连接。该块是Mamba模型的基本组件,负责通过一系列转换处理输入序列,以捕获数据中的相关模式和特征。这些不同层和操作的组合允许MambaBlock有效地处理复杂的序列建模任务。

 classMambaBlock(nn.Module):
     def__init__(self, seq_len, d_model, state_size, device):
         super(MambaBlock, self).__init__()
 
         self.inp_proj=nn.Linear(d_model, 2*d_model, device=device)
         self.out_proj=nn.Linear(2*d_model, d_model, device=device)
 
         # For residual skip connection
         self.D=nn.Linear(d_model, 2*d_model, device=device)
 
         # Set _no_weight_decay attribute on bias
         self.out_proj.bias._no_weight_decay=True
 
         # Initialize bias to a small constant value
         nn.init.constant_(self.out_proj.bias, 1.0)
 
         self.S6=S6(seq_len, 2*d_model, state_size, device)
 
         # Add 1D convolution with kernel size 3
         self.conv=nn.Conv1d(seq_len, seq_len, kernel_size=3, padding=1, device=device)
 
         # Add linear layer for conv output
         self.conv_linear=nn.Linear(2*d_model, 2*d_model, device=device)
 
         # rmsnorm
         self.norm=RMSNorm(d_model, device=device)
 
     defforward(self, x):
         """
         x_proj.shape = torch.Size([batch_size, seq_len, 2*d_model])
         x_conv.shape = torch.Size([batch_size, seq_len, 2*d_model])
         x_conv_act.shape = torch.Size([batch_size, seq_len, 2*d_model])
         """
         # Refer to Figure 3 in the MAMBA paper
 
         x=self.norm(x)
 
         x_proj=self.inp_proj(x)
 
         # Add 1D convolution with kernel size 3
         x_conv=self.conv(x_proj)
 
         x_conv_act=F.silu(x_conv)
 
         # Add linear layer for conv output
         x_conv_out=self.conv_linear(x_conv_act)
 
         x_ssm=self.S6(x_conv_out)
         x_act=F.silu(x_ssm)  # Swish activation can be implemented as x * sigmoid(x)
 
         # residual skip connection with nonlinearity introduced by multiplication
         x_residual=F.silu(self.D(x))
 
         x_combined=x_act*x_residual
 
         x_out=self.out_proj(x_combined)
 
         returnx_out

MambaBlock是Mamba核心功能

Mamba模型

包括一系列MambaBlock模块。每个块都顺序处理输入数据,一个块的输出作为下一个块的输入。这种顺序处理允许模型捕获输入数据中的复杂模式和关系,使其对涉及顺序建模的任务有效。多个块的堆叠是深度学习架构中的常见设计,因为它使模型能够学习数据的分层表示。

 classMamba(nn.Module):
     def__init__(self, seq_len, d_model, state_size, device):
         super(Mamba, self).__init__()
         self.mamba_block1=MambaBlock(seq_len, d_model, state_size, device)
         self.mamba_block2=MambaBlock(seq_len, d_model, state_size, device)
         self.mamba_block3=MambaBlock(seq_len, d_model, state_size, device)
 
     defforward(self, x):
         x=self.mamba_block1(x)
         x=self.mamba_block2(x)
         x=self.mamba_block3(x)
         returnx

RMSNorm是一个自定义规范化层,这一层用于规范神经网络的激活,这可以帮助稳定和加快训练。

 classRMSNorm(nn.Module):
     def__init__(self,
                  d_model: int,
                  eps: float=1e-5,
                  device: str='cuda'):
         super().__init__()
         self.eps=eps
         self.weight=nn.Parameter(torch.ones(d_model, device=device))
 
 
     defforward(self, x):
         output=x*torch.rsqrt(x.pow(2).mean(-1, keepdim=True) +self.eps) *self.weight
 
         returnoutput

这一层的用法:

 x=torch.rand(batch_size, seq_len, d_model, device=device)
 # Create the Mamba model
 mamba=Mamba(seq_len, d_model, state_size, device)
 
 # rmsnorm
 norm=RMSNorm(d_model)
 x=norm(x)
 
 # Forward pass
 test_output=mamba(x)
 print(f"test_output.shape = {test_output.shape}")  # Should be [batch_size, seq_len, d_model]

上面就是模型的全部基本代码,下面就可以进行数据准备和训练

我们自定义一个Enwiki8Dataset

 classEnwiki8Dataset(Dataset):
     def__init__(self, data):
         self.data=data
 
     def__len__(self):
         returnlen(self.data['input_ids'])
 
     def__getitem__(self, idx):
         item= {key: val[idx].clone().detach() forkey, valinself.data.items()}
         returnitem

pad_sequences_3d用于将一批序列填充到统一的长度,确保批中的每个序列具有相同数量的元素(或时间步长)。这在许多机器学习任务中尤其重要,因为输入数据必须具有一致的形状。

 # Define a function for padding
 defpad_sequences_3d(sequences, max_len=None, pad_value=0):
     # Assuming sequences is a tensor of shape (batch_size, seq_len, feature_size)
     batch_size, seq_len, feature_size=sequences.shape
 
     ifmax_lenisNone:
         max_len=seq_len+1
 
 
     # Initialize padded_sequences with the pad_value
     padded_sequences=torch.full((batch_size, max_len, feature_size), fill_value=pad_value, dtype=sequences.dtype, device=sequences.device)
     # Pad each sequence to the max_len
     padded_sequences[:, :seq_len, :] =sequences
 
     returnpadded_sequences

训练过程还是传统的pytorch过程:

 deftrain(model, tokenizer, data_loader, optimizer, criterion, device, max_grad_norm=1.0, DEBUGGING_IS_ON=False):
     model.train()
     total_loss=0
     forbatchindata_loader:
         optimizer.zero_grad()
 
         input_data=batch['input_ids'].clone().to(device)
         attention_mask=batch['attention_mask'].clone().to(device)
 
         target=input_data[:, 1:]
         input_data=input_data[:, :-1]
 
         # Pad all the sequences in the batch:
         input_data=pad_sequences_3d(input_data, pad_value=tokenizer.pad_token_id)
         target=pad_sequences_3d(target, max_len=input_data.size(1), pad_value=tokenizer.pad_token_id)
 
         ifUSE_MAMBA:
             output=model(input_data)
             loss=criterion(output, target)
 
         loss.backward(retain_graph=True)
 
         forname, paraminmodel.named_parameters():
            if'out_proj.bias'notinname:
                # clip weights but not bias for out_proj
                torch.nn.utils.clip_grad_norm_(param, max_norm=max_grad_norm)
 
         ifDEBUGGING_IS_ON:
             forname, parameterinmodel.named_parameters():
                 ifparameter.gradisnotNone:
                     print(f"{name} gradient: {parameter.grad.data.norm(2)}")
                 else:
                     print(f"{name} has no gradient")
 
         ifUSE_MAMBAandDIFFERENT_H_STATES_RECURRENT_UPDATE_MECHANISM:
             model.S6.h[:current_batch_size, ...].copy_(temp_buffer)
 
         optimizer.step()
 
         total_loss+=loss.item()
     returntotal_loss/len(data_loader)

评估函数也是一样:

 defevaluate(model, data_loader, criterion, device):
     model.eval()
     total_loss=0
     withtorch.no_grad():
         forbatchindata_loader:
             input_data=batch['input_ids'].clone().detach().to(device)
             attention_mask=batch['attention_mask'].clone().detach().to(device)
 
             target=input_data[:, 1:]
             input_data=input_data[:, :-1]
 
             # Pad all the sequences in the batch:
             input_data=pad_sequences_3d(input_data, pad_value=tokenizer.pad_token_id)
             target=pad_sequences_3d(target, max_len=input_data.size(1), pad_value=tokenizer.pad_token_id)
 
             ifUSE_MAMBA:
                 output=model(input_data)
                 loss=criterion(output, target)
             total_loss+=loss.item()
     returntotal_loss/len(data_loader)

最后,calculate_perplexity用于评估语言模型(如Mamba)的性能。

 defcalculate_perplexity(loss):
     returnmath.exp(loss)

load_enwiki8_dataset函数用于下载和提取enwiki8数据集,该数据集通常用于对语言模型进行基准测试。

 defload_enwiki8_dataset():
     print(f"Download and extract enwiki8 data")
     url="http://mattmahoney.net/dc/enwik8.zip"
     urllib.request.urlretrieve(url, "enwik8.zip")
 
     withZipFile("enwik8.zip") asf:
         data=f.read("enwik8").decode("utf-8")
 
     returndata

encode_dataset函数设计用于标记和编码数据集,为神经网络模型(如Mamba)处理数据集做准备。

 # Tokenize and encode the dataset
 defencode_dataset(tokenizer, text_data):
     defbatch_encode(tokenizer, text_data, batch_size=1000):
         # Tokenize in batches
         batched_input_ids= []
         foriinrange(0, len(text_data), batch_size):
             batch=text_data[i:i+batch_size]
             inputs=tokenizer(batch, add_special_tokens=True, truncation=True,
                                padding='max_length', max_length=seq_len,
                                return_tensors='pt')
             batched_input_ids.append(inputs['input_ids'])
         returntorch.cat(batched_input_ids)
 
     # Assuming enwiki8_data is a list of sentences
     input_ids=batch_encode(tokenizer, enwiki8_data)
 
     # vocab_size is the number of unique tokens in the tokenizer's vocabulary
     globalvocab_size
     vocab_size=len(tokenizer.vocab)  # Note that for some tokenizers, we might access the vocab directly
     print(f"vocab_size = {vocab_size}")
 
     # Create an embedding layer
     # embedding_dim is the size of the embedding vectors (MAMBA model's D)
     embedding_layer=nn.Embedding(num_embeddings=vocab_size, embedding_dim=d_model)
 
     # Pass `input_ids` through the embedding layer
     # This will change `input_ids` from shape [B, L] to [B, L, D]
     defbatch_embedding_calls(input_ids, embedding_layer, batch_size=256):
         # Check if input_ids is already a tensor, if not convert it
         ifnotisinstance(input_ids, torch.Tensor):
             input_ids=torch.tensor(input_ids, dtype=torch.long)
 
         # Calculate the number of batches needed
         num_batches=math.ceil(input_ids.size(0) /batch_size)
 
         # List to hold the output embeddings
         output_embeddings= []
 
         # Process each batch
         foriinrange(num_batches):
             # Calculate start and end indices for the current batch
             start_idx=i*batch_size
             end_idx=start_idx+batch_size
 
             # Get the batch
             input_id_batch=input_ids[start_idx:end_idx]
 
             # Call the embedding layer
             withtorch.no_grad():  # No need gradients for this operation
                 batch_embeddings=embedding_layer(input_id_batch)
 
             # Append the result to the list
             output_embeddings.append(batch_embeddings)
 
         # Concatenate the embeddings from each batch into a single tensor
         all_embeddings=torch.cat(output_embeddings, dim=0)
 
         returnall_embeddings
 
     # `input_ids` is a list or tensor of the input IDs and `embedding_layer` is model's embedding layer
     ifUSE_MAMBA:
         # Set `batch_size` to a value that works for memory constraints
         encoded_inputs=batch_embedding_calls(input_ids, embedding_layer, batch_size=1).float()
 
     attention_mask= (input_ids!=tokenizer.pad_token_id).type(input_ids.dtype)
 
     returnencoded_inputs, attention_mask

下面就可以进行训练了

 # Load a pretrained tokenizer
 tokenizer=AutoTokenizer.from_pretrained('bert-base-uncased')
 
 # Assuming encoded_inputs is a preprocessed tensor of shape [num_samples, seq_len, d_model]
 encoded_inputs_file='encoded_inputs_mamba.pt'
 
 
 ifos.path.exists(encoded_inputs_file):
     print("Loading pre-tokenized data...")
     encoded_inputs=torch.load(encoded_inputs_file)
 else:
     print("Tokenizing raw data...")
     enwiki8_data=load_enwiki8_dataset()
     encoded_inputs, attention_mask=encode_dataset(tokenizer, enwiki8_data)
     torch.save(encoded_inputs, encoded_inputs_file)
     print(f"finished tokenizing data")
 
 
 # Combine into a single dictionary
 data= {
     'input_ids': encoded_inputs,
     'attention_mask': attention_mask
 }
 
 # Split the data into train and validation sets
 total_size=len(data['input_ids'])
 train_size=int(total_size*0.8)
 
 train_data= {key: val[:train_size] forkey, valindata.items()}
 val_data= {key: val[train_size:] forkey, valindata.items()}
 
 train_dataset=Enwiki8Dataset(train_data)
 val_dataset=Enwiki8Dataset(val_data)
 
 
 train_loader=DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
 val_loader=DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
 
 
 # Initialize the model
 
 model=Mamba(seq_len, d_model, state_size, device).to(device)
 
 # Define the loss function and optimizer
 criterion=nn.CrossEntropyLoss()
 optimizer=optim.AdamW(model.parameters(), lr=5e-6)
 
 # Training loop
 num_epochs=25  # Number of epochs to train for
 
 forepochintqdm(range(num_epochs)):  # loop over the dataset multiple times
     train_loss=train(model, tokenizer, train_loader, optimizer, criterion, device, max_grad_norm=10.0, DEBUGGING_IS_ON=False)
     val_loss=evaluate(model, val_loader, criterion, device)
     val_perplexity=calculate_perplexity(val_loss)
     print(f'Epoch: {epoch+1}, Training Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}, Validation Perplexity: {val_perplexity:.4f}')

以上就是训练的完整代码

总结

我们介绍了Mamba的概念和架构,并且从头开始构建Mamba复现,这样可以将理论转化为实践。通过这种动手的方法,可以看到Mamba序列建模方法和效率。如果你想直接使用,可以看论文提供的代码

https://avoid.overfit.cn/post/96ca1d7044b4405a9b0a0f6154099078文章来源地址https://www.toymoban.com/news/detail-786125.html

到了这里,关于挑战Transformer的新架构Mamba解析以及Pytorch复现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【手撕Transformer】Transformer输入输出细节以及代码实现(pytorch)

    数据从输入到encoder到decoder输出这个过程中的流程(以机器翻译为例子): 对于机器翻译来说,一个样本是由原始句子和翻译后的句子组成的。比如原始句子是: “我爱机器学习”,那么翻译后是 ’i love machine learning‘。 则该一个样本就是由“我爱机器学习”和 “i love ma

    2023年04月22日
    浏览(45)
  • 人工智能(Pytorch)搭建transformer模型,真正跑通transformer模型,深刻了解transformer的架构

    大家好,我是微学AI,今天给大家讲述一下人工智能(Pytorch)搭建transformer模型,手动搭建transformer模型,我们知道transformer模型是相对复杂的模型,它是一种利用自注意力机制进行序列建模的深度学习模型。相较于 RNN 和 CNN,transformer 模型更高效、更容易并行化,广泛应用于神

    2023年04月10日
    浏览(65)
  • 深度学习实战24-人工智能(Pytorch)搭建transformer模型,真正跑通transformer模型,深刻了解transformer的架构

    大家好,我是微学AI,今天给大家讲述一下人工智能(Pytorch)搭建transformer模型,手动搭建transformer模型,我们知道transformer模型是相对复杂的模型,它是一种利用自注意力机制进行序列建模的深度学习模型。相较于 RNN 和 CNN,transformer 模型更高效、更容易并行化,广泛应用于神

    2023年04月22日
    浏览(64)
  • Transformer实现以及Pytorch源码解读(四)-Encoder层

    先放一张原论文中的图。从inputs到Poitional Encoding在前三部分中已经分析清楚,接下来往后分析。 Pytorch将图1中左半部分的神经网络层用一个TransformerEncdoer(encoder_layer,num_layers)类进行封装,该类的传参有两个:TransformerEncoderLayer(encoder_layer)和堆叠的层数(num_layers)。 接下来逐一

    2023年04月27日
    浏览(49)
  • Jamba: A Hybrid Transformer-Mamba Language Model

    相关链接:arXiv : hybrid architecture 、 Transformer 、 Mamba 、 mixture-of-experts (MoE) 、 language model 我们介绍了Jamba,一种新的基于新颖混合Transformer-Mamba混合专家(MoE)架构的基础大型语言模型。具体来说,Jamba交错了Transformer和Mamba层的块,享受两个模型家族的好处。在这些层

    2024年04月09日
    浏览(67)
  • 【计算机视觉】Visual Transformer (ViT)模型结构以及原理解析

    Visual Transformer (ViT) 出自于论文《AN IMAGE IS WORTH 16X16 WORDS: TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE》,是基于Transformer的模型在视觉领域的开篇之作。 本文将尽可能简洁地介绍一下ViT模型的整体架构以及基本原理。 ViT模型是基于Transformer Encoder模型的,在这里假设读者已经了解Transfo

    2024年02月02日
    浏览(47)
  • 《Vision Transformer (ViT)》论文精度,并解析ViT模型结构以及代码实现

    《AN IMAGE IS WORTH 16X16 WORDS: TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE》 论文共有22页,表格和图像很多,网络模型结构解释的很清楚,并且用四个公式展示了模型的计算过程;本文章对其进行精度,并对源码进行剖析,希望读者可以耐心读下去。 论文地址:https://arxiv.org/abs/2010.11929 源

    2024年02月05日
    浏览(40)
  • 怎么降AI率中文:探索学术写作的新挑战

    大家好,小发猫降ai今天来聊聊怎么降AI率中文:探索学术写作的新挑战,希望能给大家提供一点参考。降ai辅写 以下是针对论文AI辅写率高的情况,提供一些修改建议和技巧,可以借助此类工具: 还有: 怎么降AI率中文:探索学术写作的新挑战 在学术写作中,随着人工智能

    2024年03月12日
    浏览(44)
  • TMI2022 | nnFormer:利用交织3D卷积和Transformer进行医学分割的新方案

    Transformer作为自然语言处理的首选模型,在医学影像界引起了很少的关注。考虑到利用长期依赖关系的能力,Transformer有望帮助非典型卷积神经网络克服其空间归纳偏差的固有缺点。然而,大多数最近提出的基于Transformer的分割方法只是将Transformer作为辅助模块来帮助将全局上

    2024年02月07日
    浏览(42)
  • ChatGPT遭受匿名苏丹组织DDoS攻击:网络安全在AI时代的新挑战

    ChatGPT遭受匿名苏丹组织DDoS攻击:网络安全在AI时代的新挑战 最近,全球备受瞩目的AI对话机器人ChatGPT及其开发公司OpenAI遇到了一连串的服务中断和异常错误,这一系列问题背后似乎暗藏了分布式拒绝服务(DDoS)攻击的阴影。自称为“匿名苏丹”的网络行动主义者团体已经站

    2024年02月22日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包