Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import pandas as pd | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import seaborn as sns | |
| from sklearn.model_selection import train_test_split, cross_val_score | |
| from sklearn.preprocessing import StandardScaler, LabelEncoder | |
| from sklearn.metrics import ( | |
| accuracy_score, precision_score, recall_score, f1_score, | |
| mean_squared_error, r2_score, silhouette_score, confusion_matrix, | |
| classification_report, mean_absolute_error | |
| ) | |
| from sklearn.linear_model import LinearRegression, LogisticRegression | |
| from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor | |
| from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor | |
| from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor | |
| from sklearn.cluster import KMeans, DBSCAN | |
| from sklearn.decomposition import PCA | |
| from utils import get_numeric_columns, get_categorical_columns, explain_machine_learning | |
| # Page configuration | |
| st.set_page_config( | |
| page_title="Machine Learning", | |
| page_icon="🤖", | |
| layout="wide" | |
| ) | |
| # Check if data is loaded | |
| if 'df' not in st.session_state or st.session_state.df is None: | |
| st.error("Please load a dataset first! Go back to the Home page.") | |
| st.stop() | |
| df = st.session_state.df | |
| # Page title | |
| st.title("🤖 Machine Learning") | |
| st.markdown(""" | |
| Apply machine learning algorithms to your data for prediction, classification, and clustering. | |
| This page helps you build and evaluate basic machine learning models. | |
| """) | |
| # Create tabs for different ML tasks | |
| tab1, tab2, tab3, tab4 = st.tabs([ | |
| "Classification", | |
| "Regression", | |
| "Clustering", | |
| "Dimensionality Reduction" | |
| ]) | |
| # Get column lists by type | |
| numeric_columns = get_numeric_columns(df) | |
| categorical_columns = get_categorical_columns(df) | |
| # Helper functions for ML | |
| def prepare_data(dataframe, target, features, test_size=0.2, random_state=42): | |
| """ | |
| Prepare data for machine learning by handling categorical features and splitting into train/test sets | |
| Parameters: | |
| ----------- | |
| dataframe : pandas.DataFrame | |
| The input dataframe | |
| target : str | |
| The target column name | |
| features : list | |
| List of feature column names | |
| test_size : float | |
| Proportion of data to use for testing | |
| random_state : int | |
| Random seed for reproducibility | |
| Returns: | |
| -------- | |
| X_train, X_test, y_train, y_test, encoders | |
| """ | |
| # Create a copy of the dataframe to avoid modifying the original | |
| data = dataframe.copy() | |
| # Drop rows with missing values in the target or features | |
| data = data.dropna(subset=[target] + features) | |
| # Separate features and target | |
| X = data[features] | |
| y = data[target] | |
| # Handle categorical features | |
| encoders = {} | |
| for col in X.select_dtypes(include=['object', 'category']).columns: | |
| encoder = LabelEncoder() | |
| X[col] = encoder.fit_transform(X[col]) | |
| encoders[col] = encoder | |
| # Encode target if it's categorical | |
| if y.dtype == 'object' or y.dtype.name == 'category': | |
| encoder = LabelEncoder() | |
| y = encoder.fit_transform(y) | |
| encoders['target'] = encoder | |
| # Split data into train and test sets | |
| X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state) | |
| return X_train, X_test, y_train, y_test, encoders | |
| def plot_feature_importance(model, feature_names, top_n=10): | |
| """ | |
| Plot feature importance for tree-based models | |
| """ | |
| if hasattr(model, 'feature_importances_'): | |
| importances = model.feature_importances_ | |
| indices = np.argsort(importances)[-top_n:] | |
| plt.figure(figsize=(10, 6)) | |
| plt.title('Feature Importance') | |
| plt.barh(range(len(indices)), importances[indices], align='center') | |
| plt.yticks(range(len(indices)), [feature_names[i] for i in indices]) | |
| plt.xlabel('Relative Importance') | |
| return plt.gcf() | |
| else: | |
| return None | |
| def plot_confusion_matrix(y_true, y_pred, labels=None): | |
| """ | |
| Plot confusion matrix for classification models | |
| """ | |
| cm = confusion_matrix(y_true, y_pred) | |
| plt.figure(figsize=(8, 6)) | |
| sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels) | |
| plt.ylabel('True Label') | |
| plt.xlabel('Predicted Label') | |
| plt.title('Confusion Matrix') | |
| return plt.gcf() | |
| def evaluate_classification(y_true, y_pred, labels=None): | |
| """ | |
| Evaluate classification model and return metrics | |
| """ | |
| metrics = { | |
| 'Accuracy': accuracy_score(y_true, y_pred), | |
| 'Precision': precision_score(y_true, y_pred, average='weighted', zero_division=0), | |
| 'Recall': recall_score(y_true, y_pred, average='weighted', zero_division=0), | |
| 'F1 Score': f1_score(y_true, y_pred, average='weighted', zero_division=0) | |
| } | |
| return metrics | |
| def evaluate_regression(y_true, y_pred): | |
| """ | |
| Evaluate regression model and return metrics | |
| """ | |
| metrics = { | |
| 'Mean Absolute Error (MAE)': mean_absolute_error(y_true, y_pred), | |
| 'Mean Squared Error (MSE)': mean_squared_error(y_true, y_pred), | |
| 'Root Mean Squared Error (RMSE)': np.sqrt(mean_squared_error(y_true, y_pred)), | |
| 'R² Score': r2_score(y_true, y_pred) | |
| } | |
| return metrics | |
| with tab1: | |
| st.header("Classification") | |
| st.markdown(""" | |
| Classification algorithms predict categorical outcomes (like yes/no, spam/not spam, or product categories). | |
| Select your target variable (what you want to predict) and the features (predictors) to build a classification model. | |
| """) | |
| # Educational content | |
| with st.expander("Learn about classification"): | |
| st.markdown(""" | |
| ### Classification in Machine Learning | |
| Classification is a supervised learning technique where the model learns from labeled data to predict discrete categories. | |
| **Common classification algorithms:** | |
| 1. **Logistic Regression**: Despite its name, it's used for binary classification. It models the probability of a binary outcome. | |
| 2. **Decision Trees**: Creates a tree-like model of decisions. Easy to understand but prone to overfitting. | |
| 3. **Random Forest**: Builds multiple decision trees and merges their predictions. More robust than a single tree. | |
| 4. **K-Nearest Neighbors (KNN)**: Classifies based on the majority class of k nearest data points. | |
| **When to use classification:** | |
| - Email spam detection (spam/not spam) | |
| - Medical diagnosis (disease present/absent) | |
| - Customer churn prediction (will churn/won't churn) | |
| - Sentiment analysis (positive/negative/neutral) | |
| **Evaluation metrics:** | |
| - **Accuracy**: Proportion of correct predictions (can be misleading with imbalanced classes) | |
| - **Precision**: How many selected items are relevant (TP/(TP+FP)) | |
| - **Recall**: How many relevant items are selected (TP/(TP+FN)) | |
| - **F1 Score**: Harmonic mean of precision and recall | |
| - **Confusion Matrix**: Table showing correct and incorrect predictions by class | |
| """) | |
| # Check if there are categorical columns for classification | |
| if not categorical_columns: | |
| st.warning("No categorical columns found in the dataset. Classification typically requires a categorical target variable.") | |
| # Input settings for classification | |
| st.subheader("Model Settings") | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| # Select target variable | |
| target_options = categorical_columns + numeric_columns | |
| target_variable = st.selectbox( | |
| "Select target variable (what to predict)", | |
| target_options, | |
| key="classification_target" | |
| ) | |
| # For numeric targets, allow user to convert to categorical | |
| if target_variable in numeric_columns: | |
| convert_target = st.checkbox("Convert numeric target to categorical bins") | |
| if convert_target: | |
| num_bins = st.slider("Number of bins", 2, 10, 3, key="classification_bins") | |
| # Create bins | |
| df[f"{target_variable}_binned"] = pd.cut( | |
| df[target_variable].dropna(), | |
| bins=num_bins, | |
| labels=[f"Bin {i+1}" for i in range(num_bins)] | |
| ) | |
| target_variable = f"{target_variable}_binned" | |
| st.success(f"Created categorical variable '{target_variable}' from numeric data.") | |
| with col2: | |
| # Select features | |
| available_features = [col for col in df.columns if col != target_variable] | |
| selected_features = st.multiselect( | |
| "Select features (predictors)", | |
| available_features, | |
| default=available_features[:min(5, len(available_features))], | |
| key="classification_features" | |
| ) | |
| # Additional settings | |
| test_size = st.slider("Test set size (%)", 10, 50, 20, key="classification_test_size") | |
| # Select classification algorithm | |
| algorithm = st.selectbox( | |
| "Select classification algorithm", | |
| ["Logistic Regression", "Decision Tree", "Random Forest", "K-Nearest Neighbors"], | |
| key="classification_algorithm" | |
| ) | |
| # Algorithm-specific parameters | |
| if algorithm == "Logistic Regression": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| c_param = st.slider("Regularization strength (C)", 0.01, 10.0, 1.0, key="logistic_c") | |
| with col2: | |
| max_iter = st.slider("Maximum iterations", 100, 1000, 100, step=100, key="logistic_iter") | |
| model_params = { | |
| "C": c_param, | |
| "max_iter": max_iter, | |
| "random_state": 42 | |
| } | |
| elif algorithm == "Decision Tree": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| max_depth = st.slider("Maximum depth", 1, 20, 5, key="dt_depth") | |
| with col2: | |
| min_samples_split = st.slider("Minimum samples to split", 2, 20, 2, key="dt_split") | |
| model_params = { | |
| "max_depth": max_depth, | |
| "min_samples_split": min_samples_split, | |
| "random_state": 42 | |
| } | |
| elif algorithm == "Random Forest": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| n_estimators = st.slider("Number of trees", 10, 200, 100, step=10, key="rf_trees") | |
| with col2: | |
| max_depth = st.slider("Maximum depth", 1, 20, 5, key="rf_depth") | |
| model_params = { | |
| "n_estimators": n_estimators, | |
| "max_depth": max_depth, | |
| "random_state": 42 | |
| } | |
| elif algorithm == "K-Nearest Neighbors": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| n_neighbors = st.slider("Number of neighbors (k)", 1, 20, 5, key="knn_k") | |
| with col2: | |
| weights = st.selectbox( | |
| "Weight function", | |
| ["uniform", "distance"], | |
| key="knn_weights" | |
| ) | |
| model_params = { | |
| "n_neighbors": n_neighbors, | |
| "weights": weights | |
| } | |
| # Train model button | |
| if st.button("Train Classification Model", key="train_classification"): | |
| if not selected_features: | |
| st.error("Please select at least one feature.") | |
| else: | |
| # Create progress bar | |
| progress_bar = st.progress(0) | |
| status_text = st.empty() | |
| try: | |
| # Progress update | |
| status_text.text("Preparing data...") | |
| progress_bar.progress(10) | |
| # Prepare data | |
| X_train, X_test, y_train, y_test, encoders = prepare_data( | |
| df, target_variable, selected_features, | |
| test_size=test_size/100, | |
| random_state=42 | |
| ) | |
| # Progress update | |
| status_text.text("Data prepared. Initializing model...") | |
| progress_bar.progress(30) | |
| # Initialize the model based on selected algorithm | |
| if algorithm == "Logistic Regression": | |
| model = LogisticRegression(**model_params) | |
| elif algorithm == "Decision Tree": | |
| model = DecisionTreeClassifier(**model_params) | |
| elif algorithm == "Random Forest": | |
| model = RandomForestClassifier(**model_params) | |
| elif algorithm == "K-Nearest Neighbors": | |
| model = KNeighborsClassifier(**model_params) | |
| # Progress update | |
| status_text.text("Training model...") | |
| progress_bar.progress(50) | |
| # Train model | |
| model.fit(X_train, y_train) | |
| # Progress update | |
| status_text.text("Evaluating model...") | |
| progress_bar.progress(70) | |
| # Make predictions | |
| y_pred_train = model.predict(X_train) | |
| y_pred_test = model.predict(X_test) | |
| # Evaluate model | |
| train_metrics = evaluate_classification(y_train, y_pred_train) | |
| test_metrics = evaluate_classification(y_test, y_pred_test) | |
| # Progress update | |
| status_text.text("Generating visualizations...") | |
| progress_bar.progress(90) | |
| # Display results | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| st.subheader("Training Set Performance") | |
| st.dataframe(pd.DataFrame({ | |
| 'Metric': train_metrics.keys(), | |
| 'Value': [f"{v:.4f}" for v in train_metrics.values()] | |
| })) | |
| with col2: | |
| st.subheader("Test Set Performance") | |
| st.dataframe(pd.DataFrame({ | |
| 'Metric': test_metrics.keys(), | |
| 'Value': [f"{v:.4f}" for v in test_metrics.values()] | |
| })) | |
| # Check if target was encoded and get the class labels | |
| if 'target' in encoders: | |
| class_labels = list(encoders['target'].classes_) | |
| else: | |
| class_labels = list(set(y_test)) | |
| # Display confusion matrix | |
| st.subheader("Confusion Matrix (Test Set)") | |
| cm_fig = plot_confusion_matrix(y_test, y_pred_test, labels=class_labels) | |
| st.pyplot(cm_fig) | |
| # Display feature importance for tree-based models | |
| if algorithm in ["Decision Tree", "Random Forest"]: | |
| st.subheader("Feature Importance") | |
| imp_fig = plot_feature_importance(model, selected_features) | |
| if imp_fig: | |
| st.pyplot(imp_fig) | |
| # Display classification report | |
| st.subheader("Detailed Classification Report") | |
| if 'target' in encoders: | |
| report = classification_report(y_test, y_pred_test, output_dict=True) | |
| report_df = pd.DataFrame(report).transpose() | |
| st.dataframe(report_df.style.format("{:.4f}")) | |
| else: | |
| report = classification_report(y_test, y_pred_test, output_dict=True) | |
| report_df = pd.DataFrame(report).transpose() | |
| st.dataframe(report_df.style.format("{:.4f}")) | |
| # Feature explanation | |
| st.subheader("Understanding Your Model") | |
| if algorithm == "Logistic Regression": | |
| st.markdown(""" | |
| **Logistic Regression** models the probability of the target belonging to a particular category. | |
| - **Strengths**: Simple, interpretable, and efficient for linearly separable data | |
| - **Limitations**: Cannot capture complex non-linear relationships | |
| """) | |
| elif algorithm == "Decision Tree": | |
| st.markdown(""" | |
| **Decision Trees** make predictions by following a series of if-then rules learned from the data. | |
| - **Strengths**: Intuitive, handles both numerical and categorical data, captures non-linear patterns | |
| - **Limitations**: Can create overly complex trees that don't generalize well (overfitting) | |
| The feature importance chart above shows which features were most influential in the model's decisions. | |
| """) | |
| elif algorithm == "Random Forest": | |
| st.markdown(""" | |
| **Random Forest** combines multiple decision trees to improve prediction accuracy and control overfitting. | |
| - **Strengths**: High accuracy, handles large datasets well, resistant to overfitting | |
| - **Limitations**: Less interpretable than a single decision tree, computationally intensive | |
| The feature importance chart above shows which features were most influential across all trees in the forest. | |
| """) | |
| elif algorithm == "K-Nearest Neighbors": | |
| st.markdown(""" | |
| **K-Nearest Neighbors (KNN)** classifies based on the majority class among the k closest training examples. | |
| - **Strengths**: Simple, effective, no training phase, adaptable to new data | |
| - **Limitations**: Computationally expensive for large datasets, sensitive to irrelevant features | |
| KNN doesn't have traditional feature importance, but features that create clear separation between classes are more useful. | |
| """) | |
| # Progress complete | |
| progress_bar.progress(100) | |
| status_text.text("Model training and evaluation complete!") | |
| except Exception as e: | |
| st.error(f"An error occurred during model training: {e}") | |
| progress_bar.empty() | |
| status_text.empty() | |
| with tab2: | |
| st.header("Regression") | |
| st.markdown(""" | |
| Regression algorithms predict continuous numerical values (like prices, temperatures, or ages). | |
| Select your target variable (what you want to predict) and the features (predictors) to build a regression model. | |
| """) | |
| # Educational content | |
| with st.expander("Learn about regression"): | |
| st.markdown(""" | |
| ### Regression in Machine Learning | |
| Regression is a supervised learning technique that predicts continuous numerical values, as opposed to discrete categories. | |
| **Common regression algorithms:** | |
| 1. **Linear Regression**: Models the relationship between features and target using a linear equation. | |
| 2. **Decision Tree Regression**: Similar to classification trees, but predicts continuous values at the leaves. | |
| 3. **Random Forest Regression**: Ensemble of decision trees for regression tasks. | |
| 4. **K-Nearest Neighbors Regression**: Predicts based on the average of k nearest data points. | |
| **When to use regression:** | |
| - Price prediction (houses, stocks, products) | |
| - Sales forecasting | |
| - Temperature prediction | |
| - Age estimation | |
| **Evaluation metrics:** | |
| - **Mean Absolute Error (MAE)**: Average of absolute differences between predictions and actual values | |
| - **Mean Squared Error (MSE)**: Average of squared differences (penalizes larger errors more heavily) | |
| - **Root Mean Squared Error (RMSE)**: Square root of MSE, in the same units as the target | |
| - **R² Score**: Proportion of variance explained by the model (1 is perfect, 0 is no better than the mean) | |
| """) | |
| # Check if there are numeric columns for regression | |
| if not numeric_columns: | |
| st.warning("No numeric columns found in the dataset. Regression requires a numeric target variable.") | |
| # Input settings for regression | |
| st.subheader("Model Settings") | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| # Select target variable | |
| regression_target = st.selectbox( | |
| "Select target variable (what to predict)", | |
| numeric_columns, | |
| key="regression_target" | |
| ) | |
| with col2: | |
| # Select features | |
| available_features = [col for col in df.columns if col != regression_target] | |
| regression_features = st.multiselect( | |
| "Select features (predictors)", | |
| available_features, | |
| default=available_features[:min(5, len(available_features))], | |
| key="regression_features" | |
| ) | |
| # Additional settings | |
| regression_test_size = st.slider("Test set size (%)", 10, 50, 20, key="regression_test_size") | |
| # Select regression algorithm | |
| regression_algorithm = st.selectbox( | |
| "Select regression algorithm", | |
| ["Linear Regression", "Decision Tree", "Random Forest", "K-Nearest Neighbors"], | |
| key="regression_algorithm" | |
| ) | |
| # Algorithm-specific parameters | |
| if regression_algorithm == "Linear Regression": | |
| # Linear regression doesn't have many tunable parameters | |
| st.info("Linear Regression has few hyperparameters to tune. Fit intercept is enabled by default.") | |
| elif regression_algorithm == "Decision Tree": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| dt_reg_depth = st.slider("Maximum depth", 1, 20, 5, key="dt_reg_depth") | |
| with col2: | |
| dt_reg_split = st.slider("Minimum samples to split", 2, 20, 2, key="dt_reg_split") | |
| reg_model_params = { | |
| "max_depth": dt_reg_depth, | |
| "min_samples_split": dt_reg_split, | |
| "random_state": 42 | |
| } | |
| elif regression_algorithm == "Random Forest": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| rf_reg_trees = st.slider("Number of trees", 10, 200, 100, step=10, key="rf_reg_trees") | |
| with col2: | |
| rf_reg_depth = st.slider("Maximum depth", 1, 20, 5, key="rf_reg_depth") | |
| reg_model_params = { | |
| "n_estimators": rf_reg_trees, | |
| "max_depth": rf_reg_depth, | |
| "random_state": 42 | |
| } | |
| elif regression_algorithm == "K-Nearest Neighbors": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| knn_reg_k = st.slider("Number of neighbors (k)", 1, 20, 5, key="knn_reg_k") | |
| with col2: | |
| knn_reg_weights = st.selectbox( | |
| "Weight function", | |
| ["uniform", "distance"], | |
| key="knn_reg_weights" | |
| ) | |
| reg_model_params = { | |
| "n_neighbors": knn_reg_k, | |
| "weights": knn_reg_weights | |
| } | |
| # Train model button | |
| if st.button("Train Regression Model", key="train_regression"): | |
| if not regression_features: | |
| st.error("Please select at least one feature.") | |
| else: | |
| # Create progress bar | |
| reg_progress_bar = st.progress(0) | |
| reg_status_text = st.empty() | |
| try: | |
| # Progress update | |
| reg_status_text.text("Preparing data...") | |
| reg_progress_bar.progress(10) | |
| # Prepare data | |
| X_train, X_test, y_train, y_test, _ = prepare_data( | |
| df, regression_target, regression_features, | |
| test_size=regression_test_size/100, | |
| random_state=42 | |
| ) | |
| # Progress update | |
| reg_status_text.text("Data prepared. Initializing model...") | |
| reg_progress_bar.progress(30) | |
| # Initialize the model based on selected algorithm | |
| if regression_algorithm == "Linear Regression": | |
| reg_model = LinearRegression() | |
| elif regression_algorithm == "Decision Tree": | |
| reg_model = DecisionTreeRegressor(**reg_model_params) | |
| elif regression_algorithm == "Random Forest": | |
| reg_model = RandomForestRegressor(**reg_model_params) | |
| elif regression_algorithm == "K-Nearest Neighbors": | |
| reg_model = KNeighborsRegressor(**reg_model_params) | |
| # Progress update | |
| reg_status_text.text("Training model...") | |
| reg_progress_bar.progress(50) | |
| # Train model | |
| reg_model.fit(X_train, y_train) | |
| # Progress update | |
| reg_status_text.text("Evaluating model...") | |
| reg_progress_bar.progress(70) | |
| # Make predictions | |
| y_pred_train = reg_model.predict(X_train) | |
| y_pred_test = reg_model.predict(X_test) | |
| # Evaluate model | |
| train_metrics = evaluate_regression(y_train, y_pred_train) | |
| test_metrics = evaluate_regression(y_test, y_pred_test) | |
| # Progress update | |
| reg_status_text.text("Generating visualizations...") | |
| reg_progress_bar.progress(90) | |
| # Display results | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| st.subheader("Training Set Performance") | |
| st.dataframe(pd.DataFrame({ | |
| 'Metric': train_metrics.keys(), | |
| 'Value': [f"{v:.4f}" for v in train_metrics.values()] | |
| })) | |
| with col2: | |
| st.subheader("Test Set Performance") | |
| st.dataframe(pd.DataFrame({ | |
| 'Metric': test_metrics.keys(), | |
| 'Value': [f"{v:.4f}" for v in test_metrics.values()] | |
| })) | |
| # Scatter plot of predicted vs actual values | |
| st.subheader("Predicted vs Actual Values (Test Set)") | |
| fig, ax = plt.subplots(figsize=(10, 6)) | |
| ax.scatter(y_test, y_pred_test, alpha=0.5) | |
| ax.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--') | |
| ax.set_xlabel('Actual Values') | |
| ax.set_ylabel('Predicted Values') | |
| ax.set_title('Predicted vs Actual Values') | |
| # Add a text box with R² score | |
| textstr = f'R² Score: {test_metrics["R² Score"]:.4f}' | |
| props = dict(boxstyle='round', facecolor='white', alpha=0.5) | |
| ax.text(0.05, 0.95, textstr, transform=ax.transAxes, fontsize=12, | |
| verticalalignment='top', bbox=props) | |
| st.pyplot(fig) | |
| # Residual plot | |
| st.subheader("Residual Plot (Test Set)") | |
| residuals = y_test - y_pred_test | |
| fig, ax = plt.subplots(figsize=(10, 6)) | |
| ax.scatter(y_pred_test, residuals, alpha=0.5) | |
| ax.axhline(y=0, color='r', linestyle='--') | |
| ax.set_xlabel('Predicted Values') | |
| ax.set_ylabel('Residuals') | |
| ax.set_title('Residual Plot') | |
| st.pyplot(fig) | |
| # Display feature importance for tree-based models | |
| if regression_algorithm in ["Decision Tree", "Random Forest"]: | |
| st.subheader("Feature Importance") | |
| reg_imp_fig = plot_feature_importance(reg_model, regression_features) | |
| if reg_imp_fig: | |
| st.pyplot(reg_imp_fig) | |
| # Feature explanation | |
| st.subheader("Understanding Your Model") | |
| if regression_algorithm == "Linear Regression": | |
| # Get coefficients | |
| coefficients = pd.DataFrame({ | |
| 'Feature': regression_features, | |
| 'Coefficient': reg_model.coef_ | |
| }) | |
| coefficients = coefficients.sort_values('Coefficient', key=abs, ascending=False) | |
| st.markdown("**Model Coefficients:**") | |
| st.dataframe(coefficients) | |
| st.markdown(f"**Intercept:** {reg_model.intercept_:.4f}") | |
| st.markdown(""" | |
| **Linear Regression** models the target as a linear combination of the features. | |
| - **Coefficients**: Show the change in the target for a one-unit change in the feature | |
| - **Intercept**: The predicted value when all features are zero | |
| - **Strengths**: Simple, interpretable, computationally efficient | |
| - **Limitations**: Assumes linear relationship, sensitive to outliers | |
| """) | |
| elif regression_algorithm == "Decision Tree": | |
| st.markdown(""" | |
| **Decision Tree Regression** predicts by dividing the feature space into regions and using the mean target value in each region. | |
| - **Strengths**: Captures non-linear relationships, handles both numerical and categorical data | |
| - **Limitations**: Prone to overfitting with deep trees | |
| The feature importance chart above shows which features were most influential in creating the splits in the tree. | |
| """) | |
| elif regression_algorithm == "Random Forest": | |
| st.markdown(""" | |
| **Random Forest Regression** combines multiple decision trees for better prediction and reduced overfitting. | |
| - **Strengths**: High accuracy, handles large datasets well, good with non-linear data | |
| - **Limitations**: Less interpretable, computationally intensive | |
| The feature importance chart above shows which features were most influential across all trees in the forest. | |
| """) | |
| elif regression_algorithm == "K-Nearest Neighbors": | |
| st.markdown(""" | |
| **K-Nearest Neighbors Regression** predicts the average target value of the k nearest training examples. | |
| - **Strengths**: Simple, effective for small datasets, no training phase | |
| - **Limitations**: Computationally expensive for large datasets, sensitive to irrelevant features and the scale of the data | |
| For KNN regression, the predicted value is the average of the target values for the k nearest neighbors. | |
| """) | |
| # Progress complete | |
| reg_progress_bar.progress(100) | |
| reg_status_text.text("Model training and evaluation complete!") | |
| except Exception as e: | |
| st.error(f"An error occurred during model training: {e}") | |
| reg_progress_bar.empty() | |
| reg_status_text.empty() | |
| with tab3: | |
| st.header("Clustering") | |
| st.markdown(""" | |
| Clustering algorithms group similar data points together based on their features. | |
| These are unsupervised learning techniques that find natural patterns in your data. | |
| """) | |
| # Educational content | |
| with st.expander("Learn about clustering"): | |
| st.markdown(""" | |
| ### Clustering in Machine Learning | |
| Clustering is an unsupervised learning technique that groups similar data points together without predefined labels. | |
| **Common clustering algorithms:** | |
| 1. **K-Means**: Partitions data into k clusters by minimizing the distance from data points to cluster centers. | |
| 2. **DBSCAN (Density-Based Spatial Clustering of Applications with Noise)**: Groups points in high-density regions, identifies outliers, and can find clusters of arbitrary shapes. | |
| 3. **Hierarchical Clustering**: Builds a tree of clusters by either starting with all points as individual clusters and merging (agglomerative) or starting with one cluster and dividing (divisive). | |
| **When to use clustering:** | |
| - Customer segmentation | |
| - Document categorization | |
| - Anomaly detection | |
| - Image segmentation | |
| - Recommender systems | |
| **Evaluation metrics:** | |
| - **Silhouette Score**: Measures how similar an object is to its own cluster compared to other clusters (-1 to 1, higher is better) | |
| - **Inertia**: Sum of squared distances to the nearest cluster center (lower is better, but decreases with more clusters) | |
| - **Davies-Bouldin Index**: Average similarity of each cluster with its most similar cluster (lower is better) | |
| """) | |
| # Input settings for clustering | |
| st.subheader("Model Settings") | |
| # Select features for clustering | |
| clustering_features = st.multiselect( | |
| "Select features for clustering", | |
| numeric_columns, | |
| default=numeric_columns[:min(3, len(numeric_columns))], | |
| key="clustering_features" | |
| ) | |
| # Select clustering algorithm | |
| clustering_algorithm = st.selectbox( | |
| "Select clustering algorithm", | |
| ["K-Means", "DBSCAN"], | |
| key="clustering_algorithm" | |
| ) | |
| # Algorithm-specific parameters | |
| if clustering_algorithm == "K-Means": | |
| n_clusters = st.slider("Number of clusters (k)", 2, 10, 3, key="kmeans_k") | |
| # Option to use elbow method | |
| use_elbow = st.checkbox("Use elbow method to find optimal k", value=False) | |
| if use_elbow: | |
| max_k = st.slider("Maximum k to try", 2, 15, 10, key="elbow_max_k") | |
| elif clustering_algorithm == "DBSCAN": | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| eps = st.slider("Epsilon (neighborhood size)", 0.1, 2.0, 0.5, 0.1, key="dbscan_eps") | |
| with col2: | |
| min_samples = st.slider("Minimum samples in neighborhood", 2, 20, 5, key="dbscan_min_samples") | |
| # Standardize data option | |
| standardize = st.checkbox("Standardize features (recommended)", value=True) | |
| # Run clustering button | |
| if st.button("Run Clustering", key="run_clustering"): | |
| if len(clustering_features) < 2: | |
| st.error("Please select at least two features for clustering.") | |
| else: | |
| # Create progress bar | |
| cluster_progress_bar = st.progress(0) | |
| cluster_status_text = st.empty() | |
| try: | |
| # Progress update | |
| cluster_status_text.text("Preparing data...") | |
| cluster_progress_bar.progress(10) | |
| # Extract features | |
| X = df[clustering_features].dropna() | |
| # Standardize if selected | |
| if standardize: | |
| scaler = StandardScaler() | |
| X_scaled = scaler.fit_transform(X) | |
| else: | |
| X_scaled = X.values | |
| # Progress update | |
| cluster_status_text.text("Data prepared. Running clustering algorithm...") | |
| cluster_progress_bar.progress(30) | |
| # Run clustering | |
| if clustering_algorithm == "K-Means": | |
| if use_elbow: | |
| # Calculate inertia for different k values | |
| inertia = [] | |
| k_values = range(1, max_k + 1) | |
| for k in k_values: | |
| kmeans = KMeans(n_clusters=k, random_state=42, n_init=10) | |
| kmeans.fit(X_scaled) | |
| inertia.append(kmeans.inertia_) | |
| # Plot elbow method | |
| st.subheader("Elbow Method") | |
| fig, ax = plt.subplots(figsize=(10, 6)) | |
| ax.plot(k_values, inertia, 'bo-') | |
| ax.set_xlabel('Number of Clusters (k)') | |
| ax.set_ylabel('Inertia (Sum of Squared Distances)') | |
| ax.set_title('Elbow Method for Optimal k') | |
| ax.grid(True) | |
| st.pyplot(fig) | |
| st.markdown(""" | |
| **How to interpret:** Look for the "elbow" point where the rate of decrease sharply changes. | |
| This suggests a good balance between cluster quality and number of clusters. | |
| """) | |
| # Fit final K-Means model | |
| kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10) | |
| clusters = kmeans.fit_predict(X_scaled) | |
| cluster_centers = kmeans.cluster_centers_ | |
| if standardize: | |
| # Transform cluster centers back to original scale | |
| cluster_centers = scaler.inverse_transform(cluster_centers) | |
| # Evaluate clustering | |
| silhouette_avg = silhouette_score(X_scaled, clusters) | |
| inertia = kmeans.inertia_ | |
| # Add cluster labels to data | |
| X['Cluster'] = clusters | |
| elif clustering_algorithm == "DBSCAN": | |
| # Fit DBSCAN | |
| dbscan = DBSCAN(eps=eps, min_samples=min_samples) | |
| clusters = dbscan.fit_predict(X_scaled) | |
| # Count number of clusters | |
| n_clusters = len(set(clusters)) - (1 if -1 in clusters else 0) | |
| # Evaluate clustering if more than one cluster is found | |
| if n_clusters > 1: | |
| # Filter out noise points (-1) for silhouette score | |
| if -1 in clusters: | |
| mask = clusters != -1 | |
| silhouette_avg = silhouette_score(X_scaled[mask], clusters[mask]) | |
| else: | |
| silhouette_avg = silhouette_score(X_scaled, clusters) | |
| else: | |
| silhouette_avg = "N/A (need at least 2 clusters)" | |
| # Add cluster labels to data | |
| X['Cluster'] = clusters | |
| # Progress update | |
| cluster_status_text.text("Generating visualizations...") | |
| cluster_progress_bar.progress(70) | |
| # Display results | |
| st.subheader("Clustering Results") | |
| # Display metrics | |
| col1, col2 = st.columns([1, 1]) | |
| with col1: | |
| st.metric("Number of Clusters", n_clusters) | |
| if clustering_algorithm == "K-Means": | |
| st.metric("Inertia", f"{inertia:.2f}") | |
| with col2: | |
| if isinstance(silhouette_avg, str): | |
| st.metric("Silhouette Score", silhouette_avg) | |
| else: | |
| st.metric("Silhouette Score", f"{silhouette_avg:.4f}") | |
| if clustering_algorithm == "DBSCAN": | |
| noise_count = np.sum(clusters == -1) | |
| noise_percent = noise_count / len(clusters) * 100 | |
| st.metric("Noise Points", f"{noise_count} ({noise_percent:.1f}%)") | |
| # Summary of clusters | |
| st.subheader("Cluster Summary") | |
| cluster_summary = X.groupby('Cluster').size().reset_index() | |
| cluster_summary.columns = ['Cluster', 'Count'] | |
| cluster_summary['Percentage'] = cluster_summary['Count'] / len(X) * 100 | |
| st.dataframe(cluster_summary) | |
| # Cluster profiles | |
| st.subheader("Cluster Profiles") | |
| cluster_profiles = X.groupby('Cluster')[clustering_features].mean() | |
| if clustering_algorithm == "K-Means": | |
| st.dataframe(cluster_profiles) | |
| else: | |
| st.dataframe(cluster_profiles) | |
| # Visualize clusters (select 2 features for 2D plot or 3 for 3D) | |
| st.subheader("Cluster Visualization") | |
| if len(clustering_features) >= 2: | |
| # Let user select features to visualize | |
| col1, col2, col3 = st.columns([1, 1, 1]) | |
| with col1: | |
| x_feature = st.selectbox("X-axis", clustering_features, index=0, key="cluster_viz_x") | |
| with col2: | |
| y_feature = st.selectbox("Y-axis", clustering_features, index=min(1, len(clustering_features)-1), key="cluster_viz_y") | |
| with col3: | |
| if len(clustering_features) >= 3: | |
| viz_type = st.radio("Visualization type", ["2D", "3D"], key="cluster_viz_type") | |
| if viz_type == "3D": | |
| z_feature = st.selectbox("Z-axis", clustering_features, index=min(2, len(clustering_features)-1), key="cluster_viz_z") | |
| else: | |
| viz_type = "2D" | |
| # Create the visualization | |
| if viz_type == "2D": | |
| fig, ax = plt.subplots(figsize=(10, 8)) | |
| # Create a color map that handles -1 (noise) differently | |
| cmap = plt.cm.get_cmap('tab10', n_clusters) | |
| scatter = ax.scatter(X[x_feature], X[y_feature], c=X['Cluster'], cmap=cmap, alpha=0.7) | |
| # Add cluster centers for K-Means | |
| if clustering_algorithm == "K-Means": | |
| ax.scatter( | |
| cluster_centers[:, clustering_features.index(x_feature)], | |
| cluster_centers[:, clustering_features.index(y_feature)], | |
| s=200, marker='X', c='red', label='Cluster Centers' | |
| ) | |
| ax.set_xlabel(x_feature) | |
| ax.set_ylabel(y_feature) | |
| ax.set_title(f'Clusters by {x_feature} and {y_feature}') | |
| if clustering_algorithm == "K-Means": | |
| ax.legend() | |
| plt.colorbar(scatter, label='Cluster') | |
| plt.tight_layout() | |
| st.pyplot(fig) | |
| elif viz_type == "3D" and len(clustering_features) >= 3: | |
| fig = plt.figure(figsize=(10, 8)) | |
| ax = fig.add_subplot(111, projection='3d') | |
| scatter = ax.scatter( | |
| X[x_feature], X[y_feature], X[z_feature], | |
| c=X['Cluster'], cmap='tab10', alpha=0.7 | |
| ) | |
| # Add cluster centers for K-Means | |
| if clustering_algorithm == "K-Means": | |
| ax.scatter( | |
| cluster_centers[:, clustering_features.index(x_feature)], | |
| cluster_centers[:, clustering_features.index(y_feature)], | |
| cluster_centers[:, clustering_features.index(z_feature)], | |
| s=200, marker='X', c='red', label='Cluster Centers' | |
| ) | |
| ax.set_xlabel(x_feature) | |
| ax.set_ylabel(y_feature) | |
| ax.set_zlabel(z_feature) | |
| ax.set_title(f'3D Visualization of Clusters') | |
| if clustering_algorithm == "K-Means": | |
| ax.legend() | |
| plt.colorbar(scatter, label='Cluster') | |
| plt.tight_layout() | |
| st.pyplot(fig) | |
| # Feature explanation | |
| st.subheader("Understanding Your Clustering Results") | |
| if clustering_algorithm == "K-Means": | |
| st.markdown(f""" | |
| **K-Means Clustering with k={n_clusters}** | |
| - **How it works**: Divides data into k clusters by minimizing the distance from points to cluster centers | |
| - **Strengths**: Simple, efficient, works well with globular clusters | |
| - **Limitations**: Assumes spherical clusters, sensitive to outliers, requires specifying k in advance | |
| **Interpreting the results**: | |
| - Each cluster represents a group of similar data points | |
| - Cluster centers show the "typical" values for each feature in that cluster | |
| - Higher silhouette score (closer to 1) indicates better-defined clusters | |
| """) | |
| elif clustering_algorithm == "DBSCAN": | |
| st.markdown(f""" | |
| **DBSCAN Clustering with epsilon={eps}, min_samples={min_samples}** | |
| - **How it works**: Groups points in dense regions, marks points in low-density regions as noise | |
| - **Strengths**: Doesn't require specifying number of clusters, can find arbitrary shapes, identifies outliers | |
| - **Limitations**: Sensitive to parameter choices, struggles with varying densities | |
| **Interpreting the results**: | |
| - Cluster -1 represents noise points that don't belong to any cluster | |
| - Each other cluster represents a dense region of similar data points | |
| - The silhouette score indicates how well-separated the clusters are | |
| """) | |
| # Progress complete | |
| cluster_progress_bar.progress(100) | |
| cluster_status_text.text("Clustering complete!") | |
| except Exception as e: | |
| st.error(f"An error occurred during clustering: {e}") | |
| cluster_progress_bar.empty() | |
| cluster_status_text.empty() | |
| with tab4: | |
| st.header("Dimensionality Reduction") | |
| st.markdown(""" | |
| Dimensionality reduction techniques reduce the number of features while preserving important information. | |
| This helps with visualization, addressing the curse of dimensionality, and improving model performance. | |
| """) | |
| # Educational content | |
| with st.expander("Learn about dimensionality reduction"): | |
| st.markdown(""" | |
| ### Dimensionality Reduction in Machine Learning | |
| Dimensionality reduction transforms high-dimensional data into a lower-dimensional representation while preserving important information. | |
| **Common dimensionality reduction techniques:** | |
| 1. **Principal Component Analysis (PCA)**: Creates new uncorrelated features (principal components) that capture maximum variance in the data. | |
| 2. **t-SNE (t-Distributed Stochastic Neighbor Embedding)**: Focuses on preserving local structures, good for visualization. | |
| 3. **UMAP (Uniform Manifold Approximation and Projection)**: Similar to t-SNE but better preserves global structure. | |
| **When to use dimensionality reduction:** | |
| - Visualizing high-dimensional data in 2D or 3D | |
| - Reducing computational cost for subsequent algorithms | |
| - Addressing multicollinearity in features | |
| - Removing noise from data | |
| **Benefits:** | |
| - Easier visualization | |
| - Faster training of machine learning models | |
| - Reduced risk of overfitting | |
| - Removal of multicollinearity | |
| """) | |
| # Input settings for dimensionality reduction | |
| st.subheader("Model Settings") | |
| # Select features | |
| dim_red_features = st.multiselect( | |
| "Select numeric features", | |
| numeric_columns, | |
| default=numeric_columns[:min(5, len(numeric_columns))], | |
| key="dim_red_features" | |
| ) | |
| # Select technique (currently only PCA is implemented) | |
| dim_red_technique = st.selectbox( | |
| "Select technique", | |
| ["PCA (Principal Component Analysis)"], | |
| key="dim_red_technique" | |
| ) | |
| # Select number of components | |
| if dim_red_technique == "PCA (Principal Component Analysis)": | |
| max_components = min(len(dim_red_features), 10) | |
| n_components = st.slider("Number of components", 2, max_components, 2, key="pca_components") | |
| # Standardize data option | |
| standardize_dim_red = st.checkbox("Standardize features (recommended for PCA)", value=True, key="standardize_dim_red") | |
| # Optional: color points by category | |
| color_by = st.selectbox( | |
| "Color points by (optional)", | |
| ["None"] + categorical_columns, | |
| key="dim_red_color" | |
| ) | |
| # Run dimensionality reduction button | |
| if st.button("Run Dimensionality Reduction", key="run_dim_red"): | |
| if len(dim_red_features) < 2: | |
| st.error("Please select at least two features.") | |
| else: | |
| # Create progress bar | |
| dim_red_progress_bar = st.progress(0) | |
| dim_red_status_text = st.empty() | |
| try: | |
| # Progress update | |
| dim_red_status_text.text("Preparing data...") | |
| dim_red_progress_bar.progress(10) | |
| # Extract features | |
| if color_by != "None": | |
| X_dim_red = df[dim_red_features + [color_by]].dropna() | |
| color_values = X_dim_red[color_by] | |
| X_dim_red = X_dim_red[dim_red_features] | |
| else: | |
| X_dim_red = df[dim_red_features].dropna() | |
| color_values = None | |
| # Standardize if selected | |
| if standardize_dim_red: | |
| scaler_dim_red = StandardScaler() | |
| X_scaled_dim_red = scaler_dim_red.fit_transform(X_dim_red) | |
| else: | |
| X_scaled_dim_red = X_dim_red.values | |
| # Progress update | |
| dim_red_status_text.text("Running dimensionality reduction...") | |
| dim_red_progress_bar.progress(30) | |
| # Run PCA | |
| if dim_red_technique == "PCA (Principal Component Analysis)": | |
| pca = PCA(n_components=n_components) | |
| principal_components = pca.fit_transform(X_scaled_dim_red) | |
| # Create DataFrame with principal components | |
| pc_df = pd.DataFrame( | |
| data=principal_components, | |
| columns=[f'PC{i+1}' for i in range(n_components)] | |
| ) | |
| # Add color column if specified | |
| if color_values is not None: | |
| pc_df[color_by] = color_values.reset_index(drop=True) | |
| # Get explained variance | |
| explained_variance = pca.explained_variance_ratio_ | |
| cumulative_variance = np.cumsum(explained_variance) | |
| # Get component loadings | |
| loadings = pca.components_ | |
| loading_df = pd.DataFrame( | |
| loadings.T, | |
| columns=[f'PC{i+1}' for i in range(n_components)], | |
| index=dim_red_features | |
| ) | |
| # Progress update | |
| dim_red_status_text.text("Generating visualizations...") | |
| dim_red_progress_bar.progress(70) | |
| # Display results | |
| st.subheader("Dimensionality Reduction Results") | |
| # Display explained variance | |
| if dim_red_technique == "PCA (Principal Component Analysis)": | |
| st.subheader("Explained Variance") | |
| # Create bar chart of explained variance | |
| fig, ax = plt.subplots(figsize=(10, 6)) | |
| ax.bar(range(1, n_components + 1), explained_variance * 100) | |
| ax.plot(range(1, n_components + 1), cumulative_variance * 100, 'ro-') | |
| ax.set_xlabel('Principal Component') | |
| ax.set_ylabel('Explained Variance (%)') | |
| ax.set_title('Explained Variance by Principal Component') | |
| ax.set_xticks(range(1, n_components + 1)) | |
| # Add cumulative variance as text | |
| for i, (var, cum_var) in enumerate(zip(explained_variance, cumulative_variance)): | |
| ax.text(i + 1, var * 100 + 2, f'{var:.1%}', ha='center') | |
| ax.text(i + 1, cum_var * 100 + 2, f'Cum: {cum_var:.1%}', ha='center') | |
| st.pyplot(fig) | |
| # Display component loadings | |
| st.subheader("Component Loadings") | |
| st.markdown("These show how much each original feature contributes to each principal component.") | |
| # Format loadings for display | |
| st.dataframe(loading_df.style.format("{:.3f}").background_gradient(cmap='coolwarm'), use_container_width=True) | |
| # Create heatmap of loadings | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| sns.heatmap(loading_df, annot=True, cmap='coolwarm', fmt=".2f", ax=ax) | |
| ax.set_title('PCA Component Loadings') | |
| plt.tight_layout() | |
| st.pyplot(fig) | |
| # Visualize reduced dimensions | |
| st.subheader("Visualizing Data in Reduced Dimensions") | |
| if n_components >= 2: | |
| # 2D visualization | |
| fig, ax = plt.subplots(figsize=(10, 8)) | |
| if color_values is not None: | |
| # If categorical, use discrete colors | |
| if pc_df[color_by].dtype == 'object' or pc_df[color_by].dtype.name == 'category': | |
| categories = pc_df[color_by].unique() | |
| cmap = plt.cm.get_cmap('tab10', len(categories)) | |
| # Create a color map | |
| color_dict = {cat: i for i, cat in enumerate(categories)} | |
| colors = [color_dict[val] for val in pc_df[color_by]] | |
| scatter = ax.scatter(pc_df['PC1'], pc_df['PC2'], c=colors, cmap=cmap, alpha=0.7) | |
| # Create legend | |
| handles = [plt.Line2D([0], [0], marker='o', color='w', markerfacecolor=cmap(i), | |
| markersize=10, label=cat) for i, cat in enumerate(categories)] | |
| ax.legend(handles=handles, title=color_by, loc='best') | |
| # If numeric, use continuous colormap | |
| else: | |
| scatter = ax.scatter(pc_df['PC1'], pc_df['PC2'], c=pc_df[color_by], cmap='viridis', alpha=0.7) | |
| plt.colorbar(scatter, label=color_by) | |
| else: | |
| ax.scatter(pc_df['PC1'], pc_df['PC2'], alpha=0.7) | |
| # Add axis labels with explained variance | |
| ax.set_xlabel(f'PC1 ({explained_variance[0]:.1%} variance explained)') | |
| ax.set_ylabel(f'PC2 ({explained_variance[1]:.1%} variance explained)') | |
| ax.set_title('Data in 2D Principal Component Space') | |
| st.pyplot(fig) | |
| # 3D visualization if we have at least 3 components | |
| if n_components >= 3: | |
| st.subheader("3D Visualization") | |
| fig = plt.figure(figsize=(10, 8)) | |
| ax = fig.add_subplot(111, projection='3d') | |
| if color_values is not None: | |
| # If categorical, use discrete colors | |
| if pc_df[color_by].dtype == 'object' or pc_df[color_by].dtype.name == 'category': | |
| categories = pc_df[color_by].unique() | |
| cmap = plt.cm.get_cmap('tab10', len(categories)) | |
| # Create a color map | |
| color_dict = {cat: i for i, cat in enumerate(categories)} | |
| colors = [color_dict[val] for val in pc_df[color_by]] | |
| scatter = ax.scatter(pc_df['PC1'], pc_df['PC2'], pc_df['PC3'], c=colors, cmap=cmap, alpha=0.7) | |
| # Create legend | |
| handles = [plt.Line2D([0], [0], marker='o', color='w', markerfacecolor=cmap(i), | |
| markersize=10, label=cat) for i, cat in enumerate(categories)] | |
| ax.legend(handles=handles, title=color_by, loc='best') | |
| # If numeric, use continuous colormap | |
| else: | |
| scatter = ax.scatter(pc_df['PC1'], pc_df['PC2'], pc_df['PC3'], c=pc_df[color_by], cmap='viridis', alpha=0.7) | |
| plt.colorbar(scatter, label=color_by) | |
| else: | |
| ax.scatter(pc_df['PC1'], pc_df['PC2'], pc_df['PC3'], alpha=0.7) | |
| # Add axis labels with explained variance | |
| ax.set_xlabel(f'PC1 ({explained_variance[0]:.1%})') | |
| ax.set_ylabel(f'PC2 ({explained_variance[1]:.1%})') | |
| ax.set_zlabel(f'PC3 ({explained_variance[2]:.1%})') | |
| ax.set_title('Data in 3D Principal Component Space') | |
| st.pyplot(fig) | |
| # Display transformed data | |
| st.subheader("Transformed Data") | |
| st.dataframe(pc_df.head(10), use_container_width=True) | |
| # Feature explanation | |
| st.subheader("Understanding PCA Results") | |
| st.markdown(""" | |
| **Principal Component Analysis (PCA)** | |
| - **How it works**: PCA transforms the original features into a new set of uncorrelated features (principal components) that capture the maximum variance in the data. | |
| - **Explained variance**: Shows how much information (variance) each principal component captures from the original data. Higher values mean the component is more important. | |
| - **Component loadings**: Show how each original feature contributes to each principal component. Higher absolute values (positive or negative) indicate stronger influence. | |
| - **Interpreting the visualization**: | |
| - Points that are close together in the reduced space are similar in the original high-dimensional space | |
| - Clusters in the reduced space suggest natural groupings in the data | |
| - The axes represent the directions of maximum variance in the data | |
| - **Applications**: | |
| - Data visualization | |
| - Noise reduction | |
| - Feature extraction | |
| - Preprocessing for other algorithms | |
| """) | |
| # Progress complete | |
| dim_red_progress_bar.progress(100) | |
| dim_red_status_text.text("Dimensionality reduction complete!") | |
| except Exception as e: | |
| st.error(f"An error occurred during dimensionality reduction: {e}") | |
| dim_red_progress_bar.empty() | |
| dim_red_status_text.empty() | |
| # Educational sidebar | |
| with st.sidebar: | |
| st.title("📚 Learning Corner") | |
| st.markdown(""" | |
| ### Machine Learning Fundamentals | |
| **Types of Machine Learning:** | |
| 1. **Supervised Learning** | |
| - Uses labeled data | |
| - Examples: Classification, Regression | |
| 2. **Unsupervised Learning** | |
| - Uses unlabeled data | |
| - Examples: Clustering, Dimensionality Reduction | |
| 3. **Reinforcement Learning** | |
| - Learns through interaction with an environment | |
| - Examples: Game playing, Robotics | |
| **ML Workflow:** | |
| 1. Data Collection | |
| 2. Data Preparation (cleaning, feature engineering) | |
| 3. Model Selection | |
| 4. Training | |
| 5. Evaluation | |
| 6. Deployment | |
| **Avoiding Overfitting:** | |
| - Use cross-validation | |
| - Regularization | |
| - More training data | |
| - Simpler models | |
| - Early stopping | |
| **Feature Selection:** | |
| Good features make models more accurate and efficient. Look for: | |
| - Relevance to the target | |
| - Non-redundancy | |
| - Good coverage of the problem space | |
| """) | |