Update app.py

app.py

@@ -1,343 +1,146 @@
-# -*- coding: utf-8 -*-
-"""Try.ipynb
 
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1OBe8cQMTtii9Xh1Ak5ayDewo_4UvTSD-
-"""
-
-# Step 1: Imports & Data Load
+import streamlit as st
 import pandas as pd
 import numpy as np
 import seaborn as sns
 import matplotlib.pyplot as plt
 
-from sklearn.model_selection import train_test_split, StratifiedShuffleSplit, GridSearchCV
-from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.model_selection import train_test_split, RandomizedSearchCV
+from sklearn.preprocessing import LabelEncoder, StandardScaler, KBinsDiscretizer
 from sklearn.impute import SimpleImputer
 from sklearn.decomposition import PCA
 from sklearn.manifold import TSNE
-from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier # Added RandomForestClassifier here
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.naive_bayes import GaussianNB
+from sklearn.svm import SVC
+from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, RocCurveDisplay
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+from scipy.stats import uniform, randint
+
+st.set_option('deprecation.showPyplotGlobalUse', False)
+
+st.title("Electric Vehicle ML Pipeline Dashboard")
 
-print("\n1. DATA LOADING & INITIAL INSPECTION …………………………………………")
+# Load dataset
+@st.cache_data
+def load_data():
+    url = "https://drive.google.com/uc?export=download&id=1QBTnXxORRbJzE5Z2aqKHsVqgB7mqowiN"
+    return pd.read_csv(url)
 
-url = "https://drive.google.com/uc?export=download&id=1QBTnXxORRbJzE5Z2aqKHsVqgB7mqowiN"
-df = pd.read_csv(url)
-print(df.head(3))
-print("Shape:", df.shape)
+df = load_data()
+st.subheader("1. Dataset Preview")
+st.write(df.head())
 
-# Check nulls
-print(df.isna().sum())
-# Fill object columns with mode, number columns with median
+# Fill missing values
 for col in df.select_dtypes(include='object').columns:
     df[col] = df[col].fillna(df[col].mode()[0])
 for col in df.select_dtypes(include=np.number).columns:
     df[col] = df[col].fillna(df[col].median())
 
-# Outlier removal (IQR method, numeric columns)
-num_cols = df.select_dtypes(include=np.number).columns
-Q1 = df[num_cols].quantile(0.25)
-Q3 = df[num_cols].quantile(0.75)
+# Outlier Removal
+Q1 = df.quantile(0.25)
+Q3 = df.quantile(0.75)
 IQR = Q3 - Q1
-mask = ~((df[num_cols] < (Q1 - 1.5 * IQR)) | (df[num_cols] > (Q3 + 1.5 * IQR))).any(axis=1)
-df = df[mask]
+df = df[~((df < (Q1 - 1.5 * IQR)) | (df > (Q3 + 1.5 * IQR))).any(axis=1)]
 
-# Encode categorical columns
-from sklearn.preprocessing import LabelEncoder
+# Encoding
 cat_cols = df.select_dtypes(include='object').columns
-le_dict = {}
 for col in cat_cols:
     le = LabelEncoder()
     df[col] = le.fit_transform(df[col])
-    le_dict[col] = le  # Save for later decoding if needed
-
-print(df.head())
-
-# Univariate analysis: Numeric
-num_cols = df.select_dtypes(include=['int64', 'float64']).columns
-for col in num_cols:
-    plt.figure(figsize=(6,3))
-    sns.histplot(df[col].dropna(), kde=True)
-    plt.title(f'Distribution of {col}')
-    plt.show()
-
-if 'Make' in df.columns and 'Electric Range' in df.columns:
-    plt.figure(figsize=(12,6))
-    sns.boxplot(x='Make', y='Electric Range', data=df)
-    plt.xticks(rotation=90)
-    plt.title('Electric Range by Make')
-    plt.show()
-
-# Pairplot of main variables (sample for large datasets)
-sample_df = df.sample(min(1000, len(df)), random_state=42)
-if len(num_cols) > 1:
-    sns.pairplot(sample_df[num_cols])
-    plt.suptitle('Pairplot of Numeric Features', y=1.02)
-    plt.show()
-
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-# Assume df is already loaded
-num_cols = df.select_dtypes(include=['int64', 'float64']).columns
-corr = df[num_cols].corr()
-
-plt.figure(figsize=(10, 7))
-sns.heatmap(corr, annot=True, fmt='.2f', cmap='coolwarm')
-plt.title('Correlation Heatmap for Numeric Columns')
-plt.show()
 
