AttributeError: type object 'Reduction' has no attribute 'AUTO

这个错误通常是由于 PyTorch 版本不兼容导致的。在 PyTorch 1.6 及以上版本中，`torch.nn.functional` 中的 `reduction` 参数已经被移除，取而代之的是 `torch.nn.Reduction` 中的 `enum` 类型。因此，如果你使用的是 PyTorch 1.6 及以上版本，可以将 `reduction` 参数替换为 `torch.nn.Reduction` 中的枚举类型，例如：

import torch.nn as nn

loss_fn = nn.CrossEntropyLoss(reduction=nn.Reduction.SUM)

如果你使用的是 PyTorch 1.5 及以下版本，可以将 `reduction` 参数设置为字符串类型，例如：

import torch.nn as nn

loss_fn = nn.CrossEntropyLoss(reduction='sum')

相关问题

mmdetection AttributeError: 'SSDHead' object has no attribute 'loss_cls'

这个错误通常是由于代码中的某些变量或方法未正确定义或导入而引起的。在这种情况下，错误信息表明在SSDHead对象中找不到loss_cls属性。这可能是由于以下原因之一导致的：

1.代码中确实没有定义loss_cls属性或方法。
2.代码中定义了loss_cls属性或方法，但是由于某些原因未正确导入或初始化。
3.代码中定义了loss_cls属性或方法，但是在SSDHead对象中未正确调用。

为了解决这个问题，你可以尝试以下几个步骤：

1.检查代码中是否正确定义了loss_cls属性或方法，并确保它们被正确导入和初始化。
2.检查代码中是否正确调用了loss_cls属性或方法，并确保它们被正确传递和使用。
3.检查代码中是否存在拼写错误或语法错误，并进行必要的更正。
4.检查代码中是否存在其他与此错误相关的警告或错误，并进行必要的更正。

以下是一个可能的解决方案：

class SSDHead(nn.Module):
    def __init__(self, num_classes, in_channels, feat_channels=256, stacked_convs=2, **kwargs):
        super(SSDHead, self).__init__(**kwargs)
        self.num_classes = num_classes
        self.in_channels = in_channels
        self.feat_channels = feat_channels
        self.stacked_convs = stacked_convs
        self.loss_cls = nn.CrossEntropyLoss() # 定义loss_cls属性
        self.loss_bbox = nn.L1Loss(reduction='none')
        self.conv1x1 = nn.ModuleList()
        self.conv3x3 = nn.ModuleList()
        for i in range(self.stacked_convs):
            self.conv1x1.append(nn.Conv2d(self.in_channels, self.feat_channels, kernel_size=1))
            self.conv3x3.append(nn.Conv2d(self.feat_channels, self.feat_channels, kernel_size=3, padding=1))
        self.cls_convs = nn.ModuleList()
        self.reg_convs = nn.ModuleList()
        for i in range(4):
            self.cls_convs.append(nn.Conv2d(self.feat_channels, self.feat_channels, kernel_size=3, padding=1))
            self.reg_convs.append(nn.Conv2d(self.feat_channels, self.feat_channels, kernel_size=3, padding=1))
        self.cls_out = nn.Conv2d(self.feat_channels, self.num_classes, kernel_size=3, padding=1)
        self.reg_out = nn.Conv2d(self.feat_channels, 4, kernel_size=3, padding=1)

    def forward(self, x):
        cls_scores = []
        bbox_preds = []
        for feat in x:
            cls_feat = feat
            reg_feat = feat
            for i in range(self.stacked_convs):
                cls_feat = F.relu(self.conv1x1[i](cls_feat))
                cls_feat = F.relu(self.conv3x3[i](cls_feat))
                reg_feat = F.relu(self.conv1x1[i](reg_feat))
                reg_feat = F.relu(self.conv3x3[i](reg_feat))
            cls_feat = cls_feat + feat
            reg_feat = reg_feat + feat
            cls_feat = self.cls_convs[0](cls_feat)
            reg_feat = self.reg_convs[0](reg_feat)
            for i in range(1, 4):
                cls_feat = F.relu(cls_feat)
                reg_feat = F.relu(reg_feat)
                cls_feat = self.cls_convs[i](cls_feat)
                reg_feat = self.reg_convs[i](reg_feat)
            cls_score = self.cls_out(cls_feat)
            bbox_pred = self.reg_out(reg_feat)
            cls_scores.append(cls_score)
            bbox_preds.append(bbox_pred)
        return cls_scores, bbox_preds

    def loss(self, cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas):
        losses = dict()
        batch_size = cls_scores[0].size(0)
        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
        device = cls_scores[0].device
        gt_bboxes = [gt_bbox.to(device) for gt_bbox in gt_bboxes]
        gt_labels = [gt_label.to(device) for gt_label in gt_labels]
        anchor_list, valid_flag_list = self.get_anchors(featmap_sizes, img_metas, device=device)
        cls_reg_targets = self.anchor_target(anchor_list, valid_flag_list, gt_bboxes, img_metas, gt_labels)
        if cls_reg_targets is None:
            return None
        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list, num_total_pos, num_total_neg) = cls_reg_targets
        num_total_samples = reduce_mean([labels.size(0) for labels in labels_list])
        losses['loss_cls'] = self.loss_cls(cls_scores, labels_list, label_weights_list) # 调用loss_cls属性
        losses['loss_bbox'] = self.loss_bbox(bbox_preds, bbox_targets_list, bbox_weights_list, avg_factor=num_total_samples)
        return losses

