实验笔记之——基于CARN的Octave Convolution实验记录

最新推荐文章于 2024-08-16 08:32:01 发布
最新推荐文章于 2024-08-16 08:32:01 发布
阅读量2.1k 收藏 17
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwplovekimi/article/details/89787538
版权

本博文跟上一篇博文《实验笔记之——基于SRResNet的Octave Convolution实验记录》类似，只是改为CARN的结构。用octave convolution代替传统的convolution

给出CARN的代码https://github.com/nmhkahn/CARN-pytorch

论文https://arxiv.org/pdf/1803.08664.pdf

 

理论

作者主要围绕轻量级来论述本文。CARN（Cascading Residual Network，级联残差网络）

它具有以下三个特征：

  1. 全局和局部级联连接
  2. 中间特征是级联的，且被组合在1×1大小的卷积块中
  3. 使多级表示和快捷连接，让信息传递更高效

为了提升CARN的效率，作者提出了一种残差-E模块。就是将普通的Residual Block中conv换成了group conv。作者在这里提出了使用group conv而是不是 depthwise convolution，作者解释说group conv比 depthwise convolution可以更好的调整模型的有效性。关于group conv和depthwise conv可以参考博文《各种卷积层的理解（深度可分离卷积、分组卷积、扩张卷积、反卷积）》 为了进一步减少模型的参数，作者使用了recursive network，让网络的参数进行共享。

 

在局部和全局使用级联的好处如下：

  1. 结合多层的特征，可以学习到多水平的表示。
  2. 级联可以让低层的特征很快的传播到高层。

 

参考材料

https://blog.csdn.net/alxe_made/article/details/85839802

https://blog.csdn.net/Chaolei3/article/details/79374563

https://zhuanlan.zhihu.com/p/28749411

https://zybuluo.com/hanbingtao/note/626300

实验

CARN

residual block与E residual block

class BasicBlock(nn.Module):
    def __init__(self,
                 in_channels, out_channels,
                 ksize=3, stride=1, pad=1):
        super(BasicBlock, self).__init__()

        self.body = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, ksize, stride, pad),
            nn.ReLU(inplace=True)
        )

        init_weights(self.modules)
        
    def forward(self, x):
        out = self.body(x)
        return out


class ResidualBlock(nn.Module):
    def __init__(self, 
                 in_channels, out_channels):
        super(ResidualBlock, self).__init__()

        self.body = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, 1, 1),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 3, 1, 1),
        )

        init_weights(self.modules)
        
    def forward(self, x):
        out = self.body(x)
        out = F.relu(out + x)
        return out


class EResidualBlock(nn.Module):
    def __init__(self, 
                 in_channels, out_channels,
                 group=1):
        super(EResidualBlock, self).__init__()

        self.body = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, 1, 1, groups=group),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 3, 1, 1, groups=group),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 1, 1, 0),
        )

        init_weights(self.modules)
        
    def forward(self, x):
        out = self.body(x)
        out = F.relu(out + x)
        return out

先复现CARN，给出网络结构如下：

##############################################################################################
#CARN
class CARN(nn.Module):#nb=3(3 block),channel=24
    def __init__(self, in_nc, out_nc, nf=24, nc=4, nb=3, alpha=0.75, upscale=4, norm_type='batch', act_type='relu', \
            mode='NAC', res_scale=1, upsample_mode='upconv'):
        super(CARN, self).__init__()
        n_upscale = int(math.log(upscale, 2))
        if upscale == 3:
            n_upscale = 1

        self.nb = nb

        self.fea_conv =B.conv_block(in_nc, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)

        self.CascadeBlocks = nn.ModuleList([B.CascadeBlock(nf, nf, kernel_size=3, norm_type=norm_type, \
            act_type=act_type, mode=mode, res_scale=res_scale) for _ in range(nb)])
        self.CatBlocks = nn.ModuleList([B.conv_block((i + 2)*nf, nf, kernel_size=1, \
            norm_type=norm_type, act_type=act_type, mode=mode) for i in range(nb)])
        self.P_conv = B.conv_block(nf, in_nc*(upscale ** 2), kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)

        self.upsampler = nn.PixelShuffle(upscale)



    def forward(self, x):
        x = self.fea_conv(x)
        pre_fea = x
        for i in range(self.nb):
            res = self.CascadeBlocks[i](x)
            pre_fea = torch.cat((pre_fea, res), dim=1)
            x = self.CatBlocks[i](pre_fea)
        x = self.P_conv(x)
        x = F.sigmoid(self.upsampler(x))
        return x