-from sklearn.preprocessing import StandardScaler
-from sklearn.ensemble import RandomForestClassifier
-
-# Example new feature: Vehicle Age (if 'Model Year' exists)
+# Feature Engineering
 if 'Model Year' in df.columns:
     df['Vehicle_Age'] = 2025 - df['Model Year']
 
-# Scaling
-scaler = StandardScaler()
-X_scaled = scaler.fit_transform(df.drop('Electric Range', axis=1))  # Assume Electric Range is your target
-
-# Feature Selection (Random Forest importance)
-y = (df['Electric Range'] > df['Electric Range'].median()).astype(int)  # Binary target
-rf_fs = RandomForestClassifier(n_estimators=100, random_state=42)
-rf_fs.fit(X_scaled, y)
-importances = rf_fs.feature_importances_
-top_idx = np.argsort(importances)[::-1][:10]
-top_features = df.drop('Electric Range', axis=1).columns[top_idx]
-print("Top features:", top_features)
-
-# Feature extraction (PCA)
-from sklearn.decomposition import PCA
-pca = PCA(n_components=2, random_state=42)
-X_pca = pca.fit_transform(df[top_features])
-
-import matplotlib.pyplot as plt
-plt.figure(figsize=(7,5))
-plt.scatter(X_pca[:,0], X_pca[:,1], c=y, cmap='viridis', alpha=0.5)
-plt.title("PCA of Top Features")
-plt.xlabel("PC1")
-plt.ylabel("PC2")
-plt.show()
-
-from sklearn.model_selection import train_test_split
-
-# Subsample (optional, for balanced classes)
-df_balanced = df.groupby(y).apply(lambda x: x.sample(min(len(x), 300), random_state=42)).reset_index(drop=True)
-X = df_balanced[top_features]
-y_bal = (df_balanced['Electric Range'] > df_balanced['Electric Range'].median()).astype(int)
-X_train, X_test, y_train, y_test = train_test_split(X, y_bal, test_size=0.3, random_state=42, stratify=y_bal)
-
-from sklearn.decomposition import PCA
-from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-# Apply PCA
-pca = PCA(n_components=2)
-X_pca = pca.fit_transform(X_train)
-
-# Plot PCA results
-plt.figure(figsize=(8, 6))
-sns.scatterplot(x=X_pca[:, 0], y=X_pca[:, 1], hue=y_train, palette='Set1', s=60)
-plt.title("PCA - First 2 Principal Components")
-plt.xlabel("PC1")
-plt.ylabel("PC2")
-plt.legend(title="Electric Vehicle Type") # Note: The legend title 'Cover_Type' might be a copy-paste error from another project. It should ideally reflect the actual target variable name if desired.
-plt.grid(True)
-plt.tight_layout()
-plt.show()
-
-# Apply LDA
-# Change n_components to 1 as max_components is min(n_features, n_classes - 1) = min(10, 2 - 1) = 1
-lda = LDA(n_components=1)
-X_lda = lda.fit_transform(X_train, y_train)
-
-# Plot LDA results
-plt.figure(figsize=(8, 6))
-# LDA with n_components=1 results in a 1D array. You typically plot this on a line or use a histogram.
-# Plotting against a dummy variable or the class label itself can show separation.
-# Here, we plot it on the x-axis against a constant y-value or jittered y-values for visualization.
-# A more informative plot might be a histogram of LD1 values for each class.
-sns.histplot(x=X_lda[:, 0], hue=y_train, kde=True, palette='Set2')
-plt.title("LDA - First Linear Discriminant")
-plt.xlabel("LD1")
-plt.ylabel("Density")
-plt.legend(title="Electric Vehicle Type")
-plt.grid(True)
-plt.tight_layout()
-plt.show()
+# Modeling Prep
+target = 'Electric Range'
+y = (df[target] > df[target].median()).astype(int)
+X = df.drop(columns=[target])
 
