Upload 17 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/loan_applications.csv filter=lfs diff=lfs merge=lfs -text
+emi_feature_engineered.csv filter=lfs diff=lfs merge=lfs -text
+mlflow.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+# Use an official lightweight Python image
+FROM python:3.10-slim
+
+# Set the working directory
+WORKDIR /app
+
+# Install system dependencies (Required for XGBoost)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy everything (this includes your 'pages/' folder and 'models/' folder)
+COPY . .
+
+# Expose Hugging Face's default port
+EXPOSE 7860
+
+# Run the main entry point (usually named app.py or main.py)
+# Streamlit automatically detects the /pages folder for the sidebar
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,8 @@
+---
+title: EMI Eligibility Predictor
+emoji: 💰
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+---

app.py

@@ -0,0 +1,9 @@
+import streamlit as st
+
+st.set_page_config(
+    page_title="EMI Prediction System",
+    layout="wide"
+)
+
+st.title("EMI Prediction & Eligibility Platform")
+st.write("Use the sidebar to navigate between modules.")

data/loan_applications.csv

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

emi_feature_engineered.csv

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

feature_builder.py

@@ -0,0 +1,46 @@
+import pandas as pd
+
+def prepare_input_features(raw_input: dict) -> pd.DataFrame:
+    df = pd.DataFrame([raw_input])
+
+    # -------------------------------
+    # EXPENSE AGGREGATION
+    # -------------------------------
+    df["total_monthly_expenses"] = (
+        df["school_fees"]
+        + df["college_fees"]
+        + df["travel_expenses"]
+        + df["groceries_utilities"]
+        + df["other_monthly_expenses"]
+        + df["monthly_rent"]
+    )
+
+    # -------------------------------
+    # FINANCIAL RATIOS
+    # -------------------------------
+    df["debt_to_income"] = df["current_emi_amount"] / df["monthly_salary"]
+    df["expense_to_income"] = df["total_monthly_expenses"] / df["monthly_salary"]
+    df["savings_ratio"] = df["bank_balance"] / df["monthly_salary"]
+
+    # -------------------------------
+    # CREDIT RISK BUCKET (CRITICAL FIX)
+    # -------------------------------
+    df["credit_risk_bucket"] = pd.cut(
+        df["credit_score"],
+        bins=[0, 600, 700, 900],
+        labels=["Low", "Medium", "High"]
+    )
+
+    # -------------------------------
+    # EMPLOYMENT STABILITY SCORE
+    # -------------------------------
+    df["employment_stability_score"] = (
+        df["years_of_employment"] *
+        df["employment_type"].map({
+            "Government": 1.5,
+            "Private": 1.0,
+            "Self-employed": 0.8
+        })
+    )
+
+    return df

gitattributes

@@ -0,0 +1,38 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+emi_feature_engineered.csv filter=lfs diff=lfs merge=lfs -text
+mlflow.db filter=lfs diff=lfs merge=lfs -text
+data/loan_applications.csv filter=lfs diff=lfs merge=lfs -text

inference.py

