chore: make the client-server interface inherit from CML

app.py

@@ -26,18 +26,18 @@ subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
 time.sleep(3)
 
 
-def decrypt_output_with_wrong_key(encrypted_image, image_filter):
+def decrypt_output_with_wrong_key(encrypted_image, filter_name):
     """Decrypt the encrypted output using a different private key.
     """
     # Retrieve the filter's deployment path
-    filter_path = FILTERS_PATH / f"{image_filter}/deployment"
+    filter_path = FILTERS_PATH / f"{filter_name}/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)
+    output_image = wrong_client.deserialize_decrypt_dequantize(encrypted_image)
 
     return output_image
 
@@ -61,33 +61,33 @@ def shorten_bytes_object(bytes_object, limit=500):
     return bytes_object[shift : limit + shift].hex()
 
 
-def get_client(user_id, image_filter):
+def get_client(user_id, filter_name):
     """Get the client API.
 
     Args:
         user_id (int): The current user's ID.
-        image_filter (str): The filter chosen by the user
+        filter_name (str): The filter chosen by the user
 
     Returns:
         CustomFHEClient: The client API.
     """
     return CustomFHEClient(
-        FILTERS_PATH / f"{image_filter}/deployment", KEYS_PATH / f"{image_filter}_{user_id}"
+        FILTERS_PATH / f"{filter_name}/deployment", KEYS_PATH / f"{filter_name}_{user_id}"
     )
 
 
-def get_client_file_path(name, user_id, image_filter):
+def get_client_file_path(name, user_id, filter_name):
     """Get the correct temporary file path for the client.
 
     Args:
         name (str): The desired file name.
         user_id (int): The current user's ID.
-        image_filter (str): The filter chosen by the user
+        filter_name (str): The filter chosen by the user
 
     Returns:
         pathlib.Path: The file path.
     """
-    return CLIENT_TMP_PATH / f"{name}_{image_filter}_{user_id}"
+    return CLIENT_TMP_PATH / f"{name}_{filter_name}_{user_id}"
 
 
 def clean_temporary_files(n_keys=20):
@@ -121,11 +121,11 @@ def clean_temporary_files(n_keys=20):
                 file.unlink()
 
 
-def keygen(image_filter):
+def keygen(filter_name):
     """Generate the private key associated to a filter.
 
     Args:
-        image_filter (str): The current filter to consider.
+        filter_name (str): The current filter to consider.
 
     Returns:
         (user_id, True) (Tuple[int, bool]): The current user's ID and a boolean used for visual display.
@@ -138,7 +138,7 @@ def keygen(image_filter):
     user_id = numpy.random.randint(0, 2**32)
 
     # Retrieve the client API
-    client = get_client(user_id, image_filter)
+    client = get_client(user_id, filter_name)
 
     # Generate a private key
     client.generate_private_and_evaluation_keys(force=True)
@@ -154,7 +154,7 @@ def keygen(image_filter):
 
     # Save evaluation_key as bytes in a file as it is too large to pass through regular Gradio
     # buttons (see https://github.com/gradio-app/gradio/issues/1877)
-    evaluation_key_path = get_client_file_path("evaluation_key", user_id, image_filter)
+    evaluation_key_path = get_client_file_path("evaluation_key", user_id, filter_name)
 
     with evaluation_key_path.open("wb") as evaluation_key_file:
         evaluation_key_file.write(evaluation_key)
@@ -162,13 +162,13 @@ def keygen(image_filter):
     return (user_id, True, private_key_size)
 
 
-def encrypt(user_id, input_image, image_filter):
+def encrypt(user_id, input_image, filter_name):
     """Encrypt the given image for a specific user and filter.
 
     Args:
         user_id (int): The current user's ID.
         input_image (numpy.ndarray): The image to encrypt.
-        image_filter (str): The current filter to consider.
+        filter_name (str): The current filter to consider.
 
     Returns:
         (input_image, encrypted_image_short) (Tuple[bytes]): The encrypted image and one of its
@@ -182,17 +182,20 @@ def encrypt(user_id, input_image, image_filter):
         raise gr.Error("Please choose an image first.")
 
     # Retrieve the client API
