Deploy CodeBERT training Space

.gitignore

@@ -4,9 +4,7 @@ __pycache__/
 venv/
 .env
 data/*.parquet
-data/*.csv
-models/*.joblib
-models/evaluation/
+models/
 .DS_Store
 *.egg-info/
 dist/

Dockerfile

@@ -0,0 +1,17 @@
+# Python 3.12 — avoids Gradio/pydub audioop breakage on Python 3.13
+FROM python:3.12-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+CMD ["python", "train_space_app.py"]

README.md

@@ -3,9 +3,8 @@ title: SQL Error Classifier Training
 emoji: 🧠
 colorFrom: blue
 colorTo: green
-sdk: gradio
-sdk_version: 4.44.0
-app_file: train_space_app.py
+sdk: docker
+app_port: 7860
 pinned: false
 license: mit
 hardware: t4-small

README_TRAIN_SPACE.md

@@ -3,9 +3,8 @@ title: SQL Error Classifier Training
 emoji: 🧠
 colorFrom: blue
 colorTo: green
-sdk: gradio
-sdk_version: 4.44.0
-app_file: train_space_app.py
+sdk: docker
+app_port: 7860
 pinned: false
 license: mit
 hardware: t4-small

app.py

@@ -1,155 +1,66 @@
-"""
-Gradio app for Hugging Face Spaces.
-
-Deploy: create a Space with sdk=gradio and point app_file to this file.
-Set SPACE_MODEL_ID env var to your HF model repo (e.g. username/sql-error-classifier).
-"""
+"""CodeBERT inference Gradio app (optional HF Space for predictions)."""
 
 from __future__ import annotations
 
-import json
-import os
-from pathlib import Path
-
 import gradio as gr
 
-from src.huggingface import SQLLErrorClassifierHF
+from src.hf_predict_codebert import CodeBERTSQLErrorClassifier
 
-MODEL_ID = os.getenv("SPACE_MODEL_ID", "models/hf_package")
-LOCAL_PACKAGE = Path(__file__).parent / "models" / "hf_package"
+MODEL_DIR = "models/codebert-cross-encoder"
+
+try:
+    clf = CodeBERTSQLErrorClassifier(MODEL_DIR)
+    model_status = f"Loaded model from `{MODEL_DIR}`"
+except Exception as exc:
+    clf = None
+    model_status = f"Model not loaded: {exc}. Train first or set SPACE_MODEL_DIR."
 
 EXAMPLE = {
     "question": "What is the average score of students in each department?",
     "schema": "students(id, name, score, department_id) | departments(id, name)",
-    "correct_query": (
-        "SELECT department_id, AVG(score) FROM students GROUP BY department_id"
-    ),
-    "student_query": (
-        "SELECT department_id, SUM(score) FROM students GROUP BY department_id"
-    ),
-    "error_message": "query executes but produces incorrect result set",
+    "student_sql": "SELECT department_id, SUM(score) FROM students GROUP BY department_id",
+    "correct_sql": "SELECT department_id, AVG(score) FROM students GROUP BY department_id",
 }
 
 
-def _load_classifier() -> SQLLErrorClassifierHF:
-    if LOCAL_PACKAGE.exists() and (LOCAL_PACKAGE / "config.json").exists():
-        return SQLLErrorClassifierHF.from_pretrained(LOCAL_PACKAGE)
-    return SQLLErrorClassifierHF.from_pretrained(MODEL_ID)
-
-
-clf = _load_classifier()
-
-
-def classify(
-    question: str,
-    schema: str,
-    correct_query: str,
-    student_query: str,
-    error_message: str,
-) -> tuple[str, str, str]:
+def classify(question, schema, student_sql, correct_sql, threshold):
+    if clf is None:
+        return "Train a model first.", ""
     result = clf.predict(
         question=question.strip(),
         schema=schema.strip(),
-        correct_query=correct_query.strip(),
-        student_query=student_query.strip(),
-        error_message=error_message.strip() or None,
+        student_sql=student_sql.strip(),
+        correct_sql=correct_sql.strip(),
+        threshold=threshold,
     )
-
     summary = (
-        f"**{result['label_name']}**  \n"
-        f"Confidence: **{result['confidence']:.1%}**"
+        f"**{result['primary_label']}** ({result['primary_confidence']:.1%})\n\n"
+        f"All labels above threshold: {', '.join(result['error_labels']) or 'none'}"
     )
-    top_k = "\n".join(
-        f"- {item['label_name']}: {item['confidence']:.1%}"
-        for item in result["top_k"]
+    probs = "\n".join(
+        f"- {k}: {v:.1%}" for k, v in result["probabilities"].items()
     )
-    sims = result.get("similarities") or result.get("pair_scores") or {}
-    diagnostics = "\n".join(
-        f"- **{k.replace('_', ' ').title()}**: {v:.3f}"
-        for k, v in sims.items()
-    )
-    if not diagnostics:
-        diagnostics = "_No diagnostic scores for this model type._"
-    return summary, top_k, diagnostics
+    return summary, probs
 
 
 with gr.Blocks(title="SQL Error Classifier") as demo:
-    gr.Markdown(
-        """
-        # SQL Error Classifier
-        Classify **which mistake area** a student is struggling with, using:
-        **question**, **schema**, **correct query**, and the **student's query**.
-
-        Powered by a multi-tower MiniLM architecture on Hugging Face.
-        """
-    )
-
+    gr.Markdown(f"# SQL Error Classifier (CodeBERT)\n{model_status}")
     with gr.Row():
         with gr.Column():
-            question = gr.Textbox(
-                label="Question",
-                lines=2,
-                value=EXAMPLE["question"],
-            )
-            schema = gr.Textbox(
-                label="Schema",
-                lines=2,
-                value=EXAMPLE["schema"],
-            )
-            correct_query = gr.Textbox(
-                label="Correct Query",
-                lines=3,
-                value=EXAMPLE["correct_query"],
-            )
-            student_query = gr.Textbox(
-                label="Student Query",
-                lines=3,
-                value=EXAMPLE["student_query"],
-            )
-            error_message = gr.Textbox(
-                label="DB Error Message (optional)",
-                lines=2,
-                value=EXAMPLE["error_message"],
-            )
-            run_btn = gr.Button("Classify", variant="primary")
-
+            question = gr.Textbox(label="Question", lines=2, value=EXAMPLE["question"])
+            schema = gr.Textbox(label="Schema", lines=2, value=EXAMPLE["schema"])
+            student_sql = gr.Textbox(label="Student SQL", lines=3, value=EXAMPLE["student_sql"])
+            correct_sql = gr.Textbox(label="Correct SQL", lines=3, value=EXAMPLE["correct_sql"])
+            threshold = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Threshold")
+            btn = gr.Button("Classify", variant="primary")
         with gr.Column():
-            prediction = gr.Markdown(label="Prediction")
-            top_k = gr.Markdown(label="Top 3")
-            diagnostics = gr.Markdown(label="Semantic Diagnostics")
+            prediction = gr.Markdown()
+            probabilities = gr.Markdown()
 
-    run_btn.click(
+    btn.click(
         classify,
-        inputs=[question, schema, correct_query, student_query, error_message],
-        outputs=[prediction, top_k, diagnostics],
-    )
-
-    gr.Examples(
-        examples=[
-            [
-                EXAMPLE["question"],
-                EXAMPLE["schema"],
-                EXAMPLE["correct_query"],
-                EXAMPLE["student_query"],
-                EXAMPLE["error_message"],
-            ],
-            [
-                "Find students who have not provided an email address.",
-                "students(id, name, email, phone)",
-                "SELECT name FROM students WHERE email IS NULL",
-                "SELECT name FROM students WHERE email = NULL",
-                "use IS NULL or IS NOT NULL to test for null values",
-            ],
-            [
-                "List each student's name along with their department name.",
-                "students(id, name, department_id) | departments(id, name)",
-                "SELECT students.name, departments.name FROM students "
-                "INNER JOIN departments ON students.department_id = departments.id",
-                "SELECT students.name, departments.name FROM students JOIN departments",
-                "missing ON clause or invalid join condition",
-            ],
-        ],
-        inputs=[question, schema, correct_query, student_query, error_message],
+        [question, schema, student_sql, correct_sql, threshold],
+        [prediction, probabilities],
     )
 
 if __name__ == "__main__":

requirements.txt

@@ -1,15 +1,13 @@
 numpy>=1.24.0
 pandas>=2.0.0
 scikit-learn>=1.3.0
-joblib>=1.3.0
 pyarrow>=14.0.0
 tqdm>=4.66.0
 pyyaml>=6.0
-matplotlib>=3.7.0
-sentence-transformers>=2.2.0
 torch>=2.0.0
 transformers>=4.36.0
 accelerate>=0.25.0
 datasets>=2.16.0
 huggingface_hub>=0.20.0
 gradio>=4.44.0
+pyaudioop>=0.3.0

scripts/deploy_train_space.sh

@@ -1,15 +1,9 @@
 #!/usr/bin/env bash
-# Deploy training Space to Hugging Face.
-# Usage: ./scripts/deploy_train_space.sh YOUR_HF_USERNAME/sql-error-classifier-train
+# Deploy CodeBERT training Space to Hugging Face.
+# Usage: ./scripts/deploy_train_space.sh [YOUR_USERNAME/space-name]
 set -euo pipefail
 
-SPACE_ID="${1:-}"
-if [[ -z "${SPACE_ID}" ]]; then
-  echo "Usage: $0 YOUR_USERNAME/sql-error-classifier-train"
-  exit 1
-fi
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+SPACE_SUFFIX="${1:-sql-error-classifier-train}"
 TOKEN="${HF_TOKEN:-${HUGGING_FACE_HUB_TOKEN:-}}"
 
 if [[ -z "${TOKEN}" ]]; then
@@ -17,27 +11,42 @@ if [[ -z "${TOKEN}" ]]; then
   exit 1
 fi
 
+# Resolve full space id — must use an account you own
+if [[ "${SPACE_SUFFIX}" == */* ]]; then
+  SPACE_ID="${SPACE_SUFFIX}"
+else
+  USERNAME=$(python - <<PY
+from huggingface_hub import HfApi
+api = HfApi(token="${TOKEN}")
+print(api.whoami()["name"])
+PY
+)
+  SPACE_ID="${USERNAME}/${SPACE_SUFFIX}"
+fi
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 WORKDIR=$(mktemp -d)
 trap 'rm -rf "${WORKDIR}"' EXIT
 
