chore: remove CML client/server API by only using CN

app.py

@@ -19,7 +19,7 @@ from common import (
     REPO_DIR,
     SERVER_URL,
 )
-from custom_client_server import CustomFHEClient
+from client_server_interface import FHEClient
 
 # Uncomment here to have both the server and client in the same terminal
 subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
@@ -33,11 +33,11 @@ def decrypt_output_with_wrong_key(encrypted_image, filter_name):
     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 = FHEClient(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_dequantize(encrypted_image)
+    # Deserialize, decrypt and post-process the encrypted output using the new private key
+    output_image = wrong_client.deserialize_decrypt_post_process(encrypted_image)
 
     return output_image
 
@@ -53,7 +53,7 @@ def shorten_bytes_object(bytes_object, limit=500):
         limit (int): The length to consider. Default to 500.
 
     Returns:
-        Any: The fitted model.
+        str: Hexadecimal string shorten representation of the input byte object. 
 
     """
     # Define a shift for better display
@@ -69,9 +69,9 @@ def get_client(user_id, filter_name):
         filter_name (str): The filter chosen by the user
 
     Returns:
-        CustomFHEClient: The client API.
+        FHEClient: The client API.
     """
-    return CustomFHEClient(
+    return FHEClient(
         FILTERS_PATH / f"{filter_name}/deployment", KEYS_PATH / f"{filter_name}_{user_id}"
     )
 
@@ -184,11 +184,8 @@ def encrypt(user_id, input_image, filter_name):
     # Retrieve the client API
     client = get_client(user_id, filter_name)
 
-    # 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)
+    # Pre-process, encrypt and serialize the image
+    encrypted_image = client.pre_process_encrypt_serialize(input_image)
 
     # Compute the input's size in Megabytes
     encrypted_input_size = len(encrypted_image) / 1000000
@@ -341,7 +338,7 @@ def decrypt_output(user_id, filter_name):
     client = get_client(user_id, filter_name)
 
     # Deserialize, decrypt and post-process the encrypted output
-    output_image = client.deserialize_decrypt_dequantize(encrypted_output_image)
+    output_image = client.deserialize_decrypt_post_process(encrypted_output_image)
 
     return output_image, False, False
 

client_server_interface.py

@@ -0,0 +1,175 @@
+"Client-server interface custom implementation for filter models."
+
+import zipfile
+import json
+from filters import Filter
+
+import concrete.numpy as cnp
+
+class FHEServer:
+    """Server interface run a FHE circuit."""
+
+    def __init__(self, path_dir):
+        """Initialize the FHE interface.
+
+        Args:
+            path_dir (Path): The path to the directory where the circuit is saved.
+        """
+        self.path_dir = path_dir
+
+        # Load the FHE circuit
+        self.server = cnp.Server.load(self.path_dir / "server.zip")
+
+    def run(self, serialized_encrypted_image, serialized_evaluation_keys):
+        """Run the filter on the server over an encrypted image.
+
+        Args:
+            serialized_encrypted_image (bytes): The encrypted and serialized image.
+            serialized_evaluation_keys (bytes): The serialized evaluation keys.
+
+        Returns:
+            bytes: The filter's output.
+        """
+        # Deserialize the encrypted input image and the evaluation keys
+        deserialized_encrypted_image = self.server.client_specs.unserialize_public_args(
+            serialized_encrypted_image
+        )
+        deserialized_evaluation_keys = cnp.EvaluationKeys.unserialize(serialized_evaluation_keys)
+
+        # Execute the filter in FHE
+        result = self.server.run(
+            deserialized_encrypted_image, deserialized_evaluation_keys
+        )
+
+        # Serialize the encrypted output image
+        serialized_result = self.server.client_specs.serialize_public_result(result)
+
+        return serialized_result
+
+
+class FHEDev:
+    """Development interface to save and load the filter."""
+
+    def __init__(self, filter, path_dir):
+        """Initialize the FHE interface.
+
+        Args:
+            path_dir (str): The path to the directory where the circuit is saved.
+            filter (Filter): The filter to use in the FHE interface.
+        """
+
+        self.filter = filter
+        self.path_dir = path_dir
+
+        self.path_dir.mkdir(parents=True, exist_ok=True)
+
+    def save(self):
+        """Export all needed artifacts for the client and server interfaces."""
+        
+        assert self.filter.fhe_circuit is not None, (
+            "The model must be compiled before saving it."
+        )
+
+        # Export to json the parameters needed for loading the filter in the other interfaces
+        serialized_processing = {"filter_name": self.filter.filter_name}
+
+        json_path = self.path_dir / "serialized_processing.json"
+        with open(json_path, "w", encoding="utf-8") as file:
+            json.dump(serialized_processing, file)
+
+        # Save the circuit for the server
+        path_circuit_server = self.path_dir / "server.zip"
+        self.filter.fhe_circuit.server.save(path_circuit_server)
+
+        # Save the circuit for the client
+        path_circuit_client = self.path_dir / "client.zip"
+        self.filter.fhe_circuit.client.save(path_circuit_client)
+
+        with zipfile.ZipFile(path_circuit_client, "a") as zip_file:
+            zip_file.write(filename=json_path, arcname="serialized_processing.json")
+
+
+class FHEClient:
+    """Client interface to encrypt and decrypt FHE data associated to a Filter."""
+
+    def __init__(self, path_dir, key_dir):
+        """Initialize the FHE interface.
+
+        Args:
+            path_dir (Path): the path to the directory where the circuit is saved
+            key_dir (Path): the path to the directory where the keys are stored
+        """
+        self.path_dir = path_dir
+        self.key_dir = key_dir
+
+        # If path_dir does not exist raise
+        assert path_dir.exists(), f"{path_dir} does not exist. Please specify a valid path."
+
+        # Load the client
+        self.client = cnp.Client.load(self.path_dir / "client.zip", self.key_dir)
+
+        # Load the parameters
+        with zipfile.ZipFile(self.path_dir / "client.zip") as client_zip:
+            with client_zip.open("serialized_processing.json", mode="r") as file:
+                serialized_processing = json.load(file)
+
+        # Instantiate the filter
+        filter_name = serialized_processing["filter_name"]
+        self.filter = Filter(filter_name)
+
+    def generate_private_and_evaluation_keys(self, force=False):
+        """Generate the private and evaluation keys.
+
+        Args:
+            force (bool): If True, regenerate the keys even if they already exist.
+        """
+        self.client.keygen(force)
+
+    def get_serialized_evaluation_keys(self):
+        """Get the serialized evaluation keys.
+
+        Returns:
+            bytes: The evaluation keys.
+        """
+        return self.client.evaluation_keys.serialize()
+
+    def pre_process_encrypt_serialize(self, input_image):
+        """Pre-process, encrypt and serialize the input image.
+
+        Args:
+            input_image (numpy.ndarray): The image to pre-process, encrypt and serialize.
+
+        Returns:
+            bytes: The pre-processed, encrypted and serialized image.
+        """
+        # Pre-process the image
+        preprocessed_image = self.filter.pre_processing(input_image)
+
+        # Encrypt the image
+        encrypted_image = self.client.encrypt(preprocessed_image)
+
+        # Serialize the encrypted image to be sent to the server
+        serialized_encrypted_image = self.client.specs.serialize_public_args(encrypted_image)
+        return serialized_encrypted_image
+
+    def deserialize_decrypt_post_process(self, serialized_encrypted_output_image):
+        """Deserialize, decrypt and post-process the output image.
+
+        Args:
+            serialized_encrypted_output_image (bytes): The serialized and encrypted output image.
+
+        Returns:
+            numpy.ndarray: The decrypted, deserialized and post-processed image.
+        """
+        # Deserialize the encrypted image
+        encrypted_output_image = self.client.specs.unserialize_public_result(
+            serialized_encrypted_output_image
+        )
+
+        # Decrypt the image
+        output_image = self.client.decrypt(encrypted_output_image)
+
+        # Post-process the image
+        post_processed_output_image = self.filter.post_processing(output_image)
+
+        return post_processed_output_image

compile.py

@@ -3,9 +3,9 @@
 import json
 import shutil
 import onnx
+
 from common import AVAILABLE_FILTERS, FILTERS_PATH, KEYS_PATH
-from custom_client_server import CustomFHEClient
-from concrete.ml.deployment import FHEModelDev
+from client_server_interface import FHEClient, FHEDev
 
 print("Starting compiling the filters.")
 
@@ -16,13 +16,13 @@ for filter_name in AVAILABLE_FILTERS:
     deployment_path = FILTERS_PATH / f"{filter_name}/deployment"
 
     # Retrieve the client associated to the current filter
-    model = CustomFHEClient(deployment_path, KEYS_PATH).model
+    filter = FHEClient(deployment_path, KEYS_PATH).filter
 
-    # Load the onnx model
-    onnx_model = onnx.load(FILTERS_PATH / f"{filter_name}/server.onnx")
+    # Load the onnx graph
+    onnx_graph = 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)
+    # Compile the filter on a representative inputset, using the loaded onnx graph
+    filter.compile(onnx_graph=onnx_graph)
 
     processing_json_path = deployment_path / "serialized_processing.json"
 
@@ -35,7 +35,7 @@ for filter_name in AVAILABLE_FILTERS:
         shutil.rmtree(deployment_path)
 
     # Save the development files needed for deployment
-    fhe_dev = FHEModelDev(model=model, path_dir=deployment_path)
+    fhe_dev = FHEDev(filter, deployment_path)
     fhe_dev.save()
 
     # Write the serialized_processing.json file in the deployment directory

custom_client_server.py

@@ -1,35 +0,0 @@
-"Client-server interface custom implementation for filter models."
-
-import json
-import concrete.numpy as cnp
-from filters import Filter
-
-from concrete.ml.deployment import FHEModelClient
-from concrete.ml.version import __version__ as CML_VERSION
-
-
-class CustomFHEClient(FHEModelClient):
-    """Client interface to encrypt and decrypt FHE data associated to a Filter."""
-
-    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 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)
-
-        # 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.",
-        )
-
-        # Initialize the filter model using its filter name
-        filter_name = serialized_processing["model_post_processing_params"]["filter_name"]
-        self.model = Filter(filter_name)
-
-        return self.model

