更新数据集下载链接

.gitignore

@@ -1,4 +1,4 @@
-dataset/
+raw/
 
 .vscode/
 

Lab2/前馈神经网络实验.ipynb

@@ -1740,6 +1740,19 @@
     "\n",
     "在用时上，由于模型较小，数据集也较小，用时基本没有差别。"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 心得体会\r\n",
+    "\r\n",
+    "在本次实验中，我手动实现了基础的神经网络模块，包括全连接层、激活函数、损失函数等。这加深了我对神经网络内部工作原理的理解。通过手动实现的过程，让我更清楚神经网络的各个组成部分是如何协同工作的。\r\n",
+    "\r\n",
+    "我比较不同激活函数和网络结构对模型性能的影响。通过实验发现`sigmoid`函数容易导致梯度消失，而`ReLU`和`Leaky ReLU`等激活函数表现较好。隐藏层的层数和神经元个数也会影响最终的准确率。这让我明白了选择合适的激活函数和网络结构对获得良好性能至关重要。\r\n",
+    "\r\n",
+    "通过系统地调参、训练不同的模型，记录并对比它们的损失曲线和准确率曲线，我也更深入地理解了不同模型设置的优劣。当然本次实验使用的模型还是非常基础的模型，我非常期待在后面的实验中使用复杂的模型，提升我对深度学习的认识。"
+   ]
   }
  ],
  "metadata": {

Lab3/code/1.1.py

@@ -0,0 +1,29 @@
+import torch
+from torch import nn
+from utils import *
+
+
+class My_Dropout(nn.Module):
+    def __init__(self, p, **kwargs):
+        super().__init__()
+        self.p = p
+        self.mask = None
+
+    def forward(self, x: torch.Tensor):
+        if self.training:
+            self.mask = (torch.rand(x.shape) > self.p).to(dtype=torch.float32, device=x.device)
+            return x * self.mask / (1 - self.p)
+        else:
+            return x
+
+
+if __name__ == "__main__":
+    my_dropout = My_Dropout(p=0.5)
+    nn_dropout = nn.Dropout(p=0.5)
+    x = torch.tensor([[1.0, 2.0, 3.0, 4.0, 5.0], 
+                      [6.0, 7.0, 8.0, 9.0, 10.0]])
+    print(f"输入：\n{x}")
+    output_my_dropout = my_dropout(x)
+    output_nn_dropout = nn_dropout(x)
+    print(f"My_Dropout输出：\n{output_my_dropout}")
+    print(f"nn.Dropout输出：\n{output_nn_dropout}")

Lab3/code/1.2.py

@@ -0,0 +1,14 @@
+import numpy as np
+import torch
+from utils import *
+
+
+if __name__ == "__main__":
+    learning_rate = 8e-2
+    num_epochs = 101
+    for i in np.arange(3):
+        dropout_rate = 0.1 + 0.4 * i
+        model = MNIST_CLS_Model(num_classes=10, dropout_rate=dropout_rate)
+        optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
+        print(f"dropout_rate={dropout_rate}")
+        train_loss, test_acc = train_MNIST_CLS(model, optimizer, num_epochs=num_epochs)

Lab3/code/2.1.py

@@ -0,0 +1,49 @@
+import torch
+from utils import *
+
+
+class My_SGD:
+    def __init__(self, params: list[torch.Tensor], lr: float, weight_decay=0.0):
+        self.params = params
+        self.lr = lr
+        self.weight_decay = weight_decay
+
+    def step(self):
+        with torch.no_grad():
+            for param in self.params:
+                if param.grad is not None:
+                    if len(param.data.shape) > 1:
+                        param.data = param.data - self.lr * (param.grad + self.weight_decay * param.data)
+                    else:
+                        param.data = param.data - self.lr * param.grad
+
+    def zero_grad(self):
+        for param in self.params:
+            if param.grad is not None:
+                param.grad.data = torch.zeros_like(param.grad.data)
+
+
+if __name__ == "__main__":
+    params1 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+    params2 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+
+    my_sgd = My_SGD(params=[params1], lr=0.5, weight_decay=0.1)
+    optim_sgd = torch.optim.SGD(params=[params2], lr=0.5, weight_decay=0.1)
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+
+    loss1 = 2 * params1.sum()
+    loss2 = 2 * params2.sum()
+    # 偏导为2
+    loss1.backward()
+    loss2.backward()
+    print("params1的梯度为：\n", params1.grad.data)
+    print("params2的梯度为：\n", params2.grad.data)
+
+    my_sgd.step()
+    optim_sgd.step()
+    # 结果为：w - lr * grad - lr * weight_decay_rate * w
+    # w[0] = 1 - 0.5 * 2 - 0.5 * 0.1 * 1 = -0.0500
+    # w[1] = 2 - 0.5 * 2 - 0.5 * 0.1 * 2 = 0.9000
+    print("经过L_2正则化后的My_SGD反向传播结果：\n", params1.data)
+    print("经过L_2正则化后的torch.optim.SGD反向传播结果：\n", params2.data)

Lab3/code/2.2.py

@@ -0,0 +1,15 @@
+import numpy as np
+import torch
+from utils import *
+
+
+if __name__ == "__main__":
+    learning_rate = 8e-2
+    num_epochs = 101
+    color = ["blue", "green", "orange", "purple"]
+    for i in np.arange(4):
+        weight_decay_rate = i / 4 * 0.01
+        model = MNIST_CLS_Model(num_classes=10, dropout_rate=0)
+        optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay_rate)
+        print(f"weight_decay_rate={weight_decay_rate}")
+        train_loss, test_acc = train_MNIST_CLS(model, optimizer, num_epochs=num_epochs)

Lab3/code/3.1.py

@@ -0,0 +1,64 @@
+import torch
+from utils import *
+
+
+# 手动实现torch.optim.SGD
+class My_SGD:
+    def __init__(self, params: list[torch.Tensor], lr: float, weight_decay=0.0, momentum=0.0):
+        self.params = params
+        self.lr = lr
+        self.weight_decay = weight_decay
+        self.momentum = momentum
+        self.velocities = [torch.zeros_like(param.data) for param in params]
+
+    def step(self):
+        with torch.no_grad():
+            for index, param in enumerate(self.params):
+                if param.grad is not None:
+                    if self.weight_decay > 0:
+                        if len(param.data.shape) > 1:
+                            param.grad.data = (param.grad.data + self.weight_decay * param.data)
+                    self.velocities[index] = (self.momentum * self.velocities[index] - self.lr * param.grad)
+                    param.data = param.data + self.velocities[index]
+
+    def zero_grad(self):
+        for param in self.params:
+            if param.grad is not None:
+                param.grad.data = torch.zeros_like(param.grad.data)
+
+
+if __name__ == "__main__":
+    params1 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+    params2 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+
+    my_sgd = My_SGD(params=[params1], lr=0.5, momentum=1)
+    optim_sgd = torch.optim.SGD(params=[params2], lr=0.5, momentum=1)
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+
+    loss1 = 2 * params1.sum()
+    loss2 = 2 * params2.sum()
+    # 偏导为2
+    loss1.backward()
+    loss2.backward()
+    my_sgd.step()
+    optim_sgd.step()
+    # 结果为：w - lr * grad + momentum * velocity
+    # w[0] = 1 - 0.5 * 2 + 1 * 0 = 0
+    # w[1] = 2 - 0.5 * 2 + 1 * 0 = 1
+    print("My_SGD第1次反向传播结果：\n", params1.data)
+    print("torch.optim.SGD第1次反向传播结果：\n", params2.data)
+
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+    loss1 = -3 * params1.sum()
+    loss2 = -3 * params2.sum()
+    loss1.backward()
+    loss2.backward()
+    my_sgd.step()
+    optim_sgd.step()
+    # 结果为：w - lr * grad + momentum * velocity
+    # w[0] = 0 - 0.5 * -3 + 1 * (-0.5 * 2) = 0.5
+    # w[1] = 1 - 0.5 * -3 + 1 * (-0.5 * 2) = 1.5
+    print("My_SGD第2次反向传播结果：\n", params1.data)
+    print("torch.optim.SGD第2次反向传播结果：\n", params2.data)

Lab3/code/3.2.py

@@ -0,0 +1,63 @@
+import torch
+from utils import *
+
+
+class My_RMSprop:
+    def __init__(self, params: list[torch.Tensor], lr=1e-2, alpha=0.99, eps=1e-8):
+        self.params = params
+        self.lr = lr
+        self.alpha = alpha
+        self.eps = eps
+        self.square_avg = [torch.zeros_like(param.data) for param in params]
+        
+
+    def step(self):
+        with torch.no_grad():
+            for index, param in enumerate(self.params):
+                if param.grad is not None:
+                    self.square_avg[index] = self.alpha * self.square_avg[index] + (1 - self.alpha) * param.grad ** 2
+                    param.data = param.data - self.lr * param.grad / torch.sqrt(self.square_avg[index] + self.eps)
+
+    def zero_grad(self):
+        for param in self.params:
+            if param.grad is not None:
+                param.grad.data = torch.zeros_like(param.grad.data)
+
+
+if __name__ == "__main__":
+    params1 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+    params2 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+
+    my_sgd = My_RMSprop(params=[params1], lr=1, alpha=0.5, eps=1e-8)
+    optim_sgd = torch.optim.RMSprop(params=[params2], lr=1, alpha=0.5, eps=1e-8)
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+
+    loss1 = 2 * params1.sum()
+    loss2 = 2 * params2.sum()
+    # 偏导为2
+    loss1.backward()
+    loss2.backward()
+    my_sgd.step()
+    optim_sgd.step()
+    # s = alpha * s + (1-alpha) * grad^2 = 0.5 * 0 + (1-0.5) * 2^2 = 2
+    # w = w - lr * grad * (s + eps)^0.5
+    # w[0] = 1 - 1 * 2 / (2 + 1e-8)^0.5 ~= -0.41
+    # w[1] = 2 - 1 * 2 / (2 + 1e-8)^0.5 ~= -0.59
+    print("My_RMSprop第1次反向传播结果：\n", params1.data)
+    print("torch.optim.RMSprop第1次反向传播结果：\n", params2.data)
+
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+    loss1 = -3 * params1.sum()
+    loss2 = -3 * params2.sum()
+    loss1.backward()
+    loss2.backward()
+    my_sgd.step()
+    optim_sgd.step()
+    # s = alpha * s + (1-alpha) * grad^2 = 0.5 * 2 + (1-0.5) * (-3)^2 = 5.5
+    # w - lr * grad * (s + eps)^0.5
+    # w[0] = -0.41 - 1 * -3 / (5.5 + 1e-8)^0.5 ~= 0.87
+    # w[1] = 0.59 - 1 * -3 / (5.5 + 1e-8)^0.5 ~= 1.86
+    print("My_RMSprop第2次反向传播结果：\n", params1.data)
+    print("torch.optim.RMSprop第2次反向传播结果：\n", params2.data)