-from sklearn.linear_model import LogisticRegression
-from sklearn.svm import SVC
-from sklearn.ensemble import GradientBoostingClassifier
-from sklearn.naive_bayes import GaussianNB
-from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, RocCurveDisplay
-import matplotlib.pyplot as plt
+# Feature Selection
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+rf = RandomForestClassifier(random_state=42)
+rf.fit(X_scaled, y)
+top_features = pd.Series(rf.feature_importances_, index=X.columns).nlargest(10).index.tolist()
+X = df[top_features]
+
+# Subsample for balance
+df['Target'] = y
+df_bal = df.groupby('Target').apply(lambda x: x.sample(min(len(x), 300), random_state=42)).reset_index(drop=True)
+X = df_bal[top_features]
+y = df_bal['Target']
+X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.3, random_state=42)
+
+# Visualization
+st.subheader("2. Data Visualization")
+
+if st.checkbox("Show Correlation Heatmap"):
+    plt.figure(figsize=(10, 6))
+    sns.heatmap(df[top_features + ['Target']].corr(), annot=True, cmap='coolwarm')
+    st.pyplot()
+
+if st.checkbox("Show PCA Plot"):
+    pca = PCA(n_components=2)
+    X_pca = pca.fit_transform(X)
+    plt.figure(figsize=(8, 5))
+    plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis', alpha=0.6)
+    plt.title("PCA Projection")
+    st.pyplot()
+
+if st.checkbox("Show t-SNE Plot"):
+    tsne = TSNE(n_components=2, random_state=42)
+    X_tsne = tsne.fit_transform(X)
+    plt.figure(figsize=(8, 5))
+    plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='plasma', alpha=0.7)
+    plt.title("t-SNE Projection")
+    st.pyplot()
+
+# Model Training
+st.subheader("3. Model Training & Evaluation")
 
-# Store models and results
 models = {
-    'Logistic Regression': LogisticRegression(max_iter=1000, penalty='l2', random_state=42),
-    'SVM': SVC(kernel='rbf', C=1.0, probability=True, random_state=42),
-    'Gradient Boosting': GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42),
+    'Logistic Regression': LogisticRegression(max_iter=1000),
+    'SVM': SVC(probability=True),
+    'Gradient Boosting': GradientBoostingClassifier(),
     'Naive Bayes': GaussianNB()
 }
 
 for name, model in models.items():
     model.fit(X_train, y_train)
     y_pred = model.predict(X_test)
-    print(f"\n===== {name} =====")
-    print(classification_report(y_test, y_pred))
-    print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
-    # ROC-AUC and curve if possible
+    st.write(f"### {name}")
+    st.text("Classification Report")
+    st.text(classification_report(y_test, y_pred))
+    st.text("Confusion Matrix")
+    st.write(confusion_matrix(y_test, y_pred))
     if hasattr(model, "predict_proba"):
-        proba = model.predict_proba(X_test)[:, 1]
-        auc = roc_auc_score(y_test, proba)
-        print("ROC-AUC:", auc)
         RocCurveDisplay.from_estimator(model, X_test, y_test)
-        plt.title(f"{name} ROC Curve")
-        plt.show()
-    else:
-        print("ROC-AUC not available for this model.")
-
-# Gradient Boosting with Binning
-from sklearn.preprocessing import KBinsDiscretizer
+        st.pyplot()
 
