diff --git a/bilateral/hooks/hook-pycuda.py b/bilateral/hooks/hook-pycuda.py
index bf41b49344c444e2bd3136d8ed4bb9322f33b034..ca3780fd84c0b7b71c5c37c4f7239724bb9cf3a8 100644
--- a/bilateral/hooks/hook-pycuda.py
+++ b/bilateral/hooks/hook-pycuda.py
@@ -1,2 +1,3 @@
 from PyInstaller.utils.hooks import copy_metadata
-datas = copy_metadata('pycuda')
+
+datas = copy_metadata("pycuda")
diff --git a/bilateral/main.py b/bilateral/main.py
index fb2c56272b8e7761ef7bc9302e6f6c894d11d7fe..1ce47393fc34075fa7ddbcb2d787cde066065252 100644
--- a/bilateral/main.py
+++ b/bilateral/main.py
@@ -1,62 +1,56 @@
-import numpy as np
-from PIL import Image
-from src import gpu, cpu
-import fire
 import logging
 from pathlib import Path
+
+import fire
+import numpy as np
+from PIL import Image
+
+from src import cpu, gpu
+
 logger = logging.getLogger(__name__)
 
 
 def read_img(file_path: str) -> np.ndarray:
-    logger.debug(f'Reading image {file_path}')
-    src_img = Image.open(file_path).convert('L')
+    logger.debug(f"Reading image {file_path}")
+    src_img = Image.open(file_path).convert("L")
     return np.asarray(src_img)
 
 
 def write_img(img_arr: np.ndarray, img_name: str):
-    Path('out_imgs').mkdir(exist_ok=True)
-    res_img = Image.fromarray(img_arr).convert('L')
-    filename = f'out_imgs/{img_name}.png'
-    logger.debug(f'Writing image to {filename}')
+    Path("out_imgs").mkdir(exist_ok=True)
+    res_img = Image.fromarray(img_arr).convert("L")
+    filename = f"out_imgs/{img_name}.png"
+    logger.debug(f"Writing image to {filename}")
     res_img.save(filename)
 
 
 class CLI(object):
-    def run(self,
-            img_path: str,
-            sigma_r: float = 75,
-            sigma_d: float = 75):
+    def run(self, img_path: str, sigma_r: float = 75, sigma_d: float = 75):
         gpu_time = self.run_gpu(img_path, sigma_r, sigma_d)
         cpu_time = self.run_cpu(img_path, sigma_r, sigma_d)
-        logger.info(f'CPU execution time: {cpu_time}')
-        logger.info(f'GPU execution time: {gpu_time}')
-        logger.info(f'Acceleration: {cpu_time / gpu_time:.5f}')
-
-    def run_gpu(self,
-                img_path: str,
-                sigma_r: float = 75,
-                sigma_d: float = 75):
+        logger.info(f"CPU execution time: {cpu_time}")
+        logger.info(f"GPU execution time: {gpu_time}")
+        logger.info(f"Acceleration: {cpu_time / gpu_time:.5f}")
+
+    def run_gpu(self, img_path: str, sigma_r: float = 75, sigma_d: float = 75):
         src_img = read_img(img_path)
         res_img, execution_time = gpu.filter_image(src_img, sigma_r, sigma_d)
-        write_img(res_img, 'gpu')
+        write_img(res_img, "gpu")
         return execution_time
 
-    def run_cpu(self,
-                img_path: str,
-                sigma_r: float = 75,
-                sigma_d: float = 75):
+    def run_cpu(self, img_path: str, sigma_r: float = 75, sigma_d: float = 75):
         src_img = read_img(img_path)
         res_img, execution_time = cpu.filter_image(src_img, sigma_r, sigma_d)
-        write_img(res_img, 'cpu')
+        write_img(res_img, "cpu")
         return execution_time
 
 
 def setup_logging():
     logging.basicConfig(
-        format="[%(levelname)8s] %(msg)s {%(filename)s:%(lineno)s}",
-        level=logging.DEBUG)
+        format="[%(levelname)8s] %(msg)s {%(filename)s:%(lineno)s}", level=logging.DEBUG
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     setup_logging()
     fire.Fire(CLI)