Lab3/code/3.3.py

@@ -0,0 +1,64 @@
+import torch
+from utils import *
+
+
+class My_Adam:
+    def __init__(self, params: list[torch.Tensor], lr=1e-3, betas=(0.9, 0.999), eps=1e-8):
+        self.params = params
+        self.lr = lr
+        self.beta1 = betas[0]
+        self.beta2 = betas[1]
+        self.eps = eps
+        self.t = 0
+        self.momentums = [torch.zeros_like(param.data) for param in params]
+        self.velocities = [torch.zeros_like(param.data) for param in params]
+
+    def step(self):
+        self.t += 1
+        with torch.no_grad():
+            for index, param in enumerate(self.params):
+                if param.grad is not None:
+                    self.momentums[index] = (self.beta1 * self.momentums[index] + (1 - self.beta1) * param.grad)
+                    self.velocities[index] = (self.beta2 * self.velocities[index] + (1 - self.beta2) * param.grad ** 2)
+
+                    momentums_hat = self.momentums[index] / (1 - self.beta1 ** self.t)
+                    velocities_hat = self.velocities[index] / (1 - self.beta2 ** self.t)
+
+                    param.data = param.data - self.lr * momentums_hat / (torch.sqrt(velocities_hat) + self.eps)
+
+    def zero_grad(self):
+        for param in self.params:
+            if param.grad is not None:
+                param.grad.data = torch.zeros_like(param.grad.data)
+
+
+if __name__ == "__main__":
+    params1 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+    params2 = torch.tensor([[1.0, 2.0]], requires_grad=True)
+
+    my_sgd = My_Adam(params=[params1], lr=1, betas=(0.5, 0.5), eps=1e-8)
+    optim_sgd = torch.optim.Adam(params=[params2], lr=1, betas=(0.5, 0.5), eps=1e-8)
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+
+    loss1 = 2 * params1.sum()
+    loss2 = 2 * params2.sum()
+    # 偏导为2
+    loss1.backward()
+    loss2.backward()
+    my_sgd.step()
+    optim_sgd.step()
+    print("My_Adam第1次反向传播结果：\n", params1.data)
+    print("torch.optim.Adam第1次反向传播结果：\n", params2.data)
+
+    my_sgd.zero_grad()
+    optim_sgd.zero_grad()
+    loss1 = -3 * params1.sum()
+    loss2 = -3 * params2.sum()
+    # 偏导为-3
+    loss1.backward()
+    loss2.backward()
+    my_sgd.step()
+    optim_sgd.step()
+    print("My_Adam第2次反向传播结果：\n", params1.data)
+    print("torch.optim.Adam第2次反向传播结果：\n", params2.data)

Lab3/code/3.4.py

@@ -0,0 +1,23 @@
+import torch
+from utils import *
+
+if __name__ == "__main__":
+    learning_rate = 5e-2
+    num_epochs = 161
+    color = ["blue", "green", "orange"]
+    optim_names = ["SGD", "RMSprop", "Adam"]
+
+    model = MNIST_CLS_Model(num_classes=10, dropout_rate=0)
+    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)
+    print(f"optimizer: SGD")
+    train_loss, test_acc = train_MNIST_CLS(model, optimizer, num_epochs=num_epochs)
+
+    model = MNIST_CLS_Model(num_classes=10, dropout_rate=0)
+    optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, alpha=0.99, eps=1e-8)
+    print(f"optimizer: RMSprop")
+    train_loss, test_acc = train_MNIST_CLS(model, optimizer, num_epochs=num_epochs)
+
+    model = MNIST_CLS_Model(num_classes=10, dropout_rate=0)
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999), eps=1e-8)
+    print(f"optimizer: Adam")
+    train_loss, test_acc = train_MNIST_CLS(model, optimizer, num_epochs=num_epochs)

Lab3/code/4.py

@@ -0,0 +1,101 @@
+import torch
+from torch import nn
+from utils import *
+from torch.utils.data import random_split
+
+
+learning_rate = 1e-3
+num_epochs = 161
+batch_size = 8192
+num_classes = 10
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+transform = transforms.Compose(
+    [
+        transforms.ToTensor(),
+        transforms.Normalize((0.5,), (0.5,)),
+    ]
+)
+train_mnist_dataset = datasets.MNIST(root="../dataset", train=True, transform=transform, download=True)
+test_mnist_dataset = datasets.MNIST(root="../dataset", train=False, transform=transform, download=True)
+
+train_dataset_length = int(0.8 * len(train_mnist_dataset))
+val_dataset_length = len(train_mnist_dataset) - train_dataset_length
+train_mnist_dataset, val_mnist_dataset = random_split(
+    train_mnist_dataset,
+    [train_dataset_length, val_dataset_length],
+    generator=torch.Generator().manual_seed(42),
+)
+
+train_loader = DataLoader(dataset=train_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)
+val_loader = DataLoader(dataset=val_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)
+test_loader = DataLoader(dataset=test_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)
+
+model = MNIST_CLS_Model(num_classes=10, dropout_rate=0.2).to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999), eps=1e-8, weight_decay=0)
+
+early_stopping_patience = 5
+best_val_loss = float("inf")
+current_patience = 0
+
+train_loss = list()
+test_acc = list()
+val_loss = list()
+for epoch in range(num_epochs):
+    model.train()
+    total_epoch_loss = 0
+    for index, (images, targets) in tqdm(enumerate(train_loader), total=len(train_loader)):
+        optimizer.zero_grad()
+
+        images = images.to(device)
+        targets = targets.to(device)
+        one_hot_targets = one_hot(targets, num_classes=num_classes).to(dtype=torch.float)
+
+        outputs = model(images)
+        loss = criterion(outputs, one_hot_targets)
+        total_epoch_loss += loss.item()
+
+        loss.backward()
+        optimizer.step()
+
+    model.eval()
+    with torch.no_grad():
+        total_epoch_acc = 0
+        for index, (image, targets) in tqdm(enumerate(test_loader), total=len(test_loader)):
+            image = image.to(device)
+            targets = targets.to(device)
+
+            outputs = model(image)
+            pred = softmax(outputs, dim=1)
+            total_epoch_acc += (pred.argmax(1) == targets).sum().item()
+        avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)
+
+        val_total_epoch_loss = 0
+        for index, (image, targets) in tqdm(enumerate(val_loader), total=len(test_loader)):
+            image = image.to(device)
+            targets = targets.to(device)
+            one_hot_targets = one_hot(targets, num_classes=num_classes).to(dtype=torch.float)
+
+            outputs = model(image)
+            loss = criterion(outputs, one_hot_targets)
+            val_total_epoch_loss += loss.item()
+
+    print(
+        f"Epoch [{epoch + 1}/{num_epochs}],",
+        f"Train Loss: {total_epoch_loss:.10f},",
+        f"Test Acc: {avg_epoch_acc * 100:.3f}%,",
+        f"Val Loss: {val_total_epoch_loss:.10f}",
+    )
+    train_loss.append(total_epoch_loss)
+    test_acc.append(avg_epoch_acc * 100)
+    val_loss.append(val_total_epoch_loss)
+
+    if val_total_epoch_loss < best_val_loss:
+        best_val_loss = val_total_epoch_loss
+        current_patience = 0
+    else:
+        current_patience += 1
+        if current_patience >= early_stopping_patience:
+            print(f"Early stopping after {epoch + 1} epochs.")
+            break

Lab3/code/utils.py

