add tag frequency approximations, display and thresholding

e6db/utils/__init__.py

@@ -3,6 +3,7 @@ from pathlib import Path
 import gzip
 import json
 import warnings
+import math
 from typing import Callable, Iterable
 
 tag_categories = [
@@ -69,7 +70,7 @@ 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
+      ids. Contains transitive implications.
     * `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.
@@ -82,19 +83,35 @@ def load_implications(data_dir):
     return implications, implications_rej
 
 
+def tag_rank_to_freq(rank: int) -> float:
+    """Approximate the frequency of a tag given its rank"""
+    return math.exp(26.4284 * math.tanh(2.93505 * rank ** (-0.136501)) - 11.492)
+
+
+def tag_freq_to_rank(freq: int) -> float:
+    """Approximate the rank of a tag given its frequency"""
+    log_freq = math.log(freq)
+    return math.exp(
+        -7.57186
+        * (0.0465456 * log_freq - 1.24326)
+        * math.log(1.13045 - 0.0720383 * log_freq)
+        + 12.1903
+    )
+
+
 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.
+    Multiple strings can be mapped to a single id, while each id maps to a
+    single string. As a result, the encode/decode process can be used to
+    normalize tags to canonical spelling.
+
+    See `add_input_mappings` for adding aliases, and `rename_output` for setting
+    the canonical spelling of a tag.
     """
 
     def __init__(self, path_or_data: str | Path | tuple[dict, list, bytes]):
@@ -104,6 +121,14 @@ class TagNormalizer:
             data = path_or_data
         self.tag2idx, self.idx2tag, self.tag_categories = data
 
+    def get_category(self, tag: int | str, as_string=True) -> int:
+        if isinstance(tag, str):
+            tag = self.encode(tag)
+        cat = self.tag_categories[tag]
+        if as_string:
+            return tag_categories[cat]
+        return cat
+
     def encode(self, tag: str, default=None):
         "Convert tag string to numerical id"
         return self.tag2idx.get(tag, default)

e6db/utils/numpy.py

@@ -1,6 +1,7 @@
 import numpy as np
 from . import load_tags as py_load_tags
 
+
 def tags_to_scipy_csr(df_posts, column="stripped_tags", vocab_size=None):
     from .polars import tags_to_csr
     import scipy.sparse
@@ -19,3 +20,19 @@ def load_tags(data_dir):
     idx2tag = np.array(idx2tag)
     tag_categories = np.frombuffer(tag_categories, dtype=np.uint8)
     return tag2idx, idx2tag, tag_categories
+
+
+def tag_rank_to_freq(rank: np.ndarray) -> np.ndarray:
+    """Approximate the frequency of a tag given its rank"""
+    return np.exp(26.4284 * np.tanh(2.93505 * rank ** (-0.136501)) - 11.492)
+
+
+def tag_freq_to_rank(freq: np.ndarray) -> np.ndarray:
+    """Approximate the rank of a tag given its frequency"""
+    log_freq = np.log(freq)
+    return np.exp(
+        -7.57186
+        * (0.0465456 * log_freq - 1.24326)
+        * np.log(1.13045 - 0.0720383 * log_freq)
+        + 12.1903
+    )

query_tags.py

@@ -4,11 +4,15 @@ import argparse
 
 import numpy as np
 import safetensors
-
-
 from sklearn.decomposition import PCA
+
 from e6db.utils.numpy import load_tags
-from e6db.utils import tag_category2id, tag_categories_colors
+from e6db.utils import (
+    tag_category2id,
+    tag_categories_colors,
+    tag_freq_to_rank,
+    tag_rank_to_freq,
+)
 
 
 def dothething(args):
@@ -37,14 +41,16 @@ def dothething(args):
     print("Query tags:", " ".join(sel_tags))
 
     # Select neighboring tags similar to the input tags
-    n_neighbors = args.global_topk
+    global_topk = args.global_topk
     top_k = args.topk
     if top_k is None:
-        top_k = int(1.5 * args.global_topk // len(sel_idxs))
+        top_k = int(1.5 * global_topk / len(sel_idxs))
+    rank_tresh = int(tag_freq_to_rank(args.min_frequency))
+    print(f"{rank_tresh=}")
 
     # Score and filter
-    scores = Xt @ Xt[sel_idxs].T
-    scores[sel_idxs, :] = float("-inf")
+    scores = Xt[:rank_tresh] @ Xt[sel_idxs].T
+    scores[sel_idxs, :] = float("-inf")  # Mask self-matches
     if args.category:
         categories = [tag_category2id[cat] for cat in args.category]
         scores[~np.isin(tag_categories, categories), :] = float("-inf")
@@ -53,22 +59,23 @@ def dothething(args):
     neigh_idxs = np.argpartition(-scores, top_k, axis=0)[:top_k]
 
     for i, t in enumerate(sel_tags):
-        o = np.argsort(scores[neigh_idxs[:, i], i])[::-1]
-        o = neigh_idxs[o[: args.display_topk], i]
-        tag_list = " ".join(idx2tag[o])
-        print(f"* {t}: {tag_list}")
-
-    # Deduplicate, global top-k
-    neigh_idxs = np.unique(neigh_idxs)
-    scores = scores[neigh_idxs, :].sum(axis=1)
-    if len(neigh_idxs) > n_neighbors:
-        neigh_idxs = neigh_idxs[np.argpartition(-scores, n_neighbors)[:n_neighbors]]
+        order = np.argsort(scores[neigh_idxs[:, i], i])[::-1]
+        idxs = neigh_idxs[order[: args.display_topk], i]
+        tag_list = " ".join(
+            f"{idx2tag[i]} ({format_tagfreq(tag_rank_to_freq(i))})" for i in idxs
+        )
+        print(f"* {t} ({format_tagfreq(tag_rank_to_freq(sel_idxs[i]))}): {tag_list}")
 
     if not args.plot_out:
         return
-
     from matplotlib import pyplot as plt
 
+    # Deduplicate, global top-k
+    neigh_idxs = np.unique(neigh_idxs)
+    scores = scores[neigh_idxs, :].sum(axis=1)
+    if len(neigh_idxs) > global_topk:
+        neigh_idxs = neigh_idxs[np.argpartition(-scores, global_topk)[:global_topk]]
+
     idxs = np.concatenate([sel_idxs, neigh_idxs])
     query_slice = slice(None, len(sel_idxs))
     target_slice = slice(len(sel_idxs), len(sel_idxs) + args.display_topk)
@@ -81,7 +88,7 @@ def dothething(args):
     X2 /= np.linalg.norm(X2, axis=1)[:, None]
     X2t = PCA(2).fit_transform(X2)[:, ::-1]
 
-    f, ax = plt.subplots(figsize=(15, 15), facecolor="#152f56")
+    f, ax = plt.subplots(figsize=(12, 12), facecolor="#152f56")
     ax.axis("off")
 
     dx = 0.01
@@ -118,7 +125,7 @@ def dothething(args):
 
 def parse_args():
     parser = argparse.ArgumentParser(
-        description="Query similar tags and plots a local PCA",
+        description="Query similar tags and plots a local PCA.\nUse `-o -` to get an interactive plot",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     parser.add_argument(
@@ -135,6 +142,13 @@ def parse_args():
         action="append",
         help="restrict the output to the specified tag category",
     )
+    parser.add_argument(
+        "-f",
+        "--min_frequency",
+        type=int,
+        default=100,
+        help="minimal number of posts tagged for a tag to be considered",
+    )
     parser.add_argument(
         "-N",
         "--display-topk",
@@ -150,18 +164,18 @@ def parse_args():
         help="selects the global top-k neighbors for the local PCA",
     )
     parser.add_argument(
-        "-d",
-        "--first-pca",
+        "-k",
+        "--topk",
         type=int,
         default=None,
-        help="truncation rank for the global PCA meant to smooth all embeddings",
+        help="Number of neighbors to consider for each query tag. When not specified, is set to 1.5 * GLOBAL_TOPK / <number of query tags>",
     )
     parser.add_argument(
-        "-k",
-        "--topk",
+        "-d",
+        "--first-pca",
         type=int,
         default=None,
-        help="Number of neighbors to consider for each query tag",
+        help="truncation rank for the global PCA meant to smooth all embeddings",
     )
     parser.add_argument(
         "-o",
@@ -180,6 +194,15 @@ def parse_args():
     return parser.parse_args()
 
 
+def format_tagfreq(count):
+    count = int(count)
+    if count < 1000:
+        return str(count)
+    elif count < 1000_000:
+        return f"{count*1e-3:.1f}k"
+    return f"{count*1e-6:.1f}m"
+
+
 if __name__ == "__main__":
     args = parse_args()
     dothething(args)