Deep Learning Practice End Term: 22 December 2024 (September 2024 term)

1import torch
2import torch.nn as nn
3from torchvision.models import vgg16, vgg19
4
5# Block A: VGGNet-16 with modified classification head
6class VGG16Modified(nn.Module):
7    def __init__(self, num_classes=10):
8        super(VGG16Modified, self).__init__()
9        self.vgg16 = vgg16(pretrained=True)
10        self.vgg16.classifier[6] = nn.Linear(4096, num_classes)
11
12    def forward(self, x):
13        return self.vgg16(x)
14
15model_a = VGG16Modified()
16
17# Block B: VGGNet-19 with modified classification head
18class VGG19Modified(nn.Module):
19    def __init__(self, num_classes=10):
20        super(VGG19Modified, self).__init__()
21        self.vgg19 = vgg19(pretrained=True)
22        self.vgg19.classifier[6] = nn.Linear(4096, num_classes)
23
24    def forward(self, x):
25        return self.vgg19(x)
26
27model_b = VGG19Modified()
28
29# Block C: Loading VGGNet-16 and freezing feature extraction layers
30vgg16_model = vgg16(pretrained=True)
31for param in vgg16_model.features.parameters():
32    param.requires_grad = False
33vgg16_model.classifier[6] = nn.Linear(4096, 10)
34
35# Block D: VGGNet-19 with feature extraction layers unfrozen
36vgg19_model = vgg19(pretrained=True)
37vgg19_model.classifier[6] = nn.Linear(4096, 10)

1import torch
2import torch.nn as nn
3
4class RegionProposal(nn.Module):
5    def __init__(self, in_channels):
6        super(RegionProposal, self).__init__()
7        self.conv = nn.Conv2d(in_channels, 256, kernel_size=3, stride=1, padding=1)
8        self.cls_layer = nn.Conv2d(256, 18, kernel_size=1)
9        self.reg_layer = nn.Conv2d(256, 36, kernel_size=1)
10
11    def forward(self, x):
12        features = torch.relu(self.conv(x))
13        cls_logits = self.cls_layer(features)
14        reg_deltas = self.reg_layer(features)
15        return cls_logits, reg_deltas

1import torchvision.models as models
2
3class FeatureExtractor(nn.Module):
4    def __init__(self):
5        super(FeatureExtractor, self).__init__()
6        vgg = models.vgg16(pretrained=True)
7        self.features = vgg.features  # Use pre-trained VGG16 convolutional layers
8
9    def forward(self, x):
10        return self.features(x)

1from torchvision.ops import roi_pool
2
3class ROIPooling(nn.Module):
4    def __init__(self, output_size=(7, 7)):
5        super(ROIPooling, self).__init__()
6        self.output_size = output_size
7
8    def forward(self, feature_map, proposals):
9        return roi_pool(feature_map, proposals, output_size=self.output_size)

1class FullyConnectedHead(nn.Module):
2    def __init__(self, in_features, num_classes):
3        super(FullyConnectedHead, self).__init__()
4        self.fc1 = nn.Linear(in_features, 4096)
5        self.fc2 = nn.Linear(4096, 4096)
6        self.cls_score = nn.Linear(4096, num_classes)
7        self.bbox_pred = nn.Linear(4096, num_classes * 4)  # 4 coordinates per class
8
9    def forward(self, x):
10        x = torch.relu(self.fc1(x))
11        x = torch.relu(self.fc2(x))
12        cls_logits = self.cls_score(x)
13        bbox_deltas = self.bbox_pred(x)
14        return cls_logits, bbox_deltas

1import torch
2
3def calculate_iou(box1, box2):
4    # Calculate intersection
5    x1 = torch.max(box1[0], box2[0])
6    y1 = torch.max(box1[1], box2[1])
7    x2 = torch.min(box1[2], box2[2])
8    y2 = torch.min(box1[3], box2[3])
9    intersection = torch.clamp(x2 - x1, min=0) * torch.clamp(y2 - y1, min=0)
10
11    # Calculate union
12    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
13    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
14    union = area1 + area2 - intersection
15
16    # Compute IoU
17    iou = intersection / union if union > 0 else 0
18    return iou
19
20# Bounding boxes: [x1, y1, x2, y2]
21box1 = torch.tensor([0, 0, 2, 2])
22box2 = torch.tensor([1, 1, 3, 3])
23
24print(calculate_iou(box1, box2))

1import torch
2import torch.nn as nn
3
4class DepthNetwork(nn.Module):
5    def __init__(self):
6        super(DepthNetwork, self).__init__()
7        self.encoder = nn.Sequential(
8            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
9            nn.ReLU(),
10            nn.Conv2d(64, 128, kernel_size=5, stride=2, padding=2),
11            nn.ReLU()
12        )
13        self.fc = nn.Sequential(
14            nn.Linear(128 * 28 * 28, 1024),
15            nn.ReLU(),
16            nn.Linear(1024, 128 * 56 * 56)
17        )
18    def forward(self, x):
19        x = self.encoder(x)
20        x = x.view(x.size(0), -1)
21        x = self.fc(x)
22        x = x.view(x.size(0), 128, 56, 56)
23        return x

1import torch
2import torch.nn as nn
3
4class DepthRefinementNetwork(nn.Module):
5    def __init__(self):
6        super(DepthRefinementNetwork, self).__init__()
7        self.refinement = nn.Sequential(
8            nn.Conv2d(131, 64, kernel_size=3, padding=1),
9            nn.ReLU(),
10            nn.Conv2d(64, 1, kernel_size=3, padding=1)
11        )
12
13    def forward(self, coarse_depth, rgb):
14        x = torch.cat((coarse_depth, rgb), dim=1)  # Concatenate coarse depth and RGB
15        x = self.refinement(x)
16        return x