@@ -0,0 +1,106 @@
+import torch
+from torch.nn.functional import *
+from torch.utils.data import DataLoader
+from torch import nn
+from torchvision import datasets, transforms
+from tqdm import tqdm
+
+import ipdb
+
+
+class MNIST_CLS_Model(nn.Module):
+    def __init__(self, num_classes, dropout_rate=0.5):
+        super().__init__()
+        self.flatten = nn.Flatten()
+        self.fc1 = nn.Linear(in_features=28 * 28, out_features=1024)
+        self.fc2 = nn.Linear(in_features=1024, out_features=num_classes)
+        self.dropout = nn.Dropout(p=dropout_rate)
+
+    def forward(self, x: torch.Tensor):
+        x = self.flatten(x)
+        x = torch.relu(self.fc1(x))
+        x = self.dropout(x)
+        x = self.fc2(x)
+        return x
+
+
+def train_MNIST_CLS(model, optimizer, num_epochs):
+    batch_size = 8192
+    num_classes = 10
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+    transform = transforms.Compose(
+        [
+            transforms.ToTensor(),
+            transforms.Normalize((0.5,), (0.5,)),
+        ]
+    )
+    train_mnist_dataset = datasets.MNIST(
+        root="../dataset", train=True, transform=transform, download=True
+    )
+    test_mnist_dataset = datasets.MNIST(
+        root="../dataset", train=False, transform=transform, download=True
+    )
+    train_loader = DataLoader(
+        dataset=train_mnist_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=14,
+        pin_memory=True,
+    )
+    test_loader = DataLoader(
+        dataset=test_mnist_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=14,
+        pin_memory=True,
+    )
+
+    model = model.to(device)
+    criterion = nn.CrossEntropyLoss()
+
+    train_loss = list()
+    test_acc = list()
+    for epoch in range(num_epochs):
+        model.train()
+        total_epoch_loss = 0
+        for index, (images, targets) in tqdm(
+            enumerate(train_loader), total=len(train_loader)
+        ):
+            optimizer.zero_grad()
+
+            images = images.to(device)
+            targets = targets.to(device)
+            one_hot_targets = one_hot(targets, num_classes=num_classes).to(
+                dtype=torch.float
+            )
+
+            outputs = model(images)
+            loss = criterion(outputs, one_hot_targets)
+            total_epoch_loss += loss.item()
+
+            loss.backward()
+            optimizer.step()
+
+        model.eval()
+        with torch.no_grad():
+            total_epoch_acc = 0
+            for index, (image, targets) in tqdm(
+                enumerate(test_loader), total=len(test_loader)
+            ):
+                image = image.to(device)
+                targets = targets.to(device)
+
+                outputs = model(image)
+                pred = softmax(outputs, dim=1)
+                total_epoch_acc += (pred.argmax(1) == targets).sum().item()
+
+        avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)
+        print(
+            f"Epoch [{epoch + 1}/{num_epochs}],",
+            f"Train Loss: {total_epoch_loss:.10f},",
+            f"Test Acc: {avg_epoch_acc * 100:.3f}%,",
+        )
+        train_loss.append(total_epoch_loss)
+        test_acc.append(avg_epoch_acc * 100)
+    return train_loss, test_acc

Lab4/code/1.1.py

@@ -0,0 +1,73 @@
+from utils import *
+import ipdb
+
+
+class My_Conv2d(nn.Module):
+    def __init__(self, in_channels:int, out_channels:int, kernel_size:int, padding:int=0, bias=True):
+        super(My_Conv2d, self).__init__()
+        self.has_bias = bias
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.padding = padding
+        self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels, kernel_size, kernel_size))
+        nn.init.xavier_uniform_(self.weight)
+        if self.has_bias:
+            self.bias = nn.Parameter(torch.zeros(out_channels, requires_grad=True, dtype=torch.float32))
+
+    def forward(self, x):
+        batch_size, _, input_height, input_width = x.shape
+        if self.padding > 0:
+            x = F.pad(x, (self.padding, self.padding, self.padding, self.padding))
+        x = F.unfold(x, kernel_size=self.kernel_size)
+        x = x.permute(0, 2, 1).contiguous()
+        weight_unfold = self.weight.view(self.out_channels, -1).t()
+        x = torch.matmul(x, weight_unfold)
+        if self.has_bias:
+            x += self.bias
+        output_height = input_height + 2 * self.padding - self.kernel_size + 1
+        output_width = input_width + 2 * self.padding - self.kernel_size + 1
+        x = x.view(batch_size, output_height, output_width, self.out_channels).permute(0, 3, 1, 2).contiguous()
+        return x
+    
+
+class Model_Vehicle_CLS_1_1(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_1_1, self).__init__()
+        self.conv1 = My_Conv2d(in_channels=3, out_channels=128, kernel_size=3, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(128)
+        self.conv2 = My_Conv2d(in_channels=128, out_channels=512, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(512)
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = F.relu(self.bn2(self.conv2(x)))
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+
+class Model_Haze_Removal_1_1(nn.Module):
+    def __init__(self):
+        super(Model_Haze_Removal_1_1, self).__init__()
+        self.conv1 = My_Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(16)
+        self.conv2 = My_Conv2d(in_channels=16, out_channels=48, kernel_size=5, padding=2, bias=False)
+        self.bn2 = nn.BatchNorm2d(48)
+        self.conv3 = My_Conv2d(in_channels=48, out_channels=3, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = F.relu(self.bn2(self.conv2(x)))
+        x = self.conv3(x)
+        return x
+
+
+if __name__ == "__main__":
+    model = Model_Vehicle_CLS_1_1()
+    train_Vehicle_CLS(model=model, learning_rate=4e-4, batch_size=256)
+    
+    model = Model_Haze_Removal_1_1()
+    train_Haze_Removal(model=model, learning_rate=5e-3, batch_size=16)

Lab4/code/1.2.py

@@ -0,0 +1,43 @@
+from utils import *
+import ipdb
+
+class Model_Vehicle_CLS_1_2(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_1_2, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels=3, out_channels=128, kernel_size=3, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(128)
+        self.conv2 = nn.Conv2d(in_channels=128, out_channels=512, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(512)
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = F.relu(self.bn2(self.conv2(x)))
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+
+class Model_Haze_Removal_1_2(nn.Module):
+    def __init__(self):
+        super(Model_Haze_Removal_1_2, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(16)
+        self.conv2 = nn.Conv2d(in_channels=16, out_channels=48, kernel_size=5, padding=2, bias=False)
+        self.bn2 = nn.BatchNorm2d(48)
+        self.conv3 = nn.Conv2d(in_channels=48, out_channels=3, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = F.relu(self.bn2(self.conv2(x)))
+        x = self.conv3(x)
+        return x
+
+
+if __name__ == "__main__":
+    model = Model_Vehicle_CLS_1_2()
+    train_Vehicle_CLS(model=model, learning_rate=4e-4, batch_size=64)
+
+    model = Model_Haze_Removal_1_2()
+    train_Haze_Removal(model=model, learning_rate=5e-3, batch_size=16)

Lab4/code/1.3.py

@@ -0,0 +1,215 @@
+from utils import *
+
+class Model_Vehicle_CLS_1_3_1(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_1_3_1, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=512, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(512),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+
+
+class Model_Vehicle_CLS_1_3_2(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_1_3_2, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=128, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(128),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=128, out_channels=512, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(512),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes, bias=False)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+
+
+class Model_Vehicle_CLS_1_3_3(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_1_3_3, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(64),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=256, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(256),
+        )
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(512),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = F.relu(self.conv3(x))
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+
+
+class Model_Vehicle_CLS_1_3_4(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_1_3_4, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(64),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(128),
+        )
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(256),
+        )
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(512),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = F.relu(self.conv3(x))
+        x = F.relu(self.conv4(x))
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+
+class Model_Haze_Removal_1_3_1(nn.Module):
+    def __init__(self):
+        super(Model_Haze_Removal_1_3_1, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(16),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=16, out_channels=48, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(48),
+        )
+        self.conv3 = nn.Conv2d(in_channels=48, out_channels=3, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.conv3(x)
+        return x
+
+
+class Model_Haze_Removal_1_3_2(nn.Module):
+    def __init__(self):
+        super(Model_Haze_Removal_1_3_2, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=5, padding=2, bias=False),
+            nn.BatchNorm2d(16),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=16, out_channels=48, kernel_size=5, padding=2, bias=False),
+            nn.BatchNorm2d(48),
+        )
+        self.conv3 = nn.Conv2d(in_channels=48, out_channels=3, kernel_size=5, padding=2)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.conv3(x)
+        return x
+
+
+class Model_Haze_Removal_1_3_3(nn.Module):
+    def __init__(self):
+        super(Model_Haze_Removal_1_3_3, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=7, padding=3, bias=False),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=16, out_channels=48, kernel_size=7, padding=3, bias=False),
+            nn.BatchNorm2d(48),
+            nn.ReLU(inplace=True),
+        )
+        self.conv3 = nn.Conv2d(in_channels=48, out_channels=3, kernel_size=7, padding=3)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.conv3(x)
+        return x
+
+
+class Model_Haze_Removal_1_3_4(nn.Module):
+    def __init__(self):
+        super(Model_Haze_Removal_1_3_4, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=9, padding=4, bias=False),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=16, out_channels=48, kernel_size=9, padding=4, bias=False),
+            nn.BatchNorm2d(48),
+            nn.ReLU(inplace=True),
+        )
+        self.conv3 = nn.Conv2d(in_channels=48, out_channels=3, kernel_size=9, padding=4)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.conv3(x)
+        return x
+    
+
+if __name__ == "__main__":
+    num_epochs = 61
+    learning_rate = 2e-4
+    batch_size = 256
+    models = [
+        Model_Vehicle_CLS_1_3_1, 
+        Model_Vehicle_CLS_1_3_2,
+        Model_Vehicle_CLS_1_3_3,
+        Model_Vehicle_CLS_1_3_4,
+    ]
+    for i in range(4):
+        model = models[i]()
+        print(f"卷积层层数={i + 1}")
+        train_loss, test_acc = train_Vehicle_CLS(model=model, learning_rate=learning_rate,
+                                                 batch_size=batch_size, num_epochs=num_epochs)
+        print()
+
+    num_epochs = 61
+    learning_rate = 8e-3
+    batch_size = 64
+    models = [
+        Model_Haze_Removal_1_3_1, 
+        Model_Haze_Removal_1_3_2, 
+        Model_Haze_Removal_1_3_3, 
+        Model_Haze_Removal_1_3_4, 
+    ]
+    for i in range(4):
+        model = models[i]()
+        print(f"卷积核大小={3 + 2 * i}")
+        train_loss, test_loss = train_Haze_Removal(model=model, learning_rate=learning_rate, batch_size=batch_size, num_epochs=num_epochs)
+        print()

Lab4/code/2.py

@@ -0,0 +1,168 @@
+from utils import *
+
+class Model_Vehicle_CLS_2_1(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_2_1, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+
+
+class Model_Vehicle_CLS_2_2(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_2_2, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=2, dilation=2, bias=False),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=5, dilation=5, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=2, dilation=2, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=5, dilation=5, bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+
+
+class Model_Vehicle_CLS_2_3(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_2_3, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=3, dilation=3, bias=False),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=5, dilation=5, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=3, dilation=3, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=5, dilation=5, bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+
+
+class Model_Vehicle_CLS_2_4(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_2_4, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=3, dilation=3, bias=False),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=7, dilation=7, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1, dilation=1, bias=False),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=3, dilation=3, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=7, dilation=7, bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True),
+        )
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = F.avg_pool2d(x, 32)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+
+if __name__ == "__main__":
+    num_epochs = 61
+    learning_rate = 1e-4
+    batch_size = 256
+    dilations = ["[[1, 1, 1], [1, 1, 1]]", 
+                 "[[1, 2, 5], [1, 2, 5]]",
+                 "[[1, 3, 5], [1, 3, 5]]", 
+                 "[[1, 3, 7], [1, 3, 7]]"]
+    models = [
+        Model_Vehicle_CLS_2_1, 
+        Model_Vehicle_CLS_2_2, 
+        Model_Vehicle_CLS_2_3,
+        Model_Vehicle_CLS_2_4,
+    ]
+    for i in range(4):
+        model = models[i]()
+        print("Dilation: " + dilations[i])
+        train_loss, test_acc = train_Vehicle_CLS(model=model, learning_rate=learning_rate,
+                                                 batch_size=batch_size, num_epochs=num_epochs)
+        print()
+
+    

