Update app.py

app.py

@@ -1,7 +1,3 @@
-# Gradio app: CSV -> Preprocessing -> Logistic Regression with hyperparameter tuning
-# Save this file as gradio_logreg_app.py and run: python gradio_logreg_app.py
-
-import io
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
@@ -11,9 +7,11 @@ from sklearn.impute import SimpleImputer
 from sklearn.compose import ColumnTransformer
 from sklearn.pipeline import Pipeline
 from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score, confusion_matrix, classification_report, roc_auc_score
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
 import gradio as gr
 
+
+# Function to load CSV/Excel
 def load_csv(file_path):
     try:
         df = pd.read_csv(file_path)
@@ -24,16 +22,23 @@ def load_csv(file_path):
             return None, f"Failed to read file: {e} / {e2}"
     return df, None
 
+
+# File upload handler
 def on_upload(file):
     if file is None:
-        return gr.Dropdown.update(choices=[]), "No file uploaded", None
-    df, err = load_csv(file.name)  # file.name = temp file path
+        return gr.Dropdown.update(choices=[]), "No file uploaded", None, pd.DataFrame()
+
+    df, err = load_csv(file.name)  # use file.name to get path
     if err:
-        return gr.Dropdown.update(choices=[]), f"Error: {err}", None
+        return gr.Dropdown.update(choices=[]), f"Error: {err}", None, pd.DataFrame()
+
     cols = df.columns.tolist()
-    return gr.Dropdown.update(choices=cols, value=cols[-1] if len(cols) > 0 else None), f"Loaded {len(df)} rows, {len(cols)} columns", df
+    status_msg = f"Loaded {len(df)} rows, {len(cols)} columns"
+    preview_df = df.head(20)
+    return gr.Dropdown.update(choices=cols, value=cols[-1] if cols else None), status_msg, df, preview_df
+
 
-# Helper: build preprocessing + model pipeline
+# Build preprocessing pipeline
 def build_pipeline(df, target_col, impute_strategy, apply_scaling, encode_categorical):
     X = df.drop(columns=[target_col])
     numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
@@ -46,175 +51,131 @@ def build_pipeline(df, target_col, impute_strategy, apply_scaling, encode_catego
             num_transformers.append(('imputer', SimpleImputer(strategy=impute_strategy)))
         if apply_scaling:
             num_transformers.append(('scaler', StandardScaler()))
-        if num_transformers:
-            from sklearn.pipeline import make_pipeline
-            transformers.append(('num', make_pipeline(*[t[1] for t in num_transformers]), numeric_cols))
+        from sklearn.pipeline import make_pipeline
+        transformers.append(('num', make_pipeline(*[t[1] for t in num_transformers]), numeric_cols))
 
     if categorical_cols and encode_categorical:
-        cat_transformer = Pipeline(steps=[('imputer', SimpleImputer(strategy='most_frequent')),
-                                          ('ohe', OneHotEncoder(handle_unknown='ignore', sparse=False))])
+        cat_transformer = Pipeline(steps=[
+            ('imputer', SimpleImputer(strategy='most_frequent')),
+            ('ohe', OneHotEncoder(handle_unknown='ignore', sparse=False))
+        ])
         transformers.append(('cat', cat_transformer, categorical_cols))
 
-    if transformers:
-        preprocessor = ColumnTransformer(transformers=transformers, remainder='passthrough')
-    else:
-        preprocessor = 'passthrough'
+    preprocessor = ColumnTransformer(transformers=transformers, remainder='passthrough') if transformers else 'passthrough'
 
     pipe = Pipeline(steps=[('preproc', preprocessor), ('clf', LogisticRegression(max_iter=200))])
     return pipe
 
 
-# Training function
+# Train model
 def train_model(df, target_col, test_size, random_state, impute_strategy, apply_scaling, encode_categorical,
                 use_grid, c_min, c_max, c_steps, penalties, solver, cv_folds, max_iter, n_jobs):
-    # Basic checks
+
     if df is None:
         return "No data loaded", None, None, None
     if target_col not in df.columns:
         return f"Target column '{target_col}' not found", None, None, None
 
-    # Drop rows where target is missing
-    data = df.copy()
-    data = data.dropna(subset=[target_col])
-
-    # If target is not numeric, try to encode it
+    data = df.copy().dropna(subset=[target_col])
     y = data[target_col]
     if y.dtype == object or y.dtype.name == 'category' or y.dtype == bool:
         y = pd.factorize(y)[0]
 
     X = data.drop(columns=[target_col])
 
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state, stratify=y if len(np.unique(y))>1 else None)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=random_state,
+        stratify=y if len(np.unique(y)) > 1 else None
+    )
 
     pipe = build_pipeline(pd.concat([X_train, y_train], axis=1), target_col, impute_strategy, apply_scaling, encode_categorical)
     pipe.named_steps['clf'].max_iter = max_iter
 
     if use_grid:
-        # build param grid for C and penalty
         C_values = np.linspace(c_min, c_max, int(max(1, c_steps)))
