Update app.py

app.py

@@ -15,6 +15,10 @@ from keras.losses import MeanSquaredError, BinaryCrossentropy
 from keras.regularizers import l2, l1
 from keras.callbacks import Callback
 
+# Debug versions
+st.write(f"TensorFlow version: {tf.__version__}")
+st.write(f"Keras version: {tf.keras.__version__}")
+
 # Set wide layout and TensorFlow Playground CSS
 st.set_page_config(layout="wide")
 st.markdown("""
@@ -298,67 +302,68 @@ with col_right:
             self.X, self.y = X, y
             self.losses = {"Epoch": [], "Train Loss": [], "Val Loss": []}
             self.placeholder = st.empty()
-            self.model = None  # Store model instance explicitly
+            self.model = None
 
         def on_train_begin(self, logs=None):
-            self.model = self.model_  # Assign the model from the fit method
+            self.model = self.model  # Use the model passed implicitly by Keras
 
         def on_epoch_end(self, epoch, logs=None):
-            self.losses["Epoch"].append(epoch + 1)
-            self.losses["Train Loss"].append(logs["loss"])
-            self.losses["Val Loss"].append(logs.get("val_loss", logs["loss"]))  # Handle missing val_loss
-            with self.placeholder.container():
-                col1, col2 = st.columns(2)
-                with col1:
-                    plt.figure(figsize=(3, 3))
-                    if problem_type == "Classification":
-                        # Use only the first two features for 2D plotting
-                        X_2d = self.X[:, :2]  # Ensure 2D input
-                        try:
-                            y_pred_proba = self.model.predict(X_2d, verbose=0)
+            try:
+                self.losses["Epoch"].append(epoch + 1)
+                self.losses["Train Loss"].append(logs["loss"])
+                self.losses["Val Loss"].append(logs.get("val_loss", logs["loss"]))
+                with self.placeholder.container():
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        plt.figure(figsize=(3, 3))
+                        if problem_type == "Classification":
+                            X_2d = self.X[:, :2]  # Use only first two features for 2D
+                            y_pred_proba = self.model.predict(X_2d, verbose=0) if self.model else np.zeros((len(X_2d), 1))
                             y_pred = (y_pred_proba > 0.5).astype(int).ravel()
-                            plot_decision_regions(X_2d, self.y, clf=self.model, legend=2, colors='blue,red')
-                            plt.scatter(X_2d[:, 0], X_2d[:, 1], c=self.y, cmap='coolwarm', edgecolors='k', alpha=0.7)
-                            # Add decision boundary contour
-                            xx, yy = np.meshgrid(np.linspace(X_2d[:, 0].min(), X_2d[:, 0].max(), 100),
-                                                 np.linspace(X_2d[:, 1].min(), X_2d[:, 1].max(), 100))
-                            grid = np.c_[xx.ravel(), yy.ravel()]
-                            Z = self.model.predict(grid, verbose=0)
-                            Z = (Z > 0.5).astype(int).reshape(xx.shape)
-                            plt.contour(xx, yy, Z, levels=[0.5], colors='black', linewidths=2)
-                        except Exception as e:
-                            st.warning(f"Decision region plot failed: {e}")
-                            xx, yy = np.meshgrid(np.linspace(X_2d[:, 0].min(), X_2d[:, 0].max(), 100),
-                                                 np.linspace(X_2d[:, 1].min(), X_2d[:, 1].max(), 100))
-                            grid = np.c_[xx.ravel(), yy.ravel()]
-                            Z = self.model.predict(grid, verbose=0) if self.model else np.zeros_like(grid[:, 0])
-                            Z = (Z > 0.5).astype(int).reshape(xx.shape)
-                            plt.contour(xx, yy, Z, levels=[0.5], colors='black', linewidths=2)
-                            plt.contourf(xx, yy, Z, alpha=0.3, cmap="coolwarm")
-                            plt.scatter(X_2d[:, 0], X_2d[:, 1], c=self.y, cmap="coolwarm", edgecolors="k", alpha=0.7)
-                    else:
-                        y_pred = self.model.predict(self.X, verbose=0) if self.model else np.zeros_like(self.X[:, 0])
-                        plt.scatter(self.X[:, 0], self.y, c="blue", alpha=0.5)
-                        plt.plot(self.X[:, 0], y_pred, "r-", linewidths=2)
-                    plt.gca().set_facecolor("#333")
-                    plt.xticks([])
-                    plt.yticks([])
-                    st.pyplot(plt)
-                with col2:
-                    fig, ax = plt.subplots(figsize=(3, 3))
-                    ax.plot(self.losses["Epoch"], self.losses["Train Loss"], "b-", label="Train")
-                    ax.plot(self.losses["Epoch"], self.losses["Val Loss"], "r--", label="Val")
-                    ax.legend()
-                    ax.set_facecolor("#333")
-                    st.pyplot(fig)
+                            try:
+                                plot_decision_regions(X_2d, self.y, clf=self.model, legend=2, colors='blue,red')
+                                plt.scatter(X_2d[:, 0], X_2d[:, 1], c=self.y, cmap='coolwarm', edgecolors='k', alpha=0.7)
+                                xx, yy = np.meshgrid(np.linspace(X_2d[:, 0].min(), X_2d[:, 0].max(), 100),
+                                                     np.linspace(X_2d[:, 1].min(), X_2d[:, 1].max(), 100))
+                                grid = np.c_[xx.ravel(), yy.ravel()]
+                                Z = self.model.predict(grid, verbose=0) if self.model else np.zeros((len(grid), 1))
+                                Z = (Z > 0.5).astype(int).reshape(xx.shape)
+                                plt.contour(xx, yy, Z, levels=[0.5], colors='black', linewidths=2)
+                            except Exception as e:
+                                st.warning(f"Decision region plot failed: {e}")
+                                xx, yy = np.meshgrid(np.linspace(X_2d[:, 0].min(), X_2d[:, 0].max(), 100),
+                                                     np.linspace(X_2d[:, 1].min(), X_2d[:, 1].max(), 100))
+                                grid = np.c_[xx.ravel(), yy.ravel()]
+                                Z = self.model.predict(grid, verbose=0) if self.model else np.zeros((len(grid), 1))
+                                Z = (Z > 0.5).astype(int).reshape(xx.shape)
+                                plt.contour(xx, yy, Z, levels=[0.5], colors='black', linewidths=2)
+                                plt.contourf(xx, yy, Z, alpha=0.3, cmap="coolwarm")
+                                plt.scatter(X_2d[:, 0], X_2d[:, 1], c=self.y, cmap="coolwarm", edgecolors="k", alpha=0.7)
+                        else:
+                            y_pred = self.model.predict(self.X, verbose=0) if self.model else np.zeros_like(self.X[:, 0])
+                            plt.scatter(self.X[:, 0], self.y, c="blue", alpha=0.5)
+                            plt.plot(self.X[:, 0], y_pred, "r-", linewidths=2)
+                        plt.gca().set_facecolor("#333")
+                        plt.xticks([])
+                        plt.yticks([])
+                        st.pyplot(plt)
+                    with col2:
+                        fig, ax = plt.subplots(figsize=(3, 3))
+                        ax.plot(self.losses["Epoch"], self.losses["Train Loss"], "b-", label="Train")
+                        ax.plot(self.losses["Epoch"], self.losses["Val Loss"], "r--", label="Val")
+                        ax.legend()
+                        ax.set_facecolor("#333")
+                        st.pyplot(fig)
+            except Exception as e:
+                st.error(f"Error in epoch end: {e}")
 
     if st.session_state.training:
         try:
             model = create_model(len(selected_features), st.session_state.hidden_layer_neurons)
             callback = OutputCallback(selected_data, cv)
-            callback.model_ = model  # Explicitly set the model for the callback
-            model.fit(selected_data, cv, epochs=100,  # Reduced epochs for Spaces
-                      batch_size=batch_size, validation_split=1-train_ratio, 
+            callback.model = model  # Explicitly set the model for the callback
+            model.fit(selected_data, cv, epochs=100,  # Reduced for Spaces
+                      batch_size=batch_size, validation_split=1-train_ratio,
                       callbacks=[callback], verbose=0)
         except Exception as e:
             st.error(f"Training failed: {e}")