minor update

Author: soapisnotfat

models/DenseNet.py

@@ -9,15 +9,15 @@ class Bottleneck(nn.Module):
     def __init__(self, in_planes, growth_rate):
         super(Bottleneck, self).__init__()
         self.bn1 = nn.BatchNorm2d(in_planes)
-        self.conv1 = nn.Conv2d(in_planes, 4*growth_rate, kernel_size=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(4*growth_rate)
-        self.conv2 = nn.Conv2d(4*growth_rate, growth_rate, kernel_size=3, padding=1, bias=False)
+        self.conv1 = nn.Conv2d(in_planes, 4 * growth_rate, kernel_size=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(4 * growth_rate)
+        self.conv2 = nn.Conv2d(4 * growth_rate, growth_rate, kernel_size=3, padding=1, bias=False)
 
     def forward(self, x):
-        out = self.conv1(func.relu(self.bn1(x)))
-        out = self.conv2(func.relu(self.bn2(out)))
-        out = torch.cat([out,x], 1)
-        return out
+        x = self.conv1(func.relu(self.bn1(x)))
+        x = self.conv2(func.relu(self.bn2(x)))
+        x = torch.cat([x, x], 1)
+        return x
 
 
 class Transition(nn.Module):
@@ -27,46 +27,46 @@ def __init__(self, in_planes, out_planes):
         self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)
 
     def forward(self, x):
-        out = self.conv(func.relu(self.bn(x)))
-        out = func.avg_pool2d(out, 2)
-        return out
+        x = self.conv(func.relu(self.bn(x)))
+        x = func.avg_pool2d(x, 2)
+        return x
 
 
 class DenseNet(nn.Module):
-    def __init__(self, block, nblocks, growth_rate=12, reduction=0.5, num_classes=10):
+    def __init__(self, block, num_block, growth_rate=12, reduction=0.5, num_classes=10):
         super(DenseNet, self).__init__()
         self.growth_rate = growth_rate
 
         num_planes = 2*growth_rate
         self.conv1 = nn.Conv2d(3, num_planes, kernel_size=3, padding=1, bias=False)
 
-        self.dense1 = self._make_dense_layers(block, num_planes, nblocks[0])
-        num_planes += nblocks[0]*growth_rate
-        out_planes = int(math.floor(num_planes*reduction))
+        self.dense1 = self._make_dense_layers(block, num_planes, num_block[0])
+        num_planes += num_block[0] * growth_rate
+        out_planes = int(math.floor(num_planes * reduction))
         self.trans1 = Transition(num_planes, out_planes)
         num_planes = out_planes
 
-        self.dense2 = self._make_dense_layers(block, num_planes, nblocks[1])
-        num_planes += nblocks[1]*growth_rate
-        out_planes = int(math.floor(num_planes*reduction))
+        self.dense2 = self._make_dense_layers(block, num_planes, num_block[1])
+        num_planes += num_block[1] * growth_rate
+        out_planes = int(math.floor(num_planes * reduction))
         self.trans2 = Transition(num_planes, out_planes)
         num_planes = out_planes
 
-        self.dense3 = self._make_dense_layers(block, num_planes, nblocks[2])
-        num_planes += nblocks[2]*growth_rate
-        out_planes = int(math.floor(num_planes*reduction))
+        self.dense3 = self._make_dense_layers(block, num_planes, num_block[2])
+        num_planes += num_block[2] * growth_rate
+        out_planes = int(math.floor(num_planes * reduction))
         self.trans3 = Transition(num_planes, out_planes)
         num_planes = out_planes
 
-        self.dense4 = self._make_dense_layers(block, num_planes, nblocks[3])
-        num_planes += nblocks[3]*growth_rate
+        self.dense4 = self._make_dense_layers(block, num_planes, num_block[3])
+        num_planes += num_block[3] * growth_rate
 
         self.bn = nn.BatchNorm2d(num_planes)
         self.linear = nn.Linear(num_planes, num_classes)
 
-    def _make_dense_layers(self, block, in_planes, nblock):
+    def _make_dense_layers(self, block, in_planes, num_block):
         layers = []
-        for i in range(nblock):
+        for i in range(num_block):
             layers.append(block(in_planes, self.growth_rate))
             in_planes += self.growth_rate
         return nn.Sequential(*layers)
@@ -84,20 +84,20 @@ def forward(self, x):
 
 
 def DenseNet121():
-    return DenseNet(Bottleneck, [6,12,24,16], growth_rate=32)
+    return DenseNet(Bottleneck, [6, 12, 24, 16], growth_rate=32)
 
 
 def DenseNet169():
-    return DenseNet(Bottleneck, [6,12,32,32], growth_rate=32)
+    return DenseNet(Bottleneck, [6, 12, 32, 32], growth_rate=32)
 
 
 def DenseNet201():
-    return DenseNet(Bottleneck, [6,12,48,32], growth_rate=32)
+    return DenseNet(Bottleneck, [6, 12, 48, 32], growth_rate=32)
 
 
 def DenseNet161():
-    return DenseNet(Bottleneck, [6,12,36,24], growth_rate=48)
+    return DenseNet(Bottleneck, [6, 12, 36, 24], growth_rate=48)
 
 
 def densenet_cifar():
-    return DenseNet(Bottleneck, [6,12,24,16], growth_rate=12)
+    return DenseNet(Bottleneck, [6, 12, 24, 16], growth_rate=12)

models/ResNet.py

@@ -2,19 +2,6 @@
 import math
 
 
-__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
-           'resnet152']
-
-
-model_urls = {
-    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
-    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
-    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
-    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
-    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
-}
-
-
 def conv3x3(in_planes, out_planes, stride=1):
     # 3x3 convolution with padding
     return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
@@ -36,20 +23,20 @@ def __init__(self, inplanes, planes, stride=1, downsample=None):
     def forward(self, x):
         residual = x
 
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
 
-        out = self.conv2(out)
-        out = self.bn2(out)
+        x = self.conv2(x)
+        x = self.bn2(x)
 
         if self.downsample is not None:
             residual = self.downsample(x)
 
-        out += residual
-        out = self.relu(out)
+        x += residual
+        x = self.relu(x)
 
-        return out
+        return x
 
 
 class Bottleneck(nn.Module):
@@ -70,24 +57,24 @@ def __init__(self, inplanes, planes, stride=1, downsample=None):
     def forward(self, x):
         residual = x
 
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
 
-        out = self.conv2(out)
-        out = self.bn2(out)
-        out = self.relu(out)
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
 
-        out = self.conv3(out)
-        out = self.bn3(out)
+        x = self.conv3(x)
+        x = self.bn3(x)
 
         if self.downsample is not None:
             residual = self.downsample(x)
 
-        out += residual
-        out = self.relu(out)
+        x += residual
+        x = self.relu(x)
 
-        return out
+        return x
 
 
 class ResNet(nn.Module):