diff --git a/bilateral/src/cpu.py b/bilateral/src/cpu.py
index 8b2065588bdce7b0ef87efdfae25bc8ff8decd68..92950e5953e9e4b5acc7cce1069d7a0d9d348153 100644
--- a/bilateral/src/cpu.py
+++ b/bilateral/src/cpu.py
@@ -1,6 +1,7 @@
-import numpy as np
-import time
 import logging
+import time
+
+import numpy as np
 
 logger = logging.getLogger(__name__)
 
@@ -15,8 +16,8 @@ def filter_image(image: np.ndarray, sigma_r: float, sigma_d: float):
             s = 0
             for k in range(i - 1, i + 2):
                 for l in range(j - 1, j + 2):
-                    g = np.exp(-((k - i)**2 + (l - j)**2) / sigma_d**2)
-                    r = np.exp(-(image[k, l] - image[i, j])**2 / sigma_r**2)
+                    g = np.exp(-((k - i) ** 2 + (l - j) ** 2) / sigma_d ** 2)
+                    r = np.exp(-((image[k, l] - image[i, j]) ** 2) / sigma_r ** 2)
                     c += g * r
                     s += g * r * image[k, l]
             result[i, j] = s / c
diff --git a/bilateral/src/gpu.py b/bilateral/src/gpu.py
index b183a2cd7370b17efee06ec6a743633f92016648..4462637cc4346835e9915910f22fc24164867016 100644
--- a/bilateral/src/gpu.py
+++ b/bilateral/src/gpu.py
@@ -1,31 +1,29 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+import logging
+import pkgutil
 import time
+
 import numpy as np
-import pkgutil
 import pycuda.autoinit
-import pycuda.driver as drv
+from pycuda import driver as drv
 from pycuda.compiler import SourceModule
 
-import logging
-
 logger = logging.getLogger(__name__)
 
 
 def filter_image(image: np.ndarray, sigma_r: float, sigma_d: float):
-    kernel_code = pkgutil.get_data('src',
-                                   'kernel.cu').decode('UTF-8', 'ignore')
-    logger.debug('Read kernel code.')
+    kernel_code = pkgutil.get_data("src", "kernel.cu").decode("UTF-8", "ignore")
+    logger.debug("Read kernel code.")
     logger.debug(kernel_code)
     kernel = SourceModule(kernel_code)
     N, M = image.shape
     logger.debug("Image shape: {N}, {M}")
     result = np.zeros((N, M), dtype=np.uint32)
     block_size = (8, 8, 1)
-    logger.debug(f'Using block size: {block_size}')
-    grid_size = (int(np.ceil(N / block_size[0])),
-                 int(np.ceil(M / block_size[1])))
-    logger.debug(f'Using block size: {block_size}')
+    logger.debug(f"Using block size: {block_size}")
+    grid_size = (int(np.ceil(N / block_size[0])), int(np.ceil(M / block_size[1])))
+    logger.debug(f"Using block size: {block_size}")
     filt_gpu = kernel.get_function("filter")
     tex = kernel.get_texref("tex")
     tex.set_filter_mode(drv.filter_mode.LINEAR)
@@ -33,14 +31,16 @@ def filter_image(image: np.ndarray, sigma_r: float, sigma_d: float):
     tex.set_address_mode(1, drv.address_mode.MIRROR)
     drv.matrix_to_texref(image.astype(np.uint32), tex, order="C")
     start_time = time.time()
-    filt_gpu(drv.Out(result),
-             np.int32(N),
-             np.int32(M),
-             np.float32(sigma_d),
-             np.float32(sigma_r),
-             block=block_size,
-             grid=grid_size,
-             texrefs=[tex])
+    filt_gpu(
+        drv.Out(result),
+        np.int32(N),
+        np.int32(M),
+        np.float32(sigma_d),
+        np.float32(sigma_r),
+        block=block_size,
+        grid=grid_size,
+        texrefs=[tex],
+    )
     drv.Context.synchronize()
     end_time = time.time()
     execution_time = end_time - start_time