app.py

# Load necessary libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay
import warnings
warnings.filterwarnings("ignore")

df = pd.read_csv("pre_deployment_mental_health_dataset_balanced.csv")
df.head()

print(f"Shape of dataset: {df.shape}")
print("\nData types:")
print(df.dtypes)
print("\nMissing values:")
print(df.isnull().sum())
df.describe(include='all')

num_cols = df.select_dtypes(include=['int64', 'float64']).columns
cat_cols = df.select_dtypes(include='object').columns.drop('Soldier_ID')

for col in num_cols:
    plt.figure(figsize=(6, 4))
    sns.histplot(df[col], kde=True)
    plt.title(f'Distribution of {col}')
    plt.show()

for col in cat_cols:
    plt.figure(figsize=(6, 4))
    sns.countplot(data=df, x=col)
    plt.title(f'Counts of {col}')
    plt.xticks(rotation=45)
    plt.show()

df_cleaned = df.drop(columns=['Soldier_ID'])

# Outlier treatment
for col in ['Anxiety_Score', 'Depression_Score', 'Stress_Level']:
    upper = df_cleaned[col].quantile(0.99)
    df_cleaned[col] = np.where(df_cleaned[col] > upper, upper, df_cleaned[col])

encoded_df = df_cleaned.copy()
label_encoders = {}
for col in encoded_df.select_dtypes(include='object').columns:
    le = LabelEncoder()
    encoded_df[col] = le.fit_transform(encoded_df[col])
    label_encoders[col] = le

plt.figure(figsize=(12, 8))
sns.heatmap(encoded_df.corr(), annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Correlation Matrix')
plt.show()

X = encoded_df.drop(columns=['Risk_Level'])
y = encoded_df['Risk_Level']
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.2, random_state=42)

