Upload 10 files

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.extension filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+.ipynb_checkpoints
+
+.venv
+deployment_files/.*
+deployment_files/client_dir/
+deployment_files/server_dir/

README.md

@@ -1,12 +1,61 @@
----
-title: Health
-emoji: 🏢
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 4.44.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Health Prediction On Encrypted Data Using Fully Homomorphic Encryption
+emoji: 🩺😷
+colorFrom: gray
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: true
+tags:
+  - FHE
+  - PPML
+  - privacy
+  - privacy preserving machine learning
+  - image processing
+  - homomorphic encryption
+  - security
+python_version: 3.10.6
+---
+
+# Healthcare prediction using FHE
+
+## Running the application on your machine
+
+From this directory, i.e., `health_prediction`, you can proceed with the following steps.
+
+### Do once
+
+First, create a virtual env and activate it:
+
+<!--pytest-codeblocks:skip-->
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+Then, install required packages:
+
+<!--pytest-codeblocks:skip-->
+
+```bash
+pip3 install pip --upgrade
+pip3 install -U pip wheel setuptools --ignore-installed
+pip3 install -r requirements.txt --ignore-installed
+```
+
+## Run the following steps each time you relaunch the application
+
+In a terminal, run:
+
+<!--pytest-codeblocks:skip-->
+
+```bash
+source .venv/bin/activate
+python3 app.py
+```
+
+## Interacting with the application
+
+Open the given URL link (search for a line like `Running on local URL:  http://127.0.0.1:8888/`).

app.py

