logit-classifier 0.3.0__tar.gz → 0.4.0__tar.gz

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/FINDINGS.md

@@ -295,6 +295,31 @@ dispatcher reaches the math backend, which builds the full attention matrix. Mea
 `HFBackend` probes the backends at startup, at the model's own dtype, and pins the working
 ones. `benchmark.py`.
 
+## One presence wording, two threshold pairs
+
+Correct tags per tile at a pooled precision, over 905 judged tile candidates on 23 tiles,
+from the Logit Tagger's `tests-AB/ab_presence_wording.py` (round 4).
+
+| Wording | P 0.95 | P 0.97 | P 0.98 | P 0.99 |
+|---|---|---|---|---|
+| "This image visibly contains {TAG}" | 17.43 | 12.78 | 9.87 | 6.04 |
+| "Is there a {TAG} in this image?" (0.3.0, article by rule) | 17.35 | 11.30 | 2.39 | 2.09 |
+| "Present in this image: {TAG}" | 17.61 | 8.74 | 8.13 | 6.74 |
+
+The shipped fp8 tile pass cut offline, per tile and prompt over 69 runs, from
+ContextAnchoredTileRefine's `tests-AB/ab_tags_paired.py`.
+
+| Thresholds | Correct | Wrong or vague | Precision |
+|---|---|---|---|
+| broad (0.999, 0.9999) | 12.32 | 0.54 | 0.958 |
+| strict (0.99998, 0.99998) | 7.33 | 0.17 | 0.977 |
+
+Every paired interval against "This image visibly contains {TAG}" at 0.95 and 0.98 spans zero.
+It needs no grammar, and the tile pass already asked it, so its thresholds carry over. On
+declared COCO tag lists "Is there a {TAG} in this image?" (0.3.0, article by rule) kept more
+correct tags at precision 0.98 (3.79 against 1.90 per image), which is the cost of one
+wording.
+
 ## Bugs found and fixed
 
 | Bug | Effect | Fix |
@@ -329,6 +354,6 @@ and 23.66 GB against 15.12 GB, because a cropped cache is a non-contiguous view.
 
 ## Layout
 
-`tests/` holds the pytest suite, 146 unit tests and 14 that need the GPU. `tests-AB/` holds
+`tests/` holds the pytest suite, the unit tests and 14 tests that need the GPU. `tests-AB/` holds
 the measurement harnesses, matching ComfyUI-ContextAnchoredTileRefine. Fixtures live in
 `tests/fixtures/` and `tests-AB/ab_env.py` points at them.

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logit-classifier
-Version: 0.3.0
+Version: 0.4.0
 Summary: Local zero-shot classifier for text and images. Declares options and reads a calibrated probability for each from the logits. Accepts the TypeSafe System One request format, and ships a toolkit of image tag tools and ComfyUI node tools.
 Project-URL: Repository, https://github.com/Blakeem/logit-classifier
 Project-URL: Bug Tracker, https://github.com/Blakeem/logit-classifier/issues
@@ -178,7 +178,7 @@ the model.
 
 ```json
 {
-  "model": "logit-classifier-0.3.0",
+  "model": "logit-classifier-0.4.0",
   "answers": {
     "department": {
       "type": "choice",
@@ -371,7 +371,8 @@ and the classifier never imports the toolkit.
 | `drop_subsets` | drops a tag whose words all appear in a longer tag |
 | `prompt_word_forms`, `in_prompt` | test whether a tag's words appear in a prompt, singular or plural |
 | `merge_candidates` | merges proposed tags with a prompt's tags under a cap |
-| `presence_question` | writes "Is there a car in this image?" with the article the thing takes |
+| `presence_statement` | writes "This image visibly contains car" with the tag as given |
+| `BROAD_THRESHOLDS`, `STRICT_THRESHOLDS` | the scores a tag must reach, broad for more tags and strict for fewer wrong ones |
 
 ```python
 from logit_classifier.toolkit.tags import drop_subsets, parse_candidates
@@ -387,35 +388,44 @@ stays beside "cat ear", and "signage" is dropped beside "signage in chinese".
 ### ComfyUI Tools
 
 These run inside a ComfyUI node over the CLIP the workflow loaded. Each one imports comfy and
