Update app.py

app.py

@@ -522,19 +522,31 @@ elif app_mode == "Data Cleaning":
     # --------------------------
     # Label Encoding
     # --------------------------
-    enhance_section_title("Label Encoding", "🔢")
-    with st.expander("🔢 Label Encoding"):
-        data_to_encode = st.multiselect("Select categorical columns to encode", df.select_dtypes(include='object').columns)
-        if data_to_encode:
-            if st.button("Apply Label Encoding (Encoding)"):
-                new_df = df.copy()
+# --------------------------
+# Label/One-Hot Encoding
+# --------------------------
+enhance_section_title("Encoding Options", "🔢")
+with st.expander("🔢 Encoding Options"):
+    encoding_method = st.radio("Select Encoding Method", ("Label Encoding", "One-Hot Encoding"))
+    
+    data_to_encode = st.multiselect("Select categorical columns to encode", df.select_dtypes(include='object').columns)
+    if data_to_encode:
+        if st.button("Apply Encoding"):
+            new_df = df.copy()
+            if encoding_method == "Label Encoding":
                 label_encoders = {}
                 for col in data_to_encode:
                     le = LabelEncoder()
                     new_df[col] = le.fit_transform(new_df[col].astype(str))
                     label_encoders[col] = le
-                update_cleaned_data(new_df)
-                st.rerun() #Force re-run after apply
+            elif encoding_method == "One-Hot Encoding":
+                new_df = pd.get_dummies(new_df, columns=data_to_encode, drop_first=True)
+            
+            update_cleaned_data(new_df)
+            st.rerun() # Force re-run after apply
+        except Exception as e:
+                st.error(f"Error: {str(e)}")
+            
 
     # --------------------------
     # StandardScaler
@@ -574,16 +586,139 @@ elif app_mode == "Data Cleaning":
     # --------------------------
     # Bulk Operations
     # --------------------------
-    enhance_section_title("Bulk Actions", "🚀")
-    with st.expander("🚀 Bulk Actions"):
-        if st.button("Auto-Clean Common Issues (Cleaning)"):
+# --------------------------
+# Bulk Operations
+# --------------------------
+enhance_section_title("Bulk Actions", "🚀")
+with st.expander("🚀 Bulk Actions"):
+    bulk_action = st.selectbox("Select Bulk Action", [
+        "Auto-Clean Common Issues",
+        "Drop All Missing Values",
+        "Fill Missing Values",
+        "One-Hot Encode All Categorical Columns",
+        "Min-Max Scaling",
+        "Remove Outliers",
+        "Tokenize Text Columns",
+        "Vectorize Text Columns (TF-IDF)",
+        "Extract Date Features",
+        "Target Encoding",
+        "Principal Component Analysis (PCA)"
+    ])
+    
+    if bulk_action == "Auto-Clean Common Issues":
+        if st.button("Apply Auto-Clean"):
             new_df = df.copy()
             new_df = new_df.dropna(axis=1, how='all')  # Remove empty cols
             new_df = new_df.convert_dtypes()  # Better type inference
             text_cols = new_df.select_dtypes(include='object').columns
             new_df[text_cols] = new_df[text_cols].apply(lambda x: x.str.strip())
             update_cleaned_data(new_df)
