app.py

# ----- Load base libraries and packages
import gradio as gr

import numpy as np
import pandas as pd

import pickle

import xgboost as xgb
from xgboost import XGBClassifier

# ----- Useful lists
expected_inputs = ["tenure", "montant", "frequence_rech", "arpu_segment", "frequence", "data_volume", "regularity", "freq_top_pack"]
columns_to_scale = ["montant", "frequence_rech", "arpu_segment", "frequence", "data_volume", "regularity", "freq_top_pack"]
categoricals = ["tenure"]


# ----- Helper Functions
# Function to load ML toolkit
def load_ml_toolkit(file_path=r"src/Gradio_App_toolkit"):
    """
    This function loads the ML items into this app by taking the path to the ML items.

    Args:
        file_path (regexp, optional): It receives the file path to the ML items, but defaults to the "src" folder in the repository.

    Returns:
        file: It returns the pickle file (which in this case contains the Machine Learning items.)
    """

    with open(file_path, "rb") as file:
        loaded_toolkit = pickle.load(file)
    return loaded_toolkit


# Importing the toolkit
loaded_toolkit = load_ml_toolkit(r"src/Gradio_App_toolkit")
encoder = loaded_toolkit["encoder"]
scaler = loaded_toolkit["scaler"]

# Import the model
model = XGBClassifier()
model.load_model(r"src/xgb_model.json")


# Function to process inputs and return prediction
def process_and_predict(*args, encoder=encoder, scaler=scaler, model=model):
    """
    This function processes the inputs and returns the predicted churn status of the customer.
    It receives the user inputs, the encoder, scaler and model. The inputs are then put through the same process as was done during modelling, including but not limited to encoding of categorical columns and scaling of numeric columns.

    Args:
        encoder (LabelEncoder, optional): It is the encoder used to encode the categorical features before training the model, and should be loaded either as part of the ML items or as a standalone item. Defaults to encoder, which comes with the ML Items dictionary.
        scaler (MinMaxScaler, optional): It is the scaler (MinMaxScaler) used to scale the numeric features before training the model, and should be loaded either as part of the ML Items or as a standalone item. Defaults to scaler, which comes with the ML Items dictionary.
        model (XGBoost, optional): This is the model that was trained and is to be used for the prediction. It defaults to "model", as loaded from the ML toolkit.

    Returns:
        Prediction (label): Returns the label of the predicted class, i.e. one of whether the given customer will churn or not.
    """

    # Convert inputs into a DataFrame
    input_data = pd.DataFrame([args], columns=expected_inputs)

    # Encode the categorical column
    input_data["tenure"] = encoder.transform(input_data["tenure"])
    
    # Scale the numeric columns
    input_data[columns_to_scale] = scaler.transform(input_data[columns_to_scale])

    # Making the prediction
    model_output = model.predict(input_data)
    return {"Prediction: CHURN": float(model_output[0]), "Prediction: STAY": 1-float(model_output[0])}


# ----- App Interface
with gr.Blocks() as turn_on_the_gradio:
    gr.Markdown("# Expresso Customer Churn Prediction")
    gr.Markdown("""This app uses a machine learning model to predict whether or not a customer will churn based on inputs made by you, the user. The (XGBoost) model was trained and built based on Zindi's Expresso Dataset. You may refer to the expander at the bottom for more information on the inputs.""")
    
    # Phase 1: Receiving Inputs
    # Usage
    gr.Markdown("**Customer Usage Data**")
    with gr.Row():
        montant = gr.Slider(label="Top-up amount", minimum=20, step=1, interactive=True, value=1, maximum= 500000)
        data_volume = gr.Slider(label="Number of connections", minimum=0, step=1, interactive=True, value=1, maximum= 2000000)

    # Activity
    gr.Markdown("**Activity Levels**")
    with gr.Row():
        frequence_rech = gr.Slider(label="Recharge Frequency", minimum=1, step=1, interactive=True, value=1, maximum=220)
        freq_top_pack = gr.Slider(label="Top Package Activation Frequency", minimum=1, step=1, interactive=True, value=1, maximum=1050)
        regularity = gr.Slider(label="Days of Activity (out of 90 days)", minimum=1, step=1, interactive=True, value=1, maximum=90)        
        tenure = gr.Dropdown(label="Tenure (time on the network)", choices=["D 3-6 month", "E 6-9 month", "F 9-12 month", "G 12-15 month", "H 15-18 month", "I 18-21 month", "J 21-24 month", "K > 24 month"], value="K > 24 month")

    # Income
    gr.Markdown("**Income from the Customer**")
    with gr.Row():
        arpu_segment = gr.Slider(label="Income over the last 90 days", step=1, maximum=287000, interactive=True)
        frequence = gr.Slider(label="Number of times the customer has made an income", step=1, minimum=1, maximum=91, interactive=True)

    # Output Prediction
    output = gr.Label("Awaiting Submission...")
    submit_button = gr.Button("Submit")
    
    # Expander for more info on columns
    with gr.Accordion("Open for information on inputs"):
        gr.Markdown("""This app receives the following as inputs and processes them to return the prediction on whether a customer, given the inputs, will churn or not.
                    - arpu_segment: income over 90 days / 3
                    - churn: variable to predict - target
                    - data_volume: number of connections
                    - frequence: number of times the client has made an income
                    - frequence_rech: number of times the client recharged
                    - freq_top_pack: number of times the client has activated the top pack packages
                    - montant: top-up amount
                    - regularity: number of times the client is active for 90 days
                    - tenure: duration in the network
                    """)
    
    submit_button.click(fn = process_and_predict,
                        outputs = output,
                        inputs=[tenure, montant, frequence_rech, arpu_segment, frequence, data_volume, regularity, freq_top_pack])

turn_on_the_gradio.launch(favicon_path= r"src/app_thumbnail.png", inbrowser= True)