@@ -0,0 +1,771 @@
+import subprocess
+import time
+from typing import Dict, List, Tuple
+
+import gradio as gr  # pylint: disable=import-error
+import numpy as np
+import pandas as pd
+import requests
+from symptoms_categories import SYMPTOMS_LIST
+from utils import (
+    CLIENT_DIR,
+    CURRENT_DIR,
+    DEPLOYMENT_DIR,
+    INPUT_BROWSER_LIMIT,
+    KEYS_DIR,
+    SERVER_URL,
+    TARGET_COLUMNS,
+    TRAINING_FILENAME,
+    clean_directory,
+    get_disease_name,
+    load_data,
+    pretty_print,
+)
+
+from concrete.ml.deployment import FHEModelClient
+
+subprocess.Popen(["uvicorn", "server:app"], cwd=CURRENT_DIR)
+time.sleep(3)
+
+# pylint: disable=c-extension-no-member,invalid-name
+
+
+def is_none(obj) -> bool:
+    """
+    Check if the object is None.
+
+    Args:
+        obj (any): The input to be checked.
+
+    Returns:
+        bool: True if the object is None or empty, False otherwise.
+    """
+    return obj is None or (obj is not None and len(obj) < 1)
+
+
+def display_default_symptoms_fn(default_disease: str) -> Dict:
+    """
+    Displays the symptoms of a given existing disease.
+
+    Args:
+        default_disease (str): Disease
+    Returns:
+        Dict: The according symptoms
+    """
+    df = pd.read_csv(TRAINING_FILENAME)
+    df_filtred = df[df[TARGET_COLUMNS[1]] == default_disease]
+
+    return {
+        default_symptoms: gr.update(
+            visible=True,
+            value=pretty_print(
+                df_filtred.columns[df_filtred.eq(1).any()].to_list(), delimiter=", "
+            ),
+        )
+    }
+
+
+def get_user_symptoms_from_checkboxgroup(checkbox_symptoms: List) -> np.array:
+    """
+    Convert the user symptoms into a binary vector representation.
+
+    Args:
+        checkbox_symptoms (List): A list of user symptoms.
+
+    Returns:
+        np.array: A binary vector representing the user's symptoms.
+
+    Raises:
+        KeyError: If a provided symptom is not recognized as a valid symptom.
+
+    """
+    symptoms_vector = {key: 0 for key in valid_symptoms}
+    for pretty_symptom in checkbox_symptoms:
+        original_symptom = "_".join((pretty_symptom.lower().split(" ")))
+        if original_symptom not in symptoms_vector.keys():
+            raise KeyError(
+                f"The symptom '{original_symptom}' you provided is not recognized as a valid "
+                f"symptom.\nHere is the list of valid symptoms: {symptoms_vector}"
+            )
+        symptoms_vector[original_symptom] = 1
+
+    user_symptoms_vect = np.fromiter(symptoms_vector.values(), dtype=float)[np.newaxis, :]
+
+    assert all(value == 0 or value == 1 for value in user_symptoms_vect.flatten())
+
+    return user_symptoms_vect
+
+
+def get_features_fn(*checked_symptoms: Tuple[str]) -> Dict:
+    """
+    Get vector features based on the selected symptoms.
+
+    Args:
+        checked_symptoms (Tuple[str]): User symptoms
+
+    Returns:
+        Dict: The encoded user vector symptoms.
+    """
+    if not any(lst for lst in checked_symptoms if lst):
+        return {
+            error_box1: gr.update(visible=True, value="⚠️ Please provide your chief complaints."),
+        }
+
+    if len(pretty_print(checked_symptoms)) < 5:
+        print("Provide at least 5 symptoms.")
+        return {
+            error_box1: gr.update(visible=True, value="⚠️ Provide at least 5 symptoms"),
+            one_hot_vect: None,
+        }
+
+    return {
+        error_box1: gr.update(visible=False),
+        one_hot_vect: gr.update(
+            visible=False,
+            value=get_user_symptoms_from_checkboxgroup(pretty_print(checked_symptoms)),
+        ),
+        submit_btn: gr.update(value="Data submitted ✅"),
+    }
+
+
+def key_gen_fn(user_symptoms: List[str]) -> Dict:
+    """
+    Generate keys for a given user.
+
+    Args:
+        user_symptoms (List[str]): The vector symptoms provided by the user.
+
+    Returns:
+        dict: A dictionary containing the generated keys and related information.
+
+    """
+    clean_directory()
+
+    if is_none(user_symptoms):
+        print("Error: Please submit your symptoms or select a default disease.")
+        return {
+            error_box2: gr.update(visible=True, value="⚠️ Please submit your symptoms first."),
+        }
+
+    # Generate a random user ID
+    user_id = np.random.randint(0, 2**32)
+    print(f"Your user ID is: {user_id}....")
+
+    client = FHEModelClient(path_dir=DEPLOYMENT_DIR, key_dir=KEYS_DIR / f"{user_id}")
+    client.load()
+
+    # Creates the private and evaluation keys on the client side
+    client.generate_private_and_evaluation_keys()
+
+    # Get the serialized evaluation keys
+    serialized_evaluation_keys = client.get_serialized_evaluation_keys()
+    assert isinstance(serialized_evaluation_keys, bytes)
+
+    # Save the evaluation key
+    evaluation_key_path = KEYS_DIR / f"{user_id}/evaluation_key"
+    with evaluation_key_path.open("wb") as f:
+        f.write(serialized_evaluation_keys)
+
+    serialized_evaluation_keys_shorten_hex = serialized_evaluation_keys.hex()[:INPUT_BROWSER_LIMIT]
+
+    return {
+        error_box2: gr.update(visible=False),
+        key_box: gr.update(visible=False, value=serialized_evaluation_keys_shorten_hex),
+        user_id_box: gr.update(visible=False, value=user_id),
+        key_len_box: gr.update(
+            visible=False, value=f"{len(serialized_evaluation_keys) / (10**6):.2f} MB"
+        ),
+        gen_key_btn: gr.update(value="Keys have been generated ✅")
+    }
+
+
+def encrypt_fn(user_symptoms: np.ndarray, user_id: str) -> None:
+    """
+    Encrypt the user symptoms vector in the `Client Side`.
+
+    Args:
+        user_symptoms (List[str]): The vector symptoms provided by the user
+        user_id (user): The current user's ID
+    """
+
+    if is_none(user_id) or is_none(user_symptoms):
+        print("Error in encryption step: Provide your symptoms and generate the evaluation keys.")
+        return {
+            error_box3: gr.update(
+                visible=True,
+                value="⚠️ Please ensure that your symptoms have been submitted and "
+                "that you have generated the evaluation key.",
+            )
+        }
+
+    # Retrieve the client API
+    client = FHEModelClient(path_dir=DEPLOYMENT_DIR, key_dir=KEYS_DIR / f"{user_id}")
+    client.load()
+
+    user_symptoms = np.fromstring(user_symptoms[2:-2], dtype=int, sep=".").reshape(1, -1)
+    # quant_user_symptoms = client.model.quantize_input(user_symptoms)
+
+    encrypted_quantized_user_symptoms = client.quantize_encrypt_serialize(user_symptoms)
+    assert isinstance(encrypted_quantized_user_symptoms, bytes)
+    encrypted_input_path = KEYS_DIR / f"{user_id}/encrypted_input"
+
+    with encrypted_input_path.open("wb") as f:
+        f.write(encrypted_quantized_user_symptoms)
+
+    encrypted_quantized_user_symptoms_shorten_hex = encrypted_quantized_user_symptoms.hex()[
+        :INPUT_BROWSER_LIMIT
+    ]
+
+    return {
+        error_box3: gr.update(visible=False),
+        one_hot_vect_box: gr.update(visible=True, value=user_symptoms),
+        enc_vect_box: gr.update(visible=True, value=encrypted_quantized_user_symptoms_shorten_hex),
+    }
+
+
+def send_input_fn(user_id: str, user_symptoms: np.ndarray) -> Dict:
+    """Send the encrypted data and the evaluation key to the server.
+
+    Args:
+        user_id (str): The current user's ID
+        user_symptoms (np.ndarray): The user symptoms
+    """
+
+    if is_none(user_id) or is_none(user_symptoms):
+        return {
+            error_box4: gr.update(
+                visible=True,
+                value="⚠️ Please check your connectivity \n"
+                "⚠️ Ensure that the symptoms have been submitted and the evaluation "
+                "key has been generated before sending the data to the server.",
+            )
+        }
+
+    evaluation_key_path = KEYS_DIR / f"{user_id}/evaluation_key"
+    encrypted_input_path = KEYS_DIR / f"{user_id}/encrypted_input"
+
+    if not evaluation_key_path.is_file():
+        print(
+            "Error Encountered While Sending Data to the Server: "
+            f"The key has been generated correctly - {evaluation_key_path.is_file()=}"
+        )
+
+        return {
+            error_box4: gr.update(visible=True, value="⚠️ Please generate the private key first.")
+        }
+
+    if not encrypted_input_path.is_file():
+        print(
+            "Error Encountered While Sending Data to the Server: The data has not been encrypted "
+            f"correctly on the client side - {encrypted_input_path.is_file()=}"
+        )
+        return {
+            error_box4: gr.update(
+                visible=True,
+                value="⚠️ Please encrypt the data with the private key first.",
+            ),
+        }
+
+    # Define the data and files to post
+    data = {
+        "user_id": user_id,
+        "input": user_symptoms,
+    }
+
+    files = [
+        ("files", open(encrypted_input_path, "rb")),
+        ("files", open(evaluation_key_path, "rb")),
+    ]
+
+    # Send the encrypted input and evaluation key to the server
+    url = SERVER_URL + "send_input"
+    with requests.post(
+        url=url,
+        data=data,
+        files=files,
+    ) as response:
+        print(f"Sending Data: {response.ok=}")
+    return {
+        error_box4: gr.update(visible=False),
+        srv_resp_send_data_box: "Data sent",
+    }
+
+
+def run_fhe_fn(user_id: str) -> Dict:
+    """Send the encrypted input and the evaluation key to the server.
+
+    Args:
+        user_id (int): The current user's ID.
+    """
+    if is_none(user_id):
+        return {
+            error_box5: gr.update(
+                visible=True,
+                value="⚠️ Please check your connectivity \n"
+                "⚠️ Ensure that the symptoms have been submitted, the evaluation "
+                "key has been generated and the server received the data "
+                "before processing the data.",
+            ),
+            fhe_execution_time_box: None,
+        }
+
+    data = {
+        "user_id": user_id,
+    }
+
+    url = SERVER_URL + "run_fhe"
+
+    with requests.post(
+        url=url,
+        data=data,
+    ) as response:
+        if not response.ok:
+            return {
+                error_box5: gr.update(
+                    visible=True,
+                    value=(
+                        "⚠️ An error occurred on the Server Side. "
+                        "Please check connectivity and data transmission."
+                    ),
+                ),
+                fhe_execution_time_box: gr.update(visible=False),
+            }
+        else:
+            time.sleep(1)
+            print(f"response.ok: {response.ok}, {response.json()} - Computed")
+
+    return {
+        error_box5: gr.update(visible=False),
+        fhe_execution_time_box: gr.update(visible=True, value=f"{response.json():.2f} seconds"),
+    }
+
+
+def get_output_fn(user_id: str, user_symptoms: np.ndarray) -> Dict:
+    """Retreive the encrypted data from the server.
+
+    Args:
+        user_id (str): The current user's ID
+        user_symptoms (np.ndarray): The user symptoms
+    """
+
+    if is_none(user_id) or is_none(user_symptoms):
+        return {
+            error_box6: gr.update(
+                visible=True,
+                value="⚠️ Please check your connectivity \n"
+                "⚠️ Ensure that the server has successfully processed and transmitted the data to the client.",
+            )
+        }
+
+    data = {
+        "user_id": user_id,
+    }
+
+    # Retrieve the encrypted output
+    url = SERVER_URL + "get_output"
+    with requests.post(
+        url=url,
+        data=data,
+    ) as response:
+        if response.ok:
+            print(f"Receive Data: {response.ok=}")
+
+            encrypted_output = response.content
+
+            # 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 = CLIENT_DIR / f"{user_id}_encrypted_output"
+
+            with encrypted_output_path.open("wb") as f:
+                f.write(encrypted_output)
+    return {error_box6: gr.update(visible=False), srv_resp_retrieve_data_box: "Data received"}
+
+
+def decrypt_fn(
+    user_id: str, user_symptoms: np.ndarray, *checked_symptoms, threshold: int = 0.5
+) -> Dict:
+    """Dencrypt the data on the `Client Side`.
+
+    Args:
+        user_id (str): The current user's ID
+        user_symptoms (np.ndarray): The user symptoms
+        threshold (float): Probability confidence threshold
+
+    Returns:
+        Decrypted output
+    """
+
+    if is_none(user_id) or is_none(user_symptoms):
+        return {
+            error_box7: gr.update(
+                visible=True,
+                value="⚠️ Please check your connectivity \n"
+                "⚠️ Ensure that the client has successfully received the data from the server.",
+            )
+        }
+
+    # Get the encrypted output path
+    encrypted_output_path = CLIENT_DIR / f"{user_id}_encrypted_output"
+
+    if not encrypted_output_path.is_file():
+        print("Error in decryption step: Please run the FHE execution, first.")
+        return {
+            error_box7: gr.update(
+                visible=True,
+                value="⚠️ Please ensure that: \n"
+                "- the connectivity \n"
+                "- the symptoms have been submitted \n"
+                "- the evaluation key has been generated \n"
+                "- the server processed the encrypted data \n"
+                "- the Client received the data from the Server before decrypting the prediction",
+            ),
+            decrypt_box: None,
+        }
+
+    # Load the encrypted output as bytes
+    with encrypted_output_path.open("rb") as f:
+        encrypted_output = f.read()
+
+    # Retrieve the client API
+    client = FHEModelClient(path_dir=DEPLOYMENT_DIR, key_dir=KEYS_DIR / f"{user_id}")
+    client.load()
+
+    # Deserialize, decrypt and post-process the encrypted output
+    output = client.deserialize_decrypt_dequantize(encrypted_output)
+
+    top3_diseases = np.argsort(output.flatten())[-3:][::-1]
+    top3_proba = output[0][top3_diseases]
+
+    out = ""
+
+    if top3_proba[0] < threshold or abs(top3_proba[0] - top3_proba[1]) < 0.1:
+        out = (
+            "⚠️ The prediction appears uncertain; including more symptoms "
+            "may improve the results.\n\n"
+        )
+
+    out = (
+        f"{out}Given the symptoms you provided: "
+        f"{pretty_print(checked_symptoms, case_conversion=str.capitalize, delimiter=', ')}\n\n"
+        "Here are the top3 predictions:\n\n"
+        f"1. « {get_disease_name(top3_diseases[0])} » with a probability of {top3_proba[0]:.2%}\n"
+        f"2. « {get_disease_name(top3_diseases[1])} » with a probability of {top3_proba[1]:.2%}\n"
+        f"3. « {get_disease_name(top3_diseases[2])} » with a probability of {top3_proba[2]:.2%}\n"
+    )
+
+    return {
+        error_box7: gr.update(visible=False),
+        decrypt_box: out,
+        submit_btn: gr.update(value="Submit"),
+    }
+
+
+def reset_fn():
+    """Reset the space and clear all the box outputs."""
+
+    clean_directory()
+
+    return {
+        one_hot_vect: None,
+        one_hot_vect_box: None,
+        enc_vect_box: gr.update(visible=True, value=None),
+        quant_vect_box: gr.update(visible=False, value=None),
+        user_id_box: gr.update(visible=False, value=None),
+        default_symptoms: gr.update(visible=True, value=None),
+        default_disease_box: gr.update(visible=True, value=None),
+        key_box: gr.update(visible=True, value=None),
+        key_len_box: gr.update(visible=False, value=None),
+        fhe_execution_time_box: gr.update(visible=True, value=None),
+        decrypt_box: None,
+        submit_btn: gr.update(value="Submit"),
+        error_box7: gr.update(visible=False),
+        error_box1: gr.update(visible=False),
+        error_box2: gr.update(visible=False),
+        error_box3: gr.update(visible=False),
+        error_box4: gr.update(visible=False),
+        error_box5: gr.update(visible=False),
+        error_box6: gr.update(visible=False),
+        srv_resp_send_data_box: None,
+        srv_resp_retrieve_data_box: None,
+        **{box: None for box in check_boxes},
+    }
+
+
+if __name__ == "__main__":
+
+    print("Starting demo ...")
+
+    clean_directory()
+
+    (X_train, X_test), (y_train, y_test), valid_symptoms, diseases = load_data()
+
+    with gr.Blocks() as demo:
+
+        # Link + images
+        gr.Markdown()
+        gr.Markdown(
+            """
+            <p align="center">
+                <img width=200 src="https://user-images.githubusercontent.com/5758427/197816413-d9cddad3-ba38-4793-847d-120975e1da11.png">
+            </p>
+            """)
+        gr.Markdown()
+        gr.Markdown("""<h2 align="center">Health Prediction On Encrypted Data Using Fully Homomorphic Encryption</h2>""")
+        gr.Markdown()
+        gr.Markdown(
+            """
+            <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>
+                —
+                <a href="https://docs.zama.ai/concrete-ml"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="https://user-images.githubusercontent.com/5758427/197976802-fddd34c5-f59a-48d0-9bff-7ad1b00cb1fb.png">Documentation</a>
+                —
+                <a href="https://zama.ai/community"> <img style="vertical-align: middle; display:inline-block; margin-right: 3px;" width=15 src="https://user-images.githubusercontent.com/5758427/197977153-8c9c01a7-451a-4993-8e10-5a6ed5343d02.png">Community</a>
+                —
+                <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>
+            """)
+        gr.Markdown()
+        gr.Markdown(
+            """"
+            <p align="center">
+            <img width="65%" height="25%" src="https://raw.githubusercontent.com/kcelia/Img/main/healthcare_prediction.jpg">
+            </p>
+            """
+        )
+        gr.Markdown("## Notes")
+        gr.Markdown(
+            """
+            - The private key is used to encrypt and decrypt the data and shall never be shared.
+            - The evaluation key is a public key that the server needs to process encrypted data.
+            """
+        )
+
+        # ------------------------- Step 1 -------------------------
+        gr.Markdown("\n")
+        gr.Markdown("## Step 1: Select chief complaints")
+        gr.Markdown("<hr />")
+        gr.Markdown("<span style='color:grey'>Client Side</span>")
+        gr.Markdown("Select at least 5 chief complaints from the list below.")
+
+        # Step 1.1: Provide symptoms
+        check_boxes = []
+        with gr.Row():
+            with gr.Column():
+                for category in SYMPTOMS_LIST[:3]:
+                    with gr.Accordion(pretty_print(category.keys()), open=False):
+                        check_box = gr.CheckboxGroup(pretty_print(category.values()), show_label=0)
+                        check_boxes.append(check_box)
+            with gr.Column():
+                for category in SYMPTOMS_LIST[3:6]:
+                    with gr.Accordion(pretty_print(category.keys()), open=False):
+                        check_box = gr.CheckboxGroup(pretty_print(category.values()), show_label=0)
+                        check_boxes.append(check_box)
+            with gr.Column():
+                for category in SYMPTOMS_LIST[6:]:
+                    with gr.Accordion(pretty_print(category.keys()), open=False):
+                        check_box = gr.CheckboxGroup(pretty_print(category.values()), show_label=0)
+                        check_boxes.append(check_box)
+
+        error_box1 = gr.Textbox(label="Error ❌", visible=False)
+
+        # Default disease, picked from the dataframe
+        gr.Markdown(
+            "You can choose an **existing disease** and explore its associated symptoms.",
+            visible=False,
+        )
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                default_disease_box = gr.Dropdown(sorted(diseases), label="Diseases", visible=False)
+            with gr.Column(scale=5):
+                default_symptoms = gr.Textbox(label="Related Symptoms:", visible=False)
+        # User vector symptoms encoded in oneHot representation
+        one_hot_vect = gr.Textbox(visible=False)
+        # Submit botton
+        submit_btn = gr.Button("Submit")
+        # Clear botton
+        clear_button = gr.Button("Reset Space 🔁", visible=False)
+
+        default_disease_box.change(
+            fn=display_default_symptoms_fn, inputs=[default_disease_box], outputs=[default_symptoms]
+        )
+
+        submit_btn.click(
+            fn=get_features_fn,
+            inputs=[*check_boxes],
+            outputs=[one_hot_vect, error_box1, submit_btn],
+        )
+
+        # ------------------------- Step 2 -------------------------
+        gr.Markdown("\n")
+        gr.Markdown("## Step 2: Encrypt data")
+        gr.Markdown("<hr />")
+        gr.Markdown("<span style='color:grey'>Client Side</span>")
+        # Step 2.1: Key generation
+        gr.Markdown(
+            "### Key Generation\n\n"
+            "In FHE schemes, a secret (enc/dec)ryption keys are generated for encrypting and decrypting data owned by the client. \n\n"
+            "Additionally, a public evaluation key is generated, enabling external entities to perform homomorphic operations on encrypted data, without the need to decrypt them. \n\n"
+            "The evaluation key will be transmitted to the server for further processing."
+        )
+
+        gen_key_btn = gr.Button("Generate the private and evaluation keys.")
+        error_box2 = gr.Textbox(label="Error ❌", visible=False)
+        user_id_box = gr.Textbox(label="User ID:", visible=False)
+        key_len_box = gr.Textbox(label="Evaluation Key Size:", visible=False)
+        key_box = gr.Textbox(label="Evaluation key (truncated):", max_lines=3, visible=False)
+
+        gen_key_btn.click(
+            key_gen_fn,
+            inputs=one_hot_vect,
+            outputs=[
+                key_box,
+                user_id_box,
+                key_len_box,
+                error_box2,
+                gen_key_btn,
+            ],
+        )
+
+        # Step 2.2: Encrypt data locally
+        gr.Markdown("### Encrypt the data")
+        encrypt_btn = gr.Button("Encrypt the data using the private secret key")
+        error_box3 = gr.Textbox(label="Error ❌", visible=False)
+        quant_vect_box = gr.Textbox(label="Quantized Vector:", visible=False)
+
+        with gr.Row():
+            with gr.Column():
+                one_hot_vect_box = gr.Textbox(label="User Symptoms Vector:", max_lines=10)
+            with gr.Column():
+                enc_vect_box = gr.Textbox(label="Encrypted Vector:", max_lines=10)
+
+        encrypt_btn.click(
+            encrypt_fn,
+            inputs=[one_hot_vect, user_id_box],
+            outputs=[
+                one_hot_vect_box,
+                enc_vect_box,
+                error_box3,
+            ],
+        )
+        # Step 2.3: Send encrypted data to the server
+        gr.Markdown(
+            "### Send the encrypted data to the <span style='color:grey'>Server Side</span>"
+        )
+        error_box4 = gr.Textbox(label="Error ❌", visible=False)
+
+        # with gr.Row().style(equal_height=False):
+        with gr.Row():
+            with gr.Column(scale=4):
+                send_input_btn = gr.Button("Send data")
+            with gr.Column(scale=1):
+                srv_resp_send_data_box = gr.Checkbox(label="Data Sent", show_label=False)
+
+        send_input_btn.click(
+            send_input_fn,
+            inputs=[user_id_box, one_hot_vect],
+            outputs=[error_box4, srv_resp_send_data_box],
+        )
+
+        # ------------------------- Step 3 -------------------------
+        gr.Markdown("\n")
+        gr.Markdown("## Step 3: Run the FHE evaluation")
+        gr.Markdown("<hr />")
+        gr.Markdown("<span style='color:grey'>Server Side</span>")
+        gr.Markdown(
+            "Once the server receives the encrypted data, it can process and compute the output without ever decrypting the data just as it would on clear data.\n\n"
+            "This server employs a [Logistic Regression](https://github.com/zama-ai/concrete-ml/tree/release/1.1.x/use_case_examples/disease_prediction) model that has been trained on this [data-set](https://github.com/anujdutt9/Disease-Prediction-from-Symptoms/tree/master/dataset)."
+        )
+
+        run_fhe_btn = gr.Button("Run the FHE evaluation")
+        error_box5 = gr.Textbox(label="Error ❌", visible=False)
+        fhe_execution_time_box = gr.Textbox(label="Total FHE Execution Time:", visible=True)
+        run_fhe_btn.click(
+            run_fhe_fn,
+            inputs=[user_id_box],
+            outputs=[fhe_execution_time_box, error_box5],
+        )
+
+        # ------------------------- Step 4 -------------------------
+        gr.Markdown("\n")
+        gr.Markdown("## Step 4: Decrypt the data")
+        gr.Markdown("<hr />")
+        gr.Markdown("<span style='color:grey'>Client Side</span>")
+        gr.Markdown(
+            "### Get the encrypted data from the <span style='color:grey'>Server Side</span>"
+        )
+
+        error_box6 = gr.Textbox(label="Error ❌", visible=False)
+
+        # Step 4.1: Data transmission
+        # with gr.Row().style(equal_height=True):
+        with gr.Row():
+            with gr.Column(scale=4):
+                get_output_btn = gr.Button("Get data")
+            with gr.Column(scale=1):
+                srv_resp_retrieve_data_box = gr.Checkbox(label="Data Received", show_label=False)
+
+        get_output_btn.click(
+            get_output_fn,
+            inputs=[user_id_box, one_hot_vect],
+            outputs=[srv_resp_retrieve_data_box, error_box6],
+        )
+
+        # Step 4.1: Data transmission
+        gr.Markdown("### Decrypt the output")
+        decrypt_btn = gr.Button("Decrypt the output using the private secret key")
+        error_box7 = gr.Textbox(label="Error ❌", visible=False)
+        decrypt_box = gr.Textbox(label="Decrypted Output:")
+
+        decrypt_btn.click(
+            decrypt_fn,
+            inputs=[user_id_box, one_hot_vect, *check_boxes],
+            outputs=[decrypt_box, error_box7, submit_btn],
+        )
+
+        # ------------------------- End -------------------------
+
+        gr.Markdown(
+            """The app was built with [Concrete ML](https://github.com/zama-ai/concrete-ml), a Privacy-Preserving Machine Learning (PPML) open-source set of tools by Zama. 
+            Try it yourself and don't forget to star on [Github](https://github.com/zama-ai/concrete-ml) ⭐.
+            """
+        )
+
+        gr.Markdown("\n\n")
+
+        gr.Markdown(
+            """**Please Note**: This space is intended solely for educational and demonstration purposes. 
+           It should not be considered as a replacement for professional medical counsel, diagnosis, or therapy for any health or related issues. 
+           Any questions or concerns about your individual health should be addressed to your doctor or another qualified healthcare provider.
+            """
+        )
+
+        clear_button.click(
+            reset_fn,
+            outputs=[
+                one_hot_vect_box,
+                one_hot_vect,
+                submit_btn,
+                error_box1,
+                error_box2,
+                error_box3,
+                error_box4,
+                error_box5,
+                error_box6,
+                error_box7,
+                default_disease_box,
+                default_symptoms,
+                user_id_box,
+                key_len_box,
+                key_box,
+                quant_vect_box,
+                enc_vect_box,
+                srv_resp_send_data_box,
+                srv_resp_retrieve_data_box,
+                fhe_execution_time_box,
+                decrypt_box,
+                *check_boxes,
+            ],
+        )
+
+        demo.launch()