-            st.rerun() #Force re-run after apply
+            st.rerun()  # Force re-run after apply
+    
+    if bulk_action == "Drop All Missing Values":
+        if st.button("Apply Drop All Missing"):
+            new_df = df.copy()
+            new_df = new_df.dropna()  # Drop rows with any missing values
+            update_cleaned_data(new_df)
+            st.rerun()  # Force re-run after apply
+    
+    if bulk_action == "Fill Missing Values":
+        fill_value = st.text_input("Fill Value (e.g., 0, mean, median)")
+        if st.button("Apply Fill Missing"):
+            new_df = df.copy()
+            if fill_value.lower() == "mean":
+                new_df = new_df.fillna(new_df.mean())
+            elif fill_value.lower() == "median":
+                new_df = new_df.fillna(new_df.median())
+            else:
+                new_df = new_df.fillna(fill_value)
+            update_cleaned_data(new_df)
+            st.rerun()  # Force re-run after apply
+    
+    if bulk_action == "One-Hot Encode All Categorical Columns":
+        if st.button("Apply One-Hot Encoding"):
+            new_df = df.copy()
+            categorical_cols = new_df.select_dtypes(include='object').columns
+            new_df = pd.get_dummies(new_df, columns=categorical_cols, drop_first=True)
+            update_cleaned_data(new_df)
+            st.rerun()  # Force re-run after apply
+    
+    if bulk_action == "Min-Max Scaling":
+        if st.button("Apply Min-Max Scaling"):
+            new_df = df.copy()
+            scaler = MinMaxScaler()
+            numerical_cols = new_df.select_dtypes(include=np.number).columns
+            new_df[numerical_cols] = scaler.fit_transform(new_df[numerical_cols])
+            update_cleaned_data(new_df)
+            st.rerun()  # Force re-run after apply
+    
+    if bulk_action == "Remove Outliers":
+        if st.button("Apply Remove Outliers"):
+            new_df = df.copy()
+            z_scores = np.abs(stats.zscore(new_df.select_dtypes(include=np.number)))
+            new_df = new_df[(z_scores < 3).all(axis=1)]  # Remove rows with z-score > 3
+            update_cleaned_data(new_df)
+            st.rerun()  # Force re-run after apply
+
+    if bulk_action == "Tokenize Text Columns":
+        text_cols = st.multiselect("Select text columns to tokenize", df.select_dtypes(include='object').columns)
+        if text_cols:
+            if st.button("Apply Tokenization"):
+                tokenizer = Tokenizer()
+                new_df = df.copy()
+                for col in text_cols:
+                    tokenizer.fit_on_texts(new_df[col])
+                    new_df[col] = tokenizer.texts_to_sequences(new_df[col])
+                update_cleaned_data(new_df)
+                st.rerun()  # Force re-run after apply
+
+    if bulk_action == "Vectorize Text Columns (TF-IDF)":
+        text_cols = st.multiselect("Select text columns to vectorize", df.select_dtypes(include='object').columns)
+        if text_cols:
+            if st.button("Apply TF-IDF Vectorization"):
+                tfidf = TfidfVectorizer()
+                new_df = df.copy()
+                for col in text_cols:
+                    new_col = tfidf.fit_transform(new_df[col]).toarray()
+                    new_df = new_df.drop(columns=[col])
+                    new_df = new_df.join(pd.DataFrame(new_col, columns=[f'{col}_{i}' for i in range(new_col.shape[1])]))
+                update_cleaned_data(new_df)
+                st.rerun()  # Force re-run after apply
+    
+    if bulk_action == "Extract Date Features":
+        date_cols = st.multiselect("Select date columns to extract features from", df.select_dtypes(include='datetime').columns)
+        if date_cols:
+            if st.button("Apply Date Feature Extraction"):
+                new_df = df.copy()
+                for col in date_cols:
+                    new_df[f'{col}_year'] = new_df[col].dt.year
+                    new_df[f'{col}_month'] = new_df[col].dt.month
+                    new_df[f'{col}_day'] = new_df[col].dt.day
+                    new_df[f'{col}_weekday'] = new_df[col].dt.weekday
+                    new_df[f'{col}_hour'] = new_df[col].dt.hour
+                update_cleaned_data(new_df)
+                st.rerun()  # Force re-run after apply
+
+    if bulk_action == "Target Encoding":
+        target_col = st.selectbox("Select target column", df.columns)
+        cat_cols = st.multiselect("Select categorical columns to encode", df.select_dtypes(include='object').columns)
+        if cat_cols:
+            if st.button("Apply Target Encoding"):
+                new_df = df.copy()
+                for col in cat_cols:
+                    target_mean = new_df.groupby(col)[target_col].mean()
+                    new_df[col] = new_df[col].map(target_mean)
+                update_cleaned_data(new_df)
+                st.rerun()  # Force re-run after apply
+
+    if bulk_action == "Principal Component Analysis (PCA)":
+        n_components = st.slider("Number of components", min_value=1, max_value=min(df.shape[1], 10), value=2)
+        if st.button("Apply PCA"):
+            new_df = df.copy()
+            pca = PCA(n_components=n_components)
+            pca_result = pca.fit_transform(new_df.select_dtypes(include=np.number))
+            new_df = pd.DataFrame(pca_result, columns=[f'PC{i+1}' for i in range
+
 
     # --------------------------
     # Cleaned Data Preview
@@ -681,7 +816,6 @@ elif app_mode == "EDA":
                 "Swarm Plot",  # YData Library Plots,
                 "Ridge Plot",
                 "Bubble Plot",
-                "Barh Plot",
                 "Density Plot",
                 "Count Plot",
                 "Lollipop Chart",
@@ -803,13 +937,6 @@ elif app_mode == "EDA":
                                    hover_name = size_col,#Hover Name, to show value
                                     title=f"Bubble Plot of {x_axis} vs. {y_axis} Colored by{size_col}"
                         )
-            elif plot_type == "Barh Plot":
-
-                 if x_axis and y_axis:
-                    fig = px.bar(df, y=x_axis, x=y_axis,
-                                 color=color_by if color_by != "None" else None, orientation = 'h', # set x on y-axis side.
-                                title=f"Horizontal Bar Plot of {y_axis} vs {x_axis}"# added chart titles
-                                ) #Set as Vertical as Base, and
 
             elif plot_type == "Density Plot": #Kernel Estimations with px
 
@@ -910,24 +1037,83 @@ elif app_mode == "EDA":
                         st.write("There is no statistically significant association between the two categorical variables.")
 
         with tab2:
+            # Pattern Discovery--------------------------
+
             st.subheader("Pattern Discovery")
             explore_col = st.selectbox("Column to analyze", df.columns)
+            
             if pd.api.types.is_string_dtype(df[explore_col]):
                 pattern = st.text_input("Regex pattern")
                 if pattern:
-                    matches = df[explore_col].str.contains(pattern).sum()
-                    st.write(f"Found {matches} matches")
+                    # Perform regex matching
+                    matches = df[explore_col].str.contains(pattern, regex=True, na=False)
+                    num_matches = matches.sum()
+                    st.write(f"Found {num_matches} matches")
+            
+                    # Display matching rows
+                    if num_matches > 0:
+                        st.write("Matching rows:")
+                        st.dataframe(df[matches].head(), use_container_width=True)
+            
+                # Provide regex syntax help
+                with st.expander("Regex Syntax Help"):
+                    st.markdown("""
+                    **Basic Syntax:**
+                    - `.`: Any single character
+                    - `*`: 0 or more repetitions
+                    - `+`: 1 or more repetitions
+                    - `?`: 0 or 1 repetition
+                    - `[]`: Any character within the brackets
+                    - `|`: Either or
+            
+                    For more details, visit [Regex101](https://regex101.com/)
+                    """)
+            
+            else:
+                st.warning("Please select a string column for pattern discovery.")
+
 
         with tab3:
             st.subheader("Data Transformation")
-            transform_col = st.selectbox("Column to transform", numeric_cols)
-            transform_type = st.selectbox("Transformation", ["Log", "Square Root", "Z-score"])
+            transform_col = st.selectbox("Column to transform", df.select_dtypes(include=[np.number]).columns)
+            transform_type = st.selectbox("Transformation", ["Log", "Square Root", "Z-score", "Standardization", "Normalization", "Box-Cox", "Inverse"])
+            
+            fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+            
+            if transform_col:
+            sns.histplot(df[transform_col], bins=30, kde=True, ax=ax[0])
+            ax[0].set_title('Before Transformation')
+            
             if transform_type == "Log":
                 df[transform_col] = np.log1p(df[transform_col])
             elif transform_type == "Square Root":
                 df[transform_col] = np.sqrt(df[transform_col])
             elif transform_type == "Z-score":
                 df[transform_col] = (df[transform_col] - df[transform_col].mean())/df[transform_col].std()
+            elif transform_type == "Standardization":
+                df[transform_col] = (df[transform_col] - df[transform_col].mean()) / df[transform_col].std()
+            elif transform_type == "Normalization":
+                df[transform_col] = (df[transform_col] - df[transform_col].min()) / (df[transform_col].max() - df[transform_col].min())
+            elif transform_type == "Box-Cox":
+                df[transform_col], _ = boxcox(df[transform_col] + 1)  # Adding 1 to avoid log(0) error
+            elif transform_type == "Inverse":
+                df[transform_col] = 1 / df[transform_col]
+            
+            sns.histplot(df[transform_col], bins=30, kde=True, ax=ax[1])
+            ax[1].set_title('After Transformation')
+            
+            st.pyplot(fig)
+            else:
+            st.warning("Please select a column for transformation.")
+            
+            # Error handling for invalid transformations
+            try:
+            if transform_type == "Log" and (df[transform_col] <= 0).any():
+                st.error("Log transformation is not applicable to non-positive values.")
+            elif transform_type == "Box-Cox" and (df[transform_col] <= 0).any():
+                st.error("Box-Cox transformation requires all values to be positive.")
+            except Exception as e:
+            st.error(f"Transformation failed: {str(e)}")
 
     # --------------------------
     # Export & Save
@@ -956,6 +1142,12 @@ elif app_mode == "Model Training":
     
     # ----- [1. Preset Selection] -----
     with st.sidebar.expander("🚀 Quick Start", expanded=True):
+        col1, col2 = st.columns(2)
+        with col1:
+            st.image("cnn_mnist.png", caption="CNN-MNIST", use_column_width=True)
+        with col2:
+            st.image("lstm_text.png", caption="LSTM-Text", use_column_width=True)
+            
         presets = st.selectbox("Load Preset", [
             "None", 
             "CNN-MNIST", 
@@ -979,7 +1171,7 @@ elif app_mode == "Model Training":
                     {"type": "Dense", "units":1, "activation":"sigmoid"}
                 ]
             st.experimental_rerun()
-
+    
     # ----- [2. Base Model & Transfer Learning] -----
     with st.expander("🏗️ Transfer Learning", expanded=False):
         col1, col2 = st.columns(2)
@@ -988,7 +1180,9 @@ elif app_mode == "Model Training":
                 "None",
                 "MobileNetV2", 
                 "ResNet50", 
-                "BERT"
+                "BERT",
+                "InceptionV3",
+                "VGG16"
             ])
             
         with col2:
