devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Vision Mamba代码笔记

作者：我家自动化 | 2024-05-25 16:44:31

赞

踩

Vision Mamba代码笔记

1 论文回顾

  • 基本思路

论文解读见：

《VideoMamba》论文笔记_video mamba-CSDN博客

  • 注意

  1. Vision Mamba和VIT的输入和输出的shape的形状是相同的（VIT基于Transformer的Encoder设计，输入经过多层MHA和MLP计算，输入和输出的形状相同，Mamba的SSM架构就可以做到输入与输出token的个数以及每个token的维度相同，自然也可以做到整个输入和输出的形状相同，再者Vision Mamba的设计参照VIT的结构，自然也要注意输入与输出形状相同。两者的输入流经过各自对应的Encoder之后都具备了上下文信息，其效果相同，效率上基于Mamba的模型会更胜一筹。
  2. 正如1所说，Vision Mamba的设计参照VIT，这两个工作的流程是相同的，这里主要指的是图片打patch 再concat上class token再加上Position Embedding这个流程，两个模型唯一不同的地方就是Emcoder部分的不同，VIT使用的是Transformer的Encoder，Vim使用的是Mamba的Encoder，二者都是用于token间信息交互，上下文建模的

2 环境配置

按照官方readme.md配置，如果有问题照着下面这个链接改

vision mamba 运行训练记录，解决bimamba_type错误-CSDN博客

值得说明的一点是，如果你之前在跑其他的mamba，环境拿过来是不能直接直接用的，因为标准的Mamba类是没有bimamba_type这个参数的，

所以，需要去Vim代码官网去找到mamba-1p1p1包，下载之后放自己项目里

事实上Vision Mamba重写了这个Mamba类，可以看到里边是由bimamba_type这个参数的（这其实也是Vision Mamba的主要贡献），执行如下代码

  1. cp -rf mamba-1p1p1/mamba_ssm /home/liyhc/anaconda3/envs/mamba/lib/python3.10/site-packages
  2. #后边是系统的mamba的安装路径，自己照着自己环境mamba的安装路径进行修改

3 代码笔记

3.1 代码链接

官方代码链接

Vim/vim/models_mamba.py at main · hustvl/Vim (github.com)

我手敲的带中文注释的链接

Johnny-Haytham/Vim: Vim with chinese notation (github.com)

3.2 Module

3.2.1 PatchEmbed

     

  1. class PatchEmbed(nn.Module):
  2.     def __init__(self, img_size=224,patch_size=16,stride=16,in_channels=3,embed_dim=768,norm_layer=None,flatten=True):
  3.         super(PatchEmbed, self).__init__()
  4.         img_size = to_2tuple(img_size)
  5.         patch_size = to_2tuple(patch_size)#将img_size和patch_size化成元组的形式
  6.         self.img_size = img_size
  7.         self.patch_size = patch_size
  8.         #一个patch形成一个grid（网格），这里记录网格的形状
  9.         self.grid_size = ((img_size[0] - patch_size[0]) // stride + 1 , (img_size[1] - patch_size[1]) // stride + 1)
  10.         self.num_patches = self.grid_size[0] * self.grid_size[1]#总共的patch个数
  11.         self.flatten = flatten
  12.         #打patch的操作，实际为卷积的操作(为了不重复卷积，步长的大小理论上因该等于卷积核的大小）
  13.         self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=stride)
  14.         self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()#nn.Identity的输入等于输出，通常作为占位层使用
  15.  
  16.     def forward(self, x):
  17.         B, C, H, W = x.shape
  18.         assert H == self.img_size[0] and W == self.img_size[1],\
  19.             f"Input img size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})"
  20.         x = self.proj(x)#B,C,H,W——>B,embed_dim,grid_size,grid_size
  21.         if self.flatten:
  22.             x = x.flatten(2).transpose(1, 2)#B,embed_dim,grid_size,grid_size——>B,embed_dim,grid_size*grid_size——>B,grid_size*grid_size,embed_dim
  23.         x = self.norm(x)
  24.         return x