##############################################################################################
class CascadeBlock(nn.Module):
    """
    CascadeBlock, 3-3 style
    """

    def __init__(self, nc, gc, kernel_size=3, stride=1, dilation=1, groups=1, \
            bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA', res_scale=1):
        super(CascadeBlock, self).__init__()
        self.nc = nc
        self.ResBlocks = nn.ModuleList([ResNetBlock(gc, gc, gc, kernel_size, stride, dilation, groups, bias, \
            pad_type, norm_type, act_type, mode, res_scale) for _ in range(nc)])
        self.CatBlocks = nn.ModuleList([conv_block((i + 2)*gc, gc, kernel_size=1, bias=bias, pad_type=pad_type, \
            norm_type=norm_type, act_type=act_type, mode=mode) for i in range(nc)])

    def forward(self, x):
        pre_fea = x
        for i in range(self.nc):
            res = self.ResBlocks[i](x)
            pre_fea = torch.cat((pre_fea, res), dim=1)
            x = self.CatBlocks[i](pre_fea)
        return x

训练的setting

{
  "name": "carn_DIV2K_baseline" //  please remove "debug_" during training
  , "tb_logger_dir": "octave"
  , "use_tb_logger": true
  , "model":"sr"
  , "scale": 4
  , "crop_scale": 0
  , "gpu_ids": [0,1,2,3]
//  , "init_type": "kaiming"
//
//  , "finetune_type": "sft"
//  , "init_norm_type": "zero"

  , "datasets": {
    "train": {
      "name": "DIV2K800"
      , "mode": "LRHR"
      , "dataroot_HR": "/media/sdc/wpguan/BasicSR_datasets/DIV2K800_sub"
      , "dataroot_LR": "/media/sdc/wpguan/BasicSR_datasets/DIV2K800_sub_bicLRx4"
      , "subset_file": null
      , "use_shuffle": true
      , "n_workers": 8
      , "batch_size": 16 // 16
      , "HR_size": 128 // 128 | 192 | 96
      , "noise_gt": true
      , "use_flip": true
      , "use_rot": true
    }

  , "val": {
      "name": "set5"
      , "mode": "LRHR"
      , "dataroot_HR": "/media/sdc/wpguan/BasicSR_datasets/val_set5/Set5/"
      , "dataroot_LR": "/media/sdc/wpguan/BasicSR_datasets/val_set5/Set5_bicLRx4/"
      , "noise_gt": false
    }

  }

  , "path": {
    "root": "/home/wpguan/SR_master/octave"
    , "pretrain_model_G": null
  }


//
  , "network_G": {
    "which_model_G": "carn" // RRDB_net | sr_resnet | modulate_denoise_resnet |noise_subnet  octave_resnet, octave_carn
//    , "norm_type": "adaptive_conv_res"
    , "norm_type": null
    , "mode": "CNA"
    , "nf": 24//24//64
    , "nb": 3//3//16
    , "in_nc": 3
    , "out_nc": 3
//    , "gc": 32
    , "group": 1
//    , "gate_conv_bias": true
//    , "ada_ksize": 1
//    , "num_classes": 2
  }


//    , "network_G": {
//    "which_model_G": "srcnn" // RRDB_net | sr_resnet
    , "norm_type": null
//    , "norm_type": "adaptive_conv_res"
//    , "mode": "CNA"
//    , "nf": 64
//    , "in_nc": 1
//    , "out_nc": 1
//    , "ada_ksize": 5
//  }


  , "train": {
//    "lr_G": 1e-3
    "lr_G": 8e-4
    , "lr_scheme": "MultiStepLR"
    , "lr_steps": [210000, 350000, 500000]
//    , "lr_steps": [500000]
    , "lr_gamma": 0.5


    , "pixel_criterion": "l2"

    , "pixel_criterion_reg": "tv"

    , "pixel_weight": 1.0
    , "val_freq": 1e3

    , "manual_seed": 0
    , "niter": 6e5
  }

  , "logger": {
    "print_freq": 200
    , "save_checkpoint_freq": 1e3
  }
}

结果：

 

 

 

octave_CARN

再给出octave_carn网络的结构：

##############################################################################################
#Octave CARN
class Octave_CARN(nn.Module):#nb=3(3 block),channel=24
    def __init__(self, in_nc, out_nc, nf=24, nc=4, nb=3, alpha=0.75, upscale=4, norm_type='batch', act_type='relu', \
            mode='NAC', res_scale=1, upsample_mode='upconv'):
        super(Octave_CARN, self).__init__()
        n_upscale = int(math.log(upscale, 2))
        if upscale == 3:
            n_upscale = 1

        self.nb = nb

        self.fea_conv =B.conv_block(in_nc, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)
        self.oct_first=B.FirstOctaveConv(nf, nf, kernel_size=3,  alpha=alpha, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA')
        self.CascadeBlocks = nn.ModuleList([B.OctaveCascadeBlock(nc, nf, kernel_size=3, alpha=alpha, \
            norm_type=norm_type, act_type=act_type, mode=mode, res_scale=res_scale) for _ in range(nb)])
        self.CatBlocks = nn.ModuleList([B.OctaveConv((i + 2)*nf, nf, kernel_size=1, alpha=alpha, \
            norm_type=norm_type, act_type=act_type, mode=mode) for i in range(nb)])
        self.oct_last = B.LastOctaveConv(nf, nf, kernel_size=3, alpha=alpha, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA')

        self.upsampler = nn.PixelShuffle(upscale)
        self.HR_conv1 = B.conv_block(nf, in_nc*(upscale ** 2), kernel_size=3, norm_type=None, act_type=None)


    def forward(self, x):
        x = self.fea_conv(x)
        x = self.oct_first(x)
        pre_fea = x
        for i in range(self.nb):
            res = self.CascadeBlocks[i](x)
            pre_fea = (torch.cat((pre_fea[0], res[0]), dim=1), \
                        torch.cat((pre_fea[1], res[1]), dim=1))
            x = self.CatBlocks[i](pre_fea)
        x = self.oct_last(x)
        x = self.HR_conv1(x)
        x = F.sigmoid(self.upsampler(x))
        return x


##############################################################################################
####################
class OctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.7, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(OctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        self.stride = stride

        self.l2l = nn.Conv2d(int(alpha * in_nc), int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.l2h = nn.Conv2d(int(alpha * in_nc), out_nc - int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2l = nn.Conv2d(in_nc - int(alpha * in_nc), int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2h = nn.Conv2d(in_nc - int(alpha * in_nc), out_nc - int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, int(out_nc*(1 - alpha))) if norm_type else None
        self.n_l = norm(norm_type, int(out_nc*alpha)) if norm_type else None

    def forward(self, x):
        X_h, X_l = x

        if self.stride ==2:
            X_h, X_l = self.h2g_pool(X_h), self.h2g_pool(X_l)

        X_h2h = self.h2h(X_h)
        X_l2h = self.upsample(self.l2h(X_l))
        X_l2l = self.l2l(X_l)
        X_h2l = self.h2l(self.h2g_pool(X_h))
        
        #print(X_l2h.shape,"~~~~",X_h2h.shape)
        X_h = X_l2h + X_h2h
        X_l = X_h2l + X_l2l

        if self.n_h and self.n_l:
            X_h = self.n_h(X_h)
            X_l = self.n_l(X_l)

        if self.a:
            X_h = self.a(X_h)
            X_l = self.a(X_l)

        return X_h, X_l


class FirstOctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.7, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(FirstOctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
        self.stride = stride
        self.h2l = nn.Conv2d(in_nc, int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2h = nn.Conv2d(in_nc, out_nc - int(alpha * out_nc),
                                kernel_size, 1, padding, dilation, groups, bias)
        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, int(out_nc*(1 - alpha))) if norm_type else None
        self.n_l = norm(norm_type, int(out_nc*alpha)) if norm_type else None

    def forward(self, x):
        if self.stride ==2:
            x = self.h2g_pool(x)

        X_h = self.h2h(x)
        X_l = self.h2l(self.h2g_pool(x))

        if self.n_h and self.n_l:
            X_h = self.n_h(X_h)
            X_l = self.n_l(X_l)

        if self.a:
            X_h = self.a(X_h)
            X_l = self.a(X_l)

        return X_h, X_l


class LastOctaveConv(nn.Module):
    def __init__(self, in_nc, out_nc, kernel_size, alpha=0.7, stride=1, dilation=1, groups=1, \
                    bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA'):
        super(LastOctaveConv, self).__init__()
        assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
        padding = get_valid_padding(kernel_size, dilation) if pad_type == 'zero' else 0
        self.h2g_pool = nn.AvgPool2d(kernel_size=(2,2), stride=2)
        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        self.stride = stride

        self.l2h = nn.Conv2d(int(alpha * in_nc), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)
        self.h2h = nn.Conv2d(in_nc - int(alpha * in_nc), out_nc,
                                kernel_size, 1, padding, dilation, groups, bias)

        self.a = act(act_type) if act_type else None
        self.n_h = norm(norm_type, out_nc) if norm_type else None

    def forward(self, x):
        X_h, X_l = x

        if self.stride ==2:
            X_h, X_l = self.h2g_pool(X_h), self.h2g_pool(X_l)
        
        X_h2h = self.h2h(X_h)
        X_l2h = self.upsample(self.l2h(X_l))
        
        X_h = X_h2h + X_l2h

        if self.n_h:
            X_h = self.n_h(X_h)

        if self.a:
            X_h = self.a(X_h)

        return X_h

class OctaveCascadeBlock(nn.Module):
    """
    OctaveCascadeBlock, 3-3 style
    """
    def __init__(self, nc, gc, kernel_size=3, alpha=0.7, stride=1, dilation=1, groups=1, \
            bias=True, pad_type='zero', norm_type=None, act_type='prelu', mode='CNA', res_scale=1):
        super(OctaveCascadeBlock, self).__init__()
        self.nc = nc
        self.ResBlocks = nn.ModuleList([OctaveResBlock(gc, gc, gc, kernel_size, alpha, stride, dilation, \
            groups, bias, pad_type, norm_type, act_type, mode, res_scale) for _ in range(nc)])
        self.CatBlocks = nn.ModuleList([OctaveConv((i + 2)*gc, gc, kernel_size=1, alpha=alpha, bias=bias, \
            pad_type=pad_type, norm_type=norm_type, act_type=act_type, mode=mode) for i in range(nc)])

    def forward(self, x):
        pre_fea = x
        for i in range(self.nc):
            res = self.ResBlocks[i](x)
            pre_fea = (torch.cat((pre_fea[0], res[0]), dim=1), \
                        torch.cat((pre_fea[1], res[1]), dim=1))
            x = self.CatBlocks[i](pre_fea)
        return x

给出setting：

{
  "name": "octave_carn_DIV2K_alpha0.75" //  please remove "debug_" during training
  , "tb_logger_dir": "octave"
  , "use_tb_logger": true
  , "model":"sr"
  , "scale": 4
  , "crop_scale": 0
  , "gpu_ids": [0,3]
//  , "init_type": "kaiming"
//
//  , "finetune_type": "sft"
//  , "init_norm_type": "zero"

  , "datasets": {
    "train": {
      "name": "DIV2K800"
      , "mode": "LRHR"
      , "dataroot_HR": "/media/sdc/wpguan/BasicSR_datasets/DIV2K800_sub"
      , "dataroot_LR": "/media/sdc/wpguan/BasicSR_datasets/DIV2K800_sub_bicLRx4"
      , "subset_file": null
      , "use_shuffle": true
      , "n_workers": 8
      , "batch_size": 16 // 16
      , "HR_size": 128 // 128 | 192 | 96
      , "noise_gt": true
      , "use_flip": true
      , "use_rot": true
    }

  , "val": {
      "name": "set5"
      , "mode": "LRHR"
      , "dataroot_HR": "/media/sdc/wpguan/BasicSR_datasets/val_set5/MSet5"
      , "dataroot_LR": "/media/sdc/wpguan/BasicSR_datasets/val_set5/MSet5_bicLRx4"
      , "noise_gt": false
    }

  }

  , "path": {
    "root": "/home/wpguan/SR_master/octave"
    , "pretrain_model_G": null
  }


//
  , "network_G": {
    "which_model_G": "octave_carn" // RRDB_net | sr_resnet | modulate_denoise_resnet |noise_subnet  octave_resnet, octave_carn
//    , "norm_type": "adaptive_conv_res"
    , "norm_type": null
    , "mode": "CNA"
    , "nf": 24//64
    , "nb": 3//16
    , "in_nc": 3
    , "out_nc": 3
//    , "gc": 32
    , "group": 1
//    , "gate_conv_bias": true
//    , "ada_ksize": 1
//    , "num_classes": 2
  }


//    , "network_G": {
//    "which_model_G": "srcnn" // RRDB_net | sr_resnet
    , "norm_type": null
//    , "norm_type": "adaptive_conv_res"
//    , "mode": "CNA"
//    , "nf": 64
//    , "in_nc": 1
//    , "out_nc": 1
//    , "ada_ksize": 5
//  }


  , "train": {
//    "lr_G": 1e-3
    "lr_G": 6e-4
    , "lr_scheme": "MultiStepLR"
    , "lr_steps": [200000, 400000, 600000, 800000]
//    , "lr_steps": [500000]
    , "lr_gamma": 0.5


    , "pixel_criterion": "l2"

    , "pixel_criterion_reg": "tv"

    , "pixel_weight": 1.0
    , "val_freq": 1e3

    , "manual_seed": 0
    , "niter": 1e6
  }

  , "logger": {
    "print_freq": 200
    , "save_checkpoint_freq": 1e3
  }
}

结果如下图所示

 

实验python train.py -opt options/train/train_sr.json

先激活虚拟环境source activate pytorch

tensorboard --logdir tb_logger/ --port 6008

浏览器打开http://172.20.36.203:6008/#scalars
(拿到新的服务器~重新跑实验~)

 

 

 

 

 

 

gwpscut
关注
专栏目录
【图像超分】论文精读：Fast, Accurate, and Lightweight Super-Resolution with Cascading Residual Network（CARN）
畅游计算机视觉的海洋
05-25 594
近年来，深度学习方法已成功应用于单图像超分辨率任务。尽管深度学习方法具有出色的性能，但由于计算量大，不能轻易应用于实际应用。在本文中，我们通过提出一种精确、轻量级的图像超分辨率深度网络来解决这个问题。具体来说，我们设计了一种在残差网络上实现级联机制的架构。我们还提出了所提出的级联残差网络的变体模型，以进一步提高效率。我们广泛的实验表明，即使参数和操作要少得多，我们的模型也实现了与最先进方法相当的性能。
【图像超分】论文精读：Efficient Long-Range Attention Network for Image Super-resolution（ELAN）
畅游计算机视觉的海洋
08-07 59
论文题目：Efficient Long-Range Attention Network for Image Super-resolution —— 用于图像超分辨率的高效远程注意网络ECCV 2022！最近，基于转换器的方法通过利用自注意力 (SA) 进行特征提取，在各种视觉任务中展示了令人印象深刻的结果，包括图像超分辨率 (SR)。然而，大多数现有基于转换器的模型中 SA 的计算非常昂贵，而一些使用的操作对于 SR 任务可能是冗余的。这限制了 SA 计算的范围，从而限制了 SR 性能。
ECCV2018超分辨率CARN：Fast, Accurate, and Lightweight Super-Resolution with Cascading Residual Network
热门推荐
qq_41332469的博客
06-16 1万+
本文提出一种轻量级级联残差网络，速度快，性能也还不错。 提出问题 尽管深度学习方法提高了SR图像的质量，但速度慢，并不适用于真实场景。从这个角度来看，设计适合实际应用的轻量级深度学习模型非常重要。 一种方法是减少参数的数量，实现这一目标的方法有很多，但最简单和有效的方法是使用递归网络。例如，DRCN使用递归网络来减少冗余参数，而DRRN通过向DRCN添加残差体系结构来改进DRCN。与标准CNN相比...
Chisel实验笔记（四）
leishangwen的专栏
06-04 3919
在《Chisel实验笔记（二）》中，通过编写TestBench文件，然后使用Icarus Verilog、GtkWave可以测试，查看相关波形，比较直观，在《Chisel实验笔记（三）》直接对得到C++模拟器进行测试，也可以得到测试结果，实际上对C++模拟器进行测试也可以同时得到vcd文件，从而使用GtkWave查看波形，得到直观的结果。本文就介绍了这个过程。
深度学习领域新星 —— Octave Convolution：高效卷积网络的革新者
最新发布
gitblog_00057的博客
08-16 237
???? 深度学习领域新星 —— Octave Convolution：高效卷积网络的革新者 ???? OctConv项目地址:https://gitcode.com/gh_mirrors/oc/OctConv 在深度学习领域中，卷积神经网络（CNN）一直是图像识别和处理的核心。然而，传统CNN在空间冗余上的问题一直影响着模型的效率和性能。直到Octave Convolution的出现，这一切都发生了改变。...
实验总笔记
qq_64384954的博客
03-05 320
交换机SW1会查看数据帧的目的MAC地址，目的MAC地址所对应接口的vlan id与标签中的VLAN id是一样的，如果一样，则证明该数据要转发，转发出去之前要剥离标签，使之能在trunk链路上传输。交换机SW2收到后，会检查下数据帧的目的MAC地址，目的MAC地址所对应接口的vlan id，给原始数据帧打上vlan tag ，从对应的接口发出。高级ACL：3000-3999 （源IP、目的IP、源端口、目的端口、协议）---数据五元组-----精确筛选和匹。
ADAFM实验笔记
gwpscut的博客
04-30 595
本博文为测试我的小伙伴的github代码的实验记录 先给出GitHub链接（https://github.com/hejingwenhejingwen/AdaFM）
大数据实验笔记2
qq_46016205的博客
11-06 260
大数据实验笔记2 谢谢我自己，给我写了个奶奶级的实验帮助文档 实验指导书：我在这里哦 老师搭建的hadoop集群（实验结束后关闭）：59.110.168.10 web访问：59.110.168.10:9870 user:hadoop pswd:hadoop01 用java编程实现对hadoop的远程控制 可能是这么形容吧反正是这么个意思 1.java环境配置 自行下载jdk 我在这里哦 win键+r键，输入cmd，打开命令窗口，输入java -version可查看java版本（jdk版本） 实验使用的是i
网络课程实验笔记（第二天）
Ifeeexxj的博客
12-24 290
1、添加用户 命令：user 用户名 password（表示设置密码） 0（固定格式） 密码 2、登录管理 3、远程登录配置 1、进入接口 命令：router(config)#interface gigabitethernet 0/0 2.因为设备是路由交换一体，所以需要手动切换模式 （每一个接口配置IP地址时都需要） 命令：router(config-if-gigabitethernet0/...
SysStat_Carn_allinonecode3_
10-03
【SysStat_Carn_allinonecode3_】是一款集成了多种系统监控工具的软件包，主要针对Linux系统设计，旨在提供全面的系统性能监控功能。它整合了Carn的代码库，提供了统一的代码基础，使得用户能够方便地对系统的各种...
R导论_CARN_R官方文档
06-30
R导论, CARN，R的官方文档，适合入门级的朋友。该文档覆盖了R的基础知识
OctaveConv-Pytorch:拖放八度的PyTorch实现
03-16
OctaveConv-Pytorch 程的PyTorch实现 （培训进行中） 用法 from resnet import octResnet50 ... model = octResnet50 () 从
基于深度约束最小二乘的盲图像超分辨率
176420基于深度约束最小二乘的盲图像超分辨率0骆子蔚 1 黄海滨 2 于磊 1 李友伟 1 范浩强 1 刘帅成 3 , 1 *01 Megvii Technology 2 Kuaishou Technology 3University of Electronic Science...
CARN
Magic_o的博客
10-29 712
两种CARN/CARN-M CARN:CARN在本地和全局级别使用层叠机制来合并来自多个层的特性。 CARN-M:使用residual-E，结合了残差和递归的 轻量的网络分为两类：压缩当前的网络，设计小但是很有效的网络
Octave Convolution 代码详解
zghydx1924的博客
05-13 3113
OctaveConvolution Facebook和新加坡国立大学联手提出了新一代替代品：OctConv（OctaveConvolution），效果惊艳，用起来还非常方便。OctConv是一个即插即用的结构在提高精度的同时，节约计算资源的消耗。 (a)自然图像可以分解为低空间频率和高空间频率两部分。 (b)卷积层的输出图也可以根据其空间频率分解和分组。 因此文章使用一个系数α将特征图显...
Octave Convolution学习笔记 （附代码）
PLANTTHESON的博客
10-30 514
Octave Convolution学习笔记 （附代码）
【Paper & Code】（CVPR2019）Octave Convolution
穆友航的博客
05-19 449
亮点 分离图像数据中的高频和低频信息，降低低频信息的分辨率，保持高频信息的分辨率，减少了整体运算量。 论文介绍 代码 MXNet Symbol接口下的实现：OctConv ...
八分音符(频率)卷积算子 Octave Convolution
华为云官方博客
08-14 2108
为什么读此系列文章？ 优化数学和计算理论帮助机器学习完成问题分类： 1）按照领域划分，比如计算机视觉，自然语言处理，统计分析预测形； 2）按照算法复杂划分，比如是否是NP-Hard问题，是否需要精确解； 3）按照方法分类，监督性学习问题，非监督性学习问题，半监督性学习模型，和有先验信息的交互学习模型； 4）按照研模型分类，比如基于代数线性表出理论、基理论的线性模型，基于决策树的树状非线性...
模型压缩与加速:Octave Convolution
撸猫写博客
04-28 683
  自AlexNet刷新了ImageNet比赛的最佳记录以来,神经网络的又一次高潮猛烈的到来了.一些列各种各样的网络层出不穷,图像/音频/文本等各种任务下都开始了神经网络一统天下的声音.然而神经网络虽然很火,近些年在落地端却鲜有比较成功的案例,其中一个很重要的原因是这些网络需要很强的计算资源,基本都要跑在PC或者服务器上.因此个人认为深度学习如果想在工业上获得比较大的推广和应用,解决模型大小与推理...
const observer1 = new IntersectionObserver((entries) => { entries.forEach((entry) => { if (entry.isIntersecting) { entry.target.classList.add("animate"); } else { entry.target.classList.remove("animate"); } }); }, options1); const elements1 = document.querySelectorAll(".carn"); elements1.forEach((element) => { observer1.observe(element); });如何往上滚动不触发
05-27
这段代码是使用Intersection Observer API实现目标元素在进入视口时添加一个`animate`类，离开视口时移除这个类的效果。如果想要在往上滚动时不触发这个效果，可以通过设置`rootMargin`属性来实现。 例如，如果想要在目标元素的顶部进入视口150像素之后开始触发动画效果，可以这样设置`rootMargin`属性： ``` const options1 = { rootMargin: '-150px 0px 0px 0px' }; const observer1 = new IntersectionObserver((entries) => { entries.forEach((entry) => { if (entry.isIntersecting) { entry.target.classList.add("animate"); } else { entry.target.classList.remove("animate"); } }); }, options1); const elements1 = document.querySelectorAll(".carn"); elements1.forEach((element) => { observer1.observe(element); }); ``` 这样，在目标元素的顶部进入视口150像素之后才会触发动画效果，而往上滚动不会触发。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值