filters.py

@@ -2,17 +2,16 @@
 
 import numpy as np
 import torch
-from common import AVAILABLE_FILTERS, INPUT_SHAPE
-from concrete.numpy.compilation.compiler import Compiler
 from torch import nn
+from common import AVAILABLE_FILTERS, INPUT_SHAPE
 
-from concrete.ml.common.debugging.custom_assert import assert_true
+from concrete.numpy.compilation.compiler import Compiler
 from concrete.ml.common.utils import generate_proxy_function
 from concrete.ml.onnx.convert import get_equivalent_numpy_forward
 from concrete.ml.torch.numpy_module import NumpyModule
 
 
-class _TorchIdentity(nn.Module):
+class TorchIdentity(nn.Module):
     """Torch identity model."""
 
     def forward(self, x):
@@ -27,7 +26,7 @@ class _TorchIdentity(nn.Module):
         return x
 
 
-class _TorchInverted(nn.Module):
+class TorchInverted(nn.Module):
     """Torch inverted model."""
 
     def forward(self, x):
@@ -42,7 +41,7 @@ class _TorchInverted(nn.Module):
         return 255 - x
 
 
-class _TorchRotate(nn.Module):
+class TorchRotate(nn.Module):
     """Torch rotated model."""
 
     def forward(self, x):
