Pytorch | 从零构建ParNet/Non-Deep Networks对CIFAR10进行分类

news2024/12/24 17:09:58

Pytorch | 从零构建ParNet/Non-Deep Networks对CIFAR10进行分类

  • CIFAR10数据集
  • ParNet
    • 架构特点
    • 优势
    • 应用
  • ParNet结构代码详解
    • 结构代码
    • 代码详解
      • SSE
      • ParNetBlock 类
      • DownsamplingBlock 类
      • FusionBlock 类
      • ParNet 类
  • 训练过程和测试结果
  • 代码汇总
    • parnet.py
    • train.py
    • test.py

前面文章我们构建了AlexNet、Vgg、GoogleNet、ResNet、MobileNet、EfficientNet对CIFAR10进行分类：
Pytorch | 从零构建AlexNet对CIFAR10进行分类
Pytorch | 从零构建Vgg对CIFAR10进行分类
Pytorch | 从零构建GoogleNet对CIFAR10进行分类
Pytorch | 从零构建ResNet对CIFAR10进行分类
Pytorch | 从零构建MobileNet对CIFAR10进行分类
Pytorch | 从零构建EfficientNet对CIFAR10进行分类
这篇文章我们来构建ParNet(Non-Deep Networks).

CIFAR10数据集

CIFAR-10数据集是由加拿大高级研究所（CIFAR）收集整理的用于图像识别研究的常用数据集，基本信息如下：

  • 数据规模：该数据集包含60,000张彩色图像，分为10个不同的类别，每个类别有6,000张图像。通常将其中50,000张作为训练集，用于模型的训练；10,000张作为测试集，用于评估模型的性能。
  • 图像尺寸：所有图像的尺寸均为32×32像素，这相对较小的尺寸使得模型在处理该数据集时能够相对快速地进行训练和推理，但也增加了图像分类的难度。
  • 类别内容：涵盖了飞机（plane）、汽车（car）、鸟（bird）、猫（cat）、鹿（deer）、狗（dog）、青蛙（frog）、马（horse）、船（ship）、卡车（truck）这10个不同的类别，这些类别都是现实世界中常见的物体，具有一定的代表性。

下面是一些示例样本：
在这里插入图片描述

ParNet

ParNet是一种高效的深度学习网络架构由谷歌研究人员于2021年提出，以下从其架构特点、优势及应用等方面进行详细介绍：

架构特点

  • 并行子结构：ParNet的核心在于其并行的子结构设计。它由多个并行的分支组成，每个分支都包含一系列的卷积层和池化层等操作。这些分支在网络中同时进行计算，就像多条并行的道路同时运输信息一样，大大提高了信息处理的效率。
  • 多尺度特征融合：不同分支在不同的尺度上对输入图像进行处理，然后将这些多尺度的特征进行融合。例如，一个分支可能专注于提取图像中的局部细节特征，而另一个分支则更擅长捕捉图像的全局上下文信息。通过融合这些不同尺度的特征，ParNet能够更全面、更准确地理解图像内容。
  • 深度可分离卷积：在网络的卷积操作中，大量使用了深度可分离卷积。这种卷积方式将传统的卷积操作分解为深度卷积和逐点卷积两个步骤，大大减少了计算量，同时提高了模型的运行速度，使其更适合在移动设备等资源受限的环境中应用。
    在这里插入图片描述

优势

  • 高效性：由于其并行结构和深度可分离卷积的使用，ParNet在计算效率上具有很大的优势。它可以在保证模型性能的前提下，大大减少模型的参数量和计算量，从而实现快速的推理和训练。
  • 灵活性：ParNet的并行子结构和多尺度特征融合方式使其具有很强的灵活性。它可以根据不同的任务和数据集进行调整和优化，轻松适应各种图像识别和处理任务。
  • 可扩展性：该网络架构具有良好的可扩展性，可以方便地增加或减少分支的数量和深度，以满足不同的性能需求。

应用

  • 图像分类：在图像分类任务中，ParNet能够快速准确地对图像中的物体进行分类。例如，在CIFAR-10和ImageNet等标准图像分类数据集上，ParNet取得了与现有先进模型相当的准确率，同时具有更快的推理速度。
  • 目标检测：在目标检测任务中，ParNet可以有效地检测出图像中的目标物体，并确定其位置和类别。通过对多尺度特征的融合和利用，ParNet能够更好地处理不同大小和形状的目标物体，提高检测的准确率和召回率。
  • 语义分割：在语义分割任务中，ParNet能够对图像中的每个像素进行分类，将图像分割成不同的语义区域。其多尺度特征融合的特点使得它在处理复杂的场景和物体边界时具有更好的效果，能够生成更准确的分割结果。

