app.py

"""A gradio app for credit card approval prediction using FHE."""

import subprocess
import time
import gradio as gr

from settings import (
    REPO_DIR,
    ACCOUNT_MIN_MAX,
    CHILDREN_MIN_MAX,
    INCOME_MIN_MAX,
    AGE_MIN_MAX,
    EMPLOYED_MIN_MAX,
    FAMILY_MIN_MAX,
    INCOME_TYPES,
    OCCUPATION_TYPES,
    HOUSING_TYPES,
    EDUCATION_TYPES,
    FAMILY_STATUS,
)
from backend import (
    keygen_send,
    pre_process_encrypt_send_user,
    pre_process_encrypt_send_bank,
    pre_process_encrypt_send_third_party,
    run_fhe,
    get_output_and_decrypt,
    years_employed_encrypt_run_decrypt,
)


subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
time.sleep(3)


demo = gr.Blocks()


print("Starting the demo...")
with demo:
    gr.Markdown(
        """
        <h1 align="center">Encrypted Credit Card Approval Prediction Using Fully Homomorphic Encryption</h1>
        """
    )

    gr.Markdown("# Client side")

    gr.Markdown("## Step 1: Generate the keys.")
    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. It is
        therefore transmitted to the server for further processing as well.
        """
    )
    keygen_button = gr.Button("Generate the keys and send evaluation key to the server.")
    evaluation_key = gr.Textbox(
        label="Evaluation key representation:", max_lines=2, interactive=False
    )
    client_id = gr.Textbox(label="", max_lines=2, interactive=False, visible=False)
    
    # Button generate the keys
    keygen_button.click(
        keygen_send,
        outputs=[client_id, evaluation_key, keygen_button],
    )

    gr.Markdown("## Step 2: Fill in some information.")
    gr.Markdown(
        """
        Select the information that corresponds to the profile you want to evaluate. Three sources 
        of information are represented in this model:
        - a user's personal information in order to evaluate his/her credit card eligibility;
        - the user’s bank account history, which provides any type of information on the user's 
        banking information relevant to the decision (here, we consider duration of account);
        - and third party information, which represents any other information (here, employment 
        history) that could provide additional insight relevant to the decision.
        """
    )

    with gr.Row():
        with gr.Column():
            gr.Markdown("### User")
            bool_inputs = gr.CheckboxGroup(["Car", "Property", "Mobile phone"], label="Which of the following do you actively hold or own?")
            num_children = gr.Slider(**CHILDREN_MIN_MAX, step=1, label="Number of children", info="How many children do you have ?")
            household_size = gr.Slider(**FAMILY_MIN_MAX, step=1, label="Household size", info="How many members does your household have ?")
            total_income = gr.Slider(**INCOME_MIN_MAX, label="Income", info="What's you total yearly income (in euros) ?")
            age = gr.Slider(**AGE_MIN_MAX, step=1, label="Age", info="How old are you ?")
            income_type = gr.Dropdown(choices=INCOME_TYPES, value=INCOME_TYPES[0], label="Income type", info="What is your main type of income ?")
            education_type = gr.Dropdown(choices=EDUCATION_TYPES, value=EDUCATION_TYPES[0], label="Education", info="What is your education background ?")
            family_status = gr.Dropdown(choices=FAMILY_STATUS, value=FAMILY_STATUS[0], label="Family", info="What is your family status ?")
            occupation_type = gr.Dropdown(choices=OCCUPATION_TYPES, value=OCCUPATION_TYPES[0], label="Occupation", info="What is your main occupation ?")
            housing_type = gr.Dropdown(choices=HOUSING_TYPES, value=HOUSING_TYPES[0], label="Housing", info="In what type of housing do you live ?")

        with gr.Column():
            gr.Markdown("### Bank ")
            account_age = gr.Slider(**ACCOUNT_MIN_MAX, step=1, label="Account age (months)", info="How long have this person had this bank account (in months) ?")

        with gr.Column():
            gr.Markdown("### Third party ")
            employed = gr.Radio(["Yes", "No"], label="Is the person employed ?", value="Yes")
            years_employed = gr.Slider(**EMPLOYED_MIN_MAX, step=1, label="Years of employment", info="How long have this person been employed (in years) ?")


    gr.Markdown("## Step 3: Encrypt the inputs using FHE and send them to the server.")
    with gr.Row():
        with gr.Column():
            gr.Markdown("### User")
            encrypt_button_user = gr.Button("Encrypt the inputs and send to server.")
            
            encrypted_input_user = gr.Textbox(
                label="Encrypted input representation:", max_lines=2, interactive=False
            )


        with gr.Column():
            gr.Markdown("### Bank ")
            encrypt_button_bank = gr.Button("Encrypt the inputs and send to server.")

            encrypted_input_bank = gr.Textbox(
                label="Encrypted input representation:", max_lines=2, interactive=False
            )


        with gr.Column():
            gr.Markdown("### Third Party ")
            encrypt_button_third_party = gr.Button("Encrypt the inputs and send to server.")

            encrypted_input_third_party = gr.Textbox(
                label="Encrypted input representation:", max_lines=2, interactive=False
            )

    # Button to pre-process, generate the key, encrypt and send the user inputs from the client 
    # side to the server
    encrypt_button_user.click(
        pre_process_encrypt_send_user,
        inputs=[client_id, bool_inputs, num_children, household_size, total_income, age, \
                income_type, education_type, family_status, occupation_type, housing_type],
        outputs=[encrypted_input_user],
    )

    # Button to pre-process, generate the key, encrypt and send the bank inputs from the client 
    # side to the server
    encrypt_button_bank.click(
        pre_process_encrypt_send_bank,
        inputs=[client_id, account_age],
        outputs=[encrypted_input_bank],
    )

    # Button to pre-process, generate the key, encrypt and send the third party inputs from the 
    # client side to the server    
    encrypt_button_third_party.click(
        pre_process_encrypt_send_third_party,
        inputs=[client_id, employed, years_employed],
        outputs=[encrypted_input_third_party],
    )

    gr.Markdown("# Server side")
    gr.Markdown(
        """
        Once the server receives the encrypted inputs, it can compute the prediction without ever 
        needing to decrypt any value.

        This server employs an [XGBoost](https://github.com/dmlc/xgboost) classifier model that has 
        been trained on a synthetic data-set.
        """
    )

    gr.Markdown("## Step 4: Run FHE execution.")
    execute_fhe_button = gr.Button("Run FHE execution.")
    fhe_execution_time = gr.Textbox(
        label="Total FHE execution time (in seconds):", max_lines=1, interactive=False
    )

    # Button to send the encodings to the server using post method
    execute_fhe_button.click(run_fhe, inputs=[client_id], outputs=[fhe_execution_time])

    gr.Markdown("# Client side")  
    gr.Markdown(
        """
        Once the server completed the inference, the encrypted output is returned to the user.
        """
    )

    gr.Markdown("## Step 5: Receive the encrypted output from the server and decrypt.")
    gr.Markdown(
        """
        The value displayed below is a shortened byte representation of the actual encrypted output.
        """
    )

    get_output_button = gr.Button("Receive the encrypted output from the server.")
    encrypted_output_representation = gr.Textbox(
        label="Encrypted output representation: ", max_lines=2, interactive=False
    )
    prediction_output = gr.Textbox(
        label="Prediction", max_lines=1, interactive=False
    )

    # Button to send the encodings to the server using post method
    get_output_button.click(
        get_output_and_decrypt, 
        inputs=[client_id], 
        outputs=[prediction_output, encrypted_output_representation],
    )

    gr.Markdown("## Step 6 (optional): Explain the prediction.")
    gr.Markdown(
        """
        In case the credit card is likely to be denied, the user can run a second model in order to 
        Explain the prediction better. More specifically, this new model indicates the number of
        additional years of employment that could be required in order to increase the chance of 
        credit card approval.
        All of the above steps are combined into a single button for simplicity. The following 
        button therefore encrypts the same inputs (except the years of employment) from all three 
        parties, runs the new prediction in FHE and decrypts the output. 
        """
    )
    years_employed_prediction_button = gr.Button(
        "Encrypt the inputs, compute in FHE and decrypt the output."
    )
    years_employed_prediction = gr.Textbox(
        label="Additional years of employed required.", max_lines=1, interactive=False
    )

    # Button to explain the prediction
    years_employed_prediction_button.click(
        years_employed_encrypt_run_decrypt,
        inputs=[client_id, prediction_output, bool_inputs, num_children, household_size, \
                total_income, age, income_type, education_type, family_status, occupation_type, \
                housing_type, account_age, employed, years_employed],
        outputs=[years_employed_prediction],
    )

    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](https://zama.ai/). "
        "Try it yourself and don't forget to star on Github &#11088;."
    )

demo.launch(share=False)