chore: Add comments, clean unused objects and improve ridge detection

app.py

@@ -19,7 +19,7 @@ from common import (
     REPO_DIR,
     SERVER_URL,
 )
-from custom_client_server import CustomFHEClient, CustomFHEServer
+from custom_client_server import CustomFHEClient
 
 # Uncomment here to have both the server and client in the same terminal
 subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
@@ -27,11 +27,16 @@ time.sleep(3)
 
 
 def decrypt_output_with_wrong_key(encrypted_image, image_filter):
+    """Decrypt the encrypted output using a different private key.
+    """
+    # Retrieve the filter's deployment path
     filter_path = FILTERS_PATH / f"{image_filter}/deployment"
 
+    # Instantiate the client interface and generate a new private key
     wrong_client = CustomFHEClient(filter_path, WRONG_KEYS_PATH)
     wrong_client.generate_private_and_evaluation_keys(force=True)
 
+    # Deserialize, decrypt and post-processing the encrypted output using the new private key
     output_image = wrong_client.deserialize_decrypt_post_process(encrypted_image)
 
     return output_image

common.py

@@ -2,26 +2,23 @@
 
 from pathlib import Path
 
-import numpy as np
-from PIL import Image
-
-# The repository's directory
+# This repository's directory
 REPO_DIR = Path(__file__).parent
 
-# The repository's main directories
+# This repository's main necessary folders
 FILTERS_PATH = REPO_DIR / "filters"
 KEYS_PATH = REPO_DIR / ".fhe_keys"
 WRONG_KEYS_PATH = REPO_DIR / ".wrong_keys"
 CLIENT_TMP_PATH = REPO_DIR / "client_tmp"
 SERVER_TMP_PATH = REPO_DIR / "server_tmp"
 
-# Create the directories if it does not exist yet
+# Create the necessary folders
 KEYS_PATH.mkdir(exist_ok=True)
 WRONG_KEYS_PATH.mkdir(exist_ok=True)
 CLIENT_TMP_PATH.mkdir(exist_ok=True)
 SERVER_TMP_PATH.mkdir(exist_ok=True)
 