3.2.2 Vim Encoder Block

  1. class Block(nn.Module):
  2.     def __init__(
  3.             self, dim, mixer_cls,
  4.             norm_cls = nn.LayerNorm,
  5.             fused_add_norm=False,residual_in_fp32=False,drop_path=0.
  6.     ):
  7.         super(Block, self).__init__()
  8.         self.residual_in_fp32 = residual_in_fp32
  9.         self.fused_add_norm = fused_add_norm
  10.  
  11.         self.mixer = mixer_cls(dim)#这其实是Mamba的部分固定参数的调用
  12.         self.norm = norm_cls(dim)
  13.  
  14.         self.drop_path = DropPath(drop_path)
  15.  
  16.         if self.fused_add_norm:
  17.             assert RMSNorm is not None,"RMSNorm import Fails"
  18.             assert isinstance(
  19.                 self.norm, (nn.LayerNorm, RMSNorm)
  20.             ),"Only LayerNorm and RMSNorm are supported for fused_add_norm"
  21.  
  22.     def forward(self,
  23.                 hidden_states:  Tensor,#上一个时间状态的输出，也就是ht-1
  24.                 residual: Optional[Tensor]=None,
  25.                 inference_params = None):
  26.         if not self.fused_add_norm:#如果fused_add_norm为False
  27.             if residual is None:#如果残差为空，这个是if用于第一个block处理输入数据
  28.                 residual = hidden_states
  29.             else:#如果残差不为空，这个if用于处理除了第一个block以外的所有block的操作
  30.                 residual = residual + self.drop_path(self.mixer(hidden_states))
  31.                 # 将residual的数据类型转化为self.norm.weight.dtype，将residual归一化后保存为hidden_states
  32.             hidden_states = self.norm(residual.to(dtype=self.norm.weight.dtype))
  33.             if self.residual_in_fp32:#如果指定self_residual的类型是float32的话
  34.                 residual = residual.to(torch.float32)
  35.  
  36.         else:#如果fused_add_norm不为False
  37.             fused_add_norm_fn = rms_norm_fn if isinstance(self.norm, RMSNorm) else layer_norm_fn
  38.             if residual is None:#如果残差为空，这个是if用于第一个block处理输入数据
  39.                 hidden_states,residual = fused_add_norm_fn(
  40.                     hidden_states,
  41.                     self.norm.weight,
  42.                     self.norm.bias,
  43.                     residual=residual,
  44.                     prenorm=True,
  45.                     residual_in_fp32=self.residual_in_fp32,
  46.                     eps=self.norm.eps,
  47.                     )
  48.             else:#如果残差不为空，这个if用于处理除了第一个block以外的所有block的操作
  49.                 hidden_states,residual = fused_add_norm_fn(
  50.                     self.drop_path(hidden_states),
  51.                     self.norm.weight,
  52.                     self.norm.bias,
  53.                     residual=residual,
  54.                     prenorm=True,
  55.                     residual_in_fp32=self.residual_in_fp32,
  56.                     eps=self.norm.eps,
  57.                 )
  58.         hidden_states = self.mixer(hidden_states,inference_params=inference_params)
  59.         return hidden_states, residual
  60.  
  61. def create_block(
  62.         d_model,                                #token维度
  63.         ssm_cfg=None,                           #ssm模型的配置文件
  64.         norm_epsilon=1e-5,                      #
  65.         drop_path=0.,
  66.         rms_norm=False,
  67.         residual_in_fp32=False,
  68.         fused_add_norm=False,
  69.         layer_idx=None,
  70.         device=None,
  71.         dtype=None,
  72.         if_bimamba=False,                       #是否使用双向mamba扫描
  73.         bimamba_type="none",
  74.         if_devide_out=False,
  75.         init_layer_scale=None,
  76. ):
  77.     if if_bimamba:#如果使用双向mamba扫描
  78.         bimamba_type = "v1"                     #这是一个模型的版本号
  79.     if ssm_cfg is None:
  80.         ssm_cfg = {}
  81.     factory_kwargs = {"device": device, "dtype": dtype}
  82.     mixer_cls = partial(                        #代表着VIM Encoder对class token的拼接方式,cls token可以拼接到不同位置（所有token前面，所有token中间，...或是随机位置）
  83.         Mamba,
  84.         layer_idx=layer_idx,
  85.         bimamba_type=bimamba_type,
  86.         if_devide_out=if_devide_out,
  87.         init_layer_scale=init_layer_scale,
  88.         **ssm_cfg,
  89.         **factory_kwargs
  90.     )
  91.     norm_cls=partial(                           #对于class token的normalization函数
  92.         nn.LayerNorm if not rms_norm else RMSNorm,eps=norm_epsilon,**factory_kwargs
  93.     )                                           #eps用于避免归一化过程中分母为0的情况
  94.     block =Block(
  95.         d_model,
  96.         mixer_cls,
  97.         norm_cls=norm_cls,
  98.         drop_path=drop_path,
  99.         fused_add_norm=fused_add_norm,
  100.         residual_in_fp32=residual_in_fp32,
  101.     )
  102.     block.layer_idx = layer_idx
  103.     return block

