Initial Changes

.gitignore

@@ -0,0 +1,3 @@
+.env
+.vscode
+venv

app.py

@@ -0,0 +1,82 @@
+import gradio as gr
+import warnings
+warnings.filterwarnings("ignore")
+
+from ui.helpers import (
+    update_models, 
+    update_graphs, 
+    preview_csv, 
+    reset_metrics_on_file_clear, 
+    toggle_csv_preview
+)
+
+from ui.theme import OrangeRedTheme
+from ui.styles import CSS_STYLE
+
+from core.training import train_model
+from core.detection import auto_set_task
+
+with gr.Blocks() as app:
+    with gr.Column(elem_id="container"):
+        gr.Markdown("## Supervised Learning Model Trainer")
+
+        with gr.Row(equal_height=True):
+            with gr.Column():
+                file_input = gr.File(label="Upload CSV", file_types=[".csv"])
+                show_preview = gr.Checkbox(
+                    label="Show CSV Preview",
+                    value=False,
+                )
+                task_type = gr.Dropdown(
+                    ["Regression", "Classification"],
+                    label="Task Type",
+                    value="Regression",
+                )
+                model_name = gr.Dropdown(label="Model")
+                graph_type = gr.Dropdown(label="Graph Type")
+
+        with gr.Row(equal_height=True):
+            run_btn = gr.Button("Train & Evaluate", variant="primary", size="lg")
+
+        with gr.Row(equal_height=True):
+            with gr.Column():
+                csv_preview = gr.Dataframe(label="CSV Preview", interactive=False, visible=False,)
+                output = gr.Dataframe(label="Evaluation Metrics", interactive=False)
+
+        with gr.Row(equal_height=True):
+            with gr.Column():
+                plot = gr.Plot(label="Selected Graph")
+
+        file_input.change(preview_csv, file_input, csv_preview)
+        file_input.change(auto_set_task, file_input, task_type)
+        file_input.change(reset_metrics_on_file_clear,inputs=file_input,outputs=[output, plot])
+
+        task_type.change(update_models, task_type, model_name)
+        task_type.change(update_graphs, task_type, graph_type)
+
+        show_preview.change(
+            toggle_csv_preview,
+            inputs=show_preview,
+            outputs=csv_preview,
+        )
+
+        app.load(update_models, task_type, model_name)
+        app.load(update_graphs, task_type, graph_type)
+
+        run_btn.click(
+            train_model,
+            inputs=[file_input, task_type, model_name, graph_type],
+            outputs=[output, plot]
+        )
+
+
+if __name__ == "__main__":
+    orange_red_theme = OrangeRedTheme()
+    app.queue().launch(
+        theme=orange_red_theme,
+        css=CSS_STYLE,
+        show_error=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        debug=True
+    )

core/detection.py

@@ -0,0 +1,19 @@
+import pandas as pd
+
+def detect_target_type(y):
+    if y.dtype == "object" or y.dtype.name == "category":
+        return "Classification"
+
+    if y.nunique() <= 20:
+        return "Classification"
+
+    return "Regression"
+
+
+def auto_set_task(file):
+    if file is None:
+        return "Regression"
+
+    df = pd.read_csv(file.name)
+    y = df.iloc[:, -1]
+    return detect_target_type(y)

core/training.py

@@ -0,0 +1,68 @@
+import pandas as pd
+from sklearn.pipeline import Pipeline
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+
+from core.detection import detect_target_type
+from models.registry import REGRESSION_MODELS, CLASSIFICATION_MODELS
+from preprocessing.transformers import build_preprocessor
+from utils.metrics import regression_metrics, classification_metrics
+from core.visuals import regression_graphs, classification_graphs
+
+
+def train_model(file, task_type, model_name, graph_type):
+    if file is None:
+        return pd.DataFrame({
+            "Error": [f"Please upload a csv file first."]
+
+        }), None
+    
+    df = pd.read_csv(file.name)
+
+    X = df.iloc[:, :-1]
+    y = df.iloc[:, -1]
+
+    detected_task = detect_target_type(y)
+
+    if task_type != detected_task:
+        return pd.DataFrame({
+            "Error": [f"Detected {detected_task} target, but {task_type} selected."]
+        }), None
+
+    if task_type == "Classification" and y.dtype == "object":
+        y = LabelEncoder().fit_transform(y)
+
+    preprocessor = build_preprocessor(X)
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    model = (
+        REGRESSION_MODELS[model_name]
+        if task_type == "Regression"
+        else CLASSIFICATION_MODELS[model_name]
+    )
+
+    pipeline = Pipeline([
+        ("preprocessing", preprocessor),
+        ("model", model),
+    ])
+
+    pipeline.fit(X_train, y_train)
+    preds = pipeline.predict(X_test)
+
+    if task_type == "Regression":
+        metrics = regression_metrics(y_test, preds)
+    else:
+        metrics = classification_metrics(pipeline, X_test, y_test, preds)
+    
+    fig = None
+    if task_type == "Regression":
+        fig = regression_graphs(graph_type, X, y, model, pipeline, y_test, preds)
+    else:
+        fig = classification_graphs(graph_type, pipeline, X_test, y_test, preds)
+
+    metrics_df = pd.DataFrame(metrics.items(), columns=["Metric", "Value"])
+
+    return metrics_df, fig