-    client = get_client(user_id, image_filter)
+    client = get_client(user_id, filter_name)
 
-    # Pre-process, encrypt and serialize the image
-    encrypted_image = client.pre_process_encrypt_serialize(input_image)
+    # Pre-process the input image as Torch and Numpy don't follow the same shape format
+    preprocessed_input_image = client.model.pre_processing(input_image)
+
+    # Encrypt and serialize the image
+    encrypted_image = client.quantize_encrypt_serialize(preprocessed_input_image)
 
     # Compute the input's size in Megabytes
     encrypted_input_size = len(encrypted_image) / 1000000
 
     # Save encrypted_image to bytes in a file, since too large to pass through regular Gradio
     # buttons, https://github.com/gradio-app/gradio/issues/1877
-    encrypted_image_path = get_client_file_path("encrypted_image", user_id, image_filter)
+    encrypted_image_path = get_client_file_path("encrypted_image", user_id, filter_name)
 
     with encrypted_image_path.open("wb") as encrypted_image_file:
         encrypted_image_file.write(encrypted_image)
@@ -203,20 +206,20 @@ def encrypt(user_id, input_image, image_filter):
     return (input_image, encrypted_image_short, encrypted_input_size)
 
 
-def send_input(user_id, image_filter):
+def send_input(user_id, filter_name):
     """Send the encrypted input image as well as the evaluation key to the server.
 
     Args:
         user_id (int): The current user's ID.
-        image_filter (str): The current filter to consider.
+        filter_name (str): The current filter to consider.
     """
     # Get the evaluation key path
-    evaluation_key_path = get_client_file_path("evaluation_key", user_id, image_filter)
+    evaluation_key_path = get_client_file_path("evaluation_key", user_id, filter_name)
 
     if user_id == "" or not evaluation_key_path.is_file():
         raise gr.Error("Please generate the private key first.")
 
-    encrypted_input_path = get_client_file_path("encrypted_image", user_id, image_filter)
+    encrypted_input_path = get_client_file_path("encrypted_image", user_id, filter_name)
 
     if not encrypted_input_path.is_file():
         raise gr.Error("Please generate the private key and then encrypt an image first.")