3.3 Vision Mamba整体

  1. class VisionMamba(nn.Module):
  2.     def __init__(self,
  3.                  img_size=224,
  4.                  patch_size=16,
  5.                  stride=16,
  6.                  depth=24,                        #需要构造的block的个数
  7.                  embed_dim=192,
  8.                  channels=3,
  9.                  num_classes=1000,                #这里用imagenet做分类任务所以有1000个类，也就代表了最后的mlp的输出层包含1000个节点
  10.                  ssm_cfg=None,                    #ssm的配置文件
  11.                  drop_rate=0.,                    #drop_rate是针对于dropout的频率（对某个节点进行失活的操作）
  12.                  drop_path_rate=0.1,              #drop_path_rate是针对drop_path的频率（对某个层进行失活的操作）
  13.                  norm_epsilon:float=1e-5,
  14.                  rms_norm:bool=False,             #是否使用rms_norm这种方法
  15.                  fused_add_norm=False,
  16.                  residual_in_fp32=False,          #残差链接的时候是不是浮点型
  17.                  device=None,
  18.                  dtype=None,
  19.                  pt_hw_seq_len=14,                #代表sequence的长度
  20.                  if_bidirectional=False,
  21.                  final_pool_type='none',          #最后池化层的类型
  22.                  if_abs_pos_embed=False,          #在位置编码的时候是不是需要用绝对值编码（有两种位置编码方式：1、直接给出的绝对值位置编码 2、可学习的位置编码）
  23.                  if_rope=False,                   #rope也是一种对positionembeding的特殊编码方式
  24.                  if_rope_residual=False,          #对 residual的rope 旨在增加鲁棒性
  25.                  flip_img_sequences_ratio=-1.,    #image_squence的反转概率
  26.                  if_bimamba=False,
  27.                  bimamba_type="none",             #表示使用的mamba的版本
  28.                  if_cls_token=False,              #拼不拼clstoken
  29.                  if_devide_out=False,
  30.                  init_layer_scale=None,
  31.                  use_double_cls_token=False,
  32.                  use_middle_cls_token=False,
  33.                  **kwargs):                       #为了保证模型的可扩展性所以加一个**kwargs
  34.         factory_kwargs = {"device": device, "dtype": dtype}
  35.         # add factory_kwargs into kwargs
  36.         kwargs.update(factory_kwargs)
  37.         super(VisionMamba,self).__init__()
  38.         self.residual_in_fp32 = residual_in_fp32
  39.         self.fused_add_norm = fused_add_norm
  40.         self.if_bidirectional = if_bidirectional
  41.         self.final_pool_type = final_pool_type
  42.         self.if_abs_pos_embed = if_abs_pos_embed
  43.         self.if_rope = if_rope
  44.         self.if_rope_residual = if_rope_residual
  45.         self.flip_img_sequences_ratio = flip_img_sequences_ratio
  46.         self.if_cls_token = if_cls_token
  47.         self.use_double_cls_token = use_double_cls_token            #这个拼接clstoken的方式是头拼一个尾拼一个
  48.         self.use_middle_cls_token = use_middle_cls_token            #这个拼接clstoken的方式是中间拼一个
  49.         self.num_tokens = 1 if if_cls_token else 0                  #表示拼了几个cls token进去？存疑
  50.  
  51.         # pretrain parameters
  52.         self.num_classes = num_classes
  53.         self.d_model = self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
  54.  
  55.         self.patch_embed = PatchEmbed(
  56.             img_size=img_size, patch_size=patch_size, stride=stride, in_channels=channels, embed_dim=embed_dim)
  57.         num_patches = self.patch_embed.num_patches
  58.  
  59.         if if_cls_token:                                            #如果使用cls token的话
  60.             if use_double_cls_token:
  61.                 self.cls_token_head = nn.Parameter(torch.zeros(1, 1, self.embed_dim))#拼在token序列最前面的clstoken
  62.                 self.cls_token_tail = nn.Parameter(torch.zeros(1, 1, self.embed_dim))#拼在token序列最后面的clstoken
  63.                 self.num_tokens = 2                                 #代表了拼了几个cls token
  64.             else:
  65.                 self.cls_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim))
  66.                 # self.num_tokens = 1
  67.  
  68.         if if_abs_pos_embed:                                         #如果使用给定的位置编码(给定绝对值)
  69.             self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, self.embed_dim))
  70.             self.pos_drop = nn.Dropout(p=drop_rate)
  71.  
  72.         #if if_rope:                                                  #Rope(Rotary Position Embedding)对于Position Embedding的翻转操作，（数据增强操作）
  73.         #    half_head_dim = embed_dim // 2
  74.         #    hw_seq_len = img_size // patch_size                      #高/宽方向的序列长度
  75.         #    self.rope = VisionRotaryEmbeddingFast(
  76.         #        dim=half_head_dim,
  77.         #        pt_seq_len=pt_hw_seq_len,
  78.         #        ft_seq_len=hw_seq_len
  79.         #    )
  80.         self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()             #这个是最终的分类头
  81.  
  82.         #drop path rate 随机失活一些东西，目的是让模型的鲁棒性更强，效果更好
  83.         dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  #构建从start到end的等距张量，目的是为每层网络设置独立的drop_path_rate
  84.         inter_dpr = [0.0] +dpr                                                   #第一层不需要dropout，所以要在最开始拼个0
  85.         self.drop_path = DropPath(drop_path_rate) if drop_path_rate > 0. else nn.Identity()
  86.  
  87.         self.layers = nn.ModuleList(
  88.             [
  89.                 create_block(#对VisionMamba的Encoder进行初始化的操作
  90.                     embed_dim,
  91.                     ssm_cfg=ssm_cfg,
  92.                     norm_epsilon=norm_epsilon,
  93.                     rms_norm=rms_norm,
  94.                     residual_in_fp32=residual_in_fp32,
  95.                     fused_add_norm=fused_add_norm,
  96.                     layer_idx=i,
  97.                     if_bimamba=if_bimamba,
  98.                     bimamba_type=bimamba_type,
  99.                     drop_path=inter_dpr[i],
  100.                     if_devide_out=if_devide_out,
  101.                     init_layer_scale=init_layer_scale,
  102.                     **factory_kwargs
  103.                 )
  104.                 for i in range(depth)
  105.             ]
  106.         )
  107.  
  108.         self.norm_f = (nn.LayerNorm if not rms_norm else RMSNorm)(embed_dim, eps=norm_epsilon,**factory_kwargs)
  109.         #trunc_normal_函数是一个用于对张量进行截断正态分布初始化的函数。它通常用于初始化神经网络的权重或偏置。
  110.         if if_abs_pos_embed:
  111.             trunc_normal_(self.pos_embed, std=.02)
  112.  
  113.         if if_cls_token:
  114.             if use_double_cls_token:
  115.                 trunc_normal_(self.cls_token_head, std=.02)
  116.                 trunc_normal_(self.cls_token_tail, std=.02)
  117.             else:
  118.                 trunc_normal_(self.cls_token, std=.02)
  119.  
  120.         #定义前向特征传播的方法
  121.     def forward_features(self, x,inference_params=None,
  122.                          if_random_cls_token_position=False,
  123.                          if_random_token_rank=False):
  124.         x = self.patch_embed(x)
  125.         B, M, _ = x.shape
  126.  
  127.         if self.if_cls_token:
  128.             if self.use_double_cls_token:                   #在序列前后拼double_cls_token
  129.                 cls_token_head = self.cls_token_head.expand(B, -1, -1)#expend 是共享内存的拓展 并不是创建新的张量
  130.                 cls_token_tail = self.cls_token_tail.expand(B, -1, -1)
  131.  
  132.                 token_position = [0, M+1]
  133.                 x = torch.cat((cls_token_head, x, cls_token_tail), dim=1)
  134.                 M = x.shape[1]
  135.  
  136.             else:
  137.                 if self.use_middle_cls_token:
  138.                     cls_token = self.cls_token.expand(B, -1, -1)
  139.                     token_position =M//2
  140.                     x = torch.cat((x[:,:token_position,:], cls_token, x[:,token_position:,:]), dim=1)
  141.                 elif if_random_cls_token_position:
  142.                     cls_token = self.cls_token.expand(B, -1, -1)
  143.                     token_position = random.randint(0,M)
  144.                     x = torch.cat((x[:,:token_position,:], cls_token, x[:,token_position:,:]), dim=1)
  145.                     print("token_position: ", token_position)
  146.                 else:
  147.                     cls_token = self.cls_token.expand(B, -1, -1)
  148.                     token_position = 0
  149.                     x = torch.cat((cls_token, x), dim=1)
  150.                 M = x.shape[1]
  151.  
  152.         if self.if_abs_pos_embed:
  153.             x= x+self.pos_embed
  154.             x = self.pos_drop(x)
  155.  
  156.         if if_random_token_rank:#是否要把所有的token序列打乱，如果打乱了的话自然要更新存储clstoken的位置
  157.  
  158.             #生成随机 shuffle索引
  159.             shuffle_indices = torch.randperm(M)#torch.randperm(M)是用于生成一个从0到M-1的随机排列的整数序列的函数。
  160.  
  161.             if isinstance(token_position, list):
  162.                 print("original value: ",x[0, token_position[0],0], x[0, token_position[1],0])
  163.             else:
  164.                 print("original value: ",x[0, token_position,0])
  165.             print("original token_position: ", token_position)
  166.  
  167.             #执行shuffle
  168.             x = x[:, shuffle_indices, :]
  169.  
  170.             if isinstance(token_position, list):
  171.                 new_token_position = [torch.where(shuffle_indices == token_position[i])[0].item() for i in range(len(token_position))]
  172.                 token_position = new_token_position
  173.             else:
  174.                 token_position = torch.where(shuffle_indices == token_position)[0].item()
  175.  
  176.             if isinstance(token_position, list):
  177.                 print("new value: ", x[0, token_position[0],0], x[0, token_position[1],0])
  178.             else:
  179.                 print("new value: ", x[0, token_position, 0])
  180.             print("new token_position: ", token_position)
  181.  
  182.         if_flip_img_suquences = False
  183.         if self.flip_img_sequences_ratio > 0 and (self.flip_img_sequences_ratio - random.random()) >1e-5:
  184.             x=x.flip([1])#会创建一个与张量 x 的形状相同的新张量，其中第一个维度的元素被翻转。翻转是指将第一个维度中的元素按相反的顺序重新排列。
  185.             if_flip_img_suquences = True
  186.  
  187.         #mamba的整体部分
  188.         residual = None
  189.         hidden_states = x
  190.         if not self.if_bidirectional:#只使用单向扫描（所以单向扫描就既可以选择正向单向扫描进行rope，也可以选择反向单项扫描进行rope）
  191.             for layer in self.layers:
  192.  
  193.                 if if_flip_img_suquences and self.if_rope:#反转序列并使用加强版的position Embedding
  194.                     hidden_states = hidden_states.flip([1])
  195.                     if residual is not None:
  196.                         residual = residual.flip([1])
  197.  
  198.                 #rope about
  199.                 if self.if_rope:
  200.                     hidden_states = self.rope(hidden_states)
  201.                     if residual is not None and self.if_rope_residuals:
  202.                         residual = self.rope(residual)
  203.  
  204.                 if if_flip_img_suquences and self.if_rope:#这里并不是跟上上段代码重复，而是filp了之后要再反转过来
  205.                     hidden_states = hidden_states.flip([1])
  206.                     if residual is not None:
  207.                         residual = residual.flip([1])
  208.  
  209.                 hidden_states, residual = layer(
  210.                     hidden_states, residual, inference_params=inference_params,
  211.                 )
  212.  
  213.         else:#如果采用双向扫描
  214.             for i in range(len(self.layers)//2):
  215.                 if self.if_rope:
  216.                     hidden_states = self.rope(hidden_states)
  217.                     if residual is not None and self.if_rope_residuals:
  218.                         residual = self.rope(residual)
  219.  
  220.                 hidden_states_f, residual_f = self.layers[i * 2](
  221.                     hidden_states, residual, inference_params=inference_params
  222.                 )
  223.                 hidden_state_b, residual_b = self.layers[i * 2 + 1](
  224.                     hidden_states.flip([1]),None if residual is None else residual.flip([1]),inference_params=inference_params
  225.                 )
  226.                 hidden_states = hidden_states_f + hidden_state_b.flip([1])
  227.                 residual = residual_f + residual_b.flip([1])
  228.  
  229.         if not self.fused_add_norm:#如果不使用fused_add_norm
  230.             if residual is None:#如果残差为空
  231.                 residual = hidden_states
  232.             else:#如果残差不为空
  233.                 residual = residual + self.drop_path(hidden_states)
  234.             hidden_states = self.norm_f(residual.to(dtype=self.norm_f.weight.dtype))
  235.         else:
  236.             fused_add_norm_fn = rms_norm_fn if isinstance(self.norm_f,RMSNorm) else layer_norm_fn
  237.             hidden_states = fused_add_norm_fn(
  238.                 self.drop_path(hidden_states),
  239.                 self.norm_f.weight,
  240.                 self.norm_f.bias,
  241.                 eps=self.norm_f.eps,
  242.                 residual=residual,
  243.                 prenorm=False,
  244.                 residual_in_fp32=self.residual_in_fp32,
  245.             )
  246.  
  247.         # return only cls token if it exists
  248.         if self.if_cls_token:
  249.             if self.use_double_cls_token:
  250.                 return (hidden_states[:,token_position[0],:] + hidden_states[:,token_position[1],:]) / 2
  251.             else:
  252.                 if self.use_middle_cls_token:
  253.                     return hidden_states[:,token_position,:]
  254.                 elif if_random_cls_token_position:
  255.                     return hidden_states[:,token_position,:]
  256.                 else:
  257.                     return hidden_states[:,token_position,:]
  258.  
  259.         if self.final_pool_type == 'none':
  260.             return hidden_states[:,-1,:]#这个切片是为了之后的mlp所做出的妥协
  261.         elif self.final_pool_type == 'mean':
  262.             return hidden_states.mean(dim=1)
  263.         elif self.final_pool_type == 'max':
  264.             return hidden_states
  265.         elif self.final_pool_type == 'all':
  266.             return hidden_states
  267.         else:
  268.             raise NotImplementedError
  269.  
  270.     def forward(self,x,return_features=False,inference_params=None,if_random_cls_token_position=False,if_random_token_rank=False):
  271.         x = self.forward_features(x,inference_params,if_random_cls_token_position = if_random_cls_token_position,if_random_token_rank = if_random_token_rank)
  272.         if return_features:
  273.             return x
  274.         x = self.head(x)
  275.         if self.final_pool_type == 'max':
  276.             x = x.max(dim=1)[0]
  277.         return x

3.4 测试

  1. def test():
  2.     device = 'cuda' if torch.cuda.is_available() else 'cpu'
  3.     model = VisionMamba(
  4.         patch_size=16,
  5.         embed_dim=192,
  6.         depth=24,
  7.         rms_norm=True,
  8.         residual_in_fp32=True,
  9.         fused_add_norm=True,
  10.         final_pool_type='mean',
  11.         if_abs_pos_embed=True,
  12.         if_rope=False,
  13.         if_rope_residual=False,
  14.         bimamba_type="V2",
  15.         if_cls_token=True,
  16.         if_device_out=True,
  17.         use_double_cls_token=True
  18.     ).to(device)
  19.  
  20.     x = torch.randn(size=(4,3,224,224)).to(device)
  21.     preds = model(x)
  22.     print(preds.shape)
  23.  
  24. if __name__ == '__main__':
  25.     test()

3.5 输出

参考文献

下个风口？Mamba手推公式&代码手搓_哔哩哔哩_bilibili

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/622867
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号