Create app.py

app.py

@@ -0,0 +1,147 @@
+import pandas as pd
+import numpy as np
+import gradio as gr
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.metrics import confusion_matrix, classification_report, mean_squared_error, r2_score
+from sklearn.cluster import KMeans
+from sklearn.decomposition import PCA
+import matplotlib.pyplot as plt
+import seaborn as sns
+import io
+
+def analyze_csv(file, label_col):
+    try:
+        df = pd.read_csv(file.name if hasattr(file, "name") else file)
+    except Exception as e:
+        return None, None, None, None, f"error reading csv: {e}"
+    
+    if label_col not in df.columns:
+        return None, None, None, None, f"label column '{label_col}' not in data"
+    
+    df = df.dropna()
+    X = df.drop(columns=[label_col])
+    y = df[label_col]
+    
+    # use only numeric features for modeling; drop non-numeric columns
+    X_numeric = X.select_dtypes(include=[np.number])
+    if X_numeric.shape[1] == 0:
+        return None, None, None, None, "no numeric features available for modeling"
+    
+    results_text = ""
+    cm_img = None
+    reg_img = None
+    fi_img = None
+    
+    # placeholder for feature importances
+    feature_importances = None
+
+    # if label is numeric, treat as regression; otherwise, classification
+    if pd.api.types.is_numeric_dtype(y):
+        task = "regression"
+        X_train, X_test, y_train, y_test = train_test_split(X_numeric, y, test_size=0.3, random_state=42)
+        model = RandomForestRegressor(random_state=42)
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        mse = mean_squared_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+        results_text += f"regression results:\nmse: {mse:.3f}\nr2: {r2:.3f}\n"
+        # regression scatter plot: true vs predicted
+        plt.figure()
+        plt.scatter(y_test, y_pred, alpha=0.7)
+        plt.xlabel("true values")
+        plt.ylabel("predicted values")
+        plt.title("regression: true vs predicted")
+        buf = io.BytesIO()
+        plt.savefig(buf, format="png")
+        plt.close()
+        buf.seek(0)
+        reg_img = buf
+        # note: confusion matrix not applicable here
+        feature_importances = model.feature_importances_
+    else:
+        task = "classification"
+        # encode labels as integers
+        y_encoded = pd.factorize(y)[0]
+        X_train, X_test, y_train, y_test = train_test_split(X_numeric, y_encoded, test_size=0.3, random_state=42)
+        model = RandomForestClassifier(random_state=42)
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        cm = confusion_matrix(y_test, y_pred)
+        cr = classification_report(y_test, y_pred)
+        results_text += f"classification results:\n{cr}\n"
+        plt.figure()
+        sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
+        plt.xlabel("predicted")
+        plt.ylabel("true")
+        plt.title("confusion matrix")
+        buf = io.BytesIO()
+        plt.savefig(buf, format="png")
+        plt.close()
+        buf.seek(0)
+        cm_img = buf
+        feature_importances = model.feature_importances_
+    
+    # feature importance plot
+    fi = pd.Series(feature_importances, index=X_numeric.columns).sort_values(ascending=False)
+    plt.figure(figsize=(8,4))
+    sns.barplot(x=fi.values, y=fi.index)
+    plt.title("feature importances")
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight")
+    plt.close()
+    buf.seek(0)
+    fi_img = buf
+
+    # clustering: kmeans on numeric features; use pca for 2d visualization
+    k = 3
+    kmeans = KMeans(n_clusters=k, random_state=42)
+    clusters = kmeans.fit_predict(X_numeric)
+    pca = PCA(n_components=2, random_state=42)
+    X_pca = pca.fit_transform(X_numeric)
+    plt.figure()
+    scatter = plt.scatter(X_pca[:,0], X_pca[:,1], c=clusters, cmap="viridis", alpha=0.7)
+    plt.xlabel("pca 1")
+    plt.ylabel("pca 2")
+    plt.title("kmeans clustering (k=3)")
+    plt.colorbar(scatter, ticks=range(k))
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight")
+    plt.close()
+    buf.seek(0)
+    cluster_img = buf
+
+    return cm_img, reg_img, fi_img, cluster_img, results_text
+
+def update_dropdown(file):
+    try:
+        df = pd.read_csv(file.name if hasattr(file, "name") else file)
+        return list(df.columns)
+    except Exception as e:
+        return []
+
+with gr.Blocks() as demo:
+    gr.markdown("## csv analysis app")
+    with gr.Row():
+        file_input = gr.File(label="upload csv", file_types=[".csv"])
+        label_dropdown = gr.Dropdown(label="select label column", choices=[])
+    
+    file_input.change(fn=update_dropdown, inputs=file_input, outputs=label_dropdown)
+    
+    analyze_btn = gr.Button("analyze")
+    with gr.Tabs():
+        with gr.TabItem("results"):
+            results_textbox = gr.Textbox(label="metrics & results", lines=10)
+        with gr.TabItem("confusion matrix"):
+            cm_output = gr.Image(label="confusion matrix")
+        with gr.TabItem("regression plot"):
+            reg_output = gr.Image(label="regression plot")
+        with gr.TabItem("feature importances"):
+            fi_output = gr.Image(label="feature importances")
+        with gr.TabItem("clustering"):
+            cluster_output = gr.Image(label="cluster plot")
+    
+    analyze_btn.click(fn=analyze_csv, inputs=[file_input, label_dropdown],
+                      outputs=[cm_output, reg_output, fi_output, cluster_output, results_textbox])
+
+demo.launch()