Upload folder using huggingface_hub

README.md

@@ -0,0 +1,94 @@
+---
+license: apache-2.0
+base_model: google/bert_uncased_L-8_H-512_A-8
+library_name: transformers
+pipeline_tag: text-classification
+tags:
+- social-media
+- content-filtering
+- engagement-bait
+- distillation
+- onnx
+metrics:
+- f1
+- precision
+- recall
+---
+
+# engagement-farm-classifier
+
+A small classifier that flags engagement-farming posts on social platforms (built and evaluated on X/Twitter posts): explicit CTAs ("like if you agree", "tag someone who"), reply-bait questions, giveaways, chain posts, and low-substance filler whose main goal is farming replies and likes.
+
+- **Base:** google/bert_uncased_L-8_H-512_A-8 (32M parameters)
+- **Serving artifact:** int8 ONNX in `onnx-int8/` (42 MB)
+- **CPU latency:** 1.9 ms mean, 2.7 ms p95 per post (Apple Silicon, single post)
+
+## Labels
+
+`0` = `genuine`, `1` = `engagement_farming`. Serving rule: softmax probability of `engagement_farming` >= 0.5 flags the post; lower the threshold to flag more aggressively (see Metrics).
+
+## Metrics
+
+Validation (777 posts, 189 farming, held out from training):
+
+| threshold | precision | recall | f1 |
+|---|---|---|---|
+| 0.5 | 0.98 | 0.90 | 0.94 |
+| 0.3 | 0.97 | 0.90 | 0.94 |
+
+Held-out test set (273 posts collected after all training data, zero id/text overlap with training, 15 farming):
+
+| threshold | precision | recall | f1 |
+|---|---|---|---|
+| 0.5 | 1.00 | 0.47 | 0.64 |
+| 0.4 | 1.00 | 0.53 | 0.70 |
+| 0.3 | 1.00 | 0.67 | 0.80 |
+
+Zero false positives on the test set at every threshold. The test positives are subtle, timeline-native bait (rhetorical "how many of you" questions, greeting filler), so test recall is the realistic number for in-feed filtering. Test positives are few (15), so treat these as indicative.
+
+## Training data
+
+12,506 posts collected from public timelines and keyword searches. Labeled by a large LLM teacher (kimi-k3 via batched prompts), keeping only verdicts with teacher confidence >= 0.85: 7,766 posts (1,706 farming) after text dedupe. Positive class oversampled ~1:2 in the train split. Split and threshold details are in `train.py` and `eval.py`.
+
+**No raw post corpus is redistributed.** Only scripts and weights are published; the collection and labeling pipeline is included so anyone can rebuild the dataset.
+
+## Usage
+
+```python
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+
+name = "selftaughtdev/engagement-farm-classifier"
+tok = AutoTokenizer.from_pretrained(name)
+model = AutoModelForSequenceClassification.from_pretrained(name)
+
+text = "like if you agree"
+probs = model(**tok(text, return_tensors="pt", truncation=True, max_length=128)).logits.softmax(-1)[0]
+print(probs[1].item())  # probability of engagement_farming
+```
+
+For the int8 ONNX artifact:
+
+```python
+from optimum.onnxruntime import ORTModelForSequenceClassification
+from transformers import AutoTokenizer
+
+model = ORTModelForSequenceClassification.from_pretrained(name, subfolder="onnx-int8", file_name="model_quantized.onnx")
+```
+
+## Limitations
+
+- Trained on English-language posts; other languages are untested.
+- Boundary cases are genuine disagreement: a rhetorical question with substance versus the same question as pure bait. Confident-only teacher labels (>= 0.85) trim but do not remove this ambiguity.
+- Innocent-looking filler (plain "good morning" posts, rhetorical questions) is the main source of false negatives.
+
+## Regenerating the dataset and model
+
+1. `collect_tweets.js`: paste into a browser console on the target platform, it scrolls and dedupes posts into JSON.
+2. `label.py`: sends batches of 20 posts to any OpenAI-compatible teacher endpoint (`--base-url`) with parallel workers, resumable.
+3. `train.py`: fine-tunes the base model (`--base`), exports fp32 and int8 ONNX.
+4. `eval.py`: threshold sweeps on validation or a held-out file (`--labeled <file> --full`).
+
+## License
+
+Apache 2.0 (matches the base model).

collect_tweets.js

