Upload app.py

app.py

@@ -0,0 +1,206 @@
+# 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("/Users/hassan/Desktop/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_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)
+
+# Gradio prediction function
+def predict_risk(age, gender, rank, service_years, deployment_count, mental_issues, sleep, stress, anxiety, depression, fitness, support, substance_use, combat_intensity, family_status):
+    input_df = pd.DataFrame([{
+        "Age": age,
+        "Gender": label_encoders["Gender"].transform([gender])[0],
+        "Rank": label_encoders["Rank"].transform([rank])[0],
+        "Service_Years": service_years,
+        "Deployment_Count": deployment_count,
+        "Previous_Mental_Health_Issues": label_encoders["Previous_Mental_Health_Issues"].transform([mental_issues])[0],
+        "Sleep_Hours": sleep,
+        "Stress_Level": stress,
+        "Anxiety_Score": anxiety,
+        "Depression_Score": depression,
+        "Physical_Fitness_Score": fitness,
+        "Social_Support_Score": support,
+        "Substance_Use": label_encoders["Substance_Use"].transform([substance_use])[0],
+        "Combat_Training_Intensity": label_encoders["Combat_Training_Intensity"].transform([combat_intensity])[0],
+        "Family_Status": label_encoders["Family_Status"].transform([family_status])[0]
+    }])
+    
+    pred = model.predict(input_df)[0]
+    risk_label = label_encoders["Risk_Level"].inverse_transform([pred])[0]
+    return f"🔎 Predicted Mental Health Risk: **{risk_label}**"
+
+# Gradio Interface
+demo = gr.Interface(
+    fn=predict_risk,
+    inputs=[
+        gr.Slider(20, 60, step=1, label="Age"),
+        gr.Radio(["Male", "Female"], label="Gender"),
+        gr.Dropdown(["E1", "E2", "E3", "E4", "E5", "O1", "O2", "O3"], label="Rank"),
+        gr.Slider(1, 25, step=1, label="Service Years"),
+        gr.Slider(0, 10, step=1, label="Deployment Count"),
+        gr.Radio(["Yes", "No"], label="Previous Mental Health Issues"),
+        gr.Slider(0.0, 10.0, step=0.1, label="Sleep Hours"),
+        gr.Slider(0, 10, step=1, label="Stress Level"),
+        gr.Slider(0, 21, step=1, label="Anxiety Score"),
+        gr.Slider(0, 27, step=1, label="Depression Score"),
+        gr.Slider(1.0, 10.0, step=0.1, label="Physical Fitness Score"),
+        gr.Slider(1.0, 10.0, step=0.1, label="Social Support Score"),
+        gr.Radio(["Yes", "No"], label="Substance Use"),
+        gr.Radio(["Low", "Moderate", "High"], label="Combat Training Intensity"),
+        gr.Radio(["Single", "Married", "Divorced", "Engaged"], label="Family Status")
+    ],
+    outputs="text",
+    title="🧠 Mental Health Risk Predictor (Military)",
+    description="Enter a soldier's pre-deployment details to estimate mental health risk level using logistic regression."
+)
+
+# Run the app
+demo.launch()
+