@@ -1002,81 +1196,143 @@ elif app_mode == "Model Training":
                         weights='imagenet',
                         input_shape=(224, 224, 3) if custom_input else None
                     )
-                    st.info(f"Loaded {base_model} with {len(model.layers)} layers")
-
-    # ----- [3. Layer Configuration] -----
-    st.subheader("🏗️ Network Architecture")
-    
-    # Dynamic layer builder
-    layer_types = [
-        "Dense", "Conv2D", "LSTM", 
-        "Dropout", "BatchNorm", "Flatten"
-    ]
-    
-    if 'layers' not in st.session_state:
-        st.session_state.layers = []
+                elif base_model == "InceptionV3":
+                    model = tf.keras.applications.InceptionV3(
+                        include_top=False, 
+                        weights='imagenet',
+                        input_shape=(299, 299, 3) if custom_input else None
+                    )
+                elif base_model == "VGG16":
+                    model = tf.keras.applications.VGG16(
+                        include_top=False, 
+                        weights='imagenet',
+                        input_shape=(224, 224, 3) if custom_input else None
+                    )
+                    
+                st.info(f"Loaded {base_model} with {len(model.layers)} layers")
     
-    for i, layer in enumerate(st.session_state.layers):
-        cols = st.columns([1,3,2])
-        with cols[0]:
-            st.markdown(f"**Layer {i+1}**")
-        with cols[1]:
-            st.code(f"{layer['type']}: {dict((k,v) for k,v in layer.items() if k != 'type')}")
-        with cols[2]:
-            if st.button(f"❌ Remove {i+1}", key=f"remove_{i}"):
-                del st.session_state.layers[i]
+                # Visualize Model Architecture
+                fig, ax = plt.subplots(figsize=(10, 5))
+                sns.barplot(x=[layer.name for layer in model.layers], y=[layer.output_shape for layer in model.layers], ax=ax)
+                ax.set_xticklabels(ax.get_xticklabels(), rotation=90)
+                st.pyplot(fig)
+
+        # ----- [3. Layer Configuration] -----
+    with st.subheader("🏗️ Network Architecture")
+        
+        # Dynamic layer builder
+        layer_types = [
+            "Dense", "Conv2D", "LSTM", 
+            "Dropout", "BatchNorm", "Flatten"
+        ]
+        
+        if 'layers' not in st.session_state:
+            st.session_state.layers = []
+        
+        def render_layer(layer, index):
+            cols = st.columns([1, 3, 2])
+            with cols[0]:
+                st.markdown(f"**Layer {index + 1}**")
+            with cols[1]:
+                st.code(f"{layer['type']}: {dict((k, v) for k, v in layer.items() if k != 'type')}")
+            with cols[2]:
+                if st.button(f"❌ Remove {index + 1}", key=f"remove_{index}"):
+                    del st.session_state.layers[index]
+                    st.experimental_rerun()
+        
+        for i, layer in enumerate(st.session_state.layers):
+            render_layer(layer, i)
+        
+        # Add new layer controls
+        with st.expander("➕ Add New Layer", expanded=True):
+            new_layer_type = st.selectbox("Layer Type", layer_types)
+            new_layer_params = {}
+        
+            if new_layer_type == "Dense":
+                new_layer_params["units"] = st.number_input("Units", 1, 1024, 128, help="Number of neurons in the layer.")
+                new_layer_params["activation"] = st.selectbox(
+                    "Activation", ["relu", "sigmoid", "tanh"], help="Activation function to use."
+                )
+            elif new_layer_type == "Conv2D":
+                new_layer_params["filters"] = st.number_input("Filters", 1, 256, 32, help="Number of filters in the convolution.")
+                new_layer_params["kernel_size"] = st.number_input("Kernel Size", 1, 9, 3, help="Size of the convolution kernel.")
+            elif new_layer_type == "LSTM":
+                new_layer_params["units"] = st.number_input("Units", 1, 512, 64, help="Number of units in the LSTM layer.")
+            elif new_layer_type == "Dropout":
+                new_layer_params["rate"] = st.number_input("Rate", 0.0, 1.0, 0.5, help="Dropout rate to use.")
+            elif new_layer_type == "BatchNorm":
+                pass  # BatchNorm has no parameters
+            elif new_layer_type == "Flatten":
+                pass  # Flatten has no parameters
+        
+            if st.button("Add Layer"):
+                st.session_state.layers.append({
+                    "type": new_layer_type,
+                    **new_layer_params
+                })
                 st.experimental_rerun()
