app.py

import pandas as pd
import numpy as np
import streamlit as st
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score,
    f1_score,
    confusion_matrix,
    roc_curve,
    auc,
    precision_recall_curve,
)
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.datasets import make_classification
from mpl_toolkits.mplot3d import Axes3D

# Streamlit Configuration
st.set_page_config(
    page_title="🧠 Alzheimer's Diagnosis App",
    page_icon="💡",
    layout="wide",
)

# App Title with More Color and Brain Emoji
st.title("🧠 Early Diagnosis of Alzheimer's Disease 🧠")
st.subheader("🌟 Empowering early intervention for a healthier future! 🌟")

# Load Dataset
uploaded_file = st.file_uploader("📂 Upload your dataset (CSV format)", type=["csv"])

if uploaded_file is not None:
    data = pd.read_csv(uploaded_file)
    st.success("✅ Dataset loaded successfully! 🧠")
else:
    # Generate Synthetic Data if no file is uploaded
    st.warning("⚠️ No file uploaded. Using synthetic data. 🧠")
    X, y = make_classification(
        n_samples=1000,
        n_features=10,
        n_informative=5,
        n_redundant=2,
        n_classes=2,
        random_state=42,
    )
    columns = [f"Feature_{i}" for i in range(X.shape[1])]
    data = pd.DataFrame(X, columns=columns)
    data["AlzheimerRisk"] = y

# Display Full Dataset (250 rows)
st.write("### 🔍 Dataset Preview 🧠")
st.write(data.head(250))

if "AlzheimerRisk" not in data.columns:
    st.error("❌ Dataset must contain a column named 'AlzheimerRisk'. 🧠")