-torch only when it is called.
+torch only when it is called. `logit_classifier.toolkit.comfyui` exports every tool. The table
+names the module of each tool it lists.
 
-| Tool | Does |
-|---|---|
-| `comfy_classifier` | builds a classifier over the CLIP, with errors that name the node and the Load CLIP fix |
-| `generate_text` | generates one greedy reply with the Qwen chat template, and stops early on a condition |
-| `shared_vision_encode` | runs the vision tower once per picture for every generate and classify inside the block |
-| `skip_resident_loads` | skips core's model load while the CLIP is already on the GPU |
-| `routed_progress_bars`, `send_status`, `run_outcome` | show one progress bar per run and a status line under the node |
-| `fit_picture` | downscales an image to a pixel cap |
-| `prompt_tags` | lists the physical things a prompt names |
-| `tag_picture` | tags a picture, with a prompt's things added as candidates |
-| `TagSettings` | holds every wording, budget, cap and threshold of the tagger |
+| Module | Tool | Does |
+|---|---|---|
+| `classifier` | `comfy_classifier` | builds a classifier over the CLIP, with errors that name the node and the Load CLIP fix |
+| `generate` | `generate_text` | generates one greedy reply with the Qwen chat template, and stops early on a condition |
+| `generate` | `clip_generate` | runs core's generate, then clears the CUDA graphs it captured |
+| `scopes` | `shared_vision_encode` | runs the vision tower once per image for every generate and classify inside the block |
+| `scopes` | `skip_resident_loads` | skips core's model load while the CLIP is already on the GPU |
+| `progress` | `routed_progress_bars`, `send_status`, `run_outcome` | show one progress bar per run and a status line under the node |
+| `tagger` | `fit_image` | downscales an image to a pixel cap |
+| `tagger` | `tag_prompt` | lists the physical things a prompt names |
+| `tagger` | `tag_image` | tags an image, with a prompt's things added as candidates |
+| `tagger` | `TagSettings` | holds every wording, budget, cap and threshold of the tagger |
 
 The tagger generates candidate tags over the CLIP and verifies each one with the classifier.
 
 ```python
-from logit_classifier.toolkit.comfyui import TagSettings, comfy_classifier, fit_picture, tag_picture
+from logit_classifier.toolkit.comfyui import TagSettings, comfy_classifier, fit_image, tag_image
 
 classifier = comfy_classifier(clip, node="My Tagger")
-picture = fit_picture(image, 1024 * 1024)
-trace = tag_picture(clip, classifier, picture, settings=TagSettings(), known={})
+trace = tag_image(clip, classifier, fit_image(image, 1024 * 1024), settings=TagSettings(), thing_cache={})
 tags = trace.kept
 ```
 
-`known` holds the thing check's answers across a run, so each tag is asked once. The
+`thing_cache` holds the thing check's answers across a run, so each tag is asked once. The
 `TagSettings` defaults are the current measured values, and a later release may change them.
 Pass every value your output depends on to keep it fixed.
 
+For fewer wrong tags, pass `STRICT_THRESHOLDS` as `verify_thresholds`.
+
+```python
+from logit_classifier.toolkit.tags import STRICT_THRESHOLDS
+
+settings = TagSettings(verify_thresholds=STRICT_THRESHOLDS)
+```
+
 ## Differences From Jev
 
 This project matches the System One request and response format and the documented limits.
@@ -434,13 +444,13 @@ Jev publishes status codes but no error body. The error shape here is our own.
 
 ```
 uv sync --all-extras
-uv run pytest tests/test_unit.py
-uv run pytest tests/test_model.py -m model
+uv run python -m pytest tests -m "not model"
+uv run python -m pytest tests/test_model.py -m model
 uv run ruff check .
 uv run mypy
 ```
 
-The unit tests need no weights. The model tests load the GPU and take about 15 seconds.
+The unit tests need no weights. The model tests load the GPU and take 24 to 126 seconds, the longer run being the first of a session.
 
 `FINDINGS.md` is the measurement record. Every number there names the script in
 `tests-AB/` that produced it.

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/README.md