@@ -57,8 +56,8 @@ class _TorchRotate(nn.Module):
         return x.transpose(2, 3)
 
 
-class _TorchConv2D(nn.Module):
-    """Torch model for applying a single 2D convolution operator on images."""
+class TorchConv(nn.Module):
+    """Torch model for applying convolution operators on images."""
 
     def __init__(self, kernel, n_in_channels=3, n_out_channels=3, groups=1, threshold=None):
         """Initialize the filter.
@@ -74,7 +73,7 @@ class _TorchConv2D(nn.Module):
         self.threshold = threshold
 
     def forward(self, x):
-        """Forward pass for filtering the image using a 2D kernel.
+        """Forward pass for filtering the image using a 1D or 2D kernel.
 
         Args:
             x (torch.Tensor): The input image.
@@ -133,20 +132,13 @@ class Filter:
             filter_name (str): The filter to consider.
         """
 
-        assert_true(
-            filter_name in AVAILABLE_FILTERS,
+        assert filter_name in AVAILABLE_FILTERS, (
             f"Unsupported image filter or transformation. Expected one of {*AVAILABLE_FILTERS,}, "
             f"but got {filter_name}",
         )
 
-        # 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.filter_name = filter_name
         self.onnx_model = None
         self.fhe_circuit = None
         self.divide = None
@@ -154,13 +146,13 @@ class Filter:
 
         # Instantiate the torch module associated to the given filter name 
         if filter_name == "identity":
-            self.torch_model = _TorchIdentity()
+            self.torch_model = TorchIdentity()
 
         elif filter_name == "inverted":
-            self.torch_model = _TorchInverted()
+            self.torch_model = TorchInverted()
 
         elif filter_name == "rotate":
-            self.torch_model = _TorchRotate()
+            self.torch_model = TorchRotate()
 
         elif filter_name == "black and white":
             # Define the grayscale weights (RGB order)
@@ -173,7 +165,7 @@ class Filter:
             # post-processing in order to retrieve the correct result
             kernel = [299, 587, 114]
 
-            self.torch_model = _TorchConv2D(kernel, n_out_channels=1, groups=1)
+            self.torch_model = TorchConv(kernel, n_out_channels=1, groups=1)
 
             # Define the value used when for dividing the output values in post-processing
             self.divide = 1000
@@ -185,7 +177,7 @@ class Filter:
         elif filter_name == "blur":
             kernel = np.ones((3, 3))
 
-            self.torch_model = _TorchConv2D(kernel, n_out_channels=3, groups=3)
+            self.torch_model = TorchConv(kernel, n_out_channels=3, groups=3)
 
             # Define the value used when for dividing the output values in post-processing
             self.divide = 9
@@ -197,7 +189,7 @@ class Filter:
                 [0, -1, 0],
             ]
 
