Update app.py

app.py

@@ -10,7 +10,14 @@ import requests
 import asyncio
 from io import BytesIO
 import base64
-import mimetypes
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers, callbacks
+from tensorflow.keras.utils import to_categorical
+from keras.models import Sequential
+from keras.layers import Dense
+import mimetype
+import tensorflow
 import matplotlib.pyplot as plt
 from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, learning_curve
 from sklearn.linear_model import LinearRegression, LogisticRegression
@@ -1423,10 +1430,22 @@ elif app_mode == "Neural Network Studio":
     # Neural Network Configuration
     st.subheader("⚙️ Neural Network Configuration")
     with st.expander("Configure Neural Network", expanded=True):
-        hidden_layers = st.slider("Number of Hidden Layers", 1, 5, 2)
-        neurons_per_layer = st.slider("Neurons per Layer", 10, 200, 50)
-        activation = st.selectbox("Activation Function", ["relu", "tanh", "sigmoid"])
-        learning_rate = st.slider("Learning Rate", 0.001, 0.1, 0.01)
+        col1, col2 = st.columns(2)
+        with col1:
+            hidden_layers = st.slider("Number of Hidden Layers", 1, 5, 2)
+            neurons_per_layer = st.slider("Neurons per Layer", 10, 200, 50)
+            activation = st.selectbox("Activation Function",
+                ["relu", "tanh", "sigmoid", "selu", "swish"])
+            dropout_rate = st.slider("Dropout Rate", 0.0, 0.5, 0.2)
+            initializer = st.selectbox("Weight Initializer",
+                ["glorot_uniform", "he_normal", "lecun_uniform"])
+
+        with col2:
+            learning_rate = st.slider("Learning Rate", 0.0001, 0.1, 0.001, format="%.4f")
+            optimizer_choice = st.selectbox("Optimizer",
+                ["Adam", "Nadam", "RMSprop", "SGD"])
+            batch_norm = st.checkbox("Batch Normalization", value=True)
+            regularization = st.checkbox("L2 Regularization")
         epochs = st.slider("Epochs", 10, 200, 50)
         batch_size = st.slider("Batch Size", 16, 128, 32)
 
@@ -1467,23 +1486,72 @@ elif app_mode == "Neural Network Studio":
                 X_train_processed = preprocessor.fit_transform(X_train)
                 X_test_processed = preprocessor.transform(X_test)
 
-                # Neural Network Model
+                # Build neural network with advanced features
                 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=activation))
-                model.add(layers.Dense(1 if problem_type == "Regression" else len(np.unique(y_train)),
-                             activation='linear' if problem_type == "Regression" else 'softmax'))
+                    # Create configurable layers
+                    layer_config = {
+                        'units': neurons_per_layer,
+                        'activation': activation,
+                        'kernel_initializer': initializer
+                    }
+
+                    if regularization:
+                        layer_config['kernel_regularizer'] = keras.regularizers.l2(0.01)
+
+                    model.add(layers.Dense(**layer_config))
+
+                    if batch_norm:
+                        model.add(layers.BatchNormalization())
+
+                    if dropout_rate > 0:
+                        model.add(layers.Dropout(dropout_rate))
+
+                # Output layer
+                output_activation = 'linear' if problem_type == "Regression" else 'softmax'
+                output_units = 1 if problem_type == "Regression" else len(np.unique(y_train))
+                model.add(layers.Dense(output_units, activation=output_activation))
+
+                # Configure optimizer
+                optimizers = {
+                    "Adam": keras.optimizers.Adam(learning_rate=learning_rate),
+                    "Nadam": keras.optimizers.Nadam(learning_rate=learning_rate),
+                    "RMSprop": keras.optimizers.RMSprop(learning_rate=learning_rate),
+                    "SGD": keras.optimizers.SGD(learning_rate=learning_rate, momentum=0.9)
+                }
+
+                optimizer = optimizers[optimizer_choice]
 
                 # Compile the model
-                optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
                 model.compile(optimizer=optimizer,
                                loss='mse' if problem_type == "Regression" else 'sparse_categorical_crossentropy',
                                metrics=['mae'] if problem_type == "Regression" else ['accuracy'])
 