-        param_grid = {}
-        # penalty and solver interaction needs care
-        selected_penalties = penalties if len(penalties)>0 else ['l2']
-        param_grid['clf__C'] = C_values
-        param_grid['clf__penalty'] = selected_penalties
-        param_grid['clf__solver'] = [solver]
-
+        param_grid = {
+            'clf__C': C_values,
+            'clf__penalty': penalties if penalties else ['l2'],
+            'clf__solver': [solver]
+        }
         gs = GridSearchCV(pipe, param_grid, cv=cv_folds, n_jobs=n_jobs, scoring='accuracy')
         gs.fit(X_train, y_train)
-        best = gs.best_estimator_
-        best_params = gs.best_params_
-        model = best
-        train_pred = model.predict(X_train)
-        test_pred = model.predict(X_test)
-        acc = accuracy_score(y_test, test_pred)
-        report = classification_report(y_test, test_pred)
-        cm = confusion_matrix(y_test, test_pred)
-        extra = f"Best params: {best_params}"
+        model = gs.best_estimator_
+        extra = f"Best params: {gs.best_params_}"
     else:
-        # set hyperparams from UI
         clf = pipe.named_steps['clf']
-        try:
-            clf.set_params(C=float((c_min+c_max)/2), penalty=penalties[0] if penalties else 'l2', solver=solver)
-        except Exception:
-            # fallback: set only C
-            clf.set_params(C=float((c_min+c_max)/2))
-
+        clf.set_params(C=float((c_min + c_max) / 2), penalty=penalties[0] if penalties else 'l2', solver=solver)
         pipe.fit(X_train, y_train)
         model = pipe
-        train_pred = model.predict(X_train)
-        test_pred = model.predict(X_test)
-        acc = accuracy_score(y_test, test_pred)
-        report = classification_report(y_test, test_pred)
-        cm = confusion_matrix(y_test, test_pred)
         extra = "Trained with provided hyperparameters"
 
-    # Plot confusion matrix
-    fig, ax = plt.subplots(figsize=(4,4))
+    test_pred = model.predict(X_test)
+    acc = accuracy_score(y_test, test_pred)
+    report = classification_report(y_test, test_pred)
+    cm = confusion_matrix(y_test, test_pred)
+
+    # Confusion matrix plot
+    fig, ax = plt.subplots(figsize=(4, 4))
     ax.imshow(cm, interpolation='nearest')
     ax.set_title('Confusion matrix')
     ax.set_xlabel('Predicted')
     ax.set_ylabel('Actual')
     for i in range(cm.shape[0]):
         for j in range(cm.shape[1]):
-            ax.text(j, i, str(cm[i, j]), ha='center', va='center', color='white' if cm[i,j]>cm.max()/2 else 'black')
+            ax.text(j, i, str(cm[i, j]), ha='center', va='center',
+                    color='white' if cm[i, j] > cm.max() / 2 else 'black')
     plt.tight_layout()
 
-    return f"Accuracy: {acc:.4f}\n{extra}", fig, report, model
+    return f"Accuracy: {acc:.4f}\n{extra}", fig, report, str(model)
 
 
-# Build Gradio interface
-with gr.Blocks(title="CSV -> Logistic Regression (with tuning)") as demo:
-    gr.Markdown("""
-    # CSV → Preprocessing → Logistic Regression
-    1. Upload a CSV or Excel file.
-    2. Select the target (label) column.
-    3. Choose preprocessing options and hyperparameters.
-    4. Train model and view accuracy, confusion matrix and classification report.
-    """)
+# Gradio Interface
+with gr.Blocks(title="CSV -> Logistic Regression") as demo:
+    gr.Markdown("## CSV → Logistic Regression with Hyperparameter Tuning")
 
     with gr.Row():
-        with gr.Column(scale=1):
+        with gr.Column():
             file_input = gr.File(label="Upload CSV/Excel file", file_types=['.csv', '.xls', '.xlsx'])
             load_status = gr.Textbox(label="File status", interactive=False)
-            target_dropdown = gr.Dropdown(label="Select target column", choices=[], value=None)
-            preview_button = gr.Button("Preview data")
-            preview_output = gr.Dataframe(headers=None, interactive=False)
+            target_dropdown = gr.Dropdown(label="Select target column", choices=[])
+            preview_output = gr.Dataframe(label="Data Preview", interactive=False)
 
-        with gr.Column(scale=1):
-            gr.Markdown("**Preprocessing**")
-            impute_radio = gr.Radio(['mean','median','most_frequent','constant','none'], value='mean', label='Numeric imputation (if needed)')
+    with gr.Row():
+        with gr.Column():
+            impute_radio = gr.Radio(['mean', 'median', 'most_frequent', 'none'], value='mean', label='Numeric imputation')
             scaler_checkbox = gr.Checkbox(label='Apply Standard Scaling', value=True)
             encode_checkbox = gr.Checkbox(label='One-Hot Encode categorical', value=True)