-    
-    # Add new layer controls
-    with st.expander("➕ Add New Layer", expanded=True):
-        new_layer_type = st.selectbox("Layer Type", layer_types)
-        new_layer_params = {}
         
-        if new_layer_type == "Dense":
-            new_layer_params["units"] = st.number_input("Units", 1, 1024, 128)
-            new_layer_params["activation"] = st.selectbox(
-                "Activation", ["relu", "sigmoid", "tanh"]
-            )
-            
-        elif new_layer_type == "Conv2D":
-            new_layer_params["filters"] = st.number_input("Filters", 1, 256, 32)
-            new_layer_params["kernel_size"] = st.number_input("Kernel Size", 1, 9, 3)
-            
-        if st.button("Add Layer"):
-            st.session_state.layers.append({
-                "type": new_layer_type,
-                **new_layer_params
-            })
-            st.experimental_rerun()
+        # Visualize the model architecture
+        st.subheader("Model Visualization")
+        fig, ax = plt.subplots(figsize=(10, 6))
+        layer_types = [layer['type'] for layer in st.session_state.layers]
+        layer_counts = {layer: layer_types.count(layer) for layer in layer_types}
+        ax.bar(layer_counts.keys(), layer_counts.values())
+        ax.set_xlabel("Layer Types")
+        ax.set_ylabel("Count")
+        st.pyplot(fig)
+        
+        # Tooltip information
+        st.info("""
+        **Tooltips:**
+        - **Units**: Number of neurons/units in the layer.
+        - **Activation**: Function used to activate the neurons.
+        - **Filters**: Number of filters in the convolution layer.
+        - **Kernel Size**: Size of the kernel used in the convolution layer.
+        - **Rate**: Dropout rate used to drop neurons during training to prevent overfitting.
+        """)
+
 
