Initial benchmark suite: 78 test cases, evaluation script, baseline results

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.py[cod]
+venv/
+.venv/
+.DS_Store

README.md

@@ -0,0 +1,55 @@
+# HSClassify Benchmark
+
+Benchmark suite for evaluating the [HSClassify](https://github.com/JamesEBall/HSClassify_micro) HS code classifier.
+
+## Results (latest)
+
+| Metric | All Cases | In-Label-Space |
+|--------|-----------|----------------|
+| Top-1 Accuracy | 79.5% | 88.6% |
+| Top-3 Accuracy | 82.0% | 91.4% |
+| Top-5 Accuracy | 83.3% | 92.9% |
+| Chapter Accuracy | 89.7% | 95.7% |
+
+### By Category
+
+| Category | N | Top-1 | Top-3 | Top-5 |
+|----------|---|-------|-------|-------|
+| easy | 27 | 96.3% | 100% | 100% |
+| edge_case | 21 | 71.4% | 76.2% | 81.0% |
+| multilingual | 20 | 100% | 100% | 100% |
+| known_failure | 10 | 10.0% | 10.0% | 10.0% |
+
+## Test Cases
+
+78 hand-crafted cases in `benchmark_cases.csv` across four categories:
+
+- **easy** (27): Common goods the model should classify correctly
+- **edge_case** (21): Ambiguous queries, short text, brand names
+- **multilingual** (20): Thai, Vietnamese, and Chinese queries
+- **known_failure** (10): Documents current blind spots and label-space gaps
+
+## Usage
+
+Requires a trained [HSClassify_micro](https://github.com/JamesEBall/HSClassify_micro) model directory as a sibling folder (or pass `--model-dir`).
+
+```bash
+# Basic benchmark (~10s)
+python benchmark.py
+
+# Custom output path
+python benchmark.py --output results/out.json
+
+# With per-class split analysis
+python benchmark.py --split-analysis
+
+# Point to model directory explicitly
+python benchmark.py --model-dir /path/to/HSClassify_micro
+```
+
+## Split Analysis (training data)
+
+Replicates the 80/20 stratified split from model training to report:
+- Worst 15 HS codes by F1 score
+- Top 20 cross-chapter confusions
+- Overall accuracy: **77.2%** (matches training baseline)

benchmark.py

@@ -0,0 +1,528 @@
+"""
+Benchmark evaluation for the HSClassify HS code classifier.
+
+Standalone script that runs hand-crafted test cases through the model and
+reports accuracy metrics. Requires a trained HSClassify_micro model directory.
+
+Usage:
+    python benchmark.py --model-dir ../HSClassify_micro     # basic benchmark
+    python benchmark.py --output results.json               # custom output path
+    python benchmark.py --split-analysis                    # + per-class analysis
+"""
+
+import argparse
+import json
+import math
+import os
+import pickle
+import sys
+import time
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+
+
+def resolve_paths(model_dir):
+    """Resolve data and model paths from the HSClassify project directory."""
+    model_dir = Path(model_dir).resolve()
+    data_dir = model_dir / "data"
+    models_dir = model_dir / "models"
+
+    required = [
+        models_dir / "knn_classifier.pkl",
+        models_dir / "label_encoder.pkl",
+        data_dir / "hs_codes_reference.json",
+    ]
+    for p in required:
+        if not p.exists():
+            print(f"ERROR: Required file not found: {p}")
+            sys.exit(1)
+
+    return data_dir, models_dir
+
+
+# ---------------------------------------------------------------------------
+# Model loading (mirrors app.py:77-97)
+# ---------------------------------------------------------------------------
+
+def load_model(data_dir, models_dir):
+    """Load sentence transformer, classifier, label encoder, and HS reference."""
+    from sentence_transformers import SentenceTransformer
+
+    # Prefer local bundled model, fall back to Hub
+    local_model_dir = models_dir / "sentence_model"
+    has_local_weights = (
+        (local_model_dir / "model.safetensors").exists()
+        or (local_model_dir / "pytorch_model.bin").exists()
+    )
+    has_local_tokenizer = (local_model_dir / "tokenizer.json").exists()
+
+    if local_model_dir.exists() and has_local_weights and has_local_tokenizer:
+        model = SentenceTransformer(str(local_model_dir))
+        print("Loaded local sentence model from models/sentence_model")
+    else:
+        fallback_model = os.getenv(
+            "SENTENCE_MODEL_NAME",
+            "intfloat/multilingual-e5-small",
+        )
+        model = SentenceTransformer(fallback_model)
+        print(f"Loaded sentence model from Hugging Face Hub: {fallback_model}")
+
+    with open(models_dir / "knn_classifier.pkl", "rb") as f:
+        classifier = pickle.load(f)
+
+    with open(models_dir / "label_encoder.pkl", "rb") as f:
+        label_encoder = pickle.load(f)
+
+    with open(data_dir / "hs_codes_reference.json") as f:
+        hs_reference = json.load(f)
+
+    return model, classifier, label_encoder, hs_reference
+
+
+# ---------------------------------------------------------------------------
+# Prediction (mirrors app.py:346-365)
+# ---------------------------------------------------------------------------
+
+def predict_top_k(model, classifier, label_encoder, text, k=5):
+    """Return top-k (hs_code, confidence) pairs for a query string."""
+    query_emb = model.encode(
+        [f"query: {text}"],
+        normalize_embeddings=True,
+        convert_to_numpy=True,
+    )
+    probs = classifier.predict_proba(query_emb)[0]
+    top_indices = np.argsort(probs)[-k:][::-1]
+
+    results = []
+    for idx in top_indices:
+        hs_code = str(label_encoder.classes_[idx]).zfill(6)
+        results.append((hs_code, float(probs[idx])))
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Basic benchmark
+# ---------------------------------------------------------------------------
+
+def run_benchmark(model, classifier, label_encoder, hs_reference, bench_path):
+    """Run benchmark cases and return detailed results."""
+    if not bench_path.exists():
+        print(f"ERROR: {bench_path} not found")
+        sys.exit(1)
+
+    df = pd.read_csv(bench_path, dtype={"expected_hs_code": str})
+    df["expected_hs_code"] = df["expected_hs_code"].str.zfill(6)
+
+    curated_codes = set(hs_reference.keys())
+
+    results = []
+    for _, row in df.iterrows():
+        text = row["text"]
+        expected = row["expected_hs_code"]
+        category = row["category"]
+        language = row.get("language", "en")
+        notes = row.get("notes", "")
+
+        preds = predict_top_k(model, classifier, label_encoder, text, k=5)
+        pred_codes = [code for code, _ in preds]
+        top1_code = pred_codes[0]
+        top1_conf = preds[0][1]
+
+        hit_at_1 = top1_code == expected
+        hit_at_3 = expected in pred_codes[:3]
+        hit_at_5 = expected in pred_codes[:5]
+
+        # Chapter-level accuracy (first 2 digits)
+        chapter_hit = top1_code[:2] == expected[:2]
+
+        # Is the expected code in our label space?
+        in_label_space = expected in curated_codes
+
+        results.append({
+            "text": text,
+            "expected": expected,
+            "predicted": top1_code,
+            "confidence": top1_conf,
+            "hit_at_1": hit_at_1,
+            "hit_at_3": hit_at_3,
+            "hit_at_5": hit_at_5,
+            "chapter_hit": chapter_hit,
+            "in_label_space": in_label_space,
+            "category": category,
+            "language": language,
+            "notes": notes,
+            "top5": pred_codes,
+        })
+
+    return results
+
+
+def compute_metrics(results):
+    """Compute aggregate metrics from benchmark results."""
+    total = len(results)
+    in_space = [r for r in results if r["in_label_space"]]
+    n_in_space = len(in_space)
+
+    # Overall (all cases)
+    top1 = sum(r["hit_at_1"] for r in results) / total if total else 0
+    top3 = sum(r["hit_at_3"] for r in results) / total if total else 0
+    top5 = sum(r["hit_at_5"] for r in results) / total if total else 0
+    chapter = sum(r["chapter_hit"] for r in results) / total if total else 0
+
+    # In-label-space only (excludes known_failure with out-of-space codes)
+    top1_ls = sum(r["hit_at_1"] for r in in_space) / n_in_space if n_in_space else 0
+    top3_ls = sum(r["hit_at_3"] for r in in_space) / n_in_space if n_in_space else 0
+    top5_ls = sum(r["hit_at_5"] for r in in_space) / n_in_space if n_in_space else 0
+    chapter_ls = sum(r["chapter_hit"] for r in in_space) / n_in_space if n_in_space else 0
+
+    # Per-category breakdown
+    categories = {}
+    for r in results:
+        cat = r["category"]
+        if cat not in categories:
+            categories[cat] = {"total": 0, "top1": 0, "top3": 0, "top5": 0, "chapter": 0}
+        categories[cat]["total"] += 1
+        categories[cat]["top1"] += r["hit_at_1"]
+        categories[cat]["top3"] += r["hit_at_3"]
+        categories[cat]["top5"] += r["hit_at_5"]
+        categories[cat]["chapter"] += r["chapter_hit"]
+
+    for cat in categories:
+        n = categories[cat]["total"]
+        categories[cat]["top1_acc"] = categories[cat]["top1"] / n
+        categories[cat]["top3_acc"] = categories[cat]["top3"] / n
+        categories[cat]["top5_acc"] = categories[cat]["top5"] / n
+        categories[cat]["chapter_acc"] = categories[cat]["chapter"] / n
+
+    # Per-language breakdown
+    languages = {}
+    for r in results:
+        lang = r["language"]
+        if lang not in languages:
+            languages[lang] = {"total": 0, "top1": 0, "top3": 0, "top5": 0}
+        languages[lang]["total"] += 1
+        languages[lang]["top1"] += r["hit_at_1"]
+        languages[lang]["top3"] += r["hit_at_3"]
+        languages[lang]["top5"] += r["hit_at_5"]
+
+    for lang in languages:
+        n = languages[lang]["total"]
+        languages[lang]["top1_acc"] = languages[lang]["top1"] / n
+        languages[lang]["top3_acc"] = languages[lang]["top3"] / n
+        languages[lang]["top5_acc"] = languages[lang]["top5"] / n
+
+    # Failures list
+    failures = [
+        {
+            "text": r["text"],
+            "expected": r["expected"],
+            "predicted": r["predicted"],
+            "confidence": round(r["confidence"], 4),
+            "category": r["category"],
+            "language": r["language"],
+            "top5": r["top5"],
+            "notes": r["notes"],
+        }
+        for r in results
+        if not r["hit_at_1"]
+    ]
+
+    return {
+        "total_cases": total,
+        "in_label_space_cases": n_in_space,
+        "overall": {
+            "top1_accuracy": round(top1, 4),
+            "top3_accuracy": round(top3, 4),
+            "top5_accuracy": round(top5, 4),
+            "chapter_accuracy": round(chapter, 4),
+        },
+        "in_label_space": {
+            "top1_accuracy": round(top1_ls, 4),
+            "top3_accuracy": round(top3_ls, 4),
+            "top5_accuracy": round(top5_ls, 4),
+            "chapter_accuracy": round(chapter_ls, 4),
+        },
+        "by_category": categories,
+        "by_language": languages,
+        "failures": failures,
+        "n_failures": len(failures),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Split analysis (mirrors train_model.py:98-136)
+# ---------------------------------------------------------------------------
+
+def run_split_analysis(model, hs_reference, data_dir, models_dir):
+    """Replicate 80/20 stratified split and report per-class metrics."""
+    from sklearn.model_selection import train_test_split
+    from sklearn.preprocessing import LabelEncoder
+    from sklearn.neighbors import KNeighborsClassifier
+    from sklearn.metrics import classification_report, confusion_matrix
+
+    print("\n" + "=" * 60)
+    print("Split Analysis (replicating training 80/20 split)")
+    print("=" * 60)
+
+    # Load training data
+    training_csv = data_dir / "training_data.csv"
+    if not training_csv.exists():
+        print(f"ERROR: {training_csv} not found")
+        return None
+
+    df = pd.read_csv(training_csv, dtype={"hs_code": str})
+    df["hs_code"] = df["hs_code"].astype(str).str.zfill(6)
+
+    # Filter to curated codes
+    curated_codes = {str(c).zfill(6) for c in hs_reference.keys()}
+    df = df[df["hs_code"].isin(curated_codes)].copy()
+    print(f"Training data: {len(df)} rows, {df['hs_code'].nunique()} codes")
+
+    # Load pre-computed embeddings
+    embeddings_path = models_dir / "embeddings.npy"
+    if not embeddings_path.exists():
+        print(f"ERROR: {embeddings_path} not found. Run train_model.py first.")
+        return None
+
+    embeddings_full = np.load(embeddings_path)
+    embeddings = embeddings_full[df.index.to_numpy()]
+    labels = df["hs_code"].values
+
+    # Encode labels
+    le = LabelEncoder()
+    y = le.fit_transform(labels)
+    n_samples = len(y)
+    n_classes = len(le.classes_)
+    class_counts = np.bincount(y)
+    min_class_count = int(class_counts.min()) if len(class_counts) else 0
+
+    # Replicate exact split from train_model.py:98-109
+    test_size = 0.2
+    n_test = math.ceil(n_samples * test_size)
+    n_train = n_samples - n_test
+    can_stratify = (
+        min_class_count >= 2
+        and n_test >= n_classes
+        and n_train >= n_classes
+    )
+    if can_stratify:
+        X_train, X_test, y_train, y_test = train_test_split(
+            embeddings, y, test_size=test_size, random_state=42, stratify=y
+        )
+    else:
+        X_train, X_test, y_train, y_test = train_test_split(
+            embeddings, y, test_size=test_size, random_state=42, stratify=None
+        )
+
+    print(f"Train: {len(X_train)}, Test: {len(X_test)}")
+
+    # Train fresh KNN (same params as train_model.py:114)
+    clf = KNeighborsClassifier(n_neighbors=5, metric="cosine", weights="distance")
+    clf.fit(X_train, y_train)
+    y_pred = clf.predict(X_test)
+
+    # Classification report
+    report = classification_report(
+        y_test,
+        y_pred,
+        labels=np.arange(n_classes),
+        target_names=le.classes_,
+        output_dict=True,
+        zero_division=0,
+    )
+
+    overall_acc = float(np.mean(y_test == y_pred))
+    print(f"\nTest accuracy: {overall_acc:.4f} ({overall_acc * 100:.1f}%)")
+    print(f"Weighted F1: {report['weighted avg']['f1-score']:.4f}")
+    print(f"Macro F1: {report['macro avg']['f1-score']:.4f}")
+
+    # Worst 15 codes by F1
+    code_metrics = []
+    for code in le.classes_:
+        if code in report and isinstance(report[code], dict):
+            m = report[code]
+            code_metrics.append({
+                "hs_code": code,
+                "desc": hs_reference.get(code, {}).get("desc", ""),
+                "precision": round(m["precision"], 4),
+                "recall": round(m["recall"], 4),
+                "f1": round(m["f1-score"], 4),
+                "support": int(m["support"]),
+            })
+
+    code_metrics.sort(key=lambda x: x["f1"])
+    worst_15 = code_metrics[:15]
+
+    print("\nWorst 15 codes by F1:")
+    print(f"{'HS Code':<10} {'F1':>6} {'Prec':>6} {'Rec':>6} {'Sup':>5}  Description")
+    print("-" * 75)
+    for m in worst_15:
+        print(f"{m['hs_code']:<10} {m['f1']:>6.3f} {m['precision']:>6.3f} {m['recall']:>6.3f} {m['support']:>5}  {m['desc'][:40]}")
+
+    # Top 20 cross-chapter confusions
+    cm = confusion_matrix(y_test, y_pred, labels=np.arange(n_classes))
+    confusions = []
+    for true_idx in range(n_classes):
+        for pred_idx in range(n_classes):
+            if true_idx == pred_idx:
+                continue
+            count = int(cm[true_idx, pred_idx])
+            if count == 0:
+                continue
+            true_code = le.classes_[true_idx]
+            pred_code = le.classes_[pred_idx]
+            true_chapter = true_code[:2]
+            pred_chapter = pred_code[:2]
+            if true_chapter == pred_chapter:
+                continue
+            confusions.append({
+                "true_code": true_code,
+                "pred_code": pred_code,
+                "true_chapter": hs_reference.get(true_code, {}).get("chapter", true_chapter),
+                "pred_chapter": hs_reference.get(pred_code, {}).get("chapter", pred_chapter),
+                "count": count,
+            })
+
+    confusions.sort(key=lambda x: x["count"], reverse=True)
+    top_20_confusions = confusions[:20]
+
+    print(f"\nTop 20 cross-chapter confusions:")
+    print(f"{'True Code':<10} {'Pred Code':<10} {'Count':>5}  True Chapter -> Pred Chapter")
+    print("-" * 70)
+    for c in top_20_confusions:
+        print(f"{c['true_code']:<10} {c['pred_code']:<10} {c['count']:>5}  {c['true_chapter']} -> {c['pred_chapter']}")
+
+    return {
+        "test_accuracy": round(overall_acc, 4),
+        "weighted_f1": round(report["weighted avg"]["f1-score"], 4),
+        "macro_f1": round(report["macro avg"]["f1-score"], 4),
+        "n_train": len(X_train),
+        "n_test": len(X_test),
+        "worst_15_by_f1": worst_15,
+        "top_20_cross_chapter_confusions": top_20_confusions,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Reporting
+# ---------------------------------------------------------------------------
+
+def print_report(metrics):
+    """Print a human-readable benchmark report."""
+    print("\n" + "=" * 60)
+    print("BENCHMARK REPORT")
+    print("=" * 60)
+
+    o = metrics["overall"]
+    print(f"\nTotal cases: {metrics['total_cases']}  (in label space: {metrics['in_label_space_cases']})")
+    print(f"\n{'Metric':<25} {'All Cases':>10} {'In-Space':>10}")
+    print("-" * 47)
+    ls = metrics["in_label_space"]
+    print(f"{'Top-1 Accuracy':<25} {o['top1_accuracy']:>10.1%} {ls['top1_accuracy']:>10.1%}")
+    print(f"{'Top-3 Accuracy':<25} {o['top3_accuracy']:>10.1%} {ls['top3_accuracy']:>10.1%}")
+    print(f"{'Top-5 Accuracy':<25} {o['top5_accuracy']:>10.1%} {ls['top5_accuracy']:>10.1%}")
+    print(f"{'Chapter Accuracy':<25} {o['chapter_accuracy']:>10.1%} {ls['chapter_accuracy']:>10.1%}")
+
+    print(f"\nPer-Category Breakdown:")
+    print(f"{'Category':<15} {'N':>4} {'Top-1':>7} {'Top-3':>7} {'Top-5':>7} {'Chapter':>8}")
+    print("-" * 52)
+    for cat, m in sorted(metrics["by_category"].items()):
+        print(f"{cat:<15} {m['total']:>4} {m['top1_acc']:>7.1%} {m['top3_acc']:>7.1%} {m['top5_acc']:>7.1%} {m['chapter_acc']:>8.1%}")
+
+    print(f"\nPer-Language Breakdown:")
+    print(f"{'Language':<10} {'N':>4} {'Top-1':>7} {'Top-3':>7} {'Top-5':>7}")
+    print("-" * 40)
+    for lang, m in sorted(metrics["by_language"].items()):
+        print(f"{lang:<10} {m['total']:>4} {m['top1_acc']:>7.1%} {m['top3_acc']:>7.1%} {m['top5_acc']:>7.1%}")
+
+    n_fail = metrics["n_failures"]
+    print(f"\nFailures ({n_fail}):")
+    print("-" * 90)
+    for f in metrics["failures"]:
+        print(f"  {f['text'][:45]:<45} expected={f['expected']}  got={f['predicted']}  conf={f['confidence']:.2f}  [{f['category']}]")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="Benchmark HSClassify HS code classifier")
+    parser.add_argument("--model-dir", default=None,
+                        help="Path to HSClassify_micro project root (default: auto-detect sibling dir)")
+    parser.add_argument("--output", "-o", default="benchmark_results.json",
+                        help="Path for JSON results (default: benchmark_results.json)")
+    parser.add_argument("--split-analysis", action="store_true",
+                        help="Run per-class analysis on 80/20 training split")
+    args = parser.parse_args()
+
+    # Auto-detect model dir: look for sibling HSClassify_micro
+    model_dir = args.model_dir
+    if model_dir is None:
+        sibling = SCRIPT_DIR.parent / "HSClassify_micro"
+        if sibling.exists():
+            model_dir = str(sibling)
+        else:
+            # Also check same-level with different casing
+            for candidate in SCRIPT_DIR.parent.iterdir():
+                if candidate.is_dir() and "hsclassify" in candidate.name.lower() and "benchmark" not in candidate.name.lower():
+                    model_dir = str(candidate)
+                    break
+        if model_dir is None:
+            print("ERROR: Could not auto-detect HSClassify_micro directory.")
+            print("       Use --model-dir /path/to/HSClassify_micro")
+            sys.exit(1)
+
+    print(f"Using model dir: {model_dir}")
+    data_dir, models_dir = resolve_paths(model_dir)
+
+    start = time.time()
+
+    print("Loading models...")
+    model, classifier, label_encoder, hs_reference = load_model(data_dir, models_dir)
+    load_time = time.time() - start
+    print(f"Models loaded in {load_time:.1f}s")
+
+    # Basic benchmark — use local CSV from this repo
+    bench_path = SCRIPT_DIR / "benchmark_cases.csv"
+    print(f"\nRunning benchmark cases from {bench_path}...")
+    bench_start = time.time()
+    results = run_benchmark(model, classifier, label_encoder, hs_reference, bench_path)
+    metrics = compute_metrics(results)
+    bench_time = time.time() - bench_start
+    print(f"Benchmark completed in {bench_time:.1f}s")
+
+    print_report(metrics)
+
+    # Optional split analysis
+    split_metrics = None
+    if args.split_analysis:
+        split_metrics = run_split_analysis(model, hs_reference, data_dir, models_dir)
+
+    # Save JSON report
+    report = {
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "model_dir": str(model_dir),
+        "benchmark": metrics,
+        "timing": {
+            "model_load_s": round(load_time, 2),
+            "benchmark_s": round(bench_time, 2),
+            "total_s": round(time.time() - start, 2),
+        },
+    }
+    if split_metrics:
+        report["split_analysis"] = split_metrics
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "w") as f:
+        json.dump(report, f, indent=2)
+    print(f"\nResults saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()

benchmark_cases.csv

@@ -0,0 +1,79 @@
+text,expected_hs_code,category,language,notes
+fresh boneless beef,020130,easy,en,common meat product
+frozen boneless bovine meat for export,020230,easy,en,frozen meat variant
+frozen shrimp 500g bag,030617,easy,en,common seafood
+whole milk 3.5% fat,040120,easy,en,standard dairy
+cheddar cheese block,040690,easy,en,common cheese
+fresh tomatoes,070200,easy,en,basic vegetable
+fresh red apples,080810,easy,en,common fruit
+bananas fresh,080300,easy,en,top traded fruit
+raw coffee beans unroasted,090111,easy,en,major commodity
+white rice 25kg bag,100630,easy,en,staple grain
+palm oil refined,151190,easy,en,major edible oil
+cane sugar raw,170199,easy,en,basic commodity
+sweet biscuits assorted,190531,easy,en,packaged food
+bottled sparkling water flavored,220210,easy,en,common beverage
+beer lager 330ml bottles,220300,easy,en,common alcohol
+scotch whisky 700ml,220830,easy,en,spirits
+crude petroleum oil,270900,easy,en,major commodity
+polyethylene pellets LDPE,390110,easy,en,common plastic resin
+car tyre 205/55R16 new,401110,easy,en,auto consumable
+cotton t-shirts mens,610910,easy,en,basic garment
+hot rolled steel coil 600mm,720839,easy,en,industrial steel
+copper cathodes 99.99% purity,740311,easy,en,refined metal
+laptop computer 14 inch,847130,easy,en,common electronics
+smartphone Samsung Galaxy,851712,easy,en,ubiquitous device
+lithium ion battery pack 48V,850760,easy,en,EV battery
+sedan car 2000cc petrol engine,870323,easy,en,standard vehicle
+wooden bedroom wardrobe,940350,easy,en,common furniture
+tea,090210,edge_case,en,very short query - ambiguous
+car parts,870899,edge_case,en,vague automotive
+medicine,300490,edge_case,en,extremely generic
+chips,854231,edge_case,en,ambiguous - food or electronics
+oil,270900,edge_case,en,highly ambiguous
+shoes,640399,edge_case,en,generic footwear
+paper,480256,edge_case,en,very generic
+plastic bags for groceries,392321,edge_case,en,everyday item
+Galaxy S24 Ultra,851712,edge_case,en,brand name only
+Nespresso coffee capsules,210111,edge_case,en,branded coffee product
+Goodyear truck tyre 315/80R22.5,401120,edge_case,en,brand + specs
+Jack Daniels Tennessee whiskey 750ml,220830,edge_case,en,brand name spirits
+Nintendo Switch gaming console,950490,edge_case,en,brand - games vs electronics
+surgical masks disposable,901890,edge_case,en,medical supply
+USB-C charging cable,854239,edge_case,en,tech accessory
+frozen cod fish fillet,030389,edge_case,en,specific fish species
+stainless steel bolts M10,730890,edge_case,en,metal hardware
+yoga pants women polyester,620462,edge_case,en,modern clothing description
+aspirin tablets 500mg retail,300490,edge_case,en,OTC pharma
+insecticide spray for mosquitoes,380891,edge_case,en,household chemical
+PET bottles preform,390760,edge_case,en,industrial plastic
+ข้าวหอมมะลิ,100630,multilingual,th,jasmine rice
+กุ้งแช่แข็ง,030617,multilingual,th,frozen shrimp
+รถยนต์ไฟฟ้า,870380,multilingual,th,electric car
+โทรศัพท์มือถือ,851712,multilingual,th,mobile phone
+ยางรถยนต์,401110,multilingual,th,car tyre
+น้ำตาลทราย,170199,multilingual,th,granulated sugar
+เสื้อยืดผ้าฝ้าย,610910,multilingual,th,cotton t-shirt
+gạo trắng,100630,multilingual,vi,white rice
+tôm đông lạnh,030617,multilingual,vi,frozen shrimp
+cà phê nhân,090111,multilingual,vi,raw coffee beans
+thép cuộn cán nóng,720839,multilingual,vi,hot rolled steel coil
+điện thoại thông minh,851712,multilingual,vi,smartphone
+xe ô tô điện,870380,multilingual,vi,electric car
+dầu thô,270900,multilingual,vi,crude oil
+笔记本电脑,847130,multilingual,zh,laptop computer
+冷冻虾,030617,multilingual,zh,frozen shrimp
+大米,100630,multilingual,zh,rice
+锂电池,850760,multilingual,zh,lithium battery
+棉质T恤,610910,multilingual,zh,cotton t-shirt
+原油,270900,multilingual,zh,crude oil
+English breakfast tea,090240,known_failure,en,black tea - code 090240 not in label space
+matcha green tea powder,090210,known_failure,en,tea variant - model often confuses with other categories
+oolong tea leaves 100g,090230,known_failure,en,semi-fermented tea - code 090230 not in label space
+chamomile herbal tea bags,121190,known_failure,en,herbal infusion - not tea chapter - not in label space
+fresh avocado,080440,known_failure,en,avocado code 080440 not in label space
+quinoa grain organic,100850,known_failure,en,quinoa code 100850 not in label space
+soy sauce 500ml bottle,210390,known_failure,en,soy sauce code 210390 not in label space
+hand sanitizer gel 70% alcohol,380894,known_failure,en,sanitizer code 380894 not in label space
+drone with 4K camera,880211,known_failure,en,UAV code not in label space
+solar panel 400W monocrystalline,854140,known_failure,en,maps to photosensitive devices - often misclassified

benchmark_results.json

@@ -0,0 +1,638 @@
+{
+  "timestamp": "2026-02-24T20:46:17",
+  "benchmark": {
+    "total_cases": 78,
+    "in_label_space_cases": 70,
+    "overall": {
+      "top1_accuracy": 0.7949,
+      "top3_accuracy": 0.8205,
+      "top5_accuracy": 0.8333,
+      "chapter_accuracy": 0.8974
+    },
+    "in_label_space": {
+      "top1_accuracy": 0.8857,
+      "top3_accuracy": 0.9143,
+      "top5_accuracy": 0.9286,
+      "chapter_accuracy": 0.9571
+    },
+    "by_category": {
+      "easy": {
+        "total": 27,
+        "top1": 26,
+        "top3": 27,
+        "top5": 27,
+        "chapter": 27,
+        "top1_acc": 0.9629629629629629,
+        "top3_acc": 1.0,
+        "top5_acc": 1.0,
+        "chapter_acc": 1.0
+      },
+      "edge_case": {
+        "total": 21,
+        "top1": 15,
+        "top3": 16,
+        "top5": 17,
+        "chapter": 18,
+        "top1_acc": 0.7142857142857143,
+        "top3_acc": 0.7619047619047619,
+        "top5_acc": 0.8095238095238095,
+        "chapter_acc": 0.8571428571428571
+      },
+      "multilingual": {
+        "total": 20,
+        "top1": 20,
+        "top3": 20,
+        "top5": 20,
+        "chapter": 20,
+        "top1_acc": 1.0,
+        "top3_acc": 1.0,
+        "top5_acc": 1.0,
+        "chapter_acc": 1.0
+      },
+      "known_failure": {
+        "total": 10,
+        "top1": 1,
+        "top3": 1,
+        "top5": 1,
+        "chapter": 5,
+        "top1_acc": 0.1,
+        "top3_acc": 0.1,
+        "top5_acc": 0.1,
+        "chapter_acc": 0.5
+      }
+    },
+    "by_language": {
+      "en": {
+        "total": 58,
+        "top1": 42,
+        "top3": 44,
+        "top5": 45,
+        "top1_acc": 0.7241379310344828,
+        "top3_acc": 0.7586206896551724,
+        "top5_acc": 0.7758620689655172
+      },
+      "th": {
+        "total": 7,
+        "top1": 7,
+        "top3": 7,
+        "top5": 7,
+        "top1_acc": 1.0,
+        "top3_acc": 1.0,
+        "top5_acc": 1.0
+      },
+      "vi": {
+        "total": 7,
+        "top1": 7,
+        "top3": 7,
+        "top5": 7,
+        "top1_acc": 1.0,
+        "top3_acc": 1.0,
+        "top5_acc": 1.0
+      },
+      "zh": {
+        "total": 6,
+        "top1": 6,
+        "top3": 6,
+        "top5": 6,
+        "top1_acc": 1.0,
+        "top3_acc": 1.0,
+        "top5_acc": 1.0
+      }
+    },
+    "failures": [
+      {
+        "text": "polyethylene pellets LDPE",
+        "expected": "390110",
+        "predicted": "392321",
+        "confidence": 0.8091,
+        "category": "easy",
+        "language": "en",
+        "top5": [
+          "392321",
+          "390110",
+          "950490",
+          "300490",
+          "220830"
+        ],
+        "notes": "common plastic resin"
+      },
+      {
+        "text": "medicine",
+        "expected": "300490",
+        "predicted": "300220",
+        "confidence": 1.0,
+        "category": "edge_case",
+        "language": "en",
+        "top5": [
+          "300220",
+          "950490",
+          "310520",
+          "220830",
+          "240120"
+        ],
+        "notes": "extremely generic"
+      },
+      {
+        "text": "paper",
+        "expected": "480256",
+        "predicted": "481910",
+        "confidence": 1.0,
+        "category": "edge_case",
+        "language": "en",
+        "top5": [
+          "481910",
+          "310520",
+          "220830",
+          "240120",
+          "252329"
+        ],
+        "notes": "very generic"
+      },
+      {
+        "text": "Nespresso coffee capsules",
+        "expected": "210111",
+        "predicted": "090111",
+        "confidence": 0.4046,
+        "category": "edge_case",
+        "language": "en",
+        "top5": [
+          "090111",
+          "300220",
+          "740311",
+          "210111",
+          "310520"
+        ],
+        "notes": "branded coffee product"
+      },
+      {
+        "text": "USB-C charging cable",
+        "expected": "854239",
+        "predicted": "850760",
+        "confidence": 0.2069,
+        "category": "edge_case",
+        "language": "en",
+        "top5": [
+          "850760",
+          "847170",
+          "850440",
+          "870899",
+          "870332"
+        ],
+        "notes": "tech accessory"
+      },
+      {
+        "text": "stainless steel bolts M10",
+        "expected": "730890",
+        "predicted": "760120",
+        "confidence": 0.2081,
+        "category": "edge_case",
+        "language": "en",
+        "top5": [
+          "760120",
+          "901890",
+          "730890",
+          "220830",
+          "720917"
+        ],
+        "notes": "metal hardware"
+      },
+      {
+        "text": "yoga pants women polyester",
+        "expected": "620462",
+        "predicted": "611030",
+        "confidence": 1.0,
+        "category": "edge_case",
+        "language": "en",
+        "top5": [
+          "611030",
+          "950490",
+          "310520",
+          "220830",
+          "240120"
+        ],
+        "notes": "modern clothing description"
+      },
+      {
+        "text": "English breakfast tea",
+        "expected": "090240",
+        "predicted": "090210",
+        "confidence": 0.8007,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "090210",
+          "392321",
+          "950490",
+          "220830",
+          "240120"
+        ],
+        "notes": "black tea - code 090240 not in label space"
+      },
+      {
+        "text": "oolong tea leaves 100g",
+        "expected": "090230",
+        "predicted": "090210",
+        "confidence": 0.6064,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "090210",
+          "220300",
+          "392321",
+          "950490",
+          "220830"
+        ],
+        "notes": "semi-fermented tea - code 090230 not in label space"
+      },
+      {
+        "text": "chamomile herbal tea bags",
+        "expected": "121190",
+        "predicted": "392321",
+        "confidence": 0.6013,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "392321",
+          "090210",
+          "950490",
+          "220830",
+          "240120"
+        ],
+        "notes": "herbal infusion - not tea chapter - not in label space"
+      },
+      {
+        "text": "fresh avocado",
+        "expected": "080440",
+        "predicted": "080810",
+        "confidence": 1.0,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "080810",
+          "950490",
+          "310520",
+          "220830",
+          "240120"
+        ],
+        "notes": "avocado code 080440 not in label space"
+      },
+      {
+        "text": "quinoa grain organic",
+        "expected": "100850",
+        "predicted": "080810",
+        "confidence": 0.3905,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "080810",
+          "100630",
+          "080510",
+          "070200",
+          "950490"
+        ],
+        "notes": "quinoa code 100850 not in label space"
+      },
+      {
+        "text": "soy sauce 500ml bottle",
+        "expected": "210390",
+        "predicted": "220300",
+        "confidence": 0.4237,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "220300",
+          "300490",
+          "150710",
+          "950490",
+          "220830"
+        ],
+        "notes": "soy sauce code 210390 not in label space"
+      },
+      {
+        "text": "hand sanitizer gel 70% alcohol",
+        "expected": "380894",
+        "predicted": "290531",
+        "confidence": 1.0,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "290531",
+          "950490",
+          "310520",
+          "220830",
+          "240120"
+        ],
+        "notes": "sanitizer code 380894 not in label space"
+      },
+      {
+        "text": "drone with 4K camera",
+        "expected": "880211",
+        "predicted": "852580",
+        "confidence": 0.6108,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "852580",
+          "852872",
+          "870323",
+          "950490",
+          "290531"
+        ],
+        "notes": "UAV code not in label space"
+      },
+      {
+        "text": "solar panel 400W monocrystalline",
+        "expected": "854140",
+        "predicted": "850440",
+        "confidence": 0.4031,
+        "category": "known_failure",
+        "language": "en",
+        "top5": [
+          "850440",
+          "850760",
+          "870380",
+          "853400",
+          "290531"
+        ],
+        "notes": "maps to photosensitive devices - often misclassified"
+      }
+    ],
+    "n_failures": 16
+  },
+  "timing": {
+    "model_load_s": 3.93,
+    "benchmark_s": 1.24,
+    "total_s": 6.59
+  },
+  "split_analysis": {
+    "test_accuracy": 0.7721,
+    "weighted_f1": 0.7703,
+    "macro_f1": 0.8107,
+    "n_train": 7863,
+    "n_test": 1966,
+    "worst_15_by_f1": [
+      {
+        "hs_code": "870332",
+        "desc": "Diesel motor cars, 1500-2500cc",
+        "precision": 0.2958,
+        "recall": 0.2471,
+        "f1": 0.2692,
+        "support": 85
+      },
+      {
+        "hs_code": "271019",
+        "desc": "Other medium petroleum oils",
+        "precision": 0.5,
+        "recall": 0.2222,
+        "f1": 0.3077,
+        "support": 9
+      },
+      {
+        "hs_code": "870323",
+        "desc": "Motor cars, 1500-3000cc",
+        "precision": 0.2991,
+        "recall": 0.3465,
+        "f1": 0.3211,
+        "support": 101
+      },
+      {
+        "hs_code": "854239",
+        "desc": "Other electronic integrated circuits",
+        "precision": 0.5,
+        "recall": 0.25,
+        "f1": 0.3333,
+        "support": 12
+      },
+      {
+        "hs_code": "870324",
+        "desc": "Motor cars, >3000cc",
+        "precision": 0.4839,
+        "recall": 0.5263,
+        "f1": 0.5042,
+        "support": 57
+      },
+      {
+        "hs_code": "890190",
+        "desc": "Other cargo vessels",
+        "precision": 0.4211,
+        "recall": 0.6667,
+        "f1": 0.5161,
+        "support": 12
+      },
+      {
+        "hs_code": "843149",
+        "desc": "Other parts of cranes",
+        "precision": 0.6667,
+        "recall": 0.4444,
+        "f1": 0.5333,
+        "support": 18
+      },
+      {
+        "hs_code": "870899",
+        "desc": "Other parts for motor vehicles",
+        "precision": 0.5333,
+        "recall": 0.5333,
+        "f1": 0.5333,
+        "support": 15
+      },
+      {
+        "hs_code": "271600",
+        "desc": "Electrical energy",
+        "precision": 0.6,
+        "recall": 0.6,
+        "f1": 0.6,
+        "support": 10
+      },
+      {
+        "hs_code": "271012",
+        "desc": "Light petroleum oils",
+        "precision": 0.5833,
+        "recall": 0.6364,
+        "f1": 0.6087,
+        "support": 11
+      },
+      {
+        "hs_code": "120190",
+        "desc": "Soya beans, other",
+        "precision": 0.8571,
+        "recall": 0.5,
+        "f1": 0.6316,
+        "support": 12
+      },
+      {
+        "hs_code": "380891",
+        "desc": "Insecticides",
+        "precision": 1.0,
+        "recall": 0.4615,
+        "f1": 0.6316,
+        "support": 13
+      },
+      {
+        "hs_code": "901890",
+        "desc": "Other medical instruments",
+        "precision": 0.7143,
+        "recall": 0.5769,
+        "f1": 0.6383,
+        "support": 26
+      },
+      {
+        "hs_code": "847330",
+        "desc": "Parts and accessories for computers",
+        "precision": 0.8889,
+        "recall": 0.5,
+        "f1": 0.64,
+        "support": 16
+      },
+      {
+        "hs_code": "940180",
+        "desc": "Other seats",
+        "precision": 0.6667,
+        "recall": 0.6154,
+        "f1": 0.64,
+        "support": 13
+      }
+    ],
+    "top_20_cross_chapter_confusions": [
+      {
+        "true_code": "040120",
+        "pred_code": "020130",
+        "true_chapter": "Dairy",
+        "pred_chapter": "Meat",
+        "count": 3
+      },
+      {
+        "true_code": "840734",
+        "pred_code": "870323",
+        "true_chapter": "Machinery",
+        "pred_chapter": "Vehicles",
+        "count": 3
+      },
+      {
+        "true_code": "901890",
+        "pred_code": "843149",
+        "true_chapter": "Medical",
+        "pred_chapter": "Machinery",
+        "count": 3
+      },
+      {
+        "true_code": "120190",
+        "pred_code": "100199",
+        "true_chapter": "Oil Seeds",
+        "pred_chapter": "Cereals",
+        "count": 2
+      },
+      {
+        "true_code": "200990",
+        "pred_code": "190531",
+        "true_chapter": "Food Preparations",
+        "pred_chapter": "Food Preparations",
+        "count": 2
+      },
+      {
+        "true_code": "270900",
+        "pred_code": "070200",
+        "true_chapter": "Mineral Fuels",
+        "pred_chapter": "Vegetables",
+        "count": 2
+      },
+      {
+        "true_code": "271012",
+        "pred_code": "870323",
+        "true_chapter": "Mineral Fuels",
+        "pred_chapter": "Vehicles",
+        "count": 2
+      },
+      {
+        "true_code": "271019",
+        "pred_code": "151190",
+        "true_chapter": "Mineral Fuels",
+        "pred_chapter": "Oils",
+        "count": 2
+      },
+      {
+        "true_code": "730890",
+        "pred_code": "392321",
+        "true_chapter": "Steel",
+        "pred_chapter": "Plastics",
+        "count": 2
+      },
+      {
+        "true_code": "730890",
+        "pred_code": "890190",
+        "true_chapter": "Steel",
+        "pred_chapter": "Ships",
+        "count": 2
+      },
+      {
+        "true_code": "840734",
+        "pred_code": "870324",
+        "true_chapter": "Machinery",
+        "pred_chapter": "Vehicles",
+        "count": 2
+      },
+      {
+        "true_code": "843149",
+        "pred_code": "392321",
+        "true_chapter": "Machinery",
+        "pred_chapter": "Plastics",
+        "count": 2
+      },
+      {
+        "true_code": "843149",
+        "pred_code": "730890",
+        "true_chapter": "Machinery",
+        "pred_chapter": "Steel",
+        "count": 2
+      },
+      {
+        "true_code": "850760",
+        "pred_code": "870380",
+        "true_chapter": "Electronics",
+        "pred_chapter": "Vehicles",
+        "count": 2
+      },
+      {
+        "true_code": "853400",
+        "pred_code": "392010",
+        "true_chapter": "Electronics",
+        "pred_chapter": "Plastics",
+        "count": 2
+      },
+      {
+        "true_code": "870899",
+        "pred_code": "842199",
+        "true_chapter": "Vehicles",
+        "pred_chapter": "Machinery",
+        "count": 2
+      },
+      {
+        "true_code": "901890",
+        "pred_code": "870899",
+        "true_chapter": "Medical",
+        "pred_chapter": "Vehicles",
+        "count": 2
+      },
+      {
+        "true_code": "030617",
+        "pred_code": "847170",
+        "true_chapter": "Fish",
+        "pred_chapter": "Electronics",
+        "count": 1
+      },
+      {
+        "true_code": "040120",
+        "pred_code": "340111",
+        "true_chapter": "Dairy",
+        "pred_chapter": "Cosmetics",
+        "count": 1
+      },
+      {
+        "true_code": "040690",
+        "pred_code": "220300",
+        "true_chapter": "Dairy",
+        "pred_chapter": "Beverages",
+        "count": 1
+      }
+    ]
+  }
+}

requirements.txt

@@ -0,0 +1,4 @@
+sentence-transformers>=2.2.0
+scikit-learn>=1.2.0
+numpy>=1.24.0
+pandas>=2.0.0