@@ -224,7 +227,7 @@ def send_input(user_id, image_filter):
     # Define the data and files to post
     data = {
         "user_id": user_id,
-        "filter": image_filter,
+        "filter": filter_name,
     }
 
     files = [
@@ -242,16 +245,16 @@ def send_input(user_id, image_filter):
         return response.ok
 
 
-def run_fhe(user_id, image_filter):
+def run_fhe(user_id, filter_name):
     """Apply the filter on the encrypted image previously sent using FHE.
 
     Args:
         user_id (int): The current user's ID.
-        image_filter (str): The current filter to consider.
+        filter_name (str): The current filter to consider.
     """
     data = {
         "user_id": user_id,
-        "filter": image_filter,
+        "filter": filter_name,
     }
 
     # Trigger the FHE execution on the encrypted image previously sent
@@ -266,12 +269,12 @@ def run_fhe(user_id, image_filter):
             raise gr.Error("Please wait for the input image to be sent to the server.")
 
 
-def get_output(user_id, image_filter):
+def get_output(user_id, filter_name):
     """Retrieve the encrypted output image.
 
     Args:
         user_id (int): The current user's ID.
-        image_filter (str): The current filter to consider.
+        filter_name (str): The current filter to consider.
 
     Returns:
         encrypted_output_image_short (bytes): A representation of the encrypted result.
@@ -279,7 +282,7 @@ def get_output(user_id, image_filter):
     """
     data = {
         "user_id": user_id,
-        "filter": image_filter,
+        "filter": filter_name,
     }
 
     # Retrieve the encrypted output image
@@ -296,25 +299,25 @@ def get_output(user_id, image_filter):
 
             # Save the encrypted output to bytes in a file as it is too large to pass through regular
             # Gradio buttons (see https://github.com/gradio-app/gradio/issues/1877)
-            encrypted_output_path = get_client_file_path("encrypted_output", user_id, image_filter)
+            encrypted_output_path = get_client_file_path("encrypted_output", user_id, filter_name)
 
             with encrypted_output_path.open("wb") as encrypted_output_file:
                 encrypted_output_file.write(encrypted_output)
 
             # Decrypt the image using a different (wrong) key for display
-            output_image_representation = decrypt_output_with_wrong_key(encrypted_output, image_filter)
+            output_image_representation = decrypt_output_with_wrong_key(encrypted_output, filter_name)
 
             return output_image_representation, encrypted_output_size
         else:
             raise gr.Error("Please wait for the FHE execution to be completed.")
 
 
-def decrypt_output(user_id, image_filter):
+def decrypt_output(user_id, filter_name):
     """Decrypt the result.
 
     Args:
         user_id (int): The current user's ID.
-        image_filter (str): The current filter to consider.
+        filter_name (str): The current filter to consider.
 
     Returns:
         (output_image, False, False) ((Tuple[numpy.ndarray, bool, bool]): The decrypted output, as
@@ -325,7 +328,7 @@ def decrypt_output(user_id, image_filter):
         raise gr.Error("Please generate the private key first.")
 
     # Get the encrypted output path
-    encrypted_output_path = get_client_file_path("encrypted_output", user_id, image_filter)
+    encrypted_output_path = get_client_file_path("encrypted_output", user_id, filter_name)
 
     if not encrypted_output_path.is_file():
         raise gr.Error("Please run the FHE execution first.")
@@ -335,10 +338,10 @@ def decrypt_output(user_id, image_filter):
         encrypted_output_image = encrypted_output_file.read()
 
     # Retrieve the client API
-    client = get_client(user_id, image_filter)
+    client = get_client(user_id, filter_name)
 
     # Deserialize, decrypt and post-process the encrypted output
-    output_image = client.deserialize_decrypt_post_process(encrypted_output_image)
+    output_image = client.deserialize_decrypt_dequantize(encrypted_output_image)
 
     return output_image, False, False
 
@@ -374,7 +377,7 @@ with demo:
         )
 
     gr.Markdown("### Step 2. Choose your filter")
-    image_filter = gr.Dropdown(
+    filter_name = gr.Dropdown(
         choices=AVAILABLE_FILTERS, value="inverted", label="Choose your filter", interactive=True
     )
 
@@ -475,36 +478,36 @@ with demo:
     # Button to generate the private key
     keygen_button.click(
         keygen,
-        inputs=[image_filter],
+        inputs=[filter_name],
         outputs=[user_id, keygen_checkbox, private_key_size],
     )
 
     # Button to encrypt inputs on the client side
     encrypt_button.click(
         encrypt,
-        inputs=[user_id, input_image, image_filter],
+        inputs=[user_id, input_image, filter_name],
         outputs=[original_image, encrypted_input, encrypted_input_size],
     )
 
     # Button to send the encodings to the server using post method
     send_input_button.click(
-        send_input, inputs=[user_id, image_filter], outputs=[send_input_checkbox]
+        send_input, inputs=[user_id, filter_name], outputs=[send_input_checkbox]
     )
 
     # Button to send the encodings to the server using post method
-    execute_fhe_button.click(run_fhe, inputs=[user_id, image_filter], outputs=[fhe_execution_time])
+    execute_fhe_button.click(run_fhe, inputs=[user_id, filter_name], outputs=[fhe_execution_time])
 
     # Button to send the encodings to the server using post method
     get_output_button.click(
         get_output, 
-        inputs=[user_id, image_filter], 
+        inputs=[user_id, filter_name], 
         outputs=[encrypted_output_representation, encrypted_output_size]
     )
 
     # Button to decrypt the output on the client side
     decrypt_button.click(
         decrypt_output,
-        inputs=[user_id, image_filter],
+        inputs=[user_id, filter_name],
         outputs=[output_image, keygen_checkbox, send_input_checkbox],
     )
 

compile.py

@@ -4,21 +4,22 @@ import json
 import shutil
 import onnx
 from common import AVAILABLE_FILTERS, FILTERS_PATH, KEYS_PATH
-from custom_client_server import CustomFHEClient, CustomFHEDev
+from custom_client_server import CustomFHEClient
+from concrete.ml.deployment import FHEModelDev
 
 print("Starting compiling the filters.")
 
-for image_filter in AVAILABLE_FILTERS:
-    print("\nCompiling filter:", image_filter)
+for filter_name in AVAILABLE_FILTERS:
+    print("\nCompiling filter:", filter_name)
 
     # Retrieve the deployment files associated to the current filter
-    deployment_path = FILTERS_PATH / f"{image_filter}/deployment"
+    deployment_path = FILTERS_PATH / f"{filter_name}/deployment"
 
     # Retrieve the client associated to the current filter
     model = CustomFHEClient(deployment_path, KEYS_PATH).model
 
     # Load the onnx model
-    onnx_model = onnx.load(FILTERS_PATH / f"{image_filter}/server.onnx")
+    onnx_model = onnx.load(FILTERS_PATH / f"{filter_name}/server.onnx")
 
     # Compile the model on a representative inputset, using the loaded onnx model
     model.compile(onnx_model=onnx_model)
@@ -34,7 +35,7 @@ for image_filter in AVAILABLE_FILTERS:
         shutil.rmtree(deployment_path)
 
     # Save the development files needed for deployment
-    fhe_dev = CustomFHEDev(model=model, path_dir=deployment_path)
+    fhe_dev = FHEModelDev(model=model, path_dir=deployment_path)
     fhe_dev.save()
 
     # Write the serialized_processing.json file in the deployment directory

custom_client_server.py

@@ -1,204 +1,35 @@
-"Client-server interface implementation for custom integer models."
-
-from pathlib import Path
-from typing import Any
+"Client-server interface custom implementation for filter models."
 
+import json
 import concrete.numpy as cnp
-import numpy as np
 from filters import Filter
 
-from concrete.ml.common.debugging.custom_assert import assert_true
-
-
-class CustomFHEDev:
-    """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 development interface.
-
-        Args:
-            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)
-        self.model = model
+from concrete.ml.deployment import FHEModelClient
+from concrete.ml.version import __version__ as CML_VERSION
 