-binning = KBinsDiscretizer(n_bins=5, encode='ordinal', strategy='quantile')
-X_train_binned = binning.fit_transform(X_train)
-X_test_binned = binning.transform(X_test)
-gbc_bin = GradientBoostingClassifier()
-gbc_bin.fit(X_train_binned, y_train)
-y_pred_gbc_bin = gbc_bin.predict(X_test_binned)
-print("Gradient Boosting (Optimal Binning) Results:\n", classification_report(y_test, y_pred_gbc_bin))
-print("Confusion matrix:\n", confusion_matrix(y_test, y_pred_gbc_bin))
+# Hyperparameter Tuning
+st.subheader("4. Hyperparameter Tuning Summary")
 
-from sklearn.metrics import roc_auc_score, RocCurveDisplay
-import matplotlib.pyplot as plt
-
-models_to_plot = {
-    'NB': models['Naive Bayes'],
-    'LR': models['Logistic Regression'],
-    'SVM': models['SVM'],
-    'GBC': models['Gradient Boosting'],
-    'GBC_bin': gbc_bin # gbc_bin was defined in the previous cell (ipython-input-11)
-}
-
-for name, model in models_to_plot.items():
-    if hasattr(model, "predict_proba"):
-        RocCurveDisplay.from_estimator(model, X_test, y_test)
-        plt.title(name + " ROC Curve")
-        plt.show()
-        print(f"{name} ROC-AUC:", roc_auc_score(y_test, model.predict_proba(X_test)[:,1]))
-    elif hasattr(model, "decision_function"):
-        RocCurveDisplay.from_estimator(model, X_test, y_test)
-        plt.title(name + " ROC Curve")
-        plt.show()
-
-from sklearn.model_selection import RandomizedSearchCV
-from sklearn.ensemble import GradientBoostingClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.svm import SVC
-from sklearn.naive_bayes import GaussianNB
-from scipy.stats import uniform, randint
+if st.checkbox("Run Tuning"):
+    st.info("Running tuning... may take a few minutes")
 
-# Use a smaller subset for tuning (optional, but helps)
-X_sample = X_train.sample(n=min(2000, len(X_train)), random_state=42)
-y_sample = y_train.loc[X_sample.index]
+    param_dist_lr = {'C': uniform(0.01, 10), 'penalty': ['l2'], 'solver': ['lbfgs']}
+    param_dist_svm = {'C': uniform(0.1, 10)}
+    param_dist_gbc = {'n_estimators': randint(50, 150), 'learning_rate': uniform(0.01, 0.2), 'max_depth': randint(3, 6)}
 
