alkzlj

.gitignore

@@ -1,3 +1,6 @@
 venv/
 
-__pycache__/
+__pycache__/
+
+client.zip
+server.zip

app.py

@@ -1,7 +1,207 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.responses import JSONResponse, Response
+from concrete.ml.deployment import FHEModelServer
+import numpy as np
+
+from concrete.ml.deployment import FHEModelClient
+import subprocess
+from pathlib import Path
+
+
+from utils import (
+    CLIENT_DIR,
+    CURRENT_DIR,
+    DEPLOYMENT_DIR,
+    SERVER_DIR,
+    INPUT_BROWSER_LIMIT,
+    KEYS_DIR,
+    SERVER_URL,
+    TARGET_COLUMNS,
+    TRAINING_FILENAME,
+    clean_directory,
+    get_disease_name,
+    load_data,
+    pretty_print,
+)
+
+
+import time
+from typing import List
+
+# Load the FHE server
+FHE_SERVER = FHEModelServer(DEPLOYMENT_DIR)
+
 
 app = FastAPI()
 
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}
+
+
+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)
+
+
+@app.post("/generate_keys")
+def generate_keys(user_symptoms: List[str]):
+    """
+    Endpoint to generate keys based on user symptoms.
+    
+    Args:
+        user_symptoms (List[str]): The list of user symptoms.
+
+    Returns:
+        JSONResponse: A response containing the generated keys and user ID.
+    """
+    def is_none(obj):
+        return obj is None or (obj is not None and len(obj) == 0)
+
+    # Call the key generation function
+    clean_directory()
+
+    if is_none(user_symptoms):
+        return JSONResponse(
+            status_code=400, content={"error": "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 JSONResponse(
+        content={
+            "user_id": user_id,
+            "evaluation_key": serialized_evaluation_keys_shorten_hex,
+            "evaluation_key_size": f"{len(serialized_evaluation_keys) / (10**6):.2f} MB"
+        }
+    )
+
+
+@app.post("/run_dev")
+def run_dev_script():
+    """
+    Endpoint to execute the dev.py script to generate deployment files.
+    
+    Returns:
+        JSONResponse: Success message or error details.
+    """
+    try:
+        # Define the path to dev.py
+        dev_script_path = Path(__file__).parent / "dev.py"
+
+        # Execute the dev.py script
+        result = subprocess.run(
+            ["python", str(dev_script_path)],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        # Return success message with output
+        return JSONResponse(
+            content={"message": "dev.py executed successfully!", "output": result.stdout}
+        )
+
+    except subprocess.CalledProcessError as e:
+        # Return error message in case of failure
+        return JSONResponse(
+            status_code=500,
+            content={"error": "Failed to execute dev.py", "details": e.stderr}
+        )

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

@@ -1,2 +1,3 @@
 fastapi
 uvicorn[standard]
+concrete-ml==1.4.0

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