image pairs matching - issue on config file in server.zip

.gitignore

@@ -7,3 +7,4 @@ server_tmp/
 client_tmp/
 .artifacts
 __pycache__/
+.python-version

README.md

@@ -43,7 +43,7 @@ In a terminal, run:
 
 ```bash
 source .venv/bin/activate
-python3 app.py
+python app.py
 ```
 
 ## Interact with the application

app.py

@@ -1,4 +1,5 @@
-"""A local gradio app that filters images using FHE."""
+"""A local gradio app that detect matching images using FHE."""
+
 from PIL import Image
 import os
 import shutil
@@ -10,11 +11,14 @@ import requests
 from itertools import chain
 
 from common import (
-    AVAILABLE_FILTERS,
+    AVAILABLE_MATCHERS,
     CLIENT_TMP_PATH,
+    ENCRYPTED_OUTPUT_NAME,
+    ENCRYPTED_QUERY_NAME,
+    ENCRYPTED_REFERENCE_NAME,
     SERVER_TMP_PATH,
     EXAMPLES,
-    FILTERS_PATH,
+    MATCHERS_PATH,
     INPUT_SHAPE,
     KEYS_PATH,
     REPO_DIR,
@@ -27,31 +31,34 @@ subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
 time.sleep(3)
 
 
-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"{filter_name}/deployment"
+def decrypt_output_with_wrong_key(encrypted_image, matcher_name):
+    """Decrypt the encrypted output using a different private key."""
+    # Retrieve the matcher's deployment path
+    matcher_path = MATCHERS_PATH / f"{matcher_name}/deployment"
 
     # Instantiate the client interface and generate a new private key
-    wrong_client = FHEClient(filter_path, filter_name)
+    wrong_client = FHEClient(matcher_path, matcher_name)
     wrong_client.generate_private_and_evaluation_keys(force=True)
 
     # Deserialize, decrypt and post-process the encrypted output using the new private key
-    output_image = wrong_client.deserialize_decrypt_post_process(encrypted_image)
+    output_result = wrong_client.deserialize_decrypt_post_process(encrypted_image)
 
-    # For filters that are expected to output black and white images, generate two other random 
-    # channels for better display 
-    if filter_name in ["black and white", "ridge detection"]:
-        # Green channel
-        wrong_client.generate_private_and_evaluation_keys(force=True)
-        output_image[:, :, 1] = wrong_client.deserialize_decrypt_post_process(encrypted_image)[:, :, 0]
+    # # For matchers that are expected to output black and white images, generate two other random
+    # # channels for better display
+    # if matcher_name in ["black and white", "ridge detection"]:
+    #     # Green channel
+    #     wrong_client.generate_private_and_evaluation_keys(force=True)
+    #     output_result[:, :, 1] = wrong_client.deserialize_decrypt_post_process(
+    #         encrypted_image
+    #     )[:, :, 0]
 
-        # Blue channel
-        wrong_client.generate_private_and_evaluation_keys(force=True)
-        output_image[:, :, 2] = wrong_client.deserialize_decrypt_post_process(encrypted_image)[:, :, 0]
+    #     # Blue channel
+    #     wrong_client.generate_private_and_evaluation_keys(force=True)
+    #     output_result[:, :, 2] = wrong_client.deserialize_decrypt_post_process(
+    #         encrypted_image
+    #     )[:, :, 0]
 
-    return output_image
+    return output_result
 
 
 def shorten_bytes_object(bytes_object, limit=500):
@@ -65,7 +72,7 @@ def shorten_bytes_object(bytes_object, limit=500):
         limit (int): The length to consider. Default to 500.
 
     Returns:
-        str: Hexadecimal string shorten representation of the input byte object. 
+        str: Hexadecimal string shorten representation of the input byte object.
 
     """
     # Define a shift for better display
@@ -73,41 +80,41 @@ 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(user_id, matcher_name):
     """Get the client API.
 
     Args:
         user_id (int): The current user's ID.
-        filter_name (str): The filter chosen by the user
+        matcher_name (str): The matcher chosen by the user
 
     Returns:
         FHEClient: The client API.
     """
     return FHEClient(
-        FILTERS_PATH / f"{filter_name}/deployment", 
-        filter_name,
-        key_dir=KEYS_PATH / f"{filter_name}_{user_id}", 
+        MATCHERS_PATH / f"{matcher_name}/deployment",
+        matcher_name,
+        key_dir=KEYS_PATH / f"{matcher_name}_{user_id}",
     )
 
 
-def get_client_file_path(name, user_id, filter_name):
+def get_client_file_path(name, user_id, matcher_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.
-        filter_name (str): The filter chosen by the user
+        matcher_name (str): The matcher chosen by the user
 
     Returns:
         pathlib.Path: The file path.
     """
-    return CLIENT_TMP_PATH / f"{name}_{filter_name}_{user_id}"
+    return CLIENT_TMP_PATH / f"{name}_{matcher_name}_{user_id}"
 
 
 def clean_temporary_files(n_keys=20):
     """Clean keys and encrypted images.
 
-    A maximum of n_keys keys and associated temporary files are allowed to be stored. Once this 
+    A maximum of n_keys keys and associated temporary files are allowed to be stored. Once this
     limit is reached, the oldest files are deleted.
 
     Args:
@@ -136,11 +143,11 @@ def clean_temporary_files(n_keys=20):
                 file.unlink()
 
 
-def keygen(filter_name):
-    """Generate the private key associated to a filter.
+def keygen(matcher_name):
+    """Generate the private key associated to a matcher.
 
     Args:
-        filter_name (str): The current filter to consider.
+        matcher_name (str): The current matcher to consider.
 
     Returns:
         (user_id, True) (Tuple[int, bool]): The current user's ID and a boolean used for visual display.
@@ -153,7 +160,7 @@ def keygen(filter_name):
     user_id = numpy.random.randint(0, 2**32)
 
     # Retrieve the client API
-    client = get_client(user_id, filter_name)
+    client = get_client(user_id, matcher_name)
 
     # Generate a private key
     client.generate_private_and_evaluation_keys(force=True)
@@ -165,7 +172,7 @@ 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", user_id, matcher_name)
 
     with evaluation_key_path.open("wb") as evaluation_key_file:
         evaluation_key_file.write(evaluation_key)
@@ -173,13 +180,18 @@ def keygen(filter_name):
     return (user_id, True)
 
 
-def encrypt(user_id, input_image, filter_name):
-    """Encrypt the given image for a specific user and filter.
+def encrypt(
+    user_id, input_image, matcher_name, encrypted_image_name: str = "encrypted_image"
+):
+    """Encrypt the given image for a specific user and matcher.
 
     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.
+        matcher_name (str): The current matcher to consider.
+        encrypted_image_name (str): how to name the encrypted image
+            to distinguish between the query and the reference images.
+            Defaults to "encrypted_image"
 
     Returns:
         (input_image, encrypted_image_short) (Tuple[bytes]): The encrypted image and one of its
@@ -191,25 +203,34 @@ def encrypt(user_id, input_image, filter_name):
 
     if input_image is None:
         raise gr.Error("Please choose an image first.")
-    
-    if input_image.shape[-1] != 3:
-        raise ValueError(f"Input image must have 3 channels (RGB). Current shape: {input_image.shape}")
-    
-    # Resize the image if it hasn't the shape (100, 100, 3)
-    if input_image.shape != (100 , 100, 3):
+
+    if input_image.shape[-1] not in {3, 4}:
+        raise ValueError(
+            f"Input image must have 3 channels (RGB) or 4 channels. Current shape: {input_image.shape}"
+        )
+
+    if input_image.shape[-1] == 4:
+        # Discarding alpha channel from images stored as Numpy arrays
+        # (reference https://stackoverflow.com/questions/35902302/discarding-alpha-channel-from-images-stored-as-numpy-arrays)
+        input_image = input_image[:, :, :3]
+
+    # Resize the image if it hasn't the shape (INPUT_SHAPE[0], INPUT_SHAPE[1], 3)
+    if input_image.shape != (INPUT_SHAPE[0], INPUT_SHAPE[1], 3):
         input_image_pil = Image.fromarray(input_image)
-        input_image_pil = input_image_pil.resize((100, 100))
+        input_image_pil = input_image_pil.resize((INPUT_SHAPE[0], INPUT_SHAPE[1]))
         input_image = numpy.array(input_image_pil)
 
     # Retrieve the client API
-    client = get_client(user_id, filter_name)
+    client = get_client(user_id, matcher_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)
+    encrypted_image_path = get_client_file_path(
+        encrypted_image_name, user_id, matcher_name
+    )
 
     with encrypted_image_path.open("wb") as encrypted_image_file:
         encrypted_image_file.write(encrypted_image)
@@ -220,32 +241,45 @@ def encrypt(user_id, input_image, filter_name):
     return (resize_img(input_image), encrypted_image_short)
 
 
-def send_input(user_id, filter_name):
-    """Send the encrypted input image as well as the evaluation key to the server.
+def send_input(user_id, matcher_name):
+    """Send the encrypted input images 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.
+        matcher_name (str): The current matcher to consider.
     """
     # Get the evaluation key path
-    evaluation_key_path = get_client_file_path("evaluation_key", user_id, filter_name)
+    evaluation_key_path = get_client_file_path("evaluation_key", user_id, matcher_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)
+    encrypted_query_image_path = get_client_file_path(
+        ENCRYPTED_QUERY_NAME, user_id, matcher_name
+    )
+
+    encrypted_reference_image_path = get_client_file_path(
+        ENCRYPTED_REFERENCE_NAME, user_id, matcher_name
+    )
 
-    if not encrypted_input_path.is_file():
-        raise gr.Error("Please generate the private key and then encrypt an image first.")
+    for encrypted_input_path in {
+        encrypted_query_image_path,
+        encrypted_reference_image_path,
+    }:
+        if not encrypted_input_path.is_file():
+            raise gr.Error(
+                f"Please generate the private key and then encrypt an image first: {encrypted_input_path}"
+            )
 
     # Define the data and files to post
     data = {
         "user_id": user_id,
-        "filter": filter_name,
+        "matcher": matcher_name,
     }
 
     files = [
-        ("files", open(encrypted_input_path, "rb")),
+        ("files", open(encrypted_query_image_path, "rb")),
+        ("files", open(encrypted_reference_image_path, "rb")),
         ("files", open(evaluation_key_path, "rb")),
     ]
 
@@ -259,16 +293,16 @@ 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 run_fhe(user_id, matcher_name):
+    """Apply the matcher on the encrypted image previously sent using FHE.
 
     Args:
         user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        matcher_name (str): The current matcher to consider.
     """
     data = {
         "user_id": user_id,
-        "filter": filter_name,
+        "matcher": matcher_name,
     }
 
     # Trigger the FHE execution on the encrypted image previously sent
@@ -280,23 +314,25 @@ 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.")
+            print(f"ERROR run_fhe: {response}")
+            
+            raise gr.Error("Please wait for the input images to be sent to the server.")
 
 
-def get_output(user_id, filter_name):
-    """Retrieve the encrypted output image.
+def get_output(user_id, matcher_name):
+    """Retrieve the encrypted output.
 
     Args:
         user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        matcher_name (str): The current filter to consider.
 
     Returns:
-        encrypted_output_image_short (bytes): A representation of the encrypted result.
+        encrypted_output_short (bytes): A representation of the encrypted result.
 
     """
     data = {
         "user_id": user_id,
-        "filter": filter_name,
+        "matcher": matcher_name,
     }
 
     # Retrieve the encrypted output image
@@ -310,26 +346,35 @@ 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)
+            encrypted_output_path = get_client_file_path(
+                ENCRYPTED_OUTPUT_NAME, user_id, matcher_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, filter_name)
+            # Decrypt the output using a different (wrong) key for display
+            output_representation = decrypt_output_with_wrong_key(
+                encrypted_output, matcher_name
+            )
 
-            return {encrypted_output_representation: gr.update(value=resize_img(output_image_representation))}
+            return {
+                encrypted_output_representation: gr.update(
+                    value=output_representation
+                    # value=resize_img(output_image_representation)
+                )
+            }
 
         else:
             raise gr.Error("Please wait for the FHE execution to be completed.")
 
 
-def decrypt_output(user_id, filter_name):
+def decrypt_output(user_id, matcher_name):
     """Decrypt the result.
 
     Args:
         user_id (int): The current user's ID.
-        filter_name (str): The current filter to consider.
+        matcher_name (str): The current matcher to consider.
 
     Returns:
         (output_image, False, False) ((Tuple[numpy.ndarray, bool, bool]): The decrypted output, as
@@ -340,24 +385,26 @@ def decrypt_output(user_id, filter_name):
         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_NAME, user_id, matcher_name
+    )
 
     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 = encrypted_output_file.read()
 
     # Retrieve the client API
-    client = get_client(user_id, filter_name)
+    client = get_client(user_id, matcher_name)
 
     # Deserialize, decrypt and post-process the encrypted output
-    decrypted_ouput = client.deserialize_decrypt_post_process(encrypted_output_image)
+    decrypted_ouput = client.deserialize_decrypt_post_process(encrypted_output)
 
     print(f"Decrypted output: {decrypted_ouput.shape=}")
-    
-    return {output_image: gr.update(value=resize_img(decrypted_ouput))}
+
+    return {output_result: gr.update(value=decrypted_ouput)}
 
 
 def resize_img(img, width=256, height=256):
@@ -370,6 +417,7 @@ def resize_img(img, width=256, height=256):
     # Convert back to a NumPy array
     return numpy.array(resized_img_pil)
 
+
 demo = gr.Blocks()
 
 
@@ -377,10 +425,11 @@ print("Starting the demo...")
 with demo:
     gr.Markdown(
         """
-        <p align="center">
+        <!--p align="center">
             <img width=200 src="https://user-images.githubusercontent.com/5758427/197816413-d9cddad3-ba38-4793-847d-120975e1da11.png">
-        </p>
-        <h1 align="center">Image Filtering On Encrypted Data Using Fully Homomorphic Encryption</h1>
+        </p-->
+        <h1 align="center"> #ppaihackteam14 </h1>
+        <h1 align="center">Biometric image matching Using Fully Homomorphic Encryption</h1>
         <p align="center">
             <a href="https://github.com/zama-ai/concrete-ml"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="https://user-images.githubusercontent.com/5758427/197972109-faaaff3e-10e2-4ab6-80f5-7531f7cfb08f.png">Concrete-ML</a>
             —
@@ -390,48 +439,70 @@ with demo:
             —
             <a href="https://twitter.com/zama_fhe"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="https://user-images.githubusercontent.com/5758427/197975044-bab9d199-e120-433b-b3be-abd73b211a54.png">@zama_fhe</a>
         </p>
-        <p align="center">
+        <!--p align="center">
             <img src="https://user-images.githubusercontent.com/56846628/219605302-5baafac4-cf6f-4f06-9a96-91cef2b84a63.png" width="70%" height="70%">
-        </p>
-        <p align="center">
-            Test the app below, review
-            <a href="https://zama.ai/post/encrypted-image-filtering-using-homomorphic-encryption"> our tutorial</a>
-            , and try the build for yourself!
-        </p>
+        </p-->
         """
     )
 
     gr.Markdown("## Client side")
-    gr.Markdown("### Step 1: Upload an image. ")
+    gr.Markdown("### Step 1: Upload input images. ")
     gr.Markdown(
         f"The image will automatically be resized to shape ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}). "
         "The image here, however, is displayed in its original resolution. The true image used "
         "in this demo can be seen in Step 8."
     )
+    gr.Markdown("The query image to certify.")
     with gr.Row():
-        input_image = gr.Image(
-            value=None, label="Upload an image here.", height=256,
-            width=256, sources="upload", interactive=True,
+        input_query_img = gr.Image(
+            value=None,
+            label="Upload an image here.",
+            height=256,
+            width=256,
+            source="upload",
+            interactive=True,
         )
 
         examples = gr.Examples(
-            examples=EXAMPLES, inputs=[input_image], examples_per_page=5, label="Examples to use."
+            examples=EXAMPLES,
+            inputs=[input_query_img],
+            examples_per_page=5,
+            label="Examples to use.",
+        )
+    gr.Markdown("The reference image.")
+    with gr.Row():
+        input_reference_img = gr.Image(
+            value=None,
+            label="Upload an image here.",
+            height=256,
+            width=256,
+            source="upload",
+            interactive=True,
         )
 
+        examples = gr.Examples(
+            examples=EXAMPLES,
+            inputs=[input_reference_img],
+            examples_per_page=5,
+            label="Examples to use.",
+        )
 
-    gr.Markdown("### Step 2: Choose your filter.")
-    filter_name = gr.Dropdown(
-        choices=AVAILABLE_FILTERS, value="inverted", label="Choose your filter", interactive=True
+    gr.Markdown("### Step 2: Choose your matcher.")
+    matcher_name = gr.Dropdown(
+        choices=AVAILABLE_MATCHERS,
+        value="random guessing",
+        label="Choose your matcher",
+        interactive=True,
     )
 
     gr.Markdown("#### Notes")
     gr.Markdown(
         """
         - The private key is used to encrypt and decrypt the data and will never be shared.
-        - No public key is required for these filter operators.
+        - No public key is required for these matcher operators.
         """
     )
-    
+
     gr.Markdown("### Step 3: Generate the private key.")
     keygen_button = gr.Button("Generate the private key.")
 
@@ -439,25 +510,49 @@ with demo:
         keygen_checkbox = gr.Checkbox(label="Private key generated:", interactive=False)
 
     user_id = gr.Textbox(label="", max_lines=2, interactive=False, visible=False)
-    
-    gr.Markdown("### Step 4: Encrypt the image using FHE.")
-    encrypt_button = gr.Button("Encrypt the image using FHE.")
+    encrypted_query_image = gr.Textbox(
+        value=ENCRYPTED_QUERY_NAME,
+        label="",
+        max_lines=2,
+        interactive=False,
+        visible=False,
+    )
+    encrypted_reference_image = gr.Textbox(
+        value=ENCRYPTED_REFERENCE_NAME,
+        label="",
+        max_lines=2,
+        interactive=False,
+        visible=False,
+    )
 
+    gr.Markdown("### Step 4: Encrypt the images using FHE.")
+    encrypt_query_button = gr.Button("Encrypt the query image using FHE.")
+
+    with gr.Row():
+        encrypted_input_query = gr.Textbox(
+            label="Encrypted input query representation:",
+            max_lines=2,
+            interactive=False,
+        )
+
+    encrypt_reference_button = gr.Button("Encrypt the reference image using FHE.")
     with gr.Row():
-        encrypted_input = gr.Textbox(
-            label="Encrypted input representation:", max_lines=2, interactive=False
+        encrypted_input_reference = gr.Textbox(
+            label="Encrypted input reference representation:",
+            max_lines=2,
+            interactive=False,
         )
 
     gr.Markdown("## Server side")
     gr.Markdown(
-        "The encrypted value is received by the server. The server can then compute the filter "
+        "The encrypted value is received by the server. The server can then compute the matcher "
         "directly over encrypted values. Once the computation is finished, the server returns "
         "the encrypted results to the client."
     )
 
-    gr.Markdown("### Step 5: Send the encrypted image to the server.")
-    send_input_button = gr.Button("Send the encrypted image to the server.")
-    send_input_checkbox = gr.Checkbox(label="Encrypted image sent.", interactive=False)
+    gr.Markdown("### Step 5: Send the encrypted images to the server.")
+    send_input_button = gr.Button("Send the encrypted images to the server.")
+    send_input_checkbox = gr.Checkbox(label="Encrypted images sent.", interactive=False)
 
     gr.Markdown("### Step 6: Run FHE execution.")
     execute_fhe_button = gr.Button("Run FHE execution.")
@@ -465,86 +560,105 @@ with demo:
         label="Total FHE execution time (in seconds):", max_lines=1, interactive=False
     )
 
-    gr.Markdown("### Step 7: Receive the encrypted output image from the server.")
+    gr.Markdown("### Step 7: Receive the encrypted output from the server.")
     gr.Markdown(
-        "The image displayed here is the encrypted result sent by the server, which has been "
+        "The result displayed here is the encrypted result sent by the server, which has been "
         "decrypted using a different private key. This is only used to visually represent an "
-        "encrypted image."
+        "encrypted result."
+    )
+    get_output_button = gr.Button(
+        "Receive the encrypted output result from the server."
     )
-    get_output_button = gr.Button("Receive the encrypted output image from the server.")
 
     with gr.Row():
-        encrypted_output_representation = gr.Image(
-            label=f"Encrypted output representation ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
-            interactive=False,
-            height=256,
-            width=256,
-        )
+        encrypted_output_representation = gr.Label()
+        # encrypted_output_representation = gr.Image(
+        #     label=f"Encrypted output representation ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
+        #     interactive=False,
+        #     height=256,
+        #     width=256,
+        # )
 
     gr.Markdown("## Client side")
     gr.Markdown(
         "The encrypted output is sent back to the client, who can finally decrypt it with the "
-        "private key. Only the client is aware of the original image and its transformed version."
+        "private key. Only the client is aware of the original input images and the result of the matching."
     )
 
     gr.Markdown("### Step 8: Decrypt the output.")
     gr.Markdown(
-        "The image displayed on the left is the input image used during the demo. The output image "
+        "The images displayed on the left are the input images used during the demo. The output result "
         "can be seen on the right."
-    )   
+    )
     decrypt_button = gr.Button("Decrypt the output")
 
     # Final input vs output display
     with gr.Row():
-        original_image = gr.Image(
-            input_image.value,
-            label=f"Input image ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
+        original_query_image = gr.Image(
+            input_query_img.value,
+            label=f"Input query image ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
             interactive=False,
             height=256,
-            width=256,   
+            width=256,
         )
-
-        output_image = gr.Image(
-            label=f"Output image ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
+        original_reference_image = gr.Image(
+            input_reference_img.value,
+            label=f"Input reference image ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
             interactive=False,
             height=256,
             width=256,
         )
+        output_result = gr.Label()
+        # output_image = gr.Image(
+        #     label=f"Output image ({INPUT_SHAPE[0]}x{INPUT_SHAPE[1]}):",
+        #     interactive=False,
+        #     height=256,
+        #     width=256,
+        # )
 
     # Button to generate the private key
     keygen_button.click(
         keygen,
-        inputs=[filter_name],
+        inputs=[matcher_name],
         outputs=[user_id, keygen_checkbox],
     )
 
-    # Button to encrypt inputs on the client side
-    encrypt_button.click(
+    # Button to encrypt input query on the client side
+    encrypt_query_button.click(
+        encrypt,
+        inputs=[user_id, input_query_img, matcher_name, encrypted_query_image],
+        outputs=[original_query_image, encrypted_input_query],
+    )
+
+    # Button to encrypt input reference on the client side
+    encrypt_reference_button.click(
         encrypt,
-        inputs=[user_id, input_image, filter_name],
-        outputs=[original_image, encrypted_input],
+        inputs=[user_id, input_reference_img, matcher_name, encrypted_reference_image],
+        outputs=[original_reference_image, encrypted_input_reference],
     )
 
     # Button to send the encodings to the server using post method
     send_input_button.click(
-        send_input, inputs=[user_id, filter_name], outputs=[send_input_checkbox]
+        send_input, inputs=[user_id, matcher_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, filter_name], outputs=[fhe_execution_time])
+    execute_fhe_button.click(
+        run_fhe, inputs=[user_id, matcher_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, filter_name],
-        outputs=[encrypted_output_representation]
+        get_output,
+        inputs=[user_id, matcher_name],
+        outputs=[encrypted_output_representation],
     )
 
     # Button to decrypt the output on the client side
     decrypt_button.click(
         decrypt_output,
-        inputs=[user_id, filter_name],
-        outputs=[output_image, keygen_checkbox, send_input_checkbox],
+        inputs=[user_id, matcher_name],
+        outputs=[output_result, keygen_checkbox, send_input_checkbox],
     )
 
     gr.Markdown(

client_server_interface.py

@@ -1,8 +1,8 @@
-"Client-server interface custom implementation for filter models."
+"Client-server interface custom implementation for matcher models."
 
 from concrete import fhe
 
-from filters import Filter
+from matchers import Matcher
 
 
 class FHEServer:
@@ -19,22 +19,35 @@ class FHEServer:
         # Load the FHE circuit
         self.server = fhe.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.
+    def run(
+        self,
+        serialized_encrypted_query_image,
+        serialized_encrypted_reference_image,
+        serialized_evaluation_keys,
+    ):
+        """Run the matcher on the server over an encrypted image.
 
         Args:
-            serialized_encrypted_image (bytes): The encrypted and serialized image.
+            serialized_encrypted_query_image (bytes): The encrypted and serialized query image.
+            serialized_encrypted_reference_image (bytes): The encrypted and serialized referenceimage.
             serialized_evaluation_keys (bytes): The serialized evaluation keys.
 
         Returns:
-            bytes: The filter's output.
+            bytes: The matcher's output.
         """
         # Deserialize the encrypted input image and the evaluation keys
-        encrypted_image = fhe.Value.deserialize(serialized_encrypted_image)
+        encrypted_query_image = fhe.Value.deserialize(serialized_encrypted_query_image)
+        encrypted_reference_image = fhe.Value.deserialize(
+            serialized_encrypted_reference_image
+        )
         evaluation_keys = fhe.EvaluationKeys.deserialize(serialized_evaluation_keys)
 
-        # Execute the filter in FHE
-        encrypted_output = self.server.run(encrypted_image, evaluation_keys=evaluation_keys)
+        # Execute the matcher in FHE
+        encrypted_output = self.server.run(
+            encrypted_query_image,
+            encrypted_reference_image,
+            evaluation_keys=evaluation_keys,
+        )
 
         # Serialize the encrypted output image
         serialized_encrypted_output = encrypted_output.serialize()
@@ -43,60 +56,62 @@ class FHEServer:
 
 
 class FHEDev:
-    """Development interface to save and load the filter."""
+    """Development interface to save and load the matcher."""
 
-    def __init__(self, filter, path_dir):
+    def __init__(self, matcher, path_dir):
         """Initialize the FHE interface.
 
         Args:
-            filter (Filter): The filter to use in the FHE interface.
+            matcher (Matcher): The matcher to use in the FHE interface.
             path_dir (str): The path to the directory where the circuit is saved.
         """
 
-        self.filter = filter
+        self.matcher = matcher
         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."
-        )
+
+        assert (
+            self.matcher.fhe_circuit is not None
+        ), "The model must be compiled before saving it."
 
         # Save the circuit for the server, using the via_mlir in order to handle cross-platform
         # execution
         path_circuit_server = self.path_dir / "server.zip"
-        self.filter.fhe_circuit.server.save(path_circuit_server, via_mlir=True)
+        self.matcher.fhe_circuit.server.save(path_circuit_server, via_mlir=True)
 
         # Save the circuit for the client
         path_circuit_client = self.path_dir / "client.zip"
-        self.filter.fhe_circuit.client.save(path_circuit_client)
+        self.matcher.fhe_circuit.client.save(path_circuit_client)
 
 
 class FHEClient:
-    """Client interface to encrypt and decrypt FHE data associated to a Filter."""
+    """Client interface to encrypt and decrypt FHE data associated to a matcher."""
 
-    def __init__(self, path_dir, filter_name, key_dir=None):
+    def __init__(self, path_dir, matcher_name, key_dir=None):
         """Initialize the FHE interface.
 
         Args:
             path_dir (Path): The path to the directory where the circuit is saved.
-            filter_name (str): The filter's name to consider.
+            matcher_name (str): The matcher's name to consider.
             key_dir (Path): The path to the directory where the keys are stored. Default to None.
         """
         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."
+        assert (
+            path_dir.exists()
+        ), f"{path_dir} does not exist. Please specify a valid path."
 
         # Load the client
         self.client = fhe.Client.load(self.path_dir / "client.zip", self.key_dir)
 
-        # Instantiate the filter
-        self.filter = Filter(filter_name)
+        # Instantiate the matcher
+        self.matcher = Matcher(matcher_name)
 
     def generate_private_and_evaluation_keys(self, force=False):
         """Generate the private and evaluation keys.
@@ -131,7 +146,7 @@ class FHEClient:
         return serialized_encrypted_image
 
     def deserialize_decrypt_post_process(self, serialized_encrypted_output_image):
-        """Deserialize, decrypt and post-process the output image in the clear.
+        """Deserialize, decrypt and post-process the output result in the clear.
 
         Args:
             serialized_encrypted_output_image (bytes): The serialized and encrypted output image.
@@ -140,14 +155,12 @@ class FHEClient:
             numpy.ndarray: The decrypted, deserialized and post-processed image.
         """
         # Deserialize the encrypted image
-        encrypted_output_image = fhe.Value.deserialize(
-            serialized_encrypted_output_image
-        )
+        encrypted_output = fhe.Value.deserialize(serialized_encrypted_output_image)
 
-        # Decrypt the image
-        output_image = self.client.decrypt(encrypted_output_image)
+        # Decrypt the result
+        output_result = self.client.decrypt(encrypted_output)
 
-        # Post-process the image
-        post_processed_output_image = self.filter.post_processing(output_image)
+        # Post-process the result
+        post_processed_output = self.matcher.post_processing(output_result)
 
-        return post_processed_output_image
+        return post_processed_output

common.py

@@ -6,7 +6,7 @@ from pathlib import Path
 REPO_DIR = Path(__file__).parent
 
 # This repository's main necessary folders
-FILTERS_PATH = REPO_DIR / "filters"
+MATCHERS_PATH = REPO_DIR / "matchers"
 KEYS_PATH = REPO_DIR / ".fhe_keys"
 CLIENT_TMP_PATH = REPO_DIR / "client_tmp"
 SERVER_TMP_PATH = REPO_DIR / "server_tmp"
@@ -17,14 +17,13 @@ CLIENT_TMP_PATH.mkdir(exist_ok=True)
 SERVER_TMP_PATH.mkdir(exist_ok=True)
 
 # All the filters currently available in the demo
-AVAILABLE_FILTERS = [
-    "identity",
-    "inverted",
-    "rotate",
-    "black and white",
-    "blur",
-    "sharpen",
-    "ridge detection",
+AVAILABLE_MATCHERS = [
+    "random guessing",
+    # "random guessing concrete 1.1.0",
+    # "random guessing concrete 1.1.0",
+    # "static distance",
+    # "MLP-based learned distance",
+    # "CNN-based learned distance",
 ]
 
 # The input images' shape. Images with different input shapes will be cropped and resized by Gradio
@@ -36,5 +35,10 @@ INPUT_EXAMPLES_DIR = REPO_DIR / "input_examples"
 # List of all image examples suggested in the demo
 EXAMPLES = [str(image) for image in INPUT_EXAMPLES_DIR.glob("**/*")]
 
+# Encrypted image and output names
+ENCRYPTED_QUERY_NAME = "encrypted_query_image"
+ENCRYPTED_REFERENCE_NAME = "encrypted_reference_image"
+ENCRYPTED_OUTPUT_NAME = "encrypted_output"
+
 # Store the server's URL
 SERVER_URL = "http://localhost:8000/"

data/old_code/client_server_interface.py

@@ -0,0 +1,153 @@
+"Client-server interface custom implementation for filter models."
+
+from concrete import fhe
+
+from filters import Filter
+
+
+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 = fhe.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
+        encrypted_image = fhe.Value.deserialize(serialized_encrypted_image)
+        evaluation_keys = fhe.EvaluationKeys.deserialize(serialized_evaluation_keys)
+
+        # Execute the filter in FHE
+        encrypted_output = self.server.run(encrypted_image, evaluation_keys=evaluation_keys)
+
+        # Serialize the encrypted output image
+        serialized_encrypted_output = encrypted_output.serialize()
+
+        return serialized_encrypted_output
+
+
+class FHEDev:
+    """Development interface to save and load the filter."""
+
+    def __init__(self, filter, path_dir):
+        """Initialize the FHE interface.
+
+        Args:
+            filter (Filter): The filter to use in the FHE interface.
+            path_dir (str): The path to the directory where the circuit is saved.
+        """
+
+        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."
+        )
+
+        # Save the circuit for the server, using the via_mlir in order to handle cross-platform
+        # execution
+        path_circuit_server = self.path_dir / "server.zip"
+        self.filter.fhe_circuit.server.save(path_circuit_server, via_mlir=True)
+
+        # Save the circuit for the client
+        path_circuit_client = self.path_dir / "client.zip"
+        self.filter.fhe_circuit.client.save(path_circuit_client)
+
+
+class FHEClient:
+    """Client interface to encrypt and decrypt FHE data associated to a Filter."""
+
+    def __init__(self, path_dir, filter_name, key_dir=None):
+        """Initialize the FHE interface.
+
+        Args:
+            path_dir (Path): The path to the directory where the circuit is saved.
+            filter_name (str): The filter's name to consider.
+            key_dir (Path): The path to the directory where the keys are stored. Default to None.
+        """
+        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 = fhe.Client.load(self.path_dir / "client.zip", self.key_dir)
+
+        # Instantiate the filter
+        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 encrypt_serialize(self, input_image):
+        """Encrypt and serialize the input image in the clear.
+
+        Args:
+            input_image (numpy.ndarray): The image to encrypt and serialize.
+
+        Returns:
+            bytes: The pre-processed, encrypted and serialized image.
+        """
+        # Encrypt the image
+        encrypted_image = self.client.encrypt(input_image)
+
+        # Serialize the encrypted image to be sent to the server
+        serialized_encrypted_image = encrypted_image.serialize()
+        return serialized_encrypted_image
+
+    def deserialize_decrypt_post_process(self, serialized_encrypted_output_image):
+        """Deserialize, decrypt and post-process the output image in the clear.
+
+        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 = fhe.Value.deserialize(
+            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

filters.py → data/old_code/filters.py

@@ -3,7 +3,7 @@
 import numpy as np
 import torch
 from torch import nn
-from common import AVAILABLE_FILTERS, INPUT_SHAPE
+from common import AVAILABLE_MATCHERS, INPUT_SHAPE
 
 from concrete.fhe.compilation.compiler import Compiler
 from concrete.ml.common.utils import generate_proxy_function
@@ -58,7 +58,9 @@ class TorchRotate(nn.Module):
 class TorchConv(nn.Module):
     """Torch model with a single convolution operator."""
 
-    def __init__(self, kernel, n_in_channels=3, n_out_channels=3, groups=1, threshold=None):
+    def __init__(
+        self, kernel, n_in_channels=3, n_out_channels=3, groups=1, threshold=None
+    ):
         """Initialize the filter.
 
         Args:
@@ -104,16 +106,15 @@ class TorchConv(nn.Module):
                 kernel_shape[1],
             )
 
-
         else:
             raise ValueError(
                 "Wrong kernel shape, only 1D or 2D kernels are accepted. Got kernel of shape "
                 f"{kernel_shape}"
             )
 
-        # Reshape the image. This is done because Torch convolutions and Numpy arrays (for PIL 
-        # display) don't follow the same shape conventions. More precisely, x is of shape 
-        # (Width, Height, Channels) while the conv2d operator requires an input of shape 
+        # Reshape the image. This is done because Torch convolutions and Numpy arrays (for PIL
+        # display) don't follow the same shape conventions. More precisely, x is of shape
+        # (Width, Height, Channels) while the conv2d operator requires an input of shape
         # (Batch, Channels, Height, Width)
         x = x.transpose(2, 0).unsqueeze(axis=0)
 
@@ -142,18 +143,18 @@ class Filter:
             filter_name (str): The filter to consider.
         """
 
-        assert filter_name in AVAILABLE_FILTERS, (
-            f"Unsupported image filter or transformation. Expected one of {*AVAILABLE_FILTERS,}, "
+        assert filter_name in AVAILABLE_MATCHERS, (
+            f"Unsupported image filter or transformation. Expected one of {*AVAILABLE_MATCHERS,}, "
             f"but got {filter_name}",
         )
 
-        # Define attributes associated to the filter 
+        # Define attributes associated to the filter
         self.filter_name = filter_name
         self.onnx_model = None
         self.fhe_circuit = None
         self.divide = None
 
-        # Instantiate the torch module associated to the given filter name 
+        # Instantiate the torch module associated to the given filter name
         if filter_name == "identity":
             self.torch_model = TorchIdentity()
 
@@ -179,7 +180,6 @@ class Filter:
             # Define the value used when for dividing the output values in post-processing
             self.divide = 1000
 
-
         elif filter_name == "blur":
             kernel = np.ones((3, 3))
 
@@ -208,16 +208,16 @@ class Filter:
             # value to the result in order to better display the ridges
             self.torch_model = TorchConv(kernel, threshold=900)
 
-
     def compile(self):
         """Compile the filter on a representative inputset."""
-        # Generate a random representative set of images used for compilation, following shape 
+        # Generate a random representative set of images used for compilation, following shape
         # PIL's shape RGB format for Numpy arrays (image_width, image_height, 3)
-        # Additionally, 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=(H, W, 3)]]  
+        # Additionally, 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=(H, W, 3)]]
         np.random.seed(42)
         inputset = tuple(
-            np.random.randint(0, 256, size=(INPUT_SHAPE + (3, )), dtype=np.int64) for _ in range(100)
+            np.random.randint(0, 256, size=(INPUT_SHAPE + (3,)), dtype=np.int64)
+            for _ in range(100)
         )
 
         # Convert the Torch module to a Numpy module
@@ -227,11 +227,10 @@ class Filter:
         )
 
         # Get the proxy function and parameter mappings used for initializing the compiler
-        # This is done in order to be able to provide any modules with arbitrary numbers of 
+        # This is done in order to be able to provide any modules with arbitrary numbers of
         # encrypted arguments to Concrete Numpy's compiler
         numpy_filter_proxy, parameters_mapping = generate_proxy_function(
-            numpy_module.numpy_forward, 
-            ["inputs"]
+            numpy_module.numpy_forward, ["inputs"]
         )
 
         # Compile the filter and retrieve its FHE circuit

generate_dev_files.py → data/old_code/generate_dev_files.py

@@ -1,13 +1,13 @@
 "A script to generate all development files necessary for the image filtering demo."
 
 import shutil
-from common import AVAILABLE_FILTERS, FILTERS_PATH
+from common import AVAILABLE_MATCHERS, MATCHERS_PATH
 from filters import Filter
 from client_server_interface import FHEDev
 
 print("Generating deployment files for all available filters")
 
-for filter_name in AVAILABLE_FILTERS:
+for filter_name in AVAILABLE_MATCHERS:
     print("Filter:", filter_name, "\n")
 
     # Create the filter instance
@@ -17,7 +17,7 @@ for filter_name in AVAILABLE_FILTERS:
     filter.compile()
 
     # Define the directory path associated to this filter's deployment files
-    deployment_path = FILTERS_PATH / (filter_name + "/deployment")
+    deployment_path = MATCHERS_PATH / (filter_name + "/deployment")
 
     # Delete the deployment folder and its content if it already exists
     if deployment_path.is_dir():

generate_deployment_files.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+import shutil
+from client_server_interface import FHEDev
+from matchers import AVAILABLE_MATCHERS, Matcher
+
+
+print("Generating deployment files for all available filters")
+# This repository's directory
+REPO_DIR = Path(__file__).parent
+# This repository's main necessary folders
+MATCHERS_PATH = REPO_DIR / "data/compiled_models"
+for matcher_name in AVAILABLE_MATCHERS:
+    print("Matcher:", matcher_name, "\n")
+
+    # Create the filter instance
+    matcher = Matcher(matcher_name)
+
+    # Compile the model on a representative inputset
+    matcher.compile()
+
+    # Define the directory path associated to this filter's deployment files
+    deployment_path = MATCHERS_PATH / (matcher_name + "/deployment")
+
+    # Delete the deployment folder and its content if it already exists
+    if deployment_path.is_dir():
+        print("Delete the deployment folder and its content ...")
+        shutil.rmtree(deployment_path)
+
+    # Save the files needed for deployment
+    print(f"Saving the files at {deployment_path} ...")
+    fhe_dev_filter = FHEDev(matcher, deployment_path)
+    fhe_dev_filter.save()
+
+print("Done !")

matchers.py

@@ -0,0 +1,96 @@
+import random
+import numpy as np
+from torch import nn
+import torch
+
+from concrete.fhe.compilation.compiler import Compiler
+from concrete.ml.common.utils import generate_proxy_function
+from concrete.ml.torch.numpy_module import NumpyModule
+
+from common import AVAILABLE_MATCHERS
+
+
+class TorchRandomGuessing(nn.Module):
+    """Torch identity model."""
+
+    def __init__(self, classes_=[0, 1]):
+        super().__init__()
+        self.classes_ = classes_
+
+    def forward(self, q, r):
+        """Random guessing forward pass.
+
+        Args:
+            q (torch.Tensor): The input query.
+            r (torch.Tensor): The input reference.
+
+        Returns:
+             (torch.Tensor): .
+        """
+        q = q.sum()
+        r = r.sum()
+        return torch.tensor([random.choice([0, 1])]) + q - q + r - r
+
+
+class Matcher:
+    def __init__(self, matcher_name):
+        assert matcher_name in AVAILABLE_MATCHERS, (
+            f"Unsupported image matcher. Expected one of {*AVAILABLE_MATCHERS,}, "
+            f"but got {matcher_name}",
+        )
+        self.fhe_circuit = None
+        self.matcher_name = matcher_name
+
+        if self.matcher_name == "random guessing":
+            self.torch_model = TorchRandomGuessing()
+
+    def compile(self):
+
+        inputset = [(np.array([10]), np.array([5]))]
+
+        print("torch module > numpy module ...")
+        numpy_module = NumpyModule(
+            # torch_model, dummy_input=torch.from_numpy(np.array([10], dtype=np.int64))
+            self.torch_model,
+            # dummy_input=(torch.tensor([10]), torch.tensor([5])),
+            dummy_input=(
+                torch.from_numpy(inputset[0][1]),
+                torch.from_numpy(inputset[0][1]),
+            ),
+        )
+
+        print("get proxy function ...")
+        # Get the proxy function and parameter mappings used for initializing the compiler
+        # This is done in order to be able to provide any modules with arbitrary numbers of
+        # encrypted arguments to Concrete Numpy's compiler
+        numpy_filter_proxy, parameters_mapping = generate_proxy_function(
+            numpy_module.numpy_forward, ["query", "reference"]
+        )
+
+        print("Compile the filter and retrieve its FHE circuit ...")
+        compiler = Compiler(
+            numpy_filter_proxy,
+            {
+                parameters_mapping["query"]: "encrypted",
+                parameters_mapping["reference"]: "encrypted",
+            },
+        )
+        self.fhe_circuit = compiler.compile(inputset)
+        return self.fhe_circuit
+
+    def post_processing(self, output_result):
+        """Apply post-processing to the decrypted output result.
+
+        Args:
+            output_result (np.ndarray): The decrypted result to post-process.
+
+        Returns:
+            output_result (np.ndarray): The post-processed result.
+        """
+        print(f"{output_result=}")
+
+        return "PASS" if output_result[0] == 1 else "FAIL"
+
+
+# matcher = Matcher(matcher_name=AVAILABLE_MATCHERS[0])
+# fhe_circuit = matcher.compile()

matchers/filter blur/deployment/circuit.mlir

@@ -0,0 +1,11 @@
+module {
+  func.func @main(%arg0: tensor<100x100x3x!FHE.eint<12>>) -> tensor<98x98x3x!FHE.eint<12>> {
+    %0 = "FHELinalg.transpose"(%arg0) {axes = [2, 1, 0]} : (tensor<100x100x3x!FHE.eint<12>>) -> tensor<3x100x100x!FHE.eint<12>>
+    %expanded = tensor.expand_shape %0 [[0, 1], [2], [3]] : tensor<3x100x100x!FHE.eint<12>> into tensor<1x3x100x100x!FHE.eint<12>>
+    %cst = arith.constant dense<1> : tensor<3x1x3x3xi13>
+    %1 = "FHELinalg.conv2d"(%expanded, %cst) {dilations = dense<1> : tensor<2xi64>, group = 3 : i64, padding = dense<0> : tensor<4xi64>, strides = dense<1> : tensor<2xi64>} : (tensor<1x3x100x100x!FHE.eint<12>>, tensor<3x1x3x3xi13>) -> tensor<1x3x98x98x!FHE.eint<12>>
+    %2 = "FHELinalg.transpose"(%1) {axes = [0, 3, 2, 1]} : (tensor<1x3x98x98x!FHE.eint<12>>) -> tensor<1x98x98x3x!FHE.eint<12>>
+    %collapsed = tensor.collapse_shape %2 [[0, 1], [2], [3]] : tensor<1x98x98x3x!FHE.eint<12>> into tensor<98x98x3x!FHE.eint<12>>
+    return %collapsed : tensor<98x98x3x!FHE.eint<12>>
+  }
+}

matchers/filter blur/deployment/client.zip

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

matchers/filter blur/deployment/configuration.json

@@ -0,0 +1,22 @@
+{
+    "verbose": false,
+    "show_graph": null,
+    "show_mlir": null,
+    "show_optimizer": null,
+    "dump_artifacts_on_unexpected_failures": true,
+    "enable_unsafe_features": false,
+    "use_insecure_key_cache": false,
+    "insecure_key_cache_location": null,
+    "loop_parallelize": true,
+    "dataflow_parallelize": false,
+    "auto_parallelize": false,
+    "jit": false,
+    "p_error": null,
+    "global_p_error": null,
+    "auto_adjust_rounders": false,
+    "single_precision": true,
+    "parameter_selection_strategy": "mono",
+    "show_progress": false,
+    "progress_title": "",
+    "progress_tag": false
+}

matchers/filter blur/deployment/server.zip

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

matchers/random guessing concrete 1.1.0/deployment/client.zip

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

matchers/random guessing concrete 1.1.0/deployment/server.zip

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

matchers/random guessing/deployment/client.zip

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

matchers/random guessing/deployment/server.zip

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

matchers/random guessing_1.6.1/deployment/circuit.mlir

@@ -0,0 +1,14 @@
+module {
+  func.func @main(%arg0: tensor<1x!FHE.eint<4>>, %arg1: tensor<1x!FHE.eint<4>>) -> tensor<1x!FHE.eint<4>> {
+    %0 = "FHELinalg.sum"(%arg0) {axes = [], keep_dims = false} : (tensor<1x!FHE.eint<4>>) -> !FHE.eint<4>
+    %1 = "FHELinalg.sum"(%arg1) {axes = [], keep_dims = false} : (tensor<1x!FHE.eint<4>>) -> !FHE.eint<4>
+    %cst = arith.constant dense<1> : tensor<1xi2>
+    %from_elements = tensor.from_elements %0 : tensor<1x!FHE.eint<4>>
+    %2 = "FHELinalg.add_eint_int"(%from_elements, %cst) : (tensor<1x!FHE.eint<4>>, tensor<1xi2>) -> tensor<1x!FHE.eint<4>>
+    %3 = "FHELinalg.sub_eint"(%2, %from_elements) : (tensor<1x!FHE.eint<4>>, tensor<1x!FHE.eint<4>>) -> tensor<1x!FHE.eint<4>>
+    %from_elements_0 = tensor.from_elements %1 : tensor<1x!FHE.eint<4>>
+    %4 = "FHELinalg.add_eint"(%3, %from_elements_0) : (tensor<1x!FHE.eint<4>>, tensor<1x!FHE.eint<4>>) -> tensor<1x!FHE.eint<4>>
+    %5 = "FHELinalg.sub_eint"(%4, %from_elements_0) : (tensor<1x!FHE.eint<4>>, tensor<1x!FHE.eint<4>>) -> tensor<1x!FHE.eint<4>>
+    return %5 : tensor<1x!FHE.eint<4>>
+  }
+}

matchers/random guessing_1.6.1/deployment/client.zip

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

matchers/random guessing_1.6.1/deployment/composition_rules.json

@@ -0,0 +1 @@
+null

matchers/random guessing_1.6.1/deployment/configuration.json

@@ -0,0 +1,94 @@
+{
+    "verbose": false,
+    "compiler_debug_mode": false,
+    "compiler_verbose_mode": false,
+    "show_graph": null,
+    "show_bit_width_constraints": null,
+    "show_bit_width_assignments": null,
+    "show_assigned_graph": null,
+    "show_mlir": null,
+    "show_optimizer": null,
+    "show_statistics": null,
+    "dump_artifacts_on_unexpected_failures": true,
+    "enable_unsafe_features": false,
+    "use_insecure_key_cache": false,
+    "insecure_key_cache_location": null,
+    "loop_parallelize": true,
+    "dataflow_parallelize": false,
+    "auto_parallelize": false,
+    "compress_evaluation_keys": false,
+    "compress_input_ciphertexts": false,
+    "p_error": null,
+    "global_p_error": null,
+    "auto_adjust_rounders": false,
+    "auto_adjust_truncators": false,
+    "single_precision": false,
+    "parameter_selection_strategy": {
+        "py/reduce": [
+            {
+                "py/type": "concrete.fhe.compilation.configuration.ParameterSelectionStrategy"
+            },
+            {
+                "py/tuple": [
+                    "multi"
+                ]
+            }
+        ]
+    },
+    "multi_parameter_strategy": {
+        "py/reduce": [
+            {
+                "py/type": "concrete.fhe.compilation.configuration.MultiParameterStrategy"
+            },
+            {
+                "py/tuple": [
+                    "precision"
+                ]
+            }
+        ]
+    },
+    "show_progress": false,
+    "progress_title": "",
+    "progress_tag": false,
+    "fhe_simulation": false,
+    "fhe_execution": true,
+    "comparison_strategy_preference": [],
+    "bitwise_strategy_preference": [],
+    "shifts_with_promotion": true,
+    "multivariate_strategy_preference": [],
+    "min_max_strategy_preference": [],
+    "composable": false,
+    "use_gpu": false,
+    "relu_on_bits_threshold": 7,
+    "relu_on_bits_chunk_size": 3,
+    "if_then_else_chunk_size": 3,
+    "additional_pre_processors": [],
+    "additional_post_processors": [],
+    "rounding_exactness": {
+        "py/reduce": [
+            {
+                "py/type": "concrete.fhe.compilation.configuration.Exactness"
+            },
+            {
+                "py/tuple": [
+                    "exact"
+                ]
+            }
+        ]
+    },
+    "approximate_rounding_config": {
+        "py/object": "concrete.fhe.compilation.configuration.ApproximateRoundingConfig",
+        "logical_clipping": true,
+        "approximate_clipping_start_precision": 5,
+        "reduce_precision_after_approximate_clipping": true,
+        "symetrize_deltas": true
+    },
+    "optimize_tlu_based_on_measured_bounds": false,
+    "enable_tlu_fusing": true,
+    "print_tlu_fusing": false,
+    "optimize_tlu_based_on_original_bit_width": 8,
+    "detect_overflow_in_simulation": false,
+    "dynamic_indexing_check_out_of_bounds": true,
+    "dynamic_assignment_check_out_of_bounds": true,
+    "simulate_encrypt_run_decrypt": false
+}

matchers/random guessing_1.6.1/deployment/is_simulated

@@ -0,0 +1 @@
+0

matchers/random guessing_1.6.1/deployment/server.zip

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

requirements.txt

@@ -1,3 +1,3 @@
-concrete-ml==1.1.0
+concrete-ml==1.6.1
 gradio
 more_itertools

server.py

@@ -5,28 +5,35 @@ from typing import List
 from fastapi import FastAPI, File, Form, UploadFile
 from fastapi.responses import JSONResponse, Response
 
-from common import FILTERS_PATH, SERVER_TMP_PATH, AVAILABLE_FILTERS
+from common import (
+    ENCRYPTED_OUTPUT_NAME,
+    ENCRYPTED_QUERY_NAME,
+    ENCRYPTED_REFERENCE_NAME,
+    MATCHERS_PATH,
+    SERVER_TMP_PATH,
+    AVAILABLE_MATCHERS,
+)
 from client_server_interface import FHEServer
 
-# Load the server objects related to all currently available filters once and for all
+# Load the server objects related to all currently available matchers once and for all
 FHE_SERVERS = {
-    filter: FHEServer(FILTERS_PATH / f"{filter}/deployment")
-    for filter in AVAILABLE_FILTERS
+    matcher: FHEServer(MATCHERS_PATH / f"{matcher}/deployment")
+    for matcher in AVAILABLE_MATCHERS
 }
 
 
-def get_server_file_path(name, user_id, filter_name):
+def get_server_file_path(name, user_id, matcher_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.
-        filter_name (str): The filter chosen by the user
+        matcher_name (str): The matcher chosen by the user
 
     Returns:
         pathlib.Path: The file path.
     """
-    return SERVER_TMP_PATH / f"{name}_{filter_name}_{user_id}"
+    return SERVER_TMP_PATH / f"{name}_{matcher_name}_{user_id}"
 
 
 # Initialize an instance of FastAPI
@@ -42,53 +49,77 @@ def root():
 @app.post("/send_input")
 def send_input(
     user_id: str = Form(),
-    filter: str = Form(),
+    matcher: str = Form(),
     files: List[UploadFile] = File(),
 ):
     """Send the inputs to the server."""
     # Retrieve the encrypted input image and the evaluation key paths
-    encrypted_image_path = get_server_file_path("encrypted_image", user_id, filter)
-    evaluation_key_path = get_server_file_path("evaluation_key", user_id, filter)
+    encrypted_query_image_path = get_server_file_path(
+        ENCRYPTED_QUERY_NAME, user_id, matcher
+    )
+    encrypted_reference_image_path = get_server_file_path(
+        ENCRYPTED_REFERENCE_NAME, user_id, matcher
+    )
+    evaluation_key_path = get_server_file_path("evaluation_key", user_id, matcher)
 
     # Write the files using the above paths
-    with encrypted_image_path.open("wb") as encrypted_image, evaluation_key_path.open(
+    with encrypted_query_image_path.open(
+        "wb"
+    ) as encrypted_query_image_file, encrypted_reference_image_path.open(
+        "wb"
+    ) as encrypted_reference_image_file, evaluation_key_path.open(
         "wb"
     ) as evaluation_key:
-        encrypted_image.write(files[0].file.read())
-        evaluation_key.write(files[1].file.read())
+        encrypted_query_image_file.write(files[0].file.read())
+        encrypted_reference_image_file.write(files[1].file.read())
+        evaluation_key.write(files[2].file.read())
 
 
 @app.post("/run_fhe")
 def run_fhe(
     user_id: str = Form(),
-    filter: str = Form(),
+    matcher: str = Form(),
 ):
-    """Execute the filter on the encrypted input image using FHE."""
+    """Execute the matcher on the encrypted input images using FHE."""
     # Retrieve the encrypted input image and the evaluation key paths
-    encrypted_image_path = get_server_file_path("encrypted_image", user_id, filter)
-    evaluation_key_path = get_server_file_path("evaluation_key", user_id, filter)
+    encrypted_query_image_path = get_server_file_path(
+        "encrypted_query_image", user_id, matcher
+    )
+    encrypted_reference_image_path = get_server_file_path(
+        "encrypted_reference_image", user_id, matcher
+    )
+    evaluation_key_path = get_server_file_path("evaluation_key", user_id, matcher)
 
     # Read the files using the above paths
-    with encrypted_image_path.open(
+    with encrypted_query_image_path.open(
+        "rb"
+    ) as encrypted_query_image_file, encrypted_reference_image_path.open(
+        "rb"
+    ) as encrypted_reference_image_file, evaluation_key_path.open(
         "rb"
-    ) as encrypted_image_file, evaluation_key_path.open("rb") as evaluation_key_file:
-        encrypted_image = encrypted_image_file.read()
+    ) as evaluation_key_file:
+        encrypted_query_image = encrypted_query_image_file.read()
+        encrypted_reference_image = encrypted_reference_image_file.read()
         evaluation_key = evaluation_key_file.read()
 
-    # Load the FHE server related to the chosen filter
-    fhe_server = FHE_SERVERS[filter]
+    # Load the FHE server related to the chosen matcher
+    fhe_server = FHE_SERVERS[matcher]
 
     # Run the FHE execution
     start = time.time()
-    encrypted_output_image = fhe_server.run(encrypted_image, evaluation_key)
+    encrypted_output = fhe_server.run(
+        encrypted_query_image, encrypted_reference_image, evaluation_key
+    )
     fhe_execution_time = round(time.time() - start, 2)
 
-    # Retrieve the encrypted output image path
-    encrypted_output_path = get_server_file_path("encrypted_output", user_id, filter)
+    # Retrieve the encrypted output path
+    encrypted_output_path = get_server_file_path(
+        ENCRYPTED_OUTPUT_NAME, user_id, matcher
+    )
 
     # Write the file using the above path
     with encrypted_output_path.open("wb") as encrypted_output:
-        encrypted_output.write(encrypted_output_image)
+        encrypted_output.write(encrypted_output)
 
     return JSONResponse(content=fhe_execution_time)
 
@@ -96,11 +127,13 @@ def run_fhe(
 @app.post("/get_output")
 def get_output(
     user_id: str = Form(),
-    filter: str = Form(),
+    matcher: str = Form(),
 ):
-    """Retrieve the encrypted output image."""
-    # Retrieve the encrypted output image path
-    encrypted_output_path = get_server_file_path("encrypted_output", user_id, filter)
+    """Retrieve the encrypted output."""
+    # Retrieve the encrypted output path
+    encrypted_output_path = get_server_file_path(
+        ENCRYPTED_OUTPUT_NAME, user_id, matcher
+    )
 
     # Read the file using the above path
     with encrypted_output_path.open("rb") as encrypted_output_file: