Deploy CodeBERT inference Space

README.md

@@ -25,7 +25,7 @@ Model: [nishu08/sql-codebert-classifier](https://huggingface.co/nishu08/sql-code
 ## Labels
 
 `JOIN_ERROR`, `AGGREGATION_ERROR`, `FILTER_ERROR`, `WINDOW_FUNCTION_ERROR`,
-`SUBQUERY_ERROR`, `NULL_HANDLING_ERROR`, `PERFORMANCE_ERROR`, `LOGICAL_ERROR`, `SYNTAX_ERROR`
+`SUBQUERY_ERROR`, `NULL_HANDLING_ERROR`, `PERFORMANCE_ERROR`, `LOGICAL_ERROR`, `SYNTAX_ERROR`, `NO_ERROR`
 
 ## Secrets (optional)
 

README_INFERENCE_SPACE.md

@@ -25,7 +25,7 @@ Model: [nishu08/sql-codebert-classifier](https://huggingface.co/nishu08/sql-code
 ## Labels
 
 `JOIN_ERROR`, `AGGREGATION_ERROR`, `FILTER_ERROR`, `WINDOW_FUNCTION_ERROR`,
-`SUBQUERY_ERROR`, `NULL_HANDLING_ERROR`, `PERFORMANCE_ERROR`, `LOGICAL_ERROR`, `SYNTAX_ERROR`
+`SUBQUERY_ERROR`, `NULL_HANDLING_ERROR`, `PERFORMANCE_ERROR`, `LOGICAL_ERROR`, `SYNTAX_ERROR`, `NO_ERROR`
 
 ## Secrets (optional)
 

app.py

@@ -42,6 +42,13 @@ EXAMPLES = [
         "SELECT students.name, departments.name FROM students INNER JOIN departments ON students.department_id = departments.id",
         0.5,
     ],
+    [
+        "What is the average score of students in each department?",
+        "students(id, name, score, department_id) | departments(id, name)",
+        "SELECT department_id, AVG(score) FROM students GROUP BY department_id",
+        "SELECT department_id, AVG(score) FROM students GROUP BY department_id",
+        0.5,
+    ],
 ]
 
 
@@ -55,14 +62,27 @@ def classify(question, schema, student_sql, correct_sql, threshold):
         correct_sql=correct_sql.strip(),
         threshold=threshold,
     )
-    summary = (
-        f"### {result['primary_label']}\n"
-        f"Confidence: **{result['primary_confidence']:.1%}**\n\n"
-        f"**Active labels:** {', '.join(result['error_labels']) or 'none'}"
-    )
-    probs = "\n".join(
-        f"- **{k}**: {v:.1%}" for k, v in result["probabilities"].items()
-    )
+    if result["primary_label"] == "NO_ERROR":
+        if result.get("match_detected"):
+            summary = (
+                "### No error\n"
+                "Student SQL matches the correct answer — no mistake to classify."
+            )
+        else:
+            summary = (
+                "### No error\n"
+                f"No label exceeded the {threshold:.0%} threshold."
+            )
+        probs = "_All probabilities below threshold._"
+    else:
+        summary = (
+            f"### {result['primary_label']}\n"
+            f"Confidence: **{result['primary_confidence']:.1%}**\n\n"
+            f"**Active labels:** {', '.join(result['error_labels']) or 'none'}"
+        )
+        probs = "\n".join(
+            f"- **{k}**: {v:.1%}" for k, v in result["probabilities"].items()
+        )
     return summary, probs
 
 

config/codebert_labels.yaml

@@ -9,6 +9,7 @@ labels:
   - PERFORMANCE_ERROR
   - LOGICAL_ERROR
   - SYNTAX_ERROR
+  - NO_ERROR
 
 # Map dataset label_name values → one or more CodeBERT labels (multi-label)
 alias_map:
@@ -27,3 +28,4 @@ alias_map:
   TABLE_REFERENCE_ERROR: [SYNTAX_ERROR]
   DATA_TYPE_ERROR: [SYNTAX_ERROR]
   DUPLICATE_RECORD_ERROR: [FILTER_ERROR]
+  NO_ERROR: [NO_ERROR]

config/error_categories.yaml

@@ -44,3 +44,6 @@ categories:
   - id: 14
     name: FILTERING_ERROR
     description: Incorrect WHERE clause
+  - id: 15
+    name: NO_ERROR
+    description: Student SQL matches the correct answer

src/codebert_formatting.py

