Upload 3 files

app.py

@@ -16,11 +16,7 @@ from utils import (
     INPUT_BROWSER_LIMIT,
     KEYS_DIR,
     SERVER_URL,
-    TARGET_COLUMNS,
-    TRAINING_FILENAME,
     clean_directory,
-    load_data,
-    pretty_print,
 )
 
 import requests
@@ -149,7 +145,7 @@ def collect_input(passenger_class, is_male, age, company, fare, embark_point):
                 (1 if "Sibling" in company else 0) + (2 if "Child" in company else 0)
             ]
         }
-    print(input_dict)
+    # print(input_dict)
     return input_dict
 
 def clear_predict_survival(input_dict):
@@ -166,9 +162,9 @@ def concrete_predict_survival(input_dict):
     pred = concrete_clf.predict_proba(df)[0]
     return {"Perishes": float(pred[0]), "Survives": float(pred[1])}
 
-print("\nclear_test    ", clear_predict_survival({'Pclass': [1], 'Sex': [0], 'Age': [25], 'Fare': [20.0], 'Embarked': [2], 'Company': [1]}))
+# print("\nclear_test    ", clear_predict_survival({'Pclass': [1], 'Sex': [0], 'Age': [25], 'Fare': [20.0], 'Embarked': [2], 'Company': [1]}))
 
-print("encrypted_test", concrete_predict_survival({'Pclass': [1], 'Sex': [0], 'Age': [25], 'Fare': [20.0], 'Embarked': [2], 'Company': [1]}),"\n")
+# print("encrypted_test", concrete_predict_survival({'Pclass': [1], 'Sex': [0], 'Age': [25], 'Fare': [20.0], 'Embarked': [2], 'Company': [1]}),"\n")
 
 
 def key_gen_fn() -> Dict:
@@ -230,9 +226,6 @@ def encrypt_fn(user_inputs: np.ndarray, user_id: str) -> None:
     # Retrieve the client API
     client = FHEModelClient(path_dir=DEPLOYMENT_DIR, key_dir=KEYS_DIR / f"{user_id}")
     client.load()
-
-    # user_inputs = np.fromstring(user_symptoms[2:-2], dtype=int, sep=".").reshape(1, -1)
-    # quant_user_symptoms = client.model.quantize_input(user_inputs)
     
     user_inputs_df = pd.DataFrame.from_dict(user_inputs)
     user_inputs_df = encode_age(user_inputs_df)
@@ -268,7 +261,7 @@ def send_input_fn(user_id: str, user_inputs: np.ndarray) -> Dict:
             error_box4: gr.update(
                 visible=True,
                 value="⚠️ Please check your connectivity \n"
-                "⚠️ Ensure that the symptoms have been submitted and the evaluation "
+                "⚠️ Ensure that the inputs have been submitted and the evaluation "
                 "key has been generated before sending the data to the server.",
             )
         }
@@ -333,7 +326,7 @@ def run_fhe_fn(user_id: str) -> Dict:
             error_box5: gr.update(
                 visible=True,
                 value="⚠️ Please check your connectivity \n"
-                "⚠️ Ensure that the symptoms have been submitted, the evaluation "
+                "⚠️ Ensure that the inputs have been submitted, the evaluation "
                 "key has been generated and the server received the data "
                 "before processing the data.",
             ),
@@ -379,7 +372,7 @@ def send_input_fn(user_id: str, user_inputs: np.ndarray) -> Dict:
             error_box4: gr.update(
                 visible=True,
                 value="⚠️ Please check your connectivity \n"
-                "⚠️ Ensure that the symptoms have been submitted and the evaluation "
+                "⚠️ Ensure that the inputs have been submitted and the evaluation "
                 "key has been generated before sending the data to the server.",
             )
         }
@@ -534,17 +527,18 @@ def decrypt_fn(user_id: str, user_inputs: np.ndarray) -> Dict:
 with gr.Blocks() as demo:
 
     # Step 1.1: Provide inputs
+    gr.Markdown("###Titanic Survival Prediction with ML and Private Computation")
     with gr.Row():
         inp = [
-                gr.Dropdown(["first", "second", "third"], type="index"),
-                gr.Checkbox(label="is_male"),
-                gr.Slider(0, 80, value=25),
+                gr.Dropdown(["first", "second", "third"], type="index", label="Select Passenger Class"),
+                gr.Checkbox(label="Male?"),
+                gr.Slider(0, 80, value=25, label="Age", step=1),
                 gr.CheckboxGroup(["Sibling", "Child"], label="Travelling with (select all)"),
-                gr.Number(value=20),
-                gr.Radio(["S", "C", "Q"], type="index"),
+                gr.Number(value=20, label="Fare"),
+                gr.Radio(["Southampton", "Cherbourg", "Queenstown"], type="index", label="Embark point:"),
             ]
         out = gr.JSON()
-    btn = gr.Button("Run")
+    btn = gr.Button("Confirm inputs")
     btn.click(fn=collect_input, inputs=inp, outputs=out)
 
     # Step 2.1: Key generation

server.py

@@ -16,12 +16,12 @@ app = FastAPI()
 @app.get("/")
 def root():
     """
-    Root endpoint of the health prediction API.
+    Root endpoint of the titanic survival prediction API.
 
     Returns:
         dict: The welcome message.
     """
-    return {"message": "Welcome to your disease prediction with FHE!"}
+    return {"message": "Welcome to titanic survival prediction with FHE!"}
 
 
 @app.post("/send_input")

utils.py

@@ -23,47 +23,6 @@ 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
@@ -73,72 +32,3 @@ def clean_directory() -> None:
         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