@@ -0,0 +1,88 @@
+import os
+import joblib
+import pandas as pd
+import numpy as np
+from feature_builder import prepare_input_features
+
+# --------------------------------
+# PATHS
+# --------------------------------
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Ensure these match the new XGBoost models you trained
+CLASSIFIER_PATH = os.path.join(BASE_DIR, "models", "emi_classifier_final.pkl")
+REGRESSOR_PATH = os.path.join(BASE_DIR, "models", "emi_model_optimized.pkl")
+LABEL_ENCODER_PATH = os.path.join(BASE_DIR, "models", "label_encoder.pkl")
+
+# --------------------------------
+# LOAD MODELS (ONCE)
+# --------------------------------
+classifier = joblib.load(CLASSIFIER_PATH)
+regressor = joblib.load(REGRESSOR_PATH)
+# We need the label encoder to know which index corresponds to "Eligible"
+label_encoder = joblib.load(LABEL_ENCODER_PATH)
+
+# --------------------------------
+# PREDICTION FUNCTION
+# --------------------------------
+def predict_emi(raw_input: dict):
+    """
+    Returns:
+        eligibility_label (str): Eligible | High Risk | Not Eligible
+        max_emi (float): Predicted maximum EMI
+    """
+
+    # 1. FEATURE ENGINEERING
+    input_df = prepare_input_features(raw_input)
+
+    # 2. PROBABILITY-BASED CLASSIFICATION (The Fix)
+    # Get probabilities for all classes
+    probs = classifier.predict_proba(input_df)[0]
+    
+    # Create a dictionary mapping Class Name -> Probability
+    # Example: {'Eligible': 0.38, 'Not_Eligible': 0.62}
+    prob_map = {
+        label_encoder.inverse_transform([i])[0]: prob 
+        for i, prob in enumerate(probs)
+    }
+
+    # 3. THRESHOLD LOGIC (Anti-Bias)
+    # Because of the 4.5:1 imbalance, the model is "shy" to predict Eligible.
+    # We lower the requirement to 35% to give good candidates a fair chance.
+    eligible_prob = prob_map.get("Eligible", 0)
+    high_risk_prob = prob_map.get("High_Risk", 0)
+
+    if eligible_prob > 0.35:
+        ml_label = "Eligible"
+    elif high_risk_prob > 0.40:
+        ml_label = "High Risk"
+    else:
+        ml_label = "Not Eligible"
+
+    # 4. REGRESSION PREDICTION (Amount)
+    max_emi = float(regressor.predict(input_df)[0])
+    max_emi = max(max_emi, 0.0)  # Safety clamp
+
+    # 5. HARD BUSINESS RULES (The "Banker's Veto")
+    # These rules override the ML if the risk is objectively too high.
+    credit_score = input_df["credit_score"].iloc[0]
+    dti = input_df.get("debt_to_income", pd.Series([0])).iloc[0]
+    
+    # Relaxed but safe rejection criteria
+    is_hard_reject = (
+        credit_score < 400 or 
+        dti > 0.85
+    )
+
+    # 6. FINAL ELIGIBILITY LOGIC
+    if is_hard_reject:
+        eligibility_label = "Not Eligible"
+        max_emi = 0.0
+    else:
+        eligibility_label = ml_label
+
+    # If the label is "Not Eligible", we force Max EMI to 0 for consistency
+    if eligibility_label == "Not Eligible":
+        max_emi = 0.0
+
+    return eligibility_label, round(max_emi, 2)

mlflow.db

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

models/emi_classifier_final.pkl

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

models/emi_model_optimized.pkl

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

models/label_encoder.pkl

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

pages/1_Predict_EMI.py

