Card: strict '<' flag rule, format-assignment wording, vLLM section; thresholds.json flag rule

README.md

@@ -88,9 +88,46 @@ print(p_human(text))
 
 Build the prompt string exactly as above rather than through the chat template.
 
+### Score with vLLM
+
+For many inputs, vLLM is about 15 times faster than the code above and fits much longer inputs on one 80 GB GPU.
+With vLLM 0.21 (install `xgrammar==0.2.1`; later releases require transformers < 5), reusing `SYSTEM`, `SUFFIX`,
+`HUMAN` and `AI` from above:
+
+```python
+import math, os
+os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")   # FlashInfer kernels compile CUDA code and need nvcc
+os.environ.setdefault("VLLM_USE_FLASHINFER_MOE_FP16", "0")
+os.environ.setdefault("VLLM_USE_DEEP_GEMM", "0")            # H100 warmup crashes when DeepGEMM is not installed
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+tok = AutoTokenizer.from_pretrained("rishanthrajendhran/ProseLens")
+llm = LLM(model="rishanthrajendhran/ProseLens", dtype="bfloat16", max_num_seqs=256, enable_prefix_caching=False,
+          max_logprobs=20, enable_flashinfer_autotune=False, seed=0)
+sp = SamplingParams(max_tokens=1, temperature=0.0, logprobs=20)
+
+def p_human_batch(texts):
+    prompts = [{"prompt_token_ids": tok.encode(f"<|im_start|>system\n{SYSTEM}<|im_end|>\n<|im_start|>user\n{x}{SUFFIX}",
+                                               add_special_tokens=False)} for x in texts]
+    out = []
+    for r in llm.generate(prompts, sp, use_tqdm=False):
+        lp = r.outputs[0].logprobs[0]           # the top 20 next-token log-probabilities
+        out.append(1 / (1 + math.exp(lp[AI].logprob - lp[HUMAN].logprob)))
+    return out
+
+# when done: without this, vLLM 0.21 keeps a script running after its last line
+llm.llm_engine.engine_core.shutdown()
+```
+
+`max_num_seqs=256` keeps every running sequence's Mamba state in memory; vLLM's H100 default (1,024) does not fit
+beside the weights. If `human` or `ai` is missing from the top 20 (rare), score the prompt followed by each label
+token with `SamplingParams(max_tokens=1, prompt_logprobs=0)` and read the last prompt log-probability of each.
+Scores agree with the training-time scores to about 0.001 in P(human) on average; A100 and H100 GPUs differ by as much.
+
 ### Thresholds
 
-ProseLens flags a document as AI-written when P(human) is at or below a cut. Each cut is set so
+ProseLens flags a document as AI-written when P(human) is below a cut. Each cut is set so
 that a given share of human documents is flagged (the false-positive rate, FPR), measured on the 80,000 human
 documents in IdeaLens-1M's `calibration` split (10,000 per format). The paper's operating point is the global
 cut at 1% FPR.
@@ -100,7 +137,8 @@ cut at 1% FPR.
 | Global cut | 0.07082 | 0.30469 | 0.60539 | 0.92502 | 0.99889 |
 
 Per-format cuts give each format its own operating point. They need the document's format, which the paper
-assigns with WebOrganizer's FormatClassifier (FormatClassifier-NoURL when there is no URL). Each is the
+assigns with WebOrganizer's annotation prompt run on Gemini 3.7 Flash; the calibration documents use the formats
+recorded in IdeaLens-1M. Each is the
 format's own quantile, shrunk toward the global cut with weight n / (n + 2500); at 0.1% FPR 10,000 documents
 per format are too few, so there is no per-format cut. A document outside these eight formats has no
 per-format cut; do not fall back to the global cut for it.

thresholds.json

@@ -1,7 +1,7 @@
 {
  "model": "rishanthrajendhran/ProseLens",
  "input": "document",
- "flag_rule": "flag the document as AI when P(human) <= cut",
+ "flag_rule": "flag the document as AI when P(human) < cut",
  "calibration": {
   "data": "IdeaLens-1M, calibration split (human documents only)",
   "scores_from": "the training checkpoint, scored on Tinker",