Lab4/code/3.py

@@ -0,0 +1,63 @@
+from utils import *
+
+class BasicResidualBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, stride=1):
+        super(BasicResidualBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_channels != out_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(out_channels)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Model_Vehicle_CLS_3(nn.Module):
+    def __init__(self, num_classes=3):
+        super(Model_Vehicle_CLS_3, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(64),
+        )
+        self.conv2 = BasicResidualBlock(in_channels=64, out_channels=64)
+        self.conv3 = BasicResidualBlock(in_channels=64, out_channels=64)
+        self.conv4 = BasicResidualBlock(in_channels=64, out_channels=128, stride=2)
+        self.conv5 = BasicResidualBlock(in_channels=128, out_channels=128)
+        self.conv6 = BasicResidualBlock(in_channels=128, out_channels=256, stride=2)
+        self.conv7 = BasicResidualBlock(in_channels=256, out_channels=256)
+        self.conv8 = BasicResidualBlock(in_channels=256, out_channels=512, stride=2)
+        self.conv9 = BasicResidualBlock(in_channels=512, out_channels=512)
+        self.fc = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.conv4(x)
+        x = self.conv5(x)
+        x = self.conv6(x)
+        x = self.conv7(x)
+        x = self.conv8(x)
+        x = self.conv9(x)
+        x = F.avg_pool2d(x, 4)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+
+if __name__ == "__main__":
+    num_epochs = 61
+    learning_rate = 15e-5
+    batch_size = 512
+    model = Model_Vehicle_CLS_3(num_classes=3)
+    train_loss, test_acc = train_Vehicle_CLS(model=model, learning_rate=learning_rate, batch_size=batch_size, num_epochs=num_epochs)

Lab4/code/utils.py

@@ -0,0 +1,197 @@
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+from torch import nn
+from torchvision import transforms
+from tqdm import tqdm
+import os
+import time
+from PIL import Image
+import pandas as pd
+
+class Vehicle(Dataset):
+    def __init__(self, root:str="../dataset", train:bool=True, transform=None):
+        root = os.path.join(root, "Vehicles")
+        csv_file = os.path.join(root, "train.csv" if train else "test.csv")
+        self.data = pd.read_csv(csv_file).to_numpy().tolist()
+        self.root = root
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, index):
+        img_name, label = self.data[index]
+        img_path = os.path.join(self.root, img_name)
+        image = Image.open(img_path)
+        label = int(label)
+        if self.transform:
+            image = self.transform(image)
+        return image, label
+    
+
+class Haze(Dataset):
+    def __init__(self, root:str="../dataset", train:bool=True, transform=None):
+        root = os.path.join(root, "Haze")
+        split_file = pd.read_csv(os.path.join(root, "split.csv")).to_numpy().tolist()
+        self.data = list()
+        for img, is_train in split_file:
+            if train and int(is_train) == 1:
+                self.data.append(img)
+            elif not train and int(is_train) == 0:
+                self.data.append(img)
+        self.root = root
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, index):
+        img_name = self.data[index]
+        img_path = os.path.join(self.root, "raw/haze", img_name)
+        ground_truth_path = os.path.join(self.root, "raw/no_haze", img_name)
+        image = Image.open(img_path)
+        ground_truth = Image.open(ground_truth_path)
+        if self.transform:
+            image = self.transform(image)
+            ground_truth = self.transform(ground_truth)
+        return image, ground_truth
+    
+
+def train_Vehicle_CLS(model:nn.Module, learning_rate=1e-3, batch_size=64, num_epochs=51):
+    num_classes = 3
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+    transform = transforms.Compose(
+        [
+            transforms.ToTensor(),
+            transforms.Resize((32, 32), antialias=True),
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+        ]
+    )
+    train_dataset = Vehicle(root="../dataset", train=True, transform=transform)
+    test_dataset = Vehicle(root="../dataset", train=False, transform=transform)
+    
+    train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)
+    test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, num_workers=14, pin_memory=True)
+
+    model = model.to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+    train_loss = list()
+    test_acc = list()
+    for epoch in range(num_epochs):
+        model.train()
+        total_epoch_loss = 0
+        train_tik = time.time()
+        for index, (images, targets) in tqdm(enumerate(train_loader), total=len(train_loader)):
+            optimizer.zero_grad()
+
+            images = images.to(device)
+            targets = targets.to(device)
+            one_hot_targets = F.one_hot(targets, num_classes=num_classes).to(dtype=torch.float)
+
+            outputs = model(images)
+            loss = criterion(outputs, one_hot_targets)
+            total_epoch_loss += loss.item()
+
+            loss.backward()
+            optimizer.step()
+        train_tok = time.time()
+
+        model.eval()
+        with torch.no_grad():
+            total_epoch_acc = 0
+            test_tik = time.time()
+            for index, (image, targets) in tqdm(enumerate(test_loader), total=len(test_loader)):
+                image = image.to(device)
+                targets = targets.to(device)
+
+                outputs = model(image)
+                pred = F.softmax(outputs, dim=1)
+                total_epoch_acc += (pred.argmax(1) == targets).sum().item()
+            test_tok = time.time()
+
+        avg_epoch_acc = total_epoch_acc / len(test_dataset)
+        print(
+            f"Epoch [{epoch + 1}/{num_epochs}],",
+            f"Train Loss: {total_epoch_loss:.10f},",
+            f"Train Time: {1000 * (train_tok - train_tik):.2f}ms,",
+            f"Test Acc: {avg_epoch_acc * 100:.3f}%,",
+            f"Test Time: {1000 * (test_tok - test_tik):.2f}ms"
+        )
+        train_loss.append(total_epoch_loss)
+        test_acc.append(avg_epoch_acc)
+    print(f"最大显存使用量: {torch.cuda.max_memory_allocated() / (1024 * 1024):.2f}MiB")
+    torch.cuda.reset_peak_memory_stats()
+    return train_loss, test_acc
+
+
+def train_Haze_Removal(model:nn.Module, learning_rate=1e-3, batch_size=64, num_epochs=51):
+    num_epochs = 50
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+    transform = transforms.Compose(
+        [
+            transforms.ToTensor(),
+            transforms.Resize((224, 224), antialias=True),
+        ]
+    )
+    train_dataset = Haze(root="../dataset", train=True, transform=transform)
+    test_dataset = Haze(root="../dataset", train=False, transform=transform)
+
+    train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)
+    test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, num_workers=14, pin_memory=True)
+
+    model = model.to(device)
+    criterion = nn.MSELoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+    train_loss = list()
+    test_loss = list()
+    for epoch in range(num_epochs):
+        model.train()
+        total_epoch_train_loss = 0
+        train_tik = time.time()
+        for index, (images, ground_truth) in tqdm(enumerate(train_loader), total=len(train_loader)):
+            optimizer.zero_grad()
+
+            images = images.to(device)
+            ground_truth = ground_truth.to(device)
+
+            outputs = model(images)
+            loss = criterion(outputs, ground_truth)
+            total_epoch_train_loss += loss.item()
+
+            loss.backward()
+            optimizer.step()
+        train_tok = time.time()
+
+        model.eval()
+        with torch.no_grad():
+            total_epoch_test_loss = 0
+            test_tik = time.time()
+            for index, (image, ground_truth) in tqdm(enumerate(test_loader), total=len(test_loader)):
+                image = image.to(device)
+                ground_truth = ground_truth.to(device)
+
+                outputs = model(image)
+                loss = criterion(outputs, ground_truth)
+                total_epoch_test_loss += loss.item()
+            test_tok = time.time()
+
+        print(
+            f"Epoch [{epoch + 1}/{num_epochs}],",
+            f"Train Loss: {total_epoch_train_loss:.10f},",
+            f"Train Time: {1000 * (train_tok - train_tik):.2f}ms,",
+            f"Test Loss: {total_epoch_test_loss:.10f},",
+            f"Test Time: {1000 * (test_tok - test_tik):.2f}ms"
+        )
+        train_loss.append(total_epoch_train_loss)
+        test_loss.append(total_epoch_test_loss)
+    print(f"最大显存使用量: {torch.cuda.max_memory_allocated() / (1024 * 1024):.2f}MiB")
+    torch.cuda.reset_peak_memory_stats()
+    return train_loss, test_loss
+    
+    

