Adding deployment files and updating app

.gitignore

@@ -2,4 +2,19 @@
 .venv
 
 # Python cache
-__pycache__
+__pycache__
+
+# VS Code
+.vscode
+
+# Cocnrete Python artifacts
+.artifacts
+
+# Client-server related files
+.fhe_keys
+client_files
+server_files
+
+# Experiments
+experiments
+mlir

app.py

@@ -15,9 +15,13 @@ from settings import (
     FHE_KEYS,
     CLIENT_FILES,
     SERVER_FILES,
+    DEPLOYMENT_PATH,
+    INITIAL_INPUT_SHAPE,
+    INPUT_INDEXES,
+    START_POSITIONS,
 )
 
-# from concrete.ml.deployment.fhe_client_server import FHEModelClient
+from development.client_server_interface import MultiInputsFHEModelClient
 
 
 subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
@@ -43,38 +47,33 @@ def shorten_bytes_object(bytes_object, limit=500):
     return bytes_object[shift : limit + shift].hex()
 
 
-def get_client(user_id, filter_name):
+def get_client(client_id, client_type):
     """Get the client API.
 
     Args:
-        user_id (int): The current user's ID.
-        filter_name (str): The filter chosen by the user
+        client_id (int): The client ID to consider.
+        client_type (str): The type of user to consider (either 'user', 'bank' or 'third_party').
 
     Returns:
         FHEModelClient: The client API.
     """
-    # TODO
-    # return FHEModelClient(
-    #     FILTERS_PATH / f"{filter_name}/deployment", 
-    #     filter_name,
-    #     key_dir=FHE_KEYS / f"{filter_name}_{user_id}", 
-    # )
+    key_dir = FHE_KEYS / f"{client_type}_{client_id}"
 
-    return None
+    return MultiInputsFHEModelClient(DEPLOYMENT_PATH, key_dir=key_dir)
 
 
-def get_client_file_path(name, user_id, filter_name):
+def get_client_file_path(name, client_id, client_type):
     """Get the correct temporary file path for the client.
 
     Args:
-        name (str): The desired file name.
-        user_id (int): The current user's ID.
-        filter_name (str): The filter chosen by the user
+        name (str): The desired file name (either 'evaluation_key' or 'encrypted_inputs').
+        client_id (int): The client ID to consider.
+        client_type (str): The type of user to consider (either 'user', 'bank' or 'third_party').
 
     Returns:
         pathlib.Path: The file path.
     """
-    return CLIENT_FILES / f"{name}_{filter_name}_{user_id}"
+    return CLIENT_FILES / f"{name}_{client_type}_{client_id}"
 
 
 def clean_temporary_files(n_keys=20):
@@ -109,24 +108,18 @@ def clean_temporary_files(n_keys=20):
                 file.unlink()
 
 
-def keygen(filter_name):
+def keygen(client_id, client_type):
     """Generate the private key associated to a filter.
 
     Args:
-        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.
-
+        client_id (int): The client ID to consider.
+        client_type (str): The type of client to consider (either 'user', 'bank' or 'third_party').
     """
     # Clean temporary files
     clean_temporary_files()
 
-    # Create an ID for the current user
-    user_id = numpy.random.randint(0, 2**32)
-
-    # Retrieve the client API
-    client = get_client(user_id, filter_name)
+    # Retrieve the client instance
+    client = get_client(client_id, client_type)
 
     # Generate a private key
     client.generate_private_and_evaluation_keys(force=True)
@@ -138,78 +131,27 @@ def keygen(filter_name):
 
     # 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, filter_name)
+    evaluation_key_path = get_client_file_path("evaluation_key", client_id, client_type)
 
     with evaluation_key_path.open("wb") as evaluation_key_file:
         evaluation_key_file.write(evaluation_key)
 
-    return (user_id, True)
-
-
-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.
-        filter_name (str): The current filter to consider.
-
-    Returns:
-        (input_image, encrypted_image_short) (Tuple[bytes]): The encrypted image and one of its
-        representation.
-
-    """
-    user_id = keygen
-
-    if user_id == "":
-        raise gr.Error("Please generate the private key first.")
-
-    if input_image is None:
-        raise gr.Error("Please choose an image first.")
 
-    # Retrieve the client API
-    client = get_client(user_id, filter_name)
-
-    # Pre-process, encrypt and serialize the image
-    encrypted_image = client.encrypt_serialize(input_image)
-
-    # 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, filter_name)
-
-    with encrypted_image_path.open("wb") as encrypted_image_file:
-        encrypted_image_file.write(encrypted_image)
-
-    # Create a truncated version of the encrypted image for display
-    encrypted_image_short = shorten_bytes_object(encrypted_image)
-
-    send_input()
-
-    return (input_image, encrypted_image_short)
-
-
-def send_input(user_id, filter_name):
+def send_input(client_id, client_type):
     """Send the encrypted input image as well as the evaluation key to the server.
 
     Args:
