Python Pytorch&x2B；剩余网络抛出意外：TypeError:'；非类型'；对象不可调用

我正在深入学习，因为Python是我最杰出的编程语言，所以我决定从Pytorch框架开始。接下来，我实现了一个50层的ResNet。之后，我尝试用更简单的块制作ResNet-18，如下所示：

class baseBlock(torch.nn.Module):
  expansion = 1
  def __init__(self,input_planes,planes,stride=1,dim_change=None):
    super(baseBlock,self).__init__()
    #Declare convolutional layers with batch norms
    self.conv1 = torch.nn.Conv2d(input_planes, planes, stride=stride, kernel_size=3, padding=1)
    self.bn1   = torch.nn.BatchNorm2d(planes)
    self.conv2 = torch.nn.Conv2d(planes, planes, stride=1, kernel_size=3, padding=1)
    self.bn2   = torch.nn.BatchNorm2d(planes)
    self.dim_change = dim_change

  def forward(self,x):
    #Save the residue
    res = x
    output = F.relu(self.bn1(self.conv1(x)))
    output = self.bn2(self.conv2(output))

    if self.dim_change is not None:
      res = self.dim_change(res)

    output += res
    output = F.relu(output)

    return output

我将代码分为块和实际的神经网络，以使其更易于理解。NN的其余代码为：

class ResNet(torch.nn.Module):
  def __init__(self,block,num_layers,classes=10):
    super(ResNet,self).__init__()
    #according to research paper
    self.input_planes = 64
    self.conv1  = torch.nn.Conv2d(3,64,kernel_size =3,stride=1,padding=1)
    self.bn1    = torch.nn.BatchNorm2d(64)
    self.layer1 = self._layer(block, 64, num_layers[0], stride=1)
    self.layer2 = self._layer(block, 128, num_layers[1], stride=2)
    self.layer3 = self._layer(block, 256, num_layers[2], stride=2)
    self.layer4 = self._layer(block, 512, num_layers[3], stride=2)
    self.avaragePool = torch.nn.AvgPool2d(kernel_size=4,stride=1)
    self.fc = torch.nn.Linear(512*block.expansion, classes)


  def _layer(self,block,planes,num_layers,stride=1):
    dim_change = None
    if stride != 1 or planes != self.input_planes*block.expansion:
      dim_change = torch.nn.Sequential(torch.nn.Conv2d(self.input_planes, planes*block.expansion, kernel_size = 1, stride=stride),
                                                        torch.nn.BatchNorm2d(planes*block.expansion))
      netLayers = []
      netLayers.append(block(self.input_planes,planes,stride=stride, dim_change=dim_change))

      self.input_planes = planes*block.expansion

      for i in range(1,num_layers):
        netLayers.append(block(self.input_planes,planes))
        self.input_planes = planes * block.expansion

      return torch.nn.Sequential(*netLayers)


  def forward(self,x):
    x = F.relu(self.bn1(self.conv1(x)))

    #Problem at this layer
    x = self.layer1(x) <- NoneType object is not callable
    x = self.layer2(x)
    x = self.layer3(x)
    x = self.layer4(x)

    x = F.avg_pool2d(x,4)
    x = x.view(x.size(0),-1)
    x = self.fc(x)

    return x

class ResNet（火炬网络模块）：
定义初始化（self、block、num\u层，类=10）：
超级（ResNet，self）。\uuuu init\uuuuu（）
#根据研究论文
self.input_planes=64
self.conv1=torch.nn.Conv2d（3,64，内核大小=3，步幅=1，填充=1）
self.bn1=torch.nn.BatchNorm2d（64）
self.layer1=self.\u层（块，64，num\u层[0]，步长=1）
self.layer2=self.\u层（块，128，num\u层[1]，步长=2）
self.layer3=self.\u层（块，256，num\u层[2]，步长=2）
self.layer4=self.\u层（块，512，num\u层[3]，步长=2）
self.avaragepol=torch.nn.AvgPool2d（内核大小=4，步幅=1）
self.fc=torch.nn.线性（512*block.expansion，类）
定义层（自身、块、平面、数量层、跨步=1）：
尺寸变化=无
如果大步走！=一架或多架飞机！=self.input_planes*block.expansion:
尺寸更改=torch.nn.Sequential（torch.nn.Conv2d（self.input\u平面，平面*block.expansion，内核大小=1，步幅=步幅），
火炬nn.2D（平面*块扩展））
网络层=[]
附加（块（self.input\u平面，平面，跨步=跨步，尺寸更改=尺寸更改））
self.input_planes=平面*block.expansion
对于范围内的i（1，num_层）：
netLayers.append（块（自输入平面，平面））
self.input_planes=平面*block.expansion
返回火炬.nn.顺序（*netLayers）
def前进（自身，x）：
x=F.relu（self.bn1（self.conv1（x）））
#这一层的问题
这是一个简单的打字错误。您的
返回值
位于
if
中，唯一的
跨距=1的层是
层1
：

def_层（self、block、planes、num_层、stride=1）：
尺寸变化=无
如果大步走！=一架或多架飞机！=self.input_planes*block.expansion:
# [...]
返回火炬.nn.顺序（*netLayers）

因此，对于
第1层
，没有
返回
，因此
无
这是一个简单的打字错误。您的
返回值
位于
if
中，唯一的
跨距=1的层是
层1
：

def_层（self、block、planes、num_层、stride=1）：
尺寸变化=无
如果大步走！=一架或多架飞机！=self.input_planes*block.expansion:
# [...]
返回火炬.nn.顺序（*netLayers）

因此，对于
第1层
，没有
返回
，因此
无
您是对的，我正在寻找一个更复杂的错误，并错过了这个缩进错误。这个问题可以考虑解决，但我还有一个相关的问题。我不知道如何使用*netLayers，也不知道如何使用它。我解决了这个问题，在if语句之后添加了这段代码：
else:netLayers=[]netLayers.append（block（self.input\u planes，planes））return torch.nn.Sequential（*netLayers）
网络训练、丢失函数下降、准确性上升，但我想知道为什么这样做。谢谢你的时间。@CarlosHernandezPerez sry，但我不明白这个问题。你不了解星型运营者还是别的什么？评论不是针对这类事情的，但也许我可以告诉你是否值得再问一个问题。我将在这里停止提问，因为再花几个小时的编码就会给我答案。您的回答非常有帮助，谢谢。您是对的，我正在寻找一个更复杂的错误，但错过了这个缩进错误。这个问题可以考虑解决，但我还有一个相关的问题。我不知道如何使用*netLayers，也不知道如何使用它。我解决了这个问题，在if语句之后添加了这段代码：
else:netLayers=[]netLayers.append（block（self.input\u planes，planes））return torch.nn.Sequential（*netLayers）
网络训练、丢失函数下降、准确性上升，但我想知道为什么这样做。谢谢你的时间。@CarlosHernandezPerez sry，但我不明白这个问题。你不了解星型运营者还是别的什么？评论不是针对这类事情的，但也许我可以告诉你是否值得再问一个问题。我将在这里停止提问，因为再花几个小时的编码就会给我答案。你的回答很有帮助，谢谢。