Lab4/dataset/Haze/split.csv

@@ -0,0 +1,521 @@
+Image,Train
+001.jpg,1
+002.jpg,1
+003.jpg,1
+004.jpg,0
+005.jpg,0
+006.jpg,1
+007.jpg,1
+008.jpg,1
+009.jpg,1
+010.jpg,1
+011.jpg,0
+012.jpg,1
+013.jpg,0
+014.jpg,1
+015.jpg,1
+016.jpg,1
+017.jpg,1
+018.jpg,1
+019.jpg,1
+020.jpg,1
+021.jpg,1
+022.jpg,1
+023.jpg,1
+024.jpg,1
+025.jpg,1
+026.jpg,1
+027.jpg,0
+028.jpg,1
+029.jpg,1
+030.jpg,1
+031.jpg,1
+032.jpg,1
+033.jpg,1
+034.jpg,1
+035.jpg,1
+036.jpg,1
+037.jpg,0
+038.jpg,1
+039.jpg,1
+040.jpg,1
+041.jpg,1
+042.jpg,1
+043.jpg,0
+044.jpg,1
+045.jpg,1
+046.jpg,1
+047.jpg,1
+048.jpg,0
+049.jpg,1
+050.jpg,1
+051.jpg,1
+052.jpg,1
+053.jpg,1
+054.jpg,1
+055.jpg,1
+056.jpg,1
+057.jpg,1
+058.jpg,1
+059.jpg,0
+060.jpg,1
+061.jpg,1
+062.jpg,1
+063.jpg,1
+064.jpg,1
+065.jpg,0
+066.jpg,1
+067.jpg,0
+068.jpg,1
+069.jpg,0
+070.jpg,1
+071.jpg,1
+072.jpg,1
+073.jpg,1
+074.jpg,1
+075.jpg,1
+076.jpg,0
+077.jpg,1
+078.jpg,1
+079.jpg,1
+080.jpg,1
+081.jpg,1
+082.jpg,1
+083.jpg,1
+084.jpg,1
+085.jpg,0
+086.jpg,1
+087.jpg,1
+088.jpg,0
+089.jpg,1
+090.jpg,1
+091.jpg,1
+092.jpg,1
+093.jpg,1
+094.jpg,1
+095.jpg,1
+096.jpg,1
+097.jpg,1
+098.jpg,1
+099.jpg,1
+100.jpg,1
+101.jpg,1
+102.jpg,1
+103.jpg,1
+104.jpg,1
+105.jpg,1
+106.jpg,1
+107.jpg,0
+108.jpg,1
+109.jpg,0
+110.jpg,1
+111.jpg,1
+112.jpg,1
+113.jpg,1
+114.jpg,1
+115.jpg,1
+116.jpg,1
+117.jpg,1
+118.jpg,0
+119.jpg,1
+120.jpg,1
+121.jpg,0
+122.jpg,1
+123.jpg,1
+124.jpg,1
+125.jpg,1
+126.jpg,0
+127.jpg,1
+128.jpg,0
+129.jpg,0
+130.jpg,0
+131.jpg,1
+132.jpg,1
+133.jpg,1
+134.jpg,1
+135.jpg,1
+136.jpg,1
+137.jpg,1
+138.jpg,1
+139.jpg,1
+140.jpg,0
+141.jpg,0
+142.jpg,1
+143.jpg,1
+144.jpg,1
+145.jpg,1
+146.jpg,1
+147.jpg,0
+148.jpg,1
+149.jpg,1
+150.jpg,0
+151.jpg,1
+152.jpg,1
+153.jpg,1
+154.jpg,1
+155.jpg,0
+156.jpg,1
+157.jpg,0
+158.jpg,1
+159.jpg,0
+160.jpg,1
+161.jpg,0
+162.jpg,1
+163.jpg,0
+164.jpg,1
+165.jpg,0
+166.jpg,1
+167.jpg,1
+168.jpg,0
+169.jpg,1
+170.jpg,1
+171.jpg,0
+172.jpg,1
+173.jpg,1
+174.jpg,1
+175.jpg,0
+176.jpg,1
+177.jpg,1
+178.jpg,1
+179.jpg,1
+180.jpg,0
+181.jpg,1
+182.jpg,0
+183.jpg,1
+184.jpg,1
+185.jpg,1
+186.jpg,0
+187.jpg,1
+188.jpg,1
+189.jpg,1
+190.jpg,0
+191.jpg,1
+192.jpg,1
+193.jpg,1
+194.jpg,1
+195.jpg,1
+196.jpg,1
+197.jpg,1
+198.jpg,1
+199.jpg,1
+200.jpg,1
+201.jpg,1
+202.jpg,1
+203.jpg,1
+204.jpg,1
+205.jpg,0
+206.jpg,1
+207.jpg,1
+208.jpg,1
+209.jpg,1
+210.jpg,1
+211.jpg,1
+212.jpg,1
+213.jpg,1
+214.jpg,0
+215.jpg,0
+216.jpg,1
+217.jpg,1
+218.jpg,1
+219.jpg,1
+220.jpg,1
+221.jpg,1
+222.jpg,1
+223.jpg,0
+224.jpg,0
+225.jpg,1
+226.jpg,1
+227.jpg,1
+228.jpg,1
+229.jpg,0
+230.jpg,1
+231.jpg,1
+232.jpg,1
+233.jpg,0
+234.jpg,1
+235.jpg,0
+236.jpg,1
+237.jpg,1
+238.jpg,1
+239.jpg,1
+240.jpg,1
+241.jpg,1
+242.jpg,1
+243.jpg,1
+244.jpg,1
+245.jpg,1
+246.jpg,0
+247.jpg,1
+248.jpg,0
+249.jpg,0
+250.jpg,1
+251.jpg,1
+252.jpg,1
+253.jpg,1
+254.jpg,1
+255.jpg,1
+256.jpg,0
+257.jpg,1
+258.jpg,1
+259.jpg,1
+260.jpg,0
+261.jpg,1
+262.jpg,0
+263.jpg,1
+264.jpg,1
+265.jpg,0
+266.jpg,0
+267.jpg,0
+268.jpg,1
+269.jpg,1
+270.jpg,1
+271.jpg,1
+272.jpg,1
+273.jpg,1
+274.jpg,1
+275.jpg,1
+276.jpg,1
+277.jpg,1
+278.jpg,1
+279.jpg,1
+280.jpg,0
+281.jpg,1
+282.jpg,1
+283.jpg,1
+284.jpg,1
+285.jpg,1
+286.jpg,0
+287.jpg,1
+288.jpg,1
+289.jpg,1
+290.jpg,1
+291.jpg,1
+292.jpg,1
+293.jpg,0
+294.jpg,1
+295.jpg,1
+296.jpg,0
+297.jpg,1
+298.jpg,1
+299.jpg,0
+300.jpg,1
+301.jpg,1
+302.jpg,0
+303.jpg,1
+304.jpg,0
+305.jpg,1
+306.jpg,1
+307.jpg,1
+308.jpg,1
+309.jpg,1
+310.jpg,1
+311.jpg,0
+312.jpg,1
+313.jpg,1
+314.jpg,0
+315.jpg,1
+316.jpg,1
+317.jpg,1
+318.jpg,1
+319.jpg,1
+320.jpg,1
+321.jpg,0
+322.jpg,1
+323.jpg,1
+324.jpg,0
+325.jpg,1
+326.jpg,1
+327.jpg,0
+328.jpg,1
+329.jpg,1
+330.jpg,1
+331.jpg,1
+332.jpg,0
+333.jpg,1
+334.jpg,0
+335.jpg,1
+336.jpg,1
+337.jpg,1
+338.jpg,1
+339.jpg,1
+340.jpg,1
+341.jpg,1
+342.jpg,1
+343.jpg,1
+344.jpg,1
+345.jpg,0
+346.jpg,1
+347.jpg,1
+348.jpg,1
+349.jpg,1
+350.jpg,1
+351.jpg,1
+352.jpg,1
+353.jpg,1
+354.jpg,0
+355.jpg,1
+356.jpg,0
+357.jpg,1
+358.jpg,0
+359.jpg,0
+360.jpg,1
+361.jpg,0
+362.jpg,1
+363.jpg,0
+364.jpg,1
+365.jpg,1
+366.jpg,1
+367.jpg,1
+368.jpg,1
+369.jpg,0
+370.jpg,0
+371.jpg,1
+372.jpg,0
+373.jpg,1
+374.jpg,1
+375.jpg,1
+376.jpg,1
+377.jpg,0
+378.jpg,0
+379.jpg,1
+380.jpg,1
+381.jpg,1
+382.jpg,1
+383.jpg,1
+384.jpg,1
+385.jpg,1
+386.jpg,1
+387.jpg,1
+388.jpg,1
+389.jpg,1
+390.jpg,0
+391.jpg,0
+392.jpg,1
+393.jpg,1
+394.jpg,1
+395.jpg,1
+396.jpg,1
+397.jpg,1
+398.jpg,0
+399.jpg,1
+400.jpg,1
+401.jpg,0
+402.jpg,1
+403.jpg,1
+404.jpg,1
+405.jpg,0
+406.jpg,0
+407.jpg,1
+408.jpg,1
+409.jpg,1
+410.jpg,1
+411.jpg,0
+412.jpg,1
+413.jpg,1
+414.jpg,1
+415.jpg,1
+416.jpg,1
+417.jpg,1
+418.jpg,1
+419.jpg,1
+420.jpg,1
+421.jpg,0
+422.jpg,0
+423.jpg,1
+424.jpg,1
+425.jpg,0
+426.jpg,1
+427.jpg,1
+428.jpg,1
+429.jpg,0
+430.jpg,0
+431.jpg,1
+432.jpg,1
+433.jpg,1
+434.jpg,1
+435.jpg,1
+436.jpg,1
+437.jpg,1
+438.jpg,1
+439.jpg,1
+440.jpg,1
+441.jpg,1
+442.jpg,1
+443.jpg,1
+444.jpg,1
+445.jpg,1
+446.jpg,1
+447.jpg,1
+448.jpg,1
+449.jpg,1
+450.jpg,1
+451.jpg,1
+452.jpg,1
+453.jpg,1
+454.jpg,1
+455.jpg,1
+456.jpg,1
+457.jpg,1
+458.jpg,1
+459.jpg,1
+460.jpg,1
+461.jpg,1
+462.jpg,1
+463.jpg,0
+464.jpg,1
+465.jpg,1
+466.jpg,1
+467.jpg,1
+468.jpg,1
+469.jpg,1
+470.jpg,1
+471.jpg,1
+472.jpg,1
+473.jpg,1
+474.jpg,1
+475.jpg,1
+476.jpg,1
+477.jpg,1
+478.jpg,1
+479.jpg,1
+480.jpg,1
+481.jpg,1
+482.jpg,1
+483.jpg,1
+484.jpg,0
+485.jpg,1
+486.jpg,1
+487.jpg,1
+488.jpg,1
+489.jpg,1
+490.jpg,1
+491.jpg,1
+492.jpg,0
+493.jpg,1
+494.jpg,1
+495.jpg,1
+496.jpg,1
+497.jpg,1
+498.jpg,1
+499.jpg,1
+500.jpg,1
+501.jpg,1
+502.jpg,1
+503.jpg,1
+504.jpg,1
+505.jpg,1
+506.jpg,0
+507.jpg,0
+508.jpg,0
+509.jpg,1
+510.jpg,1
+511.jpg,1
+512.jpg,0
+513.jpg,0
+514.jpg,1
+515.jpg,1
+516.jpg,1
+517.jpg,1
+518.jpg,1
+519.jpg,1
+520.jpg,0