-# Parameter distributions
-param_dist_lr = {
-    'C': uniform(0.01, 10),
-    'penalty': ['l2'],
-    'solver': ['lbfgs']
-}
-param_dist_svm = {
-    'C': uniform(0.1, 10)
-}
-param_dist_gbc = {
-    'n_estimators': randint(50, 200),
-    'learning_rate': uniform(0.01, 0.2),
-    'max_depth': randint(3, 7)
-}
-param_dist_nb = {}
-
-n_iter_search = 10  # Try 10 random combinations per model
-
-# Logistic Regression
-rs_lr = RandomizedSearchCV(
-    LogisticRegression(max_iter=1000, random_state=42),
-    param_distributions=param_dist_lr,
-    n_iter=n_iter_search, cv=3, scoring='accuracy', n_jobs=-1, random_state=42)
-rs_lr.fit(X_sample, y_sample)
-print("Best Logistic Regression params:", rs_lr.best_params_)
-
-# SVM
-
-# Run randomized search for SVM
-# The original code defines rs_svm_linear but never fits it and then tries to access rs_svm.best_estimator_
-# Let's assume the user intended to run RandomizedSearchCV for the general SVM param_dist_svm
-rs_svm = RandomizedSearchCV(
-    SVC(random_state=42, max_iter=5000),
-    param_distributions=param_dist_svm, # Use the general SVM parameter distribution
-    n_iter=5,  # Use n_iter_search for consistency
-    cv=2,
-    scoring='accuracy',
-    n_jobs=-1,
-    random_state=42
-)
-rs_svm.fit(X_sample, y_sample) # Fit the SVM RandomizedSearchCV
-print("Best SVM params:", rs_svm.best_params_)
-
-
-# Gradient Boosting
-rs_gbc = RandomizedSearchCV(
-    # Removed n_bins, encode, strategy as they are not arguments for GBC
-    GradientBoostingClassifier(random_state = 42),
-    param_distributions=param_dist_gbc,
-    n_iter=n_iter_search, cv=3, scoring='accuracy', n_jobs=-1, random_state=42)
-rs_gbc.fit(X_sample, y_sample)
-print("Best Gradient Boosting params:", rs_gbc.best_params_)
-
-# Naive Bayes (no real params, but for consistency)
-rs_nb = RandomizedSearchCV(
-    GaussianNB(), param_distributions=param_dist_nb,
-    n_iter=1, cv=3, scoring='accuracy', random_state=42)
-rs_nb.fit(X_sample, y_sample)
-print("Best Naive Bayes params:", rs_nb.best_params_) # Print best params for NB as well
-
-# Evaluate best estimators on full test set
-print("\n--- Test Set Evaluation ---")
-print("LR Test Accuracy:", rs_lr.best_estimator_.score(X_test, y_test))
-print("SVM Test Accuracy:", rs_svm.best_estimator_.score(X_test, y_test)) # Use rs_svm
-print("GBC Test Accuracy:", rs_gbc.best_estimator_.score(X_test, y_test))
-print("NB Test Accuracy:", rs_nb.best_estimator_.score(X_test, y_test))
-
-from sklearn.decomposition import PCA
-import matplotlib.pyplot as plt
-
-pca = PCA(n_components=2, random_state=42)
-X_pca = pca.fit_transform(X)
-
-plt.figure(figsize=(8,6))
-plt.scatter(X_pca[:,0], X_pca[:,1], c=y_bal, cmap='coolwarm', alpha=0.6)
-plt.title("PCA Projection of Data")
-plt.xlabel("Principal Component 1")
-plt.ylabel("Principal Component 2")
-plt.colorbar(label='Class')
-plt.show()
-
-from sklearn.manifold import TSNE
+    sample_X = X_train.sample(min(1000, len(X_train)), random_state=42)
+    sample_y = y_train.loc[sample_X.index]
 
-# t-SNE on top features
-tsne = TSNE(n_components=2, random_state=42)
-X_tsne = tsne.fit_transform(X)
+    rs_lr = RandomizedSearchCV(LogisticRegression(max_iter=1000), param_distributions=param_dist_lr, n_iter=10, cv=3)
+    rs_lr.fit(sample_X, sample_y)
+    st.write("Best Logistic Regression:", rs_lr.best_params_)
 
-plt.figure(figsize=(8,5))
-# Use y_bal for coloring as it corresponds to the subsampled data X
-plt.scatter(X_tsne[:,0], X_tsne[:,1], c=y_bal, cmap='plasma', alpha=0.7)
-plt.title("t-SNE of Features")
-plt.xlabel("t-SNE1")
-plt.ylabel("t-SNE2")
-plt.show()
+    rs_svm = RandomizedSearchCV(SVC(probability=True), param_distributions=param_dist_svm, n_iter=5, cv=2)
+    rs_svm.fit(sample_X, sample_y)
+    st.write("Best SVM:", rs_svm.best_params_)
 
+    rs_gbc = RandomizedSearchCV(GradientBoostingClassifier(), param_distributions=param_dist_gbc, n_iter=10, cv=3)
+    rs_gbc.fit(sample_X, sample_y)
+    st.write("Best Gradient Boosting:", rs_gbc.best_params_)