first commit

Author: Ruibo Zhang

README.md

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+
+class block(nn.Module):
+    def __init__(self, in_channels, out_channels, identity_downsample=None, stride=1):
+        super(block, self).__init__()
+        self.expansion = 4
+        self.cov1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.cov2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+        self.cov3 = nn.Conv2d(out_channels, out_channels * self.expansion, kernel_size=1, stride=1, padding=0)
+        self.bn3 = nn.BatchNorm2d(out_channels * self.expansion)
+        self.relu = nn.ReLU()
+        self.identity_downsample = identity_downsample
+
+    def forward(self, x):
+        identity = x
+
+        x = self.relu(self.bn1(self.cov1(x)))
+        x = self.relu(self.bn2(self.cov2(x)))
+        x = self.bn3(self.cov3(x))
+
+        if self.identity_downsample is not None:
+            identity = self.identity_downsample(identity)
+        
+        x += identity
+        x = self.relu(x)
+        return x
+    
+    
+class ResNet(nn.Module):
+    def __init__(self, block, layers, image_channels, num_classes):
+        super(ResNet, self).__init__()
+        self.in_channels = 64
+        self.conv1 = nn.Conv2d(image_channels, 64, kernel_size=7, stride=2, padding=3)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.relu = nn.ReLU()
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
+        self.layer1 = self._make_layer(block, layers[0], out_channels=64, stride=1)
+        self.layer2 = self._make_layer(block, layers[1], out_channels=128, stride=2)
+        self.layer3 = self._make_layer(block, layers[2], out_channels=256, stride=2)
+        self.layer4 = self._make_layer(block, layers[3], out_channels=512, stride=2)
+
+        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
+        self.fc = nn.Linear(512*4, num_classes)
+
+    def forward(self, x):
+        x = self.maxpool(self.relu(self.bn1(self.conv1(x))))
+        x = self.layer4(self.layer3(self.layer2(self.layer1(x))))
+        x = self.avgpool(x)
+        x = x.reshape(x.shape[0], -1)
+        x = self.fc(x)
+        return x
+
+    def _make_layer(self, block, num_residual_blocks, out_channels, stride):
+        identity_downsample = None
+        layers = []
+
+        if stride != 1 or self.in_channels != out_channels * 4:
+            identity_downsample = nn.Sequential(nn.Conv2d(self.in_channels, out_channels * 4, kernel_size=1,
+                                                          stride=stride),
+                                                nn.BatchNorm2d(out_channels * 4))
+            
+        layers.append(block(self.in_channels, out_channels, identity_downsample, stride))
+        self.in_channels = out_channels * 4
+
+        for i in range(num_residual_blocks - 1):
+            layers.append(block(self.in_channels, out_channels))
+
+        return nn.Sequential(*layers)
+    
+
+def ResNet50(img_channels=3, num_classes=1000):
+    return ResNet(block, [3, 4, 6, 3], img_channels, num_classes)
+
+
+def ResNet101(img_channels=3, num_classes=1000):
+    return ResNet(block, [3, 4, 23, 3], img_channels, num_classes)
+
+
+def ResNet152(img_channels=3, num_classes=1000):
+    return ResNet(block, [3, 8, 36, 3], img_channels, num_classes)
+
+def test():
+    net = ResNet152()
+    x = torch.randn(2, 3, 224, 224)
+    y = net(x)
+    print(y.shape)
+
+test()

ResNet.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+
+class ZeroConvBatchNorm(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(ZeroConvBatchNorm, self).__init__()
+
+        # Define zero convolutional layer and batch normalization
+        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        self.conv.weight.data.fill_(0)  # Set all weights to zero
+        self.bn = nn.BatchNorm2d(out_channels)
+
+    def forward(self, x):
+        out = self.conv(x)
+        out = self.bn(out)
+        return out
+
+class IdentityMappingModule(nn.Module):
+    def __init__(self, in_channels, hidden_channels):
+        super(IdentityMappingModule, self).__init__()
+
+        layers = []
+        for _ in range(6):  # Create 6 pairs of zero conv and batch norm layers
+            zero_conv_bn = ZeroConvBatchNorm(hidden_channels, hidden_channels)
+            layers.append(zero_conv_bn)
+        self.identity_module = nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = self.identity_module(x)
+        return out + x  # Skip connection
+
+# Example usage
+input_channels = 3
+hidden_channels = 3
+input_tensor = torch.randn(8, input_channels, 32, 32)  # Example input tensor with batch size 8
+
+identity_module = IdentityMappingModule(input_channels, hidden_channels)
+output_tensor = identity_module(input_tensor)
+
+print("Input tensor shape:", input_tensor)
+print("Output tensor shape:", output_tensor)
+print(input_tensor == output_tensor)
+