Lab4/dataset/Haze/split_dataset.py

@@ -0,0 +1,16 @@
+import os
+import pandas as pd
+import random
+
+train_list = set()
+
+img_list = [i for i in os.listdir("raw/haze") if i.endswith(".jpg")]
+random.shuffle(img_list)
+for img in img_list[ : int(len(img_list) * 0.8)]:
+    train_list.add(img)
+img_list.sort()
+data = list()
+for img in img_list:
+    data.append([img, 1 if img in train_list else 0])
+
+pd.DataFrame(data=data, columns=["Image", "Train"]).to_csv("./split.csv", index=False)

Lab4/dataset/Vehicles/split_dataset.py

@@ -0,0 +1,26 @@
+import os
+import random
+import pandas as pd
+
+train_list = list()
+test_list = list()
+
+root_dir = "raw"
+class_index = 0
+for vehicle in os.listdir(root_dir):
+    img_list = [i for i in os.listdir(os.path.join(root_dir, vehicle)) if i.endswith(".jpg")]
+    random.shuffle(img_list)
+    split_num = int(len(img_list) * 0.8)
+    for img in img_list[0 : split_num]:
+        train_list.append([os.path.join(root_dir, vehicle, img), class_index])
+    for img in img_list[split_num : ]:
+        test_list.append([os.path.join(root_dir, vehicle, img), class_index])
+    class_index += 1
+
+train_list.sort()
+test_list.sort()
+
+pd.DataFrame(data=train_list, columns=["Vehicle", "Label"]).to_csv("./train.csv", index=False)
+pd.DataFrame(data=test_list, columns=["Vehicle", "Label"]).to_csv("./test.csv", index=False)
+
+

Lab4/dataset/Vehicles/test.csv

@@ -0,0 +1,273 @@
+Vehicle,Label
+raw/bus/bus002.jpg,1
+raw/bus/bus005.jpg,1
+raw/bus/bus008.jpg,1
+raw/bus/bus017.jpg,1
+raw/bus/bus019.jpg,1
+raw/bus/bus033.jpg,1
+raw/bus/bus034.jpg,1
+raw/bus/bus040.jpg,1
+raw/bus/bus043.jpg,1
+raw/bus/bus044.jpg,1
+raw/bus/bus045.jpg,1
+raw/bus/bus046.jpg,1
+raw/bus/bus051.jpg,1
+raw/bus/bus052.jpg,1
+raw/bus/bus056.jpg,1
+raw/bus/bus057.jpg,1
+raw/bus/bus063.jpg,1
+raw/bus/bus066.jpg,1
+raw/bus/bus077.jpg,1
+raw/bus/bus080.jpg,1
+raw/bus/bus096.jpg,1
+raw/bus/bus097.jpg,1
+raw/bus/bus099.jpg,1
+raw/bus/bus114.jpg,1
+raw/bus/bus115.jpg,1
+raw/bus/bus119.jpg,1
+raw/bus/bus127.jpg,1
+raw/bus/bus132.jpg,1
+raw/bus/bus133.jpg,1
+raw/bus/bus135.jpg,1
+raw/bus/bus139.jpg,1
+raw/bus/bus141.jpg,1
+raw/bus/bus145.jpg,1
+raw/bus/bus156.jpg,1
+raw/bus/bus170.jpg,1
+raw/bus/bus173.jpg,1
+raw/bus/bus183.jpg,1
+raw/bus/bus190.jpg,1
+raw/bus/bus192.jpg,1
+raw/bus/bus200.jpg,1
+raw/bus/bus201.jpg,1
+raw/bus/bus209.jpg,1
+raw/bus/bus213.jpg,1
+raw/bus/bus218.jpg,1
+raw/car/car002.jpg,0
+raw/car/car012.jpg,0
+raw/car/car018.jpg,0
+raw/car/car025.jpg,0
+raw/car/car030.jpg,0
+raw/car/car034.jpg,0
+raw/car/car036.jpg,0
+raw/car/car047.jpg,0
+raw/car/car053.jpg,0
+raw/car/car054.jpg,0
+raw/car/car058.jpg,0
+raw/car/car060.jpg,0
+raw/car/car062.jpg,0
+raw/car/car063.jpg,0
+raw/car/car066.jpg,0
+raw/car/car072.jpg,0
+raw/car/car084.jpg,0
+raw/car/car087.jpg,0
+raw/car/car089.jpg,0
+raw/car/car099.jpg,0
+raw/car/car103.jpg,0
+raw/car/car105.jpg,0
+raw/car/car106.jpg,0
+raw/car/car116.jpg,0
+raw/car/car117.jpg,0
+raw/car/car120.jpg,0
+raw/car/car132.jpg,0
+raw/car/car138.jpg,0
+raw/car/car139.jpg,0
+raw/car/car152.jpg,0
+raw/car/car153.jpg,0
+raw/car/car157.jpg,0
+raw/car/car168.jpg,0
+raw/car/car177.jpg,0
+raw/car/car182.jpg,0
+raw/car/car183.jpg,0
+raw/car/car184.jpg,0
+raw/car/car187.jpg,0
+raw/car/car192.jpg,0
+raw/car/car209.jpg,0
+raw/car/car212.jpg,0
+raw/car/car215.jpg,0
+raw/car/car222.jpg,0
+raw/car/car225.jpg,0
+raw/car/car227.jpg,0
+raw/car/car237.jpg,0
+raw/car/car238.jpg,0
+raw/car/car249.jpg,0
+raw/car/car250.jpg,0
+raw/car/car257.jpg,0
+raw/car/car263.jpg,0
+raw/car/car275.jpg,0
+raw/car/car279.jpg,0
+raw/car/car283.jpg,0
+raw/car/car288.jpg,0
+raw/car/car299.jpg,0
+raw/car/car300.jpg,0
+raw/car/car317.jpg,0
+raw/car/car318.jpg,0
+raw/car/car336.jpg,0
+raw/car/car345.jpg,0
+raw/car/car351.jpg,0
+raw/car/car357.jpg,0
+raw/car/car358.jpg,0
+raw/car/car360.jpg,0
+raw/car/car369.jpg,0
+raw/car/car374.jpg,0
+raw/car/car376.jpg,0
+raw/car/car377.jpg,0
+raw/car/car379.jpg,0
+raw/car/car380.jpg,0
+raw/car/car381.jpg,0
+raw/car/car386.jpg,0
+raw/car/car396.jpg,0
+raw/car/car402.jpg,0
+raw/car/car404.jpg,0
+raw/car/car410.jpg,0
+raw/car/car424.jpg,0
+raw/car/car437.jpg,0
+raw/car/car439.jpg,0
+raw/car/car441.jpg,0
+raw/car/car454.jpg,0
+raw/car/car457.jpg,0
+raw/car/car458.jpg,0
+raw/car/car460.jpg,0
+raw/car/car461.jpg,0
+raw/car/car470.jpg,0
+raw/car/car475.jpg,0
+raw/car/car477.jpg,0
+raw/car/car486.jpg,0
+raw/car/car490.jpg,0
+raw/car/car495.jpg,0
+raw/car/car500.jpg,0
+raw/car/car502.jpg,0
+raw/car/car511.jpg,0
+raw/car/car525.jpg,0
+raw/car/car534.jpg,0
+raw/car/car537.jpg,0
+raw/car/car544.jpg,0
+raw/car/car546.jpg,0
+raw/car/car547.jpg,0
+raw/car/car551.jpg,0
+raw/car/car559.jpg,0
+raw/car/car566.jpg,0
+raw/car/car568.jpg,0
+raw/car/car570.jpg,0
+raw/car/car571.jpg,0
+raw/car/car574.jpg,0
+raw/car/car577.jpg,0
+raw/car/car580.jpg,0
+raw/car/car583.jpg,0
+raw/car/car585.jpg,0
+raw/car/car588.jpg,0
+raw/car/car600.jpg,0
+raw/car/car604.jpg,0
+raw/car/car606.jpg,0
+raw/car/car611.jpg,0
+raw/car/car613.jpg,0
+raw/car/car625.jpg,0
+raw/car/car626.jpg,0
+raw/car/car638.jpg,0
+raw/car/car646.jpg,0
+raw/car/car647.jpg,0
+raw/car/car649.jpg,0
+raw/car/car653.jpg,0
+raw/car/car661.jpg,0
+raw/car/car664.jpg,0
+raw/car/car667.jpg,0
+raw/car/car669.jpg,0
+raw/car/car670.jpg,0
+raw/car/car691.jpg,0
+raw/car/car698.jpg,0
+raw/car/car701.jpg,0
+raw/car/car707.jpg,0
+raw/car/car715.jpg,0
+raw/car/car716.jpg,0
+raw/car/car718.jpg,0
+raw/car/car720.jpg,0
+raw/car/car728.jpg,0
+raw/car/car730.jpg,0
+raw/car/car733.jpg,0
+raw/car/car741.jpg,0
+raw/car/car743.jpg,0
+raw/car/car753.jpg,0
+raw/car/car755.jpg,0
+raw/car/car756.jpg,0
+raw/car/car757.jpg,0
+raw/car/car760.jpg,0
+raw/car/car761.jpg,0
+raw/car/car763.jpg,0
+raw/car/car764.jpg,0
+raw/car/car768.jpg,0
+raw/car/car769.jpg,0
+raw/car/car770.jpg,0
+raw/car/car772.jpg,0
+raw/car/car774.jpg,0
+raw/truck/truck001.jpg,2
+raw/truck/truck006.jpg,2
+raw/truck/truck009.jpg,2
+raw/truck/truck011.jpg,2
+raw/truck/truck018.jpg,2
+raw/truck/truck020.jpg,2
+raw/truck/truck021.jpg,2
+raw/truck/truck026.jpg,2
+raw/truck/truck031.jpg,2
+raw/truck/truck039.jpg,2
+raw/truck/truck043.jpg,2
+raw/truck/truck045.jpg,2
+raw/truck/truck051.jpg,2
+raw/truck/truck067.jpg,2
+raw/truck/truck075.jpg,2
+raw/truck/truck080.jpg,2
+raw/truck/truck084.jpg,2
+raw/truck/truck088.jpg,2
+raw/truck/truck091.jpg,2
+raw/truck/truck093.jpg,2
+raw/truck/truck095.jpg,2
+raw/truck/truck097.jpg,2
+raw/truck/truck098.jpg,2
+raw/truck/truck103.jpg,2
+raw/truck/truck107.jpg,2
+raw/truck/truck113.jpg,2
+raw/truck/truck116.jpg,2
+raw/truck/truck117.jpg,2
+raw/truck/truck118.jpg,2
+raw/truck/truck124.jpg,2
+raw/truck/truck130.jpg,2
+raw/truck/truck136.jpg,2
+raw/truck/truck141.jpg,2
+raw/truck/truck146.jpg,2
+raw/truck/truck152.jpg,2
+raw/truck/truck153.jpg,2
+raw/truck/truck155.jpg,2
+raw/truck/truck157.jpg,2
+raw/truck/truck164.jpg,2
+raw/truck/truck170.jpg,2
+raw/truck/truck171.jpg,2
+raw/truck/truck176.jpg,2
+raw/truck/truck185.jpg,2
+raw/truck/truck192.jpg,2
+raw/truck/truck193.jpg,2
+raw/truck/truck197.jpg,2
+raw/truck/truck207.jpg,2
+raw/truck/truck211.jpg,2
+raw/truck/truck216.jpg,2
+raw/truck/truck217.jpg,2
+raw/truck/truck218.jpg,2
+raw/truck/truck220.jpg,2
+raw/truck/truck221.jpg,2
+raw/truck/truck223.jpg,2
+raw/truck/truck226.jpg,2
+raw/truck/truck235.jpg,2
+raw/truck/truck252.jpg,2
+raw/truck/truck259.jpg,2
+raw/truck/truck261.jpg,2
+raw/truck/truck264.jpg,2
+raw/truck/truck271.jpg,2
+raw/truck/truck306.jpg,2
+raw/truck/truck309.jpg,2
+raw/truck/truck311.jpg,2
+raw/truck/truck317.jpg,2
+raw/truck/truck326.jpg,2
+raw/truck/truck328.jpg,2
+raw/truck/truck329.jpg,2
+raw/truck/truck333.jpg,2
+raw/truck/truck335.jpg,2
+raw/truck/truck345.jpg,2
+raw/truck/truck360.jpg,2