@@ -145,7 +145,7 @@ the model.
 
 ```json
 {
-  "model": "logit-classifier-0.3.0",
+  "model": "logit-classifier-0.4.0",
   "answers": {
     "department": {
       "type": "choice",
@@ -338,7 +338,8 @@ and the classifier never imports the toolkit.
 | `drop_subsets` | drops a tag whose words all appear in a longer tag |
 | `prompt_word_forms`, `in_prompt` | test whether a tag's words appear in a prompt, singular or plural |
 | `merge_candidates` | merges proposed tags with a prompt's tags under a cap |
-| `presence_question` | writes "Is there a car in this image?" with the article the thing takes |
+| `presence_statement` | writes "This image visibly contains car" with the tag as given |
+| `BROAD_THRESHOLDS`, `STRICT_THRESHOLDS` | the scores a tag must reach, broad for more tags and strict for fewer wrong ones |
 
 ```python
 from logit_classifier.toolkit.tags import drop_subsets, parse_candidates
@@ -354,35 +355,44 @@ stays beside "cat ear", and "signage" is dropped beside "signage in chinese".
 ### ComfyUI Tools
 
 These run inside a ComfyUI node over the CLIP the workflow loaded. Each one imports comfy and
-torch only when it is called.
+torch only when it is called. `logit_classifier.toolkit.comfyui` exports every tool. The table
+names the module of each tool it lists.
 
-| Tool | Does |
-|---|---|
-| `comfy_classifier` | builds a classifier over the CLIP, with errors that name the node and the Load CLIP fix |
-| `generate_text` | generates one greedy reply with the Qwen chat template, and stops early on a condition |
-| `shared_vision_encode` | runs the vision tower once per picture for every generate and classify inside the block |
-| `skip_resident_loads` | skips core's model load while the CLIP is already on the GPU |
-| `routed_progress_bars`, `send_status`, `run_outcome` | show one progress bar per run and a status line under the node |
-| `fit_picture` | downscales an image to a pixel cap |
-| `prompt_tags` | lists the physical things a prompt names |
-| `tag_picture` | tags a picture, with a prompt's things added as candidates |
-| `TagSettings` | holds every wording, budget, cap and threshold of the tagger |
+| Module | Tool | Does |
+|---|---|---|
+| `classifier` | `comfy_classifier` | builds a classifier over the CLIP, with errors that name the node and the Load CLIP fix |
+| `generate` | `generate_text` | generates one greedy reply with the Qwen chat template, and stops early on a condition |
+| `generate` | `clip_generate` | runs core's generate, then clears the CUDA graphs it captured |
+| `scopes` | `shared_vision_encode` | runs the vision tower once per image for every generate and classify inside the block |
+| `scopes` | `skip_resident_loads` | skips core's model load while the CLIP is already on the GPU |
+| `progress` | `routed_progress_bars`, `send_status`, `run_outcome` | show one progress bar per run and a status line under the node |
+| `tagger` | `fit_image` | downscales an image to a pixel cap |
+| `tagger` | `tag_prompt` | lists the physical things a prompt names |
+| `tagger` | `tag_image` | tags an image, with a prompt's things added as candidates |
+| `tagger` | `TagSettings` | holds every wording, budget, cap and threshold of the tagger |
 
 The tagger generates candidate tags over the CLIP and verifies each one with the classifier.
 
 ```python
-from logit_classifier.toolkit.comfyui import TagSettings, comfy_classifier, fit_picture, tag_picture
+from logit_classifier.toolkit.comfyui import TagSettings, comfy_classifier, fit_image, tag_image
 
 classifier = comfy_classifier(clip, node="My Tagger")
-picture = fit_picture(image, 1024 * 1024)
-trace = tag_picture(clip, classifier, picture, settings=TagSettings(), known={})
+trace = tag_image(clip, classifier, fit_image(image, 1024 * 1024), settings=TagSettings(), thing_cache={})
 tags = trace.kept
 ```
 
-`known` holds the thing check's answers across a run, so each tag is asked once. The
+`thing_cache` holds the thing check's answers across a run, so each tag is asked once. The
 `TagSettings` defaults are the current measured values, and a later release may change them.
 Pass every value your output depends on to keep it fixed.
 
+For fewer wrong tags, pass `STRICT_THRESHOLDS` as `verify_thresholds`.
+
+```python
+from logit_classifier.toolkit.tags import STRICT_THRESHOLDS
+
+settings = TagSettings(verify_thresholds=STRICT_THRESHOLDS)
+```
+
 ## Differences From Jev
 
 This project matches the System One request and response format and the documented limits.