jetson移植模型时提示AttributeError: 'SEBottleneck' object has no attribute 'se'

### Jetson 平台模型移植时遇到 `AttributeError` 的解决方案

当在 Jetson 平台上进行模型移植并遇到类似于 `SEBottleneck no attribute se` 或其他类似的属性错误时，通常是因为使用的库版本不兼容或代码中的某些特性不再受支持。

#### 1. 版本兼容性检查
确保所使用的 PyTorch 和 CUDA 版本与 Jetson 设备完全兼容。不同硬件平台可能有不同的驱动程序和软件栈需求。对于特定于 SE 模块的问题，可以考虑更新到最新版本的 PyTorch 库[^1]：

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113

#### 2. 修改源码适配新API
如果发现类定义中确实缺少某个方法，则可能是由于 API 变更引起。针对 `SEBottleneck` 类缺失 `se` 属性的情况，建议查看官方文档确认最新的接口调用方式，并相应调整自定义模块实现逻辑[^3]。

例如，在较新的 ResNet 实现里可能会这样处理 Squeeze-and-Excitation (SE):

from torchvision.models.resnet import Bottleneck as _Bottleneck

class SEBottleneck(_Bottleneck):
    expansion = 4
    
    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
                 base_width=64, dilation=1, norm_layer=None,
                 *, reduction=16):  # 新增参数reduction控制压缩比例
        super().__init__(
            inplanes=inplanes,
            planes=planes,
            stride=stride,
            downsample=downsample,
            groups=groups,
            base_width=base_width,
            dilation=dilation,
            norm_layer=norm_layer)

        self.se_module = SEModule(planes * self.expansion, reduction=reduction)

    def forward(self, x):
        identity = 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)

        if hasattr(self, "se_module"):
            out = self.se_module(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out


def SEModule(channels, reduction):
    return nn.Sequential(
        nn.AdaptiveAvgPool2d(1),
        nn.Conv2d(channels, channels // reduction, kernel_size=1, padding=0),
        nn.ReLU(inplace=True),
        nn.Conv2d(channels // reduction, channels, kernel_size=1, padding=0),
        nn.Sigmoid()
    )

#### 3. 使用预训练权重迁移学习
考虑到计算资源有限以及开发效率问题，在 Jetson Nano 这样的边缘设备上部署深度神经网络时推荐采用迁移学习策略。通过加载已经过充分训练的基础模型（如ResNeXt），仅微调最后几层来适应具体应用场景，既可节省时间又能获得不错的效果[^2]。