-            self.torch_model = _TorchConv2D(kernel, n_out_channels=3, groups=3)
+            self.torch_model = TorchConv(kernel, n_out_channels=3, groups=3)
 
         elif filter_name == "ridge detection":
             kernel = [
@@ -208,18 +200,18 @@ class Filter:
 
             # 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)
+            self.torch_model = TorchConv(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
 
-    def compile(self, onnx_model=None):
+    def compile(self, onnx_graph=None):
         """Compile the model on a representative inputset.
 
         Args:
-            onnx_model (onnx.ModelProto): The loaded onnx model to consider. If None, it will be
+            onnx_graph (onnx.ModelProto): The loaded onnx model to consider. If None, it will be
                 generated automatically using a NumpyModule. Default to None.
         """
         # Generate a random representative set of images used for compilation, following Torch's 
@@ -232,17 +224,17 @@ class Filter:
         )
 
         # If no onnx model was given, generate a new one.
-        if onnx_model is None:
+        if onnx_graph is None:
             numpy_module = NumpyModule(
                 self.torch_model,
                 dummy_input=torch.from_numpy(inputset[0]),
             )
 
-            onnx_model = numpy_module.onnx_model
+            onnx_graph = numpy_module.onnx_model
 
         # Get the proxy function and parameter mappings for initializing the compiler
-        self.onnx_model = onnx_model
-        numpy_filter = get_equivalent_numpy_forward(onnx_model)
+        self.onnx_graph = onnx_graph
+        numpy_filter = get_equivalent_numpy_forward(onnx_graph)
 
         numpy_filter_proxy, parameters_mapping = generate_proxy_function(numpy_filter, ["inputs"])
 
@@ -256,20 +248,6 @@ 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.
 

filters/black and white/deployment/client.zip

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

filters/black and white/deployment/serialized_processing.json

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

filters/black and white/deployment/server.zip

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

filters/blur/deployment/client.zip

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

filters/blur/deployment/serialized_processing.json

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

filters/blur/deployment/server.zip

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

filters/identity/deployment/client.zip

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

filters/identity/deployment/serialized_processing.json

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

filters/identity/deployment/server.zip

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

filters/inverted/deployment/client.zip

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

filters/inverted/deployment/serialized_processing.json

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

filters/inverted/deployment/server.zip

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

filters/ridge detection/deployment/client.zip

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

filters/ridge detection/deployment/serialized_processing.json

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

filters/ridge detection/deployment/server.zip

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

filters/rotate/deployment/client.zip

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

filters/rotate/deployment/serialized_processing.json

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

filters/rotate/deployment/server.zip

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

filters/sharpen/deployment/client.zip

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

filters/sharpen/deployment/serialized_processing.json

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

filters/sharpen/deployment/server.zip

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

generate_dev_files.py

@@ -4,7 +4,7 @@ import shutil
 import onnx
 from common import AVAILABLE_FILTERS, FILTERS_PATH
 from filters import Filter
-from concrete.ml.deployment import FHEModelDev
+from client_server_interface import FHEDev
 
 print("Generating deployment files for all available filters")
 
@@ -28,10 +28,10 @@ for filter_name in AVAILABLE_FILTERS:
         shutil.rmtree(deployment_path)
 
     # Save the files needed for deployment
-    fhe_dev_filter = FHEModelDev(deployment_path, filter)
+    fhe_dev_filter = FHEDev(filter, deployment_path)
     fhe_dev_filter.save()
 
     # Save the ONNX model
-    onnx.save(filter.onnx_model, filter_path / "server.onnx")
+    onnx.save(filter.onnx_graph, filter_path / "server.onnx")
 
 print("Done !")

server.py

@@ -2,12 +2,11 @@
 
 import time
 from typing import List
-
-from common import FILTERS_PATH, SERVER_TMP_PATH
 from fastapi import FastAPI, File, Form, UploadFile
 from fastapi.responses import JSONResponse, Response
-from pydantic import BaseModel
-from concrete.ml.deployment import FHEModelServer
+
+from common import FILTERS_PATH, SERVER_TMP_PATH
+from client_server_interface import FHEServer
 
 
 def get_server_file_path(name, user_id, filter_name):
@@ -24,10 +23,6 @@ def get_server_file_path(name, user_id, filter_name):
     return SERVER_TMP_PATH / f"{name}_{filter_name}_{user_id}"
 
 
-class FilterRequest(BaseModel):
-    filter: str
-
-
 # Initialize an instance of FastAPI
 app = FastAPI()
 
@@ -74,7 +69,7 @@ def run_fhe(
         evaluation_key = evaluation_key_file.read()
 
     # Load the FHE server
-    fhe_server = FHEModelServer(FILTERS_PATH / f"{filter}/deployment")
+    fhe_server = FHEServer(FILTERS_PATH / f"{filter}/deployment")
 
     # Run the FHE execution
     start = time.time()