normalize_tags: add config file, update readme.

README.md

@@ -12,28 +12,114 @@ tags:
 
 # E6DB
 
-This a dataset is compiled from the e621 database. It currently provides indexes
-for normalizing tags and embeddings for finding similar tags.
+This a dataset is compiled from the e621 database. It currently provides
+utilities and indexes for normalizing tags and embeddings for finding similar
+tags.
+
+## Installation
+
+Please clone with `git` after having installed
+[`git-lfs`](https://docs.github.com/en/repositories/working-with-files/managing-large-files/installing-git-large-file-storage).
+Do not download the github zip, it doesn't contain the data files.
 
 ## Utilities
 
 ### `query_tags.py`
 
-A small command-line utility that finds related tags and generates 2D plots illustrating tag relationships through local PCA projection. It utilizes collaborative filtering embeddings, [computed with alternating least squares](./notebooks/AltLstSq.ipynb).
+A small command-line utility that finds related tags and generates 2D plots
+illustrating tag relationships through local PCA projection. It utilizes
+collaborative filtering embeddings, [computed with alternating least
+squares](./notebooks/AltLstSq.ipynb).
 
-When only tags are provided as arguments, it displays the top-k most similar tags (where k is set with `-k`). By using `-o plot.png` or `-o -`, it saves or displays a 2D plot showing the local projection of the query and related tags.
+When only tags are provided as arguments, it displays the top-k most similar
+tags (where k is set with `-k`). By using `-o plot.png` or `-o -`, it saves or
+displays a 2D plot showing the local projection of the query and related tags.
 
-Tag categories are represented with the e621 color scheme. Results can be filtered based on one or more categories using the `-c` flag once or multiple times. The `-f` flag sets a post count threshold.
+Tag categories are represented with the e621 color scheme. Results can be
+filtered based on one or more categories using the `-c` flag once or multiple
+times. The `-f` flag sets a post count threshold.
 
 Filtering occurs in the following sequence:
 
-- Tags used fewer than twice are excluded from the dataset; tags with a post count lower than the `-f` threshold are also discarded.
+- Tags used fewer than twice are excluded from the dataset; tags with a post
+  count lower than the `-f` threshold are also discarded.
 - If a category filter is specified, only matching tags are retained.
 - For each query tag, the most `-k` similar neighboring tags are selected.
-- The per-query neighbors are printed, and if no plot is being generated, filtering halts at this point.
-- Similarity scores are aggregated across queries, and the `-n` tags closest to all queries are chosen for the PCA.
+- The per-query neighbors are printed, and if no plot is being generated,
+  filtering halts at this point.
+- Similarity scores are aggregated across queries, and the `-n` tags closest to
+  all queries are chosen for the PCA.
 - Only the highest `-N` scoring tags are displayed in the plot.
 
+### `normalize_tags.py`
+
+Tag Normalizer is a powerful command-line tool designed to clean, standardize,
+and normalize e621 tags in text files. By applying a set of customizable rules,
+Tag Normalizer helps maintain consistency and improve the quality of your tag
+data.
+
+#### Usage
+
+```
+python normalize_tags.py <path to input dataset> <path to output normalized tags> -s unknown
+```
+
+Find all `*.txt` and `*.cap*` files in `<path to input dataset>` and write the
+normalized files in `<path to output normalized tags>` while reproducing the
+folder hierarchy. Additionally, `-s unknown` writes to the standard output the
+the top 100 unrecognized tags. `-s meta` will show the top 100 meta tags, while
+`-k 50` alone will show the top 50 for all categories.
+
+You can specify the same folder for input and output, and use `-f` to skip
+confirmation.
+
+#### Configuration
+
+Tag Normalizer uses a TOML configuration file to customize its behavior. By
+default, it looks for `normalize.toml` in the following locations:
+
+1. The path specified by the `-c` or `--config` option
+2. The output directory
+3. The input directory
+4. The current directory (most likely the example one)
+
+Here's a brief overview of the main configuration options:
+
+- `blacklist`: List of tags to remove
+- `blacklist_regexp`: Regular expressions for blacklisting tags
+- `keep_underscores`: List of tags where underscores should be preserved
+- `blacklist_categories`: Categories of tags to remove entirely
+- `remove_parens_suffix_for_categories`: Categories where parenthetical suffixes
+  should be removed
+- `aliases`: Define tag aliases
+- `aliases_overrides`: Define aliases that can override existing tag meanings
+- `renames`: Specify tags to be renamed in the output
+- `use_underscores`: Whether to use underscores or spaces in output tags
+- `keep_implied`: Whether to keep or remove implied tags, may also be a list of
+  tags to keep even when implied by another one
+- `on_alias_conflict`: How to handle conflicts when creating aliases
+- `artist_by_prefix`: Whether to add "by\_" prefix to artist tags
+- `blacklist_implied`: Whether to also blacklist tags implied by blacklisted
+  tags
+
+For a detailed explanation of each option, refer to the comments in the
+`normalize.toml` file. It contains the default values with some opinionated
+changes.
+
+#### Command-line Options
+
+- `-c`, `--config`: Specify a custom configuration file (default: looks for
+  `normalize.toml` in output dir, input dir, or current dir)
+- `-v`, `--verbose`: Enable verbose logging
+- `-f`, `--force`: Don't ask for confirmation when overwriting input files
+- `-b`, `--print-blacklist`: Print the effective list of blacklisted tags
+- `-k`, `--print-topk [N]`: Print the N most common tags (default: 100 if no
+  value provided)
+- `-s`, `--stats-categories <cat>`: Restrict tag count printing to specific
+  categories (or `unknown` for non e621 tags)
+- `-j`, `--print-implied-topk [N]`: Print the N most common implied tags
+  (default: 100 if no value provided)
+
 ### `e6db.utils`
 
 This [module](./e6db/utils/__init__.py) contains utilities for loading the provided data and use it to normalize tag sets.

e6db/utils/__init__.py

@@ -4,8 +4,12 @@ import gzip
 import json
 import warnings
 import math
+import logging
 from typing import Callable, Iterable
 
+
+logger = logging.getLogger(__name__)
+
 tag_categories = [
     "general",
     "artist",
@@ -62,6 +66,7 @@ def load_tags(data_dir):
         tag2idx = json.load(fp)
     with gzip.open(data_dir / "tags_categories.bin.gz", "rb") as fp:
         tag_categories = fp.read()
+    logging.info(f"Loaded {len(idx2tag)} tags, {len(tag2idx)} tag2id mappings")
     return tag2idx, idx2tag, tag_categories
 
 
@@ -81,6 +86,9 @@ def load_implications(data_dir):
     implications = {int(k): v for k, v in implications.items()}
     with gzip.open(data_dir / "implications_rej.json.gz", "rb") as fp:
         implications_rej = json.load(fp)
+    logger.info(
+        f"Loaded {len(implications)} implications + {len(implications_rej)} implication from tags without id"
+    )
     return implications, implications_rej
 
 
@@ -100,7 +108,8 @@ def tag_freq_to_rank(freq: int) -> float:
     )
 
 
-MapFun = Callable[[str, int | None], str | list[str]]
+InMapFun = Callable[[str, int | None], list[str]]
+OutMapFun = Callable[[str], list[str]]
 
 
 class TagNormalizer:
@@ -173,28 +182,37 @@ class TagNormalizer:
                 if on_conflict == "raise":
                     raise ValueError(msg)
                 elif on_conflict == "warn":
-                    warnings.warn(msg)
+                    logger.warning(msg)
                 elif on_conflict == "overwrite_rarest" and to_tid > conflict:
                     continue
                 elif on_conflict != "overwrite":
                     continue
             tag2idx[tag] = to_tid
 
+    def remove_input_mappings(self, tags: str | Iterable[str]):
+        """Remove tag strings from the mapping"""
+        if isinstance(tags, str):
+            tags = (tags,)
+        for tag in tags:
+            if tag in self.tag2idx:
+                del self.tag2idx[tag]
+            else:
+                logger.warning(f"tag {tag!r} is not a valid tag")
+
     def rename_output(self, orig: int | str, dest: str):
         """Change the tag string associated with an id. Used by `decode`."""
         if not isinstance(orig, int):
             orig = self.tag2idx[orig]
         self.idx2tag[orig] = dest
 
-    def map_inputs(self, mapfun: MapFun, on_conflict="raise") -> "TagNormalizer":
+    def map_inputs(self, mapfun: InMapFun, on_conflict="raise") -> "TagNormalizer":
         res = type(self)(({}, self.idx2tag, self.tag_categories))
         for tag, tid in self.tag2idx.items():
             res.add_input_mappings(mapfun(tag, tid), tid, on_conflict=on_conflict)
         return res
 
-    def map_outputs(self, mapfun: MapFun) -> "TagNormalizer":
-        idx2tag_gen = (mapfun(t, i) for i, t in enumerate(self.idx2tag))
-        idx2tag = [t if isinstance(t, str) else t[0] for t in idx2tag_gen]
+    def map_outputs(self, mapfun: OutMapFun) -> "TagNormalizer":
+        idx2tag = [mapfun(t, i) for i, t in enumerate(self.idx2tag)]
         return type(self)((self.tag2idx, idx2tag, self.tag_categories))
 
     def get(self, key: int | str, default=None):
@@ -218,9 +236,9 @@ class TagSetNormalizer:
             data = path_or_data
         self.tag_normalizer, self.implications, self.implications_rej = data
 
-    def map_implicaitons_rej(
-        self, mapfun: MapFun, on_conflict="raise"
-    ) -> "TagSetNormalizer":
+    def map_inputs(self, mapfun: InMapFun, on_conflict="raise") -> "TagSetNormalizer":
+        tag_normalizer = self.tag_normalizer.map_inputs(mapfun, on_conflict=on_conflict)
+
         implications_rej: dict[str, list[str]] = {}
         for tag_string, implied_ids in self.implications_rej.items():
             for new_tag_string in mapfun(tag_string, None):
@@ -235,36 +253,22 @@ class TagSetNormalizer:
                         continue
                 implications_rej[new_tag_string] = implied_ids
 
-        return type(self)((self.tag_normalizer, self.implications, implications_rej))
-
-    def map_tags(
-        self, mapfun: MapFun, map_input=True, map_output=True, on_conflict="raise"
-    ) -> "TagSetNormalizer":
-        """Apply a function to all tag strings.
-
-        The provided function will be run on:
+        res = type(self)((tag_normalizer, self.implications, implications_rej))
+        return res
 
-        * The of list output tag strings,
-        * Keys from the dictionary mapping strings to ids, contains canonical
-          tag and aliases,
-        * Implication source tags that are not used frequently enough to get an
-          id assigned (less than twice).
+    def map_outputs(self, mapfun: OutMapFun) -> "TagSetNormalizer":
+        tag_normalizer = self.tag_normalizer.map_outputs(mapfun)
+        return type(self)((tag_normalizer, self.implications, self.implications_rej))
 
-        The function should return a list, where the first string is the
-        canonical tag used in the output, the others are additional aliases
-        used for recognizing the tag.
-        """
-        tag_normalizer = self.tag_normalizer
-        if map_input:
-            tag_normalizer = tag_normalizer.map_inputs(mapfun, on_conflict=on_conflict)
-        if map_output:
-            tag_normalizer = tag_normalizer.map_outputs(mapfun)
-        res = type(self)((tag_normalizer, self.implications, self.implications_rej))
-        if map_input:
-            res = res.map_implicaitons_rej(mapfun, on_conflict=on_conflict)
-        return res
+    def get_implied(self, tag: int | str) -> list[int]:
+        if isinstance(tag, int):
+            return self.implications.get(tag, ())
+        else:
+            return self.implications_rej.get(tag, ())
 
-    def encode(self, tags: Iterable[str], keep_implied=False):
+    def encode(
+        self, tags: Iterable[str], keep_implied: bool | set[int] = False
+    ) -> tuple[list[int | str], set[int]]:
         """
         Encode a list of string as numerical ids and strip implied tags.
 
@@ -277,17 +281,23 @@ class TagSetNormalizer:
         """
         implied = set()
         res = []
+        encode = self.tag_normalizer.tag2idx.get
+        get_implied = self.implications.get
+        get_implied_rej = self.implications_rej.get
         for tag in tags:
-            tag = self.tag_normalizer.encode(tag, tag)
+            tag = encode(tag, tag)
             implied.update(
-                self.implications.get(tag, ())
+                get_implied(tag, ())
                 if isinstance(tag, int)
-                else self.implications_rej.get(tag, ())
+                else get_implied_rej(tag, ())
             )
             res.append(tag)
         if not keep_implied:
             res = [t for t in res if t not in implied]
+        elif isinstance(keep_implied, set):
+            res = [t for t in res if t not in implied or t in keep_implied]
         return res, implied
 
-    def decode(self, tags):
-        return [self.tag_normalizer.decode(t) for t in tags]
+    def decode(self, tags: Iterable[int | str]) -> list[str]:
+        idx2tag = self.tag_normalizer.idx2tag
+        return [idx2tag[t] if isinstance(t, int) else t for t in tags]

normalize.toml

@@ -0,0 +1,92 @@
+# Tag Normalization Configuration
+
+# Blacklist: A list of tags to be removed during normalization
+# These tags will be completely excluded from the output
+# Default: ["invalid tag"]
+blacklist = [
+    "invalid tag",
+    "by conditional dnp",
+    "hi res",
+    "absurd res",
+    "superabsurd res",
+    "4k",
+    "uncensored",
+    "ambiguous gender",
+    "translation edit",
+    "story in description",
+    "non- balls",
+    "non- nipples",
+    "non- breasts",
+    "feet out of frame",
+    "funny_post_number",
+    "tagme",
+    "edit_request",
+]
+
+# Blacklist Regular Expressions: Tags matching these regexes will be removed
+# These are full-match regexes, so they must match the entire tag
+blacklist_regexp = [
+    "(\\d+s?|\\d+:\\d+)", # Numbers, years and aspect ratio
+    ".*?_at_source",
+]
+
+# Keep Underscores: List of tags where underscores should be preserved
+# By default, underscores are replaced with spaces unless specified here
+keep_underscores = ["rating_explicit", "rating_questionable", "rating_safe"]
+
+# Blacklist Categories: Entire categories of tags to be removed
+# Common categories include "artist", "character", "copyright", "general", "meta", "species", "pool"
+blacklist_categories = ["pool"]
+
+# Remove Parentheses Suffix: Categories where parenthetical suffixes should be removed
+# E.g., "character_(series)" becomes just "character" if does not conflicts with
+# an existing tag/alias (for on_alias_conflict="ignore")
+remove_parens_suffix_for_categories = [
+    "artist",
+    "character",
+    "copyright",
+    "lore",
+    "species",
+]
+
+# Use Underscores: Determines whether to use underscores or spaces in output tags
+# Default: false (use spaces)
+use_underscores = false
+
+# Keep Implied: Whether to keep implied tags or remove them. Can also be a list of tags
+# Default: false (remove implied tags)
+keep_implied = false
+
+# On Alias Conflict: How to handle conflicts when creating aliases
+# Options: "silent", "overwrite", "overwrite_rarest", "warn", "raise"
+# Default: "ignore" meaning do not modify the alias
+on_alias_conflict = "ignore"
+
+# Artist By Prefix: Whether to add "by_" prefix to artist tags
+# Default: true
+artist_by_prefix = true
+
+# Blacklist Implied: Whether to also blacklist tags implied by blacklisted tags
+# Default: true
+blacklist_implied = true
+
+# Aliases: Define tag aliases (alternative names for the same tag)
+# The key is the alias, and the value is the target tag
+[aliases]
+explicit = "rating_explicit"
+score_explicit = "rating_explicit"
+score_safe = "rating_safe"
+score_questionable = "rating_questionable"
+
+# Aliases Overrides: Similar to aliases, but can override existing tag meanings
+# Use this carefully as it can change the semantics of existing tags
+[aliases_overrides]
+safe = "rating_safe"
+questionable = "rating_questionable"
+
+# Renames: Specify tags to be renamed in the output
+# This also causes them to be recognized as aliases in the input (for idempotency)
+# The key is the original tag name, and the value is the new name
+[renames]
+domestic_cat = "cat"
+domestic_dog = "dog"

normalize_tags.py

@@ -3,152 +3,206 @@
 import argparse
 import logging
 import re
-import sys
 import time
 from collections import Counter
-from functools import cache
 from itertools import chain
 from pathlib import Path
 
-import e6db
+try:
+    from tqdm import tqdm
+except ImportError:
+    tqdm = lambda x: x
+
+try:
+    import tomllib
+except ImportError:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        import toml as tomllib
+
 from e6db.utils import TagSetNormalizer, tag_categories, tag_category2id
 
-data_dir = Path(__file__).resolve().parent / "data"
+DATA_DIR = Path(__file__).resolve().parent / "data"
+RE_PARENS_SUFFIX = re.compile(r"_\([^)]+\)$")
 
 
-def make_tagset_normalizer(warn_conflict=True) -> TagSetNormalizer:
+def make_tagset_normalizer(config: dict) -> TagSetNormalizer:
     """
     Create a TagSetNormalizer for encoding/decoding tags to and from integers.
-    Pre-configures it with more aliases and customize the spelling of some tags in the output.
+    Configures it based on the provided config.
     """
-    tagset_normalizer = TagSetNormalizer(data_dir)
-    tagid2cat = tagset_normalizer.tag_normalizer.tag_categories
+    # This loads all the aliases and implications
+    tagset_normalizer = TagSetNormalizer(DATA_DIR)
 
+    tagid2cat = tagset_normalizer.tag_normalizer.tag_categories
     cat_artist = tag_category2id["artist"]
-    cat_lore = tag_category2id["lore"]
-
-    @cache
-    def tag_mapfun(tag_underscores, tid):
-        """
-        Maps raw e621 tags to more natural forms. The input will be from:
-
-        * The list output tag strings,
-        * Keys from the dictionary mapping strings to ids, contains canonical
-          tag and aliases,
-        * Implication source tags that are not used frequently enough to get an
-          id.
-
-        Returns a list, where the first string is the canonical tag used in the
-        output, the others are additional aliases used for recognizing the tag.
-        """
+    cat2suffix = {
+        tag_category2id["character"]: "_(character)",
+        tag_category2id["lore"]: "_(lore)",
+        tag_category2id["species"]: "_(species)",
+        tag_category2id["copyright"]: "_(copyright)",
+    }
+
+    # Create additional aliases for tags using simple rules
+    def input_map(tag, tid):
+        yield tag
+
+        # Make an alias without parentheses, it might conflict but we'll handle
+        # it depending on `on_alias_conflict` config value.
+        without_suffix = RE_PARENS_SUFFIX.sub("", tag)
+        had_suffix = tag != without_suffix
+        if had_suffix:
+            yield without_suffix
+
+        # Add an alias with the suffix (special case for artist)
         cat = tagid2cat[tid] if tid is not None else -1
-        tag = tag_underscores.replace("_", " ")
-        tags = [tag, tag_underscores]
         if cat == cat_artist:
-            if not tag.startswith("by "):
-                # 'by ' is used in the output tags
-                tag_without_suffix = tag.removesuffix(" (artist)")
-                tags.insert(0, f"by {tag_without_suffix}")
-            if not tag.endswith("(artist)"):
-                artist = tag.removeprefix("by ")
-                tags.append(f"{artist} (artist)")
-        elif cat == cat_lore and not tag.endswith(" (lore)"):
-            tags.append(f"{tag} (lore)")
+            artist = without_suffix.removeprefix("by_")
+            if artist != without_suffix:
+                yield artist
+                if not had_suffix:
+                    yield f"{artist}_(artist)"
+            else:
+                yield f"by_{artist}"
+                if not had_suffix:
+                    yield f"by_{artist}_(artist)"
+        elif not had_suffix:
+            suffix = cat2suffix.get(cat)
+            if suffix is not None:
+                yield f"{without_suffix}{suffix}"
 
         # Recognize tags where ':' were replaced by a space (aspect ratio)
         if ":" in tag:
-            tags.append(tag.replace(":", " "))
-
-        # Recognize tags that have escaped parentheses
-        for t in tags.copy():
-            escaped = t.replace("(", "\\(").replace(")", "\\)")
-            if escaped != t:
-                tags.append(escaped)
-
-        # Example of debugging:
-        # if "digital media" in tag:
-        #     print(tags)
-        return tags
-
-    tagset_normalizer = tagset_normalizer.map_tags(
-        tag_mapfun,
-        # on_conflictc choices: "silent", "overwrite", "overwrite_rarest",
-        # warn", "raise", use "warn" to debug conflicts.
-        on_conflict="warn" if warn_conflict else "overwrite_rarest",
+            yield tag.replace(":", " ")
+
+    on_alias_conflict = config.get("on_alias_conflict", None)
+    tagset_normalizer = tagset_normalizer.map_inputs(
+        input_map,
+        # on_conflict choices: "silent", "overwrite", "overwrite_rarest",
+        # "warn", "raise", use "warn" to debug conflicts.
+        on_conflict=on_alias_conflict or "ignore",
     )
-
-    # Add some underscores back in the output, for example "rating explicit"
-    # will be exported as "rating_explicit"
     tag_normalizer = tagset_normalizer.tag_normalizer
-    tag_normalizer.rename_output("rating explicit", "rating_explicit")
-    tag_normalizer.rename_output("rating questionable", "rating_questionable")
-    tag_normalizer.rename_output("rating safe", "rating_safe")
-
-    # Custom mappings, for example "explicit" will be interpreted as
-    # "rating_explicit"
-    tag_normalizer.add_input_mappings("explicit", "rating_explicit")
-    tag_normalizer.add_input_mappings("score_explicit", "rating_explicit")
-    tag_normalizer.add_input_mappings("safe", "rating_safe", on_conflict="overwrite")
-    tag_normalizer.add_input_mappings("score_safe", "rating_safe")
-    tag_normalizer.add_input_mappings(
-        "questionable", "rating_questionable", on_conflict="overwrite"
+    tag2id = tag_normalizer.tag2idx
+
+    # Apply custom input mappings
+    for antecedent, consequent in config.get("aliases", {}).items():
+        antecedent = antecedent.replace(" ", "_")
+        consequent = consequent.replace(" ", "_")
+        tag_normalizer.add_input_mappings(
+            antecedent, consequent, on_conflict=on_alias_conflict or "warn"
+        )
+    for antecedent, consequent in config.get("aliases_overrides", {}).items():
+        antecedent = antecedent.replace(" ", "_")
+        consequent = consequent.replace(" ", "_")
+        tag_normalizer.add_input_mappings(
+            antecedent, consequent, on_conflict="overwrite"
+        )
+
+    # Apply custom output renames as opposite aliases to ensure
+    # idempotence:
+    output_renames = {
+        old.replace(" ", "_"): new.replace(" ", "_")
+        for old, new in config.get("renames", {}).items()
+    }
+    for old, new in output_renames.items():
+        tag_normalizer.add_input_mappings(new, old)
+
+    # Remove specified aliases
+    for tag in config.get("remove_aliases", []):
+        tag = tag.replace(" ", "_")
+        tag_normalizer.remove_input_mappings(tag)
+
+    # Apply rule based output renames
+    remove_suffix_for_cats = config.get(
+        "remove_parens_suffix_for_categories",
+        ["artist", "character", "copyright", "lore", "species"],
     )
-    tag_normalizer.add_input_mappings("score_questionable", "rating_questionable")
+    remove_suffix_for_cats = {tag_category2id[c] for c in remove_suffix_for_cats}
+    artist_by_prefix = config.get("artist_by_prefix", True)
+
+    def map_output(tag, tid):
+        cat = tagid2cat[tid] if tid is not None else -1
+        if cat in remove_suffix_for_cats:
+            without_suffix = RE_PARENS_SUFFIX.sub("", tag)
+            if tag != without_suffix and tag2id.get(without_suffix) == tid:
+                tag = without_suffix
+        if cat == cat_artist and artist_by_prefix and not tag.startswith("by_"):
+            tag_wby = f"by_{tag}"
+            if tag2id.get(tag_wby) == tid:
+                tag = tag_wby
+        return tag
+
+    tagset_normalizer = tagset_normalizer.map_outputs(map_output)
+    tag2id = tagset_normalizer.tag_normalizer.tag2idx
+
+    # Apply custom output renames
+    for old, new in output_renames.items():
+        if tag2id[old] == tag2id[new]:
+            tag_normalizer.rename_output(old, new)
+        else:
+            logging.warning(
+                f"Cannot rename {old} -> {new}: old tag id={tag2id[old]} vs. new tag id={tag2id[new]})"
+            )
 
     return tagset_normalizer
 
 
 def make_blacklist(
     tagset_normalizer: TagSetNormalizer,
-    additional_tags=None,
-    additional_regexps=None,
-    override_base=False,
+    config: dict,
+    print_blacklist=False,
 ):
-    if override_base:
-        blacklist = set()
-        re_blacklist = set()
-    else:
-        # Base blacklist
-        blacklist = {
-            "invalid tag",
-            "by conditional dnp",
-            "hi res",
-            "absurd res",
-            "superabsurd res",
-            "4k",
-            "uncensored",
-            "ambiguous gender",
-            "translation edit",
-            "story in description",
-            "non- balls",
-            "non- nipples",
-            "non- breasts",
-            "feet out of frame",
-        }
-        # Base regexp
-        re_blacklist = {r"(\d+|\d+:\d+)"}
-
-    # Add additional tags and regexps
-    if additional_tags:
-        blacklist.update(additional_tags)
-    if additional_regexps:
-        re_blacklist.update(additional_regexps)
+    if print_blacklist:
+        print("\n🚫 Blacklisted tags:")
 
     all_tags = tagset_normalizer.tag_normalizer.idx2tag
+    encode = tagset_normalizer.tag_normalizer.encode
+    decode = tagset_normalizer.tag_normalizer.decode
+    get_implied = tagset_normalizer.get_implied
+
+    blacklist = set()
+    for tag in config.get("blacklist", ["invalid tag"]):
+        tag = tag.replace(" ", "_")
+        encoded_tag = encode(tag, tag)
+        blacklist.add(encoded_tag)
+        if print_blacklist:
+            decoded_tag = decode(encoded_tag)
+            if tag != decoded_tag:
+                print(f"   {tag} -> {decoded_tag}")
+            else:
+                print(f"   {tag}")
+
+    for regexp in config.get("blacklist_regexp", []):
+        regexp = regexp.replace(" ", "_")
+        cregexp = re.compile(regexp)
+        for tid, tag in enumerate(all_tags):
+            if cregexp.fullmatch(tag):
+                blacklist.add(tid)
+                if print_blacklist:
+                    print(f'   {tag} (r"{regexp})"')
+
+    implied = set()
+    if config.get("blacklist_implied", True):
+        for tag in blacklist:
+            tag_implied = get_implied(tag)
+            implied.update(tag_implied)
+            if print_blacklist:
+                for implied_tag in tag_implied:
+                    print(f"   {decode(implied_tag)} (implied by {decode(tag)})")
+    blacklist |= implied
 
-    # Apply regexp blacklist
-    for pattern in re_blacklist:
-        re_pattern = re.compile(pattern)
-        blacklist.update(t for t in all_tags if re_pattern.fullmatch(t))
-
-    # blacklist tags ending with ' at source'
-    blacklist.update(t for t in all_tags if t.endswith(" at source"))
-
-    # Encode the blacklist to ids
-    blacklist, implied = tagset_normalizer.encode(blacklist)
-
-    # Also blacklist tags implied by blacklisted tags
-    blacklist = set(blacklist) | implied
+    tagid2cat = tagset_normalizer.tag_normalizer.tag_categories
+    blacklist_categories = {
+        tag_category2id[c] for c in config.get("blacklist_categories", ["pool"])
+    }
+    if blacklist_categories:
+        for tid, cat in enumerate(tagid2cat):
+            if cat in blacklist_categories:
+                blacklist.add(tid)
+                if print_blacklist:
+                    print(f"   {tagid2cat[tid]} (cat:{tag_categories[cat]})")
 
     return blacklist
 
@@ -158,8 +212,11 @@ RE_SEP = re.compile(r"[,\n]")  # Split on commas and newlines
 
 def load_caption(fp: Path):
     """
-    Load caption from file.
-    Caption are formatted like this: tag1, tag2, caption1., caption2.
+    Load caption from file and split out caption sentences.
+
+    Caption are formatted like this: tag1, tag2, sentence caption1., sentence
+    caption2. Optional sentence captions ending with "." are split out so that
+    they are left untouched.
     """
     tags, captions = [], []
     with open(fp, "rt") as fd:
@@ -178,14 +235,26 @@ def process_directory(
     dataset_root: Path,
     output_dir: Path,
     tagset_normalizer: TagSetNormalizer,
+    config: dict,
     blacklist: set = set(),
-    keep_implied=True,
 ):
+    use_underscores = config.get("use_underscores", False)
+    keep_underscores = set(config.get("keep_underscores", ()))
+    keep_implied = config.get("keep_implied", False)
+    if isinstance(keep_implied, list):
+        encode = tagset_normalizer.tag_normalizer.encode
+        keep_implied = {encode(t, t) for t in keep_implied}
+
+    # Running stats
     counter = Counter()
     implied_counter = Counter()
     processed_files = 0
     skipped_files = 0
-    for file in chain(dataset_root.glob("**/*.txt"), dataset_root.glob("**/*.cap*")):
+    blacklist_instances = 0
+    implied_instances = 0
+
+    files = [*dataset_root.glob("**/*.txt"), *dataset_root.glob("**/*.cap*")]
+    for file in tqdm(files):
         if "sample-prompts" in file.name:
             skipped_files += 1
             continue
@@ -193,8 +262,20 @@ def process_directory(
         orig_tags = tags
 
         # Convert tags to ids, separate implied tags
+        tags = [
+            t.lower().replace(" ", "_").replace(r"\(", "(").replace(r"\)", ")")
+            for t in tags
+        ]
+        original_len = len(tags)
+
+        # Encode to integer ids and strip implied tags
         tags, implied = tagset_normalizer.encode(tags, keep_implied=keep_implied)
+        implication_filtered_len = len(tags)
+        implied_instances += original_len - implication_filtered_len
+
+        # Remove blacklisted tags
         tags = [t for t in tags if t not in blacklist]
+        blacklist_instances += implication_filtered_len - len(tags)
 
         # Count tags
         counter.update(tags)
@@ -202,6 +283,10 @@ def process_directory(
 
         # Convert back to strings
         tags = tagset_normalizer.decode(tags)
+        if not use_underscores:
+            tags = [
+                t.replace("_", " ") if t not in keep_underscores else t for t in tags
+            ]
         if tags == orig_tags:
             skipped_files += 1
             continue
@@ -214,10 +299,24 @@ def process_directory(
             fd.write(result)
         processed_files += 1
 
-    return counter, implied_counter, processed_files, skipped_files
+    return dict(
+        counter=counter,
+        implied_counter=implied_counter,
+        processed_files=processed_files,
+        skipped_files=skipped_files,
+        blacklist_instances=blacklist_instances,
+        implied_instances=implied_instances,
+    )
 
 
-def print_topk(counter, tagset_normalizer, n=10, categories=None, implied=False):
+def print_topk(
+    counter: Counter,
+    tagset_normalizer: TagSetNormalizer,
+    config: dict,
+    n=10,
+    categories=None,
+    implied=False,
+):
     if implied:
         implied = "implied "
     else:
@@ -228,6 +327,9 @@ def print_topk(counter, tagset_normalizer, n=10, categories=None, implied=False)
     else:
         print(f"\nTop {n} most common {implied}tags:")
 
+    use_underscores = config.get("use_underscores", True)
+    keep_underscores = config.get("keep_underscores", set())
+
     filtered_counter = counter
     if categories:
         filtered_counter = Counter()
@@ -245,15 +347,13 @@ def print_topk(counter, tagset_normalizer, n=10, categories=None, implied=False)
         if isinstance(tag, int):
             tag_string = tagset_normalizer.tag_normalizer.decode(tag)
             cat = tag_categories[tagset_normalizer.tag_normalizer.tag_categories[tag]]
-            print(f"   {tag_string:<30} count={count:<7} (e621:{cat})")
+            source = f"e621:{cat}"
         else:
-            print(f"   {tag:<30} count={count:<7} (unknown)")
-
-
-def print_blacklist(blacklist, tagset_normalizer):
-    print("\n🚫 Blacklisted tags:")
-    for tag_str in sorted(tagset_normalizer.decode(blacklist)):
-        print(f"   {tag_str}")
+            tag_string = tag
+            source = "unknown"
+        if not use_underscores and tag_string not in keep_underscores:
+            tag_string = tag_string.replace("_", " ")
+        print(f"   {tag_string:<30} count={count:<7} ({source})")
 
 
 def setup_logger(verbose):
@@ -262,6 +362,20 @@ def setup_logger(verbose):
     return logging.getLogger(__name__)
 
 
+def ask_for_confirmation(prompt, default=False):
+    if default:
+        prompt = f"{prompt} (Y/n): "
+    else:
+        prompt = f"{prompt} (y/N): "
+
+    response = input(prompt).strip().lower()
+
+    if response not in "yn":
+        return default
+
+    return response == "y"
+
+
 def main():
     parser = argparse.ArgumentParser(
         description="🏷️  Tag Normalizer - Clean and normalize your tags with ease!"
@@ -273,31 +387,23 @@ def main():
         "output_dir", type=Path, help="Output directory for normalized tag files"
     )
     parser.add_argument(
-        "-v", "--verbose", action="store_true", help="Enable verbose logging"
-    )
-    parser.add_argument(
-        "-i", "--keep-implied", action="store_true", help="Keep implied tags"
-    )
-    parser.add_argument(
-        "-b",
-        "--additional-blacklist",
-        action="append",
-        help="Additional tags to add to the blacklist",
+        "-c",
+        "--config",
+        type=Path,
+        help="Toml configuration file, defaults to output_dir/normalize.toml, input_dir/normalize.toml or ./normalize.toml",
+        default=None,
     )
     parser.add_argument(
-        "-r",
-        "--additional-blacklist-regexp",
-        action="append",
-        help="Additional regular expressions for blacklisting tags",
+        "-v", "--verbose", action="store_true", help="Enable verbose logging"
     )
     parser.add_argument(
-        "-O",
-        "--override-base-blacklist",
+        "-f",
+        "--force",
         action="store_true",
-        help="Override the base blacklist and regexp with only the provided additions",
+        help="Don't ask for confirmation for clobbering input files",
     )
     parser.add_argument(
-        "--print-blacklist",
+        "-b", "--print-blacklist",
         action="store_true",
         help="Print the effective list of blacklisted tags",
     )
@@ -318,70 +424,108 @@ def main():
         help="Print the N most common implied tags (default: 100 if flag is used without a value)",
     )
     parser.add_argument(
-        "-c",
+        "-s",
         "--stats-categories",
         action="append",
         choices=list(tag_category2id.keys()) + ["unknown"],
         help="Restrict tag count printing to specific categories or 'unknown'",
     )
-    parser.add_argument(
-        "--print-conflicts",
-        action="store_true",
-        help="Print the conflicts encountered during the construction of the normalization mapping (useful for debugging it)",
-    )
     args = parser.parse_args()
-
     logger = setup_logger(args.verbose)
 
+    # Validate input/output directories
+    input_dir = args.input_dir.resolve()
+    output_dir = args.output_dir.resolve()
+    if not input_dir.is_dir():
+        logger.error(f"Input directory does not exist: {input_dir}")
+        exit(1)
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        logger.error(f"Could not create output directory {output_dir}: {e}")
+        exit(1)
     logger.info("🚀 Starting Tag Normalizer")
-    logger.info(f"Input directory: {args.input_dir}")
-    logger.info(f"Output directory: {args.output_dir}")
+    logger.info(f"Input directory: {input_dir}")
+    logger.info(f"Output directory: {output_dir}")
+
+    if input_dir == output_dir and not args.force:
+        if not ask_for_confirmation(
+            "Input and output directories are the same. This will clobber the input directory. Are you sure you want to continue?",
+            default=False,
+        ):
+            exit(0)
+
+    # Load config file
+    for config_path in [
+        args.config,
+        output_dir / "normalize.toml",
+        input_dir / "normalize.toml",
+        Path(".") / "normalize.toml",
+    ]:
+        if config_path is None:
+            continue
+        if config_path.exists():
+            config_path = config_path.resolve()
+            break
+    else:
+        logger.error(f"Could not find a config file in {input_dir}, {output_dir} or ./")
+        exit(1)
+    logger.info(f"🔧 Using config file: {config_path}")
+    with open(config_path, "rb") as f:
+        config = tomllib.load(f)
 
     logger.info("🔧 Initializing tag normalizer...")
     start_time = time.time()
-    tagset_normalizer = make_tagset_normalizer(warn_conflict=args.print_conflicts)
-    logging.info(f"  Data loaded in {time.time() - start_time:.2f} seconds")
+    tagset_normalizer = make_tagset_normalizer(config)
+    logging.info(f"✅ Data loaded in {time.time() - start_time:.2f} seconds")
 
     logger.info("🚫 Creating blacklist...")
     blacklist = make_blacklist(
         tagset_normalizer,
-        additional_tags=args.additional_blacklist,
-        additional_regexps=args.additional_blacklist_regexp,
-        override_base=args.override_base_blacklist,
+        config,
+        print_blacklist=args.print_blacklist,
     )
     logger.info(f"Blacklist size: {len(blacklist)} tags")
-    if args.print_blacklist:
-        print_blacklist(blacklist, tagset_normalizer)
 
     logger.info("🔍 Processing files...")
     start_time = time.time()
-    counter, implied_counter, processed_files, skipped_files = process_directory(
-        args.input_dir,
-        args.output_dir,
+    stats = process_directory(
+        input_dir,
+        output_dir,
         tagset_normalizer,
+        config,
         blacklist=blacklist,
-        keep_implied=args.keep_implied,
     )
 
     logger.info(
         f"✅ Processing complete! Time taken: {time.time() - start_time:.2f} seconds"
     )
-    logger.info(f"Files processed: {processed_files}")
-    logger.info(f"Files skipped (no changes): {skipped_files}")
-    logger.info(f"Total unique tags: {len(counter)}")
-    logger.info(f"Total tag occurrences: {sum(counter.values())}")
-    if args.print_topk:
+    logger.info(f"Files modified: {stats['processed_files']}")
+    logger.info(f"Files skipped (no changes): {stats['skipped_files']}")
+    counter = stats["counter"]
+    logger.info(f"Unique tags: {len(counter)}")
+    logger.info(f"Tag occurrences: {sum(counter.values())}")
+    unknown_counter = [count for t, count in counter.items() if not isinstance(t, int)]
+    logger.info(f"Unknown tags: {len(unknown_counter)}")
+    logger.info(f"Unknown tags occurrences: {sum(unknown_counter)}")
+    logger.info(f"Removed by blacklist: {stats['blacklist_instances']}")
+    logger.info(f"Removed by implication: {stats['implied_instances']}")
+    if args.print_topk or args.stats_categories:
+        if not args.print_topk:
+            args.print_topk = 100
         print_topk(
             counter,
             tagset_normalizer,
-            args.print_topk,
-            args.stats_categories,
+            config,
+            n=args.print_topk,
+            categories=args.stats_categories,
         )
     if args.print_implied_topk:
         print_topk(
-            implied_counter,
+            stats["implied_counter"],
             tagset_normalizer,
-            args.print_implied_topk,
+            config,
+            n=args.print_implied_topk,
             implied=True,
         )
 

query_tags.py

@@ -61,9 +61,26 @@ def dothething(args):
 
     # Deduplicate, global top-k
     neigh_idxs = np.unique(neigh_idxs)
-    scores = scores[neigh_idxs, :].sum(axis=1)
+    scores = scores[neigh_idxs, :].mean(axis=1)
+    rej = None
     if len(neigh_idxs) > global_topk:
-        neigh_idxs = neigh_idxs[np.argpartition(-scores, global_topk)[:global_topk]]
+        partition = np.argpartition(-scores, global_topk)
+        rej = neigh_idxs[partition[global_topk:]]
+        rej_scores = scores[partition[global_topk:]]
+        scores = scores[partition[:global_topk]]
+        neigh_idxs = neigh_idxs[partition[:global_topk]]
+
+    tag_list = " ".join(
+        f"{idx2tag[i]} ({format_tagfreq(tag_rank_to_freq(i))})"
+        for s, i in zip(scores, neigh_idxs)
+    )
+    print("accepted:", tag_list)
+    if rej is not None:
+        tag_list = " ".join(
+            f"{idx2tag[i]} ({format_tagfreq(tag_rank_to_freq(i))}, {s})"
+            for s, i in zip(rej_scores, rej)
+        )
+        print("rejected:", tag_list)
 
     idxs = np.concatenate([sel_idxs, neigh_idxs])
     query_slice = slice(None, len(sel_idxs))