Lab5/dataset.py

@@ -0,0 +1,141 @@
+import numpy as np
+import pandas as pd
+import torch
+import torch.utils.data as data
+import warnings
+warnings.filterwarnings("ignore")
+
+
+# 定义dataset
+class my_Dataset(data.Dataset):
+    def __init__(self, features, labels):
+        self.seqs = features
+        self.targets = labels
+
+    def __getitem__(self, index):
+        return self.seqs[index], self.targets[index]
+
+    def __len__(self):
+        return self.seqs.shape[0]
+
+
+# 空气质量数据集
+class KrakowDataset:
+    def __init__(self, sensor:int=171, is_resample:bool=True):
+        # 选取几个月个月的数据
+        self.month = ['april-2017', 'august-2017', 'december-2017', 'february-2017',
+                      'january-2017', 'july-2017', 'june-2017', 'march-2017',
+                      'may-2017', 'november-2017', 'october-2017', 'september-2017']
+        raw_data = pd.concat([pd.read_csv(f'./dataset/Krakow-airquality/raw/{month}.csv') for month in self.month])
+
+        # 确定特征列
+        features = ['temperature', 'humidity', 'pressure', 'pm1', 'pm25', 'pm10']
+        self.sensor = sensor    # 选取探测器,并非每个探测器都有数据
+        self.feature_col = ['UTC time'] + [f'{self.sensor}_{fea}' for fea in features]
+        data_df = raw_data[[col for col in raw_data.columns if col in self.feature_col]]
+
+        # 按时间戳排序
+        data_df['UTC time'] = pd.to_datetime(data_df['UTC time'])
+        data_df = data_df.set_index('UTC time').sort_index()
+
+        # 重采样、插分
+        if is_resample:
+            self.start_time, self.end_time = data_df.index.min(), data_df.index.max()
+            full_index = pd.date_range(self.start_time, self.end_time, freq='h')
+            data_df = data_df.reindex(full_index)
+            data_df = data_df.interpolate(method='linear')
+        else:
+            data_df = data_df.dropna()
+
+        # 数据标准化
+        self.min = data_df.min()
+        self.max = data_df.max()
+        self.data = (data_df - self.min) / (self.max - self.min)
+
+    def denormalize(self, x):
+        key = f'{self.sensor}_{self.target}'
+        return x * (self.max[key] - self.min[key]) + self.min[key]
+
+    def construct_set(self, train_por=0.6, test_por=0.2, window_size=12, target='pm25'):
+        train_x = []
+        train_y = []
+        val_x = []
+        val_y = []
+        test_x = []
+        test_y = []
+        self.target = target
+        self.feature_col.remove('UTC time')
+        self.data = self.data.reset_index()
+
+        len_train = int(self.data.shape[0] * train_por)
+        train_seqs = self.data[:len_train]
+        for i in range(train_seqs.shape[0] - window_size):
+            train_seq = train_seqs.loc[i:i + window_size]
+            train_x.append(train_seq.loc[i:i + window_size - 1][self.feature_col].values.tolist())
+            train_y.append(train_seq.loc[i + window_size][f'{self.sensor}_{target}'].tolist())
+
+        len_val = int(self.data.shape[0] * (train_por + test_por))
+        val_seqs = self.data[len_train:len_val]
+        val_seqs = val_seqs.reset_index()
+        for i in range(val_seqs.shape[0] - window_size):
+            val_seq = val_seqs.loc[i:i + window_size]
+            val_x.append(val_seq.loc[i:i + window_size - 1][self.feature_col].values.tolist())
+            val_y.append(val_seq.loc[i + window_size][f'{self.sensor}_{target}'].tolist())
+
+        test_seqs = self.data[len_val:]
+        test_seqs = test_seqs.reset_index()
+        for i in range(test_seqs.shape[0] - window_size):
+            test_seq = test_seqs.loc[i:i + window_size]
+            test_x.append(test_seq.loc[i:i + window_size - 1][self.feature_col].values.tolist())
+            test_y.append(test_seq.loc[i + window_size][f'{self.sensor}_{target}'].tolist())
+
+        train_set = my_Dataset(torch.Tensor(train_x), torch.Tensor(train_y))
+        val_set = my_Dataset(torch.Tensor(val_x), torch.Tensor(val_y))
+        test_set = my_Dataset(torch.Tensor(test_x), torch.Tensor(test_y))
+        return train_set, val_set, test_set
+
+
+class TrafficDataset:
+    def __init__(self, sensor=10, target=0):
+        # 选取适当的检测器用作序列数据
+        self.raw_data = np.load('./dataset/traffic-flow/raw/traffic.npz')['data']
+        self.sensor = sensor
+        self.target = target
+        # 数据标准化
+        self.min = self.raw_data.min()
+        self.max = self.raw_data.max()
+        self.data = (self.raw_data - self.min) / (self.max - self.min)
+
+    def denormalize(self, x):
+        return x * (self.max - self.min) + self.min
+
+    def construct_set(self, train_por=0.6, test_por=0.2, window_size=12, label=0):
+        train_x = []
+        train_y = []
+        val_x = []
+        val_y = []
+        test_x = []
+        test_y = []
+
+        len_train = int(self.data.shape[0] * train_por)
+        train_seqs = self.data[0:len_train, self.sensor, :]
+        for i in range(len_train - window_size):
+            train_x.append(train_seqs[i:i + window_size - 1])
+            train_y.append(train_seqs[i + window_size][label])
+
+        len_val = int(self.data.shape[0] * test_por)
+        val_seqs = self.data[len_train:len_train + len_val, self.sensor, :]
+        for i in range(len_val - window_size):
+            val_x.append(val_seqs[i:i + window_size - 1])
+            val_y.append(val_seqs[i + window_size][label])
+
+        len_test = int(self.data.shape[0] * (1 - train_por - test_por))
+        test_seqs = self.data[len_train + len_val:, self.sensor, :]
+        for i in range(len_test - window_size):
+            test_x.append(test_seqs[i:i + window_size - 1])
+            test_y.append(test_seqs[i + window_size][label])
+
+        train_set = my_Dataset(torch.Tensor(train_x), torch.Tensor(train_y))
+        val_set = my_Dataset(torch.Tensor(val_x), torch.Tensor(val_y))
+        test_set = my_Dataset(torch.Tensor(test_x), torch.Tensor(test_y))
+        return train_set, val_set, test_set

