Update app.py

app.py

@@ -2,96 +2,165 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import StandardScaler, LabelEncoder
 from sklearn.linear_model import LinearRegression
 from sklearn.ensemble import RandomForestRegressor
 from sklearn.metrics import mean_squared_error, r2_score
 import matplotlib.pyplot as plt
 import seaborn as sns
 
-# Streamlit setup
-st.title("ML Model Training and Evaluation App")
-st.write("This app allows you to upload data, analyze it, train ML models, and visualize results.")
-
-# Upload dataset
-uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
-
-# Sidebar settings
-test_size = st.sidebar.slider("Test Size (Train/Test Split)", 0.1, 0.5, 0.2)
-random_state = st.sidebar.number_input("Random State", min_value=0, max_value=100, value=42)
-models_to_train = st.sidebar.multiselect(
-    "Select Models to Train",
-    ["Linear Regression", "Random Forest"],
-    ["Linear Regression", "Random Forest"]
-)
-
-if uploaded_file:
-    # Load the dataset
-    data = pd.read_csv(uploaded_file)
-    st.write("Dataset Preview:")
-    st.dataframe(data.head())
-
-    # Analyze the data
-    if st.checkbox("Show Data Analysis"):
-        st.write("Missing Values:")
-        st.write(data.isnull().sum())
-        
-        st.write("Statistical Summary:")
-        st.write(data.describe())
-        
+
+def analyze_data(data):
+    """
+    Perform initial data analysis
+    """
+    # Check for missing values
+    st.write("Missing values:")
+    st.write(data.isnull().sum())
+    
+    # Display statistical summary
+    st.write("Statistical summary:")
+    st.write(data.describe())
+    
+    # Visualize correlation matrix for numeric columns
+    numeric_data = data.select_dtypes(include=['number'])
+    if not numeric_data.empty:
         st.write("Correlation Matrix:")
-        numeric_data = data.select_dtypes(include=['number'])
         plt.figure(figsize=(10, 8))
         sns.heatmap(numeric_data.corr(), annot=True, cmap='coolwarm', center=0)
-        st.pyplot()
+        st.pyplot(plt)
+
+
+def preprocess_data(data, target_column):
+    """
+    Preprocess the data: Handle categorical variables, missing values, and scale numeric features
+    """
+    # Fill missing values
+    data.fillna(data.mean(), inplace=True)
+
+    # Separate numeric and categorical columns
+    numeric_columns = data.select_dtypes(include=['int64', 'float64']).columns
+    categorical_columns = data.select_dtypes(include=['object']).columns
 
-    # Prepare the data
-    X, y = data.iloc[:, :-1], data.iloc[:, -1]
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
+    # Encode categorical columns
+    for col in categorical_columns:
+        label_encoder = LabelEncoder()
+        data[col] = label_encoder.fit_transform(data[col])
 
-    # Scale the data
+    # Separate features and target
+    X = data.drop(columns=[target_column])
+    y = data[target_column]
+
+    # Scale numeric features
     scaler = StandardScaler()