-# All the filters currently available in the app
+# All the filters currently available in the demo
 AVAILABLE_FILTERS = [
     "identity",
     "inverted",
@@ -32,25 +29,14 @@ AVAILABLE_FILTERS = [
     "ridge detection",
 ]
 
-# The input image's shape. Images with larger input shapes will be cropped and/or resized to this
+# The input images' shape. Images with different input shapes will be cropped and resized by Gradio
 INPUT_SHAPE = (100, 100)
 
-# Generate random images as an inputset for compilation
-np.random.seed(42)
-INPUTSET = tuple(
-    np.random.randint(0, 255, size=(INPUT_SHAPE + (3,)), dtype=np.int64) for _ in range(10)
-)
-
-
-def load_image(image_path):
-    image = Image.open(image_path).convert("RGB").resize(INPUT_SHAPE)
-    image = np.asarray(image, dtype="int64")
-    return image
-
-
-_INPUTSET_DIR = REPO_DIR / "input_examples"
+# Retrieve the input examples directory
+INPUT_EXAMPLES_DIR = REPO_DIR / "input_examples"
 
-# List of all image examples suggested in the app
-EXAMPLES = [str(image) for image in _INPUTSET_DIR.glob("**/*")]
+# List of all image examples suggested in the demo
+EXAMPLES = [str(image) for image in INPUT_EXAMPLES_DIR.glob("**/*")]
 
+# Store the server's URL
 SERVER_URL = "http://localhost:8000/"

compile.py

@@ -2,10 +2,8 @@
 
 import json
 import shutil
-
-import numpy as np
 import onnx
-from common import AVAILABLE_FILTERS, FILTERS_PATH, INPUT_SHAPE, INPUTSET, KEYS_PATH
+from common import AVAILABLE_FILTERS, FILTERS_PATH, KEYS_PATH
 from custom_client_server import CustomFHEClient, CustomFHEDev
 
 print("Starting compiling the filters.")
@@ -13,18 +11,17 @@ print("Starting compiling the filters.")
 for image_filter in AVAILABLE_FILTERS:
     print("\nCompiling filter:", image_filter)
 
-    # Load the onnx model
-    onnx_model = onnx.load(FILTERS_PATH / f"{image_filter}/server.onnx")
-
+    # Retrieve the deployment files associated to the current filter
     deployment_path = FILTERS_PATH / f"{image_filter}/deployment"
 
-    # Retrieve the client API related to the current filter
+    # Retrieve the client associated to the current filter
     model = CustomFHEClient(deployment_path, KEYS_PATH).model
 
-    image_shape = INPUT_SHAPE + (3,)
+    # Load the onnx model
+    onnx_model = onnx.load(FILTERS_PATH / f"{image_filter}/server.onnx")
 
-    # Compile the model using the loaded onnx model
-    model.compile(INPUTSET, onnx_model=onnx_model)
+    # Compile the model on a representative inputset, using the loaded onnx model
+    model.compile(onnx_model=onnx_model)
 
     processing_json_path = deployment_path / "serialized_processing.json"
 
@@ -36,11 +33,11 @@ for image_filter in AVAILABLE_FILTERS:
     if deployment_path.is_dir():
         shutil.rmtree(deployment_path)
 
-    # Save the files needed for deployment
-    fhe_api = CustomFHEDev(model=model, path_dir=deployment_path)
-    fhe_api.save()
+    # Save the development files needed for deployment
+    fhe_dev = CustomFHEDev(model=model, path_dir=deployment_path)
+    fhe_dev.save()
 
-    # Write the serialized_processing.json file to the deployment folder
+    # Write the serialized_processing.json file in the deployment directory
     with open(processing_json_path, "w") as f:
         json.dump(serialized_processing, f)
 

custom_client_server.py

@@ -1,4 +1,4 @@
-"Client-server interface implementation for custom models."
+"Client-server interface implementation for custom integer models."
 
 from pathlib import Path
 from typing import Any
@@ -11,16 +11,16 @@ from concrete.ml.common.debugging.custom_assert import assert_true
 
 
 class CustomFHEDev:
-    """Dev API to save the custom model and then load and run the FHE circuit."""
+    """Dev API to save the custom integer model, load and run a FHE circuit."""
 
     model: Any = None
 
     def __init__(self, path_dir: str, model: Any = None):
-        """Initialize the FHE API.
+        """Initialize the development interface.
 
         Args:
-            path_dir (str): the path to the directory where the circuit is saved
-            model (Any): the model to use for the FHE API
+            path_dir (str): The path to the directory where the circuit is saved.
+            model (Any): The model to use for the development interface.
         """
 
         self.path_dir = Path(path_dir)
@@ -33,7 +33,7 @@ class CustomFHEDev:
         """Export all needed artifacts for the client and server.
 
         Raises:
-            Exception: path_dir is not empty
+            Exception: path_dir is not empty.
         """
         # Check if the path_dir is empty with pathlib
         listdir = list(Path(self.path_dir).glob("**/*"))
@@ -73,11 +73,11 @@ class CustomFHEClient:
     client: cnp.Client
 
     def __init__(self, path_dir: str, key_dir: str = None):
-        """Initialize the FHE API.
+        """Initialize the client interface.
 
         Args:
-            path_dir (str): the path to the directory where the circuit is saved
-            key_dir (str): the path to the directory where the keys are stored
+            path_dir (str): The path to the directory where the circuit is saved.
+            key_dir (str): The path to the directory where the keys are stored.
         """
         self.path_dir = Path(path_dir)
         self.key_dir = Path(key_dir)
@@ -103,7 +103,7 @@ class CustomFHEClient:
         """Generate the private and evaluation keys.
 
         Args:
-            force (bool): if True, regenerate the keys even if they already exist
+            force (bool): If True, regenerate the keys even if they already exist.
         """
         self.client.keygen(force)
 
@@ -111,7 +111,7 @@ class CustomFHEClient:
         """Get the serialized evaluation keys.
 
         Returns:
-            cnp.EvaluationKeys: the evaluation keys
+            cnp.EvaluationKeys: The evaluation keys.
         """
         return self.client.evaluation_keys.serialize()
 
@@ -119,10 +119,10 @@ class CustomFHEClient:
         """Encrypt and serialize the values.
 
         Args:
-            x (numpy.ndarray): the values to encrypt and serialize
+            x (numpy.ndarray): The values to encrypt and serialize.
 
         Returns:
-            cnp.PublicArguments: the encrypted and serialized values
+            cnp.PublicArguments: The encrypted and serialized values.
         """
         # Pre-process the values
         x = self.model.pre_processing(x)
@@ -140,10 +140,10 @@ class CustomFHEClient:
         """Deserialize, decrypt and post-process the values.
 
         Args:
-            serialized_encrypted_output (cnp.PublicArguments): the serialized and encrypted output
+            serialized_encrypted_output (cnp.PublicArguments): The serialized and encrypted output.
 
         Returns:
-            numpy.ndarray: the decrypted values
+            numpy.ndarray: The decrypted values.
         """
         # Deserialize the encrypted values
         deserialized_encrypted_output = self.client.specs.unserialize_public_result(
@@ -159,15 +159,15 @@ class CustomFHEClient:
 
 
 class CustomFHEServer:
-    """Server API to load and run the FHE circuit."""
+    """Server interface to load and run a FHE circuit."""
 
     server: cnp.Server
 
     def __init__(self, path_dir: str):
-        """Initialize the FHE API.
+        """Initialize the server interface.
 
         Args:
-            path_dir (str): the path to the directory where the circuit is saved
+            path_dir (str): The path to the directory where the circuit is saved.
         """
 
         self.path_dir = Path(path_dir)
@@ -187,11 +187,11 @@ class CustomFHEServer:
         """Run the model on the server over encrypted data.
 
         Args:
-            serialized_encrypted_data (cnp.PublicArguments): the encrypted and serialized data
-            serialized_evaluation_keys (cnp.EvaluationKeys): the serialized evaluation keys
+            serialized_encrypted_data (cnp.PublicArguments): The encrypted and serialized data.
+            serialized_evaluation_keys (cnp.EvaluationKeys): The serialized evaluation keys.
 
         Returns:
-            cnp.PublicResult: the result of the model
+            cnp.PublicResult: The result of the model.
         """
         assert_true(self.server is not None, "Model has not been loaded.")
 

filters.py

@@ -4,7 +4,7 @@ import json
 
 import numpy as np
 import torch
-from common import AVAILABLE_FILTERS
+from common import AVAILABLE_FILTERS, INPUT_SHAPE
 from concrete.numpy.compilation.compiler import Compiler
 from torch import nn
 
@@ -63,17 +63,18 @@ class _TorchRotate(nn.Module):
 class _TorchConv2D(nn.Module):
     """Torch model for applying a single 2D convolution operator on images."""
 
-    def __init__(self, kernel, n_in_channels=3, n_out_channels=3, groups=1):
-        """Initializing the filter
+    def __init__(self, kernel, n_in_channels=3, n_out_channels=3, groups=1, threshold=None):
+        """Initialize the filter.
 
         Args:
             kernel (np.ndarray): The convolution kernel to consider.
         """
         super().__init__()
-        self.kernel = kernel
+        self.kernel = torch.tensor(kernel, dtype=torch.int64)
         self.n_out_channels = n_out_channels
         self.n_in_channels = n_in_channels
         self.groups = groups
+        self.threshold = threshold
 
     def forward(self, x):
         """Forward pass for filtering the image using a 2D kernel.
@@ -113,7 +114,14 @@ class _TorchConv2D(nn.Module):
                 f"{kernel_shape}"
             )
 
-        return nn.functional.conv2d(x, kernel, stride=stride, groups=self.groups)
+        # Apply the convolution
+        x = nn.functional.conv2d(x, kernel, stride=stride, groups=self.groups)
+
+        # Subtract a given threshold if given
+        if self.threshold is not None:
+            x -= self.threshold
+
+        return x
 
 
 class Filter:
@@ -135,6 +143,8 @@ class Filter:
         )
 
         self.filter = image_filter
+        self.onnx_model = None
+        self.fhe_circuit = None
         self.divide = None
         self.repeat_out_channels = False
 
@@ -156,65 +166,62 @@ class Filter:
             # However, since FHE computations require weights to be integers, we first multiply
             # these by a factor of 1000. The output image's values are then divided by 1000 in
             # post-processing in order to retrieve the correct result
-            kernel = torch.tensor([299, 587, 114])
+            kernel = [299, 587, 114]
 
             self.torch_model = _TorchConv2D(kernel, n_out_channels=1, groups=1)
 
-            # Division value for post-processing
+            # Define the value used when for dividing the output values in post-processing
             self.divide = 1000
 
-            # Grayscaled image needs to be put in RGB format for Gradio display
+            # Indicate that the out_channels will need to be repeated, as Gradio requires all 
+            # images to have a RGB format, even for grayscaled ones
             self.repeat_out_channels = True
 
         elif image_filter == "blur":
-            kernel = torch.ones((3, 3), dtype=torch.int64)
+            kernel = np.ones((3, 3))
 
             self.torch_model = _TorchConv2D(kernel, n_out_channels=3, groups=3)
 
-            # Division value for post-processing
+            # Define the value used when for dividing the output values in post-processing
             self.divide = 9
 
         elif image_filter == "sharpen":
-            kernel = torch.tensor(
-                [
-                    [0, -1, 0],
-                    [-1, 5, -1],
-                    [0, -1, 0],
-                ]
-            )
+            kernel = [
+                [0, -1, 0],
+                [-1, 5, -1],
+                [0, -1, 0],
+            ]
 
             self.torch_model = _TorchConv2D(kernel, n_out_channels=3, groups=3)
 
         elif image_filter == "ridge detection":
-            kernel = torch.tensor(
-                [
-                    [-1, -1, -1],
-                    [-1, 9, -1],
-                    [-1, -1, -1],
-                ]
-            )
-
-            self.torch_model = _TorchConv2D(kernel, n_out_channels=1, groups=1)
-
-            # Ridge detection is usually displayed as a grayscaled image, which needs to be put in
-            # RGB format for Gradio display
+            kernel = [
+                [-1, -1, -1],
+                [-1, 9, -1],
+                [-1, -1, -1],
+            ]
+
+            # Additionally to the convolution operator, the filter will subtract a given threshold
+            # value to the result in order to better display the ridges
+            self.torch_model = _TorchConv2D(kernel, n_out_channels=1, groups=1, threshold=900)
+
+            # Indicate that the out_channels will need to be repeated, as Gradio requires all 
+            # images to have a RGB format, even for grayscaled ones. Ridge detection images are 
+            # ususally displayed as such
             self.repeat_out_channels = True
 
-        self.onnx_model = None
-        self.fhe_circuit = None
-
-    def compile(self, inputset, onnx_model=None):
-        """Compile the model using an inputset.
+    def compile(self, onnx_model=None):
+        """Compile the model on a representative inputset.
 
         Args:
-            inputset (List[np.ndarray]): The set of images to use for compilation
             onnx_model (onnx.ModelProto): The loaded onnx model to consider. If None, it will be
                 generated automatically using a NumpyModule. Default to None.
         """
-        # Reshape the inputs found in inputset. This is done because Torch and Numpy don't follow
-        # the same shape conventions.
+        # Generate a random representative set of images used for compilation, following Torch's 
+        # shape format (batch, in_channels, image_height, image_width) 
+        np.random.seed(42)
         inputset = tuple(
-            np.expand_dims(input.transpose(2, 0, 1), axis=0).astype(np.int64) for input in inputset
+            np.random.randint(0, 255, size=((1, 3) + INPUT_SHAPE), dtype=np.int64) for _ in range(10)
         )
 
         # If no onnx model was given, generate a new one.
@@ -243,30 +250,31 @@ class Filter:
         return self.fhe_circuit
 
     def pre_processing(self, input_image):
-        """Processing that needs to be applied before encryption.
+        """Apply pre-processing to the encrypted input images.
 
         Args:
-            input_image (np.ndarray): The image to pre-process
+            input_image (np.ndarray): The image to pre-process.
 
         Returns:
-            input_image (np.ndarray): The pre-processed image
+            input_image (np.ndarray): The pre-processed image.
         """
         # Reshape the inputs found in inputset. This is done because Torch and Numpy don't follow
         # the same shape conventions.
+        # Additionally, make sure the input images are made of integers only
         input_image = np.expand_dims(input_image.transpose(2, 0, 1), axis=0).astype(np.int64)
 
         return input_image
 
     def post_processing(self, output_image):
-        """Processing that needs to be applied after decryption.
+        """Apply post-processing to the encrypted output images.
 
         Args:
-            input_image (np.ndarray): The decrypted image to post-process
+            input_image (np.ndarray): The decrypted image to post-process.
 
         Returns:
-            input_image (np.ndarray): The post-processed image
+            input_image (np.ndarray): The post-processed image.
         """
-        # Apply a division if needed
+        # Divide all values if needed
         if self.divide is not None:
             output_image //= self.divide
 
@@ -277,7 +285,7 @@ class Filter:
         # the same shape conventions.
         output_image = output_image.transpose(0, 2, 3, 1).squeeze(0)
 
-        # Grayscaled image needs to be put in RGB format for Gradio display
+        # Gradio requires all images to follow a RGB format
         if self.repeat_out_channels:
             output_image = output_image.repeat(3, axis=2)
 

filters/black and white/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9a8fae28225c53cc6e184535a8880187626892461a7f0c25afe322dfaa83f678
+oid sha256:eef269dcec0d548972cc25c3ef9abd8067bd8df8e4a30b53a1b3006575b70baf
 size 388

filters/black and white/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4253afb0e46be27e5aa2562c14e7bc402fc7aa39cf01a824f1170c5e46ccf9aa
+oid sha256:8ca528ad3f3b99b6c69b0bb0e0a4724615a6be7ac2222424b7c2ac48c26e5b95
 size 4364

filters/blur/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6ead03bc109e6598c90000f580c2d149f19c4ed968dfa302dfea78c131bdad02
+oid sha256:ce25848e14481bf54e4a52fad3ea178bc78ebf2d62e464839da4de58c5a48d43
 size 391

filters/blur/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:deb92cf90d25f2c4552bb8a2fa0eb0f0cbe0fdc549665f2b63a15a78c0b20d72
+oid sha256:9a058aeab0894ea93e00db344a9e71abeb63c6e8faa8bdb661ae4b304d3eee5c
 size 7263

filters/identity/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:05f39bf162b0ffcd9e4105c371180a621ebdc64fce12a751547424e3a6ec0c0b
+oid sha256:b285786e91816d4f1848968d6737929a90f073d2aabac607b0fe5cd0867f314a
 size 378

filters/identity/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9741844b0e166078608310f3812724cf0dd117927457763ecec48e5e510ebc5a
+oid sha256:438384a8517e5ccb354851b9a8baa3ee86af59726d9f1600d98527f0568059b5
 size 2559

filters/inverted/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:05f39bf162b0ffcd9e4105c371180a621ebdc64fce12a751547424e3a6ec0c0b
+oid sha256:b285786e91816d4f1848968d6737929a90f073d2aabac607b0fe5cd0867f314a
 size 378

filters/inverted/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e3b413c12bb4d656e739247af1ffb848d57a70a2f57011dd367af66c56cce025
+oid sha256:ca6086a06f95b349609433162e316ceddf05dfe6ea2b0936492123ff46f417a7
 size 4179

filters/ridge detection/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b58c440c56ec350092d730eb2e8d2118225eed501fb8dba5df17b96440fe6a08
+oid sha256:f8fe63b4e3b322a2c4dd1bb742878b2e90c1b6c151dc2af7bb16155fea29a66c
 size 397

filters/ridge detection/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:91c225472c2d225d3211b54a1f4bca1a7df54ae6543e6d62e7c6a48601dd9e31
-size 4479
+oid sha256:58266bb522e40f8ba7746e1eca6191e7a1c3c385e99b294c759bbbc88f7e6408
+size 5043

filters/ridge detection/server.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:48821745ed7a9b25b5ba8ae0dc3da35739985bf5dd1dac5b3a9c207adbbf1c45
-size 532
+oid sha256:42f9914e64003c33c7eceb639a001ceb4460c8226e0e380cb032741851e41c49
+size 648

filters/rotate/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:05f39bf162b0ffcd9e4105c371180a621ebdc64fce12a751547424e3a6ec0c0b
+oid sha256:b285786e91816d4f1848968d6737929a90f073d2aabac607b0fe5cd0867f314a
 size 378

filters/rotate/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3f4c3cfa73f19125923edca845c70a55eb5a882ddb17fc8f979ed349b845eb6e
+oid sha256:ecea959453ffd704efba1c5e22db54e902cc6c3289870ece101793d1479cb347
 size 4431

filters/sharpen/deployment/client.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4a13c773025de645be26fbedd7bb9b0926464ad08f992ff089aee90ee58df5f3
+oid sha256:4df798a79bfc380debbfbc7a9cdaf79a096fe1deb18327f31dc141bea38f8d4e
 size 396

filters/sharpen/deployment/server.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:65892df870b0e07b717fb971b85c0e6ed2d0acc345db9fec1eb90497b1092374
+oid sha256:befb2eaff02cc855af745dc82bc8f24ce713e4ff4393e3b635f55b8f82e0ff20
 size 7311

generate_dev_files.py

@@ -1,11 +1,8 @@
 "A script to generate all development files necessary for the image filtering demo."
 
 import shutil
-from pathlib import Path
-
-import numpy as np
 import onnx
-from common import AVAILABLE_FILTERS, FILTERS_PATH, INPUT_SHAPE, INPUTSET
+from common import AVAILABLE_FILTERS, FILTERS_PATH
 from custom_client_server import CustomFHEDev
 from filters import Filter
 
@@ -17,16 +14,16 @@ for image_filter in AVAILABLE_FILTERS:
     # Create the filter instance
     filter = Filter(image_filter)
 
-    image_shape = INPUT_SHAPE + (3,)
-
-    # Compile the filter on the inputset
-    filter.compile(INPUTSET)
+    # Compile the model on a representative inputset
+    filter.compile()
 
+    # Define the directory path associated to this filter
     filter_path = FILTERS_PATH / image_filter
 
+    # Define the directory path associated to this filter's deployment files
     deployment_path = filter_path / "deployment"
 
-    # Delete the deployment folder and its content if it exist
+    # Delete the deployment folder and its content if it already exists
     if deployment_path.is_dir():
         shutil.rmtree(deployment_path)
 

server.py

@@ -43,9 +43,12 @@ def send_input(
     filter: str = Form(),
     files: List[UploadFile] = File(),
 ):
+    """Send the inputs to the server."""
+    # Retrieve the encrypted input image and the evaluation key paths
     encrypted_image_path = get_server_file_path("encrypted_image", filter, user_id)
     evaluation_key_path = get_server_file_path("evaluation_key", filter, user_id)
-
+    
+    # Write the files using the above paths
     with encrypted_image_path.open("wb") as encrypted_image, evaluation_key_path.open(
         "wb"
     ) as evaluation_key:
@@ -58,26 +61,30 @@ def run_fhe(
     user_id: str = Form(),
     filter: str = Form(),
 ):
-
+    """Execute the filter on the encrypted input image using FHE."""
+    # Retrieve the encrypted input image and the evaluation key paths
     encrypted_image_path = get_server_file_path("encrypted_image", filter, user_id)
     evaluation_key_path = get_server_file_path("evaluation_key", filter, user_id)
 
+    # Read the files using the above paths
     with encrypted_image_path.open("rb") as encrypted_image_file, evaluation_key_path.open(
         "rb"
     ) as evaluation_key_file:
         encrypted_image = encrypted_image_file.read()
         evaluation_key = evaluation_key_file.read()
 
-    #  Load the model
-    fhe_model = CustomFHEServer(FILTERS_PATH / f"{filter}/deployment")
+    # Load the FHE server
+    fhe_server = CustomFHEServer(FILTERS_PATH / f"{filter}/deployment")
 
     # Run the FHE execution
     start = time.time()
-    encrypted_output_image = fhe_model.run(encrypted_image, evaluation_key)
+    encrypted_output_image = fhe_server.run(encrypted_image, evaluation_key)
     fhe_execution_time = round(time.time() - start, 2)
 
+    # Retrieve the encrypted output image path
     encrypted_output_path = get_server_file_path("encrypted_output", filter, user_id)
 
+    # Write the file using the above path
     with encrypted_output_path.open("wb") as encrypted_output:
         encrypted_output.write(encrypted_output_image)
 
@@ -89,8 +96,11 @@ def get_output(
     user_id: str = Form(),
     filter: str = Form(),
 ):
+    """Retrieve the encrypted output image."""
+    # Retrieve the encrypted output image path
     encrypted_output_path = get_server_file_path("encrypted_output", filter, user_id)
 
+    # Read the file using the above path
     with encrypted_output_path.open("rb") as encrypted_output_file:
         encrypted_output = encrypted_output_file.read()