Reformat codebase with more default black. (#506)

Author: jettify

Makefile

@@ -34,8 +34,8 @@ cov cover coverage:
 	@echo "open file://`pwd`/htmlcov/index.html"
 
 checkfmt:
-	isort --check-only --diff $(FILES)
-	black -S -l 79 --check $(FILES)
+	isort --profile black  --check-only --diff $(FILES)
+	black -l 79 --check $(FILES)
 
 lint: flake checkrst pyroma bandit checkfmt
 
@@ -60,11 +60,11 @@ doc:
 	@echo "open file://`pwd`/docs/_build/html/index.html"
 
 black:
-	black -S -l 79 setup.py torch_optimizer/ tests/ examples/
+	black -l 79 setup.py torch_optimizer/ tests/ examples/
 
 fmt:
-	isort ${FILES}
-	black -S -l 79 ${FILES}
+	isort --profile black ${FILES}
+	black -l 79 ${FILES}
 
 
 .PHONY: all flake test vtest cov clean doc

examples/mnist.py

@@ -45,9 +45,9 @@ def train(conf, model, device, train_loader, optimizer, epoch, writer):
         if batch_idx % conf.log_interval == 0:
             loss = loss.item()
             idx = batch_idx + epoch * (len(train_loader))
-            writer.add_scalar('Loss/train', loss, idx)
+            writer.add_scalar("Loss/train", loss, idx)
             print(
-                'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                "Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}".format(
                     epoch,
                     batch_idx * len(data),
                     len(train_loader.dataset),
@@ -66,13 +66,13 @@ def test(conf, model, device, test_loader, epoch, writer):
             data, target = data.to(device), target.to(device)
             output = model(data)
             # sum up batch loss
-            test_loss += F.nll_loss(output, target, reduction='sum').item()
+            test_loss += F.nll_loss(output, target, reduction="sum").item()
             # get the index of the max log-probability
             pred = output.argmax(dim=1, keepdim=True)
             correct += pred.eq(target.view_as(pred)).sum().item()
 
     test_loss /= len(test_loader.dataset)
-    fmt = '\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'
+    fmt = "\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n"
     print(
         fmt.format(
             test_loss,
@@ -82,15 +82,15 @@ def test(conf, model, device, test_loader, epoch, writer):
         )
     )
 
-    writer.add_scalar('Accuracy', correct, epoch)
-    writer.add_scalar('Loss/test', test_loss, epoch)
+    writer.add_scalar("Accuracy", correct, epoch)
+    writer.add_scalar("Loss/test", test_loss, epoch)
 
 
 def prepare_loaders(conf, use_cuda=False):
-    kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
+    kwargs = {"num_workers": 1, "pin_memory": True} if use_cuda else {}
     train_loader = torch.utils.data.DataLoader(
         datasets.MNIST(
-            '../data',
+            "../data",
             train=True,
             download=True,
             transform=transforms.Compose(
@@ -107,7 +107,7 @@ def prepare_loaders(conf, use_cuda=False):
 
     test_loader = torch.utils.data.DataLoader(
         datasets.MNIST(
-            '../data',
+            "../data",
             train=False,
             transform=transforms.Compose(
                 [
@@ -147,21 +147,21 @@ def __init__(
 
 def main():
     conf = Config()
-    log_dir = 'runs/mnist_custom_optim'
-    print('Tensorboard: tensorboard --logdir={}'.format(log_dir))
+    log_dir = "runs/mnist_custom_optim"
+    print("Tensorboard: tensorboard --logdir={}".format(log_dir))
 
     with SummaryWriter(log_dir) as writer:
         use_cuda = not conf.no_cuda and torch.cuda.is_available()
         torch.manual_seed(conf.seed)
-        device = torch.device('cuda' if use_cuda else 'cpu')
+        device = torch.device("cuda" if use_cuda else "cpu")
         train_loader, test_loader = prepare_loaders(conf, use_cuda)
 
         model = Net().to(device)
 
         # create grid of images and write to tensorboard
         images, labels = next(iter(train_loader))
         img_grid = utils.make_grid(images)
-        writer.add_image('mnist_images', img_grid)
+        writer.add_image("mnist_images", img_grid)
 
         # custom optimizer from torch_optimizer package
         optimizer = optim.DiffGrad(model.parameters(), lr=conf.lr)
@@ -173,8 +173,8 @@ def main():
             scheduler.step()
             for name, param in model.named_parameters():
                 writer.add_histogram(name, param, epoch)
-                writer.add_histogram('{}.grad'.format(name), param.grad, epoch)
+                writer.add_histogram("{}.grad".format(name), param.grad, epoch)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/viz_optimizers.py

@@ -7,13 +7,13 @@
 
 import torch_optimizer as optim
 
-plt.style.use('seaborn-white')
+plt.style.use("seaborn-white")
 
 
 def rosenbrock(tensor):
     # https://en.wikipedia.org/wiki/Test_functions_for_optimization
     x, y = tensor
-    return (1 - x) ** 2 + 100 * (y - x ** 2) ** 2
+    return (1 - x) ** 2 + 100 * (y - x**2) ** 2
 
 
 def rastrigin(tensor, lib=torch):
@@ -22,8 +22,8 @@ def rastrigin(tensor, lib=torch):
     A = 10
     f = (
         A * 2
-        + (x ** 2 - A * lib.cos(x * math.pi * 2))
-        + (y ** 2 - A * lib.cos(y * math.pi * 2))
+        + (x**2 - A * lib.cos(x * math.pi * 2))
+        + (y**2 - A * lib.cos(y * math.pi * 2))
     )
     return f
 
@@ -47,8 +47,8 @@ def execute_steps(
 
 
 def objective_rastrigin(params):
-    lr = params['lr']
-    optimizer_class = params['optimizer_class']
+    lr = params["lr"]
+    optimizer_class = params["optimizer_class"]
     initial_state = (-2.0, 3.5)
     minimum = (0, 0)
     optimizer_config = dict(lr=lr)
@@ -60,8 +60,8 @@ def objective_rastrigin(params):
 
 
 def objective_rosenbrok(params):
-    lr = params['lr']
-    optimizer_class = params['optimizer_class']
+    lr = params["lr"]
+    optimizer_class = params["optimizer_class"]
     minimum = (1.0, 1.0)
     initial_state = (-2.0, 2.0)
     optimizer_config = dict(lr=lr)
@@ -85,15 +85,15 @@ def plot_rastrigin(grad_iter, optimizer_name, lr):
     fig = plt.figure(figsize=(8, 8))
 
     ax = fig.add_subplot(1, 1, 1)
-    ax.contour(X, Y, Z, 20, cmap='jet')
-    ax.plot(iter_x, iter_y, color='r', marker='x')
+    ax.contour(X, Y, Z, 20, cmap="jet")
+    ax.plot(iter_x, iter_y, color="r", marker="x")
     ax.set_title(
-        'Rastrigin func: {} with '
-        '{} iterations, lr={:.6}'.format(optimizer_name, len(iter_x), lr)
+        "Rastrigin func: {} with "
+        "{} iterations, lr={:.6}".format(optimizer_name, len(iter_x), lr)
     )
-    plt.plot(*minimum, 'gD')
-    plt.plot(iter_x[-1], iter_y[-1], 'rD')
-    plt.savefig('docs/rastrigin_{}.png'.format(optimizer_name))
+    plt.plot(*minimum, "gD")
+    plt.plot(iter_x[-1], iter_y[-1], "rD")
+    plt.savefig("docs/rastrigin_{}.png".format(optimizer_name))
 
 
 def plot_rosenbrok(grad_iter, optimizer_name, lr):
@@ -109,16 +109,16 @@ def plot_rosenbrok(grad_iter, optimizer_name, lr):
     fig = plt.figure(figsize=(8, 8))
 
     ax = fig.add_subplot(1, 1, 1)
-    ax.contour(X, Y, Z, 90, cmap='jet')
-    ax.plot(iter_x, iter_y, color='r', marker='x')
+    ax.contour(X, Y, Z, 90, cmap="jet")
+    ax.plot(iter_x, iter_y, color="r", marker="x")
 
     ax.set_title(
-        'Rosenbrock func: {} with {} '
-        'iterations, lr={:.6}'.format(optimizer_name, len(iter_x), lr)
+        "Rosenbrock func: {} with {} "
+        "iterations, lr={:.6}".format(optimizer_name, len(iter_x), lr)
     )
-    plt.plot(*minimum, 'gD')
-    plt.plot(iter_x[-1], iter_y[-1], 'rD')
-    plt.savefig('docs/rosenbrock_{}.png'.format(optimizer_name))
+    plt.plot(*minimum, "gD")
+    plt.plot(iter_x[-1], iter_y[-1], "rD")
+    plt.savefig("docs/rosenbrock_{}.png".format(optimizer_name))
 
 
 def execute_experiments(
@@ -128,8 +128,8 @@ def execute_experiments(
     for item in optimizers:
         optimizer_class, lr_low, lr_hi = item
         space = {
-            'optimizer_class': hp.choice('optimizer_class', [optimizer_class]),
-            'lr': hp.loguniform('lr', lr_low, lr_hi),
+            "optimizer_class": hp.choice("optimizer_class", [optimizer_class]),
+            "lr": hp.loguniform("lr", lr_low, lr_hi),
         }
         best = fmin(
             fn=objective,
@@ -138,24 +138,24 @@ def execute_experiments(
             max_evals=200,
             rstate=np.random.RandomState(seed),
         )
-        print(best['lr'], optimizer_class)
+        print(best["lr"], optimizer_class)
 
         steps = execute_steps(
             func,
             initial_state,
             optimizer_class,
-            {'lr': best['lr']},
+            {"lr": best["lr"]},
             num_iter=500,
         )
-        plot_func(steps, optimizer_class.__name__, best['lr'])
+        plot_func(steps, optimizer_class.__name__, best["lr"])
 
 
 def LookaheadYogi(*a, **kw):
     base = optim.Yogi(*a, **kw)
     return optim.Lookahead(base)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # python examples/viz_optimizers.py
 
     # Each optimizer has tweaked search space to produce better plots and

requirements-dev.txt

@@ -1,8 +1,7 @@
 -e .
 bandit==1.7.0
-black==21.9b0
+black==23.3.0
 flake8-bugbear==21.9.2
-flake8-quotes==3.3.1
 flake8==4.0.1
 ipdb==0.13.9
 isort==5.9.3