-
-            gr.Markdown("**Train / Test & Randomness**")
             test_size = gr.Slider(0.05, 0.5, value=0.2, step=0.05, label='Test size')
-            random_state = gr.Number(value=42, precision=0, label='Random state (int)')
+            random_state = gr.Number(value=42, precision=0, label='Random state')
 
-            gr.Markdown("**Logistic Regression hyperparams**")
-            use_grid = gr.Checkbox(label='Use GridSearchCV for hyperparameter tuning', value=True)
-            c_min = gr.Number(value=0.01, label='C (min)')
-            c_max = gr.Number(value=10.0, label='C (max)')
-            c_steps = gr.Slider(1, 20, value=5, step=1, label='C steps (grid size)')
-            penalties = gr.CheckboxGroup(['l1','l2','elasticnet','none'], label='Penalties to try (Grid only / or choose first)', value=['l2'])
-            solver = gr.Dropdown(['lbfgs','liblinear','saga','sag','newton-cg'], value='lbfgs', label='Solver')
-            max_iter = gr.Slider(50,1000,value=200,step=10,label='Max iterations')
-            cv_folds = gr.Slider(2,10,value=5,step=1,label='CV folds for GridSearch')
-            n_jobs = gr.Slider(1,8,value=1,step=1,label='n_jobs for GridSearch')
+            use_grid = gr.Checkbox(label='Use GridSearchCV', value=True)
+            c_min = gr.Number(value=0.01, label='C min')
+            c_max = gr.Number(value=10.0, label='C max')
+            c_steps = gr.Slider(1, 20, value=5, step=1, label='C steps')
+            penalties = gr.CheckboxGroup(['l1', 'l2', 'elasticnet', 'none'], value=['l2'], label='Penalties')
+            solver = gr.Dropdown(['lbfgs', 'liblinear', 'saga'], value='lbfgs', label='Solver')
+            max_iter = gr.Slider(50, 1000, value=200, step=10, label='Max iterations')
+            cv_folds = gr.Slider(2, 10, value=5, step=1, label='CV folds')
+            n_jobs = gr.Slider(1, 8, value=1, step=1, label='n_jobs')
 
-            train_btn = gr.Button("Train model")
+            train_btn = gr.Button("Train Model")
 
     with gr.Row():
-        with gr.Column():
-            accuracy_text = gr.Textbox(label='Accuracy & notes', interactive=False)
-            conf_plot = gr.Plot(label='Confusion Matrix')
-        with gr.Column():
-            class_report = gr.Textbox(label='Classification report', interactive=False)
-            model_obj = gr.JSON(label='Trained model (sklearn pipeline as repr)')
+        accuracy_text = gr.Textbox(label='Accuracy & Notes', interactive=False)
+        conf_plot = gr.Plot(label='Confusion Matrix')
+        class_report = gr.Textbox(label='Classification Report', interactive=False)
+        model_obj = gr.Textbox(label='Model', interactive=False)
 
-    # State to keep dataframe
     df_state = gr.State()
 
-    # Wire upload -> get columns
-    file_input.change(fn=on_upload, inputs=[file_input], outputs=[target_dropdown, load_status, df_state])
-
-    def preview(df):
-        if df is None:
-            return pd.DataFrame()
-        return df.head(20)
-
-    preview_button.click(fn=preview, inputs=[df_state], outputs=[preview_output])
-
-    def do_train(df, target, test_size_val, rand_state, impute_s, scale_flag, encode_flag,
-                 use_grid_flag, cmin, cmax, csteps, penalties_sel, solver_sel, cv_f, max_it, n_jobs_val):
-        msg, fig, report, model = train_model(df, target, test_size_val, int(rand_state), impute_s, scale_flag, encode_flag,
-                                             use_grid_flag, float(cmin), float(cmax), int(csteps), penalties_sel, solver_sel, int(cv_f), int(max_it), int(n_jobs_val))
-        model_repr = str(model)
-        return msg, fig, report, model_repr
-
-    train_btn.click(fn=do_train, inputs=[df_state, target_dropdown, test_size, random_state, impute_radio, scaler_checkbox, encode_checkbox,
-                                         use_grid, c_min, c_max, c_steps, penalties, solver, cv_folds, max_iter, n_jobs],
-                    outputs=[accuracy_text, conf_plot, class_report, model_obj])
+    file_input.change(fn=on_upload, inputs=file_input, outputs=[target_dropdown, load_status, df_state, preview_output])
 
+    train_btn.click(
+        fn=train_model,
+        inputs=[df_state, target_dropdown, test_size, random_state, impute_radio, scaler_checkbox, encode_checkbox,
+                use_grid, c_min, c_max, c_steps, penalties, solver, cv_folds, max_iter, n_jobs],
+        outputs=[accuracy_text, conf_plot, class_report, model_obj]
+    )
 
 if __name__ == '__main__':
-    demo.launch(server_name='0.0.0.0', share=False)
+    demo.launch()