Update app.py

app.py

@@ -2,82 +2,57 @@ 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, LabelEncoder
+from sklearn.preprocessing import StandardScaler
 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
 
-
+# Function Definitions
 def analyze_data(data):
-    """
-    Perform initial data analysis
-    """
-    # Check for missing values
-    st.write("Missing values:")
+    st.write("### Data Analysis")
+    st.write("**Missing Values:**")
     st.write(data.isnull().sum())
-    
-    # Display statistical summary
-    st.write("Statistical summary:")
+    st.write("**Statistical Summary:**")
     st.write(data.describe())
-    
-    # Visualize correlation matrix for numeric columns
+
+    # Correlation matrix
     numeric_data = data.select_dtypes(include=['number'])
     if not numeric_data.empty:
-        st.write("Correlation Matrix:")
+        st.write("**Correlation Matrix:**")
         plt.figure(figsize=(10, 8))
         sns.heatmap(numeric_data.corr(), annot=True, cmap='coolwarm', center=0)
         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
+def prepare_data(data):
     numeric_columns = data.select_dtypes(include=['int64', 'float64']).columns
-    categorical_columns = data.select_dtypes(include=['object']).columns
-
-    # Encode categorical columns
-    for col in categorical_columns:
-        label_encoder = LabelEncoder()
-        data[col] = label_encoder.fit_transform(data[col])
+    X = data[numeric_columns[:-1]]
+    y = data[numeric_columns[-1]]
+    return X, y
 
-    # Separate features and target
-    X = data.drop(columns=[target_column])
-    y = data[target_column]
 
-    # Scale numeric features
+def preprocess_data(X_train, X_test):
     scaler = StandardScaler()
-    X[numeric_columns] = scaler.fit_transform(X[numeric_columns])
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+    return X_train_scaled, X_test_scaled, scaler
 
-    return X, y
 
-
-def train_and_evaluate_models(X_train, X_test, y_train, y_test, feature_names):
-    """
-    Train and evaluate multiple models
-    """
+def train_and_evaluate_models(X_train_scaled, X_test_scaled, y_train, y_test, feature_names):
     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)
+        model.fit(X_train_scaled, y_train)
+        train_pred = model.predict(X_train_scaled)
+        test_pred = model.predict(X_test_scaled)
 
-        # Calculate metrics
         results[name] = {
             'model': model,
             'train_rmse': np.sqrt(mean_squared_error(y_train, train_pred)),
@@ -86,81 +61,56 @@ def train_and_evaluate_models(X_train, X_test, y_train, y_test, feature_names):
             '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")
+        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}")
 
-        # 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):")
+                'Feature': feature_names,
+                'Importance': model.feature_importances_
+            }).sort_values('Importance', ascending=False)
+            st.write("**Feature Importance:**")
             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)')
+            sns.barplot(x='Importance', y='Feature', data=feature_importance)
+            plt.title('Feature Importance')
             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")
+    st.title("Housing Price Prediction")
 
     uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
-
     if uploaded_file:
-        # Load the dataset
         data = pd.read_csv(uploaded_file)
+        st.write("## Dataset Overview")
+        st.write(data.head())
 
         # Analyze the data
-        st.subheader("Data Analysis")
         analyze_data(data)
 
-        # Select target column
-        target_column = st.selectbox("Select the target column:", data.columns)
+        # Prepare the data
+        X, y = prepare_data(data)
 
-        if target_column:
-            # Preprocess the data
-            X, y = preprocess_data(data, target_column)
+        # Train-test split
+        test_size = st.slider("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)
 
-            # 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)
+        # Preprocess the data
+        X_train_scaled, X_test_scaled, scaler = preprocess_data(X_train, X_test)
 
-            # 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!")
+        # Train and evaluate models
+        st.write("## Model Training and Evaluation")
+        train_and_evaluate_models(X_train_scaled, X_test_scaled, y_train, y_test, X_train.columns)
 
 
+# Run the app
 if __name__ == "__main__":
     main()
 
-