feat: initial release of machine learning space

README.md

@@ -0,0 +1,19 @@
+---
+title: Custom Text Classification Studio
+emoji: 🏷️
+colorFrom: red
+colorTo: blue
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# Custom Text Classification Studio
+
+An interactive educational machine learning application designed to help digital humanities and social science students learn supervised learning. Students can upload a labeled dataset, train a classifier locally, and instantly test predictions in real-time.
+
+### Features
+1. **Interactive Training**: Choose between Multinomial Naive Bayes, Logistic Regression, or Linear SVM models.
+2. **Visual Diagnostic Dashboards**: View accuracy scores, comprehensive classification reports, and interactive Plotly confusion matrix heatmaps.
+3. **Live Testing Playground**: Type or paste new, unseen paragraphs and view predicted categories along with a full probability distribution bar chart.
+4. **Zero-Server dependencies**: Trains in seconds completely inside the Space memory.

app.py

@@ -0,0 +1,260 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.model_selection import train_test_split
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import LinearSVC
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+import plotly.graph_objects as go
+
+# Global variables to store the trained model, vectorizer, and categories
+global_vectorizer = None
+global_model = None
+global_classes = None
+
+def train_classifier(file_obj, algorithm):
+    global global_vectorizer, global_model, global_classes
+    
+    if file_obj is None:
+        return "Please upload a CSV or Excel labeled training file.", None, None, gr.update(visible=False)
+        
+    try:
+        if file_obj.name.endswith('.csv'):
+            df = pd.read_csv(file_obj.name)
+        else:
+            df = pd.read_excel(file_obj.name)
+    except Exception as e:
+        return f"Error reading file: {str(e)}", None, None, gr.update(visible=False)
+        
+    # Standardize column headers
+    text_col, label_col = None, None
+    for col in df.columns:
+        if col.lower() in ['text', 'document', 'content', 'body', 'sentence']:
+            text_col = col
+        elif col.lower() in ['label', 'category', 'class', 'target', 'topic']:
+            label_col = col
+            
+    if not text_col or not label_col:
+        # Fallbacks
+        string_cols = df.select_dtypes(include=['object']).columns
+        if len(string_cols) >= 2:
+            text_col = string_cols[0]
+            label_col = string_cols[1]
+        else:
+            return "Could not find 'Text' and 'Label' columns. Make sure your sheet has at least two columns.", None, None, gr.update(visible=False)
+            
+    df = df.dropna(subset=[text_col, label_col])
+    
+    if len(df) < 10:
+        return "Training dataset is too small. Please provide at least 10 labeled rows.", None, None, gr.update(visible=False)
+        
+    texts = df[text_col].astype(str).tolist()
+    labels = df[label_col].astype(str).tolist()
+    
+    # Split
+    X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.25, random_state=42)
+    
+    # Vectorizer
+    vectorizer = TfidfVectorizer(stop_words='english', max_features=2000)
+    X_train_vec = vectorizer.fit_transform(X_train)
+    X_test_vec = vectorizer.transform(X_test)
+    
+    # Model select
+    if algorithm == "Naive Bayes":
+        model = MultinomialNB()
+    elif algorithm == "Logistic Regression":
+        model = LogisticRegression(random_state=42, max_iter=1000)
+    else:  # Linear SVM
+        model = LinearSVC(random_state=42)
+        
+    model.fit(X_train_vec, y_train)
+    preds = model.predict(X_test_vec)
+    
+    # Metrics
+    acc = accuracy_score(y_test, preds)
+    classes = sorted(list(set(labels)))
+    report = classification_report(y_test, preds, output_dict=True)
+    report_df = pd.DataFrame(report).transpose().round(3).reset_index().rename(columns={"index": "Metric Class"})
+    
+    # Save globals for real-time inference
+    global_vectorizer = vectorizer
+    global_model = model
+    global_classes = classes
+    
+    # 4. Generate Visual Plotly Confusion Matrix
+    cm = confusion_matrix(y_test, preds, labels=classes)
+    
+    fig = go.Figure(data=go.Heatmap(
+        z=cm,
+        x=classes,
+        y=classes,
+        colorscale='Oranges',
+        text=cm,
+        texttemplate="%{text}",
+        hoverinfo='z'
+    ))
+    
+    fig.update_layout(
+        title=f"Confusion Matrix (Test Accuracy: {acc:.2%})",
+        paper_bgcolor='#16100c',
+        plot_bgcolor='#16100c',
+        font_color='#f4eee6',
+        xaxis=dict(title="Predicted label", gridcolor='rgba(255,255,255,0.05)'),
+        yaxis=dict(title="True label", gridcolor='rgba(255,255,255,0.05)'),
+        margin=dict(l=40, r=40, t=50, b=40)
+    )
+    
+    metrics_summary_html = f"""
+    <div style='display: grid; grid-template-columns: repeat(2, 1fr); gap: 1rem; margin-bottom: 1.5rem;'>
+        <div style='background: rgba(255, 255, 255, 0.03); border: 1px solid rgba(255, 255, 255, 0.08); border-radius: 8px; padding: 1rem; text-align: center;'>
+            <div style='font-size: 0.75rem; text-transform: uppercase; color: #ff7043; letter-spacing: 0.1em;'>Model Testing Accuracy</div>
+            <div style='font-size: 2rem; font-weight: bold; margin-top: 0.5rem;'>{acc:.2%}</div>
+        </div>
+        <div style='background: rgba(255, 255, 255, 0.03); border: 1px solid rgba(255, 255, 255, 0.08); border-radius: 8px; padding: 1rem; text-align: center;'>
+            <div style='font-size: 0.75rem; text-transform: uppercase; color: #ff7043; letter-spacing: 0.1em;'>Number of Target Classes</div>
+            <div style='font-size: 2rem; font-weight: bold; margin-top: 0.5rem;'>{len(classes)}</div>
+        </div>
+    </div>
+    """
+    
+    return "", metrics_summary_html, fig, report_df, gr.update(visible=True)
+
+def classify_new_text(new_text):
+    global global_vectorizer, global_model, global_classes
+    
+    if global_model is None or global_vectorizer is None:
+        return "Please train a classification model first using the panel on the left.", None
+        
+    if not new_text or len(new_text.strip()) < 3:
+        return "Please enter a valid text to classify.", None
+        
+    # Vectorize
+    vec = global_vectorizer.transform([new_text])
+    
+    # Predict
+    if hasattr(global_model, "predict_proba"):
+        probs = global_model.predict_proba(vec)[0]
+    else:  # LinearSVC uses decision function
+        decision = global_model.decision_function(vec)[0]
+        # Map decision scores to pseudo-probabilities via softmax or sigmoid
+        if len(global_classes) == 2:
+            # For binary LinearSVC, decision is a single float
+            probs = np.array([1 / (1 + np.exp(decision)), 1 / (1 + np.exp(-decision))])
+        else:
+            exp_scores = np.exp(decision - np.max(decision))
+            probs = exp_scores / exp_scores.sum()
+            
+    pred_idx = np.argmax(probs)
+    predicted_label = global_classes[pred_idx]
+    confidence = probs[pred_idx]
+    
+    # Generate horizontal Plotly bar chart
+    fig = go.Figure(go.Bar(
+        x=probs,
+        y=global_classes,
+        orientation='h',
+        marker=dict(color='#ff7043', line=dict(width=1, color='#16100c')),
+        text=[f"{p:.1%}" for p in probs],
+        textposition='auto'
+    ))
+    
+    fig.update_layout(
+        title="Class Probability Distribution",
+        paper_bgcolor='#16100c',
+        plot_bgcolor='#16100c',
+        font_color='#f4eee6',
+        xaxis=dict(showgrid=True, gridcolor='rgba(255,255,255,0.05)', range=[0, 1]),
+        yaxis=dict(gridcolor='rgba(255,255,255,0.05)'),
+        margin=dict(l=40, r=40, t=50, b=40)
+    )
+    
+    result_html = f"""
+    <div style='background: rgba(255, 112, 67, 0.05); border-left: 4px solid #ff7043; border-radius: 4px; padding: 1.5rem; margin-bottom: 1rem;'>
+        <div style='font-size: 0.8rem; text-transform: uppercase; color: #f4eee6; letter-spacing: 0.1em;'>Predicted Category</div>
+        <div style='font-size: 2.2rem; font-weight: bold; color: #ff7043; margin-top: 0.5rem;'>{predicted_label}</div>
+        <div style='font-size: 0.95rem; margin-top: 0.5rem; opacity: 0.8;'>Confidence Score: <strong>{confidence:.2%}</strong></div>
+    </div>
+    """
+    
+    return result_html, fig
+
+theme = gr.themes.Default(
+    primary_hue="orange",
+    neutral_hue="stone"
+).set(
+    body_background_fill="#0d0907",
+    body_text_color="#c4bbae",
+    block_background_fill="#16100c",
+    block_border_width="1px",
+    block_label_text_color="#f4eee6"
+)
+
+with gr.Blocks(theme=theme, title="Text Classifier Studio") as demo:
+    gr.Markdown(
+        """
+        # 🏷️ Custom Text Classification Studio
+        ### Upload a labeled training sheet (CSV containing Text and Category labels) to train a custom machine learning classifier locally. Test it instantly with live texts!
+        """
+    )
+    
+    error_msg = gr.Markdown("", visible=False)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_obj = gr.File(label="Upload Training CSV or Excel", file_types=[".csv", ".xlsx"])
+            gr.Markdown("💡 **Tip**: Make sure your sheet has a **Text** column and a **Label** column (e.g., 'Politics', 'Sports', 'Art').")
+            
+            algorithm = gr.Radio(
+                choices=["Naive Bayes", "Logistic Regression", "Linear Support Vector (SVM)"],
+                value="Naive Bayes",
+                label="Classification Algorithm"
+            )
+            
+            train_btn = gr.Button("Train Custom Classifier", variant="primary")
+            
+        with gr.Column(scale=2):
+            stats_box = gr.HTML()
+            
+            with gr.Tabs():
+                with gr.TabItem("Validation & Diagnostics"):
+                    plot_cm = gr.Plot()
+                    table_report = gr.Dataframe(headers=["Metric Class", "precision", "recall", "f1-score", "support"])
+                    
+                with gr.TabItem("Live Model Playground"):
+                    with gr.Group(visible=False) as inference_group:
+                        new_text_input = gr.Textbox(
+                            label="Enter New Text to Classify",
+                            placeholder="Write or paste any paragraph here to test the trained model in real-time...",
+                            lines=5
+                        )
+                        predict_btn = gr.Button("Predict Category", variant="secondary")
+                        prediction_result = gr.HTML()
+                        plot_probs = gr.Plot()
+                    
+                    no_model_warning = gr.Markdown(
+                        "⚠️ **No Model Trained Yet**: Upload a training dataset on the left and click 'Train Custom Classifier' to unlock the live playground!",
+                        visible=True
+                    )
+
+    def on_train_success(file_obj, algo):
+        err, stats, plot, report, update_group = train_classifier(file_obj, algo)
+        if err:
+            return gr.update(value=err, visible=True), "", None, None, gr.update(visible=False), gr.update(visible=True)
+        return gr.update(visible=False), stats, plot, report, update_group, gr.update(visible=False)
+        
+    train_btn.click(
+        on_train_success,
+        inputs=[file_obj, algorithm],
+        outputs=[error_msg, stats_box, plot_cm, table_report, inference_group, no_model_warning]
+    )
+    
+    predict_btn.click(
+        classify_new_text,
+        inputs=[new_text_input],
+        outputs=[prediction_result, plot_probs]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+pandas
+numpy
+scikit-learn
+plotly
+openpyxl