-                # Train the model
-                history = model.fit(X_train_processed, y_train, epochs=epochs, batch_size=batch_size,
-                                     validation_split=0.2, verbose=0)
+                # Add callbacks section
+                with st.expander("Advanced Training Options"):
+                    early_stopping = st.checkbox("Early Stopping", value=True)
+                    reduce_lr = st.checkbox("Reduce Learning Rate on Plateau")
+                    patience = st.slider("Patience Epochs", 5, 20, 10) if early_stopping else 0
+
+                callbacks_list = []
+                if early_stopping:
+                    callbacks_list.append(
+                        callbacks.EarlyStopping(patience=patience, restore_best_weights=True))
+                if reduce_lr:
+                    callbacks_list.append(
+                        callbacks.ReduceLROnPlateau(factor=0.2, patience=patience//2))
+
+                # Train the model with callbacks
+                history = model.fit(
+                    X_train_processed, y_train,
+                    epochs=epochs,
+                    batch_size=batch_size,
+                    validation_split=0.2,
+                    callbacks=callbacks_list,
+                    verbose=0
+                )
 
                 # Store model and preprocessor
                 st.session_state.model = Pipeline(steps=[('preprocessor', preprocessor), ('model', model)])
@@ -1497,6 +1565,11 @@ elif app_mode == "Neural Network Studio":
 
                 # Model Evaluation
                 y_pred = model.predict(X_test_processed)
+
+                # Post-processing for classification
+                if problem_type == "Classification":
+                    y_pred = np.argmax(y_pred, axis=1)  # Convert probabilities to class labels
+
                 if problem_type == "Regression":
                     mse = mean_squared_error(y_test, y_pred)
                     rmse = np.sqrt(mse)
@@ -1518,14 +1591,32 @@ elif app_mode == "Neural Network Studio":
                     st.write("Classification Report:")
                     st.text(classification_report(y_test, y_pred))
 
-                # Visualization
+                # Visualization with multiple metrics
                 st.subheader("📊 Training History")
-                fig, ax = plt.subplots()
-                ax.plot(history.history['loss'], label='loss')
-                ax.plot(history.history['val_loss'], label='val_loss')
-                ax.set_xlabel('Epoch')
-                ax.set_ylabel('Loss')
-                ax.legend()
+                fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+
+                # Plot loss
+                ax1.plot(history.history['loss'], label='Train Loss')
+                ax1.plot(history.history['val_loss'], label='Validation Loss')
+                ax1.set_title('Loss Evolution')
+                ax1.set_xlabel('Epoch')
+                ax1.set_ylabel('Loss')
+                ax1.legend()
+
+                # Plot accuracy/metric
+                if problem_type == "Classification":
+                    ax2.plot(history.history['accuracy'], label='Train Accuracy')
+                    ax2.plot(history.history['val_accuracy'], label='Validation Accuracy')
+                    ax2.set_title('Accuracy Evolution')
+                    ax2.set_ylabel('Accuracy')
+                else:
+                    ax2.plot(history.history['mae'], label='Train MAE')
+                    ax2.plot(history.history['val_mae'], label='Validation MAE')
+                    ax2.set_title('MAE Evolution')
+                    ax2.set_ylabel('MAE')
+
+                ax2.set_xlabel('Epoch')
+                ax2.legend()
                 st.pyplot(fig)
 
                 st.success("Neural network trained successfully!")
@@ -1538,7 +1629,8 @@ elif app_mode == "Neural Network Studio":
         model_filename = st.text_input("Enter Model Filename (without extension)", "neural_network")
         if st.button("Save Model"):
             try:
-                joblib.dump(st.session_state.model, f"{model_filename}.joblib")
-                st.success(f"Model saved as {model_filename}.joblib")
+                # Save the entire Keras model including architecture and weights
+                st.session_state.model.named_steps['model'].save(f"{model_filename}.h5")  # Saves as a HDF5 file
+                st.success(f"Model saved as {model_filename}.h5")
             except Exception as e:
                 st.error(f"Error saving model: {e}")