class ResNet(nn.Module):
    def __init__(self,block, layers, num_class=1000, norm_layer=None):
        super(ResNet, self).__init__()
        if norm_layer is None:
            norm_layer = nn.BatchNorm2d
        self._norm_layer = norm_layer
 
        self.inplanes = 64
 
        #对应第一层conv1
        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride = 2, padding = 3, bias=False)#7*7卷积
        self.bn1 = norm_layer(self.inplanes)#正态分布（归一化操作）
 
        self.relu = nn.ReLU(inplace=True)#激活
 
        #对应第二层
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2)#3*3最大池化池化
 
        # stages部分，分别第1，2，3，4个stage
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
 
        #对应最后一层
        self.gap = nn.AdaptiveAvgPool2d((1,1))#平均池化
 
        self.linear = nn.Linear(512*block.expansion, num_class)#线性
 
        for m in self.modules():
        	#isinstance()函数来判断一个对象是否是一个已知的类型，类似 type()，其实就是没有正态分布的话咱就kaiming均匀分布。
            if isinstance(m, nn.Conv2d): 
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
				#kaiming均匀分布
            elif isinstance(m, nn.BatchNorm2d):#是正态分布
                nn.init.constant_(m.weight, 1)
			#torch.nn.init.constant(tensor, val)，用val的值填充输入的张量或变量，即变成全1分布
                nn.init.constant_(m.bias, 0)#偏置变为0
    def forward(self,x):
 
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.maxpool(out)
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.gap(out)
        out = nn.Flatten(out)#推平
        out = self.linear(out)
 
        return out

def _make_layer(self, block, planes, blocks, stride = 1):
 
    #将多个block拼接成一个stage，实现block之间的衔接；block指前面定义的BottleNeck或BasicBlock;planes指进行变换的通道数;blocks指这个stage中block的数目;stride：filter在原图上扫描时，需要跳跃的格数
 
        norm_layer = self._norm_layer
        downsample = None
        if stride !=1 or self.inplanes != block.expansion *planes:
        #形状不匹配的两种情况:(1)通道数目不匹配，（2）stride导致的feature map的尺寸不匹配
        
            downsample= nn.Sequential(
            conv1x1(self.inplanes, block.expansion *planes, stride = stride),
            norm_layer(block.expansion *planes)
                                )
# self.inplanes是block的输入通道数，planes是做3x3卷积的空间的通道数，expansion是残差结构中输出维度是输入维度的多少倍，同一个stage内，第一个block，inplanes=planes， 输出为planes*block.expansion
        # 第二个block开始，该block的inplanes等于上一层的输出的通道数planes*block.expansion（类似于卷积后的结果进入下一个卷积时，前一个卷积得到的output的输出为下一个卷积的input）
 
        layers = []
        layers.append(block(self.inplanes, blocks[0], stride=stride, downsample=downsample, norm_layer=norm_layer))
        #在一个stage中，只对stage中的第一个block中使用下采样(stride!=1)，其他的block都不影响feature map的维度的
        self.inplanes = planes * self.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, blocks[0], stride=stride, norm_layer=norm_layer))#这里就没有downsample了
 
        return nn.Sequential(*layers)# 变量名前加星号表示Unpack解包