utils: tag normalization

data/implications.json.gz

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

data/implications_rej.json.gz

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

e6db/utils/__init__.py

@@ -2,11 +2,13 @@
 from pathlib import Path
 import gzip
 import json
+import warnings
+from typing import Callable, Iterable
 
 tag_categories = [
     "general",
     "artist",
-    "",  # Invalid catid
+    None,  # Invalid catid
     "copyright",
     "character",
     "species",
@@ -19,7 +21,7 @@ tag_category2id = {v: k for k, v in enumerate(tag_categories) if v}
 tag_categories_colors = [
     "#b4c7d9",
     "#f2ac08",
-    "black",  # Invalid catid
+    None,  # Invalid catid
     "#d0d",
     "#0a0",
     "#ed5d1f",
@@ -31,7 +33,7 @@ tag_categories_colors = [
 tag_categories_alt_colors = [
     "#2e76b4",
     "#fbd67f",
-    "black",  # Invalid catid
+    None,  # Invalid catid
     "#ff5eff",
     "#2bff2b",
     "#f6b295",
@@ -43,6 +45,13 @@ tag_categories_alt_colors = [
 
 
 def load_tags(data_dir):
+    """
+    Load tag data, returns a tuple `(tag2idx, idx2tag, tag_categories)`
+
+    * `tag2idx`: dict mapping tag and aliases to numerical ids
+    * `idx2tag`: list mapping numerical id to tag string
+    * `tag_categories`: byte string mapping numerical id to categories
+    """
     data_dir = Path(data_dir)
     with gzip.open(data_dir / "tags.txt.gz", "rt") as fd:
         idx2tag = fd.read().split("\n")
@@ -53,3 +62,206 @@ def load_tags(data_dir):
     with gzip.open(data_dir / "tags_categories.bin.gz", "rb") as fp:
         tag_categories = fp.read()
     return tag2idx, idx2tag, tag_categories
+
+
+def load_implications(data_dir):
+    """
+    Load implication mappings. Returns a tuple `(implications, implications_rej)`
+
+    * `implications`: dict mapping numerical ids to a list of implied numerical
+      ids
+    * `implications_rej`: dict mapping tag to a list of implied numerical ids
+    keys in implications_rej are tag that have a very little usage (less than 2
+    posts) and don't have numerical ids associated with them.
+    """
+    with gzip.open(data_dir / "implications.json.gz", "rb") as fp:
+        implications = json.load(fp)
+    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)
+    return implications, implications_rej
+
+
+MapFun = Callable[[str, int | None], str | list[str]]
+
+
+#
+# WARNING: this API is goofy and will chang soon
+#
+class TagNormalizer:
+    """
+    Map tag strings to numerical ids, and vice versa.
+
+    Multiple strings can be mapped to a single id, while each id map to a single
+    string. As a result, the encode/decode process can be used to normalize
+    tags.
+    """
+
+    def __init__(self, path_or_data: str | Path | tuple[dict, list, bytes]):
+        if isinstance(path_or_data, (Path, str)):
+            data = load_tags(path_or_data)
+        else:
+            data = path_or_data
+        self.tag2idx, self.idx2tag, self.tag_categories = data
+
+    def encode(self, tag: str, default=None):
+        "Convert tag string to numerical id"
+        return self.tag2idx.get(tag, default)
+
+    def decode(self, tag: int | str):
+        "Convert numerical id to tag string"
+        if isinstance(tag, str):
+            return tag
+        return self.idx2tag[tag]
+
+    def get_reverse_mapping(self):
+        """Return a list mapping id -> [ tag strings ]"""
+        res = [[] for i in range(len(self.idx2tag))]
+        for tag, tid in self.tag2idx.items():
+            res[tid].append(tag)
+        return res
+
+    def add_input_mappings(
+        self, tags: str | Iterable[str], to_tid: int | str, on_conflict="raise"
+    ):
+        """Associate tag strings to an id for recognition by `encode`
+
+        `on_conflict` defines what to do when the tag string is already mapped
+        to a different id:
+
+        * "raise": raise an ValueError (default)
+        * "warn": raise a warning
+        * "overwrite_rarest": make the tag point to the most frequently used tid
+        * "overwrite": silently overwrite the mapping
+        * "silent", or any other string: don't set the mapping
+        """
+        tag2idx = self.tag2idx
+        if not isinstance(to_tid, int):
+            to_tid = tag2idx[to_tid]
+        if isinstance(tags, str):
+            tags = (tags,)
+        for tag in tags:
+            conflict = tag2idx.get(tag, to_tid)
+            if conflict != to_tid:
+                msg = f"mapping {tag!r}->{self.idx2tag[to_tid]!r}({to_tid}) conflicts with previous mapping {tag!r}->{self.idx2tag[conflict]!r}({conflict})."
+                if on_conflict == "raise":
+                    raise ValueError(msg)
+                elif on_conflict == "warn":
+                    warnings.warn(msg)
+                elif on_conflict == "overwrite_rarest" and to_tid > conflict:
+                    continue
+                elif on_conflict != "overwrite":
+                    continue
+            tag2idx[tag] = to_tid
+
+    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":
+        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]
+        return type(self)((self.tag2idx, idx2tag, self.tag_categories))
+
+    def get(self, key: int | str, default=None):
+        """
+        Returns the string tag associated with a numerical id, or conversely,
+        the id associated with a tag.
+        """
+        if isinstance(key, int):
+            idx2tag = self.idx2tag
+            if key >= len(idx2tag):
+                return default
+            return idx2tag[key]
+        return self.tag2idx.get(key, default)
+
+
+class TagSetNormalizer:
+    def __init__(self, path_or_data: str | Path | tuple[TagNormalizer, dict, dict]):
+        if isinstance(path_or_data, (Path, str)):
+            data = TagNormalizer(path_or_data), *load_implications(path_or_data)
+        else:
+            data = path_or_data
+        self.tag_normalizer, self.implications, self.implications_rej = data
+
+    def map_implicaitons_rej(
+        self, mapfun: MapFun, on_conflict="raise"
+    ) -> "TagSetNormalizer":
+        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):
+                conflict = implications_rej.get(new_tag_string, implied_ids)
+                if conflict != implied_ids:
+                    msg = f"mapping {tag_string!r}->{implied_ids} conflicts with previous mapping {tag_string!r}->{conflict}."
+                    if on_conflict == "raise":
+                        raise ValueError(msg)
+                    elif on_conflict == "warn":
+                        warnings.warn(msg)
+                    elif on_conflict != "overwrite":
+                        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:
+
+        * 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).
+
+        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 encode(self, tags: Iterable[str], keep_implied=False):
+        """
+        Encode a list of string as numerical ids and strip implied tags.
+
+        Unknown tags are returned as strings.
+
+        Returns :
+
+        * a list of tag ids and unknown tag strings,
+        * a list of implied tag ids.
+        """
+        implied = set()
+        res = []
+        for tag in tags:
+            tag = self.tag_normalizer.encode(tag, tag)
+            implied.update(
+                self.implications.get(tag, ())
+                if isinstance(tag, int)
+                else self.implications_rej.get(tag, ())
+            )
+            res.append(tag)
+        if not keep_implied:
+            res = [t for t in res if t not in implied]
+        return res, implied
+
+    def decode(self, tags):
+        return [self.tag_normalizer.decode(t) for t in tags]

notebooks/Normalize tags T2I dataset.ipynb

@@ -0,0 +1,417 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cfb2d5b1-bcc3-423f-959a-cc9070546c9f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload explicit\n",
+    "\n",
+    "from itertools import chain\n",
+    "from collections import Counter\n",
+    "from functools import cache\n",
+    "import re\n",
+    "from pathlib import Path\n",
+    "\n",
+    "\n",
+    "from prelib import data_dir\n",
+    "%aimport e6db.utils\n",
+    "from e6db.utils import TagSetNormalizer, tag_categories, tag_category2id"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e388984c-819f-4aac-8fcf-22c70d266b91",
+   "metadata": {},
+   "source": [
+    "# Create the mappings\n",
+    "\n",
+    "By default, the tag strings in this dataset are using the raw e621 format, with underscores. `TagNormalizer` enables renaming the tags and adding new spelling as aliases.\n",
+    "\n",
+    "The tag formating choices made here are specific to [this dataset](https://huggingface.co/datasets/k4d3/furry) meant for PDXL training with sd-scripts. You should adapt it to your own dataset, model and trainer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5d43e7c4-2216-4928-bb24-347fb287c07d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cat_artist = e6db.utils.tag_category2id['artist']\n",
+    "cat_lore = e6db.utils.tag_category2id['lore']\n",
+    "\n",
+    "tagset_normalizer = e6db.utils.TagSetNormalizer(data_dir)\n",
+    "tagid2cat = tagset_normalizer.tag_normalizer.tag_categories\n",
+    "\n",
+    "@cache\n",
+    "def tag_mapfun(tag_underscores, tid):\n",
+    "    \"\"\"\n",
+    "    Maps raw e621 tags to more natural forms.\n",
+    "    Will be run on:\n",
+    "\n",
+    "    * The list of output tag strings,\n",
+    "    * Keys from the dictionary mapping strings to ids, contains canonical tag and aliases,\n",
+    "    * Implication source tags that are not used frequently enough to get an id.\n",
+    "\n",
+    "    Returns a list, where the first string is the canonical tag used in the output,\n",
+    "    the others are additional aliases used for recognizing the tag.\n",
+    "    \"\"\"\n",
+    "    cat = tagid2cat[tid] if tid is not None else -1\n",
+    "    tag = tag_underscores.replace('_', ' ')\n",
+    "    tags = [tag, tag_underscores]\n",
+    "    if cat == cat_artist:\n",
+    "        if not tag.startswith('by '):\n",
+    "            # 'by ' is used in the output tags\n",
+    "            tags.insert(0, f'by {tag.removesuffix(' (artist)')}')\n",
+    "        if not tag.endswith('(artist)'):\n",
+    "            artist = tag.removeprefix('by ')\n",
+    "            tags.append(f'{artist} (artist)')\n",
+    "    elif cat == cat_lore and not tag.endswith(' (lore)'):\n",
+    "            tags.append(f'{tag} (lore)')\n",
+    "\n",
+    "    escaped_parens = [t.replace('(', r'\\(').replace(')', r'\\)') for t in tags]\n",
+    "    for t, ep in zip(tags[1:], escaped_parens[1:]):\n",
+    "        if t != ep:\n",
+    "            tags.append(ep)\n",
+    "    if escaped_parens[0] != tags[0]:\n",
+    "        tags.insert(0, escaped_parens[0]) # apparently sd-scripts require escaped parentheses \n",
+    "    if ':' in tag: # Recognize tags where ':' were replaced by a space\n",
+    "        tags.append(tag.replace(':', ' '))\n",
+    "    return tags\n",
+    "\n",
+    "\n",
+    "# Note: uses a single function to map both tag recognition and tags in the output, but this will change\n",
+    "tagset_normalizer = tagset_normalizer.map_tags(tag_mapfun, on_conflict=\"overwrite_rarest\") \n",
+    "# on_conflict: use warn to debug conflicts. silent, overwrite, overwrite_rarest, warn, raise\n",
+    "del tag_mapfun # drop the cache\n",
+    "\n",
+    "# Add some underscores back\n",
+    "tag_normalizer = tagset_normalizer.tag_normalizer\n",
+    "tag_normalizer.rename_output('rating explicit', 'rating_explicit')\n",
+    "tag_normalizer.rename_output('rating questionable', 'rating_questionable')\n",
+    "tag_normalizer.rename_output('rating safe', 'rating_safe')\n",
+    "# Custom mappings\n",
+    "tag_normalizer.add_input_mappings('explicit', 'rating_explicit')\n",
+    "tag_normalizer.add_input_mappings('score_explicit', 'rating_explicit')\n",
+    "tag_normalizer.add_input_mappings('safe', 'rating_safe', on_conflict='overwrite')\n",
+    "tag_normalizer.add_input_mappings('score_safe', 'rating_safe')\n",
+    "tag_normalizer.add_input_mappings('questionable', 'rating_questionable', on_conflict='overwrite')\n",
+    "tag_normalizer.add_input_mappings('score_questionable', 'rating_questionable')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8ef27e6f-8bbf-4481-b5e9-7d2b9cd8dd99",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[0;31mSignature:\u001b[0m\n",
+       "\u001b[0mtagset_normalizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap_tags\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mmapfun\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mmap_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mmap_output\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mon_conflict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'raise'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m'TagSetNormalizer'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m\n",
+       "Apply a function to all tag strings.\n",
+       "\n",
+       "The provided function will be run on:\n",
+       "\n",
+       "* The of list output tag strings,\n",
+       "* Keys from the dictionary mapping strings to ids, contains canonical\n",
+       "  tag and aliases,\n",
+       "* Implication source tags that are not used frequently enough to get an\n",
+       "  id assigned (less than twice).\n",
+       "\n",
+       "The function should return a list, where the first string is the\n",
+       "canonical tag used in the output, the others are additional aliases\n",
+       "used for recognizing the tag.\n",
+       "\u001b[0;31mFile:\u001b[0m      ~/code/e6db/e6db/utils/__init__.py\n",
+       "\u001b[0;31mType:\u001b[0m      method"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tagset_normalizer.map_tags?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "554e0048-761a-494b-9573-4fb60d55ff98",
+   "metadata": {},
+   "source": [
+    "# Edit caption files\n",
+    "\n",
+    "Loads, normalize and remove implied tags from a files in a sd-script hierarchy of directories.\n",
+    "\n",
+    "Unknown tags are kept untouched.\n",
+    "\n",
+    "Specific to kade's format, captions are detected as tags ending with a period and are moved to the end of the file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "497c2b51-4429-4d1b-93ef-b9c79193698f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tags=[6, 5, 17, 'unknown tag'] implied={0, 15}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[0;31mSignature:\u001b[0m \u001b[0mtagset_normalizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtags\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mIterable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeep_implied\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m\n",
+       "Encode a list of string as numerical ids and strip implied tags.\n",
+       "\n",
+       "Unknown tags are returned as strings.\n",
+       "\n",
+       "Returns :\n",
+       "\n",
+       "* a list of tag ids and unknown tag strings,\n",
+       "* a list of implied tag ids.\n",
+       "\u001b[0;31mFile:\u001b[0m      ~/code/e6db/e6db/utils/__init__.py\n",
+       "\u001b[0;31mType:\u001b[0m      method"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# We will use tagset_normalizer.encode()/decode() to normalize tags. Demo:\n",
+    "tags, implied = tagset_normalizer.encode(['solo', 'male', 'canine', 'mammal', 'unknown tag'])\n",
+    "print(f'{tags=} {implied=}')\n",
+    "\n",
+    "tagset_normalizer.decode(tags)\n",
+    "\n",
+    "tagset_normalizer.encode?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5200e13d-983c-463c-aa8e-33429515d63e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RE_SEP = re.compile(r'[,\\n]') # Split on commas and newline\n",
+    "\n",
+    "dataset_root = Path('~/repos/kade/furry').expanduser()\n",
+    "output_dir = Path('/tmp/furry_fix')\n",
+    "#output_dir = dataset_root # clobber mode\n",
+    "\n",
+    "def load_caption(fp):\n",
+    "    tags, captions = [], []\n",
+    "    with open(fp, 'rt') as fd:\n",
+    "        for chunk in RE_SEP.split(fd.read()):\n",
+    "            chunk = chunk.strip()\n",
+    "            if not chunk:\n",
+    "                continue\n",
+    "            if chunk.endswith('.'):\n",
+    "                captions.append(chunk)\n",
+    "            else:\n",
+    "                tags.append(chunk)\n",
+    "    return tags, captions\n",
+    "\n",
+    "\n",
+    "counter = Counter()\n",
+    "for file in chain(dataset_root.glob('**/*.txt'), dataset_root.glob('**/*.cap*')):\n",
+    "    if 'sample-prompts' in file.name:\n",
+    "        continue\n",
+    "    tags, captions = load_caption(file)\n",
+    "    orig_tags = tags\n",
+    "    tags, implied = tagset_normalizer.encode(tags)\n",
+    "    counter.update(tags)\n",
+    "    tags = tagset_normalizer.decode(tags)\n",
+    "    if tags == orig_tags:\n",
+    "        continue\n",
+    "\n",
+    "    output_file = output_dir / file.relative_to(dataset_root)\n",
+    "    output_file.parent.mkdir(parents=True, exist_ok=True)\n",
+    "    result = ', '.join(chain(tags, captions))\n",
+    "    with open(output_file, 'wt') as fd:\n",
+    "        fd.write(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d4741937-f1fd-4a1c-b3ed-9698e3d76a79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "solo                           count=10877 (e621:general)\n",
+      "rating_explicit                count=9363 (e621:general)\n",
+      "anthro                         count=7274 (e621:general)\n",
+      "nude                           count=5894 (e621:general)\n",
+      "female                         count=4525 (e621:general)\n",
+      "hi res                         count=4378 (e621:meta)\n",
+      "digital media \\(artwork\\)      count=4245 (e621:meta)\n",
+      "erection                       count=3952 (e621:general)\n",
+      "male                           count=3821 (e621:general)\n",
+      "looking at viewer              count=3600 (e621:general)\n",
+      "duo                            count=3555 (e621:general)\n",
+      "balls                          count=3496 (e621:general)\n",
+      "tail                           count=3485 (e621:general)\n",
+      "nipples                        count=3474 (e621:general)\n",
+      "open mouth                     count=3264 (e621:general)\n",
+      "smile                          count=3089 (e621:general)\n",
+      "blush                          count=2956 (e621:general)\n",
+      "english text                   count=2939 (e621:meta)\n",
+      "rating_safe                    count=2764 (e621:general)\n",
+      "white fur                      count=2338 (e621:general)\n",
+      "furry                          count=2275 (e621:invalid)\n",
+      "blue eyes                      count=2271 (e621:general)\n",
+      "navel                          count=2252 (e621:general)\n",
+      "tongue out                     count=2160 (e621:general)\n",
+      "outside                        count=2069 (e621:general)\n",
+      "absurd res                     count=1986 (e621:meta)\n",
+      "standing                       count=1982 (e621:general)\n",
+      "muscular male                  count=1977 (e621:general)\n",
+      "breasts                        count=1957 (e621:general)\n",
+      "butt                           count=1947 (e621:general)\n",
+      "pussy                          count=1915 (e621:general)\n",
+      "simple background              count=1910 (e621:general)\n",
+      "penis                          count=1866 (e621:general)\n",
+      "wolf                           count=1847 (e621:species)\n",
+      "brown fur                      count=1799 (e621:general)\n",
+      "claws                          count=1738 (e621:general)\n",
+      "abs                            count=1678 (e621:general)\n",
+      "animal ears                    count=1662 (e621:general)\n",
+      "male focus                     count=1653 (e621:general)\n",
+      "dialogue                       count=1602 (e621:general)\n",
+      "big breasts                    count=1557 (e621:general)\n",
+      "thick thighs                   count=1550 (e621:general)\n",
+      "anus                           count=1525 (e621:general)\n",
+      "furry male                     count=1511 (unknown)\n",
+      "eyes closed                    count=1486 (e621:general)\n",
+      "rating_questionable            count=1480 (e621:general)\n",
+      "sitting                        count=1464 (e621:general)\n",
+      "pecs                           count=1452 (e621:general)\n",
+      "watersports                    count=1448 (e621:general)\n",
+      "horn                           count=1444 (e621:general)\n",
+      "uncensored                     count=1405 (e621:meta)\n",
+      "humanoid penis                 count=1392 (e621:general)\n",
+      "spread legs                    count=1343 (e621:general)\n",
+      "white background               count=1335 (e621:general)\n",
+      "biped                          count=1334 (e621:general)\n",
+      "signature                      count=1322 (e621:meta)\n",
+      "fur                            count=1311 (e621:general)\n",
+      "long hair                      count=1228 (e621:general)\n",
+      "grey fur                       count=1223 (e621:general)\n",
+      "invalid tag                    count=1216 (e621:invalid)\n",
+      "detailed background            count=1206 (e621:general)\n",
+      "teeth                          count=1178 (e621:general)\n",
+      "black fur                      count=1152 (e621:general)\n",
+      "urine stream                   count=1148 (e621:general)\n",
+      "clothed                        count=1137 (e621:general)\n",
+      "fangs                          count=1129 (e621:general)\n",
+      "male/female                    count=1101 (e621:general)\n",
+      "black nose                     count=1100 (e621:general)\n",
+      "fox                            count=1098 (e621:species)\n",
+      "peeing                         count=1082 (e621:general)\n",
+      "green eyes                     count=1058 (e621:general)\n",
+      "barefoot                       count=1040 (e621:general)\n",
+      "5 fingers                      count=1040 (e621:general)\n",
+      "toe claws                      count=981 (e621:general)\n",
+      "artist name                    count=980 (e621:meta)\n",
+      "looking back                   count=980 (e621:general)\n",
+      "monochrome                     count=980 (e621:meta)\n",
+      "paws                           count=971 (e621:general)\n",
+      "feral                          count=951 (e621:general)\n",
+      "inside                         count=948 (e621:general)\n",
+      "black hair                     count=940 (e621:general)\n",
+      "thighs                         count=922 (e621:invalid)\n",
+      "4 toes                         count=922 (e621:general)\n",
+      "brown hair                     count=920 (e621:general)\n",
+      "full-length portrait           count=920 (e621:meta)\n",
+      "knot                           count=919 (e621:general)\n",
+      "big penis                      count=915 (e621:general)\n",
+      "red eyes                       count=913 (e621:general)\n",
+      "by kenket                      count=913 (e621:artist)\n",
+      "barazoku                       count=902 (e621:general)\n",
+      "on back                        count=900 (e621:general)\n",
+      "hair                           count=889 (e621:general)\n",
+      "orange fur                     count=881 (e621:general)\n",
+      "canine penis                   count=881 (e621:general)\n",
+      "gynomorph                      count=870 (e621:general)\n",
+      "by kenno arkkan                count=868 (e621:artist)\n",
+      "male peeing                    count=865 (e621:general)\n",
+      "tongue                         count=852 (e621:general)\n",
+      "bottomless                     count=836 (e621:general)\n",
+      "interspecies                   count=833 (e621:general)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Shows tag frequencies in the dataset, not counting the occurrences of implied tags\n",
+    "for tag, count in counter.most_common(n=100):\n",
+    "    if isinstance(tag, int):\n",
+    "        tag_string = tagset_normalizer.tag_normalizer.decode(tag)\n",
+    "        cat = tag_categories[tagset_normalizer.tag_normalizer.tag_categories[tag]]\n",
+    "        print(f'{tag_string:<30} {count=} (e621:{cat})')\n",
+    "    else:\n",
+    "        print(f'{tag:<30} {count=} (unknown)')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2b9cf8a6-61e2-4806-99fb-f92403294f08",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "furry male(1511), feet out of frame(306), furry sticker(306), furry with furry(290), animal focus(287), male pubic hair(251), furry with non-furry(243), wolf boy(243), gynomorph female(224), intersex intersex(140), male masturbation(125), gynomorph male(118), armpits(116), navel hair(107), by spaceengine(94), gynomorph gynomorph(91), male ambiguous(89), fox girl(87), tiger boy(87), photo \\(medium\\)(78), score explicit(63), clothed nude(60), greg rutkowski(54), five nights at freddy's security breach(53), blp(52), avery palmer(50), hamgas(48), bare pectorals(47), digimon \\(creature\\)(47), cum on boy(39), two-tone skin(39), non- breasts(35), animal hands(34), black male underwear(29), by jwst(29), leopard ears(28), non- balls(28), ground vehicle(27), cum on pectorals(25), white male underwear(25), female ambiguous(25), fox boy(24), by hubble(24), rabbit girl(22), andromorph male(22), painting \\(medium\\)(22), demon horns(19), herm male(19), webcomic character(19), lion boy(18), herm female(18), dharrel(18), fish boy(17), krystal(17), shower \\(place\\)(15), flame-tipped tail(15), tiger girl(14), genderswap \\(mtf\\)(14), sidepec(13), animal collar(13), heart-shaped chest(13), gynomorph herm(13), foot out of frame(12), animalization(12), In the picture(12), arrow \\(projectile\\)(11), naked shirt(11), colored tongue(11), herm herm(11), generation 9(11), planet pov(11), score safe(11), futa with female(10), futanari masturbation(10), ringtail(10), faux traditional media(10), ambiguous ambiguous(10), dock(9), dappled sunlight(8), scar on leg(8), fewer digits(8), webcomic(8), balls on floor(8), breasts squeezed together(7), goat girl(7), fishnets(7), pectoral cleavage(7), slingshot swimsuit(7), 6+boys(7), planted(7), white thighhighs(7), full-package futanari(7), red thighhighs(7), cowboy western(7), deviantart username(7), off on(7), regional form \\(\\)(7), score questionable(7), In a dimly lit room(7), In the background(7)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Top 100 of unknown tags:\n",
+    "print(', '.join([f'{k}({v})' for k,v in counter.most_common() if isinstance(k, str)][:100]))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}