app.py

import gradio as gr
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score, precision_score

df_train = None
model = None
vectorizer = None
test_metrics = None

df_predict = None  # for batch prediction file
df_predict_results = None  # to store batch prediction results for export

def load_training_file(file):
    global df_train
    if file is None:
        return "❌ Please upload a file.", gr.update(choices=[], value=None), gr.update(choices=[], value=None)

    df_train = pd.read_excel(file.name)
    col_names = list(df_train.columns)

    return f"✅ Loaded training file with {len(df_train)} rows", gr.update(choices=col_names, value=col_names[0]), gr.update(choices=col_names, value=col_names[-1])

def interpret_score(score):
    # Simple interpretation based on accuracy score
    if score < 0.6:
        return "🔴 The model performance is LOW. Consider improving your data or features."
    elif score < 0.8:
        return "🟠 The model performance is MODERATE. It may work but could be improved."
    else:
        return "🟢 The model performance is STRONG. The model is reliable."

def train_model(text_column, target_column):
    global model, vectorizer, test_metrics, df_train

    if df_train is None:
        return "❌ No training data loaded."

    if text_column not in df_train.columns or target_column not in df_train.columns:
        return "❌ Invalid column selection."

    df_filtered = df_train.dropna(subset=[text_column, target_column])

    if len(df_filtered) < 10:
        return "❌ Not enough data after filtering for training. Need at least 10 samples."

    X_train, X_test, y_train, y_test = train_test_split(
        df_filtered[text_column], df_filtered[target_column], test_size=0.2, random_state=42
    )

    vectorizer = TfidfVectorizer()
    X_train_vec = vectorizer.fit_transform(X_train)
    X_test_vec = vectorizer.transform(X_test)

    model = LogisticRegression(max_iter=1000)
    model.fit(X_train_vec, y_train)

    y_pred = model.predict(X_test_vec)

    accuracy = accuracy_score(y_test, y_pred)
    precision = precision_score(y_test, y_pred, average='weighted', zero_division=0)
    report = classification_report(y_test, y_pred, zero_division=0)

    performance_msg = interpret_score(accuracy)

    test_metrics = (
        f"Accuracy: {accuracy:.2%}\n"
        f"Precision (weighted): {precision:.2%}\n\n"
        f"{performance_msg}\n\n"
        f"Classification Report:\n{report}"
    )

    return f"✅ Model trained on {len(df_filtered)} examples.\n\nTest set evaluation:\n{test_metrics}"

def predict_label(text_input):
    if model is None or vectorizer is None:
        return "❌ Model is not trained yet."

    X = vectorizer.transform([text_input])
    prediction = model.predict(X)[0]
    proba = model.predict_proba(X).max()

    return f"🔮 Prediction: {prediction} (confidence: {proba:.2%})"

def load_prediction_file(file):
    global df_predict
    if file is None:
        return "❌ Please upload a prediction file.", gr.update(choices=[], value=None)
    df_predict = pd.read_excel(file.name)
    col_names = list(df_predict.columns)
    return f"✅ Loaded prediction file with {len(df_predict)} rows", gr.update(choices=col_names, value=col_names[0])

def run_batch_prediction(text_column):
    global df_predict, model, vectorizer, df_predict_results
    if model is None or vectorizer is None:
        return "❌ Model is not trained yet.", None
    if df_predict is None:
        return "❌ No prediction file loaded.", None
    if text_column not in df_predict.columns:
        return "❌ Invalid text column selected.", None

    df_filtered = df_predict.dropna(subset=[text_column]).copy()
    X = vectorizer.transform(df_filtered[text_column])
    preds = model.predict(X)
    probs = model.predict_proba(X).max(axis=1)

    df_filtered["Prediction"] = preds
    df_filtered["Confidence"] = probs

    df_predict_results = df_filtered  # save for export

    # Show preview of first 10 rows
    return f"✅ Batch prediction completed on {len(df_filtered)} rows.", df_filtered.head(10)