core/visuals.py

@@ -0,0 +1,65 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn.model_selection import learning_curve
+from sklearn.metrics import (
+    roc_curve, precision_recall_curve,
+    confusion_matrix, classification_report
+)
+
+def regression_graphs(graph_type, X, y, model, pipeline, y_test, preds):
+    if graph_type == "Actual vs Predicted":
+        fig, ax = plt.subplots()
+        ax.plot(y_test.values[:100])
+        ax.plot(preds[:100])
+        ax.legend(["Actual", "Predicted"])
+    elif graph_type == "Residual Plot":
+        fig, ax = plt.subplots()
+        ax.scatter(preds, y_test - preds)
+        ax.axhline(0)
+    elif graph_type == "Residual Histogram":
+        fig, ax = plt.subplots()
+        ax.hist(y_test - preds, bins=30)
+    elif graph_type == "Feature Importance":
+        fig = None
+        if hasattr(model, "feature_importances_"):
+            fig, ax = plt.subplots()
+            ax.bar(range(len(model.feature_importances_)), model.feature_importances_)
+    elif graph_type == "Learning Curve":
+        sizes, train_scores, test_scores = learning_curve(
+            pipeline, X, y
+        )
+        fig, ax = plt.subplots()
+        ax.plot(sizes, train_scores.mean(axis=1))
+        ax.plot(sizes, test_scores.mean(axis=1))
+        ax.legend(["Train", "Test"])
+    
+    return fig
+
+def classification_graphs(graph_type, pipeline, X_test, y_test, preds):
+    if graph_type == "Confusion Matrix":
+        cm = confusion_matrix(y_test, preds)
+        fig, ax = plt.subplots()
+        ax.imshow(cm)
+        ax.set_title("Confusion Matrix")
+    elif graph_type == "ROC Curve":
+        probs = pipeline.predict_proba(X_test)[:, 1]
+        fpr, tpr, _ = roc_curve(y_test, probs)
+        fig, ax = plt.subplots()
+        ax.plot(fpr, tpr)
+        ax.set_title("ROC Curve")
+    elif graph_type == "Per-Class Metrics Table":
+        fig = classification_report(y_test, preds, output_dict=True)
+        fig = pd.DataFrame(fig).transpose()
+    elif graph_type == "Precision-Recall Curve":
+        probs = pipeline.predict_proba(X_test)[:, 1]
+        p, r, _ = precision_recall_curve(y_test, probs)
+        fig, ax = plt.subplots()
+        ax.plot(r, p)
+        ax.set_title("Precision-Recall Curve")
+    elif graph_type == "Probability Histogram":
+        probs = pipeline.predict_proba(X_test)[:, 1]
+        fig, ax = plt.subplots()
+        ax.hist(probs, bins=20)
+        ax.set_title("Prediction Probability Histogram")
+    
+    return fig

models/registry.py