-        # Create the directory path if it does not exist yet
-        Path(self.path_dir).mkdir(parents=True, exist_ok=True)
-
-    def save(self):
-        """Export all needed artifacts for the client and server.
-
-        Raises:
-            Exception: path_dir is not empty.
-        """
-        # Check if the path_dir is empty with pathlib
-        listdir = list(Path(self.path_dir).glob("**/*"))
-        if len(listdir) > 0:
-            raise Exception(
-                f"path_dir: {self.path_dir} is not empty."
-                "Please delete it before saving a new model."
-            )
-
-        assert_true(
-            hasattr(self.model, "fhe_circuit"),
-            "The model must be compiled and have a fhe_circuit object",
-        )
-
-        # Model must be compiled with jit=False
-        # In a jit model, everything is in memory so it is not serializable.
-        assert_true(
-            not self.model.fhe_circuit.configuration.jit,
-            "The model must be compiled with the configuration option jit=False.",
-        )
 
-        # Export the parameters
-        self.model.to_json(path_dir=self.path_dir, file_name="serialized_processing")
+class CustomFHEClient(FHEModelClient):
+    """Client interface to encrypt and decrypt FHE data associated to a Filter."""
 
-        # Save the circuit for the server
-        path_circuit_server = self.path_dir / "server.zip"
-        self.model.fhe_circuit.server.save(path_circuit_server)
-
-        # Save the circuit for the client
-        path_circuit_client = self.path_dir / "client.zip"
-        self.model.fhe_circuit.client.save(path_circuit_client)
-
-
-class CustomFHEClient:
-    """Client API to encrypt and decrypt FHE data."""
-
-    client: cnp.Client
-
-    def __init__(self, path_dir: str, key_dir: str = None):
-        """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.
-        """
-        self.path_dir = Path(path_dir)
-        self.key_dir = Path(key_dir)
-
-        # If path_dir does not exist, raise an error
-        assert_true(
-            Path(path_dir).exists(), f"{path_dir} does not exist. Please specify a valid path."
-        )
-
-        # Load
-        self.load()
-
-    def load(self):  # pylint: disable=no-value-for-parameter
+    def load(self):
         """Load the parameters along with the FHE specs."""
 
         # Load the client
         self.client = cnp.Client.load(self.path_dir / "client.zip", self.key_dir)
 