@@ -0,0 +1,77 @@
+// X (Twitter) timeline collector. Paste into the browser console on x.com.
+//   __farmCollector.start(2000)   // auto-scroll and collect up to 2000 tweets
+//   __farmCollector.stop()       // stop scrolling
+//   __farmCollector.data()       // array of {id, author, text}
+//   __farmCollector.download()   // saves tweets.json
+//   __farmCollector.clear()      // wipe collected data
+// Survives page refreshes (localStorage). Run start() again to continue where you left off.
+(() => {
+  const KEY = "farm_collector_tweets";
+
+  const load = () => {
+    try {
+      return new Map(JSON.parse(localStorage.getItem(KEY) || "[]").map((t) => [t.id, t]));
+    } catch {
+      return new Map();
+    }
+  };
+
+  const save = (tweets) => {
+    try {
+      localStorage.setItem(KEY, JSON.stringify(tweets));
+    } catch (e) {
+      console.warn("[farm-collector] storage full, run download() now", e);
+    }
+  };
+
+  function extract() {
+    const tweets = load();
+    for (const article of document.querySelectorAll('article[data-testid="tweet"]')) {
+      const link = article.querySelector('a[href*="/status/"]');
+      const text = article.querySelector('[data-testid="tweetText"]')?.innerText?.trim();
+      const match = link?.href.match(/([^/?#]+)\/status\/(\d+)/);
+      if (!match || !text) continue;
+      const [, author, id] = match;
+      if (!tweets.has(id)) tweets.set(id, { id, author, text });
+    }
+    save([...tweets.values()]);
+    return tweets.size;
+  }
+
+  let timer = null;
+
+  function start(max = 2000) {
+    stop();
+    let stall = 0;
+    let last = extract();
+    console.log(`[farm-collector] ${last} collected, scrolling...`);
+    timer = setInterval(() => {
+      window.scrollBy(0, window.innerHeight * (0.7 + Math.random() * 0.6));
+      const count = extract();
+      stall = count > last ? 0 : stall + 1;
+      last = count;
+      console.log(`[farm-collector] ${count}/${max}`);
+      if (count >= max || stall >= 12) stop(); // no new tweets for ~18s means timeline exhausted
+    }, 1500);
+  }
+
+  function stop() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  function download() {
+    const blob = new Blob([JSON.stringify(data(), null, 1)], { type: "application/json" });
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(blob);
+    a.download = "tweets.json";
+    a.click();
+    URL.revokeObjectURL(a.href);
+  }
+
+  function data() {
+    return [...load().values()];
+  }
+
+  window.__farmCollector = { start, stop, data, download, clear: () => localStorage.removeItem(KEY) };
+})();

eval.py

@@ -0,0 +1,90 @@
+"""Evaluate the trained ONNX model on the validation split with a threshold sweep.
+
+Usage: python eval.py [--thresholds 0.5,0.4,0.3,0.2] [--min-confidence 0.85]
+
+Mirrors train.py's split (same seed, filter, dedup) so the rows match training.
+The serving threshold is a deployment choice: lower it to hide more bait at the
+cost of hiding more genuine tweets.
+"""
+import argparse
+import glob
+import json
+import os
+import random
+
+import numpy as np
+from optimum.onnxruntime import ORTModelForSequenceClassification
+from transformers import AutoTokenizer
+
+SEED = 13
+
+
+def val_rows(rows, min_conf, full=False):
+    data = [
+        r
+        for r in rows
+        if r.get("label") is not None and r.get("text") and r.get("confidence", 1.0) >= min_conf
+    ]
+    seen, deduped = set(), []
+    for r in data:
+        if r["text"] not in seen:
+            seen.add(r["text"])
+            deduped.append(r)
+    random.Random(SEED).shuffle(deduped)
+    return deduped if full else deduped[int(len(deduped) * 0.9) :]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dir", default="model_out")
+    ap.add_argument("--labeled", default="labeled.json")
+    ap.add_argument("--thresholds", default="0.5,0.4,0.3,0.2")
+    ap.add_argument("--min-confidence", type=float, default=0.85)
+    ap.add_argument("--full", action="store_true", help="evaluate all rows, skip the 90/10 val split")
+    args = ap.parse_args()
+    thresholds = [float(t) for t in args.thresholds.split(",")]
+
+    d = args.dir
+    files = glob.glob(os.path.join(d, "onnx-int8", "*.onnx"))
+    if not files:
+        raise SystemExit(f"no artifacts in {d}/onnx-int8, run train.py first")
+
+    val = val_rows(json.load(open(args.labeled)), args.min_confidence, args.full)
+    onnx_file = max(files, key=os.path.getsize)
+    model = ORTModelForSequenceClassification.from_pretrained(
+        os.path.dirname(onnx_file), file_name=os.path.basename(onnx_file)
+    )
+    tok = AutoTokenizer.from_pretrained(d)
+    labels = np.array([int(bool(r["label"])) for r in val])
+    probs = np.array(
+        [
+            float(
+                model(**tok(r["text"], return_tensors="pt", truncation=True, max_length=128)).logits.softmax(-1)[0, 1]
+            )
+            for r in val
+        ]
+    )
+    print(f"{d} (min_conf {args.min_confidence}): val {len(val)} rows, {int(labels.sum())} farming")
+    sweep(labels, probs, thresholds)
+    clean = [(l, p) for r, l, p in zip(val, labels, probs) if r.get("src") == "timeline"]
+    if clean:
+        clabels = np.array([l for l, _ in clean])
+        cprobs = np.array([p for _, p in clean])
+        print(f"clean-timeline-only: {len(clean)} rows, {int(clabels.sum())} farming")
+        sweep(clabels, cprobs, thresholds)
+
+
+def sweep(labels, probs, thresholds):
+    for t in thresholds:
+        preds = (probs >= t).astype(int)
+        tp = int(((preds == 1) & (labels == 1)).sum())
+        fp = int(((preds == 1) & (labels == 0)).sum())
+        fn = int(((preds == 0) & (labels == 1)).sum())
+        prec = tp / (tp + fp) if tp + fp else 0.0
+        rec = tp / (tp + fn) if tp + fn else 0.0
+        f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0
+        print(f"  t={t}: TP={tp} FP={fp} FN={fn} precision={prec:.2f} recall={rec:.2f} f1={f1:.2f}")
+
+
+if __name__ == "__main__":
+    main()

label.py

@@ -0,0 +1,168 @@
+"""Batch-label tweets as engagement farming with a strong LLM teacher.
+
+Usage:
+    LABEL_API_KEY=... python label.py tweets.json --model kimi-k3
+
+Any OpenAI-compatible endpoint works; --base-url overrides it
+(default: OpenAI's API). Batches 20 tweets per request with
+--workers batches in parallel. Writes labeled.json after every batch
+(resumable: rerun skips labeled ids and retries null labels). Row shape:
+{id, author, text, label, confidence}. train.py applies the confidence
+cutoff (--min-confidence, default 0.85) at training time.
+"""
+import argparse
+import json
+import os
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from openai import OpenAI
+
+INSTRUCTIONS = """You label tweets for an anti-engagement-farming product.
+
+Engagement-farming tweets exist to drive likes, replies, retweets, shares, tags
+or clicks rather than to convey genuine information, storytelling, opinion or
+value. This includes:
+1. Explicit calls to action: "Like if you agree!", "Retweet to bless someone!"
+2. Implicit prompts with no substance: open-ended questions solely for replies
+3. Giveaways or incentives: "RT and I'll follow back!", "Reply to win a prize!"
+4. Emotional hooks with no new content: "This made me cry... thoughts?"
+5. Low-effort filler or greetings: "Good morning everyone!"
+6. Clickbait teasers: "You won't believe what happened next..."
+7. Tag-a-friend / chain posts / polls purely for engagement
+8. Any other tactic where the primary goal is metric boosting
+
+You receive a JSON array of {"i": index, "text": tweet}. For each element, judge
+whether the tweet's PRIMARY PURPOSE is engagement farming and how confident you
+are. Respond with ONLY a JSON object:
+{"results": [{"i": 0, "label": true, "confidence": 0.9}, ...]}
+label is true for engagement farming, false for genuine, confidence in [0, 1].
+Every input index must appear exactly once.
+
+Examples:
+"Like this if you love pizza" -> label true, confidence 0.99
+"Which do you prefer, summer or winter? Vote in the replies!" -> label true, confidence 0.9
+"I just rescued a kitten from the shelter and she's settling in." -> label false, confidence 0.95
+"Our Q2 earnings report is now available: link." -> label false, confidence 0.9"""
+
+
+def parse_json(text):
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        start, end = text.find("{"), text.rfind("}")
+        if start >= 0 and end > start:
+            return json.loads(text[start : end + 1])
+        raise
+
+
+def coerce_label(raw):
+    if isinstance(raw, bool):
+        return raw
+    if isinstance(raw, str):
+        return {"true": True, "false": False}.get(raw.strip().lower())
+    return None
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("tweets", nargs="?", default="tweets.json")
+    ap.add_argument("--out", default="labeled.json")
+    ap.add_argument("--base-url", default=os.environ.get("LABEL_BASE_URL", "https://api.openai.com/v1"))
+    ap.add_argument("--model", default=os.environ.get("LABEL_MODEL", "kimi-k3"))
+    ap.add_argument("--batch-size", type=int, default=20)
+    ap.add_argument("--workers", type=int, default=6)
+    args = ap.parse_args()
+
+    key = os.environ.get("LABEL_API_KEY") or os.environ.get("OPENAI_API_KEY")
+    if not key:
+        raise SystemExit("set LABEL_API_KEY (or OPENAI_API_KEY)")
+    client = OpenAI(base_url=args.base_url, api_key=key)
+    with open(args.tweets) as f:
+        tweets = json.load(f)
+    done = {}
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            done = {r["id"]: r for r in json.load(f)}
+    todo = [
+        t
+        for t in tweets
+        if t.get("id") and t.get("text") and (t["id"] not in done or done[t["id"]].get("label") is None)
+    ]
+    print(f"{len(done)} already labeled, {len(todo)} to go", file=sys.stderr)
+
+    batches = [todo[i : i + args.batch_size] for i in range(0, len(todo), args.batch_size)]
+    lock = threading.Lock()
+
+    def label_batch(batch):
+        for attempt in (1, 2):
+            try:
+                resp = client.chat.completions.create(
+                    model=args.model,
+                    messages=[
+                        {"role": "system", "content": INSTRUCTIONS},
+                        {
+                            "role": "user",
+                            "content": json.dumps(
+                                [{"i": i, "text": t["text"]} for i, t in enumerate(batch)]
+                            ),
+                        },
+                    ],
+                )
+                data = parse_json(resp.choices[0].message.content or "")
+                return (
+                    data.get("results", [])
+                    if isinstance(data, dict)
+                    else data
+                    if isinstance(data, list)
+                    else []
+                )
+            except Exception as e:
+                if attempt == 2:
+                    print(f"batch failed, skipping (rerun to retry): {e}", file=sys.stderr)
+                    return []
+                time.sleep(3)
+        return []
+
+    def handle(pair):
+        index, batch = pair
+        results = label_batch(batch)
+        with lock:
+            for r in results:
+                i = r.get("i")
+                if not isinstance(i, int) or not 0 <= i < len(batch):
+                    continue
+                t = batch[i]
+                conf = min(max(float(r.get("confidence", 0)), 0.0), 1.0)
+                done[t["id"]] = {
+                    "id": t["id"],
+                    "author": t["author"],
+                    "text": t["text"],
+                    "src": t.get("src"),
+                    "label": coerce_label(r.get("label")),
+                    "confidence": conf,
+                }
+            with open(args.out, "w") as f:
+                json.dump(list(done.values()), f, indent=1)
+            kept = sum(1 for r in done.values() if r["label"] is not None)
+            print(
+                f"[{min((index + 1) * args.batch_size, len(todo))}/{len(todo)}] {kept} usable",
+                file=sys.stderr,
+            )
+
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        list(pool.map(handle, enumerate(batches)))
+
+    farming = sum(1 for r in done.values() if r["label"] is True)
+    genuine = sum(1 for r in done.values() if r["label"] is False)
+    print(
+        f"done: {len(done)} labeled, {farming} farming, {genuine} genuine, "
+        f"{len(done) - farming - genuine} unlabeled",
+        file=sys.stderr,
+    )
+
+
+if __name__ == "__main__":
+    main()

model_out/config.json

@@ -0,0 +1,33 @@
+{
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 512,
+  "id2label": {
+    "0": "genuine",
+    "1": "engagement_farming"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 2048,
+  "label2id": {
+    "engagement_farming": 1,
+    "genuine": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 8,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "transformers_version": "4.57.6",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

model_out/metrics.json

@@ -0,0 +1,9 @@
+{
+ "eval_loss": 0.17980128526687622,
+ "eval_accuracy": 0.972972972972973,
+ "eval_f1": 0.9433962264150944,
+ "eval_runtime": 2.8042,
+ "eval_samples_per_second": 277.086,
+ "eval_steps_per_second": 4.636,
+ "epoch": 6.0
+}

model_out/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:426690dca42c7dea1ced3cc6c4055a811220bfcb516bbf002d68167ea58fa94c
+size 165512728

model_out/onnx-int8/config.json

@@ -0,0 +1,33 @@
+{
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 512,
+  "id2label": {
+    "0": "genuine",
+    "1": "engagement_farming"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 2048,
+  "label2id": {
+    "engagement_farming": 1,
+    "genuine": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 8,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "transformers_version": "4.57.6",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

model_out/onnx-int8/model_quantized.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3dd0b51581307e7c20f85daf5d35099b94a3d100b631ca1371ece3dc068273c
+size 42017674

model_out/onnx-int8/ort_config.json

@@ -0,0 +1,33 @@
+{
+  "one_external_file": true,
+  "opset": null,
+  "optimization": {},
+  "quantization": {
+    "activations_dtype": "QUInt8",
+    "activations_symmetric": false,
+    "format": "QOperator",
+    "is_static": false,
+    "mode": "IntegerOps",
+    "nodes_to_exclude": [],
+    "nodes_to_quantize": [],
+    "operators_to_quantize": [
+      "Conv",
+      "MatMul",
+      "Attention",
+      "LSTM",
+      "Gather",
+      "Transpose",
+      "EmbedLayerNormalization"
+    ],
+    "per_channel": true,
+    "qdq_add_pair_to_weight": false,
+    "qdq_dedicated_pair": false,
+    "qdq_op_type_per_channel_support_to_axis": {
+      "MatMul": 1
+    },
+    "reduce_range": false,
+    "weights_dtype": "QInt8",
+    "weights_symmetric": true
+  },
+  "use_external_data_format": false
+}

model_out/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

model_out/tokenizer_config.json

@@ -0,0 +1,58 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

train.py

@@ -0,0 +1,165 @@
+"""Fine-tune a small BERT on labeled tweets and export a quantized ONNX classifier.
+
+Usage:
+    python train.py labeled.json --base google/bert_uncased_L-4_H-256_A-4 --out model_out
+
+Reads labeled.json from label.py, filters rows by --min-confidence
+(default 0.85), trains a 90/10 split, prints validation accuracy/F1, and
+writes:
+- model_out/          PyTorch checkpoint + tokenizer (upload this to Hugging Face)
+- model_out/onnx/     fp32 ONNX
+- model_out/onnx-int8/  int8 ONNX, the serving artifact (~12 MB for BERT-mini)
+"""
+import argparse
+import json
+import os
+import platform
+import random
+
+import numpy as np
+import torch
+from optimum.onnxruntime import ORTModelForSequenceClassification, ORTQuantizer
+from optimum.onnxruntime.configuration import AutoQuantizationConfig
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    DataCollatorWithPadding,
+    Trainer,
+    TrainingArguments,
+)
+
+SEED = 13
+MAX_TOKENS = 128  # tweets are short; 128 covers nearly all of them
+
+
+class TweetDataset(torch.utils.data.Dataset):
+    def __init__(self, rows, tokenizer):
+        self.encodings = tokenizer([r["text"] for r in rows], truncation=True, max_length=MAX_TOKENS)
+        self.labels = [int(bool(r["label"])) for r in rows]
+
+    def __len__(self):
+        return len(self.labels)
+
+    def __getitem__(self, i):
+        item = {k: torch.tensor(v[i]) for k, v in self.encodings.items()}
+        item["labels"] = torch.tensor(self.labels[i])
+        return item
+
+
+def metrics(eval_pred):
+    preds = np.argmax(eval_pred.predictions, axis=1)
+    labels = eval_pred.label_ids
+    tp = int(((preds == 1) & (labels == 1)).sum())
+    fp = int(((preds == 1) & (labels == 0)).sum())
+    fn = int(((preds == 0) & (labels == 1)).sum())
+    return {
+        "accuracy": float((preds == labels).mean()),
+        "f1": 2 * tp / (2 * tp + fp + fn) if (2 * tp + fp + fn) else 0.0,
+    }
+
+
+def onnx_path(directory):
+    return max(
+        (os.path.join(directory, f) for f in os.listdir(directory) if f.endswith(".onnx")),
+        key=os.path.getsize,
+    )
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("labeled", nargs="?", default="labeled.json")
+    ap.add_argument("--base", default="google/bert_uncased_L-4_H-256_A-4")
+    ap.add_argument("--out", default="model_out")
+    ap.add_argument("--epochs", type=float, default=4.0)
+    ap.add_argument("--lr", type=float, default=5e-5)
+    ap.add_argument("--min-confidence", type=float, default=0.85)
+    args = ap.parse_args()
+
+    with open(args.labeled) as f:
+        rows = [
+            r
+            for r in json.load(f)
+            if r.get("label") is not None
+            and r.get("text")
+            and r.get("confidence", 1.0) >= args.min_confidence
+        ]
+    seen, deduped = set(), []
+    for r in rows:
+        if r["text"] not in seen:
+            seen.add(r["text"])
+            deduped.append(r)
+    positives = sum(int(bool(r["label"])) for r in deduped)
+    print(f"{len(deduped)} usable tweets ({positives} farming / {len(deduped) - positives} genuine)")
+    if len(deduped) < 200:
+        raise SystemExit("need at least 200 labeled tweets, collect more first")
+    if positives < 0.05 * len(deduped):
+        print("warning: under 5% positives, collect from bait-heavy timelines or lists to balance")
+
+    random.Random(SEED).shuffle(deduped)
+    cut = int(len(deduped) * 0.9)
+    train_rows, val_rows = deduped[:cut], deduped[cut:]
+
+    # timeline data is ~95% genuine; oversample farming rows in the train split
+    # (val stays natural) so the classifier actually learns the rare class
+    pos = [r for r in train_rows if r["label"]]
+    neg = [r for r in train_rows if not r["label"]]
+    if pos:
+        factor = max(1, round(len(neg) / len(pos) / 2))  # aim for ~1:2 ratio
+        train_rows = neg + pos * factor
+        random.Random(SEED + 1).shuffle(train_rows)
+        print(f"oversampled {len(pos)} farming rows x{factor} -> {len(train_rows)} train rows")
+
+    tokenizer = AutoTokenizer.from_pretrained(args.base)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        args.base,
+        num_labels=2,
+        id2label={0: "genuine", 1: "engagement_farming"},
+        label2id={"genuine": 0, "engagement_farming": 1},
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=TrainingArguments(
+            output_dir=args.out,
+            num_train_epochs=args.epochs,
+            per_device_train_batch_size=32,
+            per_device_eval_batch_size=64,
+            learning_rate=args.lr,
+            eval_strategy="epoch",
+            save_strategy="no",
+            logging_steps=20,
+            seed=SEED,
+            report_to=[],
+        ),
+        train_dataset=TweetDataset(train_rows, tokenizer),
+        eval_dataset=TweetDataset(val_rows, tokenizer),
+        data_collator=DataCollatorWithPadding(tokenizer),
+        compute_metrics=metrics,
+    )
+    trainer.train()
+    eval_metrics = trainer.evaluate()
+    print("validation:", eval_metrics)
+
+    model.save_pretrained(args.out)
+    tokenizer.save_pretrained(args.out)
+    with open(os.path.join(args.out, "metrics.json"), "w") as f:
+        json.dump(eval_metrics, f, indent=1)
+
+    onnx_dir = os.path.join(args.out, "onnx")
+    ORTModelForSequenceClassification.from_pretrained(args.out, export=True).save_pretrained(onnx_dir)
+
+    quant_dir = os.path.join(args.out, "onnx-int8")
+    arm = platform.machine() in ("arm64", "aarch64")
+    qconfig = (
+        AutoQuantizationConfig.arm64(is_static=False)
+        if arm
+        else AutoQuantizationConfig.avx512_vnni(is_static=False)
+    )
+    ORTQuantizer.from_pretrained(onnx_dir).quantize(save_dir=quant_dir, quantization_config=qconfig)
+
+    print(f"fp32 ONNX: {os.path.getsize(onnx_path(onnx_dir)) / 1e6:.1f} MB")
+    print(f"int8 ONNX: {os.path.getsize(onnx_path(quant_dir)) / 1e6:.1f} MB -> {quant_dir}")
+
+
+if __name__ == "__main__":
+    main()