CV05_深度学习模块之间的缝合教学(1)

已于 2024-07-10 22:29:12 修改
阅读量1k 收藏 25
点赞数 27
分类专栏： 计算机视觉 文章标签： 深度学习 人工智能 cnn 机器学习 计算机视觉 目标检测 傅立叶分析
于 2024-07-10 22:26:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51605551/article/details/140331712
版权

1.1 在哪里缝

测试文件？（×）

训练文件？（×）

模型文件？（√）

1.2 骨干网络与模块缝合

以Vision Transformer为例，模型文件里有很多类，我们只在最后集大成的那个类里添加模块。

之后后，我们准备好我们要缝合的模块，比如SE Net模块，我们先建立一个测试文件测试能否跑通

import numpy as np
import torch
from torch import nn
from torch.nn import init

class SEAttention(nn.Module):
    # 初始化SE模块，channel为通道数，reduction为降维比率
    def __init__(self, channel=512, reduction=16):
        super().__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)  # 自适应平均池化层，将特征图的空间维度压缩为1x1
        self.fc = nn.Sequential(  # 定义两个全连接层作为激励操作，通过降维和升维调整通道重要性
            nn.Linear(channel, channel // reduction, bias=False),  # 降维，减少参数数量和计算量
            nn.ReLU(inplace=True),  # ReLU激活函数，引入非线性
            nn.Linear(channel // reduction, channel, bias=False),  # 升维，恢复到原始通道数
            nn.Sigmoid()  # Sigmoid激活函数，输出每个通道的重要性系数
        )

    # 权重初始化方法
    def init_weights(self):
        for m in self.modules():  # 遍历模块中的所有子模块
            if isinstance(m, nn.Conv2d):  # 对于卷积层
                init.kaiming_normal_(m.weight, mode='fan_out')  # 使用Kaiming初始化方法初始化权重
                if m.bias is not None:
                    init.constant_(m.bias, 0)  # 如果有偏置项，则初始化为0
            elif isinstance(m, nn.BatchNorm2d):  # 对于批归一化层
                init.constant_(m.weight, 1)  # 权重初始化为1
                init.constant_(m.bias, 0)  # 偏置初始化为0
            elif isinstance(m, nn.Linear):  # 对于全连接层
                init.normal_(m.weight, std=0.001)  # 权重使用正态分布初始化
                if m.bias is not None:
                    init.constant_(m.bias, 0)  # 偏置初始化为0

    # 前向传播方法
    def forward(self, x):
        b, c, _, _ = x.size()  # 获取输入x的批量大小b和通道数c
        y = self.avg_pool(x).view(b, c)  # 通过自适应平均池化层后，调整形状以匹配全连接层的输入
        y = self.fc(y).view(b, c, 1, 1)  # 通过全连接层计算通道重要性，调整形状以匹配原始特征图的形状
        return x * y.expand_as(x)  # 将通道重要性系数应用到原始特征图上，进行特征重新校准

# 示例使用
if __name__ == '__main__':
    input = torch.randn(50, 512, 7, 7)  # 随机生成一个输入特征图
    se = SEAttention(channel=512, reduction=8)  # 实例化SE模块，设置降维比率为8
    output = se(input)  # 将输入特征图通过SE模块进行处理
    print(output.shape)  # 打印处理后的特征图形状，验证SE模块的作用

打印处理后的形状，我们这里要注意，缝合模块时只需要注意第一维，也就是这个channel，要和骨干网络保持一致，只要你把输入输出的通道数对齐，那么这个通道数就可以缝合成功。

把模块复制进骨干网络中：

然后进行缝合，在缝合之前要先测试通道是否匹配，不然肯定报错。

如何验证通道数

我们找到骨干网络前向传播的部分，在你想加入这个模块地方print(x.shape)即可。运行训练文件：

放在最前面：

通道数为3（8为batch size）。

将模块添加进骨干网络

在骨干网络的init函数下添加：（ctrl+p可查看参数）通道数与之前查的对齐。

在前向传播中添加：

看看是否正常运行：

正常运行，说明模块缝合成功！

打印缝合后的模型结构

该操作在模型文件中进行。

VisionTransformer(
  (patch_embed): PatchEmbed(
    (proj): Conv2d(3, 768, kernel_size=(16, 16), stride=(16, 16))
    (norm): Identity()
  )
  (pos_drop): Dropout(p=0.0, inplace=False)
  (blocks): Sequential(
    (0): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (1): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (2): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (3): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (4): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (5): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (6): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (7): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (8): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (9): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (10): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
    (11): Block(
      (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (attn): Attention(
        (qkv): Linear(in_features=768, out_features=2304, bias=True)
        (attn_drop): Dropout(p=0.0, inplace=False)
        (proj): Linear(in_features=768, out_features=768, bias=True)
        (proj_drop): Dropout(p=0.0, inplace=False)
      )
      (drop_path): Identity()
      (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
      (mlp): Mlp(
        (fc1): Linear(in_features=768, out_features=3072, bias=True)
        (act): GELU()
        (fc2): Linear(in_features=3072, out_features=768, bias=True)
        (drop): Dropout(p=0.0, inplace=False)
      )
    )
  )
  (norm): LayerNorm((768,), eps=1e-06, elementwise_affine=True)
  (pre_logits): Sequential(
    (fc): Linear(in_features=768, out_features=768, bias=True)
    (act): Tanh()
  )
  (head): Linear(in_features=768, out_features=21843, bias=True)
  (se): SEAttention(
    (avg_pool): AdaptiveAvgPool2d(output_size=1)
    (fc): Sequential(
      (0): Linear(in_features=3, out_features=0, bias=False)
      (1): ReLU(inplace=True)
      (2): Linear(in_features=0, out_features=3, bias=False)
      (3): Sigmoid()
    )
  )
)

我们可以看到多了一个SEAttention,说明模块缝合进去了！

1.3 模块之间缝合

以SENet和ECA模块为例。

串联模块

方式1

同1.2。照猫画虎。（注意通道数保持一致）

打印模型结构：

ECAAttention(
  (gap): AdaptiveAvgPool2d(output_size=1)
  (conv): Conv1d(1, 1, kernel_size=(3,), stride=(1,), padding=(1,))
  (sigmoid): Sigmoid()
  (se): SEAttention(
    (avg_pool): AdaptiveAvgPool2d(output_size=1)
    (fc): Sequential(
      (0): Linear(in_features=64, out_features=4, bias=False)
      (1): ReLU(inplace=True)
      (2): Linear(in_features=4, out_features=64, bias=False)
      (3): Sigmoid()
   )))

 方式2

我们定义一个串联函数，将模块之间串联起来：

实例化查看一下模型结构

输出结果：

torch.Size([1, 63, 64, 64]) torch.Size([1, 63, 64, 64])
Cascade(
  (se): SEAttention(
    (avg_pool): AdaptiveAvgPool2d(output_size=1)
    (fc): Sequential(
      (0): Linear(in_features=63, out_features=3, bias=False)
      (1): ReLU(inplace=True)
      (2): Linear(in_features=3, out_features=63, bias=False)
      (3): Sigmoid()
    )
  )
  (eca): ECAAttention(
    (gap): AdaptiveAvgPool2d(output_size=1)
    (conv): Conv1d(1, 1, kernel_size=(63,), stride=(1,), padding=(31,))
    (sigmoid): Sigmoid()
  )
)

并联模块

对于并联模块，方法有很多种，两个两个模块输出的张量可以：

（1）逐元素相加（2）逐元素相乘（3）concat拼接（4）等等

输出结果：

torch.Size([1, 63, 64, 64]) torch.Size([1, 126, 64, 64])
Cascade(
  (se): SEAttention(
    (avg_pool): AdaptiveAvgPool2d(output_size=1)
    (fc): Sequential(
      (0): Linear(in_features=63, out_features=3, bias=False)
      (1): ReLU(inplace=True)
      (2): Linear(in_features=3, out_features=63, bias=False)
      (3): Sigmoid()
    )
  )
  (eca): ECAAttention(
    (gap): AdaptiveAvgPool2d(output_size=1)
    (conv): Conv1d(1, 1, kernel_size=(63,), stride=(1,), padding=(31,))
    (sigmoid): Sigmoid()
  )
)

1.4 思考 

我们不要拘泥于只串联获并联，可以将二者结合，多个模块中，部分模块并联后又与其他模块串联，等等。。这种排列组合之后，总会有一个你想要的模型！！！

江畔柳前堤
关注
  • 27
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
CV08_深度学习模块之间的缝合教学(3)--加载预训练权重
https://github.com/foxpup11?tab=repositories
07-13 876
https://www.bilibili.com/video/BV1zT421S7yg/?spm_id_from=333.999.0.0&vd_source=7dace3632125a1ef7fd32c285eb2fbac
CV09_深度学习模块之间的缝合教学(4)--调参
https://github.com/foxpup11?tab=repositories
07-14 488
https://www.bilibili.com/video/BV1cr421V7iS/?spm_id_from=333.999.0.0&vd_source=7dace3632125a1ef7fd32c285eb2fbac
CV07_深度学习模块之间的缝合教学(2)--维度转换
https://github.com/foxpup11?tab=repositories
07-12 1623
https://www.bilibili.com/video/BV1Cf421Z7Th/?spm_id_from=333.999.0.0&vd_source=7dace3632125a1ef7fd32c285eb2fbac
深度学习网络缝合模块学习
qq_45845375的博客
03-29 1094
模块和模块之间还可以，进行串行，并行等的连接，模块之间可以有很多组合方式。4在init中进行实例化，注意通道数是上一步forward的通道数。模块和模块之前也可用通过以上方式进行模块间的融合。5在forward中加载init中的实例化。3在forward中查看通道数是多少。6模型实例化测试模块是否加入。1缝合模块只看通道数。2把模块复制到模型中。
MATLAB深度学习简介.zip_deep learning_matlab_palacezk1_深度学习 matlab_深度学习
07-15
在计算机视觉中，CNNs被用于图像分类、目标检测和图像分割；在自然语言处理中，RNNs和变种如长短时记忆网络（LSTM）用于文本分类、机器翻译和情感分析；在语音识别中，深度学习模型如深度信念网络（DBN）和卷积神经...
cv实战链接.zip_深度学习_百度深度学习_视觉深度学习_计算机视觉 从CV基础到深度学习实战
07-14
计算机视觉（Computer Vision，简称CV）是一门多领域交叉学科，它涉及图像处理、机器学习、模式识别等技术，旨在让计算机系统理解并解释图像和视频数据。深度学习（Deep Learning）是机器学习的一个分支，它通过模拟...
cvd.zip_CVD_deep learning_深度学习_深度学习’_深度学习视觉
07-14
深度学习是一种人工智能领域的核心技术，它在计算机视觉（CV）领域有着广泛的应用，特别是在视觉场景识别上。本项目“cvd.zip”聚焦于深度学习在视觉理解中的应用，为用户提供了一套实用的代码库，帮助开发者和研究...
yzjcgui.rar_deep learning_叶子识别_深度学习_深度学习 识别_深度学习识别
07-14
标题中的“yzjcgui.rar_deep learning_叶子识别_深度学习_深度学习 识别_深度学习识别”揭示了这个压缩包内容的核心，它涉及到一个使用深度学习技术进行叶子识别的项目。这里的“yzjcgui”可能是指一个特定的图形...
fusion.zip_green31h_曝光融合_深度图像_深度学习 图像_深度学习融合
07-14
而“深度图像”通常指的是包含像素深度信息的图像，常用于3D重建或计算机视觉应用。“深度学习_图像”表明了深度学习在图像处理领域的应用，而“深度学习融合”则特指利用深度学习技术进行图像融合的过程。 压缩包...
Python代码，强化学习，深度学习
2401_85886655的博客
07-19 798
python代码编写，Python算法设计，强化学习优化，改进模型，训练模型，测试模型，可视化绘制，代编运行结果，交互多模型改进，预测模型，算法修改，Python包管理、数据分析、数据可视化、代码报错等等。Matlab代编，Python代编，神经网络，计算机视觉。问卷分析|数据查找！医学统计，回归分析，空间计量，神经网络。实证分析，事件分析，统计建模，面板模型。相关分析|生存分析，金融计量，各类算法。以上均可，个人保证高质量，保证效率。电子通信机器学习图像处理等。
GPU驱动、CUDA 、cuDNN 和CUDA Toolkit之间的关系（深度学习小白必懂）
weixin_44115575的博客
07-23 1015
GPU驱动、CUDA、cuDNN和CUDA Toolkit之间有着紧密的关系，它们共同构成了一个完整的GPU编程和深度学习开发环境。 在最初配置anaconda环境时一直搞不明白它们之间的关系。所以根据自己的理解，通俗详细解释它们各自的角色和相互间的关系，并且列举了一些在anaconda虚拟环境中的例子。 不对的地方希望大家指正。
昇思25天学习打卡营第20天 | LSTM+CRF序列标注
嫦娥妹妹等等我的博客
07-21 353
在自然语言处理（NLP）的领域中，序列标注是一个基础且关键的任务，涉及到从文本数据中提取有用信息，如命名实体识别（NER）、词性标注（POS）等。本次学习重点是探索如何结合长短时记忆网络（LSTM）和条件随机场（CRF）来执行序列标注任务，尤其是在命名实体识别上的应用。
昇思学习打卡-25-自然语言处理/RNN实现情感分类
最新发布
weixin_42630613的博客
07-23 760
昇思学习打卡-RNN实现情感分类
实时吸烟检测系统：基于深度学习与YOLO模型的完整实现
a871923942的博客
07-19 729
该系统包含一个用户界面，利用YOLO（You Only Look Once）v8/v7/v6/v5模型进行吸烟检测，并提供了完整的实现步骤和代码。本文介绍了一个基于深度学习的吸烟检测系统，详细描述了从数据收集和标注、模型训练、系统实现到用户界面设计的全过程。通过结合YOLO模型和PyQt5，我们可以实现一个实时、精确的吸烟检测系统，为公共场所的吸烟行为管理提供有力支持。为了训练一个高精度的吸烟检测模型，我们需要一个包含大量吸烟和非吸烟图片的数据集。利用训练好的模型进行吸烟检测，并实现视频流的实时检测。
《昇思25天学习打卡营第23天|RNN实现情感分类》
m0_58790800的博客
07-21 967
递归神经网络（RNN）是一种用于处理序列数据的神经网络，它通过隐藏状态（hidden state）将前一个时间步的信息传递到下一个时间步，从而捕捉序列中的依赖关系。尽管RNN在理论上可以处理任意长度的序列，但在实践中往往会遇到梯度消失和梯度爆炸问题，特别是在处理长序列时。RNN(循环神经网络)循环神经网络（Recurrent Neural Network, RNN）是一类以序列（sequence）数据为输入，在序列的演进方向进行递归（recursion）且所有节点（循环单元）按链式连接的神经网络。
Passing output of 3DCNN layer to LSTM layer
suiusoar
07-23 827
将3DCNN（三维卷积神经网络）层的输出传递给LSTM（长短期记忆网络）层
人工智能算法工程师(高级)课程5-图像生成项目之对抗生成模型与代码详解
weixin_42878111的博客
07-23 100
本文介绍了GAN、CGAN和DCGAN的数学原理，并通过PyTorch框架提供了完整的代码实现。通过这些代码，读者可以深入了解对抗生成模型的训练过程，并掌握图像生成的原理和技术。在实际应用中，这些模型可以用于图像合成、风格迁移、数据增强等多个领域。需要注意的是，训练GAN模型可能会遇到稳定性问题，因此在实际操作中可能需要调整超参数和模型结构以获得最佳效果。
基于深度学习的故障检测
weixin_42605076的博客
07-20 993
基于深度学习的故障检测是一项利用深度学习技术对设备、系统和结构的运行数据进行分析，以检测、识别和预测潜在故障的技术。其应用范围广泛，包括工业设备监控、制造系统故障检测、交通系统安全监测等。
Pytorch学习笔记——损失函数的综合运用
weixin_50765519的博客
07-19 980
结合之前的知识，构建一个简单的CNN模型来分类CIFAR-10数据集中的图像。输入和目标张量分别是。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值