Update app.py

app.py

@@ -850,7 +850,12 @@ elif app_mode == "Predictions":
         # Input data for prediction
         st.subheader("Enter Data for Prediction")
         input_data = {}
-        for col in df.drop(columns=[st.session_state.model.steps[-1][0]]).columns:
+        model_columns = st.session_state.model.steps[0][1].transformers_[0][2] + st.session_state.model.steps[0][1].transformers_[1][2]
+        if not set(model_columns).issubset(set(df.drop(columns=[st.session_state.model.steps[-1][0]]).columns)):
+            st.error("The model was trained on a dataframe that contains different columns than the currently uploaded dataframe. Please upload the correct dataframe.")
+            st.stop()
+
+        for col in model_columns:
             if pd.api.types.is_numeric_dtype(df[col]):
                 input_data[col] = st.number_input(f"Enter {col}", value=df[col].mean())
             else:
@@ -858,10 +863,13 @@ elif app_mode == "Predictions":
 
         # Prediction Button
         if st.button("Make Prediction"):
-            input_df = pd.DataFrame([input_data])
-            prediction = st.session_state.model.predict(input_df)[0]
-            st.subheader("Prediction Result")
-            st.write(f"The predicted value is: {prediction}")
+            try:
+                input_df = pd.DataFrame([input_data])
+                prediction = st.session_state.model.predict(input_df)[0]
+                st.subheader("Prediction Result")
+                st.write(f"The predicted value is: {prediction}")
+            except Exception as e:
+                st.error(f"An error occurred during prediction: {e}")
     else:
         st.write("Please train a model first in the 'Model Training' section.")
 
@@ -923,7 +931,50 @@ elif app_mode == "Visualization Lab":
             y_col_funnel = st.selectbox("Select Y Column for Funnel Chart", df.columns)
             fig = px.funnel(df, x=x_col_funnel, y=y_col_funnel)
             st.plotly_chart(fig, use_container_width=True)
-        elif app_mode == "Neural Network Studio":
+
+elif app_mode == "Visualization Lab" and st.session_state.cleaned_data is not None:
+    st.subheader("Clustering Analysis")
+    df = st.session_state.cleaned_data.copy()
+
+    # Select columns for clustering
+    numerical_cols = df.select_dtypes(include=np.number).columns.tolist()
+
+    if not numerical_cols:
+        st.warning("No numerical columns found for clustering.")
+    else:
+        cluster_cols = st.multiselect("Select Columns for Clustering", numerical_cols, default=numerical_cols[:2] if len(numerical_cols) >= 2 else numerical_cols)
+
+        if cluster_cols:
+            try:
+                # Scale the data
+                scaler = StandardScaler()
+                scaled_data = scaler.fit_transform(df[cluster_cols])
+
+                # Number of clusters
+                n_clusters = st.slider("Number of Clusters", 2, 10, 3, help="Number of clusters to form.")
+
+                # Apply K-Means clustering
+                kmeans = KMeans(n_clusters=n_clusters, random_state=42)
+                clusters = kmeans.fit_predict(scaled_data)
+
+                # Add cluster labels to the DataFrame
+                df['Cluster'] = clusters
+
+                # Visualize clusters
+                if len(cluster_cols) == 2:
+                    fig = px.scatter(df, x=cluster_cols[0], y=cluster_cols[1], color='Cluster', title="K-Means Clustering")
+                    st.plotly_chart(fig, use_container_width=True)
+                elif len(cluster_cols) == 3:
+                    fig = px.scatter_3d(df, x=cluster_cols[0], y=cluster_cols[1], z=cluster_cols[2], color='Cluster', title="K-Means Clustering (3D)")
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.write("Clustering visualization is only supported for 2 or 3 selected columns.")
+
+                st.success("Clustering applied successfully!")
+            except Exception as e:
+                st.error(f"An error occurred during clustering: {e}")
+
+elif app_mode == "Neural Network Studio":
     st.title("🧠 Neural Network Studio")
 
     if st.session_state.cleaned_data is not None:
@@ -967,148 +1018,118 @@ elif app_mode == "Visualization Lab":
         # Model Training Button
         if st.button("Train Neural Network Model"):
             with st.spinner("Training neural network model..."):