@@ -2,12 +2,24 @@
 
 from __future__ import annotations
 
+import re
+
 QUESTION_TAG = "QUESTION:"
 SCHEMA_TAG = "SCHEMA:"
 STUDENT_TAG = "STUDENT_SQL:"
 CORRECT_TAG = "CORRECT_SQL:"
 
 
+def normalize_sql(sql: str) -> str:
+    """Normalize SQL for equality checks (whitespace, case, trailing semicolon)."""
+    text = sql.strip().rstrip(";")
+    return re.sub(r"\s+", " ", text).lower()
+
+
+def sql_queries_equivalent(student_sql: str, correct_sql: str) -> bool:
+    return normalize_sql(student_sql) == normalize_sql(correct_sql)
+
+
 def format_cross_encoder_input(
     question: str,
     schema: str,

src/hf_metrics.py

@@ -12,7 +12,7 @@ from sklearn.metrics import (
     precision_score,
     recall_score,
 )
-
+ 
 
 def sigmoid(x: np.ndarray) -> np.ndarray:
     return 1.0 / (1.0 + np.exp(-x))

src/hf_predict_codebert.py

@@ -11,7 +11,7 @@ import numpy as np
 import torch
 from transformers import AutoModelForSequenceClassification, AutoTokenizer
 
-from src.codebert_formatting import format_cross_encoder_input
+from src.codebert_formatting import format_cross_encoder_input, sql_queries_equivalent
 from src.device_utils import get_device
 from src.codebert_labels import load_codebert_labels, multihot_to_label_names
 from src.hf_metrics import sigmoid
@@ -74,6 +74,21 @@ class CodeBERTSQLErrorClassifier:
         threshold: Optional[float] = None,
         top_k: int = 5,
     ) -> dict:
+        thr = threshold if threshold is not None else self.threshold
+
+        if sql_queries_equivalent(student_sql, correct_sql):
+            return {
+                "error_labels": [],
+                "probabilities": {name: 0.0 for name in self.label_list},
+                "top_k": [
+                    {"label": name, "probability": 0.0}
+                    for name in self.label_list[:5]
+                ],
+                "primary_label": "NO_ERROR",
+                "primary_confidence": 1.0,
+                "match_detected": True,
+            }
+
         text = format_cross_encoder_input(
             question=question,
             schema=schema,
@@ -92,7 +107,6 @@ class CodeBERTSQLErrorClassifier:
             logits = self.model(**encoded).logits.cpu().numpy()[0]
 
         probs = sigmoid(logits)
-        thr = threshold if threshold is not None else self.threshold
         predicted = multihot_to_label_names(probs, self.label_list, threshold=thr)
 
         ranked = sorted(
@@ -101,14 +115,23 @@ class CodeBERTSQLErrorClassifier:
             reverse=True,
         )[:top_k]
 
+        top_label, top_prob = ranked[0]
+        if top_prob >= thr:
+            primary_label = top_label
+            primary_confidence = float(top_prob)
+        else:
+            primary_label = "NO_ERROR"
+            primary_confidence = 1.0 - float(top_prob)
+
         return {
             "error_labels": predicted,
             "probabilities": {name: float(p) for name, p in ranked},
             "top_k": [
                 {"label": name, "probability": float(p)} for name, p in ranked
             ],
-            "primary_label": ranked[0][0],
-            "primary_confidence": float(ranked[0][1]),
+            "primary_label": primary_label,
+            "primary_confidence": primary_confidence,
+            "match_detected": False,
         }
 
     def predict_batch(

src/sql_templates.py

@@ -223,6 +223,12 @@ def inject_performance_error(rng: random.Random, exercise: Exercise) -> Tuple[st
     return rng.choice(variants), "inefficient query: SELECT * or cartesian join detected"
 
 
+def inject_no_error(rng: random.Random, exercise: Exercise) -> Tuple[str, str]:
+    """Correct submission: student SQL equals the reference answer."""
+    sql = exercise.correct_query.strip()
+    return sql, ""
+
+
 def inject_filtering_error(rng: random.Random, exercise: Exercise) -> Tuple[str, str]:
     sql = exercise.correct_query
     col = _pick(rng, list(exercise.columns))
@@ -255,4 +261,5 @@ ERROR_INJECTORS: Dict[int, Callable[[random.Random, Exercise], Tuple[str, str]]]
     12: inject_logical_error,
     13: inject_performance_error,
     14: inject_filtering_error,
+    15: inject_no_error,
 }