-        # Load the model
-        self.model = Filter.from_json(self.path_dir / "serialized_processing.json")
-
-    def generate_private_and_evaluation_keys(self, force=False):
-        """Generate the private and evaluation keys.
+        # Load the filter's parameters from the json file
+        with (self.path_dir / "serialized_processing.json").open("r", encoding="utf-8") as f:
+            serialized_processing = json.load(f)
 
-        Args:
-            force (bool): If True, regenerate the keys even if they already exist.
-        """
-        self.client.keygen(force)
-
-    def get_serialized_evaluation_keys(self) -> cnp.EvaluationKeys:
-        """Get the serialized evaluation keys.
-
-        Returns:
-            cnp.EvaluationKeys: The evaluation keys.
-        """
-        return self.client.evaluation_keys.serialize()
-
-    def pre_process_encrypt_serialize(self, x: np.ndarray) -> cnp.PublicArguments:
-        """Encrypt and serialize the values.
-
-        Args:
-            x (numpy.ndarray): The values to encrypt and serialize.
-
-        Returns:
-            cnp.PublicArguments: The encrypted and serialized values.
-        """
-        # Pre-process the values
-        x = self.model.pre_processing(x)
-
-        # Encrypt the values
-        enc_x = self.client.encrypt(x)
-
-        # Serialize the encrypted values to be sent to the server
-        serialized_enc_x = self.client.specs.serialize_public_args(enc_x)
-        return serialized_enc_x
-
-    def deserialize_decrypt_post_process(
-        self, serialized_encrypted_output: cnp.PublicArguments
-    ) -> np.ndarray:
-        """Deserialize, decrypt and post-process the values.
-
-        Args:
-            serialized_encrypted_output (cnp.PublicArguments): The serialized and encrypted output.
-
-        Returns:
-            numpy.ndarray: The decrypted values.
-        """
-        # Deserialize the encrypted values
-        deserialized_encrypted_output = self.client.specs.unserialize_public_result(
-            serialized_encrypted_output
+        # Make sure the version in serialized_model is the same as CML_VERSION
+        assert serialized_processing["cml_version"] == CML_VERSION, (
+            f"The version of Concrete ML library ({CML_VERSION}) is different "
+            f"from the one used to save the model ({serialized_processing['cml_version']}). "
+            "Please update to the proper Concrete ML version.",
         )
 
-        # Decrypt the values
-        deserialized_decrypted_output = self.client.decrypt(deserialized_encrypted_output)
-
-        # Apply the model post processing
-        deserialized_decrypted_output = self.model.post_processing(deserialized_decrypted_output)
-        return deserialized_decrypted_output
-
+        # Initialize the filter model using its filter name
+        filter_name = serialized_processing["model_post_processing_params"]["filter_name"]
+        self.model = Filter(filter_name)
 
-class CustomFHEServer:
-    """Server interface to load and run a FHE circuit."""
-
-    server: cnp.Server
-
-    def __init__(self, path_dir: str):
-        """Initialize the server interface.
-
-        Args:
-            path_dir (str): The path to the directory where the circuit is saved.
-        """
-
-        self.path_dir = Path(path_dir)
-
-        # Load the FHE circuit
-        self.load()
-
-    def load(self):
-        """Load the circuit."""
-        self.server = cnp.Server.load(self.path_dir / "server.zip")
-
-    def run(
-        self,
-        serialized_encrypted_data: cnp.PublicArguments,
-        serialized_evaluation_keys: cnp.EvaluationKeys,
-    ) -> cnp.PublicResult:
-        """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.
-
-        Returns:
-            cnp.PublicResult: The result of the model.
-        """
-        assert_true(self.server is not None, "Model has not been loaded.")
-
-        deserialized_encrypted_data = self.server.client_specs.unserialize_public_args(
-            serialized_encrypted_data
-        )
-        deserialized_evaluation_keys = cnp.EvaluationKeys.unserialize(serialized_evaluation_keys)
-        result = self.server.run(deserialized_encrypted_data, deserialized_evaluation_keys)
-        serialized_result = self.server.client_specs.serialize_public_result(result)
-        return serialized_result
+        return self.model

filters.py

@@ -127,37 +127,45 @@ class _TorchConv2D(nn.Module):
 class Filter:
     """Filter class used in the app."""
 
-    def __init__(self, image_filter="inverted"):
+    def __init__(self, filter_name):
         """Initializing the filter class using a given filter.
 
         Most filters can be found at https://en.wikipedia.org/wiki/Kernel_(image_processing).
 
         Args:
-            image_filter (str): The filter to consider. Default to "inverted".
+            filter_name (str): The filter to consider.
         """
 
         assert_true(
-            image_filter in AVAILABLE_FILTERS,
+            filter_name in AVAILABLE_FILTERS,
             f"Unsupported image filter or transformation. Expected one of {*AVAILABLE_FILTERS,}, "
-            f"but got {image_filter}",
+            f"but got {filter_name}",
         )
 
-        self.filter = image_filter
+        # Define attributes needed in order to prevent the Concrete-ML client-server interface 
+        # from breaking
+        self.post_processing_params = {"filter_name": filter_name}
+        self.input_quantizers = []
+        self.output_quantizers = []
+
+        # Define attributes associated to the filter 
+        self.filter = filter_name
         self.onnx_model = None
         self.fhe_circuit = None
         self.divide = None
         self.repeat_out_channels = False
 
-        if image_filter == "identity":
+        # Instantiate the torch module associated to the given filter name 
+        if filter_name == "identity":
             self.torch_model = _TorchIdentity()
 
-        elif image_filter == "inverted":
+        elif filter_name == "inverted":
             self.torch_model = _TorchInverted()
 
-        elif image_filter == "rotate":
+        elif filter_name == "rotate":
             self.torch_model = _TorchRotate()
 
-        elif image_filter == "black and white":
+        elif filter_name == "black and white":
             # Define the grayscale weights (RGB order)
             # These weights were used in PAL and NTSC video systems and can be found at
             # https://en.wikipedia.org/wiki/Grayscale
@@ -177,7 +185,7 @@ class Filter:
             # images to have a RGB format, even for grayscaled ones
             self.repeat_out_channels = True
 
-        elif image_filter == "blur":
+        elif filter_name == "blur":
             kernel = np.ones((3, 3))
 
             self.torch_model = _TorchConv2D(kernel, n_out_channels=3, groups=3)
@@ -185,7 +193,7 @@ class Filter:
             # Define the value used when for dividing the output values in post-processing
             self.divide = 9
 
-        elif image_filter == "sharpen":
+        elif filter_name == "sharpen":
             kernel = [
                 [0, -1, 0],
                 [-1, 5, -1],
@@ -194,7 +202,7 @@ class Filter:
 
             self.torch_model = _TorchConv2D(kernel, n_out_channels=3, groups=3)
 
-        elif image_filter == "ridge detection":
+        elif filter_name == "ridge detection":
             kernel = [
                 [-1, -1, -1],
                 [-1, 9, -1],
@@ -218,7 +226,9 @@ class Filter:
                 generated automatically using a NumpyModule. Default to None.
         """
         # Generate a random representative set of images used for compilation, following Torch's 
-        # shape format (batch, in_channels, image_height, image_width) 
+        # shape format (batch, in_channels, image_height, image_width) for each samples
+        # This version's compiler only handles tuples of 1-batch array as inputset, meaning we need
+        # to define the inputset as a Tuple[np.ndarray[shape=(1, 3, H, W)]]  
         np.random.seed(42)
         inputset = tuple(
             np.random.randint(0, 255, size=((1, 3) + INPUT_SHAPE), dtype=np.int64) for _ in range(10)
@@ -249,6 +259,20 @@ class Filter:
 
         return self.fhe_circuit
 
+    def quantize_input(self, input_image):
+        """Quantize the input.
+        
+        Images are already quantized in this case, however we need to define this method in order 
+        to prevent the Concrete-ML client-server interface from breaking.
+
+        Args:
+            input_image (np.ndarray): The input to quantize.
+
+        Returns:
+            np.ndarray: The quantized input.
+        """
+        return input_image
+
     def pre_processing(self, input_image):
         """Apply pre-processing to the encrypted input images.
 
@@ -290,72 +314,3 @@ class Filter:
             output_image = output_image.repeat(3, axis=2)
 
         return output_image
-
-    @classmethod
-    def from_json(cls, json_path):
-        """Instantiate a filter using a json file.
-
-        Args:
-            json_path (Union[str, pathlib.Path]): Path to the json file.
-
-        Returns:
-            model (Filter): The instantiated filter class.
-        """
-        # Load the parameters from the json file
-        with open(json_path, "r", encoding="utf-8") as f:
-            serialized_processing = json.load(f)
-
-        # Make sure the version in serialized_model is the same as CML_VERSION
-        assert_true(
-            serialized_processing["cml_version"] == CML_VERSION,
-            f"The version of Concrete ML library ({CML_VERSION}) is different "
-            f"from the one used to save the model ({serialized_processing['cml_version']}). "
-            "Please update to the proper Concrete ML version.",
-        )
-
-        # Initialize the model
-        model = cls(image_filter=serialized_processing["model_filter"])
-
-        return model
-
-    def to_json(self, path_dir, file_name="serialized_processing"):
-        """Export the parameters to a json file.
-
-        Args:
-            path_dir (Union[str, pathlib.Path]): The path to consider when saving the file.
-            file_name (str): The file name
-        """
-        # Serialize the parameters
-        serialized_processing = {
-            "model_filter": self.filter,
-        }
-        serialized_processing = self._clean_dict_types_for_json(serialized_processing)
-
-        # Add the version of the current CML library
-        serialized_processing["cml_version"] = CML_VERSION
-
-        # Save the json file
-        with open(path_dir / f"{file_name}.json", "w", encoding="utf-8") as f:
-            json.dump(serialized_processing, f)
-
-    def _clean_dict_types_for_json(self, d: dict) -> dict:
-        """Clean all values in the dict to be json serializable.
-
-        Args:
-            d (Dict): The dict to clean
-
-        Returns:
-            Dict: The cleaned dict
-        """
-        key_to_delete = []
-        for key, value in d.items():
-            if isinstance(value, list) and len(value) > 0 and isinstance(value[0], dict):
-                d[key] = [self._clean_dict_types_for_json(v) for v in value]
-            elif isinstance(value, dict):
-                d[key] = self._clean_dict_types_for_json(value)
-            elif isinstance(value, (np.generic, np.ndarray)):
-                d[key] = d[key].tolist()
-
-        for key in key_to_delete:
-            d.pop(key)
-        return d

filters/black and white/deployment/client.zip

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

filters/black and white/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "black and white", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "black and white"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/black and white/deployment/server.zip

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

filters/black_and_white/deployment/client.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:000285a62f642b20eda541c6697e33de3d725c254ff5c2098e3157fc73cd017b
-size 388

filters/black_and_white/deployment/serialized_processing.json

@@ -1 +0,0 @@
-{"model_filter": "black_and_white", "cml_version": "0.6.0-rc0"}

filters/black_and_white/deployment/server.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9867657ff1e7b2c8eb3c72f28be8b8e8ee0b355762b99f34a25a2c9de0cb104c
-size 4762

filters/black_and_white/server.onnx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3f4774c394a6fec8cc43dae14ce627837aa998fcc78ba4ab67ad1c5bf92dd3ee
-size 336

filters/blur/deployment/client.zip

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

filters/blur/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "blur", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "blur"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/blur/deployment/server.zip

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

filters/identity/deployment/client.zip

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

filters/identity/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "identity", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "identity"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/identity/deployment/server.zip

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

filters/inverted/deployment/client.zip

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

filters/inverted/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "inverted", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "inverted"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/inverted/deployment/server.zip

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

filters/ridge detection/deployment/client.zip

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

filters/ridge detection/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "ridge detection", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "ridge detection"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/ridge detection/deployment/server.zip

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

filters/ridge_detection/deployment/client.zip

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

filters/ridge_detection/deployment/serialized_processing.json

@@ -1 +0,0 @@
-{"model_filter": "ridge_detection", "cml_version": "0.6.0-rc0"}

filters/ridge_detection/deployment/server.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3605e14d8533e3c57edf30a7da32d4441fcb68228a8ebd028015338b8b5d5f70
-size 4884

filters/ridge_detection/server.onnx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1e05d56c4988abd621aee6dea4efe2dfdaf1d09dfb78bb7bf7b6bb3a00d3e80b
-size 532

filters/rotate/deployment/client.zip

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

filters/rotate/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "rotate", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "rotate"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/rotate/deployment/server.zip

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

filters/sharpen/deployment/client.zip

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

filters/sharpen/deployment/serialized_processing.json

@@ -1 +1 @@
-{"model_filter": "sharpen", "cml_version": "0.6.1"}
+{"model_type": "Filter", "model_post_processing_params": {"filter_name": "sharpen"}, "input_quantizers": [], "output_quantizers": [], "cml_version": "0.6.1"}

filters/sharpen/deployment/server.zip

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

generate_dev_files.py

@@ -3,22 +3,22 @@
 import shutil
 import onnx
 from common import AVAILABLE_FILTERS, FILTERS_PATH
-from custom_client_server import CustomFHEDev
 from filters import Filter
+from concrete.ml.deployment import FHEModelDev
 
 print("Generating deployment files for all available filters")
 
-for image_filter in AVAILABLE_FILTERS:
-    print("Filter:", image_filter, "\n")
+for filter_name in AVAILABLE_FILTERS:
+    print("Filter:", filter_name, "\n")
 
     # Create the filter instance
-    filter = Filter(image_filter)
+    filter = Filter(filter_name)
 
     # Compile the model on a representative inputset
     filter.compile()
 
     # Define the directory path associated to this filter
-    filter_path = FILTERS_PATH / image_filter
+    filter_path = FILTERS_PATH / filter_name
 
     # Define the directory path associated to this filter's deployment files
     deployment_path = filter_path / "deployment"
@@ -28,7 +28,7 @@ for image_filter in AVAILABLE_FILTERS:
         shutil.rmtree(deployment_path)
 
     # Save the files needed for deployment
-    fhe_dev_filter = CustomFHEDev(deployment_path, filter)
+    fhe_dev_filter = FHEModelDev(deployment_path, filter)
     fhe_dev_filter.save()
 
     # Save the ONNX model

server.py

@@ -4,24 +4,24 @@ import time
 from typing import List
 
 from common import FILTERS_PATH, SERVER_TMP_PATH
-from custom_client_server import CustomFHEServer
 from fastapi import FastAPI, File, Form, UploadFile
 from fastapi.responses import JSONResponse, Response
 from pydantic import BaseModel
+from concrete.ml.deployment import FHEModelServer
 
 
-def get_server_file_path(name, user_id, image_filter):
+def get_server_file_path(name, user_id, filter_name):
     """Get the correct temporary file path for the server.
 
     Args:
         name (str): The desired file name.
         user_id (int): The current user's ID.
-        image_filter (str): The filter chosen by the user
+        filter_name (str): The filter chosen by the user
 
     Returns:
         pathlib.Path: The file path.
     """
-    return SERVER_TMP_PATH / f"{name}_{image_filter}_{user_id}"
+    return SERVER_TMP_PATH / f"{name}_{filter_name}_{user_id}"
 
 
 class FilterRequest(BaseModel):
@@ -74,7 +74,7 @@ def run_fhe(
         evaluation_key = evaluation_key_file.read()
 
     # Load the FHE server
-    fhe_server = CustomFHEServer(FILTERS_PATH / f"{filter}/deployment")
+    fhe_server = FHEModelServer(FILTERS_PATH / f"{filter}/deployment")
 
     # Run the FHE execution
     start = time.time()