-                # Split data
-                X = df[feature_columns]
-                y = df[target_column]
-                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
-
-                # Preprocessing
-                numeric_transformer = Pipeline(steps=[
-                    ('imputer', SimpleImputer(strategy='median')),
-                    ('scaler', StandardScaler())
-                ])
-                categorical_transformer = Pipeline(steps=[
-                    ('imputer', SimpleImputer(strategy='most_frequent')),
-                    ('onehot', OneHotEncoder(handle_unknown='ignore'))
-                ])
-
-                numeric_features = X_train.select_dtypes(include=['int64', 'float64']).columns
-                categorical_features = X_train.select_dtypes(include=['object']).columns
-
-                preprocessor = ColumnTransformer(
-                    transformers=[
-                        ('num', numeric_transformer, numeric_features),
-                        ('cat', categorical_transformer, categorical_features)
+                try:
+                    # Split data
+                    X = df[feature_columns]
+                    y = df[target_column]
+                    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
+
+                    # Preprocessing
+                    numeric_transformer = Pipeline(steps=[
+                        ('imputer', SimpleImputer(strategy='median')),
+                        ('scaler', StandardScaler())
+                    ])
+                    categorical_transformer = Pipeline(steps=[
+                        ('imputer', SimpleImputer(strategy='most_frequent')),
+                        ('onehot', OneHotEncoder(handle_unknown='ignore'))
                     ])
 
-                X_train_processed = preprocessor.fit_transform(X_train)
-                X_test_processed = preprocessor.transform(X_test)
-
-                # Neural Network Model Selection and Training
-                if model_type == "Simple Neural Network":
-                    import tensorflow as tf
-                    from tensorflow import keras
-                    from tensorflow.keras import layers
-
-                    model = keras.Sequential()
-                    model.add(layers.Input(shape=(X_train_processed.shape[1],)))
-                    for _ in range(hidden_layers):
-                        model.add(layers.Dense(neurons_per_layer, activation='relu'))
-                    model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)), activation='linear' if problem_type == "Regression" else 'softmax'))
-
-                    model.compile(optimizer='adam',
-                                  loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
-                                  metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
-
-                    model.fit(X_train_processed, y_train, epochs=epochs, batch_size=batch_size, validation_split=0.2, verbose=0)
-
-                    y_pred = model.predict(X_test_processed)
-                    if problem_type == "Classification":
-                         y_pred = np.argmax(y_pred, axis=1)
-
-                elif model_type == "Convolutional Neural Network (CNN)":
-                    import tensorflow as tf
-                    from tensorflow import keras
-                    from tensorflow.keras import layers
-
-                    # Reshape data for CNN (example for 1D CNN)
-                    X_train_cnn = np.expand_dims(X_train_processed, axis=2)
-                    X_test_cnn = np.expand_dims(X_test_processed, axis=2)
-
-                    model = keras.Sequential()
-                    model.add(layers.Conv1D(filters=32, kernel_size=3, activation='relu', input_shape=(X_train_cnn.shape[1], 1)))
-                    model.add(layers.MaxPooling1D(pool_size=2))
-                    model.add(layers.Flatten())
-                    model.add(layers.Dense(50, activation='relu'))
-                    model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)), activation='linear' if problem_type == "Regression" else 'softmax'))
-
-                    model.compile(optimizer='adam',
-                                  loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
-                                  metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
-
-                    model.fit(X_train_cnn, y_train, epochs=epochs_cnn, batch_size=batch_size_cnn, validation_split=0.2, verbose=0)
-
-                    y_pred = model.predict(X_test_cnn)
-                    if problem_type == "Classification":
-                        y_pred = np.argmax(y_pred, axis=1)
-
-                elif model_type == "Recurrent Neural Network (RNN)":
-                    import tensorflow as tf
-                    from tensorflow import keras
-                    from tensorflow.keras import layers
-
-                    # Reshape data for RNN (example for simple RNN)
-                    X_train_rnn = np.reshape(X_train_processed, (X_train_processed.shape[0], sequence_length, X_train_processed.shape[1] // sequence_length))
-                    X_test_rnn = np.reshape(X_test_processed, (X_test_processed.shape[0], sequence_length, X_test_processed.shape[1] // sequence_length))
-
-                    model = keras.Sequential()
-                    model.add(layers.SimpleRNN(50, activation='relu', input_shape=(X_train_rnn.shape[1], X_train_rnn.shape[2])))
-                    model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)), activation='linear' if problem_type == "Regression" else 'softmax'))
-
-                    model.compile(optimizer='adam',
-                                  loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
-                                  metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
-
-                    model.fit(X_train_rnn, y_train, epochs=epochs_rnn, batch_size=batch_size_rnn, validation_split=0.2, verbose=0)
-
-                    y_pred = model.predict(X_test_rnn)
-                    if problem_type == "Classification":
-                        y_pred = np.argmax(y_pred, axis=1)
-
-                # Evaluation
-                if problem_type == "Regression":
-                    mse = mean_squared_error(y_test, y_pred)
-                    rmse = np.sqrt(mse)
-                    mae = mean_absolute_error(y_test, y_pred)
-                    r2 = r2_score(y_test, y_pred)
-                    st.write(f"Mean Squared Error: {mse:.4f}")
-                    st.write(f"Root Mean Squared Error: {rmse:.4f}")
-                    st.write(f"Mean Absolute Error: {mae:.4f}")
-                    st.write(f"R-squared: {r2:.4f}")
-                else:
-                    accuracy = accuracy_score(y_test, y_pred)
-                    precision = precision_score(y_test, y_pred, average='weighted')
-                    recall = recall_score(y_test, y_pred, average='weighted')
-                    f1 = f1_score(y_test, y_pred, average='weighted')
-                    st.write(f"Accuracy: {accuracy:.4f}")
-                    st.write(f"Precision: {precision:.4f}")
-                    st.write(f"Recall: {recall:.4f}")
-                    st.write(f"F1 Score: {f1:.4f}")        
-            # Clustering Analysis (Example: K-Means)
-if app_mode == "Visualization Lab" and st.session_state.cleaned_data is not None:
-    st.subheader("Clustering Analysis")
-    df = st.session_state.cleaned_data.copy()
-
-    # Select columns for clustering
-    cluster_cols = st.multiselect("Select Columns for Clustering", df.select_dtypes(include=np.number).columns.tolist(), default=df.select_dtypes(include=np.number).columns.tolist()[:2])
-
-    if cluster_cols:
-        # Number of clusters
-        n_clusters = st.slider("Number of Clusters", 2, 10, 3, help="Number of clusters to form.")
-
-        # Apply K-Means clustering
-        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
-        clusters = kmeans.fit_predict(df[cluster_cols])
-
-        # Add cluster labels to the DataFrame
-        df['Cluster'] = clusters
-
-        # Visualize clusters
-        if len(cluster_cols) == 2:
-            fig = px.scatter(df, x=cluster_cols[0], y=cluster_cols[1], color='Cluster', title="K-Means Clustering")
-            st.plotly_chart(fig, use_container_width=True)
-        elif len(cluster_cols) == 3:
-            fig = px.scatter_3d(df, x=cluster_cols[0], y=cluster_cols[1], z=cluster_cols[2], color='Cluster', title="K-Means Clustering (3D)")
-            st.plotly_chart(fig, use_container_width=True)
-        else:
-            st.write("Clustering visualization is only supported for 2 or 3 selected columns.")
+                    numeric_features = X_train.select_dtypes(include=['int64', 'float64']).columns
+                    categorical_features = X_train.select_dtypes(include=['object']).columns
+
+                    preprocessor = ColumnTransformer(
+                        transformers=[
+                            ('num', numeric_transformer, numeric_features),
+                            ('cat', categorical_transformer, categorical_features)
+                        ])
+
+                    X_train_processed = preprocessor.fit_transform(X_train)
+                    X_test_processed = preprocessor.transform(X_test)
+
+                    # Neural Network Model Selection and Training
+                    if model_type == "Simple Neural Network":
+                        model = keras.Sequential()
+                        model.add(layers.Input(shape=(X_train_processed.shape[1],)))
+                        for _ in range(hidden_layers):
+                            model.add(layers.Dense(neurons_per_layer, activation='relu'))
+                        model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)), activation='linear' if problem_type == "Regression" else 'softmax'))
+
+                        model.compile(optimizer='adam',
+                                      loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
+                                      metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
+
+                        model.fit(X_train_processed, y_train, epochs=epochs, batch_size=batch_size, validation_split=0.2, verbose=0)
+
+                        y_pred = model.predict(X_test_processed)
+                        if problem_type == "Classification":
+                            y_pred = np.argmax(y_pred, axis=1)
+
+                    elif model_type == "Convolutional Neural Network (CNN)":
+                        X_train_cnn = np.expand_dims(X_train_processed, axis=2)
+                        X_test_cnn = np.expand_dims(X_test_processed, axis=2)
+
+                        model = keras.Sequential()
+                        model.add(layers.Conv1D(filters=32, kernel_size=3, activation='relu', input_shape=(X_train_cnn.shape[1], 1)))
+                        model.add(layers.MaxPooling1D(pool_size=2))
+                        model.add(layers.Flatten())
+                        model.add(layers.Dense(50, activation='relu'))
+                        model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)), activation='linear' if problem_type == "Regression" else 'softmax'))
+
+                        model.compile(optimizer='adam',
+                                      loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
+                                      metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
+
+                        model.fit(X_train_cnn, y_train, epochs=epochs_cnn, batch_size=batch_size_cnn, validation_split=0.2, verbose=0)
+
+                        y_pred = model.predict(X_test_cnn)
+                        if problem_type == "Classification":
+                            y_pred = np.argmax(y_pred, axis=1)
+
+                    elif model_type == "Recurrent Neural Network (RNN)":
+                        try:
+                            X_train_rnn = np.reshape(X_train_processed, (X_train_processed.shape[0], sequence_length, X_train_processed.shape[1] // sequence_length))
+                            X_test_rnn = np.reshape(X_test_processed, (X_test_processed.shape[0], sequence_length, X_test_processed.shape[1] // sequence_length))
+
+                            model = keras.Sequential()
+                            model.add(layers.SimpleRNN(50, activation='relu', input_shape=(X_train_rnn.shape[1], X_train_rnn.shape[2])))
+                            model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)), activation='linear' if problem_type == "Regression" else 'softmax'))
+
+                            model.compile(optimizer='adam',
+                                          loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
+                                          metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
+
+                            model.fit(X_train_rnn, y_train, epochs=epochs_rnn, batch_size=batch_size_rnn, validation_split=0.2, verbose=0)
+
+                            y_pred = model.predict(X_test_rnn)
+                            if problem_type == "Classification":
+                                y_pred = np.argmax(y_pred, axis=1)
+                        except Exception as e:
+                            st.error(f"Error during RNN training: {e}")
+                            st.stop()  # Stop execution if RNN fails
+
+                    # Evaluation
+                    if problem_type == "Regression":
+                        mse = mean_squared_error(y_test, y_pred)
+                        rmse = np.sqrt(mse)
+                        mae = mean_absolute_error(y_test, y_pred)
+                        r2 = r2_score(y_test, y_pred)
+                        st.write(f"Mean Squared Error: {mse:.4f}")
+                        st.write(f"Root Mean Squared Error: {rmse:.4f}")
+                        st.write(f"Mean Absolute Error: {mae:.4f}")
+                        st.write(f"R-squared: {r2:.4f}")
+                    else:
+                        accuracy = accuracy_score(y_test, y_pred)
+                        precision = precision_score(y_test, y_pred, average='weighted', zero_division=0) #Added zero_division
+                        recall = recall_score(y_test, y_pred, average='weighted', zero_division=0) #Added zero_division
+                        f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0) #Added zero_division
+                        st.write(f"Accuracy: {accuracy:.4f}")
+                        st.write(f"Precision: {precision:.4f}")
+                        st.write(f"Recall: {recall:.4f}")
+                        st.write(f"F1 Score: {f1:.4f}")
+                        st.write("Classification Report:")
+                        st.text(classification_report(y_test, y_pred)) #added classification report
+
+                    st.success("Model trained successfully!")
+
+                except Exception as e:
+                    st.error(f"An error occurred during training: {e}")