else:
    # Data Preprocessing
    st.write("### 🛠 Data Preprocessing 🧠")

    # Encode categorical columns
    label_encoders = {}
    for col in data.select_dtypes(include=["object"]).columns:
        label_encoders[col] = LabelEncoder()
        data[col] = label_encoders[col].fit_transform(data[col])

    # Display full processed dataset (250 rows)
    st.write("✅ Preprocessed Dataset 🧠", data.head(250))

    # Ensure that Alzheimer's Risk is binary
    if data['AlzheimerRisk'].dtype != 'int' and data['AlzheimerRisk'].dtype != 'bool':
        # If Alzheimer's risk is continuous, binarize it (for classification purposes)
        st.write("⚠️ Binarizing 'AlzheimerRisk' to binary classification. 🧠")
        data['AlzheimerRisk'] = (data['AlzheimerRisk'] >= 0.5).astype(int)

    # Select Features and Target
    features = [col for col in data.columns if col != "AlzheimerRisk"]
    X = data[features]
    y = data["AlzheimerRisk"]

    # Split Data
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # Train RandomForestClassifier (Improved Accuracy)
    rf_model = RandomForestClassifier(random_state=42, n_estimators=200, max_depth=10)
    rf_model.fit(X_train, y_train)

    # Evaluate Model
    y_pred = rf_model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred)

    # Display Metrics
    st.metric("🎯 Accuracy 🧠", f"{accuracy*100:.2f}%")
    st.metric("📊 F1 Score 🧠", f"{f1:.2f}")

    # Add AGE Distribution Plot
    st.write("### 📊 Age Distribution 🧠")
    if "Age" in data.columns:
        plt.figure(figsize=(10, 6))
        sns.histplot(data['Age'], kde=True, color='dodgerblue', bins=20)
        plt.title("Age Distribution 🧠")
        st.pyplot(plt.gcf())
        plt.clf()
    else:
        st.warning("⚠️ Age column not found in the dataset! 🧠")

    # Confusion Matrix
    st.write("### 📊 Confusion Matrix 🧠")
    cm = confusion_matrix(y_test, y_pred)
    fig, ax = plt.subplots(figsize=(8, 6))
    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=["No Risk", "At Risk"], yticklabels=["No Risk", "At Risk"])
    plt.title("Confusion Matrix 🧠")
    plt.ylabel("True label 🧠")
    plt.xlabel("Predicted label 🧠")
    st.pyplot(fig)
    plt.clf()

    # Feature Importance
    st.write("### 📊 Feature Importance 🧠")
    feature_importances = rf_model.feature_importances_
    sorted_idx = np.argsort(feature_importances)[::-1]
    sorted_features = np.array(features)[sorted_idx]
    sorted_importances = feature_importances[sorted_idx]
    
    # Plot Feature Importance
    plt.figure(figsize=(10, 6))
    sns.barplot(x=sorted_importances, y=sorted_features, palette="viridis")
    plt.title("Feature Importance 🧠")
    plt.xlabel("Importance Score 🧠")
    plt.ylabel("Features 🧠")
    st.pyplot(plt.gcf())
    plt.clf()

    # Add Line Graph and Area Graph
    st.write("### 📈 Line Graph 🧠")
    line_feature = st.selectbox("Select feature for Line Graph:", features)
    plt.figure(figsize=(10, 6))
    sns.lineplot(data=data, x=data.index, y=line_feature, color="green")
    plt.title(f"Line Graph of {line_feature} 🧠")
    plt.xlabel("Index 🧠")
    plt.ylabel(line_feature)
    st.pyplot(plt.gcf())
    plt.clf()

    st.write("### 📉 Area Graph 🧠")
    area_feature = st.selectbox("Select feature for Area Graph:", features)
    plt.figure(figsize=(10, 6))
    sns.lineplot(data=data, x=data.index, y=area_feature, color="orange", linewidth=2)
    plt.fill_between(data.index, data[area_feature], color="orange", alpha=0.3)
    plt.title(f"Area Graph of {area_feature} 🧠")
    plt.xlabel("Index 🧠")
    plt.ylabel(area_feature)
    st.pyplot(plt.gcf())
    plt.clf()

    # Visualizations
    st.write("### 📊 Data Visualizations 🧠")
    visualization_type = st.selectbox(
        "Choose a visualization type 🧠:",
        ["2D Scatter Plot", "3D Scatter Plot", "Bar Chart", "Pie Chart", "Histogram"],
    )

    if visualization_type == "2D Scatter Plot":
        x_col = st.selectbox("Select X-axis feature 🧠:", features)
        y_col = st.selectbox("Select Y-axis feature 🧠:", features)
        plt.figure(figsize=(10, 6))
        sns.scatterplot(data=data, x=x_col, y=y_col, hue="AlzheimerRisk", palette="viridis")
        plt.title("2D Scatter Plot 🧠")
        st.pyplot(plt.gcf())
        plt.clf()

    elif visualization_type == "3D Scatter Plot":
        x_col = st.selectbox("Select X-axis feature 🧠:", features)
        y_col = st.selectbox("Select Y-axis feature 🧠:", features)
        z_col = st.selectbox("Select Z-axis feature 🧠:", features)
        fig = plt.figure(figsize=(10, 8))
        ax = fig.add_subplot(111, projection="3d")
        scatter = ax.scatter(
            data[x_col], data[y_col], data[z_col], c=data["AlzheimerRisk"], cmap="viridis", s=50
        )
        ax.set_xlabel(x_col)
        ax.set_ylabel(y_col)
        ax.set_zlabel(z_col)
        plt.colorbar(scatter, label="AlzheimerRisk 🧠")
        st.pyplot(fig)
        plt.clf()

    elif visualization_type == "Bar Chart":
        bar_feature = st.selectbox("Select feature for Bar Chart 🧠:", features)
        plt.figure(figsize=(10, 6))
        data.groupby(bar_feature)["AlzheimerRisk"].mean().plot(kind="bar", color="skyblue")
        plt.title("Bar Chart of Risk by Feature 🧠")
        plt.xlabel(bar_feature)
        plt.ylabel("Average Risk 🧠")
        st.pyplot(plt.gcf())
        plt.clf()

    elif visualization_type == "Pie Chart":
        pie_counts = data["AlzheimerRisk"].value_counts()
        plt.figure(figsize=(8, 8))
        plt.pie(
            pie_counts,
            labels=["No Risk 🧠", "At Risk 🧠"],
            autopct="%1.1f%%",
            startangle=140,
            colors=["green", "red"],
        )
        plt.title("Distribution of Alzheimer's Risk 🧠")
        st.pyplot(plt.gcf())
        plt.clf()

    elif visualization_type == "Histogram":
        hist_feature = st.selectbox("Select feature for Histogram 🧠:", features)
        plt.figure(figsize=(10, 6))
        sns.histplot(data=data, x=hist_feature, hue="AlzheimerRisk", kde=True, palette="viridis")
        plt.title("Histogram 🧠")
        st.pyplot(plt.gcf())
        plt.clf()

    # ROC Curve
    st.write("### 📈 ROC Curve 🧠")
    y_proba = rf_model.predict_proba(X_test)[:, 1]
    fpr, tpr, _ = roc_curve(y_test, y_proba)
    roc_auc = auc(fpr, tpr)
    plt.figure(figsize=(10, 6))
    plt.plot(fpr, tpr, color="blue", lw=2, label=f"ROC Curve (AUC = {roc_auc:.2f}) 🧠")
    plt.plot([0, 1], [0, 1], color="gray", linestyle="--")
    plt.xlabel("False Positive Rate 🧠")
    plt.ylabel("True Positive Rate 🧠")
    plt.title("Receiver Operating Characteristic (ROC) Curve 🧠")
    plt.legend(loc="lower right")
    st.pyplot(plt.gcf())
    plt.clf()

    # Precision-Recall Curve
    st.write("### 📉 Precision-Recall Curve 🧠")
    precision, recall, _ = precision_recall_curve(y_test, y_proba)
    plt.figure(figsize=(10, 6))
    plt.plot(recall, precision, color="green", lw=2, label="Precision-Recall Curve 🧠")
    plt.xlabel("Recall 🧠")
    plt.ylabel("Precision 🧠")
    plt.title("Precision-Recall Curve 🧠")
    plt.legend(loc="upper right")
    st.pyplot(plt.gcf())
    plt.clf()

    # Prediction Tab
    st.write("### 🧮 Predict Alzheimer's Risk 🧠")
    input_data = {}
    for feature in features:
        if feature in label_encoders:  # For categorical features
            input_data[feature] = st.selectbox(f"{feature} 🔽", label_encoders[feature].classes_)
            input_data[feature] = label_encoders[feature].transform([input_data[feature]])[0]
        else:  # For numeric features
            input_data[feature] = st.number_input(f"{feature} ✏️", value=float(data[feature].mean()))

    # Predict Risk
    input_df = pd.DataFrame([input_data])
    prediction = rf_model.predict(input_df)[0]
    prediction_proba = rf_model.predict_proba(input_df)[0]

    # Display Prediction
    st.write("### 🩺 Prediction Result 🧠")
    if prediction == 1:
        st.error(f"🚨 The person is **at risk** of Alzheimer's Disease 🧠.")
    else:
        st.success(f"✅ The person is **not at risk** of Alzheimer's Disease 🧠.")
    st.write(f"🔍 Prediction Confidence 🧠: {prediction_proba[prediction]:.2f}")