@@ -401,13 +411,13 @@ Jev publishes status codes but no error body. The error shape here is our own.
 
 ```
 uv sync --all-extras
-uv run pytest tests/test_unit.py
-uv run pytest tests/test_model.py -m model
+uv run python -m pytest tests -m "not model"
+uv run python -m pytest tests/test_model.py -m model
 uv run ruff check .
 uv run mypy
 ```
 
-The unit tests need no weights. The model tests load the GPU and take about 15 seconds.
+The unit tests need no weights. The model tests load the GPU and take 24 to 126 seconds, the longer run being the first of a session.
 
 `FINDINGS.md` is the measurement record. Every number there names the script in
 `tests-AB/` that produced it.

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/src/logit_classifier/_version.py

@@ -1,3 +1,3 @@
 """The package version, apart from __init__ so config.py can read it without a cycle."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/src/logit_classifier/toolkit/comfyui/__init__.py

@@ -13,14 +13,14 @@ from .generate import IMAGE_SLOT, chat, clip_generate, generate_text, stop_when
 from .progress import routed_progress_bars, run_outcome, send_status, token_fill
 from .scopes import shared_vision_encode, skip_resident_loads
 from .tagger import (
-    PromptTags,
+    ImageTagTrace,
+    PromptTagTrace,
     TagSettings,
-    TagTrace,
-    english_text,
-    fit_picture,
-    prompt_tags,
-    tag_picture,
+    fit_image,
+    tag_image,
+    tag_prompt,
     thing_scores,
+    to_english,
 )
 
 __all__ = [
@@ -28,23 +28,23 @@ __all__ = [
     "IMAGE_SLOT",
     "PACKED_TOKEN_CEILING",
     "ComfyClipBackend",
-    "PromptTags",
+    "ImageTagTrace",
+    "PromptTagTrace",
     "TagSettings",
-    "TagTrace",
     "chat",
     "clip_generate",
     "comfy_classifier",
-    "english_text",
-    "fit_picture",
+    "fit_image",
     "generate_text",
-    "prompt_tags",
     "routed_progress_bars",
     "run_outcome",
     "send_status",
     "shared_vision_encode",
     "skip_resident_loads",
     "stop_when",
-    "tag_picture",
+    "tag_image",
+    "tag_prompt",
     "thing_scores",
+    "to_english",
     "token_fill",
 ]

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/src/logit_classifier/toolkit/comfyui/scopes.py

@@ -12,7 +12,7 @@ from ...backends.comfy_clip import _clip_parts, _resident
 
 @contextmanager
 def shared_vision_encode(clip: Any) -> Iterator[None]:
-    """Run the vision tower once per picture tensor for the duration, shared by generate and classify.
+    """Run the vision tower once per image tensor for the duration, shared by generate and classify.
 
     Each encode runs inside the determinism window, where classify always ran it, so its
     scores are unchanged. A transformer without core's preprocess_embed passes through.

{logit_classifier-0.3.0 → logit_classifier-0.4.0}/src/logit_classifier/toolkit/comfyui/tagger.py

@@ -15,12 +15,16 @@ from typing import Any
 from ...classifier import Classifier
 from ...schema import ChoiceAnswer, ChoiceQuestion, JSONContent, Question, SystemOneRequest
 from ..tags import (
+    BROAD_THRESHOLDS,
+    PRESENCE_STATEMENT,
     MergedCandidates,
+    PresenceThresholds,
     drop_subsets,
     in_prompt,
     merge_candidates,
     parse_candidates,
     passed_by_origin,
+    presence_statement,
     prompt_word_forms,
     tag_stop,
 )
@@ -31,7 +35,7 @@ _PROMPT = "{PROMPT}"
 _TAG = "{TAG}"
 _THING_CHECKS = ("all", "prompt")
 _SUBSETS_RULES = ("words", "head-noun")
-_ORDERS = ("score", "proposed")
+_ORDERS = ("score", "candidate")
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -61,15 +65,14 @@ class TagSettings:
     # On fp8, 40 over 25 added 0.85 correct and 0.15 wrong or vague tags per render, and 0.87 and 0.10 per tile
     # (the Logit Tagger's tests-AB/ab_tagger_score.py --replay, ContextAnchoredTileRefine tests-AB/ab_tags_bench.py).
     propose_cap: int = 25
-    # The model's 25 and a long prompt's 30 to 40 tags, in one packed verify pass beside a 1 MP picture
-    # (ContextAnchoredTileRefine tests-AB/tags-bench-log.md).
+    # The model's 25 and a long prompt's about 40 tags, in one packed verify pass beside a 1 MP image
+    # (ContextAnchoredTileRefine tests-AB/tags-bench-log.md, section 7).
     merge_cap: int = 64
     # The propose wording's own nouns came back as tags and passed verify (ContextAnchoredTileRefine
     # tests-AB/ab_tile_tags.py).
     category_nouns: frozenset[str] = frozenset({"objects", "people", "animals", "clothing", "materials", "setting"})
 
-    # A 500 word prompt listed 28 to 45 tags in 70 to 256 tokens (ContextAnchoredTileRefine tags-bench-log.md). Past
-    # the prompt's own things the model pads the list with words the prompt lacks, so a streak of them ends it.
+    # Past the prompt's own things the model pads the list with words the prompt lacks, so a streak of them ends it.
     prompt_tags_instruction: str = (
         "This is a prompt for an image:\n{PROMPT}\n\nList the physical things the prompt names that "
         "could be pointed at in the image: objects, people, animals, plants, clothing, materials, "
@@ -100,21 +103,17 @@ class TagSettings:
                   "shape or form, lighting in general, a camera or render effect, a style, a mood, a "
                   "quality or an idea"),
     )
-    # Mid scores mix things with non-things ("robots" 0.85 on fp8), so only a confident "other" drops a tag.
-    thing_threshold: float = 0.9
+    # Low p("thing") scores mix things with non-things ("robots" 0.15 on fp8), so only a score below 0.1 drops a tag.
+    thing_threshold: float = 0.1
     # Judging only the prompt's tags kept "watermark" and "pixel art", and added 0.28 vague tags per render and 0.81
     # per tile on fp8 (ab_tagger_score.py --replay, ab_tags_bench.py).
     thing_check: str = "all"
 
-    # The crop wording "This crop visibly contains {f}" reached AUC 0.963 in this repo's tests-AB/ab_multi_label.py.
-    # "Is there {TAG} in this image?" removed 34 correct tile tags per 4 wrong ones (ab_tags_bench.py).
-    verify_statement: str = "This image visibly contains {TAG}"
-    # On fp8, 0.999 over 0.9 removed a wrong or vague tag per 2.6 to 4.0 correct ones on renders, photos and tiles,
-    # and 0.9999 cost about 50 correct tile tags per further one (ab_tagger_score.py --replay, ab_tags_bench.py).
-    verify_threshold: float = 0.999
-    # A near name passes 0.9, and 0.9999 cut wrong tags per tile from 0.92 to 0.29 (ContextAnchoredTileRefine
-    # tests-AB/tags-bench-log.md).
-    prompt_only_threshold: float = 0.9999
+    # The toolkit's presence wording (toolkit/tags.py), which the Logit Tagger asks of a listed tag and a prompt's thing.
+    verify_statement: str = PRESENCE_STATEMENT
+    # On fp8, 0.999 over 0.9 removed a wrong or vague tag per 2.6 to 4.0 correct ones, and 0.9999 on a declared tag cut
+    # wrong tags per tile from 0.83 to 0.29 (ab_tagger_score.py --replay, ContextAnchoredTileRefine tags-bench-log.md).
+    verify_thresholds: PresenceThresholds = BROAD_THRESHOLDS
 
     # The "head-noun" rule keeps "cat" beside "cat ear", and also "stone" beside "stone walls" and "castle" beside
     # "stone castle tower". On fp8 tiles it added 0.03 wrong or vague tags per tile (ab_tags_bench.py).
@@ -127,12 +126,7 @@ class TagSettings:
             ("translate_instruction", self.translate_instruction, _PROMPT),
             ("thing_question", self.thing_question, _TAG),
         ]
-        thresholds = {
-            "english_threshold": self.english_threshold,
-            "thing_threshold": self.thing_threshold,
-            "verify_threshold": self.verify_threshold,
-            "prompt_only_threshold": self.prompt_only_threshold,
-        }
+        thresholds: dict[str, float] = {}
         budgets = {
             "propose_max_tokens": self.propose_max_tokens,
             "propose_cap": self.propose_cap,
@@ -147,6 +141,15 @@ class TagSettings:
         }
         criteria_keys = {key for key, _text in self.thing_criteria}
 
+        if not isinstance(self.verify_thresholds, PresenceThresholds):
+            raise ValueError(f"TagSettings got verify_thresholds={self.verify_thresholds!r}. Use a PresenceThresholds, "
+                             f"such as BROAD_THRESHOLDS or STRICT_THRESHOLDS from logit_classifier.toolkit.tags.")
+        thresholds = {
+            "english_threshold": self.english_threshold,
+            "thing_threshold": self.thing_threshold,
+            "verify_thresholds.proposed": self.verify_thresholds.proposed,
+            "verify_thresholds.declared": self.verify_thresholds.declared,
+        }
         # An empty verify statement turns verify off, so it needs no placeholder.
         if self.verify_statement:
             wordings.append(("verify_statement", self.verify_statement, _TAG))
@@ -175,23 +178,23 @@ class TagSettings:
 
 
 @dataclass(frozen=True, kw_only=True)
-class PromptTags:
-    """One prompt's listing, for the pack to merge into every picture's candidates.
+class PromptTagTrace:
+    """One prompt's pass through tag_prompt, whose tags the pack merges into every image's candidates.
 
-    text is the English text the listing read. listed holds the tags in_prompt keeps, p_other each one's thing check
+    text is the English text the listing read. listed holds the tags in_prompt keeps, p_thing each one's thing check
     score, and tags the listed tags the thing check keeps.
     """
 
     text: str
     reply: str
     listed: tuple[str, ...]
