chore: update

ConcreteXGBoostClassifier.pkl

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

app.py

@@ -0,0 +1,405 @@
+import pickle as pkl
+import shutil
+from pathlib import Path
+from time import time
+from typing import List, Tuple, Union
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+from sklearn import metrics, preprocessing
+from sklearn.ensemble import RandomForestClassifier as SklearnRandomForestClassifier
+from sklearn.model_selection import train_test_split
+
+from concrete.ml.common.serialization.loaders import load, loads
+from concrete.ml.deployment import FHEModelClient, FHEModelDev, FHEModelServer
+from concrete.ml.sklearn import XGBClassifier as ConcreteXGBoostClassifier
+
+path_to_model = Path("./client_folder").resolve()
+
+import subprocess
+
+from preprocessing import (  # pylint: disable=wrong-import-position, no-name-in-module
+    map_prediction,
+    pretty_print,
+)
+from symptoms_categories import SYMPTOMS_LIST
+
+ENCRYPTED_DATA_BROWSER_LIMIT = 500
+# This repository's directory
+REPO_DIR = Path(__file__).parent
+
+print(f"{REPO_DIR=}")
+# subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
+# time.sleep(3)
+
+
+def load_data():
+    # Load data
+    df_train = pd.read_csv("./data/Training_preprocessed.csv")
+    df_test = pd.read_csv("./data/Testing_preprocessed.csv")
+
+    # Separate the traget from the training set
+    # df['prognosis] contains the name of the disease
+    # df['y] contains the numeric label of the disease
+
+    y_train = df_train["y"]
+    X_train = df_train.drop(columns=["y", "prognosis"], axis=1, errors="ignore")
+
+    y_test = df_train["y"]
+    X_test = df_test.drop(columns=["y", "prognosis"], axis=1, errors="ignore")
+
+    return (df_train, X_train, X_test), (df_test, y_train, y_test)
+
+
+def load_model(X_train, y_train):
+    concrete_args = {"max_depth": 1, "n_bits": 3, "n_estimators": 3, "n_jobs": -1}
+    classifier = ConcreteXGBoostClassifier(**concrete_args)
+    classifier.fit(X_train, y_train)
+    circuit = classifier.compile(X_train)
+
+    return classifier, circuit
+
+
+def key_gen():
+
+    # Key serialization
+    user_id = np.random.randint(0, 2**32)
+
+    client = FHEModelClient(path_dir=path_to_model, key_dir=f".fhe_keys/{user_id}")
+    client.load()
+
+    # The client first need to create the private and evaluation keys.
+
+    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)
+
+    np.save(f".fhe_keys/{user_id}/eval_key.npy", serialized_evaluation_keys)
+
+    serialized_evaluation_keys_shorten = list(serialized_evaluation_keys)[:200]
+    serialized_evaluation_keys_shorten_hex = "".join(
+        f"{i:02x}" for i in serialized_evaluation_keys_shorten
+    )
+    # Evaluation keys can be quite large files but only have to be shared once with the server.
+
+    # Check the size of the evaluation keys (in MB)
+    return [
+        serialized_evaluation_keys_shorten_hex,
+        user_id,
+        f"{len(serialized_evaluation_keys) / (10**6):.2f} MB",
+    ]
+
+
+def encode_quantize_encrypt(user_symptoms, user_id):
+    # check if the key has been generated
+    client = FHEModelClient(path_dir=path_to_model, key_dir=f".fhe_keys/{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)
+
+    # print(client.model.predict(vect_x, fhe="simulate"), client.model.predict(vect_x, fhe="execute"))
+    # pred_s = client.model.fhe_circuit.simulate(quant_vect)
+    # pred_fhe = client.model.fhe_circuit.encrypt_run_decrypt(quant_vect) #
+    # non alpha -> \X1124, base64 ou en exa
+
+    # Compute size
+
+    np.save(f".fhe_keys/{user_id}/encrypted_quant_vect.npy", encrypted_quantized_user_symptoms)
+
+    encrypted_quantized_encoding_shorten = list(encrypted_quantized_user_symptoms)[:200]
+    encrypted_quantized_encoding_shorten_hex = "".join(
+        f"{i:02x}" for i in encrypted_quantized_encoding_shorten
+    )
+
+    return user_symptoms, quant_user_symptoms, encrypted_quantized_encoding_shorten_hex
+
+
+def decrypt_prediction(encrypted_quantized_vect, user_id):
+    fhe_api = FHEModelClient(path_dir=path_to_model, key_dir=f".fhe_keys/{user_id}")
+    fhe_api.load()
+    fhe_api.generate_private_and_evaluation_keys(force=False)
+    predictions = fhe_api.deserialize_decrypt_dequantize(encrypted_quantized_vect)
+    return predictions
+
+
+def get_user_vect_symptoms_from_checkboxgroup(*user_symptoms) -> np.array:
+    symptoms_vector = {key: 0 for key in valid_columns}
+
+    for symptom_box in user_symptoms:
+        for pretty_symptom in symptom_box:
+            symptom = "_".join((pretty_symptom.lower().split(" ")))
+            if symptom not in symptoms_vector.keys():
+                raise KeyError(
+                    f"The symptom '{symptom}' you provided is not recognized as a valid "
+                    f"symptom.\nHere is the list of valid symptoms: {symptoms_vector}"
+                )
+            symptoms_vector[symptom] = 1.0
+
+    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_user_vect_symptoms_from_default_disease(disease):
+
+    user_symptom_vector = df_test[df_test["prognosis"] == disease].iloc[0].values
+
+    user_symptoms_vect = np.fromiter(user_symptom_vector[:-2], dtype=float)[np.newaxis, :]
+
+    assert all(value == 0 or value == 1 for value in user_symptoms_vect.flatten())
+
+    return user_symptoms_vect
+
+
+def get_user_symptoms_from_default_disease(disease):
+    df_filtred = df_test[df_test["prognosis"] == disease]
+    columns_with_1 = df_filtred.columns[df_filtred.eq(1).any()].to_list()
+    return pretty_print(columns_with_1)
+
+
+def get_user_symptoms_vector(selected_default_disease, *selected_symptoms):
+
+    if any(lst for lst in selected_symptoms if lst) and (
+        selected_default_disease is not None and len(selected_default_disease) > 0
+    ):
+        # If the user has already selected a disease and added more symptoms, raise an error
+        if set(pretty_print(selected_symptoms)) - set(
+            get_user_symptoms_from_default_disease(selected_default_disease)
+        ):
+            return {
+                user_vector_textbox: gr.update(value="An error occurs"),
+                error_box: gr.update(
+                    visible=True, value="Enter a default disease or select your own symptoms"
+                ),
+            }
+    # If the user has not selected a default disease or symptoms, an error is raised.
+    if not any(lst for lst in selected_symptoms if lst) and (
+        selected_default_disease is None
+        or (selected_default_disease is not None and len(selected_default_disease) < 1)
+    ):
+        return {
+            user_vector_textbox: gr.update(value="An error occurs"),
+            error_box: gr.update(
+                visible=True, value="Enter a default disease or select your own symptoms"
+            ),
+        }
+    # Case 1: The user has checked his own symptoms
+    if any(lst for lst in selected_symptoms if lst):
+        return {
+            user_vector_textbox: get_user_vect_symptoms_from_checkboxgroup(*selected_symptoms),
+        }
+
+    # Case 2: The user has selected a default disease
+    if selected_default_disease is not None and len(selected_default_disease) > 0:
+        return {
+            user_vector_textbox: get_user_vect_symptoms_from_default_disease(
+                selected_default_disease
+            ),
+            error_box: gr.update(visible=False),
+            **{
+                box: get_user_symptoms_from_default_disease(selected_default_disease)
+                for box in check_boxes
+            },
+        }
+
+
+def clear_all_buttons():
+    return {
+        user_id_textbox: None,
+        eval_key_textbox: None,
+        eval_key_len_textbox: None,
+        user_vector_textbox: None,
+        box_default: None,
+        error_box: gr.update(visible=False),
+        **{box: None for box in check_boxes},
+    }
+
+
+if __name__ == "__main__":
+    print("Starting demo ...")
+
+    (df_train, X_train, X_test), (df_test, y_train, y_test) = load_data()
+
+    valid_columns = X_train.columns.to_list()
+
+    with gr.Blocks() as demo:
+
+        # Link + images
+        gr.Markdown(
+            """
+    <p align="center">
+        <img width=200 src="https://user-images.githubusercontent.com/5758427/197816413-d9cddad3-ba38-4793-847d-120975e1da11.png">
+    </p>
+
+    <h2 align="center">Health Prediction On Encrypted Data Using Homomorphic Encryption.</h2>
+
+    <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>
+
+    <p align="center">
+    <img src="https://raw.githubusercontent.com/kcelia/Img/main/demo-img2.png" width="60%" height="60%">
+    </p>
+    """
+        )
+
+        # Gentle introduction
+        gr.Markdown("## Introduction")
+        gr.Markdown("""Blablabla""")
+
+        # User symptoms
+        gr.Markdown("# Step 1: Provide your symptoms")
+        gr.Markdown("Client side")
+
+        # Default disease, picked from the dataframe
+        with gr.Row():
+            default_diseases = list(set(df_test["prognosis"]))
+            box_default = gr.Dropdown(default_diseases, label="Disease")
+
+        # Box symptoms
+        check_boxes = []
+        for i, category in enumerate(SYMPTOMS_LIST):
+            check_box = gr.CheckboxGroup(
+                pretty_print(category.values()),
+                label=pretty_print(category.keys()),
+                info=f"Symptoms related to `{pretty_print(category.values())}`",
+                max_batch_size=45,
+            )
+            check_boxes.append(check_box)
+
+        # User symptom vector
+        with gr.Row():
+            user_vector_textbox = gr.Textbox(
+                label="User symptoms (vector)",
+                interactive=False,
+                max_lines=100,
+            )
+        error_box = gr.Textbox(label="Error", visible=False)
+
+        with gr.Row():
+            # Submit botton
+            with gr.Column():
+                submit_button = gr.Button("Submit")
+            # Clear botton
+            with gr.Column():
+                clear_button = gr.Button("Clear", style="background-color: yellow;")
+
+        # Click submit botton
+
+        submit_button.click(
+            fn=get_user_symptoms_vector,
+            inputs=[box_default, *check_boxes],
+            outputs=[user_vector_textbox, error_box, *check_boxes],
+        )
+        # Load the model
+        concrete_classifier = load(
+            open("ConcreteRandomForestClassifier.pkl", "r", encoding="utf-8")
+        )
+
+        gr.Markdown("# Step 2: Generate the keys")
+        gr.Markdown("Client side")
+
+        gen_key = gr.Button("Generate the keys and send public part to server")
+
+        with gr.Row():
+            # User ID
+            with gr.Column(scale=1, min_width=600):
+                user_id_textbox = gr.Textbox(
+                    label="User ID:",
+                    max_lines=4,
+                    interactive=False,
+                )
+            # Evaluation key size
+            with gr.Column(scale=1, min_width=600):
+                eval_key_len_textbox = gr.Textbox(
+                    label="Evaluation key size:", max_lines=4, interactive=False
+                )
+
+        with gr.Row():
+            # Evaluation key (truncated)
+            with gr.Column(scale=2, min_width=600):
+                eval_key_textbox = gr.Textbox(
+                    label="Evaluation key (truncated):",
+                    max_lines=4,
+                    interactive=False,
+                )
+
+        gen_key.click(key_gen, outputs=[eval_key_textbox, user_id_textbox, eval_key_len_textbox])
+
+        clear_button.click(
+            clear_all_buttons,
+            outputs=[
+                user_id_textbox,
+                user_vector_textbox,
+                eval_key_textbox,
+                eval_key_len_textbox,
+                box_default,
+                error_box,
+                *check_boxes,
+            ],
+        )
+
+        gr.Markdown("# Step 3: Encode the message with the private key")
+        gr.Markdown("Client side")
+
+        encode_msg = gr.Button("Generate the keys and send public part to server")
+
+        with gr.Row():
+
+            with gr.Column(scale=1, min_width=600):
+                vect_textbox = gr.Textbox(
+                    label="Vector:",
+                    max_lines=4,
+                    interactive=False,
+                )
+
+            with gr.Column(scale=1, min_width=600):
+                quant_vect_textbox = gr.Textbox(
+                    label="Quant vector:", max_lines=4, interactive=False
+                )
+
+            with gr.Column(scale=1, min_width=600):
+                encrypted_vect_textbox = gr.Textbox(
+                    label="Encrypted vector:", max_lines=4, interactive=False
+                )
+
+        encode_msg.click(
+            encode_quantize_encrypt,
+            inputs=[user_vector_textbox, user_id_textbox],
+            outputs=[vect_textbox, quant_vect_textbox, encrypted_vect_textbox],
+        )
+
+        gr.Markdown("# Step 4: Run the FHE evaluation")
+        gr.Markdown("Server side")
+
+        run_fhe = gr.Button("Run the FHE evaluation")
+
+        gr.Markdown("# Step 5: Decrypt the sentiment")
+        gr.Markdown("Server side")
+
+        decrypt_target_botton = gr.Button("Decrypt the sentiment")
+        decrypt_target_textbox = gr.Textbox(
+            label="Encrypted vector:", max_lines=4, interactive=False
+        )
+
+        decrypt_target_botton.click(
+            decrypt_prediction,
+            inputs=[encrypted_vect_textbox, user_id_textbox],
+            outputs=[decrypt_target_textbox],
+        )
+
+    demo.launch()

client_folder/client.zip

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

client_folder/server.zip

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

client_folder/versions.json

@@ -0,0 +1 @@
+{"concrete-ml": "1.0.0rc2", "concrete-python": "1.0.0", "python": "3.10.6"}

preprocessing.py

@@ -0,0 +1,83 @@
+"""
+Preliminary preprocessing on the data, such as:
+- correcting column names
+- encoding the target column
+"""
+
+import pandas as pd
+from sklearn import preprocessing
+
+COLUMNS_TO_DROP = ["Unnamed: 133"]
+TARGET_COLUMN = ["prognosis"]
+RENAME_COLUMNS = {
+    "scurring": "scurving",
+    "dischromic _patches": "dischromic_patches",
+    "spotting_ urination": "spotting_urination",
+    "foul_smell_of urine": "foul_smell_of_urine",
+}
+
+
+def pretty_print(input):
+    """
+    Prettify the input.
+
+    Args:
+        input: Can be a list of symtoms or a disease.
+
+    Returns:
+        list: Sorted and prettified input.
+    """
+    # Convert to a list if necessary
+    if isinstance(input, list):
+        input = list(input)
+
+    # Flatten the list if required
+    pretty_list = []
+    for item in input:
+        if isinstance(item, list):
+            pretty_list.extend(item)
+        else:
+            pretty_list.append(item)
+
+    # Sort and prettify the input
+    pretty_list = sorted([" ".join((item.split("_"))).title() for item in pretty_list])
+
+    return pretty_list
+
+
+def map_prediction(target_columns=["y", "prognosis"]):
+    df = pd.read_csv("Training_preprocessed.csv")
+    relevent_df = df[target_columns].drop_duplicates().relevent_df.where(df["y"] == 1)
+    prediction = relevent_df[target_columns[1]].dropna().values[0]
+    return prediction
+
+
+if __name__ == "__main__":
+
+    # Load data
+    df_train = pd.read_csv("Training.csv")
+    df_test = pd.read_csv("Testing.csv")
+
+    # Remove unseless columns
+    df_train.drop(columns=COLUMNS_TO_DROP, axis=1, errors="ignore", inplace=True)
+    df_test.drop(columns=COLUMNS_TO_DROP, axis=1, errors="ignore", inplace=True)
+
+    # Correct some typos in some columns name
+    df_train.rename(columns=RENAME_COLUMNS, inplace=True)
+    df_test.rename(columns=RENAME_COLUMNS, inplace=True)
+
+    # Convert y category labels to y
+    label_encoder = preprocessing.LabelEncoder()
+    label_encoder.fit(df_train[TARGET_COLUMN].values.flatten())
+
+    df_train["y"] = label_encoder.transform(df_train[TARGET_COLUMN].values.flatten())
+    df_test["y"] = label_encoder.transform(df_test[TARGET_COLUMN].values.flatten())
+
+    # Cast X features from int64 to float32
+    float_columns = df_train.columns.drop(TARGET_COLUMN)
+    df_train[float_columns] = df_train[float_columns].astype("float32")
+    df_test[float_columns] = df_test[float_columns].astype("float32")
+
+    # Save preprocessed data
+    df_train.to_csv(path_or_buf="Training_preprocessed.csv", index=False)
+    df_test.to_csv(path_or_buf="Testing_preprocessed.csv", index=False)

server.py

@@ -0,0 +1,93 @@
+"""Server that will listen for GET and POST requests from the client."""
+
+import time
+from pathlib import Path
+from typing import List
+
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.responses import JSONResponse, Response
+
+from concrete.ml.deployment import FHEModelServer
+
+# Initialize an instance of FastAPI
+app = FastAPI()
+
+current_dir = Path(__file__).parent
+
+# Load the model
+fhe_model = FHEModelServer(Path.joinpath(current_dir, "./client_folder"))
+
+# Define the default route
+@app.get("/")
+def root():
+    return {"message": "Welcome to Your disease prediction with fhe !"}
+
+
+@app.post("/send_input")
+def send_input(
+    user_id: str = Form(),
+    filter: 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 = 0  # Tcurrent_dir("encrypted_image", user_id, filter)
+    evaluation_key_path = current_dir / ".fhe_keys/{user_id}"
+
+    # Write the files using the above paths
+    with encrypted_image_path.open("wb") as encrypted_image, evaluation_key_path.open(
+        "wb"
+    ) as evaluation_key:
+        encrypted_image.write(files[0].file.read())
+        evaluation_key.write(files[1].file.read())
+
+
+@app.post("/run_fhe")
+def run_fhe(
+    user_id: str = Form(),
+    filter: str = Form(),
+):
+    """Execute the filter on the encrypted input image 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)
+
+    # Read the files using the above paths
+    with encrypted_image_path.open("rb") as encrypted_image_file, evaluation_key_path.open(
+        "rb"
+    ) as evaluation_key_file:
+        encrypted_image = encrypted_image_file.read()
+        evaluation_key = evaluation_key_file.read()
+
+    # Load the FHE server
+    fhe_server = FHEServer(FILTERS_PATH / f"{filter}/deployment")
+
+    # Run the FHE execution
+    start = time.time()
+    encrypted_output_image = fhe_server.run(encrypted_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)
+
+    # Write the file using the above path
+    with encrypted_output_path.open("wb") as encrypted_output:
+        encrypted_output.write(encrypted_output_image)
+
+    return JSONResponse(content=fhe_execution_time)
+
+
+@app.post("/get_output")
+def get_output(
+    user_id: str = Form(),
+    filter: 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)
+
+    # Read the file using the above path
+    with encrypted_output_path.open("rb") as encrypted_output_file:
+        encrypted_output = encrypted_output_file.read()
+
+    return Response(encrypted_output)

symptoms_categories.py

@@ -0,0 +1,226 @@
+"""
+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.
+"""
+
+import itertools
+
+import pandas as pd
+
+DIGESTIVE_SYSTEM_SYPTOMS = {
+    "Digestive system syptoms": [
+        "stomach_pain",
+        "acidity",
+        "vomiting",
+        "indigestion",
+        "constipation",
+        "abdominal_pain",
+        "diarrhoea",
+        "belly_pain",
+        "nausea",
+        "distention_of_abdomen",
+        "stomach_bleeding",
+        "pain_during_bowel_movements",
+        "passage_of_gases",
+        "brittle_nails",
+        "red_spots_over_body",
+        "swelling_of_stomach",
+        "bloody_stool",
+        "yellowish_skin",
+        "irritation_in_anus",
+        "pain_in_anal_region",
+        "abnormal_menstruation",
+    ]
+}
+
+SKIN_SYPTOMS = {
+    "Skin related symptoms": [
+        "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",
+    ]
+}
+
+ORL_SYPTOMS = {
+    "ORL_SYPTOMS": [
+        "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_RELATED_SYMPTOMS": [
+        "breathlessness",
+        "chest_pain",
+        "cough",
+        "rusty_sputum",
+        "phlegm",
+        "mucoid_sputum",
+        "congestion",
+        "blood_in_sputum",
+        "fast_heart_rate",
+    ]
+}
+
+EYES_SYMPTOMS = {
+    "Eyes_related_symptoms": [
+        "sunken_eyes",
+        "redness_of_eyes",
+        "watering_from_eyes",
+        "blurred_and_distorted_vision",
+        "pain_behind_the_eyes",
+        "visual_disturbances",
+    ]
+}
+
+VASCULAR_LYMPHATIC_SYMPTOMS = {
+    "VASCULAR_LYMPHATIC_SYMPTOMS": [
+        "cold_hands_and_feets",
+        "swollen_blood_vessels",
+        "swollen_legs",
+        "swelled_lymph_nodes",
+        "palpitations",
+        "prominent_veins_on_calf",
+        "yellowing_of_eyes",
+        "puffy_face_and_eyes",
+        "fluid_overload",
+        "fluid_overload.1",
+        "swollen_extremeties",
+    ]
+}
+
+UROLOGICAL_SYMPTOMS = {
+    "UROLOGICAL_SYMPTOMS": [
+        "burning_micturition",
+        "spotting_urination",
+        "yellow_urine",
+        "bladder_discomfort",
+        "foul_smell_of_urine",
+        "continuous_feel_of_urine",
+        "polyuria",
+        "dark_urine",
+    ]
+}
+
+MUSCULOSKELETAL_SYMPTOMS = {
+    "MUSCULOSKELETAL_SYMPTOMS": [
+        "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",
+    ]
+}
+
+FEELING_SYMPTOMS = {
+    "FEELING_SYPTOMS": [
+        "anxiety",
+        "restlessness",
+        "lethargy",
+        "mood_swings",
+        "depression",
+        "irritability",
+        "lack_of_concentration",
+        "fatigue",
+        "malaise",
+        "weight_gain",
+        "increased_appetite",
+        "weight_loss",
+        "loss_of_appetite",
+        "obesity",
+        "excessive_hunger",
+    ]
+}
+
+OTHER_SYPTOMS = {
+    "OTHER_SYPTOMS": [
+        "ulcers_on_tongue",
+        "shivering",
+        "chills",
+        "irregular_sugar_level",
+        "high_fever",
+        "slurred_speech",
+        "sweating",
+        "internal_itching",
+        "mild_fever",
+        "toxic_look_(typhos)",
+        "acute_liver_failure",
+        "dehydration",
+        "headache",
+        "extra_marital_contacts",
+        "drying_and_tingling_lips",
+        "altered_sensorium",
+    ]
+}
+
+PATIENT_HISTORY = {
+    "PATIENT_HISTORY": [
+        "family_history",
+        "receiving_blood_transfusion",
+        "receiving_unsterile_injections",
+        "history_of_alcohol_consumption",
+        "coma",
+    ]
+}
+
+SYMPTOMS_LIST = [
+    SKIN_SYPTOMS,
+    EYES_SYMPTOMS,
+    ORL_SYPTOMS,
+    THORAX_SYMPTOMS,
+    DIGESTIVE_SYSTEM_SYPTOMS,
+    UROLOGICAL_SYMPTOMS,
+    VASCULAR_LYMPHATIC_SYMPTOMS,
+    MUSCULOSKELETAL_SYMPTOMS,
+    FEELING_SYMPTOMS,
+    PATIENT_HISTORY,
+    OTHER_SYPTOMS,
+]
+
+
+def test(file_path="./Training.csv"):
+    df = pd.read_csv(file_path, index_col=0)
+    valid_column = df.columns
+    all_symptoms = [category.values() for category in SYMPTOMS_LIST]
+    all_symptoms = list(itertools.chain.from_iterable(all_symptoms))
+    all_symptoms = list(itertools.chain.from_iterable(all_symptoms))
+    set(valid_column) - set(all_symptoms), set(all_symptoms) - set(valid_column)
+
+
+if __name__ == "__main__":
+    test()