@@ -0,0 +1,40 @@
+from sklearn.linear_model import LinearRegression, LogisticRegression, Perceptron
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.naive_bayes import GaussianNB
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.svm import SVC, SVR
+from sklearn.neural_network import MLPClassifier, MLPRegressor
+
+REGRESSION_MODELS = {
+    "Linear Regression": LinearRegression(),
+    "KNN Regressor": KNeighborsRegressor(),
+    "Decision Tree Regressor": DecisionTreeRegressor(),
+    "SVR": SVR(),
+    "MLP Regressor": MLPRegressor(max_iter=1000),
+}
+
+CLASSIFICATION_MODELS = {
+    "Logistic Regression": LogisticRegression(max_iter=500),
+    "KNN Classifier": KNeighborsClassifier(),
+    "Naive Bayes": GaussianNB(),
+    "Perceptron": Perceptron(),
+    "Decision Tree Classifier": DecisionTreeClassifier(),
+    "SVM Classifier": SVC(probability=True),
+    "MLP Classifier": MLPClassifier(max_iter=1000),
+}
+
+CLASSIFICATION_GRAPHS = [
+    "Confusion Matrix",
+    "ROC Curve",
+    "Per-Class Metrics Table",
+    "Precision-Recall Curve",
+    "Probability Histogram",
+]
+
+REGRESSION_GRAPHS = [
+    "Actual vs Predicted",
+    "Residual Plot",
+    "Residual Histogram",
+    "Feature Importance",
+    "Learning Curve",
+]

preprocessing/transformers.py

@@ -0,0 +1,13 @@
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+
+def build_preprocessor(X):
+    num_cols = X.select_dtypes(include=["int64", "float64"]).columns
+    cat_cols = X.select_dtypes(include=["object", "category"]).columns
+
+    return ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), num_cols),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), cat_cols),
+        ]
+    )

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+pandas
+scikit-learn
+numpy
+matplotlib

ui/helpers.py

@@ -0,0 +1,52 @@
+import gradio as gr
+import pandas as pd
+from models.registry import REGRESSION_MODELS, CLASSIFICATION_MODELS, REGRESSION_GRAPHS, CLASSIFICATION_GRAPHS
+
+
+def update_models(task_type):
+    if task_type == "Regression":
+        models = list(REGRESSION_MODELS.keys())
+    else:
+        models = list(CLASSIFICATION_MODELS.keys())
+
+    return gr.update(
+        choices=models,
+        value=models[0] if models else None  # ✅ auto-select first
+    )
+
+
+def update_graphs(task_type):
+    graphs = (
+        REGRESSION_GRAPHS
+        if task_type == "Regression"
+        else CLASSIFICATION_GRAPHS
+    )
+
+    return gr.update(
+        choices=graphs,
+        value=graphs[0],   # ✅ auto-select first option
+    )
+
+import os
+
+def preview_csv(file, max_rows=50):
+    if not file:
+        return None
+
+    size_mb = os.path.getsize(file.name) / (1024 * 1024)
+
+    if size_mb > 50:
+        return None  # ❌ No preview
+
+    return pd.read_csv(file.name, nrows=max_rows)
+
+
+
+def reset_metrics_on_file_clear(file):
+    if file is None:
+        return pd.DataFrame(), None
+    return gr.update(), gr.update()
+
+
+def toggle_csv_preview(show):
+    return gr.update(visible=show)

ui/styles.py

@@ -0,0 +1,16 @@
+CSS_STYLE = """
+#container {
+    max-width: 1280px;
+    margin: auto;
+}
+
+@media (min-width: 1600px) {
+    #container {
+        max-width: 1440px;
+    }
+}
+
+#title h1 {
+    font-size: 2.4em !important;
+}
+"""

ui/theme.py

@@ -0,0 +1,28 @@
+from gradio.themes import Soft
+from gradio.themes.utils import colors, fonts, sizes
+
+colors.orange_red = colors.Color(
+    name="orange_red",
+    c50="#FFF0E5", c100="#FFE0CC", c200="#FFC299", c300="#FFA366",
+    c400="#FF8533", c500="#FF4500", c600="#E63E00", c700="#CC3700",
+    c800="#B33000", c900="#992900", c950="#802200",
+)
+
+class OrangeRedTheme(Soft):
+    def __init__(self):
+        super().__init__(
+            primary_hue=colors.orange_red,
+            secondary_hue=colors.orange_red,
+            neutral_hue=colors.slate,
+            text_size=sizes.text_lg,
+            font=(fonts.GoogleFont("Outfit"), "Arial", "sans-serif"),
+            font_mono=(fonts.GoogleFont("IBM Plex Mono"), "monospace"),
+        )
+        super().set(
+            body_background_fill="linear-gradient(135deg, *primary_200, *primary_100)",
+            button_primary_background_fill="linear-gradient(90deg, *secondary_500, *secondary_600)",
+            button_primary_background_fill_hover="linear-gradient(90deg, *secondary_600, *secondary_700)",
+            button_primary_text_color="white",
+            block_border_width="3px",
+            block_shadow="*shadow_drop_lg",
+        )

