[MNT] Code formatting

Author: xuyxu

examples/classification_cifar10_cnn.py

@@ -28,7 +28,6 @@ def display_records(records, logger):
 
 
 class LeNet5(nn.Module):
-
     def __init__(self):
         super(LeNet5, self).__init__()
         self.conv1 = nn.Conv2d(3, 6, 5)
@@ -68,22 +67,25 @@ def forward(self, x):
             transforms.RandomHorizontalFlip(),
             transforms.RandomCrop(32, 4),
             transforms.ToTensor(),
-            transforms.Normalize((0.4914, 0.4822, 0.4465),
-                                 (0.2023, 0.1994, 0.2010)),
+            transforms.Normalize(
+                (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
+            ),
         ]
     )
 
     test_transformer = transforms.Compose(
         [
             transforms.ToTensor(),
-            transforms.Normalize((0.4914, 0.4822, 0.4465),
-                                 (0.2023, 0.1994, 0.2010)),
+            transforms.Normalize(
+                (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
+            ),
         ]
     )
 
     train_loader = DataLoader(
-        datasets.CIFAR10(data_dir, train=True, download=True,
-                         transform=train_transformer),
+        datasets.CIFAR10(
+            data_dir, train=True, download=True, transform=train_transformer
+        ),
         batch_size=batch_size,
         shuffle=True,
     )
@@ -98,9 +100,7 @@ def forward(self, x):
 
     # FusionClassifier
     model = FusionClassifier(
-        estimator=LeNet5,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=LeNet5, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -118,14 +118,13 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("FusionClassifier", training_time, evaluating_time,
-                    testing_acc))
+    records.append(
+        ("FusionClassifier", training_time, evaluating_time, testing_acc)
+    )
 
     # VotingClassifier
     model = VotingClassifier(
-        estimator=LeNet5,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=LeNet5, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -141,14 +140,13 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("VotingClassifier", training_time, evaluating_time,
-                    testing_acc))
+    records.append(
+        ("VotingClassifier", training_time, evaluating_time, testing_acc)
+    )
 
     # BaggingClassifier
     model = BaggingClassifier(
-        estimator=LeNet5,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=LeNet5, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -164,14 +162,13 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("BaggingClassifier", training_time, evaluating_time,
-                    testing_acc))
+    records.append(
+        ("BaggingClassifier", training_time, evaluating_time, testing_acc)
+    )
 
     # GradientBoostingClassifier
     model = GradientBoostingClassifier(
-        estimator=LeNet5,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=LeNet5, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -187,14 +184,18 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("GradientBoostingClassifier", training_time,
-                    evaluating_time, testing_acc))
+    records.append(
+        (
+            "GradientBoostingClassifier",
+            training_time,
+            evaluating_time,
+            testing_acc,
+        )
+    )
 
     # SnapshotEnsembleClassifier
     model = SnapshotEnsembleClassifier(
-        estimator=LeNet5,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=LeNet5, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -210,8 +211,14 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("SnapshotEnsembleClassifier", training_time,
-                    evaluating_time, testing_acc))
+    records.append(
+        (
+            "SnapshotEnsembleClassifier",
+            training_time,
+            evaluating_time,
+            testing_acc,
+        )
+    )
 
     # Print results on different ensemble methods
     display_records(records, logger)

examples/regression_YearPredictionMSD_mlp.py

@@ -102,9 +102,7 @@ def forward(self, x):
 
     # FusionRegressor
     model = FusionRegressor(
-        estimator=MLP,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=MLP, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -120,14 +118,13 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("FusionRegressor", training_time, evaluating_time,
-                    testing_mse))
+    records.append(
+        ("FusionRegressor", training_time, evaluating_time, testing_mse)
+    )
 
     # VotingRegressor
     model = VotingRegressor(
-        estimator=MLP,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=MLP, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -143,14 +140,13 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("VotingRegressor", training_time, evaluating_time,
-                    testing_mse))
+    records.append(
+        ("VotingRegressor", training_time, evaluating_time, testing_mse)
+    )
 
     # BaggingRegressor
     model = BaggingRegressor(
-        estimator=MLP,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=MLP, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -166,14 +162,13 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("BaggingRegressor", training_time, evaluating_time,
-                    testing_mse))
+    records.append(
+        ("BaggingRegressor", training_time, evaluating_time, testing_mse)
+    )
 
     # GradientBoostingRegressor
     model = GradientBoostingRegressor(
-        estimator=MLP,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=MLP, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -189,14 +184,18 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("GradientBoostingRegressor", training_time,
-                    evaluating_time, testing_mse))
+    records.append(
+        (
+            "GradientBoostingRegressor",
+            training_time,
+            evaluating_time,
+            testing_mse,
+        )
+    )
 
     # SnapshotEnsembleRegressor
     model = SnapshotEnsembleRegressor(
-        estimator=MLP,
-        n_estimators=n_estimators,
-        cuda=True
+        estimator=MLP, n_estimators=n_estimators, cuda=True
     )
 
     # Set the optimizer
@@ -212,8 +211,14 @@ def forward(self, x):
     toc = time.time()
     evaluating_time = toc - tic
 
-    records.append(("SnapshotEnsembleRegressor", training_time,
-                    evaluating_time, testing_acc))
+    records.append(
+        (
+            "SnapshotEnsembleRegressor",
+            training_time,
+            evaluating_time,
+            testing_acc,
+        )
+    )
 
     # Print results on different ensemble methods
     display_records(records, logger)

examples/snapshot_ensemble_cifar10_resnet18.py

@@ -16,18 +16,30 @@ class BasicBlock(nn.Module):
     def __init__(self, in_planes, planes, stride=1):
         super(BasicBlock, self).__init__()
         self.conv1 = nn.Conv2d(
-            in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+            in_planes,
+            planes,
+            kernel_size=3,
+            stride=stride,
+            padding=1,
+            bias=False,
+        )
         self.bn1 = nn.BatchNorm2d(planes)
-        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
-                               stride=1, padding=1, bias=False)
+        self.conv2 = nn.Conv2d(
+            planes, planes, kernel_size=3, stride=1, padding=1, bias=False
+        )
         self.bn2 = nn.BatchNorm2d(planes)
 
         self.shortcut = nn.Sequential()
