Deep Learning Practice End Term: 13 April 2025 (January 2025 term)

1import torch
2import torch.nn as nn
3from torchvision.models import alexnet
4
5class CustomAlexNet(nn.Module):
6    def __init__(self, num_classes=10):
7        super(CustomAlexNet, self).__init__()
8        self.alexnet = alexnet(pretrained=True)
9        # Blank portion
10    def forward(self, x):
11        x = self.alexnet.features(x)
12        x = self.alexnet.avgpool(x)
13        x = torch.flatten(x, 1)
14        x = self.alexnet.classifier(x)
15        return x
16
17model = CustomAlexNet()

1import torch
2import torch.nn as nn
3import torch.nn.functional as F
4
5class CNN(nn.Module):
6    def __init__(self):
7        super(CNN, self).__init__()
8        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
9        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
10        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
11
12        # Fully Connected (FC) Layer - Missing Part
13
14    def forward(self, x):
15        x = self.pool(F.relu(self.conv1(x)))
16        x = self.pool(F.relu(self.conv2(x)))
17        x = torch.flatten(x, 1) # Flatten feature map
18
19        # Missing part
20
21        return x

1# Predicted bounding boxes and confidence scores
2predictions = [
3    {'bbox': [40, 40, 90, 90], 'score': 0.85},
4    {'bbox': [20, 20, 60, 60], 'score': 0.80},
5    {'bbox': [150, 150, 200, 200], 'score': 0.65},
6    {'bbox': [250, 250, 300, 300], 'score': 0.50}
7]
8
9# Ground truth bounding boxes
10ground_truths = [
11    {'bbox': [40, 40, 90, 90]},
12    {'bbox': [20, 20, 60, 60]},
13    {'bbox': [150, 150, 200, 200]}
14]
15
16# Function to calculate IoU (Intersection over Union)
17def calculate_iou(box1, box2):
18    x1 = max(box1[0], box2[0])
19    y1 = max(box1[1], box2[1])
20    x2 = min(box1[2], box2[2])
21    y2 = min(box1[3], box2[3])
22    intersection = max(0, x2 - x1) * max(0, y2 - y1)
23    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
24    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
25    union = area1 + area2 - intersection
26    return intersection / union if union > 0 else 0
27
28# Match predictions with ground truths (IoU > 0.5 considered correct)
29threshold = 0.5
30true_positives = 0
31false_positives = 0
32false_negatives = len(ground_truths)
33
34for pred in predictions:
35    matched = False
36    for gt in ground_truths:
37        iou = calculate_iou(pred['bbox'], gt['bbox'])
38        if iou >= threshold:
39            true_positives += 1
40            false_negatives -= 1
41            matched = True
42            break
43    if not matched:
44        false_positives += 1
45
46precision = true_positives / (true_positives + false_positives)
47recall = true_positives / (true_positives + false_negatives)
48
49print(f"Precision: {precision:.2f}")
50print(f"Recall: {recall:.2f}")

1# Predicted labels and ground truth labels
2predictions = [1, 1, 0, 1, 0, 0, 1, 0, 1, 1]
3ground_truth = [1, 0, 0, 1, 0, 1, 1, 0, 1, 0]
4
5# Confusion matrix components
6true_positive = sum([1 for p, g in zip(predictions, ground_truth) if p == 1 and g == 1])
7false_positive = sum([1 for p, g in zip(predictions, ground_truth) if p == 1 and g == 0])
8false_negative = sum([1 for p, g in zip(predictions, ground_truth) if p == 0 and g == 1])
9
10# Precision and Recall Calculation
11precision = true_positive / (true_positive + false_positive) if (true_positive + false_positive) > 0
12else 0
13
14recall = true_positive / (true_positive + false_negative) if (true_positive + false_negative) > 0
15else 0
16
17# F1-Score Calculation
18f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
19
20print(f"F1-Score: {f1_score:.2f}")

1import torch
2import torch.nn as nn
3
4class ResNetBlock(nn.Module):
5    def __init__(self, in_channels, out_channels, stride=1):
6        super(ResNetBlock, self).__init__()
7        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1,
8        bias=False)
9        self.bn1 = nn.BatchNorm2d(out_channels)
10        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1,
11        bias=False)
12        self.bn2 = nn.BatchNorm2d(out_channels)
13        self.relu = nn.ReLU(inplace=True)
14
15        self.shortcut = nn.Sequential()
16        if stride != 1 or in_channels != out_channels:
17            self.shortcut = nn.Sequential(
18                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
19                nn.BatchNorm2d(out_channels)
20            )
21
22    def forward(self, x):
23        identity = x  # Store residual connection
24        out = self.conv1(x)
25        out = self.bn1(out)
26        out = self.relu(out)
27        out = self.conv2(out)
28        out = self.bn2(out)
29
30        # Missing Code
31
32        out = self.relu(out)
33        return out
34
35model = ResNetBlock(64, 128, stride=2)