utils/metrics.py

@@ -0,0 +1,44 @@
+import numpy as np
+from sklearn.metrics import (
+    mean_absolute_error,
+    mean_squared_error,
+    r2_score,
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score,
+    roc_auc_score,
+)
+
+from sklearn.utils.multiclass import type_of_target
+
+def regression_metrics(y_true, preds):
+    return {
+        "MAE": mean_absolute_error(y_true, preds),
+        "MSE": mean_squared_error(y_true, preds),
+        "RMSE": np.sqrt(mean_squared_error(y_true, preds)),
+        "R²": r2_score(y_true, preds),
+    }
+
+
+def classification_metrics(pipeline, X_test, y_test, preds):
+    metrics = {
+        "Accuracy": accuracy_score(y_test, preds),
+        "Precision": precision_score(y_test, preds, average="weighted"),
+        "Recall": recall_score(y_test, preds, average="weighted"),
+        "F1 Score": f1_score(y_test, preds, average="weighted"),
+    }
+
+    if hasattr(pipeline.named_steps["model"], "predict_proba"):
+        probs = pipeline.predict_proba(X_test)
+        target_type = type_of_target(y_test)
+
+        if target_type == "binary":
+            metrics["ROC-AUC"] = roc_auc_score(y_test, probs[:, 1])
+
+        elif target_type == "multiclass":
+            metrics["ROC-AUC"] = roc_auc_score(
+                y_test, probs, multi_class="ovr", average="weighted"
+            )
+
+    return metrics

version_1_app.py

@@ -0,0 +1,142 @@
+import gradio as gr
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import (
+    accuracy_score,
+    mean_absolute_error,
+    mean_squared_error,
+    r2_score,
+)
+import numpy as np
+
+# ======================
+# Model imports
+# ======================
+from sklearn.linear_model import (
+    LinearRegression,
+    LogisticRegression,
+    Perceptron,
+)
+from sklearn.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+)
+from sklearn.naive_bayes import GaussianNB
+from sklearn.tree import (
+    DecisionTreeClassifier,
+    DecisionTreeRegressor,
+)
+from sklearn.svm import SVC, SVR
+from sklearn.neural_network import (
+    MLPClassifier,
+    MLPRegressor,
+)
+
+# ======================
+# Model registry
+# ======================
+REGRESSION_MODELS = {
+    "Linear Regression": LinearRegression,
+    "KNN Regressor": KNeighborsRegressor,
+    "Decision Tree Regressor": DecisionTreeRegressor,
+    "SVR": SVR,
+    "MLP Regressor": MLPRegressor,
+}
+
+CLASSIFICATION_MODELS = {
+    "Logistic Regression": LogisticRegression,
+    "KNN Classifier": KNeighborsClassifier,
+    "Naive Bayes": GaussianNB,
+    "Perceptron": Perceptron,
+    "Decision Tree Classifier": DecisionTreeClassifier,
+    "SVM Classifier": SVC,
+    "MLP Classifier": MLPClassifier,
+}
+
+# ======================
+# UI Logic
+# ======================
+def update_models(task_type):
+    if task_type == "Regression":
+        return gr.update(choices=list(REGRESSION_MODELS.keys()), value=None)
+    return gr.update(choices=list(CLASSIFICATION_MODELS.keys()), value=None)
+
+
+def train_model(file, task_type, model_name):
+    df = pd.read_csv(file.name)
+
+    # Assumption: last column is target
+    X = df.iloc[:, :-1]
+    y = df.iloc[:, -1]
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    if task_type == "Regression":
+        model = REGRESSION_MODELS[model_name]()
+        model.fit(X_train, y_train)
+
+        preds = model.predict(X_test)
+
+        mae = mean_absolute_error(y_test, preds)
+        mse = mean_squared_error(y_test, preds)
+        rmse = np.sqrt(mse)
+        r2 = r2_score(y_test, preds)
+
+        return (
+            f"Model: {model_name}\n"
+            f"Task: Regression\n"
+            f"MAE: {mae:.4f}\n"
+            f"MSE: {mse:.4f}\n"
+            f"RMSE: {rmse:.4f}\n"
+            f"R² Score: {r2:.4f}"
+        )
+
+    else:
+        model = CLASSIFICATION_MODELS[model_name]()
+        model.fit(X_train, y_train)
+
+        preds = model.predict(X_test)
+        acc = accuracy_score(y_test, preds)
+
+        return (
+            f"Model: {model_name}\n"
+            f"Task: Classification\n"
+            f"Accuracy: {acc:.4f}"
+        )
+
+
+# ======================
+# Gradio App
+# ======================
+with gr.Blocks() as demo:
+    gr.Markdown("## Supervised Learning Model Trainer")
+    gr.Markdown(
+        "Upload a CSV file. The **last column is treated as target**."
+    )
+
+    file_input = gr.File(label="Upload CSV", file_types=[".csv"])
+    task_dropdown = gr.Dropdown(
+        ["Regression", "Classification"],
+        label="Task Type",
+    )
+    model_dropdown = gr.Dropdown(label="Model")
+    output = gr.Textbox(label="Result", lines=5)
+
+    train_btn = gr.Button("Generate")
+
+    task_dropdown.change(
+        update_models,
+        inputs=task_dropdown,
+        outputs=model_dropdown,
+    )
+
+    train_btn.click(
+        train_model,
+        inputs=[file_input, task_dropdown, model_dropdown],
+        outputs=output,
+    )
+
+demo.launch()

