Homework3 Submit

hw3/code/data_preprocess.py

@@ -28,9 +28,9 @@ def preprocess(pre_conv, data_root, image_size, classes):
     # calculate the mean and PCA projection matrix
     data_mean, u = PCA(train_data, 2)
 
+    u = u * 20
+
     # TODO: using PCA to compress the dimensionality of the train_data after subtracting the mean vector
-    print(train_data)
-    print(data_mean)
     train_data_pca = (train_data - data_mean) @ u
 
     visualize(train_data_pca, train_label, "train")
@@ -100,14 +100,14 @@ def PCA(data, dim=2):
     data_mean = data.mean(dim=0)
     # TODO: compute the covariance matrix of train_data
     diff = data - data_mean
-    data_cov = diff.T @ diff
+    # data_cov = diff.T @ diff
+    data_cov = torch.cov(diff.T)
     # TODO: compute the SVD decompositon of data_cov using torch.linalg.svd
     # reference: https://pytorch.org/docs/1.11/generated/torch.linalg.svd.html
     u, s, v = torch.linalg.svd(data_cov)
     # TODO: return the proper 'data_mean' and 'u[]'
     return data_mean, u[:, :dim]
 
-
 def loaddata(pre_conv, data_root, mode, image_size, classes):
     """
     load one dataset, and use pretrained network in homework 2 to extract feature
@@ -173,7 +173,7 @@ if __name__ == "__main__":
         configs["use_stn"],
         configs["dropout_prob"],
     )
-    cls.load_state_dict(pretrained_checkpoint["model_state"])
+    cls.load_state_dict(pretrained_checkpoint["model_state"], strict=False)
     for param in cls.parameters():
         param.requires_grad = False
     conv = cls.conv_net

hw3/code/svm_hw.py

@@ -85,11 +85,13 @@ class Hinge(torch.autograd.Function):
 
         # TODO: compute the hinge loss (together with L2 norm for SVM): loss = 0.5*||w||^2 + C*\sum_i{max(0, 1 - y_i*output_i)}
         # you may need F.relu() to implement the max() function.
+        # print("output size", output.size())
+        # print("label size", label.size())
         # print("product", label * output.reshape_as(label))
         # print("minus", 1 - label * output.reshape_as(label))
         # print("relu", F.relu(1 - label * output.reshape_as(label)))
         # print("sum", (F.relu(1 - label * output.reshape_as(label))).sum())
-        loss = 1/2 * (W @ W.T) + C * (F.relu(1 - label * output.reshape_as(label))).sum()
+        loss = 1/2 * (W @ W.T) + C * (F.relu(1 - (output.T * label).T)).sum()
         ctx.save_for_backward(output, W, label, C)
 
         return loss
@@ -109,7 +111,7 @@ class Hinge(torch.autograd.Function):
         # print("output", output, "label", label, "product", (1 - label.reshape_as(output) * output))
         # print("grad_loss size", grad_loss.size())
         # print("sizeof l / output", (C * torch.heaviside(1 - label.reshape_as(output) * output, torch.tensor(0).type_as(output)) * (-label.reshape_as(output))).size())
-        grad_output = grad_loss * C * (torch.heaviside(1 - label.reshape_as(output) * output, torch.tensor(1).type_as(output)) * (-label.reshape_as(output)))
+        grad_output = grad_loss * C * ((torch.heaviside(1 - (output.T * label).T, torch.tensor(1).type_as(output)).T * (-label))).T
         grad_W = grad_loss * W
         return grad_output, grad_W, None, None
 

hw3/code/test_svm.py

@@ -44,7 +44,7 @@ def test(
     svm = SVM_HINGE(model_svm["configs"]["feature_channel"], model_svm["configs"]["C"])
 
     # TODO: load model parameters (model_svm['state_dict']) we saved in model_path using svm.load_state_dict()
-    svm.load_state_dict(model_svm["model_state"])
+    svm.load_state_dict(model_svm["state_dict"])
 
     # TODO: put the model on CPU or GPU
     svm.to(device)