Update app.py

app.py

@@ -1,181 +1,36 @@
 import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-from sklearn.model_selection import train_test_split, GridSearchCV
-from sklearn.preprocessing import StandardScaler, OneHotEncoder
-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
 import gradio as gr
 
-
-# Function to load CSV/Excel
+# File loading function
 def load_csv(file_path):
     try:
-        df = pd.read_csv(file_path)
-    except Exception as e:
+        return pd.read_csv(file_path), None
+    except Exception as e_csv:
         try:
-            df = pd.read_excel(file_path)
-        except Exception as e2:
-            return None, f"Failed to read file: {e} / {e2}"
-    return df, None
-
+            return pd.read_excel(file_path), None
+        except Exception as e_xls:
+            return None, f"Failed to read file. CSV error: {e_csv} | Excel error: {e_xls}"
 
-# File upload handler
+# Upload handler
 def on_upload(file):
-    if file is None:
-        return gr.Dropdown.update(choices=[]), "No file uploaded", None, pd.DataFrame()
-
-    df, err = load_csv(file.name)  # use file.name to get path
+    if not file:
+        return "No file uploaded", pd.DataFrame()
+    
+    df, err = load_csv(file.name)
     if err:
-        return gr.Dropdown.update(choices=[]), f"Error: {err}", None, pd.DataFrame()
-
-    cols = df.columns.tolist()
-    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
-
-
-# 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()
-    categorical_cols = X.select_dtypes(exclude=[np.number]).columns.tolist()
-
-    transformers = []
-    if numeric_cols:
-        num_transformers = []
-        if impute_strategy != 'none':
-            num_transformers.append(('imputer', SimpleImputer(strategy=impute_strategy)))
-        if apply_scaling:
-            num_transformers.append(('scaler', StandardScaler()))
-        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))
-        ])
-        transformers.append(('cat', cat_transformer, categorical_cols))
-
-    preprocessor = ColumnTransformer(transformers=transformers, remainder='passthrough') if transformers else 'passthrough'
-
-    pipe = Pipeline(steps=[('preproc', preprocessor), ('clf', LogisticRegression(max_iter=200))])
-    return pipe
-
-
-# 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):
-
-    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
-
-    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
-    )
-
-    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:
-        C_values = np.linspace(c_min, c_max, int(max(1, c_steps)))
-        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)
-        model = gs.best_estimator_
-        extra = f"Best params: {gs.best_params_}"
-    else:
-        clf = pipe.named_steps['clf']
-        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
-        extra = "Trained with provided hyperparameters"
-
-    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')
-    plt.tight_layout()
-
-    return f"Accuracy: {acc:.4f}\n{extra}", fig, report, str(model)
-
-
-# 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():
-            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=[])
-            preview_output = gr.Dataframe(label="Data Preview", interactive=False)
-
-    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)
-            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')
-
-            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")
-
-    with gr.Row():
-        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)
+        return f"Error: {err}", pd.DataFrame()
+    
+    return f"Loaded {len(df)} rows, {len(df.columns)} columns", df.head(20)
 
-    df_state = gr.State()
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("## 📂 CSV/Excel File Upload & Preview")
 
-    file_input.change(fn=on_upload, inputs=file_input, outputs=[target_dropdown, load_status, df_state, preview_output])
+    file_input = gr.File(label="Upload CSV or Excel File", file_types=[".csv", ".xlsx"], type="file")
+    status_output = gr.Textbox(label="Status")
+    preview_output = gr.DataFrame(label="Preview (first 20 rows)")
 
-    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]
-    )
+    file_input.change(fn=on_upload, inputs=file_input, outputs=[status_output, preview_output])
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demo.launch()