-        if stride != 1 or in_planes != self.expansion*planes:
+        if stride != 1 or in_planes != self.expansion * planes:
             self.shortcut = nn.Sequential(
-                nn.Conv2d(in_planes, self.expansion*planes,
-                          kernel_size=1, stride=stride, bias=False),
-                nn.BatchNorm2d(self.expansion*planes)
+                nn.Conv2d(
+                    in_planes,
+                    self.expansion * planes,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False,
+                ),
+                nn.BatchNorm2d(self.expansion * planes),
             )
 
     def forward(self, x):
@@ -43,17 +55,18 @@ def __init__(self, block, num_blocks, num_classes=10):
         super(ResNet, self).__init__()
         self.in_planes = 64
 
-        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,
-                               stride=1, padding=1, bias=False)
+        self.conv1 = nn.Conv2d(
+            3, 64, kernel_size=3, stride=1, padding=1, bias=False
+        )
         self.bn1 = nn.BatchNorm2d(64)
         self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
         self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
         self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
         self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
-        self.linear = nn.Linear(512*block.expansion, num_classes)
+        self.linear = nn.Linear(512 * block.expansion, num_classes)
 
     def _make_layer(self, block, planes, num_blocks, stride):
-        strides = [stride] + [1]*(num_blocks-1)
+        strides = [stride] + [1] * (num_blocks - 1)
         layers = []
         for stride in strides:
             layers.append(block(self.in_planes, planes, stride))
@@ -93,29 +106,33 @@ def forward(self, x):
             transforms.RandomHorizontalFlip(),
             transforms.RandomCrop(32, 4),
             transforms.ToTensor(),
-            transforms.Normalize((0.4914, 0.4822, 0.4465),
-                                 (0.2023, 0.1994, 0.2010)),
+            transforms.Normalize(
+                (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
+            ),
         ]
     )
 
     test_transformer = transforms.Compose(
         [
             transforms.ToTensor(),
-            transforms.Normalize((0.4914, 0.4822, 0.4465),
-                                 (0.2023, 0.1994, 0.2010)),
+            transforms.Normalize(
+                (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
+            ),
         ]
     )
 
     train_loader = DataLoader(
-        datasets.CIFAR10(data_dir, train=True, download=True, transform=train_transformer),
+        datasets.CIFAR10(
+            data_dir, train=True, download=True, transform=train_transformer
+        ),
         batch_size=batch_size,
-        shuffle=True
+        shuffle=True,
     )
 
     test_loader = DataLoader(
         datasets.CIFAR10(data_dir, train=False, transform=test_transformer),
         batch_size=batch_size,
-        shuffle=True
+        shuffle=True,
     )
 
     # Set the Logger
@@ -126,16 +143,13 @@ def forward(self, x):
         estimator=ResNet,
         estimator_args={"block": BasicBlock, "num_blocks": [2, 2, 2, 2]},
         n_estimators=n_estimators,
-        cuda=True
+        cuda=True,
     )
 
     # Set the Optimizer
-    model.set_optimizer("SGD",
-                        lr=lr,
-                        weight_decay=weight_decay,
-                        momentum=momentum)
+    model.set_optimizer(
+        "SGD", lr=lr, weight_decay=weight_decay, momentum=momentum
+    )
 
     # Train and Evaluate
-    model.fit(train_loader,
-              epochs=epochs,
-              test_loader=test_loader)
+    model.fit(train_loader, epochs=epochs, test_loader=test_loader)