修改requirements.txt文件，添加main函数判断

Lab1/code/2.1.py

@@ -95,53 +95,54 @@ class My_Dataset(Dataset):
         return x, y
 
 
-learning_rate = 5e-2
-num_epochs = 10
-batch_size = 1024
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
+if __name__ == "__main__":
+    learning_rate = 5e-2
+    num_epochs = 10
+    batch_size = 1024
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
 
-dataset = My_Dataset()
-dataloader = DataLoader(
-    dataset=dataset,
-    batch_size=batch_size,
-    shuffle=True,
-    num_workers=14,
-    pin_memory=True,
-)
-
-model = Model_2_1().to(device)
-criterion = My_BCELoss()
-optimizer = My_optimizer(model.parameters(), lr=learning_rate)
-
-for epoch in range(num_epochs):
-    total_epoch_loss = 0
-    total_epoch_pred = 0
-    total_epoch_target = 0
-    for index, (x, targets) in tqdm(enumerate(dataloader), total=len(dataloader)):
-        optimizer.zero_grad()
-        x = x.to(device).to(dtype=torch.float32)
-        targets = targets.to(device).to(dtype=torch.float32)
-        x = x.unsqueeze(1)
-        y_pred = model(x)
-        loss = criterion(y_pred, targets)
-        total_epoch_loss += loss.item()
-        total_epoch_target += targets.sum().item()
-        total_epoch_pred += y_pred.sum().item()
-
-        loss.backward()
-        optimizer.step()
-
-    print(
-        f"Epoch {epoch + 1}/{num_epochs}, Loss: {total_epoch_loss}, Acc: {1 - abs(total_epoch_pred - total_epoch_target) / total_epoch_target}"
+    dataset = My_Dataset()
+    dataloader = DataLoader(
+        dataset=dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=14,
+        pin_memory=True,
     )
 
-with torch.no_grad():
-    test_data = (np.array([[2]]) - dataset.min_x) / (dataset.max_x - dataset.min_x)
-    test_data = Variable(
-        torch.tensor(test_data, dtype=torch.float64), requires_grad=False
-    ).to(device)
-    predicted = model(test_data).to("cpu")
-    print(
-        f"Model weights: {model.linear.weight.item()}, bias: {model.linear.bias.item()}"
-    )
-    print(f"Prediction for test data: {predicted.item()}")
+    model = Model_2_1().to(device)
+    criterion = My_BCELoss()
+    optimizer = My_optimizer(model.parameters(), lr=learning_rate)
+
+    for epoch in range(num_epochs):
+        total_epoch_loss = 0
+        total_epoch_pred = 0
+        total_epoch_target = 0
+        for index, (x, targets) in tqdm(enumerate(dataloader), total=len(dataloader)):
+            optimizer.zero_grad()
+            x = x.to(device).to(dtype=torch.float32)
+            targets = targets.to(device).to(dtype=torch.float32)
+            x = x.unsqueeze(1)
+            y_pred = model(x)
+            loss = criterion(y_pred, targets)
+            total_epoch_loss += loss.item()
+            total_epoch_target += targets.sum().item()
+            total_epoch_pred += y_pred.sum().item()
+
+            loss.backward()
+            optimizer.step()
+
+        print(
+            f"Epoch {epoch + 1}/{num_epochs}, Loss: {total_epoch_loss}, Acc: {1 - abs(total_epoch_pred - total_epoch_target) / total_epoch_target}"
+        )
+
+    with torch.no_grad():
+        test_data = (np.array([[2]]) - dataset.min_x) / (dataset.max_x - dataset.min_x)
+        test_data = Variable(
+            torch.tensor(test_data, dtype=torch.float64), requires_grad=False
+        ).to(device)
+        predicted = model(test_data).to("cpu")
+        print(
+            f"Model weights: {model.linear.weight.item()}, bias: {model.linear.bias.item()}"
+        )
+        print(f"Prediction for test data: {predicted.item()}")

Lab1/code/2.2.py

@@ -38,56 +38,57 @@ class My_Dataset(Dataset):
         return x, y
 
 
-learning_rate = 5e-2
-num_epochs = 10
-batch_size = 1024
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
+if __name__ == "__main__":
+    learning_rate = 5e-2
+    num_epochs = 10
+    batch_size = 1024
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
 
-dataset = My_Dataset()
-dataloader = DataLoader(
-    dataset=dataset,
-    batch_size=batch_size,
-    shuffle=True,
-    num_workers=14,
-    pin_memory=True,
-)
-
-model = Model_2_2().to(device)
-criterion = nn.BCELoss()
-optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
-
-for epoch in range(num_epochs):
-    total_epoch_loss = 0
-    total_epoch_pred = 0
-    total_epoch_target = 0
-    for index, (x, targets) in tqdm(enumerate(dataloader), total=len(dataloader)):
-        optimizer.zero_grad()
-
-        x = x.to(device)
-        targets = targets.to(device)
-
-        x = x.unsqueeze(1)
-        targets = targets.unsqueeze(1)
-        y_pred = model(x)
-        loss = criterion(y_pred, targets)
-        total_epoch_loss += loss.item()
-        total_epoch_target += targets.sum().item()
-        total_epoch_pred += y_pred.sum().item()
-
-        loss.backward()
-        optimizer.step()
-
-    print(
-        f"Epoch {epoch + 1}/{num_epochs}, Loss: {total_epoch_loss}, Acc: {1 - abs(total_epoch_pred - total_epoch_target) / total_epoch_target}"
+    dataset = My_Dataset()
+    dataloader = DataLoader(
+        dataset=dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=14,
+        pin_memory=True,
     )
 
-with torch.no_grad():
-    test_data = (np.array([[2]]) - dataset.min_x) / (dataset.max_x - dataset.min_x)
-    test_data = Variable(
-        torch.tensor(test_data, dtype=torch.float64), requires_grad=False
-    ).to(device)
-    predicted = model(test_data).to("cpu")
-    print(
-        f"Model weights: {model.linear.weight.item()}, bias: {model.linear.bias.item()}"
-    )
-    print(f"Prediction for test data: {predicted.item()}")
+    model = Model_2_2().to(device)
+    criterion = nn.BCELoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+    for epoch in range(num_epochs):
+        total_epoch_loss = 0
+        total_epoch_pred = 0
+        total_epoch_target = 0
+        for index, (x, targets) in tqdm(enumerate(dataloader), total=len(dataloader)):
+            optimizer.zero_grad()
+
+            x = x.to(device)
+            targets = targets.to(device)
+
+            x = x.unsqueeze(1)
+            targets = targets.unsqueeze(1)
+            y_pred = model(x)
+            loss = criterion(y_pred, targets)
+            total_epoch_loss += loss.item()
+            total_epoch_target += targets.sum().item()
+            total_epoch_pred += y_pred.sum().item()
+
+            loss.backward()
+            optimizer.step()
+
+        print(
+            f"Epoch {epoch + 1}/{num_epochs}, Loss: {total_epoch_loss}, Acc: {1 - abs(total_epoch_pred - total_epoch_target) / total_epoch_target}"
+        )
+
+    with torch.no_grad():
+        test_data = (np.array([[2]]) - dataset.min_x) / (dataset.max_x - dataset.min_x)
+        test_data = Variable(
+            torch.tensor(test_data, dtype=torch.float64), requires_grad=False
+        ).to(device)
+        predicted = model(test_data).to("cpu")
+        print(
+            f"Model weights: {model.linear.weight.item()}, bias: {model.linear.bias.item()}"
+        )
+        print(f"Prediction for test data: {predicted.item()}")

Lab1/code/3.1.py

@@ -96,73 +96,76 @@ class Model_3_1:
         return self.params
 
 
-learning_rate = 5e-1
-num_epochs = 10
-batch_size = 4096
-num_classes = 10
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
+if __name__ == "__main__":
+    learning_rate = 5e-1
+    num_epochs = 10
+    batch_size = 4096
+    num_classes = 10
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
 
-transform = transforms.Compose(
-    [
-        transforms.ToTensor(),
-        transforms.Normalize((0.5,), (1.0,)),
-    ]
-)
-train_dataset = datasets.FashionMNIST(
-    root="../dataset", train=True, transform=transform, download=True
-)
-test_dataset = datasets.FashionMNIST(
-    root="../dataset", train=False, transform=transform, download=True
-)
-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,
-    shuffle=True,
-    num_workers=14,
-    pin_memory=True,
-)
-
-model = Model_3_1(num_classes).to(device)
-criterion = My_CrossEntropyLoss()
-optimizer = My_optimizer(model.parameters(), lr=learning_rate)
-
-for epoch in range(num_epochs):
-    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).to(dtype=torch.long)
-
-        one_hot_targets = (
-            my_one_hot(targets, num_classes=num_classes).to(device).to(dtype=torch.long)
-        )
-
-        outputs = model(images)
-        loss = criterion(outputs, one_hot_targets)
-        total_epoch_loss += loss
-
-        loss.backward()
-        optimizer.step()
-
-    total_acc = 0
-    with torch.no_grad():
-        for index, (image, targets) in tqdm(
-            enumerate(test_loader), total=len(test_loader)
-        ):
-            image = image.to(device)
-            targets = targets.to(device)
-            outputs = model(image)
-            total_acc += (outputs.argmax(1) == targets).sum()
-    print(
-        f"Epoch {epoch + 1}/{num_epochs} Train, Loss: {total_epoch_loss}, Acc: {total_acc / len(test_dataset)}"
+    transform = transforms.Compose(
+        [
+            transforms.ToTensor(),
+            transforms.Normalize((0.5,), (1.0,)),
+        ]
     )
+    train_dataset = datasets.FashionMNIST(
+        root="../dataset", train=True, transform=transform, download=True
+    )
+    test_dataset = datasets.FashionMNIST(
+        root="../dataset", train=False, transform=transform, download=True
+    )
+    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,
+        shuffle=True,
+        num_workers=14,
+        pin_memory=True,
+    )
+
+    model = Model_3_1(num_classes).to(device)
+    criterion = My_CrossEntropyLoss()
+    optimizer = My_optimizer(model.parameters(), lr=learning_rate)
+
+    for epoch in range(num_epochs):
+        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).to(dtype=torch.long)
+
+            one_hot_targets = (
+                my_one_hot(targets, num_classes=num_classes)
+                .to(device)
+                .to(dtype=torch.long)
+            )
+
+            outputs = model(images)
+            loss = criterion(outputs, one_hot_targets)
+            total_epoch_loss += loss
+
+            loss.backward()
+            optimizer.step()
+
+        total_acc = 0
+        with torch.no_grad():
+            for index, (image, targets) in tqdm(
+                enumerate(test_loader), total=len(test_loader)
+            ):
+                image = image.to(device)
+                targets = targets.to(device)
+                outputs = model(image)
+                total_acc += (outputs.argmax(1) == targets).sum()
+        print(
+            f"Epoch {epoch + 1}/{num_epochs} Train, Loss: {total_epoch_loss}, Acc: {total_acc / len(test_dataset)}"
+        )