@@ -0,0 +1,160 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from inference import predict_emi  # Ensure inference.py is in the same folder
+
+# -------------------------------
+# PAGE CONFIG
+# -------------------------------
+st.set_page_config(
+    page_title="EMI Eligibility Pro",
+    page_icon="💰",
+    layout="wide"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+    <style>
+    .main {
+        background-color: #f5f7f9;
+    }
+    .stMetric {
+        background-color: #ffffff;
+        padding: 15px;
+        border-radius: 10px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+st.title("🚀 EMI Eligibility & Risk Prediction")
+st.write("Fill in the details below to check your loan eligibility and maximum safe EMI.")
+
+# -------------------------------
+# INPUT FORM
+# -------------------------------
+with st.container():
+    # SECTION 1: Personal & Demographic
+    st.subheader("👤 Personal Information")
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        age = st.number_input("Age", 18, 70, 30)
+        gender = st.selectbox("Gender", ["Male", "Female"])
+        marital_status = st.selectbox("Marital Status", ["Single", "Married"])
+    with col2:
+        education = st.selectbox("Education", ["High School", "Graduate", "Post Graduate", "Professional"])
+        family_size = st.number_input("Family Size", 1, 10, 3)
+        dependents = st.number_input("Dependents", 0, 10, 1)
+    with col3:
+        house_type = st.selectbox("House Type", ["Rented", "Own", "Family"])
+        company_type = st.selectbox("Company Type", ["Startup", "SME", "MNC", "Government"])
+
+    st.divider()
+
+    # SECTION 2: Employment & Income
+    st.subheader("💼 Employment & Financials")
+    col4, col5, col6 = st.columns(3)
+    with col4:
+        employment_type = st.selectbox("Employment Type", ["Private", "Government", "Self-employed"])
+        years_of_employment = st.number_input("Years of Employment", 0, 40, 5)
+    with col5:
+        monthly_salary = st.number_input("Monthly Salary (INR)", 10000, 500000, 50000, step=5000)
+        credit_score = st.number_input("Credit Score", 300, 900, 700)
+    with col6:
+        bank_balance = st.number_input("Bank Balance (INR)", 0, 10000000, 200000)
+        existing_loans = st.selectbox("Existing Loans", ["No", "Yes"])
+
+    st.divider()
+
+    # SECTION 3: Expenses & Current Debt
+    st.subheader("📉 Monthly Outgoings")
+    col7, col8, col9 = st.columns(3)
+    with col7:
+        monthly_rent = st.number_input("Monthly Rent (INR)", 0, 100000, 10000)
+        current_emi_amount = st.number_input("Current EMI Totals", 0, 100000, 0)
+    with col8:
+        groceries_utilities = st.number_input("Groceries & Utilities", 0, 50000, 8000)
+        travel_expenses = st.number_input("Travel Expenses", 0, 50000, 3000)
+    with col9:
+        school_college_fees = st.number_input("Education Fees (Total)", 0, 150000, 0)
+        other_monthly_expenses = st.number_input("Other Expenses", 0, 50000, 5000)
+
+    st.divider()
+
+    # SECTION 4: Loan Details
+    st.subheader("📝 Loan Application Details")
+    col10, col11, col12 = st.columns(3)
+    with col10:
+        emi_scenario = st.selectbox("EMI Type", ["Personal Loan EMI", "Vehicle EMI", "Home Appliances EMI", "Education EMI", "E-commerce Shopping EMI"])
+    with col11:
+        requested_amount = st.number_input("Requested Loan Amount (INR)", 10000, 20000000, 300000)
+    with col12:
+        requested_tenure = st.number_input("Requested Tenure (Months)", 3, 84, 24)
+
+# -------------------------------
+# PREDICTION ENGINE
+# -------------------------------
+st.markdown("<br>", unsafe_allow_html=True)
+
+if st.button("Analyze Eligibility", use_container_width=True, type="primary"):
+    
+    # Bundle input for Inference
+    raw_input = {
+        "age": age,
+        "gender": gender,
+        "marital_status": marital_status,
+        "education": education,
+        "monthly_salary": monthly_salary,
+        "employment_type": employment_type,
+        "years_of_employment": years_of_employment,
+        "company_type": company_type,
+        "house_type": house_type,
+        "monthly_rent": monthly_rent,
+        "family_size": family_size,
+        "dependents": dependents,
+        "school_fees": school_college_fees * 0.4, # Heuristic split if your model expects separate
+        "college_fees": school_college_fees * 0.6,
+        "travel_expenses": travel_expenses,
+        "groceries_utilities": groceries_utilities,
+        "other_monthly_expenses": other_monthly_expenses,
+        "existing_loans": existing_loans,
+        "current_emi_amount": current_emi_amount,
+        "credit_score": credit_score,
+        "bank_balance": bank_balance,
+        "emergency_fund": bank_balance * 0.2, # Assumption if not provided
+        "emi_scenario": emi_scenario,
+        "requested_amount": requested_amount,
+        "requested_tenure": requested_tenure
+    }
+
+    with st.spinner("Consulting the AI Risk Model..."):
+        eligibility, max_emi = predict_emi(raw_input)
+
+    st.markdown("---")
+    
+    # DISPLAY RESULTS
+    res_col1, res_col2 = st.columns([1, 2])
+    
+    with res_col1:
+        if eligibility == "Eligible":
+            st.success(f"### Result: {eligibility} ✅")
+            st.metric("Safe EMI Limit", f"₹ {max_emi:,.2f}")
+        elif eligibility == "High Risk":
+            st.warning(f"### Result: {eligibility} ⚠️")
+            st.metric("Risk-Adjusted EMI", f"₹ {max_emi:,.2f}")
+        else:
+            st.error(f"### Result: {eligibility} ❌")
+            st.metric("Approved EMI", "₹ 0.00")
+
+    with res_col2:
+        st.write("#### AI Analysis Summary")
+        if eligibility == "Eligible":
+            st.write(f"Based on your credit score of **{credit_score}** and disposable income, you are highly likely to be approved. Your monthly surplus supports an EMI of up to **₹{max_emi:,.2f}**.")
+        elif eligibility == "High Risk":
+            st.write("You are borderline eligible. We recommend either increasing your loan tenure (to lower the monthly burden) or closing small existing debts to improve your score.")
+        else:
+            st.write("Unfortunately, based on current debt-to-income ratios and credit history, we cannot approve this loan. Try again after improving your credit score or increasing your monthly bank balance.")
+
+    # Show "What-If" Analysis
+    if eligibility != "Eligible":
+        st.info("💡 **Pro-Tip:** Lowering your 'Requested Amount' or increasing your 'Tenure' usually improves eligibility results.")

pages/2_Data_Exploration.py

@@ -0,0 +1,164 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+
+st.set_page_config(layout="wide")
+st.title("Financial Data Exploration & Insights")
+
+# -----------------------------------
+# DATA LOADING
+# -----------------------------------
+@st.cache_data
+def load_data():
+    return pd.read_csv("data/loan_applications.csv")
+
+df = load_data()
+
+st.subheader("Dataset Overview")
+st.write(f"Total Records: {len(df)}")
+st.dataframe(df.head(50), use_container_width=True)
+
+# -----------------------------------
+# SCHEMA VALIDATION
+# -----------------------------------
+required_columns = {
+    "monthly_salary",
+    "max_monthly_emi",
+    "credit_score",
+    "emi_eligibility",
+    "debt_to_income",
+    "expense_to_income",
+    "savings_ratio",
+    "credit_risk_bucket"
+}
+
+missing_cols = required_columns - set(df.columns)
+if missing_cols:
+    st.error(f"Missing required columns: {missing_cols}")
+    st.stop()
+
+# -----------------------------------
+# INTERACTIVE FILTERS
+# -----------------------------------
+st.markdown("---")
+st.subheader("Data Filters")
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    credit_range = st.slider(
+        "Credit Score Range",
+        int(df.credit_score.min()),
+        int(df.credit_score.max()),
+        (600, 800)
+    )
+
+with col2:
+    eligibility_filter = st.multiselect(
+        "EMI Eligibility",
+        options=df["emi_eligibility"].unique().tolist(),
+        default=df["emi_eligibility"].unique().tolist()
+    )
+
+with col3:
+    risk_filter = st.multiselect(
+        "Credit Risk Bucket",
+        options=df["credit_risk_bucket"].unique().tolist(),
+        default=df["credit_risk_bucket"].unique().tolist()
+    )
+
+filtered_df = df[
+    (df["credit_score"].between(*credit_range)) &
+    (df["emi_eligibility"].isin(eligibility_filter)) &
+    (df["credit_risk_bucket"].isin(risk_filter))
+]
+
+st.write(f"Filtered Records: {len(filtered_df)}")
+
+# -----------------------------------
+# VISUALIZATIONS
+# -----------------------------------
+st.markdown("---")
+st.subheader("Key Financial Visualizations")
+
+# ---- Salary vs Max EMI
+st.markdown("### Monthly Salary vs Maximum Safe EMI")
+
+fig, ax = plt.subplots()
+ax.scatter(
+    filtered_df["monthly_salary"],
+    filtered_df["max_monthly_emi"]
+)
+ax.set_xlabel("Monthly Salary (INR)")
+ax.set_ylabel("Maximum Safe EMI (INR)")
+st.pyplot(fig)
+
+# ---- Credit Score vs EMI
+st.markdown("### Credit Score vs EMI Capacity")
+
+fig, ax = plt.subplots()
+ax.scatter(
+    filtered_df["credit_score"],
+    filtered_df["max_monthly_emi"]
+)
+ax.set_xlabel("Credit Score")
+ax.set_ylabel("Maximum Safe EMI (INR)")
+st.pyplot(fig)
+
+# ---- Debt to Income Distribution
+st.markdown("### Debt-to-Income Ratio Distribution")
+
+fig, ax = plt.subplots()
+ax.hist(filtered_df["debt_to_income"], bins=30)
+ax.set_xlabel("Debt-to-Income Ratio")
+st.pyplot(fig)
+
+# ---- EMI Eligibility Breakdown
+st.markdown("### EMI Eligibility Distribution")
+eligibility_counts = filtered_df["emi_eligibility"].value_counts()
+st.bar_chart(eligibility_counts)
+
+# ---- Credit Risk Bucket Distribution
+st.markdown("### Credit Risk Bucket Distribution")
+risk_counts = filtered_df["credit_risk_bucket"].value_counts()
+st.bar_chart(risk_counts)
+
+# -----------------------------------
+# SUMMARY STATISTICS
+# -----------------------------------
+st.markdown("---")
+st.subheader("Summary Statistics")
+
+col4, col5, col6 = st.columns(3)
+
+with col4:
+    st.metric(
+        "Average Salary",
+        f"₹ {filtered_df['monthly_salary'].mean():,.0f}"
+    )
+
+with col5:
+    st.metric(
+        "Average Max EMI",
+        f"₹ {filtered_df['max_monthly_emi'].mean():,.0f}"
+    )
+
+with col6:
+    st.metric(
+        "Average Credit Score",
+        f"{filtered_df['credit_score'].mean():.0f}"
+    )
+
+# -----------------------------------
+# EXPORT OPTION
+# -----------------------------------
+st.markdown("---")
+st.subheader("Export Filtered Data")
+
+csv = filtered_df.to_csv(index=False).encode("utf-8")
+st.download_button(
+    "Download Filtered Dataset",
+    data=csv,
+    file_name="filtered_loan_data.csv",
+    mime="text/csv"
+)

pages/3_Model_Monitoring.py

@@ -0,0 +1,29 @@
+import streamlit as st
+import mlflow
+from mlflow.tracking import MlflowClient
+import pandas as pd
+
+st.title("Model Performance & Monitoring")
+
+client = MlflowClient()
+experiments = client.search_experiments()
+
+exp_names = [exp.name for exp in experiments]
+selected_exp = st.selectbox("Select Experiment", exp_names)
+
+exp = client.get_experiment_by_name(selected_exp)
+runs = client.search_runs(exp.experiment_id)
+
+runs_df = pd.DataFrame([
+    {
+        "run_id": r.info.run_id,
+        "status": r.info.status,
+        "accuracy": r.data.metrics.get("accuracy"),
+        "rmse": r.data.metrics.get("rmse"),
+    }
+    for r in runs
+])
+
+st.dataframe(runs_df)
+
+st.markdown("For full details, access the MLflow UI at http://127.0.0.1:5000")

pages/4_Admin_Panel.py

@@ -0,0 +1,19 @@
+import streamlit as st
+import pandas as pd
+
+st.title("Administrative Panel")
+st.warning("Restricted Access Authorized Users Only")
+
+uploaded_file = st.file_uploader(
+    "Upload New Loan Dataset (CSV)",
+    type=["csv"]
+)
+
+if uploaded_file:
+    df = pd.read_csv(uploaded_file)
+    st.success("Dataset uploaded successfully")
+    st.dataframe(df.head())
+
+    if st.button("Persist Dataset"):
+        df.to_csv("data/loan_applications.csv", index=False)
+        st.success("Dataset saved and ready for retraining")

requirements.txt

@@ -0,0 +1,8 @@
+streamlit
+pandas
+numpy
+scikit-learn
+xgboost
+joblib
+matplotlib
+mlflow