-        user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        client_id (int): The client ID to consider.
+        client_type (str): The type of client to consider (either 'user', 'bank' or 'third_party').
     """
-    # Get the evaluation key path
-    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, filter_name)
-
-    if not encrypted_input_path.is_file():
-        raise gr.Error("Please generate the private key and then encrypt an image first.")
+    # Get the paths to the evaluation key and encrypted inputs
+    evaluation_key_path = get_client_file_path("evaluation_key", client_id, client_type)
+    encrypted_input_path = get_client_file_path("encrypted_inputs", client_id, client_type)
 
     # Define the data and files to post
     data = {
-        "user_id": user_id,
-        "filter": filter_name,
+        "client_id": client_id,
+        "client_type": client_type,
     }
 
     files = [
@@ -227,19 +169,64 @@ def send_input(user_id, filter_name):
         return response.ok
 
 
-def run_fhe(user_id, filter_name):
-    """Apply the filter on the encrypted image previously sent using FHE.
+def keygen_encrypt_send(inputs, client_type):
+    """Encrypt the given inputs for a specific client.
 
     Args:
-        user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        inputs (numpy.ndarray): The inputs to encrypt.
+        client_type (str): The type of client to consider (either 'user', 'bank' or 'third_party').
+    
+    Returns:
+
     """
+    # Create an ID for the current client to consider
+    client_id = numpy.random.randint(0, 2**32)
+
+    keygen(client_id, client_type)
+
+    # Retrieve the client instance
+    client = get_client(client_id, client_type)
+
+    # TODO : pre-process the data first 
+
+    # Quantize, encrypt and serialize the inputs
+    encrypted_inputs = client.quantize_encrypt_serialize_multi_inputs(
+        inputs, 
+        input_index=INPUT_INDEXES[client_type], 
+        initial_input_shape=INITIAL_INPUT_SHAPE, 
+        start_position=START_POSITIONS[client_type],
+    )
+
+    # Save encrypted_inputs to bytes in a file, since too large to pass through regular Gradio
+    # buttons, https://github.com/gradio-app/gradio/issues/1877
+    encrypted_inputs_path = get_client_file_path("encrypted_inputs", client_id, client_type)
+
+    with encrypted_inputs_path.open("wb") as encrypted_inputs_file:
+        encrypted_inputs_file.write(encrypted_inputs)
+
+    # Create a truncated version of the encrypted image for display
+    encrypted_inputs_short = shorten_bytes_object(encrypted_inputs)
+
+    send_input(client_id, client_type)
+
+    # TODO: also return private key representation if possible
+    return encrypted_inputs_short
+
+
+def run_fhe(client_id):
+    """Run the model on the encrypted inputs previously sent using FHE.
+
+    Args:
+        client_id (int): The client ID to consider.
+    """
+
+    # TODO : add a warning for users to send all client types' inputs 
+
     data = {
-        "user_id": user_id,
-        "filter": filter_name,
+        "client_id": client_id,
     }
 