Lab1/code/3.2.py

@@ -20,77 +20,78 @@ class Model_3_2(nn.Module):
         return x
 
 
-learning_rate = 5e-2
-num_epochs = 10
-batch_size = 4096
-num_classes = 10
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
+if __name__ == "__main__":
+    learning_rate = 5e-2
+    num_epochs = 10
+    batch_size = 4096
+    num_classes = 10
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
 
-transform = transforms.Compose(
-    [
-        transforms.ToTensor(),
-        transforms.Normalize((0.5,), (1.0,)),
-    ]
-)
-train_dataset = datasets.FashionMNIST(
-    root="../dataset", train=True, transform=transform, download=True
-)
-test_dataset = datasets.FashionMNIST(
-    root="../dataset", train=False, transform=transform, download=True
-)
-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,
-    shuffle=True,
-    num_workers=14,
-    pin_memory=True,
-)
-
-model = Model_3_2(num_classes).to(device)
-criterion = nn.CrossEntropyLoss()
-optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
-
-for epoch in range(num_epochs):
-    total_epoch_loss = 0
-    model.train()
-    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 = (
-            torch.nn.functional.one_hot(targets, num_classes=num_classes)
-            .to(device)
-            .to(dtype=torch.float32)
-        )
-
-        outputs = model(images)
-        loss = criterion(outputs, one_hot_targets)
-        total_epoch_loss += loss
-
-        loss.backward()
-        optimizer.step()
-
-    model.eval()
-    total_acc = 0
-    with torch.no_grad():
-        for index, (image, targets) in tqdm(
-            enumerate(test_loader), total=len(test_loader)
-        ):
-            image = image.to(device)
-            targets = targets.to(device)
-            outputs = model(image)
-            total_acc += (outputs.argmax(1) == targets).sum()
-    print(
-        f"Epoch {epoch + 1}/{num_epochs} Train, Loss: {total_epoch_loss}, Acc: {total_acc / len(test_dataset)}"
+    transform = transforms.Compose(
+        [
+            transforms.ToTensor(),
+            transforms.Normalize((0.5,), (1.0,)),
+        ]
     )
+    train_dataset = datasets.FashionMNIST(
+        root="../dataset", train=True, transform=transform, download=True
+    )
+    test_dataset = datasets.FashionMNIST(
+        root="../dataset", train=False, transform=transform, download=True
+    )
+    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,
+        shuffle=True,
+        num_workers=14,
+        pin_memory=True,
+    )
+
+    model = Model_3_2(num_classes).to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
+
+    for epoch in range(num_epochs):
+        total_epoch_loss = 0
+        model.train()
+        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 = (
+                torch.nn.functional.one_hot(targets, num_classes=num_classes)
+                .to(device)
+                .to(dtype=torch.float32)
+            )
+
+            outputs = model(images)
+            loss = criterion(outputs, one_hot_targets)
+            total_epoch_loss += loss
+
+            loss.backward()
+            optimizer.step()
+
+        model.eval()
+        total_acc = 0
+        with torch.no_grad():
+            for index, (image, targets) in tqdm(
+                enumerate(test_loader), total=len(test_loader)
+            ):
+                image = image.to(device)
+                targets = targets.to(device)
+                outputs = model(image)
+                total_acc += (outputs.argmax(1) == targets).sum()
+        print(
+            f"Epoch {epoch + 1}/{num_epochs} Train, Loss: {total_epoch_loss}, Acc: {total_acc / len(test_dataset)}"
+        )