models = {
    'Random Forest': RandomForestClassifier(random_state=42),
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Gradient Boosting': GradientBoostingClassifier(random_state=42)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    print(f"\n{name} Classification Report:\n")
    print(classification_report(y_test, y_pred))

# Hyperparameter tuning with multiple models
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

model_configs = {
    "Logistic Regression": {
        "model": LogisticRegression(max_iter=1000),
        "params": {"model__C": [0.01, 0.1, 1, 10], "model__solver": ["liblinear", "lbfgs"]}
    },
    "Random Forest": {
        "model": RandomForestClassifier(random_state=42),
        "params": {"model__n_estimators": [100, 200], "model__max_depth": [None, 10, 20]}
    },
    "Gradient Boosting": {
        "model": GradientBoostingClassifier(random_state=42),
        "params": {"model__n_estimators": [100, 200], "model__learning_rate": [0.05, 0.1], "model__max_depth": [3, 5]}
    },
    "SVM": {
        "model": SVC(probability=True),
        "params": {"model__C": [0.1, 1, 10], "model__kernel": ["linear", "rbf"]}
    },
    "K-Nearest Neighbors": {
        "model": KNeighborsClassifier(),
        "params": {"model__n_neighbors": [3, 5, 7], "model__weights": ["uniform", "distance"]}
    },
    "Naive Bayes": {
        "model": GaussianNB(),
        "params": {}
    }
}

best_models = {}
for name, config in model_configs.items():
    pipe = Pipeline([("scaler", StandardScaler()), ("model", config["model"])])
    grid = GridSearchCV(pipe, config["params"], cv=5, scoring="f1_macro", n_jobs=-1)
    grid.fit(X_train, y_train)
    best_models[name] = {"best_estimator": grid.best_estimator_, "best_score": grid.best_score_}

best_model_name = max(best_models, key=lambda name: best_models[name]['best_score'])
print(f"\nBest Model: {best_model_name} — F1 Score: {best_models[best_model_name]['best_score']:.4f}")

best_model = LogisticRegression(max_iter=1000)
best_model.fit(X_train, y_train)
y_pred = best_model.predict(X_test)
ConfusionMatrixDisplay.from_estimator(best_model, X_test, y_test, cmap='Blues')
plt.title('Confusion Matrix - Logistic Regression')
plt.show()

import pandas as pd
import numpy as np
import gradio as gr
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# Load the dataset
df = pd.read_csv("pre_deployment_mental_health_dataset_balanced.csv")
df_clean = df.drop(columns=["Soldier_ID"])

# Encode categorical variables
label_encoders = {}
for col in df_clean.select_dtypes(include='object').columns:
    le = LabelEncoder()
    df_clean[col] = le.fit_transform(df_clean[col])
    label_encoders[col] = le

# Define features and target
X = df_clean.drop("Risk_Level", axis=1)
y = df_clean["Risk_Level"]

# Split and train model
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

# Create test profile dropdown (first 5 samples)
sample_data = df.head(5).set_index("Soldier_ID").drop(columns=["Risk_Level"])

# Define prediction function
def predict_risk(*args):
    input_dict = dict(zip(X.columns, args))

    # Encode string values before passing to model
    for col in input_dict:
        if col in label_encoders:
            val = input_dict[col]
            # If value is not already a known label, skip encoding
            if val not in label_encoders[col].classes_:
                # Decode the most frequent value instead
                fallback = label_encoders[col].classes_[0]
                input_dict[col] = label_encoders[col].transform([fallback])[0]
            else:
                input_dict[col] = label_encoders[col].transform([val])[0]


    input_df = pd.DataFrame([input_dict])
    pred = model.predict(input_df)[0]
    risk_label = label_encoders["Risk_Level"].inverse_transform([pred])[0]
    return f"🔎 Predicted Mental Health Risk: **{risk_label}**"


def autofill(soldier_id):
    row = sample_data.loc[soldier_id].copy()
    return row.tolist()




# Create Gradio interface
with gr.Blocks(title="Military Mental Health Risk Predictor") as demo:
    gr.Markdown("# 🧠 Mental Health Risk Predictor (Military)")
    gr.Markdown("Predict a soldier's mental health risk using full or quick input modes.")

    with gr.Tabs():
        # ----------------- Tab 1: Full Input Mode -----------------
        with gr.Tab("Full Input Mode"):
            gr.Markdown("### 📋 Full Feature Input")

            dropdown = gr.Dropdown(choices=list(sample_data.index), label="Auto-Fill From Soldier ID")
            autofill_btn = gr.Button("Auto-Fill")

            # Original full input fields
            age = gr.Slider(20, 60, step=1, label="Age")
            gender = gr.Radio(["Male", "Female"], label="Gender")
            rank = gr.Dropdown(["E1", "E2", "E3", "E4", "E5", "O1", "O2", "O3"], label="Rank")
            service_years = gr.Slider(1, 25, step=1, label="Service Years")
            deployment_count = gr.Slider(0, 10, step=1, label="Deployment Count")
            mental_issues = gr.Radio(["Yes", "No"], label="Previous Mental Health Issues")
            sleep = gr.Slider(0.0, 10.0, step=0.1, label="Sleep Hours")
            stress = gr.Slider(0, 10, step=1, label="Stress Level")
            anxiety = gr.Slider(0, 21, step=1, label="Anxiety Score")
            depression = gr.Slider(0, 27, step=1, label="Depression Score")
            fitness = gr.Slider(1.0, 10.0, step=0.1, label="Physical Fitness Score")
            support = gr.Slider(1.0, 10.0, step=0.1, label="Social Support Score")
            substance_use = gr.Radio(["Yes", "No"], label="Substance Use")
            combat_intensity = gr.Radio(["Low", "Moderate", "High"], label="Combat Training Intensity")
            family_status = gr.Radio(["Single", "Married", "Divorced", "Engaged"], label="Family Status")

            output_full = gr.Textbox(label="Prediction", interactive=False)

            all_inputs = [
                age, gender, rank, service_years, deployment_count,
                mental_issues, sleep, stress, anxiety, depression,
                fitness, support, substance_use, combat_intensity, family_status
            ]

            gr.Button("Submit").click(
                fn=predict_risk, 
                inputs=all_inputs, 
                outputs=output_full
            )

            autofill_btn.click(
                fn=autofill, 
                inputs=dropdown, 
                outputs=all_inputs
            )

            gr.Markdown("⚠️ Tip: Use the dropdown to quickly fill test data.")

            gr.Markdown("""
### 🟢🟠🔴 Risk Level Legend

- 🟢 **Low Risk**: Soldier shows strong mental and physical indicators. Fit for deployment without concern.
- 🟠 **Moderate Risk**: Some factors suggest reduced resilience or emerging stress. Monitor or support as needed.
- 🔴 **High Risk**: Significant signs of mental strain. Recommend further evaluation or support intervention.
""")


        # ----------------- Tab 2: Quick Input Mode -----------------
        with gr.Tab("Quick Input Mode"):
            gr.Markdown("### ⚡ Quick Mode (Important Features Only)")

            stress_q = gr.Slider(0, 10, step=1, label="Stress Level")
            anxiety_q = gr.Slider(0, 21, step=1, label="Anxiety Score")
            depression_q = gr.Slider(0, 27, step=1, label="Depression Score")
            fitness_q = gr.Slider(1.0, 10.0, step=0.1, label="Physical Fitness Score")
            support_q = gr.Slider(1.0, 10.0, step=0.1, label="Social Support Score")
            sleep_q = gr.Slider(0.0, 10.0, step=0.1, label="Sleep Hours")
            service_q = gr.Slider(1, 25, step=1, label="Service Years")

            quick_inputs = [stress_q, anxiety_q, depression_q, fitness_q, support_q, sleep_q, service_q]

            output_quick = gr.Textbox(label="Prediction", interactive=False)

            def predict_quick(stress, anxiety, depression, fitness, support, sleep, service):
                input_dict = {
                    "Stress_Level": stress,
                    "Anxiety_Score": anxiety,
                    "Depression_Score": depression,
                    "Physical_Fitness_Score": fitness,
                    "Social_Support_Score": support,
                    "Sleep_Hours": sleep,
                    "Service_Years": service
                }

                # Fill missing fields
                for col in X.columns:
                    if col not in input_dict:
                        if col in label_encoders:
                            mode_encoded = X[col].mode()[0]
                            input_dict[col] = label_encoders[col].inverse_transform([mode_encoded])[0]
                        else:
                            input_dict[col] = X[col].median()

                # ENSURE THE ORDER MATCHES X.columns
                ordered_values = [input_dict[col] for col in X.columns]
                return predict_risk(*ordered_values)




            gr.Button("Submit").click(
                fn=predict_quick,
                inputs=quick_inputs,
                outputs=output_quick
            )

            gr.Markdown("""
        ### 🟢🟠🔴 Risk Level Legend

        - 🟢 **Low Risk**: Soldier shows strong mental and physical indicators. Fit for deployment without concern.
        - 🟠 **Moderate Risk**: Some factors suggest reduced resilience or emerging stress. Monitor or support as needed.
        - 🔴 **High Risk**: Significant signs of mental strain. Recommend further evaluation or support intervention.
        """)


demo.launch()