Lab5/utils.py

@@ -0,0 +1,176 @@
+import math
+import torch
+from torch.utils import data
+import torch.nn as nn
+from matplotlib import pyplot as plt
+import numpy as np
+import time
+
+
+def mse_fn(y, pred):
+    return np.mean((np.array(y) - np.array(pred)) ** 2)
+
+
+def mae_fn(y, pred):
+    return np.mean(np.abs(np.array(y) - np.array(pred)))
+
+
+def mape_fn(y, pred):
+    mask = y != 0
+    y = y[mask]
+    pred = pred[mask]
+    mape = np.abs((y - pred) / y)
+    mape = np.mean(mape) * 100
+    return mape
+
+
+def eval(y, pred):
+    y = y.cpu().numpy()
+    pred = pred.cpu().numpy()
+    mse = mse_fn(y, pred)
+    rmse = math.sqrt(mse)
+    mae = mae_fn(y, pred)
+    mape = mape_fn(y, pred)
+    return [rmse, mae, mape]
+
+
+# 测试函数（用于分类）
+def test(net, data_iter, loss_fn, denormalize_fn, device='cpu'):
+    rmse, mae, mape = 0, 0, 0
+    batch_count = 0
+    total_loss = 0.0
+    net.eval()
+    for seqs, targets in data_iter:
+        seqs = seqs.to(device).float()
+        targets = targets.to(device).float()
+        y_hat = net(seqs)
+        loss = loss_fn(y_hat, targets)
+
+        targets = denormalize_fn(targets)
+        y_hat = denormalize_fn(y_hat)
+        a, b, c = eval(targets.detach(), y_hat.detach())
+        rmse += a
+        mae += b
+        mape += c
+        total_loss += loss.detach().cpu().numpy().tolist()
+        batch_count += 1
+    return [rmse / batch_count, mae / batch_count, mape / batch_count], total_loss / batch_count
+
+
+def train(net, train_iter, val_iter, test_iter, loss_fn, denormalize_fn, optimizer, num_epoch,
+          early_stop=10, device='cpu', num_print_epoch_round=0):
+    train_loss_lst = []
+    val_loss_lst = []
+    train_score_lst = []
+    val_score_lst = []
+    epoch_time = []
+
+    best_epoch = 0
+    best_val_rmse = 9999
+    early_stop_flag = 0
+    for epoch in range(num_epoch):
+        net.train()
+        epoch_loss = 0
+        batch_count = 0
+        batch_time = []
+        rmse, mae, mape = 0, 0, 0
+        for seqs, targets in train_iter:
+            batch_s = time.time()
+            seqs = seqs.to(device).float()
+            targets = targets.to(device).float()
+            optimizer.zero_grad()
+            y_hat = net(seqs)
+            loss = loss_fn(y_hat, targets)
+            loss.backward()
+            optimizer.step()
+
+            targets = denormalize_fn(targets)
+            y_hat = denormalize_fn(y_hat)
+            a, b, c = eval(targets.detach(), y_hat.detach())
+            rmse += a
+            mae += b
+            mape += c
+            epoch_loss += loss.detach().cpu().numpy().tolist()
+            batch_count += 1
+
+            batch_time.append(time.time() - batch_s)
+
+        train_loss = epoch_loss / batch_count
+        train_loss_lst.append(train_loss)
+        train_score_lst.append([rmse/batch_count, mae/batch_count, mape/batch_count])
+
+        # 验证集
+        val_score, val_loss = test(net, val_iter, loss_fn, denormalize_fn, device)
+        val_score_lst.append(val_score)
+        val_loss_lst.append(val_loss)
+
+        epoch_time.append(np.array(batch_time).sum())
+
+        # 打印本轮训练结果
+        if num_print_epoch_round > 0 and (epoch+1) % num_print_epoch_round == 0:
+            print(
+                f"Epoch [{epoch + 1}/{num_epoch}],",
+                f"Train Loss: {train_loss:.4f},",
+                f"Train RMSE: {train_score_lst[-1][0]:.4f},",
+                f"Val Loss: {val_loss:.4f},",
+                f"Val RMSE: {val_score[0]:.6f},",
+                f"Time Use: {epoch_time[-1]:.3f}s"
+            )
+
+        # 早停
+        if val_score[0] < best_val_rmse:
+            best_val_rmse = val_score[0]
+            best_epoch = epoch
+            early_stop_flag = 0
+        else:
+            early_stop_flag += 1
+            if early_stop_flag == early_stop:
+                print(f'The model has not been improved for {early_stop} rounds. Stop early!')
+                break
+
+    # 输出最终训练结果
+    print(
+        f'Final result:',
+        f'Get best validation rmse {np.array(val_score_lst)[:, 0].min():.4f} at epoch {best_epoch},',
+        f'Total time {np.array(epoch_time).sum():.2f}s'
+    )
+
+    # 计算测试集效果
+    test_score, test_loss = test(net, test_iter, loss_fn, denormalize_fn, device)
+    print(
+        'Test result:',
+        f'Test RMSE: {test_score[0]},',
+        f'Test MAE: {test_score[1]},',
+        f'Test MAPE: {test_score[2]}'
+    )
+    return train_loss_lst, val_loss_lst, train_score_lst, val_score_lst, epoch
+
+
+def visualize(num_epochs, train_data, test_data, x_label='epoch', y_label='loss'):
+    x = np.arange(0, num_epochs + 1).astype(dtype=np.int32)
+    plt.figure(figsize=(5, 3.5))
+    plt.plot(x, train_data, label=f"train_{y_label}", linewidth=1.5)
+    plt.plot(x, test_data, label=f"val_{y_label}", linewidth=1.5)
+    plt.xlabel(x_label)
+    plt.ylabel(y_label)
+    plt.legend()
+    plt.show()
+
+
+def plot_metric(score_log):
+    score_log = np.array(score_log)
+
+    plt.figure(figsize=(13, 3.5))
+    plt.subplot(1, 3, 1)
+    plt.plot(score_log[:, 0], c='#d28ad4')
+    plt.ylabel('RMSE')
+
+    plt.subplot(1, 3, 2)
+    plt.plot(score_log[:, 1], c='#e765eb')
+    plt.ylabel('MAE')
+
+    plt.subplot(1, 3, 3)
+    plt.plot(score_log[:, 2], c='#6b016d')
+    plt.ylabel('MAPE')
+
+    plt.show()

README.md

@@ -0,0 +1,41 @@
+# 深度学习课程实验报告-北京交通大学计算机学院
+
+> 北京交通大学计算机学院开设的2023-2024学年秋季学期深度学习（本科）课程 课程实验报告
+>
+> 作者 柯劲帆
+
+本实验报告绝大部分由个人完成，小部分参考课程材料和ChatGPT。
+
+结课后整理，供后续选课同学参考。
+
+## Getting Started 使用指南
+
+### Installation 安装
+
+Windows & Linux:
+
+在命令行运行以下命令，获取项目源码：
+
+```shell
+git clone https://github.com/typingbugs/School-DeepLearningCourse-Lab.git
+```
+
+pip安装python依赖包：
+
+```shell
+pip install -r requirements.txt
+```
+
+获取数据集（实验四和实验五需要）：
+
+链接：https://pan.baidu.com/s/13pELZTtqVu11Q1GhSFZUdg?pwd=8024 
+提取码：8024
+
+解压命令：
+```shell
+tar -xzvf datasets.tar.gz
+```
+
+如果对你有帮助，麻烦点个**star** ~
+
+Enjoy ~

requirements.txt

@@ -2,8 +2,8 @@ black
 ipdb
 jupyter
 numpy
-torch==2.1.0
+torch
-torchaudio==2.1.0
+torchvision
-torchvision==0.16.0
 tqdm
-matplotlib
+matplotlib
+pandas