-echo "==> Preparing Space files in ${WORKDIR}..."
+echo "==> Preparing Space files..."
 rsync -a \
   --exclude '.venv' \
   --exclude 'models' \
   --exclude '__pycache__' \
   --exclude '.git' \
+  --exclude '*.joblib' \
   "${ROOT}/" "${WORKDIR}/"
 
 cp "${ROOT}/README_TRAIN_SPACE.md" "${WORKDIR}/README.md"
 
-echo "==> Creating / updating Space ${SPACE_ID}..."
+echo "==> Creating Space: ${SPACE_ID}"
 python - <<PY
 from huggingface_hub import HfApi
 api = HfApi(token="${TOKEN}")
-api.create_repo("${SPACE_ID}", repo_type="space", space_sdk="gradio", exist_ok=True)
+api.create_repo("${SPACE_ID}", repo_type="space", space_sdk="docker", exist_ok=True)
 PY
 
-echo "==> Uploading to Hugging Face Space..."
+echo "==> Uploading..."
 python - <<PY
 from huggingface_hub import HfApi
 api = HfApi(token="${TOKEN}")
@@ -49,6 +58,5 @@ api.upload_folder(
 )
 PY
 
-echo "==> Done: https://huggingface.co/spaces/${SPACE_ID}"
-echo "Next: Space Settings → Hardware → GPU t4-small"
-echo "      Space Settings → Secrets → HF_TOKEN"
+echo "Done: https://huggingface.co/spaces/${SPACE_ID}"
+echo "Set Hardware → GPU t4-small, Secrets → HF_TOKEN"

train_space_app.py

@@ -227,4 +227,4 @@ with gr.Blocks(title="SQL Error Classifier — Train") as demo:
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)