dev.py

@@ -0,0 +1,52 @@
+"""Generating deployment files."""
+
+import shutil
+
+from pathlib import Path
+
+import pandas as pd
+
+from concrete.ml.sklearn import LogisticRegression as ConcreteLogisticRegression
+from concrete.ml.deployment import FHEModelDev
+
+
+# Data files location
+TRAINING_FILE_NAME = "./data/Training_preprocessed.csv"
+TESTING_FILE_NAME = "./data/Testing_preprocessed.csv"
+
+# Load data
+df_train = pd.read_csv(TRAINING_FILE_NAME)
+df_test = pd.read_csv(TESTING_FILE_NAME)
+
+# Split the data into X_train, y_train, X_test_, y_test sets
+TARGET_COLUMN = ["prognosis_encoded", "prognosis"]
+
+y_train = df_train[TARGET_COLUMN[0]].values.flatten()
+y_test = df_test[TARGET_COLUMN[0]].values.flatten()
+
+X_train = df_train.drop(TARGET_COLUMN, axis=1)
+X_test = df_test.drop(TARGET_COLUMN, axis=1)
+
+# Concrete ML model
+
+# Models parameters
+optimal_param = {"C": 0.9, "n_bits": 13, "solver": "sag", "multi_class": "auto"}
+
+clf = ConcreteLogisticRegression(**optimal_param)
+
+# Fit the model
+clf.fit(X_train, y_train)
+
+# Compile the model
+fhe_circuit = clf.compile(X_train)
+
+fhe_circuit.client.keygen(force=False)
+
+path_to_model = Path("./deployment_files/").resolve()
+
+if path_to_model.exists():
+    shutil.rmtree(path_to_model)
+
+dev = FHEModelDev(path_to_model, clf)
+
+dev.save(via_mlir=True)