def export_predictions():
    global df_predict_results
    if df_predict_results is None:
        return None
    export_path = "/mnt/data/predictions_output.xlsx"  # Gradio environment allows writing here
    df_predict_results.to_excel(export_path, index=False)
    return export_path

with gr.Blocks() as demo:
    gr.Markdown("# 🧠 Text Classification App")

    gr.Markdown(
        """
        ### How does this model work?
        This app uses a **Logistic Regression** model trained on your text data.
        - Text data is transformed into numbers using **TF-IDF vectorization**, which converts text into features based on word importance.
        - The model learns patterns from labeled examples you provide.
        - After training, it can predict the label/category of new text inputs.
        \n
        **Note:** Model performance depends heavily on quality and quantity of your data.
        """
    )

    gr.Markdown(
        "### Step 1: Upload your training data\n"
        "Upload an Excel file (`.xlsx`) containing your texts and corresponding labels."
    )

    with gr.Row():
        file_input = gr.File(label="Upload Training Excel File (.xlsx)", file_types=[".xlsx"],
                             interactive=True)
        load_button = gr.Button("📂 Load Training File")

    status_output = gr.Markdown()

    gr.Markdown(
        "After loading, select the text and target columns for training."
    )

    with gr.Row():
        text_column_dropdown = gr.Dropdown(label="Text column",
                                           interactive=True,
                                           info="Select the column that contains the text data.")
        target_column_dropdown = gr.Dropdown(label="Target column",
                                             interactive=True,
                                             info="Select the column that contains the labels to predict.")

    train_button = gr.Button("🚀 Train Model")
    training_status = gr.Markdown()

    gr.Markdown(
        "### Step 2: Predict on single texts\n"
        "Enter a text below to get the model's predicted label."
    )

    with gr.Row():
        input_text = gr.Textbox(label="Enter text to classify", placeholder="Type some text here...")
        predict_button = gr.Button("🔍 Predict Single")

    prediction_output = gr.Markdown()

    gr.Markdown(
        "### Step 3: Batch prediction\n"
        "Upload a new Excel file with texts to predict multiple labels at once."
    )

    with gr.Row():
        pred_file_input = gr.File(label="Upload Prediction Excel File (.xlsx)", file_types=[".xlsx"])
        load_pred_button = gr.Button("📂 Load Prediction File")

    pred_status = gr.Markdown()

    pred_text_column_dropdown = gr.Dropdown(label="Text column for Prediction",
                                            info="Select the column in your prediction file containing text to classify.")

    batch_pred_button = gr.Button("⚡ Run Batch Prediction")
    batch_pred_status = gr.Markdown()
    batch_pred_preview = gr.Dataframe(headers=None, interactive=False)

    export_button = gr.Button("⬇️ Export Predictions")
    gr.Markdown(
        "Click **Export Predictions** to download the batch prediction results as an Excel file."
    )

    # Button connections
    load_button.click(
        fn=load_training_file,
        inputs=file_input,
        outputs=[status_output, text_column_dropdown, target_column_dropdown]
    )

    train_button.click(
        fn=train_model,
        inputs=[text_column_dropdown, target_column_dropdown],
        outputs=training_status
    )

    predict_button.click(
        fn=predict_label,
        inputs=input_text,
        outputs=prediction_output
    )

    load_pred_button.click(
        fn=load_prediction_file,
        inputs=pred_file_input,
        outputs=[pred_status, pred_text_column_dropdown]
    )

    batch_pred_button.click(
        fn=run_batch_prediction,
        inputs=pred_text_column_dropdown,
        outputs=[batch_pred_status, batch_pred_preview]
    )

    export_button.click(
        fn=export_predictions,
        inputs=[],
        outputs=gr.File(file_types=[".xlsx"])
    )

if __name__ == "__main__":
    demo.launch()