-    p_other: tuple[float, ...]
+    p_thing: tuple[float, ...]
     tags: tuple[str, ...]
 
 
 @dataclass(frozen=True, kw_only=True)
-class TagTrace:
-    """One picture's pass through every stage.
+class ImageTagTrace:
+    """One image's pass through tag_image.
 
     echo_reply holds the replaced reply when the echo fallback ran. dropped holds (name, reason) pairs from the merge
     and the thing check. scores holds None per candidate with verify off. verified is before drop_subsets, and kept
@@ -211,7 +214,7 @@ class TagTrace:
     verify_ms: float
 
 
-def fit_picture(image: Any, max_pixels: int) -> Any:
+def fit_image(image: Any, max_pixels: int) -> Any:
     """Return the first three channels of a [B, H, W, C] image, area-downscaled to at most max_pixels, never upscaled.
 
     Core resizes a vision image only above 12.8 MP, so a 4k input would cost about 12k vision tokens.
@@ -225,7 +228,7 @@ def fit_picture(image: Any, max_pixels: int) -> Any:
     fitted_width = 0
 
     if max_pixels < 1:
-        raise ValueError(f"fit_picture got max_pixels={max_pixels!r}. Use 1 or more.")
+        raise ValueError(f"fit_image got max_pixels={max_pixels!r}. Use 1 or more.")
     if height * width <= max_pixels:
         return rgb
     scale = math.sqrt(max_pixels / (height * width))
@@ -238,13 +241,13 @@ def fit_picture(image: Any, max_pixels: int) -> Any:
 
 
 def thing_scores(
-    classifier: Classifier, tags: Sequence[str], settings: TagSettings, known: dict[str, float]
+    classifier: Classifier, tags: Sequence[str], settings: TagSettings, thing_cache: dict[str, float]
 ) -> tuple[float, ...]:
-    """Return the thing check's p("other") per tag, asking every tag missing from known in one text-only request.
+    """Return the thing check's p("thing") per tag, asking every tag missing from thing_cache in one text-only request.
 
-    known carries the answers across a run, so each tag is asked once per known.
+    thing_cache carries the answers across a run, so each tag is asked once per cache.
     """