-    X_train_scaled = scaler.fit_transform(X_train)
-    X_test_scaled = scaler.transform(X_test)
-
-    # Train and evaluate models
-    if st.button("Train Models"):
-        results = {}
-        
-        if "Linear Regression" in models_to_train:
-            lr = LinearRegression()
-            lr.fit(X_train_scaled, y_train)
-            y_pred_train = lr.predict(X_train_scaled)
-            y_pred_test = lr.predict(X_test_scaled)
-            results["Linear Regression"] = {
-                "Train RMSE": np.sqrt(mean_squared_error(y_train, y_pred_train)),
-                "Test RMSE": np.sqrt(mean_squared_error(y_test, y_pred_test)),
-                "Train R²": r2_score(y_train, y_pred_train),
-                "Test R²": r2_score(y_test, y_pred_test)
-            }
-        
-        if "Random Forest" in models_to_train:
-            rf = RandomForestRegressor(random_state=random_state, n_estimators=100)
-            rf.fit(X_train_scaled, y_train)
-            y_pred_train = rf.predict(X_train_scaled)
-            y_pred_test = rf.predict(X_test_scaled)
-            results["Random Forest"] = {
-                "Train RMSE": np.sqrt(mean_squared_error(y_train, y_pred_train)),
-                "Test RMSE": np.sqrt(mean_squared_error(y_test, y_pred_test)),
-                "Train R²": r2_score(y_train, y_pred_train),
-                "Test R²": r2_score(y_test, y_pred_test)
-            }
-        
-        st.write("Model Results:")
-        st.json(results)
-
-        # Optional: Plot actual vs predicted for Random Forest
-        if "Random Forest" in results:
-            plt.figure(figsize=(8, 6))
-            plt.scatter(y_test, rf.predict(X_test_scaled), alpha=0.5)
-            plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
-            plt.xlabel("Actual")
-            plt.ylabel("Predicted")
-            plt.title("Random Forest: Actual vs Predicted")
-            st.pyplot()
+    X[numeric_columns] = scaler.fit_transform(X[numeric_columns])
+
+    return X, y
+
+
+def train_and_evaluate_models(X_train, X_test, y_train, y_test, feature_names):
+    """
+    Train and evaluate multiple models
+    """
+    models = {
+        'Linear Regression': LinearRegression(),
+        'Random Forest': RandomForestRegressor(n_estimators=100, random_state=42)
+    }
+    
+    results = {}
+
+    for name, model in models.items():
+        # Train the model
+        model.fit(X_train, y_train)
+
+        # Make predictions
+        train_pred = model.predict(X_train)
+        test_pred = model.predict(X_test)
+
+        # Calculate metrics
+        results[name] = {
+            'model': model,
+            'train_rmse': np.sqrt(mean_squared_error(y_train, train_pred)),
+            'test_rmse': np.sqrt(mean_squared_error(y_test, test_pred)),
+            'train_r2': r2_score(y_train, train_pred),
+            'test_r2': r2_score(y_test, test_pred)
+        }
+
+        # Display results
+        st.write(f"{name} Results:")
+        st.write(f"Training RMSE: {results[name]['train_rmse']:.2f}")
+        st.write(f"Test RMSE: {results[name]['test_rmse']:.2f}")
+        st.write(f"Training R²: {results[name]['train_r2']:.3f}")
+        st.write(f"Test R²: {results[name]['test_r2']:.3f}")
+
+        # Plot predictions
+        plot_predictions(model, X_test, y_test, f"{name} Predictions vs Actual Values")
+
+        # Feature importance for Random Forest
+        if name == 'Random Forest':
+            feature_importance = pd.DataFrame({
+                'feature': feature_names,
+                'importance': model.feature_importances_
+            }).sort_values('importance', ascending=False)
+            st.write("Feature Importance (Random Forest):")
+            st.write(feature_importance)
+
+            # Plot feature importance
+            plt.figure(figsize=(10, 6))
+            sns.barplot(x='importance', y='feature', data=feature_importance)
+            plt.title('Feature Importance (Random Forest)')
+            st.pyplot(plt)
+
+    return results
+
+
+def plot_predictions(model, X_test, y_test, title):
+    """
+    Plot actual vs predicted values
+    """
+    predictions = model.predict(X_test)
+
+    plt.figure(figsize=(10, 6))
+    plt.scatter(y_test, predictions, alpha=0.5)
+    plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
+    plt.xlabel('Actual Values')
+    plt.ylabel('Predicted Values')
+    plt.title(title)
+    st.pyplot(plt)
+
+
+def main():
+    st.title("Machine Learning Model Training and Evaluation")
+
+    uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
+
+    if uploaded_file:
+        # Load the dataset
+        data = pd.read_csv(uploaded_file)
+
+        # Analyze the data
+        st.subheader("Data Analysis")
+        analyze_data(data)
+
+        # Select target column
+        target_column = st.selectbox("Select the target column:", data.columns)
+
+        if target_column:
+            # Preprocess the data
+            X, y = preprocess_data(data, target_column)
+
+            # Split the data
+            test_size = st.slider("Select test data size:", 0.1, 0.5, 0.2)
+            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
+
+            # Train and evaluate models
+            st.subheader("Model Training and Evaluation")
+            results = train_and_evaluate_models(X_train, X_test, y_train, y_test, X.columns)
+
+            st.write("Training and evaluation completed!")
+
+
+if __name__ == "__main__":
+    main()
+