+    # ----- [4. Regularization & Advanced Options] -----
     # ----- [4. Regularization & Advanced Options] -----
     with st.expander("⚙️ Advanced Configuration", expanded=False):
         col1, col2 = st.columns(2)
         
         with col1:
             st.subheader("Regularization")
-            l2_reg = st.number_input("L2 Regularization", 0.0, 0.1, 0.001)
-            dropout = st.number_input("Global Dropout", 0.0, 0.5, 0.2)
-            batch_norm = st.checkbox("Batch Normalization")
+            l2_reg = st.number_input("L2 Regularization", 0.0, 0.1, 0.001, help="Regularization to prevent overfitting.")
+            dropout = st.number_input("Global Dropout", 0.0, 0.5, 0.2, help="Dropout rate for neurons during training.")
+            batch_norm = st.checkbox("Batch Normalization", help="Add batch normalization after each layer.")
             
         with col2:
             st.subheader("Optimization")
             optimizer = st.selectbox("Optimizer", [
                 "adam", "sgd", "rmsprop", 
                 "nadam", "adamax"
-            ])
+            ], help="Optimizer for model training.")
             
             loss = st.selectbox("Loss Function", [
                 "categorical_crossentropy",
                 "binary_crossentropy",
                 "mse",
                 "mae"
-            ])
+            ], help="Loss function to minimize during training.")
             
             metrics = st.multiselect("Metrics", [
                 "accuracy", "precision", 
                 "recall", "auc"
-            ])
+            ], help="Evaluation metrics to track during training.")
+    
+    # Additional Configuration for Validation and Hyperparameter Tuning
+    with st.expander("🔧 Additional Configuration", expanded=False):
+        st.subheader("Validation Settings")
+        val_split = st.slider("Validation Split", 0.0, 0.5, 0.2, help="Proportion of data to use for validation.")
+        
+        st.subheader("Hyperparameter Tuning")
+        tuning = st.checkbox("Enable Hyperparameter Tuning", help="Enable automated hyperparameter tuning.")
+        if tuning:
+            tuning_method = st.selectbox("Tuning Method", ["Grid Search", "Random Search"])
+            num_trials = st.number_input("Number of Trials", 1, 100, 10, help="Number of trials for hyperparameter search.")
 
     # ----- [5. Training & Monitoring] -----
     st.subheader("🎯 Training Configuration")
@@ -1091,7 +1347,7 @@ elif app_mode == "Model Training":
         def update_chart(self):
             df = pd.DataFrame(st.session_state.metrics)
             fig = px.line(df, y=['loss', 'val_loss'], 
-                         title="Training Progress")
+                          title="Training Progress")
             loss_chart.plotly_chart(fig)
     
     if st.button("🚀 Start Training"):
@@ -1117,7 +1373,8 @@ elif app_mode == "Model Training":
                     model.add(BatchNormalization())
                     
                 # Add global dropout
-                model.add(Dropout(dropout))
+                if dropout > 0:
+                    model.add(Dropout(dropout))
             
             model.compile(
                 optimizer=optimizer,
@@ -1142,6 +1399,7 @@ elif app_mode == "Model Training":
         except Exception as e:
             st.error(f"Training failed: {str(e)}")
 
+
     # ----- [6. Export & Deployment] -----
     st.subheader("💾 Export Model")