ParNet结构代码详解

结构代码

import torch
import torch.nn as nn
import torch.nn.functional as F

class SSE(nn.Module):
    def __init__(self, in_channels):
        super(SSE, self).__init__()
        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Linear(in_channels, in_channels)

    def forward(self, x):
        out = self.global_avgpool(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        out = torch.sigmoid(out)
        out = out.view(out.size(0), out.size(1), 1, 1)
        
        return x * out
    

class ParNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(ParNetBlock, self).__init__()
        self.branch1x1 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        self.branch3x3 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        self.sse = SSE(out_channels)

    def forward(self, x):
        branch1x1 = self.branch1x1(x)
        branch3x3 = self.branch3x3(x)
        out = branch1x1 + branch3x3
        out = self.sse(out)
        out = F.silu(out)

        return out
    

class DownsamplingBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DownsamplingBlock, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.se = SSE(out_channels)

    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        out = self.relu(out)
        out = self.se(out)

        return out
    

class FusionBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(FusionBlock, self).__init__()
        self.conv1x1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=2, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.se = SSE(out_channels)
        self.concat = nn.Conv2d(out_channels * 2, out_channels, kernel_size=1, bias=False)
    
    def forward(self, x1, x2):
        x1, x2 = self.conv1x1(x1), self.conv1x1(x2)
        x1, x2 = self.bn(x1), self.bn(x2)
        x1, x2 = self.relu(x1), self.relu(x2)
        x1, x2 = self.se(x1), self.se(x2)
        out = torch.cat([x1, x2], dim=1)
        out = self.concat(out)

        return out
    
class ParNet(nn.Module):
    def __init__(self, num_classes):
        super(ParNet, self).__init__()
        self.downsampling_blocks = nn.ModuleList([
            DownsamplingBlock(3, 64),
            DownsamplingBlock(64, 128),
            DownsamplingBlock(128, 256),
        ])

        self.streams = nn.ModuleList([
            nn.Sequential(
                ParNetBlock(64, 64),
                ParNetBlock(64, 64),
                ParNetBlock(64, 64),
                DownsamplingBlock(64, 128)
            ),
            nn.Sequential(
                ParNetBlock(128, 128),
                ParNetBlock(128, 128),
                ParNetBlock(128, 128),
                ParNetBlock(128, 128)
            ),
            nn.Sequential(
                ParNetBlock(256, 256),
                ParNetBlock(256, 256),
                ParNetBlock(256, 256),
                ParNetBlock(256, 256)
            )
        ])

        self.fusion_blocks = nn.ModuleList([
            FusionBlock(128, 256),
            FusionBlock(256, 256)
        ])

        self.final_downsampling = DownsamplingBlock(256, 1024)
        self.fc = nn.Linear(1024, num_classes)

    def forward(self, x):
        downsampled_features = []
        for i, downsampling_block in enumerate(self.downsampling_blocks):
            x = downsampling_block(x)
            downsampled_features.append(x)

        stream_features = []
        for i, stream in enumerate(self.streams):
            stream_feature = stream(downsampled_features[i])
            stream_features.append(stream_feature)

        fused_features = stream_features[0]
        for i in range(1, len(stream_features)):
            fused_features = self.fusion_blocks[i - 1](fused_features, stream_features[i])

        x = self.final_downsampling(fused_features)
        x = F.adaptive_avg_pool2d(x, (1, 1))
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x

代码详解

以下是对上述提供的ParNet代码的详细解释，这段代码使用PyTorch框架构建了一个名为ParNet的神经网络模型，整体结构符合ParNet网络架构的特点，下面从不同模块依次进行分析：

SSE

class SSE(nn.Module):
    def __init__(self, in_channels):
        super(SSE, self).__init__()
        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Linear(in_channels, in_channels)

    def forward(self, x):
        out = self.global_avgpool(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        out = torch.sigmoid(out)
        out = out.view(out.size(0), out.size(1), 1, 1)
        
        return x * out

  • 功能概述：
    这个类实现了类似Squeeze-and-Excitation（SE）模块的功能，旨在对输入特征进行通道维度的重加权，突出重要的通道特征，抑制相对不重要的通道特征。

  • __init__方法：

    • 首先通过nn.AdaptiveAvgPool2d(1)创建了一个自适应平均池化层，它可以将输入特征图在空间维度上压缩为大小为(1, 1)的特征图，也就是将每个通道的特征进行全局平均池化，得到通道维度上的统计信息，无论输入特征图的尺寸是多少都可以自适应处理。
    • 接着创建了一个全连接层nn.Linear(in_channels, in_channels)，其输入和输出维度都是in_channels，目的是学习通道维度上的变换权重。

  • forward方法：

    • 先将输入x经过全局平均池化层得到压缩后的特征表示out，然后通过view操作将其维度调整为二维形式（批次大小，通道数），方便后续全连接层处理。
    • 接着将这个特征送入全连接层进行线性变换，再经过sigmoid激活函数，将输出值映射到(0, 1)区间，得到每个通道对应的权重。
    • 最后将权重的维度调整回四维（批次大小，通道数，1，1），并与原始输入x进行逐元素相乘，实现对不同通道特征的重加权。

ParNetBlock 类

class ParNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(ParNetBlock, self).__init__()
        self.branch1x1 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        self.branch3x3 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        self.sse = SSE(out_channels)

    def forward(self, x):
        branch1x1 = self.branch1x1(x)
        branch3x3 = self.branch3x3(x)
        out = branch1x1 + branch3x3
        out = self.sse(out)
        out = F.silu(out)

        return out

  • 功能概述：
    该类定义了ParNet中的一个基础并行块结构，包含两个并行分支（1x1卷积分支和3x3卷积分支）以及一个SSE模块，用于提取和融合特征，并进行通道重加权和非线性激活。

  • __init__方法：

    • 构建了两个并行分支，branch1x1是一个由1x1卷积层、批归一化层和ReLU激活函数组成的序列，1x1卷积主要用于调整通道维度，同时可以融合不同通道间的信息，且计算量相对较小。
    • branch3x3同样是由3x3卷积层（带有合适的填充保证特征图尺寸不变）、批归一化层和ReLU激活函数组成，3x3卷积能够捕捉局部空间特征信息。
    • 最后实例化了一个SSE模块，用于后续对融合后的特征进行通道维度的重加权。

  • forward方法：

    • 首先将输入x分别送入两个并行分支进行处理，得到两个分支的输出branch1x1和branch3x3，然后将它们对应元素相加进行特征融合。
    • 接着把融合后的特征送入SSE模块进行通道重加权，最后使用F.silu（也就是swish函数）激活函数对结果进行非线性激活，并返回处理后的特征。

DownsamplingBlock 类

class DownsamplingBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DownsamplingBlock, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.se = SSE(out_channels)

    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        out = self.relu(out)
        out = self.se(out)

        return out

  • 功能概述：
    用于对输入特征图进行下采样操作，同时融合了批归一化、非线性激活以及类似SE的通道重加权功能，以减少特征图的空间尺寸并提取更抽象的特征。

  • __init__方法：
    创建了一个3x3卷积层，其步长设置为2，配合合适的填充，在进行卷积操作时可以实现特征图在空间维度上长宽各减半的下采样效果，同时调整通道维度到out_channels。还定义了批归一化层、ReLU激活函数以及一个SSE模块。

  • forward方法：
    按照顺序依次将输入x经过卷积层、批归一化层、ReLU激活函数进行处理，然后再通过SSE模块进行通道重加权，最终返回下采样并处理后的特征图。

FusionBlock 类

class FusionBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(FusionBlock, self).__init__()
        self.conv1x1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=2, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.se = SSE(out_channels)
        self.concat = nn.Conv2d(out_channels * 2, out_channels, kernel_size=1, bias=False)
    
    def forward(self, x1, x2):
        x1, x2 = self.conv1x1(x1), self.conv1x1(x2)
        x1, x2 = self.bn(x1), self.bn(x2)
        x1, x2 = self.relu(x1), self.relu(x2)
        x1, x2 = self.se(x1), self.se(x2)
        out = torch.cat([x1, x2], dim=1)
        out = self.concat(out)

        return out

  • 功能概述：
    该类用于融合不同分支或不同阶段的特征，通过一系列操作包括调整通道维度、批归一化、激活以及通道重加权，然后将两个特征在通道维度上进行拼接并进一步融合。

  • __init__方法：

    • 首先创建了1x1卷积层，步长设置为2，用于对输入的两个特征分别进行通道维度调整以及下采样操作（特征图空间尺寸减半）。
    • 接着定义了批归一化层、ReLU激活函数以及SSE模块，用于对下采样后的特征进行处理。还创建了一个1x1卷积层concat，用于将拼接后的特征进一步融合为指定的通道维度。

  • forward方法：
    分别对输入的两个特征x1和x2依次进行1x1卷积、批归一化、ReLU激活以及SSE模块的处理，然后将它们在通道维度上进行拼接（torch.cat操作，维度dim=1表示按通道维度拼接），最后通过concat卷积层将拼接后的特征融合为指定的通道维度，并返回融合后的特征。

ParNet 类

class ParNet(nn.Module):
    def __init__(self, num_classes):
        super(ParNet, self).__init__()
        self.downsampling_blocks = nn.ModuleList([
            DownsamplingBlock(3, 64),
            DownsamplingBlock(64, 128),
            DownsamplingBlock(128, 256),
        ])

        self.streams = nn.ModuleList([
            nn.Sequential(
                ParNetBlock(64, 64),
                ParNetBlock(64, 64),
                ParNetBlock(64, 64),
                DownsamplingBlock(64, 128)
            ),
            nn.Sequential(
                ParNetBlock(128, 128),
                ParNetBlock(128, 128),
                ParNetBlock(128, 128),
                ParNetBlock(128, 128)
            ),
            nn.Sequential(
                ParNetBlock(256, 256),
                ParNetBlock(256, 256),
                ParNetBlock(256, 256),
                ParNetBlock(256, 256)
            )
        ])

        self.fusion_blocks = nn.ModuleList([
            FusionBlock(128, 256),
            FusionBlock(256, 256)
        ])

        self.final_downsampling = DownsamplingBlock(256, 1024)
        self.fc = nn.Linear(1024, num_classes)

    def forward(self, x):
        downsampled_features = []
        for i, downsampling_block in enumerate(self.downsampling_blocks):
            x = downsampling_block(x)
            downsampled_features.append(x)

        stream_features = []
        for i, stream in enumerate(self.streams):
            stream_feature = stream(downsampled_features[i])
            stream_features.append(stream_feature)

        fused_features = stream_features[0]
        for i in range(1, len(stream_features)):
            fused_features = self.fusion_blocks[i - 1](fused_features, stream_features[i])

        x = self.final_downsampling(fused_features)
        x = F.adaptive_avg_pool2d(x, (1, 1))
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x

  • 功能概述：
    这是整个ParNet网络的定义类，整合了前面定义的各个模块，构建出完整的网络结构，包括下采样、并行分支处理、特征融合以及最后的分类全连接层等部分，能够接收输入图像数据并输出对应的分类预测结果。

  • __init__方法：

    • downsampling_blocks：通过nn.ModuleList创建了一个包含三个下采样块的列表，用于对输入图像依次进行下采样，将图像的空间尺寸逐步缩小，同时增加通道数，从最初的3通道（对应RGB图像）逐步变为64、128、256通道。
    • streams：同样是nn.ModuleList，定义了三个并行的流（stream），每个流由多个ParNetBlock和一个DownsamplingBlock组成，不同流在不同的特征图尺度和通道维度上进行特征提取和处理，每个流内部的ParNetBlock用于提取和融合局部特征，最后的DownsamplingBlock用于进一步下采样。
    • fusion_blocks：也是nn.ModuleList，包含两个特征融合块，用于融合不同流的特征，将各个流提取到的不同层次的特征进行融合，以综合利用多尺度信息。
    • final_downsampling：定义了一个下采样块，用于对融合后的特征再进行一次下采样，将通道数提升到1024，进一步提取更抽象的全局特征。
    • fc：创建了一个全连接层，用于将最终提取到的特征映射到指定的类别数量num_classes，实现图像分类任务的输出。

  • forward方法：

    • 首先，通过循环将输入x依次经过各个下采样块进行下采样，并将每次下采样后的特征保存到downsampled_features列表中，得到不同阶段下采样后的特征图。
    • 接着，针对每个流，将对应的下采样后的特征图送入流中进行处理，每个流内部的模块会进一步提取和融合特征，得到每个流输出的特征，并保存在stream_features列表中。
    • 然后，先取第一个流的特征作为初始的融合特征，再通过循环依次使用特征融合块将其他流的特征与已有的融合特征进行融合，不断更新融合特征。
    • 之后，将融合后的特征送入最后的下采样块进行进一步下采样处理。
    • 再通过自适应平均池化F.adaptive_avg_pool2d将特征图在空间维度上压缩为(1, 1)大小，然后使用view操作将其展平为二维向量。
    • 最后将展平后的特征送入全连接层进行分类预测，返回最终的分类结果。

总体而言，这段代码构建了一个符合ParNet架构特点的神经网络模型，通过多个模块的组合实现了高效的特征提取、融合以及分类功能，可应用于图像分类等相关任务。

训练过程和测试结果

训练过程损失函数变化曲线：
在这里插入图片描述

训练过程准确率变化曲线：
在这里插入图片描述

测试结果：
在这里插入图片描述

代码汇总

项目github地址
项目结构：

|--data
|--models
	|--__init__.py
	|-parnet.py
	|--...
|--results
|--weights
|--train.py
|--test.py

parnet.py

import torch
import torch.nn as nn
import torch.nn.functional as F

class SSE(nn.Module):
    def __init__(self, in_channels):
        super(SSE, self).__init__()
        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Linear(in_channels, in_channels)

    def forward(self, x):
        out = self.global_avgpool(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        out = torch.sigmoid(out)
        out = out.view(out.size(0), out.size(1), 1, 1)
        
        return x * out
    

class ParNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(ParNetBlock, self).__init__()
        self.branch1x1 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        self.branch3x3 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        self.sse = SSE(out_channels)

    def forward(self, x):
        branch1x1 = self.branch1x1(x)
        branch3x3 = self.branch3x3(x)
        out = branch1x1 + branch3x3
        out = self.sse(out)
        out = F.silu(out)

        return out
    

class DownsamplingBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DownsamplingBlock, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.se = SSE(out_channels)

    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        out = self.relu(out)
        out = self.se(out)

        return out
    

class FusionBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(FusionBlock, self).__init__()
        self.conv1x1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=2, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.se = SSE(out_channels)
        self.concat = nn.Conv2d(out_channels * 2, out_channels, kernel_size=1, bias=False)
    
    def forward(self, x1, x2):
        x1, x2 = self.conv1x1(x1), self.conv1x1(x2)
        x1, x2 = self.bn(x1), self.bn(x2)
        x1, x2 = self.relu(x1), self.relu(x2)
        x1, x2 = self.se(x1), self.se(x2)
        out = torch.cat([x1, x2], dim=1)
        out = self.concat(out)

        return out
    
class ParNet(nn.Module):
    def __init__(self, num_classes):
        super(ParNet, self).__init__()
        self.downsampling_blocks = nn.ModuleList([
            DownsamplingBlock(3, 64),
            DownsamplingBlock(64, 128),
            DownsamplingBlock(128, 256),
        ])

        self.streams = nn.ModuleList([
            nn.Sequential(
                ParNetBlock(64, 64),
                ParNetBlock(64, 64),
                ParNetBlock(64, 64),
                DownsamplingBlock(64, 128)
            ),
            nn.Sequential(
                ParNetBlock(128, 128),
                ParNetBlock(128, 128),
                ParNetBlock(128, 128),
                ParNetBlock(128, 128)
            ),
            nn.Sequential(
                ParNetBlock(256, 256),
                ParNetBlock(256, 256),
                ParNetBlock(256, 256),
                ParNetBlock(256, 256)
            )
        ])

        self.fusion_blocks = nn.ModuleList([
            FusionBlock(128, 256),
            FusionBlock(256, 256)
        ])

        self.final_downsampling = DownsamplingBlock(256, 1024)
        self.fc = nn.Linear(1024, num_classes)

    def forward(self, x):
        downsampled_features = []
        for i, downsampling_block in enumerate(self.downsampling_blocks):
            x = downsampling_block(x)
            downsampled_features.append(x)

        stream_features = []
        for i, stream in enumerate(self.streams):
            stream_feature = stream(downsampled_features[i])
            stream_features.append(stream_feature)

        fused_features = stream_features[0]
        for i in range(1, len(stream_features)):
            fused_features = self.fusion_blocks[i - 1](fused_features, stream_features[i])

        x = self.final_downsampling(fused_features)
        x = F.adaptive_avg_pool2d(x, (1, 1))
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x

train.py

test.py

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2264836.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【服务器】linux服务器管理员查看用户使用内存情况

【服务器】linux服务器管理员查看用户使用内存情况

【服务器】linux服务器管理员查看用户使用硬盘内存情况 1、查看所有硬盘内存使用情况 df -h2、查看硬盘挂载目录下所有用户内存使用情况 du -sh /public/*3、查看某个用户所有文件夹占用硬盘内存情况 du -sh /public/zhangsan/*
阅读更多...
[搜广推]王树森推荐系统——其他召回通道

[搜广推]王树森推荐系统——其他召回通道

地理位置召回 GeoHash召回 想法：用户可能对附近发生的事感兴趣 方法：对经纬度的编码，地图上一个长方形区域 索引：GeoHash -> 优质笔记列表(按时间倒排) 这条召回通道没有个性化 同城召回 想法：用户可能对同…
阅读更多...
重温设计模式--外观模式

重温设计模式--外观模式

文章目录 外观模式（Facade Pattern）概述定义 外观模式UML图作用 外观模式的结构C 代码示例1C代码示例2总结 外观模式（Facade Pattern）概述 定义 外观模式是一种结构型设计模式，它为子系统中的一组接口提供了一个统一…
阅读更多...
OpenCV学习——图像融合

OpenCV学习——图像融合

import cv2 as cv import cv2 as cvbg cv.imread("test_images/background.jpg", cv.IMREAD_COLOR) fg cv.imread("test_images/forground.png", cv.IMREAD_COLOR)# 打印图片尺寸 print(bg.shape) print(fg.shape)resize_size (1200, 800)bg cv.resize…
阅读更多...
ECharts热力图-笛卡尔坐标系上的热力图，附视频讲解与代码下载

ECharts热力图-笛卡尔坐标系上的热力图，附视频讲解与代码下载

引言： 热力图（Heatmap）是一种数据可视化技术，它通过颜色的深浅变化来表示数据在不同区域的分布密集程度。在二维平面上，热力图将数据值映射为颜色，通常颜色越深表示数据值越大，颜色越浅表示数…
阅读更多...
进程间关系与守护进程

进程间关系与守护进程

个人主页：C忠实粉丝 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 C忠实粉丝 原创 进程间关系与守护进程 收录于专栏[Linux学习] 本专栏旨在分享学习Linux的一点学习笔记，欢迎大家在评论区交流讨论💌 目录 1. 进程组 什…
阅读更多...
LightGBM分类算法在医疗数据挖掘中的深度探索与应用创新(上)

LightGBM分类算法在医疗数据挖掘中的深度探索与应用创新(上)

一、引言 1.1 医疗数据挖掘的重要性与挑战 在当今数字化医疗时代，医疗数据呈爆炸式增长，这些数据蕴含着丰富的信息，对医疗决策具有极为重要的意义。通过对医疗数据的深入挖掘，可以发现潜在的疾病模式、治疗效果关联以及患者的健康风险因素，从而为精准医疗、个性化治疗方…
阅读更多...
【文档搜索引擎】缓冲区优化和索引模块小结

【文档搜索引擎】缓冲区优化和索引模块小结

开机之后，首次制作索引会非常慢，但后面就会快了 重启机器，第一次制作又会非常慢 这是为什么呢？ 在 parserContent 里面，我们进行了一个读文件的操作 计算机读取文件，是一个开销比较大的操作， …
阅读更多...
html+css网页设计 旅游 移动端 雪花旅行社4个页面

html+css网页设计 旅游 移动端 雪花旅行社4个页面

htmlcss网页设计 旅游 移动端 雪花旅行社4个页面 网页作品代码简单，可使用任意HTML辑软件（如：Dreamweaver、HBuilder、Vscode 、Sublime 、Webstorm、Text 、Notepad 等任意html编辑软件进行运行及修改编辑等操作）。 获取源码 …
阅读更多...
3 JDK 常见的包和BIO,NIO,AIO

3 JDK 常见的包和BIO,NIO,AIO

JDK常见的包 java.lang:系统基础类 java.io:文件操作相关类，比如文件操作 java.nio:为了完善io包中的功能，提高io性能而写的一个新包 java.net:网络相关的包 java.util:java辅助类，特别是集合类 java.sql:数据库操作类 IO流 按照流的流向分…
阅读更多...
从零创建一个 Django 项目

从零创建一个 Django 项目

1. 准备环境 在开始之前，确保你的开发环境满足以下要求： 安装了 Python (推荐 3.8 或更高版本)。安装 pip 包管理工具。如果要使用 MySQL 或 PostgreSQL，确保对应的数据库已安装。 创建虚拟环境 在项目目录中创建并激活虚拟环境&#xff…
阅读更多...
ubuntu20.04安装imwheel实现鼠标滚轮调速

ubuntu20.04安装imwheel实现鼠标滚轮调速

ubuntu20.04安装imwheel实现鼠标滚轮调速 Ubuntu 系统自带的设置中仅具备调节鼠标速度的功能，而无调节鼠标滚轮速度的功能。其默认的鼠标滚轮速度较为缓慢，在查看文档时影响尚可接受，但在快速浏览网页时，滚轮速度过慢会给用户带来…
阅读更多...
GitLab的安装与卸载

GitLab的安装与卸载

目录 GitLab安装 GitLab使用 使用前可选操作 修改web端口 修改Prometheus端口 使用方法 GitLab的卸载 环境说明 系统版本 CentOS 7.2 x86_64 软件版本 gitlab-ce-10.8.4 GitLab安装 Gitlab的rpm包集成了它需要的软件，简化了安装步骤，所以直接…
阅读更多...
简单工厂模式和策略模式的异同

简单工厂模式和策略模式的异同

文章目录 简单工厂模式和策略模式的异同相同点：不同点：目的：结构： C 代码示例简单工厂模式示例（以创建图形对象为例）策略模式示例（以计算价格折扣策略为例）UML区别 简单工厂模式和策…
阅读更多...
脑肿瘤检测数据集，对9900张原始图片进行YOLO，COCO，VOC格式的标注

脑肿瘤检测数据集，对9900张原始图片进行YOLO，COCO，VOC格式的标注

脑肿瘤检测数据集，对9900张原始图片进行YOLO，COCO，VOC格式的标注 数据集分割 训练组 70％ 6930图片 有效集 20％ 1980图片 测试集 10％ 990图片 预处理 静态裁剪： 24-82&…
阅读更多...
YOLOv8 | 训练自定义数据集

YOLOv8 | 训练自定义数据集

目录 1 处理数据集1.1 数据集格式介绍1.2 划分数据集1.3 在 YOLOv8 中配置数据集 2 训练 YOLOv8 模型2.1 模型训练代码2.2 开启 TensorBoard 若尚未部署 YOLOv8，则可参考这篇博客： YOLOv8 | Windows 系统下从零开始搭建 YOLOv8 项目环境 1 处理…
阅读更多...
Java设计模式 —— 【结构型模式】外观模式详解

Java设计模式 —— 【结构型模式】外观模式详解

文章目录 概述结构案例实现优缺点 概述 外观模式又名门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这…
阅读更多...
可编辑99PPT | 智能工厂整体规划方案及实施细部方案

可编辑99PPT | 智能工厂整体规划方案及实施细部方案

荐言分享：智能工厂是利用物联网、大数据、人工智能等先进技术，实现生产过程自动化、智能化和柔性化的现代工厂。本整体规划方案旨在通过整合信息技术、自动化技术、人工智能技术和物联网技术，构建一个高效、灵活、绿色、可持续的生产环境&…
阅读更多...
Allegro17.4创建异形焊盘速通

Allegro17.4创建异形焊盘速通

Allegro17.4创建异形焊盘速通 打开Padstack Editor 17.4，新建焊盘，以标贴焊盘为例: 该标贴焊盘是在底面，选择END LAYRE ，选择 Shape symbol Geometry，Shape symbol选择框右边有选择键，跳到Library Shape S…
阅读更多...
多行为级联24|多行为推荐的超图增强级联图卷积网络

多行为级联24|多行为推荐的超图增强级联图卷积网络

挂到arxiv上的，多行为级联超图加对比学习,超图是针对单个行为的，而不是针对多个行为的。参考的类似工作是CRGCN加MBSSL。这两篇我都做了论文阅读，（CRGCN正在路上，MBSSL是我的第一篇论文阅读帖子）推荐系统论…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023