version_2_app.py

@@ -0,0 +1,266 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import warnings
+warnings.filterwarnings(action="ignore")
+
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import (
+    StandardScaler,
+    OneHotEncoder,
+    LabelEncoder,
+)
+from sklearn.metrics import (
+    mean_absolute_error,
+    mean_squared_error,
+    r2_score,
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score,
+    roc_auc_score,
+)
+
+# ======================
+# Models
+# ======================
+from sklearn.linear_model import (
+    LinearRegression,
+    LogisticRegression,
+    Perceptron,
+)
+from sklearn.neighbors import (
+    KNeighborsClassifier,
+    KNeighborsRegressor,
+)
+from sklearn.naive_bayes import GaussianNB
+from sklearn.tree import (
+    DecisionTreeClassifier,
+    DecisionTreeRegressor,
+)
+from sklearn.svm import SVC, SVR
+from sklearn.neural_network import (
+    MLPClassifier,
+    MLPRegressor,
+)
+
+from sklearn.utils.multiclass import type_of_target
+
+# ======================
+# Model Registry
+# ======================
+REGRESSION_MODELS = {
+    "Linear Regression": LinearRegression(),
+    "KNN Regressor": KNeighborsRegressor(),
+    "Decision Tree Regressor": DecisionTreeRegressor(),
+    "SVR": SVR(),
+    "MLP Regressor": MLPRegressor(max_iter=1000),
+}
+
+CLASSIFICATION_MODELS = {
+    "Logistic Regression": LogisticRegression(max_iter=500),
+    "KNN Classifier": KNeighborsClassifier(),
+    "Naive Bayes": GaussianNB(),
+    "Perceptron": Perceptron(),
+    "Decision Tree Classifier": DecisionTreeClassifier(),
+    "SVM Classifier": SVC(probability=True),
+    "MLP Classifier": MLPClassifier(max_iter=1000),
+}
+
+# ======================
+# UI Helpers
+# ======================
+def update_models(task_type):
+    if task_type == "Regression":
+        return gr.update(choices=list(REGRESSION_MODELS.keys()), value=None)
+    else:
+        return gr.update(choices=list(CLASSIFICATION_MODELS.keys()), value=None)
+
+def preview_csv(file):
+    if file is None:
+        return None
+    return pd.read_csv(file.name)
+
+
+def detect_target_type(y):
+    # Categorical target
+    if y.dtype == "object" or y.dtype.name == "category":
+        return "Classification"
+
+    # Numeric but low cardinality → classification
+    if y.nunique() <= 20:
+        return "Classification"
+
+    return "Regression"
+
+
+def auto_set_task(file):
+    if file is None:
+        return "Regression"
+    df = pd.read_csv(file.name)
+    y = df.iloc[:, -1]
+    return detect_target_type(y)
+
+
+# ======================
+# Core Training Logic
+# ======================
+def train_model(file, task_type, model_name):
+    df = pd.read_csv(file.name)
+
+    # Target = last column
+    X = df.iloc[:, :-1]
+    y = df.iloc[:, -1]
+
+    detected_task = detect_target_type(y)
+
+    # 🚫 Mismatch validation
+    if task_type != detected_task:
+        return pd.DataFrame(
+            {
+                "Error": [
+                    f"Dataset target detected as {detected_task}, "
+                    f"but {task_type} model selected."
+                ]
+            }
+        )
+
+    # ---------- Automatic label encoding ----------
+    if task_type == "Classification" and y.dtype == "object":
+        y = LabelEncoder().fit_transform(y)
+
+    # ---------- Feature preprocessing ----------
+    num_cols = X.select_dtypes(include=["int64", "float64"]).columns
+    cat_cols = X.select_dtypes(include=["object", "category"]).columns
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), num_cols),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), cat_cols),
+        ]
+    )
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # ---------- Model selection ----------
+    model = (
+        REGRESSION_MODELS[model_name]
+        if task_type == "Regression"
+        else CLASSIFICATION_MODELS[model_name]
+    )
+
+    pipeline = Pipeline(
+        steps=[
+            ("preprocessing", preprocessor),
+            ("model", model),
+        ]
+    )
+
+    pipeline.fit(X_train, y_train)
+    preds = pipeline.predict(X_test)
+
+    # ---------- Metrics ----------
+    if task_type == "Regression":
+        metrics = {
+            "MAE": mean_absolute_error(y_test, preds),
+            "MSE": mean_squared_error(y_test, preds),
+            "RMSE": np.sqrt(mean_squared_error(y_test, preds)),
+            "R²": r2_score(y_test, preds),
+        }
+
+    else:
+        metrics = {
+            "Accuracy": accuracy_score(y_test, preds),
+            "Precision": precision_score(y_test, preds, average="weighted"),
+            "Recall": recall_score(y_test, preds, average="weighted"),
+            "F1 Score": f1_score(y_test, preds, average="weighted"),
+        }
+
+        # ROC-AUC (safe handling)
+        if hasattr(pipeline.named_steps["model"], "predict_proba"):
+            probs = pipeline.predict_proba(X_test)
+            target_type = type_of_target(y_test)
+
+            # Binary classification
+            if target_type == "binary":
+                roc_auc = roc_auc_score(y_test, probs[:, 1])
+                metrics["ROC-AUC"] = roc_auc
+
+            # Multiclass classification
+            elif target_type == "multiclass":
+                roc_auc = roc_auc_score(
+                    y_test,
+                    probs,
+                    multi_class="ovr",
+                    average="weighted",
+                )
+                metrics["ROC-AUC"] = roc_auc
+
+
+    # ---------- Metric table ----------
+    result_df = pd.DataFrame(
+        metrics.items(), columns=["Metric", "Value"]
+    )
+
+    return result_df
+
+# ======================
+# Gradio UI
+# ======================
+with gr.Blocks() as app:
+    gr.Markdown("## Supervised Learning Model Trainer")
+    gr.Markdown(
+        "• Upload CSV\n"
+        "• Last column is target\n"
+        "• Automatic preprocessing & metrics"
+    )
+
+    file_input = gr.File(label="Upload CSV", file_types=[".csv"])
+
+    csv_preview = gr.Dataframe(
+        label="CSV Preview",
+        interactive=False,
+    )
+
+    task_type = gr.Dropdown(
+        ["Regression", "Classification"], label="Task Type", value="Regression"
+    )
+    model_name = gr.Dropdown(label="Model")
+    output = gr.Dataframe(label="Evaluation Metrics")
+
+    run_btn = gr.Button("Train & Evaluate")
+
+
+    file_input.change(
+        preview_csv,
+        inputs=file_input,
+        outputs=csv_preview,
+    )
+
+    file_input.change(
+        auto_set_task,
+        inputs=file_input,
+        outputs=task_type,
+    )
+
+    task_type.change(
+        update_models, inputs=task_type, outputs=model_name
+    )
+
+    app.load(
+        update_models,
+        inputs=task_type,
+        outputs=model_name,
+    )
+
+    run_btn.click(
+        train_model,
+        inputs=[file_input, task_type, model_name],
+        outputs=output,
+    )
+
+app.launch()