-    unknown = tuple(dict.fromkeys(tag for tag in tags if tag not in known))
+    unknown = tuple(dict.fromkeys(tag for tag in tags if tag not in thing_cache))
     criteria: dict[str, JSONContent | None] = dict(settings.thing_criteria)
     questions: dict[str, Question] = {}
 
@@ -258,11 +261,11 @@ def thing_scores(
             answer = response.answers[qid]
             if not isinstance(answer, ChoiceAnswer):
                 raise TypeError(f"thing question {qid} got a {answer.type} answer, not a choice")
-            known[tag] = answer.probabilities["other"]
-    return tuple(known[tag] for tag in tags)
+            thing_cache[tag] = answer.probabilities["thing"]
+    return tuple(thing_cache[tag] for tag in tags)
 
 
-def english_text(clip: Any, classifier: Classifier, prompt: str, settings: TagSettings) -> str:
+def to_english(clip: Any, classifier: Classifier, prompt: str, settings: TagSettings) -> str:
     """Return the prompt when the language gate is off or reads it as English, otherwise its English translation.
 
     A blank translation gives the prompt back.
@@ -279,9 +282,9 @@ def english_text(clip: Any, classifier: Classifier, prompt: str, settings: TagSe
     return translation or prompt
 
 
-def prompt_tags(
-    clip: Any, classifier: Classifier, prompt: str, settings: TagSettings, known: dict[str, float]
-) -> PromptTags:
+def tag_prompt(
+    clip: Any, classifier: Classifier, prompt: str, settings: TagSettings, thing_cache: dict[str, float]
+) -> PromptTagTrace:
     """List the physical things the prompt names that its English text grounds and the thing check keeps.
 
     The listing reads the prompt's English text, since in_prompt and the streak stop match the text's own words.
@@ -290,33 +293,34 @@ def prompt_tags(
     word_forms: frozenset[str] = frozenset()
     reply = ""
     listed: tuple[str, ...] = ()
-    p_other: tuple[float, ...] = ()
+    p_thing: tuple[float, ...] = ()
 
     if not prompt.strip():
-        return PromptTags(text="", reply="", listed=(), p_other=(), tags=())
-    text = english_text(clip, classifier, prompt, settings)
+        return PromptTagTrace(text="", reply="", listed=(), p_thing=(), tags=())
+    text = to_english(clip, classifier, prompt, settings)
     word_forms = prompt_word_forms(text)
     reply = generate_text(clip, settings.prompt_tags_instruction.replace(_PROMPT, text),
                           max_tokens=settings.prompt_tags_max_tokens,
                           should_stop=tag_stop(max_tags=None, ungrounded_streak=settings.ungrounded_streak,
                                                word_forms=word_forms))
     listed = tuple(tag for tag in parse_candidates(reply) if in_prompt(tag, word_forms))
-    p_other = thing_scores(classifier, listed, settings, known)
-    return PromptTags(text=text, reply=reply, listed=listed, p_other=p_other,
-                      tags=tuple(tag for tag, p in zip(listed, p_other, strict=True) if p < settings.thing_threshold))
+    p_thing = thing_scores(classifier, listed, settings, thing_cache)
+    return PromptTagTrace(text=text, reply=reply, listed=listed, p_thing=p_thing,
+                          tags=tuple(tag for tag, p in zip(listed, p_thing, strict=True)
+                                     if p >= settings.thing_threshold))
 
 
-def _propose(clip: Any, picture: Any, instruction: str, settings: TagSettings) -> tuple[str, tuple[str, ...]]:
-    reply = generate_text(clip, instruction, image=picture, max_tokens=settings.propose_max_tokens,
+def _propose(clip: Any, image: Any, instruction: str, settings: TagSettings) -> tuple[str, tuple[str, ...]]:
+    reply = generate_text(clip, instruction, image=image, max_tokens=settings.propose_max_tokens,
                           should_stop=tag_stop(max_tags=settings.propose_cap, ungrounded_streak=0))
 
     return reply, tuple(parse_candidates(reply, max_candidates=settings.propose_cap))
 
 
 def _things_only(classifier: Classifier, merged: MergedCandidates, settings: TagSettings,
-                 known: dict[str, float]) -> MergedCandidates:
-    p_other = thing_scores(classifier, merged.candidates, settings, known)
-    is_thing = [p < settings.thing_threshold for p in p_other]
+                 thing_cache: dict[str, float]) -> MergedCandidates:
+    p_thing = thing_scores(classifier, merged.candidates, settings, thing_cache)
+    is_thing = [p >= settings.thing_threshold for p in p_thing]
     not_things = tuple((tag, "not a thing") for tag, thing in zip(merged.candidates, is_thing, strict=True)
                        if not thing)
 
@@ -324,24 +328,24 @@ def _things_only(classifier: Classifier, merged: MergedCandidates, settings: Tag
                             tuple(itertools.compress(merged.origins, is_thing)), merged.dropped + not_things)
 
 
-def tag_picture(
+def tag_image(
     clip: Any,
     classifier: Classifier,
-    picture: Any,
+    image: Any,
     *,
     prompt_tags: Sequence[str] = (),
     settings: TagSettings,
-    known: dict[str, float],
+    thing_cache: dict[str, float],
     on_stage: Callable[[str], None] | None = None,
-) -> TagTrace:
-    """Propose, merge with prompt_tags, check, verify and clean the tags of a picture the caller already fitted.
+) -> ImageTagTrace:
+    """Propose, merge with prompt_tags, check, verify and clean the tags of an image the caller already fitted.
 
-    Propose and verify run in one shared_vision_encode scope, so the vision tower encodes the picture once. on_stage
+    Propose and verify run in one shared_vision_encode scope, so the vision tower encodes the image once. on_stage
     hears "propose", then "verify".
     """
     announce = on_stage if on_stage is not None else (lambda _stage: None)
-    thresholds = {"model": settings.verify_threshold, "both": settings.verify_threshold,
-                  "prompt": settings.prompt_only_threshold}
+    thresholds = {"model": settings.verify_thresholds.proposed, "both": settings.verify_thresholds.proposed,
+                  "prompt": settings.verify_thresholds.declared}
     reply = ""
     echo_reply: str | None = None
     proposed: tuple[str, ...] = ()
@@ -358,21 +362,22 @@ def tag_picture(
     with shared_vision_encode(clip):
         announce("propose")
         started = time.perf_counter()
-        reply, proposed = _propose(clip, picture, settings.propose_instruction, settings)
+        reply, proposed = _propose(clip, image, settings.propose_instruction, settings)
         if (settings.echo_fallback_instruction is not None
                 and not merge_candidates(proposed, (), cap=settings.merge_cap,
                                          drop=settings.category_nouns).candidates):
             echo_reply = reply
-            reply, proposed = _propose(clip, picture, settings.echo_fallback_instruction, settings)
+            reply, proposed = _propose(clip, image, settings.echo_fallback_instruction, settings)
         propose_ms = (time.perf_counter() - started) * 1000.0
         merged = merge_candidates(proposed, prompt_tags, cap=settings.merge_cap, drop=settings.category_nouns)
         if settings.thing_check == "all":
-            merged = _things_only(classifier, merged, settings, known)
+            merged = _things_only(classifier, merged, settings, thing_cache)
         announce("verify")
         started = time.perf_counter()
         if settings.verify_statement:
             verify_scores = tuple(classifier.nouls(
-                [settings.verify_statement.replace(_TAG, tag) for tag in merged.candidates], image=picture))
+                [presence_statement(tag, wording=settings.verify_statement) for tag in merged.candidates],
+                image=image))
             verified = passed_by_origin(merged.candidates, merged.origins, verify_scores, thresholds=thresholds)
             scores = verify_scores
         else:
@@ -385,6 +390,6 @@ def tag_picture(
         score_of = dict(zip(merged.candidates, verify_scores, strict=True))
         # sorted is stable, so tied tags keep candidate order.
         kept = tuple(sorted(kept, key=score_of.__getitem__, reverse=True))
-    return TagTrace(reply=reply, echo_reply=echo_reply, proposed=proposed, candidates=merged.candidates,
-                    origins=merged.origins, dropped=merged.dropped, scores=scores, verified=verified, kept=kept,
-                    propose_ms=propose_ms, verify_ms=verify_ms)
+    return ImageTagTrace(reply=reply, echo_reply=echo_reply, proposed=proposed, candidates=merged.candidates,
+                         origins=merged.origins, dropped=merged.dropped, scores=scores, verified=verified, kept=kept,
+                         propose_ms=propose_ms, verify_ms=verify_ms)