基于 Paddle2.0 实现 DLA 模型
热心网友
95
转载
本文介绍了Deep Layer Aggregation（DLA）模型，将聚合定义为网络不同层的组合，提出深度可聚合结构，通过迭代深层聚合（IDA）和分层深度聚合（HDA）融合特征。迁移了最新模型代码和预训练参数，验证了精度。还展示了模型细节、搭建、精度验证及训练示例，指出DLA能以较少参数和计算量获更高精度。
引入
本文将聚合 aggregation 定义为跨越整个网络的不同层之间的组合。在这篇文章中，作者团队把注意力放在一族可以更有效的聚合深度、分辨率和尺度的网络。本文将可以组合的、非线性的、最先聚合的层可以通过多次聚合在整个网络中传递的结构称为深度可聚合的。由于网络可以包含许多层和连接，模组化设计可以通过分组与复制来克服网络过于复杂的问题。层组合为块，块根据其特征分辨率组合成层级。本文主要探讨如何聚合块与层级（换句话说层级间的网络保持一致的分辨率，而语义融合一般发生在层级内，空间融合一般发生在层级间）。项目说明
本项目迁移最新实现的模型代码和预训练模型参数文件模型前向计算结果与最新实现无明显差异，预训练模型的精度与最新实现和论文标称的精度对齐暂未也不打算重新进行模型训练，欢迎大家自行进行训练验证如果项目中有任何问题，也欢迎大家在评论区留言交流相关资料
论文：Deep Layer Aggregation
免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈
最新实现：ucbdrive/dla
验证集数据处理：
# 图像后端: pil# 输入大小: 224x224transforms = T.Compose([ T.Resize(256, interpolation='bilinear'), T.CenterCrop(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])登录后复制
模型细节：
其中 DLA-34、DLA-102 两个模型的预训练参数为最新提供的增加了 tricks 的预训练模型，精度会相比论文中的标称精度高一些概述
视觉识别需要丰富的表示形式，其范围从低到高，范围从小到大，分辨率从精细到粗糙。即使卷积网络中的要素深度很深，仅靠隔离层还是不够的：将这些表示法进行复合和聚合可改善对内容和位置的推断。尽管已合并了残差连接以组合各层，但是这些连接本身是“浅”的，并且只能通过简单的一步操作来融合。作者通过更深层的聚合来增强标准体系结构，以更好地融合各层的信息。Deep Layer Aggregation 结构迭代地和分层地合并了特征层次结构，以使网络具有更高的准确性和更少的参数。跨体系结构和任务的实验表明，与现有的分支和合并方案相比，Deep Layer Aggregation 可提高识别和分辨率。深层聚合（Deep Layer Aggregation）
首先，我们将聚合定义为网络中不同层之间的连接。在这项工作中，我们专注于一系列架构，以有效地聚合深度，分辨率和尺度。
迭代深层聚合（Iterative Deep Aggregation）
首先通过网络中堆叠的块根据分辨率划分为多个阶段。深层阶段的语义信息很丰富但是空间上比较粗糙。将低层阶段通过跳跃连接到高层阶段来融合尺寸和分辨率。但现有的跳跃连接都是线性的，并且最浅层的聚合最少，如图(b)。因此，我们提出IDA来聚合并加深特征的代表。聚合从最浅，最小的尺度开始，然后迭代地合并更深，更大的尺度。通过这种方式，浅层特征被重新定义，因为它们通过不同的聚合阶段传播。
x1，x2，，，xn代表n层，N是聚合结点。登录后复制
分层深度聚合（Hierarchical Deep Aggregation）
HDA通过融合在树形中块和阶段来保存并且结合特征通道。通过HDA将较浅和较深的层组合在一起，以学习跨越更多特征层次结构的更丰富的组合。尽管IDA在阶段方面的融合很有效果，但是在网络中多个块之间融合并不有效。IDA仅仅通过融合阶段是远远不够的，因为它还是顺序的。层次聚合的深层分支结构如图2（d）。有了HDA的大体结构，我们便可以提高它的深度以及效率。通过将聚合节点的输出作为下一个子树的输入反馈到主干中，来代替仅将中间聚合路由到树的上方。也就是说将前两个块聚合后的结果反馈到骨干网络中继续参加训练。如此一来便会聚合所有先前的块而不是仅仅聚合前一个块。为提高效率，我们聚合了具有相同深度的结点，将父亲和左子树连接。HDA的公式如下：
N代表聚合节点。B代表一个卷积块。登录后复制
聚合元素
聚合节点
聚合节点的作用是融合并压缩输入。聚合节点学着去选择并且处理重要的信息保证在输出中保持相同的维度作为单个输入。在我们的结构中，IDA一直都是二进制的，HDA节点具有可变数量的参数，具体取决于树的深度。虽然聚合节点可以基于任何块或层，但为了简单和高效，我们选择单个卷积，然后进行批量归一化和非线性。这避免了聚合结构的开销。在分类网络中，我们使用1x1卷积作为聚合结点；在语义分割中，我们添加了更多级别的迭代深度聚合来插入特征，在这种情况下使用3×3卷积。另外，由于残差连接在组装深层网络很有效果，因此在我们的聚合节点出同样增加了残差连接。可实验证明残差连接对聚合并没有显著性的效果。在HDA中，从任何块到根的最短路径是层次结构的深度，因此沿着聚合路径可能不会出现递减或爆炸的渐变。在我们的实验中，加入残差可以在层次结构最深的有4层甚至更多的时候帮助到HDA。但同时可能会影响对小一点的层次的效果。在公式1和2中，对节点N的定义如下：
σ是非线性激活。公式4是相对于公式3加了残差连接。登录后复制
Blocks and Stages（块和阶段）
深层融合是一个比较普遍的架构因为它可以和任何一个骨干网络兼容（如ResNet，ResNeXT，Densenet等）。实验中我们使用到了三种不同的残差块：Basic blocks（即ResNet）将堆叠卷积与恒等映射跳过连接相结合；Bottleneck blocks通过1x1卷积降维；Split blocks（即ResNeXT）通过将通道分组为多个单独的路径（称为拆分的基数）来使功能多样化。该工作中，我们将bottleneck和split neck的输出和中间通道数量之比减少一半，基数设置为32。分类网络
分类网络例如ResNet 和ResNeXT都是阶段性的网络，每一个阶段都有多个残差网络组成，阶段之间通过下采样获得特征图。整个网络有32倍的降采样，最后通过对输出进行softmax得分，进而分类。本文中，在阶段之间用IDA，在每个阶段内部使用HDA。通过共享聚合节点可以轻松组合这些类型的聚合。这种情况我们只需通过结合公式1和2来改变每个垂直方向的根节点。在各个阶段之间通过池化进行下采样。对于不同的框架，我们采用不同的处理方式。比如在DRN（带有空洞卷积的ResNet）中，我们将前两个阶段的最大池化代替为多个卷积，阶段1是7x7卷积+ basic block，阶段2是basic block。
模型搭建
In [2]import mathimport paddleimport paddle.nn as nnimport paddle.nn.functional as Ffrom paddle.nn.initializer import Constant, Normal# 初始化zeros_ = Constant(value=0.)ones_ = Constant(value=1.)# 占位层class Identity(nn.Layer): def __init__(self): super(Identity, self).__init__() def forward(self, input): return input# DLA Basic 模块（ConvBNs + Residual）class DlaBasic(nn.Layer): def __init__(self, inplanes, planes, stride=1, dilation=1, **cargs): super(DlaBasic, self).__init__() self.conv1 = nn.Conv2D( inplanes, planes, kernel_size=3, stride=stride, padding=dilation, bias_attr=False, dilation=dilation) self.bn1 = nn.BatchNorm2D(planes) self.relu = nn.ReLU() self.conv2 = nn.Conv2D( planes, planes, kernel_size=3, stride=1, padding=dilation, bias_attr=False, dilation=dilation) self.bn2 = nn.BatchNorm2D(planes) self.stride = stride def forward(self, x, residual=None): if residual is None: residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out += residual out = self.relu(out) return out# DLA Bottleneck 模块（ConvBNs + Residual）class DlaBottleneck(nn.Layer): expansion = 2 def __init__(self, inplanes, outplanes, stride=1, dilation=1, cardinality=1, base_width=64): super(DlaBottleneck, self).__init__() self.stride = stride mid_planes = int(math.floor( outplanes * (base_width / 64)) * cardinality) mid_planes = mid_planes // self.expansion self.conv1 = nn.Conv2D(inplanes, mid_planes, kernel_size=1, bias_attr=False) self.bn1 = nn.BatchNorm2D(mid_planes) self.conv2 = nn.Conv2D( mid_planes, mid_planes, kernel_size=3, stride=stride, padding=dilation, bias_attr=False, dilation=dilation, groups=cardinality) self.bn2 = nn.BatchNorm2D(mid_planes) self.conv3 = nn.Conv2D(mid_planes, outplanes, kernel_size=1, bias_attr=False) self.bn3 = nn.BatchNorm2D(outplanes) self.relu = nn.ReLU() def forward(self, x, residual=None): if residual is None: residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) out += residual out = self.relu(out) return out# DLA 根节点class DlaRoot(nn.Layer): def __init__(self, in_channels, out_channels, kernel_size, residual): super(DlaRoot, self).__init__() self.conv = nn.Conv2D( in_channels, out_channels, 1, stride=1, bias_attr=False, padding=(kernel_size - 1) // 2) self.bn = nn.BatchNorm2D(out_channels) self.relu = nn.ReLU() self.residual = residual def forward(self, *x): children = x x = self.conv(paddle.concat(x, 1)) x = self.bn(x) if self.residual: x += children[0] x = self.relu(x) return x# DLA Tree（通过 Tree 的方式来组织模型网络）class DlaTree(nn.Layer): def __init__(self, levels, block, in_channels, out_channels, stride=1, dilation=1, cardinality=1, base_width=64, level_root=False, root_dim=0, root_kernel_size=1, root_residual=False): super(DlaTree, self).__init__() if root_dim == 0: root_dim = 2 * out_channels if level_root: root_dim += in_channels self.downsample = nn.MaxPool2D( stride, stride=stride) if stride > 1 else Identity() self.project = Identity() cargs = dict(dilation=dilation, cardinality=cardinality, base_width=base_width) if levels == 1: self.tree1 = block(in_channels, out_channels, stride, **cargs) self.tree2 = block(out_channels, out_channels, 1, **cargs) if in_channels != out_channels: self.project = nn.Sequential( nn.Conv2D(in_channels, out_channels, kernel_size=1, stride=1, bias_attr=False), nn.BatchNorm2D(out_channels)) else: cargs.update(dict(root_kernel_size=root_kernel_size, root_residual=root_residual)) self.tree1 = DlaTree( levels - 1, block, in_channels, out_channels, stride, root_dim=0, **cargs) self.tree2 = DlaTree( levels - 1, block, out_channels, out_channels, root_dim=root_dim + out_channels, **cargs) if levels == 1: self.root = DlaRoot(root_dim, out_channels, root_kernel_size, root_residual) self.level_root = level_root self.root_dim = root_dim self.levels = levels def forward(self, x, residual=None, children=None): children = [] if children is None else children bottom = self.downsample(x) residual = self.project(bottom) if self.level_root: children.append(bottom) x1 = self.tree1(x, residual) if self.levels == 1: x2 = self.tree2(x1) x = self.root(x2, x1, *children) else: children.append(x1) x = self.tree2(x1, children=children) return x# DLA 模型class DLA(nn.Layer): def __init__(self, levels, channels, in_chans=3, cardinality=1, base_width=64, block=DlaBottleneck, residual_root=False, drop_rate=0.0, class_dim=1000, with_pool=True): super(DLA, self).__init__() self.channels = channels self.class_dim = class_dim self.with_pool = with_pool self.cardinality = cardinality self.base_width = base_width self.drop_rate = drop_rate self.base_layer = nn.Sequential( nn.Conv2D(in_chans, channels[0], kernel_size=7, stride=1, padding=3, bias_attr=False), nn.BatchNorm2D(channels[0]), nn.ReLU()) self.level0 = self._make_conv_level( channels[0], channels[0], levels[0]) self.level1 = self._make_conv_level( channels[0], channels[1], levels[1], stride=2) cargs = dict(cardinality=cardinality, base_width=base_width, root_residual=residual_root) self.level2 = DlaTree( levels[2], block, channels[1], channels[2], 2, level_root=False, **cargs) self.level3 = DlaTree( levels[3], block, channels[2], channels[3], 2, level_root=True, **cargs) self.level4 = DlaTree( levels[4], block, channels[3], channels[4], 2, level_root=True, **cargs) self.level5 = DlaTree( levels[5], block, channels[4], channels[5], 2, level_root=True, **cargs) self.feature_info = [ # rare to have a meaningful stride 1 level dict(num_chs=channels[0], reduction=1, module='level0'), dict(num_chs=channels[1], reduction=2, module='level1'), dict(num_chs=channels[2], reduction=4, module='level2'), dict(num_chs=channels[3], reduction=8, module='level3'), dict(num_chs=channels[4], reduction=16, module='level4'), dict(num_chs=channels[5], reduction=32, module='level5'), ] self.num_features = channels[-1] if with_pool: self.global_pool = nn.AdaptiveAvgPool2D(1) if class_dim > 0: self.fc = nn.Conv2D(self.num_features, class_dim, 1) for m in self.sublayers(): if isinstance(m, nn.Conv2D): n = m._kernel_size[0] * m._kernel_size[1] * m._out_channels normal_ = Normal(mean=0.0, std=math.sqrt(2. / n)) normal_(m.weight) elif isinstance(m, nn.BatchNorm2D): ones_(m.weight) zeros_(m.bias) def _make_conv_level(self, inplanes, planes, convs, stride=1, dilation=1): modules = [] for i in range(convs): modules.extend([ nn.Conv2D(inplanes, planes, kernel_size=3, stride=stride if i == 0 else 1, padding=dilation, bias_attr=False, dilation=dilation), nn.BatchNorm2D(planes), nn.ReLU()]) inplanes = planes return nn.Sequential(*modules) def forward_features(self, x): x = self.base_layer(x) x = self.level0(x) x = self.level1(x) x = self.level2(x) x = self.level3(x) x = self.level4(x) x = self.level5(x) return x def forward(self, x): x = self.forward_features(x) if self.with_pool: x = self.global_pool(x) if self.drop_rate > 0.: x = F.dropout(x, p=self.drop_rate, training=self.training) if self.class_dim > 0: x = self.fc(x) x = x.flatten(1) return xdef dla_34(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 2, 2, 1), channels=(16, 32, 64, 128, 256, 512), block=DlaBasic, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla34.pdparams') model.set_dict(params) return modeldef dla_46_c(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 2, 2, 1), channels=(16, 32, 64, 64, 128, 256), block=DlaBottleneck, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla46_c.pdparams') model.set_dict(params) return modeldef dla_46x_c(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 2, 2, 1), channels=(16, 32, 64, 64, 128, 256), block=DlaBottleneck, cardinality=32, base_width=4, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla46x_c.pdparams') model.set_dict(params) return modeldef dla_60x_c(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 2, 3, 1), channels=(16, 32, 64, 64, 128, 256), block=DlaBottleneck, cardinality=32, base_width=4, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla60x_c.pdparams') model.set_dict(params) return modeldef dla_60(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 2, 3, 1), channels=(16, 32, 128, 256, 512, 1024), block=DlaBottleneck, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla60.pdparams') model.set_dict(params) return modeldef dla_60x(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 2, 3, 1), channels=(16, 32, 128, 256, 512, 1024), block=DlaBottleneck, cardinality=32, base_width=4, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla60x.pdparams') model.set_dict(params) return modeldef dla_102(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 3, 4, 1), channels=(16, 32, 128, 256, 512, 1024), block=DlaBottleneck, residual_root=True, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla102.pdparams') model.set_dict(params) return modeldef dla_102x(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 3, 4, 1), channels=(16, 32, 128, 256, 512, 1024), block=DlaBottleneck, cardinality=32, base_width=4, residual_root=True, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla102x.pdparams') model.set_dict(params) return modeldef dla_102x2(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 1, 3, 4, 1), channels=(16, 32, 128, 256, 512, 1024), block=DlaBottleneck, cardinality=64, base_width=4, residual_root=True, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla102x2.pdparams') model.set_dict(params) return modeldef dla_169(pretrained=False, **kwargs): model = DLA( levels=(1, 1, 2, 3, 5, 1), channels=(16, 32, 128, 256, 512, 1024), block=DlaBottleneck, residual_root=True, **kwargs ) if pretrained: params = paddle.load('/home/aistudio/data/data78316/dla169.pdparams') model.set_dict(params) return model登录后复制 模型精度验证
In [ ]# 解压数据集!mkdir ~/data/ILSVRC2012!tar -xf ~/data/data68594/ILSVRC2012_img_val.tar -C ~/data/ILSVRC2012登录后复制 In [1]
import osimport cv2import numpy as npimport paddleimport paddle.vision.transforms as Tfrom PIL import Image# 构建数据集class ILSVRC2012(paddle.io.Dataset): def __init__(self, root, label_list, transform, backend='pil'): self.transform = transform self.root = root self.label_list = label_list self.backend = backend self.load_datas() def load_datas(self): self.imgs = [] self.labels = [] with open(self.label_list, 'r') as f: for line in f: img, label = line[:-1].split(' ') self.imgs.append(os.path.join(self.root, img)) self.labels.append(int(label)) def __getitem__(self, idx): label = self.labels[idx] image = self.imgs[idx] if self.backend=='cv2': image = cv2.imread(image) else: image = Image.open(image).convert('RGB') image = self.transform(image) return image.astype('float32'), np.array(label).astype('int64') def __len__(self): return len(self.imgs)# 配置模型val_transforms = T.Compose([ T.Resize(256, interpolation='bilinear'), T.CenterCrop(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])model = dla_60(pretrained=True)model = paddle.Model(model)model.prepare(metrics=paddle.metric.Accuracy(topk=(1, 5)))# 配置数据集val_dataset = ILSVRC2012('data/ILSVRC2012', transform=val_transforms, label_list='data/data68594/val_list.txt', backend='pil')# 模型验证acc = model.evaluate(val_dataset, batch_size=128, num_workers=0, verbose=0)print(acc)登录后复制 /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/tensor/creation.py:143: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations if data.dtype == np.object:/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dataloader/dataloader_iter.py:89: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations if isinstance(slot[0], (np.ndarray, np.bool, numbers.Number)):/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/utils.py:77: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working return (isinstance(seq, collections.Sequence) and登录后复制
模型训练
由于 ImageNet 数据集过大，不太好加载这里使用 Cifar100 演示一下模型的训练操作In [ ]# 导入 Paddleimport paddleimport paddle.nn as nnimport paddle.vision.transforms as Tfrom paddle.vision import Cifar100# 加载模型model = dla_60(pretrained=True, class_dim=100)# 使用高层 API 进行模型封装model = paddle.Model(model)# 配置优化器opt = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())# 配置损失函数loss = nn.CrossEntropyLoss()# 配置评价指标metric = paddle.metric.Accuracy(topk=(1, 5))# 模型准备model.prepare(optimizer=opt, loss=loss, metrics=metric)# 配置数据增广train_transforms = T.Compose([ T.Resize(256, interpolation='bilinear'), T.RandomCrop(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])val_transforms = T.Compose([ T.Resize(256, interpolation='bilinear'), T.CenterCrop(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])# 配置数据集train_dataset = Cifar100(mode='train', transform=train_transforms, backend='pil')val_dataset = Cifar100(mode='test', transform=val_transforms, backend='pil')# 模型微调model.fit( train_data=train_dataset, eval_data=val_dataset, batch_size=64, epochs=1, eval_freq=1, log_freq=1, save_dir='save_models', save_freq=1, verbose=1, drop_last=False, shuffle=True, num_workers=0)登录后复制
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py:1303: UserWarning: Skip loading for fc.weight. fc.weight receives a shape [1000, 1024, 1, 1], but the expected shape is [100, 1024, 1, 1]. warnings.warn(("Skip loading for {}. ".format(key) + str(err)))/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py:1303: UserWarning: Skip loading for fc.bias. fc.bias receives a shape [1000], but the expected shape is [100]. warnings.warn(("Skip loading for {}. ".format(key) + str(err)))Cache file /home/aistudio/.cache/paddle/dataset/cifar/cifar-100-python.tar.gz not found, downloading https://dataset.bj.bcebos.com/cifar/cifar-100-python.tar.gz Begin to downloadDownload finished登录后复制 The loss value printed in the log is the current step, and the metric is the average value of previous step.Epoch 1/1登录后复制
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/nn/layer/norm.py:648: UserWarning: When training, we now always track global mean and variance. "When training, we now always track global mean and variance.")登录后复制
step 782/782 [==============================] - loss: 2.2643 - acc_top1: 0.3284 - acc_top5: 0.6364 - 328ms/step save checkpoint at /home/aistudio/save_models/0Eval begin...The loss value printed in the log is the current batch, and the metric is the average value of previous step.step 157/157 [==============================] - loss: 2.3870 - acc_top1: 0.4577 - acc_top5: 0.7807 - 171ms/step Eval samples: 10000save checkpoint at /home/aistudio/save_models/final登录后复制
模型精度对比
对比一些常见的 CNN 模型的结果如下：
总结
DLA 通过特别设计的多层级的深层聚合模块，提升了模型的精度和效率对比其他常见的 CNN 模型，DLA 可以以较少的参数和较少的计算量获得更高的精度
免责声明：
游乐网为非赢利性网站，所展示的游戏/软件/文章内容均来自于互联网或第三方用户上传分享，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系youleyoucom@outlook.com。
相关攻略
Pywinrm 通过Windows远程管理（WinRM）协议，让Python能够像操作本地一样执行远程Windows命令，真正打通了跨平台管理的最后一公里。 在混合IT环境中，Linux机器管理Wi
早些时候，聊过 Python 领域那场惊心动魄的供应链攻击。当时我就感叹，虽然我们 JavaScript 开发者对这类套路烂熟于心，但亲眼目睹这种规模的“投毒”还是头一次。 早些时候，聊过 Pyth
Toga 是 BeeWare 家族的核心成员，号称“写一次，跑遍所有平台”，而且用的是系统原生控件，不是那种一看就是网页套壳的界面 。 写了这么多年 Python，你是不是也想过：要是能一套代码跑
异常处理的核心：让错误在正确的地方被有效处理。正确的地方，就是别在底层就把异常吞了，也别在顶层还抛裸奔的 Exception。 异常处理写得好，半夜不用起来改 bug。1 你是不是也这么干过？tr
1 Skills机制概述 提起OpenClaw的Skills机制，不少人可能会把它想象成传统意义上的可执行插件。其实，它的内涵要更精妙一些。 简单说，Skills本质上是一套基于提示驱动的能力扩展机制。它并不是一个可以独立“跑”起来的程序模块，而是通过一份结构化描述文件（核心就是那个SKILL m
热门专题
刀塔传奇破解版无限钻石下载大全
2025-08-05
洛克王国正式正版手游下载安装大全
2025-08-05
热门推荐
加密货币行业翘首以盼的监管里程碑，终于有了实质性进展。美国证券交易委员会（SEC）主席保罗·阿特金斯（Paul Atkins）近日证实，那份允许加密项目在早期获得注册豁免权的“安全港”框架提案，已经正式送抵白宫，进入了最终审查阶段。 在范德堡大学与区块链协会联合举办的数字资产峰会上，阿特金斯透露了这
微策略Strategy报告：第一季录得144 6亿美元浮亏 再斥资约3 3亿美元买进4871枚比特币 市场震荡的威力有多大？看看Strategy的最新季报就明白了。根据其最新向美国证管会(SEC)提交的8-K报告，受市场剧烈波动影响，这家公司所持的比特币在第一季度录得了一笔惊人的数字——144 6亿
稳定币巨头Tether的动向，向来是加密世界的风向标。这不，它向Web3基础设施的版图扩张，又迈出了关键一步。公司执行长Paolo Ardoino在社交平台X上透露，其工程团队正在全力“烹制”一个新项目——去中心化搜索引擎 “Hypersearch”。这个消息一出，立刻引发了行业的广泛猜想。 采用D
基地位于Coinbase旗下以太坊Layer2网络Base的Seamless Protocol，日前正式宣告了服务的终结。这个曾经吸引了超过20万用户的原生DeFi借贷协议，在运营不到三年后，终究没能跑赢时间。它主打的核心产品是Integrated Leverage Markets（ILMs）——一
PAAL代币揭秘：深度解析Web3社区治理的核心钥匙 在去中心化自治组织的浪潮中，谁真正掌握了项目的话语权？PAAL代币提供了一套系统化的答案。它不仅是生态内流转的价值媒介，更是开启链上治理大门的核心凭证。通过持有并质押PAAL代币，用户能够对协议升级、资金分配乃至战略方向等关键事务投出决定性的一票