requirements.txt

@@ -0,0 +1,4 @@
+concrete-ml==1.4.0
+gradio
+uvicorn>=0.21.0
+fastapi>=0.93.0

server.py

@@ -0,0 +1,100 @@
+"""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 utils import DEPLOYMENT_DIR, SERVER_DIR  # pylint: disable=no-name-in-module
+
+from concrete.ml.deployment import FHEModelServer
+
+# Load the FHE server
+FHE_SERVER = FHEModelServer(DEPLOYMENT_DIR)
+
+# Initialize an instance of FastAPI
+app = FastAPI()
+
+# Define the default route
+@app.get("/")
+def root():
+    """
+    Root endpoint of the health prediction API.
+
+    Returns:
+        dict: The welcome message.
+    """
+    return {"message": "Welcome to your disease prediction with FHE!"}
+
+
+@app.post("/send_input")
+def send_input(
+    user_id: str = Form(),
+    files: List[UploadFile] = File(),
+):
+    """Send the inputs to the server."""
+
+    print("\nSend the data to the server ............\n")
+
+    # Receive the Client's files (Evaluation key + Encrypted symptoms)
+    evaluation_key_path = SERVER_DIR / f"{user_id}_valuation_key"
+    encrypted_input_path = SERVER_DIR / f"{user_id}_encrypted_input"
+
+    # Save the files using the above paths
+    with encrypted_input_path.open("wb") as encrypted_input, evaluation_key_path.open(
+        "wb"
+    ) as evaluation_key:
+        encrypted_input.write(files[0].file.read())
+        evaluation_key.write(files[1].file.read())
+
+
+@app.post("/run_fhe")
+def run_fhe(
+    user_id: str = Form(),
+):
+    """Inference in FHE."""
+
+    print("\nRun in FHE in the server ............\n")
+    evaluation_key_path = SERVER_DIR / f"{user_id}_valuation_key"
+    encrypted_input_path = SERVER_DIR / f"{user_id}_encrypted_input"
+
+    # Read the files (Evaluation key + Encrypted symptoms) using the above paths
+    with encrypted_input_path.open("rb") as encrypted_output_file, evaluation_key_path.open(
+        "rb"
+    ) as evaluation_key_file:
+        encrypted_output = encrypted_output_file.read()
+        evaluation_key = evaluation_key_file.read()
+
+    # Run the FHE execution
+    start = time.time()
+    encrypted_output = FHE_SERVER.run(encrypted_output, evaluation_key)
+    assert isinstance(encrypted_output, bytes)
+    fhe_execution_time = round(time.time() - start, 2)
+
+    # Retrieve the encrypted output path
+    encrypted_output_path = SERVER_DIR / f"{user_id}_encrypted_output"
+
+    # Write the file using the above path
+    with encrypted_output_path.open("wb") as f:
+        f.write(encrypted_output)
+
+    return JSONResponse(content=fhe_execution_time)
+
+
+@app.post("/get_output")
+def get_output(user_id: str = Form()):
+    """Retrieve the encrypted output from the server."""
+
+    print("\nGet the output from the server ............\n")
+
+    # Path where the encrypted output is saved
+    encrypted_output_path = SERVER_DIR / f"{user_id}_encrypted_output"
+
+    # Read the file using the above path
+    with encrypted_output_path.open("rb") as f:
+        encrypted_output = f.read()
+
+    time.sleep(1)
+
+    # Send the encrypted output
+    return Response(encrypted_output)

symptoms_categories.py

@@ -0,0 +1,197 @@
+"""
+In this file, we roughly split up a list of symptoms, taken from "./training.csv" file, avalaible
+through: "https://github.com/anujdutt9/Disease-Prediction-from-Symptoms/tree/master/dataset"
+into medical categories, in order to make the UI more plesant for the users.
+
+Each variable contains a list of symptoms sthat can be pecific to a part of the body or to a list
+of similar symptoms.
+"""
+
+
+DIGESTIVE_SYSTEM_SYMPTOMS = {
+    "DIGESTIVE_SYSTEM_CONCERNS": [
+        "stomach_pain",
+        "acidity",
+        "vomiting",
+        "indigestion",
+        "constipation",
+        "abdominal_pain",
+        "diarrhea",
+        "nausea",
+        "distention_of_abdomen",
+        "stomach_bleeding",
+        "pain_during_bowel_movements",
+        "passage_of_gases",
+        "red_spots_over_body",
+        "swelling_of_stomach",
+        "bloody_stool",
+        "irritation_in_anus",
+        "pain_in_anal_region",
+        "abnormal_menstruation",
+    ]
+}
+
+DERMATOLOGICAL_SYMPTOMS = {
+    "DERMATOLOGICAL_CONCERNS": [
+        "itching",
+        "skin_rash",
+        "pus_filled_pimples",
+        "blackheads",
+        "scurving",
+        "skin_peeling",
+        "silver_like_dusting",
+        "small_dents_in_nails",
+        "inflammatory_nails",
+        "blister",
+        "red_sore_around_nose",
+        "bruising",
+        "yellow_crust_ooze",
+        "dischromic_patches",
+        "nodal_skin_eruptions",
+        "toxic_look_(typhus)",
+        "brittle_nails",
+        "yellowish_skin",
+    ]
+}
+
+ORL_SYMPTOMS = {
+    "ORL_CONCERNS": [
+        "loss_of_smell",
+        "continuous_sneezing",
+        "runny_nose",
+        "patches_in_throat",
+        "throat_irritation",
+        "sinus_pressure",
+        "enlarged_thyroid",
+        "loss_of_balance",
+        "unsteadiness",
+        "dizziness",
+        "spinning_movements",
+    ]
+}
+
+THORAX_SYMPTOMS = {
+    "THORAX_CONCERNS": [
+        "breathlessness",
+        "chest_pain",
+        "cough",
+        "rusty_sputum",
+        "phlegm",
+        "mucoid_sputum",
+        "congestion",
+        "blood_in_sputum",
+        "fast_heart_rate",
+    ]
+}
+
+OPHTHALMOLOGICAL_SYMPTOMS = {
+    "OPHTHALMOLOGICAL_CONCERNS": [
+        "sunken_eyes",
+        "redness_of_eyes",
+        "watering_from_eyes",
+        "blurred_and_distorted_vision",
+        "pain_behind_the_eyes",
+        "visual_disturbances",
+    ]
+}
+
+VASCULAR_LYMPHATIC_SYMPTOMS = {
+    "VASCULAR_AND_LYMPHATIC_CONCERNS": [
+        "cold_hands_and_feets",
+        "swollen_blood_vessels",
+        "swollen_legs",
+        "swelled_lymph_nodes",
+        "palpitations",
+        "prominent_veins_on_calf",
+        "yellowing_of_eyes",
+        "puffy_face_and_eyes",
+        "severe_fluid_overload",
+        "swollen_extremeties",
+    ]
+}
+
+UROLOGICAL_SYMPTOMS = {
+    "UROLOGICAL_CONCERNS": [
+        "burning_micturition",
+        "spotting_urination",
+        "yellow_urine",
+        "bladder_discomfort",
+        "foul_smell_of_urine",
+        "continuous_feel_of_urine",
+        "polyuria",
+        "dark_urine",
+    ]
+}
+
+MUSCULOSKELETAL_SYMPTOMS = {
+    "MUSCULOSKELETAL_CONCERNS": [
+        "joint_pain",
+        "muscle_wasting",
+        "muscle_pain",
+        "muscle_weakness",
+        "knee_pain",
+        "stiff_neck",
+        "swelling_joints",
+        "movement_stiffness",
+        "hip_joint_pain",
+        "painful_walking",
+        "weakness_of_one_body_side",
+        "neck_pain",
+        "back_pain",
+        "weakness_in_limbs",
+        "cramps",
+    ]
+}
+
+GENERAL_SYMPTOMS = {
+    "GENERAL_CONCERNS": [
+        "acute_liver_failure",
+        "anxiety",
+        "restlessness",
+        "lethargy",
+        "mood_swings",
+        "irritability",
+        "lack_of_concentration",
+        "fatigue",
+        "malaise",
+        "weight_gain",
+        "increased_appetite",
+        "weight_loss",
+        "loss_of_appetite",
+        "excess_body_fat",
+        "excessive_hunger",
+        "ulcers_on_tongue",
+        "shivering",
+        "chills",
+        "irregular_sugar_level",
+        "high_fever",
+        "slurred_speech",
+        "sweating",
+        "internal_itching",
+        "mild_fever",
+        "dehydration",
+        "headache",
+        "frequent_unprotected_sexual_intercourse_with_multiple_partners",
+        "drying_and_tingling_lips",
+        "altered_sensorium",
+        "family_history",
+        "receiving_blood_transfusion",
+        "receiving_unsterile_injections",
+        "chronic_alcohol_abuse",
+    ]
+}
+
+SYMPTOMS_LIST = [
+    # Column 1
+    DIGESTIVE_SYSTEM_SYMPTOMS,
+    UROLOGICAL_SYMPTOMS,
+    VASCULAR_LYMPHATIC_SYMPTOMS,
+    # Column 2
+    ORL_SYMPTOMS,
+    DERMATOLOGICAL_SYMPTOMS,
+    MUSCULOSKELETAL_SYMPTOMS,
+    # Column 3
+    OPHTHALMOLOGICAL_SYMPTOMS,
+    THORAX_SYMPTOMS,
+    GENERAL_SYMPTOMS,
+]

utils.py

@@ -0,0 +1,144 @@
+import os
+import shutil
+from pathlib import Path
+from typing import List, Tuple, Union
+
+import numpy
+import pandas
+
+from concrete.ml.sklearn import XGBClassifier as ConcreteXGBoostClassifier
+
+# Max Input to be displayed on the HuggingFace space brower using Gradio
+# Too large inputs, slow down the server: https://github.com/gradio-app/gradio/issues/1877
+INPUT_BROWSER_LIMIT = 380
+
+# Store the server's URL
+SERVER_URL = "http://localhost:8000/"
+
+CURRENT_DIR = Path(__file__).parent
+DEPLOYMENT_DIR = CURRENT_DIR / "deployment_files"
+KEYS_DIR = DEPLOYMENT_DIR / ".fhe_keys"
+CLIENT_DIR = DEPLOYMENT_DIR / "client_dir"
+SERVER_DIR = DEPLOYMENT_DIR / "server_dir"
+
+ALL_DIRS = [KEYS_DIR, CLIENT_DIR, SERVER_DIR]
+
+# Columns that define the target
+TARGET_COLUMNS = ["prognosis_encoded", "prognosis"]
+
+TRAINING_FILENAME = "./data/Training_preprocessed.csv"
+TESTING_FILENAME = "./data/Testing_preprocessed.csv"
+
+# pylint: disable=invalid-name
+
+
+def pretty_print(
+    inputs, case_conversion=str.title, which_replace: str = "_", to_what: str = " ", delimiter=None
+):
+    """
+    Prettify and sort the input as a list of string.
+
+    Args:
+        inputs (Any): The inputs to be prettified.
+
+    Returns:
+        List: The prettified and sorted list of inputs.
+
+    """
+    # Flatten the list if required
+    pretty_list = []
+    for item in inputs:
+        if isinstance(item, list):
+            pretty_list.extend(item)
+        else:
+            pretty_list.append(item)
+
+    # Sort
+    pretty_list = sorted(list(set(pretty_list)))
+    # Replace
+    pretty_list = [item.replace(which_replace, to_what) for item in pretty_list]
+    pretty_list = [case_conversion(item) for item in pretty_list]
+    if delimiter:
+        pretty_list = f"{delimiter.join(pretty_list)}."
+
+    return pretty_list
+
+
+def clean_directory() -> None:
+    """
+    Clear direcgtories
+    """
+    print("Cleaning...\n")
+    for target_dir in ALL_DIRS:
+        if os.path.exists(target_dir) and os.path.isdir(target_dir):
+            shutil.rmtree(target_dir)
+        target_dir.mkdir(exist_ok=True, parents=True)
+
+
+def get_disease_name(encoded_prediction: int, file_name: str = TRAINING_FILENAME) -> str:
+    """Return the disease name given its encoded label.
+
+    Args:
+        encoded_prediction (int): The encoded prediction
+        file_name (str): The data file path
+
+    Returns:
+        str: The according disease name
+    """
+    df = pandas.read_csv(file_name, usecols=TARGET_COLUMNS).drop_duplicates()
+    disease_name, _ = df[df[TARGET_COLUMNS[0]] == encoded_prediction].values.flatten()
+    return disease_name
+
+
+def load_data() -> Union[Tuple[pandas.DataFrame, numpy.ndarray], List]:
+    """
+    Return the data
+
+    Args:
+        None
+
+    Return:
+        The train, testing set and valid symptoms.
+    """
+    # Load data
+    df_train = pandas.read_csv(TRAINING_FILENAME)
+    df_test = pandas.read_csv(TESTING_FILENAME)
+
+    # Separate the traget from the training / testing set:
+    # TARGET_COLUMNS[0] -> "prognosis_encoded" -> contains the numeric label of the disease
+    # TARGET_COLUMNS[1] -> "prognosis"         -> contains the name of the disease
+
+    y_train = df_train[TARGET_COLUMNS[0]]
+    X_train = df_train.drop(columns=TARGET_COLUMNS, axis=1, errors="ignore")
+
+    y_test = df_test[TARGET_COLUMNS[0]]
+    X_test = df_test.drop(columns=TARGET_COLUMNS, axis=1, errors="ignore")
+
+    return (
+        (X_train, X_test),
+        (y_train, y_test),
+        X_train.columns.to_list(),
+        df_train[TARGET_COLUMNS[1]].unique().tolist(),
+    )
+
+
+def load_model(X_train: pandas.DataFrame, y_train: numpy.ndarray):
+    """
+    Load a pre-trained serialized model
+
+    Args:
+        X_train (pandas.DataFrame): Training set
+        y_train (numpy.ndarray): Targets of the training set
+
+    Return:
+        The Concrete ML model and its circuit
+    """
+    # Parameters
+    concrete_args = {"max_depth": 1, "n_bits": 3, "n_estimators": 3, "n_jobs": -1}
+    classifier = ConcreteXGBoostClassifier(**concrete_args)
+    # Train the model
+    classifier.fit(X_train, y_train)
+    # Compile the model
+    circuit = classifier.compile(X_train)
+
+    return classifier, circuit