-    # Trigger the FHE execution on the encrypted image previously sent
+    # Trigger the FHE execution on the encrypted inputs previously sent
     url = SERVER_URL + "run_fhe"
     with requests.post(
         url=url,
@@ -248,23 +235,21 @@ def run_fhe(user_id, filter_name):
         if response.ok:
             return response.json()
         else:
-            raise gr.Error("Please wait for the input image to be sent to the server.")
+            raise gr.Error("Please wait for the inputs to be sent to the server.")
 
 
-def get_output(user_id, filter_name):
-    """Retrieve the encrypted output image.
+def get_output(client_id):
+    """Retrieve the encrypted output.
 
     Args:
-        user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        client_id (int): The client ID to consider.
 
     Returns:
-        encrypted_output_image_short (bytes): A representation of the encrypted result.
+        output_encrypted_representation (numpy.ndarray): A representation of the encrypted output.
 
     """
     data = {
-        "user_id": user_id,
-        "filter": filter_name,
+        "client_id": client_id,
     }
 
     # Retrieve the encrypted output image
@@ -278,54 +263,54 @@ def get_output(user_id, filter_name):
 
             # 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, filter_name)
+            # TODO : check if output to user is relevant
+            encrypted_output_path = get_client_file_path("encrypted_output", client_id, "user")
 
             with encrypted_output_path.open("wb") as encrypted_output_file:
                 encrypted_output_file.write(encrypted_output)
             
             # TODO 
-            # Decrypt the image using a different (wrong) key for display
-            # output_image_representation = decrypt_output_with_wrong_key(encrypted_output, filter_name)
+            # Decrypt the output using a different (wrong) key for display
+            # output_encrypted_representation = decrypt_output_with_wrong_key(encrypted_output, client_type)
 
-            # return output_image_representation
+            # return output_encrypted_representation
 
             return None
         else:
             raise gr.Error("Please wait for the FHE execution to be completed.")
 
 
-def decrypt_output(user_id, filter_name):
+def decrypt_output(client_id, client_type):
     """Decrypt the result.
 
     Args:
-        user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        client_id (int): The client ID to consider.
+        client_type (str): The type of client to consider (either 'user', 'bank' or 'third_party').
 
     Returns:
-        (output_image, False, False) ((Tuple[numpy.ndarray, bool, bool]): The decrypted output, as
-            well as two booleans used for resetting Gradio checkboxes
+        output(numpy.ndarray): The decrypted output
 
     """
-    if user_id == "":
-        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, filter_name)
+    encrypted_output_path = get_client_file_path("encrypted_output", client_id, client_type)
 
     if not encrypted_output_path.is_file():
         raise gr.Error("Please run the FHE execution first.")
 
     # Load the encrypted output as bytes
     with encrypted_output_path.open("rb") as encrypted_output_file:
-        encrypted_output_image = encrypted_output_file.read()
+        encrypted_output_proba = encrypted_output_file.read()
 
     # Retrieve the client API
-    client = get_client(user_id, filter_name)
+    client = get_client(client_id, client_type)
 
     # Deserialize, decrypt and post-process the encrypted output
-    output_image = client.deserialize_decrypt_post_process(encrypted_output_image)
+    output_proba = client.deserialize_decrypt_post_process(encrypted_output_proba)
 
-    return output_image, False, False
+    # Determine the predicted class
+    output = numpy.argmax(output_proba, axis=1)
+
+    return output
 
 
 demo = gr.Blocks()
@@ -344,7 +329,7 @@ with demo:
     gr.Markdown("### Step 1: Infos. ")
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### Client ")
+            gr.Markdown("### User")
             # TODO : change infos
             choice_1 = gr.Dropdown(choices=["Yes, No"], label="Choose", interactive=True)
             slide_1 = gr.Slider(2, 20, value=4, label="Count", info="Choose between 2 and 20")
@@ -363,25 +348,25 @@ with demo:
     gr.Markdown("### Step 2: Keygen, encrypt  using FHE and send the inputs to the server.")
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### Client ")
-            encrypt_button_1 = gr.Button("Encrypt the inputs and send to server.")
-            keys_1 = gr.Textbox(
+            gr.Markdown("### User")
+            encrypt_button_user = gr.Button("Encrypt the inputs and send to server.")
+            keys_user = gr.Textbox(
                 label="Keys representation:", max_lines=2, interactive=False
             )
-            encrypted_input_1 = gr.Textbox(
+            encrypted_input_user = gr.Textbox(
                 label="Encrypted input representation:", max_lines=2, interactive=False
             )
 
-            client_id = gr.Textbox(label="", max_lines=2, interactive=False, visible=False)
+            user_id = gr.Textbox(label="", max_lines=2, interactive=False, visible=False)
 
 
         with gr.Column():
             gr.Markdown("### Bank ")
-            encrypt_button_2 = gr.Button("Encrypt the inputs and send to server.")
-            keys_2 = gr.Textbox(
+            encrypt_button_bank = gr.Button("Encrypt the inputs and send to server.")
+            keys_bank = gr.Textbox(
                 label="Keys representation:", max_lines=2, interactive=False
             )
-            encrypted_input_2 = gr.Textbox(
+            encrypted_input_bank = gr.Textbox(
                 label="Encrypted input representation:", max_lines=2, interactive=False
             )
 
@@ -390,15 +375,15 @@ with demo:
 
         with gr.Column():
             gr.Markdown("### Third Party ")
-            encrypt_button_3 = gr.Button("Encrypt the inputs and send to server.")
+            encrypt_button_third_party = gr.Button("Encrypt the inputs and send to server.")
             keys_3 = gr.Textbox(
                 label="Keys representation:", max_lines=2, interactive=False
             )
-            encrypted_input_3 = gr.Textbox(
+            encrypted_input__third_party = gr.Textbox(
                 label="Encrypted input representation:", max_lines=2, interactive=False
             )
 
-            party_id = gr.Textbox(label="", max_lines=2, interactive=False, visible=False)
+            third_party_id = gr.Textbox(label="", max_lines=2, interactive=False, visible=False)
 
     gr.Markdown("## Server side")
     gr.Markdown(
@@ -428,7 +413,7 @@ with demo:
     get_output_button = gr.Button("Receive the encrypted output from the server.")
 
     encrypted_output_representation = gr.Textbox(
-        label="Credit card approval decision: ", max_lines=1, interactive=False
+        label="Encrypted output representation: ", max_lines=1, interactive=False
     )
 
     gr.Markdown("### Step 8: Decrypt the output.")
@@ -438,15 +423,22 @@ with demo:
         label="Credit card approval decision: ", max_lines=1, interactive=False
     )
 
-    # # Button to generate the private key
-    # keygen_button.click(
-    #     keygen,
-    #     inputs=[filter_name],
-    #     outputs=[user_id, keygen_checkbox],
+    # Button to encrypt inputs on the client side
+    # encrypt_button_user.click(
+    #     encrypt,
+    #     inputs=[user_id, input_image, filter_name],
+    #     outputs=[original_image, encrypted_input],
+    # )
+
+    # # Button to encrypt inputs on the client side
+    # encrypt_button_bank.click(
+    #     encrypt,
+    #     inputs=[user_id, input_image, filter_name],
+    #     outputs=[original_image, encrypted_input],
     # )
 
     # # Button to encrypt inputs on the client side
-    # encrypt_button.click(
+    # encrypt_button_third_party.click(
     #     encrypt,
     #     inputs=[user_id, input_image, filter_name],
     #     outputs=[original_image, encrypted_input],

deployment_files/client.zip

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

deployment_files/server.zip

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

deployment_files/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.11"}

development/client_server_interface.py

@@ -0,0 +1,77 @@
+import numpy
+import copy
+
+from concrete.fhe import Value, EvaluationKeys
+
+from concrete.ml.deployment.fhe_client_server import FHEModelClient, FHEModelDev, FHEModelServer
+from concrete.ml.sklearn import XGBClassifier as ConcreteXGBClassifier
+
+
+class MultiInputsFHEModelDev(FHEModelDev):
+
+    def __init__(self, *arg, **kwargs):
+
+        super().__init__(*arg, **kwargs)
+        
+        model = copy.copy(self.model)
+        model.__class__ = ConcreteXGBClassifier
+        self.model = model
+
+
+class MultiInputsFHEModelClient(FHEModelClient):
+
+    def __init__(self, *args, nb_inputs=1, **kwargs):
+        self.nb_inputs = nb_inputs
+
+        super().__init__(*args, **kwargs)
+    
+    def quantize_encrypt_serialize_multi_inputs(self, x: numpy.ndarray, input_index, initial_input_shape, start_position) -> bytes:
+
+        x_padded = numpy.zeros(initial_input_shape)
+
+        end = start_position + x.shape[1]
+        x_padded[:, start_position:end] = x
+
+        q_x_padded = self.model.quantize_input(x_padded)
+
+        q_x = q_x_padded[:, start_position:end]
+        
+        q_x_padded = [None for _ in range(self.nb_inputs)]
+        q_x_padded[input_index] = q_x
+
+        # Encrypt the values
+        q_x_enc = self.client.encrypt(*q_x_padded)
+
+        # Serialize the encrypted values to be sent to the server
+        q_x_enc_ser = q_x_enc[input_index].serialize()
+        return q_x_enc_ser
+    
+
+class MultiInputsFHEModelServer(FHEModelServer):
+
+    def run(
+        self,
+        *serialized_encrypted_quantized_data: bytes,
+        serialized_evaluation_keys: bytes,
+    ) -> bytes:
+        """Run the model on the server over encrypted data.
+
+        Args:
+            serialized_encrypted_quantized_data (bytes): the encrypted, quantized
+                and serialized data
+            serialized_evaluation_keys (bytes): the serialized evaluation keys
+
+        Returns:
+            bytes: the result of the model
+        """
+        assert self.server is not None, "Model has not been loaded."
+
+        deserialized_encrypted_quantized_data = tuple(Value.deserialize(data) for data in serialized_encrypted_quantized_data)
+
+        deserialized_evaluation_keys = EvaluationKeys.deserialize(serialized_evaluation_keys)
+
+        result = self.server.run(
+            *deserialized_encrypted_quantized_data, evaluation_keys=deserialized_evaluation_keys
+        )
+        serialized_result = result.serialize()
+        return serialized_result

development/development.py

@@ -0,0 +1,67 @@
+"A script to generate all development files necessary for the project."
+
+import shutil
+import numpy
+import pandas
+
+from sklearn.model_selection import train_test_split
+from imblearn.over_sampling import SMOTE
+
+from ..settings import DEPLOYMENT_PATH, RANDOM_STATE
+from client_server_interface import MultiInputsFHEModelDev
+from model import MultiInputXGBClassifier
+from development.pre_processing import pre_process_data
+
+
+print("Load and pre-process the data")
+
+data = pandas.read_csv("data/clean_data.csv", encoding="utf-8")
+
+# Make median annual salary similar to France (2023): from 157500 to 22050
+data["Total_income"] = data["Total_income"] * 0.14
+
+# Remove ID feature
+data.drop("ID", axis=1, inplace=True)
+
+# Feature engineer the data
+pre_processed_data, training_bins = pre_process_data(data)
+
+# Define input and target data
+y = pre_processed_data.pop("Target")
+x = pre_processed_data
+
+# The initial data-set is very imbalanced: use SMOTE to get better results
+x, y = SMOTE().fit_resample(x, y)
+
+# Retrieve the training data
+X_train, _, y_train, _ = train_test_split(
+    x, y, stratify=y, test_size=0.3, random_state=RANDOM_STATE
+)
+
+# Convert the Pandas data frames into Numpy arrays
+X_train_np = X_train.to_numpy()
+y_train_np = y_train.to_numpy()
+
+
+print("Train and compile the model")
+
+model = MultiInputXGBClassifier(max_depth=3, n_estimators=40)
+
+model.fit(X_train_np, y_train_np)
+ 
+multi_inputs_train = numpy.array_split(X_train_np, 3, axis=1)
+
+model.compile(*multi_inputs_train, inputs_encryption_status=["encrypted", "encrypted", "encrypted"])
+
+# Delete the deployment folder and its content if it already exists
+if DEPLOYMENT_PATH.is_dir():
+    shutil.rmtree(DEPLOYMENT_PATH)
+
+
+print("Save deployment files")
+
+# Save the files needed for deployment
+fhe_dev = MultiInputsFHEModelDev(model, DEPLOYMENT_PATH)
+fhe_dev.save()
+
+print("Done !")

development/model.py

@@ -0,0 +1,130 @@
+import numpy
+from typing import Optional, Sequence, Union
+
+from concrete.fhe.compilation.compiler import Compiler, Configuration, DebugArtifacts, Circuit
+
+from concrete.ml.common.check_inputs import check_array_and_assert
+from concrete.ml.common.utils import (
+    generate_proxy_function, 
+    manage_parameters_for_pbs_errors, 
+    check_there_is_no_p_error_options_in_configuration
+)
+from concrete.ml.quantization.quantized_module import QuantizedModule, _get_inputset_generator
+from concrete.ml.sklearn import XGBClassifier as ConcreteXGBClassifier
+
+
+class MultiInputXGBClassifier(ConcreteXGBClassifier):
+
+    def quantize_input(self, *X: numpy.ndarray) -> numpy.ndarray:
+        self.check_model_is_fitted()
+        assert sum(input.shape[1] for input in X) == len(self.input_quantizers)
+
+        base_j = 0
+        q_inputs = []
+        for i, input in enumerate(X):
+            q_input = numpy.zeros_like(input, dtype=numpy.int64)
+
+            for j in range(input.shape[1]):
+                quantizer_index = base_j + j
+                q_input[:, j] = self.input_quantizers[quantizer_index].quant(input[:, j])
+
+            assert q_input.dtype == numpy.int64, f"Inputs {i} were not quantized to int64 values"
+
+            q_inputs.append(q_input)
+            base_j += input.shape[1]
+
+        return tuple(q_inputs) if len(q_inputs) > 1 else q_inputs[0]
+
+    def compile(
+        self,
+        *inputs,
+        configuration: Optional[Configuration] = None,
+        artifacts: Optional[DebugArtifacts] = None,
+        show_mlir: bool = False,
+        p_error: Optional[float] = None,
+        global_p_error: Optional[float] = None,
+        verbose: bool = False,
+        inputs_encryption_status: Optional[Sequence[str]] = None,
+    ) -> Circuit:
+
+        # Check that the model is correctly fitted
+        self.check_model_is_fitted()
+
+        # Cast pandas, list or torch to numpy
+        inputs_as_array = []
+        for input in inputs:
+            input_as_array = check_array_and_assert(input)
+            inputs_as_array.append(input_as_array)
+
+        inputs_as_array = tuple(inputs_as_array)
+
+        # p_error or global_p_error should not be set in both the configuration and direct arguments
+        check_there_is_no_p_error_options_in_configuration(configuration)
+
+        # Find the right way to set parameters for compiler, depending on the way we want to default
+        p_error, global_p_error = manage_parameters_for_pbs_errors(p_error, global_p_error)
+
+        # Quantize the inputs
+        quantized_inputs = self.quantize_input(*inputs_as_array)
+
+        # Generate the compilation input-set with proper dimensions
+        inputset = _get_inputset_generator(quantized_inputs)
+
+        # Reset for double compile
+        self._is_compiled = False
+
+        # Retrieve the compiler instance
+        module_to_compile = self._get_module_to_compile(inputs_encryption_status)
+
+        # Compiling using a QuantizedModule requires different steps and should not be done here
+        assert isinstance(module_to_compile, Compiler), (
+            "Wrong module to compile. Expected to be of type `Compiler` but got "
+            f"{type(module_to_compile)}."
+        )
+
+        # Jit compiler is now deprecated and will soon be removed, it is thus forced to False
+        # by default
+        self.fhe_circuit_ = module_to_compile.compile(
+            inputset,
+            configuration=configuration,
+            artifacts=artifacts,
+            show_mlir=show_mlir,
+            p_error=p_error,
+            global_p_error=global_p_error,
+            verbose=verbose,
+            single_precision=False,
+            fhe_simulation=False,
+            fhe_execution=True,
+            jit=False,
+        )
+
+        self._is_compiled = True
+
+        # For mypy
+        assert isinstance(self.fhe_circuit, Circuit)
+
+        return self.fhe_circuit
+
+    def _get_module_to_compile(self, inputs_encryption_status) -> Union[Compiler, QuantizedModule]:
+        assert self._tree_inference is not None, self._is_not_fitted_error_message()
+
+        if not self._is_compiled:
+            xgb_inference = self._tree_inference
+            self._tree_inference = lambda *args: xgb_inference(numpy.concatenate(args, axis=1))
+
+        input_names = [f"input_{i}_encrypted" for i in range(len(inputs_encryption_status))]
+
+        # Generate the proxy function to compile
+        _tree_inference_proxy, function_arg_names = generate_proxy_function(
+            self._tree_inference, input_names
+        )
+
+        inputs_encryption_statuses = {input_name: status for input_name, status in zip(function_arg_names.values(), inputs_encryption_status)}
+
+        # Create the compiler instance
+        compiler = Compiler(
+            _tree_inference_proxy,
+            inputs_encryption_statuses,
+        )
+
+        return compiler

development/pre_processing.py

@@ -0,0 +1,122 @@
+import pandas
+from copy import deepcopy
+
+
+def convert_dummy(df, feature):
+    pos = pandas.get_dummies(df[feature], prefix=feature)
+
+    df.drop([feature], axis=1, inplace=True)
+    df = df.join(pos)
+    return df
+
+
+def get_category(df, col, labels, qcut=False, binsnum=None, bins=None, retbins=False):
+    assert binsnum is not None or bins is not None
+
+    if qcut and binsnum is not None: 
+        localdf, bin_edges = pandas.qcut(df[col], q=binsnum, labels=labels, retbins=True)  # quantile cut
+    else:
+        input_bins = bins if bins is not None else binsnum
+        localdf, bin_edges = pandas.cut(df[col], bins=input_bins, labels=labels, retbins=True)  # equal-length cut
+
+    df.drop(col, axis=1, inplace=True)
+
+    localdf = pandas.DataFrame(localdf)
+    df = df.join(localdf[col])
+
+    if retbins:
+        return df, bin_edges
+
+    return df
+
+
+def pre_process_data(input_data, bins=None, columns=None):
+    assert bins is None or ("bin_edges_income" in bins and "bin_edges_age" in bins and "bin_edges_years_employed" in bins and columns is not None)
+
+    training_bins = {}
+
+    input_data = deepcopy(input_data)
+    bins = deepcopy(bins) if bins is not None else None
+
+    input_data.loc[input_data["Num_children"] >= 2, "Num_children"] = "2_or_more"
+
+    input_data = convert_dummy(input_data, "Num_children")
+
+    if bins is None:
+        input_data, bin_edges_income = get_category(input_data, "Total_income", ["low", "medium", "high"], qcut=True, binsnum=3, retbins=True)
+        training_bins["bin_edges_income"] = bin_edges_income
+    else:
+        input_data = get_category(input_data, "Total_income", ["low", "medium", "high"], bins=bins["bin_edges_income"])
+
+    input_data = convert_dummy(input_data, "Total_income")
+
+    if bins is None:
+        input_data, bin_edges_age = get_category(input_data, "Age", ["lowest", "low", "medium", "high", "highest"], binsnum=5, retbins=True)
+        training_bins["bin_edges_age"] = bin_edges_age
+    else:
+        input_data = get_category(input_data, "Age", ["lowest", "low", "medium", "high", "highest"], bins=bins["bin_edges_age"])
+
+    input_data = convert_dummy(input_data, "Age")
+
+    if bins is None:
+        input_data, bin_edges_years_employed = get_category(input_data, "Years_employed", ["lowest", "low", "medium", "high", "highest"], binsnum=5, retbins=True)
+        training_bins["bin_edges_years_employed"] = bin_edges_years_employed
+    else:
+        input_data = get_category(input_data, "Years_employed", ["lowest", "low", "medium", "high", "highest"], bins=bins["bin_edges_years_employed"])
+
+    input_data = convert_dummy(input_data, "Years_employed")
+
+    input_data.loc[input_data["Num_family"] >= 3, "Num_family"] = "3_or_more"
+
+    input_data = convert_dummy(input_data, "Num_family")
+
+    input_data.loc[input_data["Income_type"] == "Pensioner", "Income_type"] = "State servant"
+    input_data.loc[input_data["Income_type"] == "Student", "Income_type"] = "State servant"
+
+    input_data = convert_dummy(input_data, "Income_type")
+
+    input_data.loc[
+        (input_data["Occupation_type"] == "Cleaning staff")
+        | (input_data["Occupation_type"] == "Cooking staff")
+        | (input_data["Occupation_type"] == "Drivers")
+        | (input_data["Occupation_type"] == "Laborers")
+        | (input_data["Occupation_type"] == "Low-skill Laborers")
+        | (input_data["Occupation_type"] == "Security staff")
+        | (input_data["Occupation_type"] == "Waiters/barmen staff"),
+        "Occupation_type",
+    ] = "Labor_work"
+    input_data.loc[
+        (input_data["Occupation_type"] == "Accountants")
+        | (input_data["Occupation_type"] == "Core staff")
+        | (input_data["Occupation_type"] == "HR staff")
+        | (input_data["Occupation_type"] == "Medicine staff")
+        | (input_data["Occupation_type"] == "Private service staff")
+        | (input_data["Occupation_type"] == "Realty agents")
+        | (input_data["Occupation_type"] == "Sales staff")
+        | (input_data["Occupation_type"] == "Secretaries"),
+        "Occupation_type",
+    ] = "Office_work"
+    input_data.loc[
+        (input_data["Occupation_type"] == "Managers")
+        | (input_data["Occupation_type"] == "High skill tech staff")
+        | (input_data["Occupation_type"] == "IT staff"),
+        "Occupation_type",
+    ] = "High_tech_work"
+
+    input_data = convert_dummy(input_data, "Occupation_type")
+
+    input_data = convert_dummy(input_data, "Housing_type")
+
+    input_data.loc[input_data["Education_type"] == "Academic degree", "Education_type"] = "Higher education"
+    input_data = convert_dummy(input_data, "Education_type")
+
+    input_data = convert_dummy(input_data, "Family_status")
+
+    input_data = input_data.astype("int")
+    
+    if training_bins:
+        return input_data, training_bins
+    
+    input_data = input_data.reindex(columns=columns, fill_value=0)
+
+    return input_data

requirements.txt

@@ -1,2 +1,4 @@
 # concrete-ml==1.3.0
-gradio==3.40.1
+gradio==3.40.1
+concrete-ml==1.3.0
+imblearn==0.0

server.py

@@ -0,0 +1,104 @@
+"""Server that will listen for GET and POST requests from the client."""
+
+import time
+from typing import List
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.responses import JSONResponse, Response
+
+from settings import DEPLOYMENT_PATH, SERVER_FILES, CLIENT_TYPES
+from development.client_server_interface import MultiInputsFHEModelServer
+
+# Load the server objects related to all currently available filters once and for all
+FHE_SERVER = MultiInputsFHEModelServer(DEPLOYMENT_PATH / "deployment")
+
+def get_server_file_path(name, client_id, client_type):
+    """Get the correct temporary file path for the server.
+
+    Args:
+        name (str): The desired file name (either 'evaluation_key' or 'encrypted_inputs').
+        client_id (int): The client ID to consider.
+        client_type (str): The type of user to consider (either 'user', 'bank' or 'third_party').
+
+    Returns:
+        pathlib.Path: The file path.
+    """
+    return SERVER_FILES / f"{name}_{client_type}_{client_id}"
+
+
+# Initialize an instance of FastAPI
+app = FastAPI()
+
+# Define the default route
+@app.get("/")
+def root():
+    return {"message": "Welcome to Credit Card Approval Prediction server!"}
+
+
+@app.post("/send_input")
+def send_input(
+    client_id: str = Form(),
+    client_type: str = Form(),
+    files: List[UploadFile] = File(),
+):
+    """Send the inputs to the server."""
+    # Retrieve the encrypted inputs and the evaluation key paths
+    encrypted_inputs_path = get_server_file_path("encrypted_inputs", client_id, client_type)
+    evaluation_key_path = get_server_file_path("evaluation_key", client_id, client_type)
+    
+    # Write the files using the above paths
+    with encrypted_inputs_path.open("wb") as encrypted_inputs, evaluation_key_path.open(
+        "wb"
+    ) as evaluation_key:
+        encrypted_inputs.write(files[0].file.read())
+        evaluation_key.write(files[1].file.read())
+
+
+@app.post("/run_fhe")
+def run_fhe(
+    client_id: str = Form(),
+):
+    """Execute the model on the encrypted inputs using FHE."""
+    # Retrieve the evaluation key 
+    evaluation_key_path = get_server_file_path("evaluation_key", client_id, "user")
+
+    # Get the evaluation key
+    with evaluation_key_path.open("rb") as evaluation_key_file:
+        evaluation_key = evaluation_key_file.read()
+
+    # Get the encrypted inputs
+    encrypted_inputs = []
+    for client_type in CLIENT_TYPES:
+        encrypted_inputs_path = get_server_file_path("encrypted_inputs", client_id, client_type)
+        with encrypted_inputs_path.open("rb") as encrypted_inputs_file:
+            encrypted_input = encrypted_inputs_file.read()
+            encrypted_inputs.append(encrypted_input)
+
+    # Run the FHE execution
+    start = time.time()
+    encrypted_output = FHE_SERVER.run(*encrypted_inputs, serialized_evaluation_keys=evaluation_key)
+    fhe_execution_time = round(time.time() - start, 2)
+
+    # Retrieve the encrypted output path
+    encrypted_output_path = get_server_file_path("encrypted_output", client_id, client_type)
+
+    # Write the file using the above path
+    with encrypted_output_path.open("wb") as output_file:
+        output_file.write(encrypted_output)
+
+    return JSONResponse(content=fhe_execution_time)
+
+
+@app.post("/get_output")
+def get_output(
+    client_id: str = Form(),
+    client_type: str = Form(),
+):
+    """Retrieve the encrypted output."""
+    # Retrieve the encrypted output path
+    encrypted_output_path = get_server_file_path("encrypted_output", client_id, client_type)
+
+    # Read the file using the above path
+    with encrypted_output_path.open("rb") as encrypted_output_file:
+        encrypted_output = encrypted_output_file.read()
+
+    return Response(encrypted_output)

settings.py

@@ -6,7 +6,7 @@ from pathlib import Path
 REPO_DIR = Path(__file__).parent
 
 # This repository's main necessary directories
-FILTERS_PATH = REPO_DIR / "filters"
+DEPLOYMENT_PATH = REPO_DIR / "deployment_files"
 FHE_KEYS = REPO_DIR / ".fhe_keys"
 CLIENT_FILES = REPO_DIR / "client_files"
 SERVER_FILES = REPO_DIR / "server_files"
@@ -19,3 +19,18 @@ SERVER_FILES.mkdir(exist_ok=True)
 # Store the server's URL
 SERVER_URL = "http://localhost:8000/" 
 
+RANDOM_STATE = 0
+
+INITIAL_INPUT_SHAPE = (1, 49)
+
+CLIENT_TYPES = ["user", "bank", "third_party"]
+INPUT_INDEXES = {
+    "user": 0,
+    "bank": 1,
+    "third_party": 2,
+}
+START_POSITIONS = {
+    "user": 0,  # First position: start from 0
+    "bank": 17,  # Second position: start from len(input_user)
+    "third_party": 33,  # Third position: start from len(input_user) + len(input_bank)
+}