Upload 14 files

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+val_dataset.csv filter=lfs diff=lfs merge=lfs -text

1_json_to_csv.py

@@ -0,0 +1,28 @@
+import json
+
+import pandas as pd
+
+cat_name_to_db_id = {
+    "meta": 5,
+    "character": 4,
+    "copyright": 3,
+    "artist": 1,
+    "general": 0,
+    "year": 10,
+    "rating": 9,
+}
+
+
+with open("cm_tags.json") as f:
+    data = json.load(f)
+
+df_list = []
+for elem in data["idx_to_tag"]:
+    base = {"tag_id": None, "name": None, "category": None, "count": -1}
+    base["tag_id"] = elem
+    base["name"] = data["idx_to_tag"][elem]
+    base["category"] = cat_name_to_db_id[data["tag_to_category"][base["name"]]]
+    df_list.append(base)
+
+df = pd.DataFrame.from_dict(df_list)
+df.to_csv("cm_tags.csv", index=False)

2_retrieve_images_by_cc.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+import pandas as pd
+from cheesechaser.datapool.danbooru import DanbooruNewestDataPool
+
+existing = Path("original").glob("*")
+existing = [int(x.stem) for x in existing]
+
+df = pd.read_csv("val_dataset.csv")
+want = df["id"].tolist()
+want = list(set(want) - set(existing))
+
+pool = DanbooruNewestDataPool()
+
+pool.batch_download_to_directory(
+    resource_ids=want,
+    dst_dir="original",
+    max_workers=12,
+    silent=True,
+)

3_common_tags.py

@@ -0,0 +1,33 @@
+import pandas as pd
+
+sw_tags = pd.read_csv("sw_tags.csv")
+cm_tags = pd.read_csv("cm_tags.csv")
+
+sw_tags["tag_idx"] = sw_tags.index
+
+sw_tags = sw_tags.set_index("name")
+cm_tags = cm_tags.set_index("name")
+
+common_tags = sw_tags.index.intersection(cm_tags.index)
+
+sw_tags = sw_tags[sw_tags.index.isin(common_tags)]
+cm_tags = cm_tags[cm_tags.index.isin(common_tags)]
+
+# Some tags have changed category over time,
+# so only keep the ones where the category matches between the datasets
+sw_tags["cm_category"] = cm_tags["category"]
+sw_tags = sw_tags[sw_tags["category"] == sw_tags["cm_category"]]
+sw_tags = sw_tags.drop("cm_category", axis=1)
+
+common_tags = sw_tags.index.intersection(cm_tags.index)
+
+sw_tags = sw_tags[sw_tags.index.isin(common_tags)]
+cm_tags = cm_tags[cm_tags.index.isin(common_tags)]
+
+cm_tags["tag_idx"] = cm_tags["tag_id"]
+cm_tags["tag_id"] = sw_tags["tag_id"]
+
+cm_tags = cm_tags.reindex(sw_tags.index)
+
+sw_tags.to_csv("sw_tags_common.csv")
+cm_tags.to_csv("cm_tags_common.csv")

4_cm_onnx_inference.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+from tqdm import tqdm
+
+# Disable decompression bomb warnings 'cuz we trust danbooru images
+Image.MAX_IMAGE_PIXELS = None
+
+
+def load_model(model_path):
+    """Test an ONNX model with a single image"""
+    # Load ONNX model
+    print(f"Loading ONNX model from {model_path}")
+    try:
+        # Try with CUDA
+        session = ort.InferenceSession(
+            model_path,
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        print(f"Using providers: {session.get_providers()}")
+    except Exception as e:
+        print(f"CUDA not available, using CPU: {e}")
+        session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
+        print(f"Using providers: {session.get_providers()}")
+    return session
+
+
+def preprocess_image(image_path, image_size=512):
+    """Process an image for inference"""
+    try:
+        with Image.open(image_path) as img:
+            # Convert RGBA or Palette images to RGB
+            # ...while respecting transparency set in the palette
+            if img.mode in ("RGBA", "P"):
+                img = img.convert("RGBA")
+                canvas = Image.new("RGBA", img.size, (0, 0, 0))
+                canvas.alpha_composite(img)
+                img = canvas.convert("RGB")
+
+            # Get original dimensions
+            width, height = img.size
+            aspect_ratio = width / height
+
+            # Calculate new dimensions to maintain aspect ratio
+            if aspect_ratio > 1:
+                new_width = image_size
+                new_height = int(new_width / aspect_ratio)
+            else:
+                new_height = image_size
+                new_width = int(new_height * aspect_ratio)
+
+            # Resize with LANCZOS filter
+            img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+            # Create new image with padding
+            new_image = Image.new("RGB", (image_size, image_size), (0, 0, 0))
+            paste_x = (image_size - new_width) // 2
+            paste_y = (image_size - new_height) // 2
+            new_image.paste(img, (paste_x, paste_y))
+
+            # Apply transforms
+            img_tensor = np.array(new_image, dtype=np.float32)
+            img_tensor = img_tensor / 255.0
+            return img_tensor
+    except Exception as e:
+        raise Exception(f"Error processing {image_path}: {str(e)}")
+
+
+def test_onnx_model(session, image_path):
+    # Preprocess image
+    img_tensor = preprocess_image(image_path)
+
+    # Add batch dimension and convert to numpy
+    img_numpy = np.transpose(img_tensor, [2, 0, 1])
+    img_numpy = np.expand_dims(img_numpy, axis=0)
+
+    # Get input name
+    input_name = session.get_inputs()[0].name
+
+    # Run inference
+    outputs = session.run(None, {input_name: img_numpy})
+
+    # Process outputs
+    initial_probs = 1.0 / (1.0 + np.exp(-outputs[0]))  # Apply sigmoid
+    return initial_probs
+
+
+if __name__ == "__main__":
+    session = load_model("camie-tagger/model_initial.onnx")
+    images = sorted(list(Path("original").glob("*")))
+
+    probs = np.zeros((len(images), 70527), dtype=np.float32)
+    for i, image_path in enumerate(tqdm(images)):
+        probs[i] = test_onnx_model(session, image_path)
+
+    np.save("cm_probs.npy", probs)

5_wd_v3_onnx_inference.py

@@ -0,0 +1,83 @@
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+from tqdm import tqdm
+
+# Disable decompression bomb warnings 'cuz we trust danbooru images
+Image.MAX_IMAGE_PIXELS = None
+
+
+def load_model(model_path):
+    """Test an ONNX model with a single image"""
+    # Load ONNX model
+    print(f"Loading ONNX model from {model_path}")
+    try:
+        # Try with CUDA
+        session = ort.InferenceSession(
+            model_path,
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        print(f"Using providers: {session.get_providers()}")
+    except Exception as e:
+        print(f"CUDA not available, using CPU: {e}")
+        session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
+        print(f"Using providers: {session.get_providers()}")
+    return session
+
+
+def preprocess_image(image_path, target_size=448):
+    image = Image.open(image_path)
+    image = image.convert(mode="RGBA")
+
+    canvas = Image.new("RGBA", image.size, (255, 255, 255))
+    canvas.alpha_composite(image)
+    image = canvas.convert("RGB")
+
+    # Pad image to square
+    image_shape = image.size
+    max_dim = max(image_shape)
+    pad_left = (max_dim - image_shape[0]) // 2
+    pad_top = (max_dim - image_shape[1]) // 2
+
+    padded_image = Image.new("RGB", (max_dim, max_dim), (255, 255, 255))
+    padded_image.paste(image, (pad_left, pad_top))
+
+    # Resize
+    if max_dim != target_size:
+        padded_image = padded_image.resize(
+            (target_size, target_size),
+            Image.BICUBIC,
+        )
+
+    # Convert to numpy array
+    image_array = np.asarray(padded_image, dtype=np.float32)
+
+    # Convert PIL-native RGB to BGR
+    image_array = image_array[:, :, ::-1]
+
+    return np.expand_dims(image_array, axis=0)
+
+
+def test_onnx_model(session, image_path):
+    # Preprocess image
+    img_numpy = preprocess_image(image_path)
+
+    # Get input name
+    input_name = session.get_inputs()[0].name
+
+    # Run inference
+    outputs = session.run(None, {input_name: img_numpy})[0]
+    return outputs
+
+
+if __name__ == "__main__":
+    session = load_model("wd_v3_tagger/swinv2.onnx")
+    images = sorted(list(Path("original").glob("*")))
+
+    probs = np.zeros((len(images), 10861), dtype=np.float32)
+    for i, image_path in enumerate(tqdm(images)):
+        probs[i] = test_onnx_model(session, image_path)
+
+    np.save("swinv2_probs.npy", probs)

6_get_labels.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+df = pd.read_csv("val_dataset.csv")
+df = df.set_index("id")
+
+images = sorted(list(Path("original").glob("*")))
+images = [int(x.stem) for x in images]
+df = df.loc[images]
+
+tags = pd.read_csv("sw_tags_common.csv")
+tags = tags["name"].tolist()
+
+
+def to_one_hot(x):
+    tag_fields = [
+        "tag_string_general",
+        "tag_string_character",
+        "tag_string_copyright",
+        "tag_string_artist",
+        "tag_string_meta",
+    ]
+
+    tag_string = []
+    for tag_field in tag_fields:
+        column_content = x[tag_field]
+        if pd.isna(column_content):
+            continue
+
+        tag_string.extend(column_content.split(" "))
+
+    return np.isin(tags, tag_string)
+
+
+labels = np.zeros((len(df), len(tags)), dtype=np.uint8)
+for i, elem in enumerate(df.iterrows()):
+    res = to_one_hot(elem[1])
+    labels[i] = res
+
+np.save("labels.npy", labels)

7_analyze_metrics_macro.py

@@ -0,0 +1,183 @@
+import argparse
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+def calc_metrics(img_tags, img_probs, thresh):
+    yz = (img_tags > 0).astype(np.uint8)
+    pos = (img_probs > thresh).astype(np.uint8)
+    pct = pos + 2 * yz
+
+    FP = np.sum(pct == 1, axis=0).astype(np.float32)
+    FN = np.sum(pct == 2, axis=0).astype(np.float32)
+    TP = np.sum(pct == 3, axis=0).astype(np.float32)
+
+    recall = TP / np.maximum(TP + FN, 1e-6)
+    precision = TP / np.maximum(TP + FP, 1e-6)
+    return precision.mean(), recall.mean()
+
+
+parser = argparse.ArgumentParser(description="Analyze output probabilities dumps")
+parser.add_argument(
+    "-tc",
+    "--tags-csv",
+    default="sw_tags_common.csv",
+    help="Dataset name",
+)
+
+parser.add_argument(
+    "-d",
+    "--dump",
+    default="swinv2_probs.npy",
+    help="Probabilities dump",
+)
+
+parser.add_argument(
+    "-l",
+    "--labels",
+    default="labels.npy",
+    help="One-hot encoded labels dump file",
+)
+
+parser.add_argument(
+    "-s",
+    "--start-index",
+    type=int,
+    default=0,
+    help="Slice files along axis=1 starting from this index",
+)
+
+parser.add_argument(
+    "-e",
+    "--end-index",
+    type=int,
+    default=-1,
+    help="Slice files along axis=1 ending to this index",
+)
+
+parser.add_argument(
+    "-c",
+    "--category",
+    type=int,
+    default=-1,
+    help="Only analyze tags of this category (-1 = all)",
+)
+
+thresh_group = parser.add_mutually_exclusive_group()
+thresh_group.add_argument(
+    "-a",
+    "--analyze",
+    action="store_true",
+    help="Iteratively look for the threshold where P ≈ R",
+)
+thresh_group.set_defaults(analyze=False)
+
+thresh_group.add_argument(
+    "-t",
+    "--threshold",
+    type=float,
+    default=0.4,
+    help="Use this threshold to calculate the metrics",
+)
+args = parser.parse_args()
+
+img_probs = np.load(args.dump)
+img_tags = np.load(args.labels)
+
+df = pd.read_csv(args.tags_csv)
+indexes = df["tag_idx"].tolist()
+img_probs = img_probs[:, indexes]
+
+if args.category != -1:
+    indexes = np.where(df["category"] == args.category)[0]
+    img_probs = img_probs[:, indexes]
+    img_tags = img_tags[:, indexes]
+
+end_index = args.end_index
+if end_index == -1:
+    end_index = img_probs.shape[1]
+
+img_probs = img_probs[:, args.start_index : end_index]
+img_tags = img_tags[:, args.start_index : end_index]
+
+indexes = np.where(img_tags.sum(axis=0) > 0)[0]
+img_probs = img_probs[:, indexes]
+img_tags = img_tags[:, indexes]
+print(f"Final # of tags: {img_tags.shape[1]}")
+
+assert img_probs.shape[1] > 0
+
+if args.analyze:
+    threshold_min = 0.05
+    threshold_max = 0.95
+
+    iters = 0
+    recall = 0.0
+    precision = 1.0
+    while not np.isclose(recall, precision) and (iters < 15):
+        threshold = (threshold_max + threshold_min) / 2
+        precision, recall = calc_metrics(img_tags, img_probs, threshold)
+        if precision > recall:
+            threshold_max = threshold
+        else:
+            threshold_min = threshold
+        iters += 1
+
+    threshold = round(threshold, 4)
+else:
+    threshold = args.threshold
+
+pos = (img_probs > threshold).astype(np.uint8)
+yz = (img_tags > 0).astype(np.uint8)
+pct = pos + 2 * yz
+
+TN = np.sum(pct == 0, axis=0).astype(np.float32)
+FP = np.sum(pct == 1, axis=0).astype(np.float32)
+FN = np.sum(pct == 2, axis=0).astype(np.float32)
+TP = np.sum(pct == 3, axis=0).astype(np.float32)
+
+recall = np.mean(TP / np.maximum(TP + FN, 1e-6))
+precision = np.mean(TP / np.maximum(TP + FP, 1e-6))
+accuracy = np.mean((TP + TN) / (TP + TN + FP + FN))
+
+
+def get_fbeta(beta, TP, FP, FN):
+    numerator = (1 + beta**2) * TP
+    denominator = (1 + beta**2) * TP + beta**2 * FN + FP
+
+    idx = np.where(denominator == 0)
+    numerator[idx] = 1
+    denominator[idx] = 1
+
+    return np.mean(numerator / denominator)
+
+
+def get_mcc(TP, TN, FP, FN):
+    N = TP + FN + FP + TN
+    S = (TP + FN) / N
+    P = (TP + FP) / N
+    numerator = (TP / N) - (S * P)
+    denominator = S * P * (1 - S) * (1 - P)
+    denominator = np.maximum(denominator, 1e-12)
+    denominator = np.sqrt(denominator)
+    return np.mean(numerator / denominator)
+
+
+F1 = get_fbeta(1, TP, FP, FN)
+F2 = get_fbeta(2, TP, FP, FN)
+
+MCC = get_mcc(TP, TN, FP, FN)
+
+model_name = Path(args.dump).name
+d = {
+    "thres": threshold,
+    "F1": round(float(F1), 4),
+    "F2": round(float(F2), 4),
+    "MCC": round(float(MCC), 4),
+    "A": round(float(accuracy), 4),
+    "R": round(float(recall), 4),
+    "P": round(float(precision), 4),
+}
+print(f"{model_name}: {str(d)}")

README.md

@@ -0,0 +1,70 @@
+## What's what
+
+`1_json_to_csv.py`:  
+ - converts cm_tags.json to a csv format I'm more used to and that is easier to use with my existing tooling
+
+`2_retrieve_images_by_cc.py`:  
+ - retrieves the validation images using cheesechaser, downloads them to "original/"
+
+`3_common_tags.py`:  
+ - clean up both models tag sets to only consider the common tags; note down the indexes to use to fetch the correct tag probs from the dumps generated by the inference scripts
+
+`4_cm_onnx_inference.py`:  
+ - run inference using the ONNX model of camie-tagger, dump the activated (post-sigmoid) outputs
+
+`5_wd_v3_onnx_inference.py`:  
+ - run inference using the ONNX model of wd_v3 taggers (hardcoded to use swinv2_v3, could be made to use any of the v3 series), dump the activated outputs
+
+`6_get_labels.py`:  
+ - get one-hot encoded labels from val_dataset.csv, dumps them to "labels.npy"
+
+`7_analyze_metrics_macro.py`:  
+ - final analysis tool
+
+## Results
+
+Category 0: general tags - full
+```
+[user]$ python 7_analyze_metrics_macro.py -tc sw_tags_common.csv -c 0 -d swinv2_probs.npy -l labels.npy -a
+Final # of tags: 7853
+swinv2_probs.npy: {'thres': 0.2613, 'F1': 0.5386, 'F2': 0.5475, 'MCC': 0.548, 'A': 0.9972, 'R': 0.5619, 'P': 0.5619}
+
+[user]$ python 7_analyze_metrics_macro.py -tc cm_tags_common.csv -c 0 -d cm_probs.npy -l labels.npy -a
+Final # of tags: 7853
+cm_probs.npy: {'thres': 0.2694, 'F1': 0.273, 'F2': 0.2835, 'MCC': 0.2859, 'A': 0.9955, 'R': 0.3075, 'P': 0.3075}
+```
+
+Category 0: general tags - ignoring the top 5000
+```
+[user]$ python 7_analyze_metrics_macro.py -tc sw_tags_common.csv -c 0 -d swinv2_probs.npy -l labels.npy -a -s 5000
+Final # of tags: 2859
+swinv2_probs.npy: {'thres': 0.2272, 'F1': 0.4908, 'F2': 0.5026, 'MCC': 0.5069, 'A': 0.9998, 'R': 0.5256, 'P': 0.5255}
+
+[user]$ python 7_analyze_metrics_macro.py -tc cm_tags_common.csv -c 0 -d cm_probs.npy -l labels.npy -a -s 5000
+Final # of tags: 2859
+cm_probs.npy: {'thres': 0.2484, 'F1': 0.1961, 'F2': 0.2032, 'MCC': 0.2104, 'A': 0.9997, 'R': 0.2295, 'P': 0.2294}
+```
+
+Category 4: character tags
+```
+[user]$ python 7_analyze_metrics_macro.py -tc sw_tags_common.csv -c 4 -d swinv2_probs.npy -l labels.npy -a
+Final # of tags: 2585
+swinv2_probs.npy: {'thres': 0.3411, 'F1': 0.9464, 'F2': 0.9482, 'MCC': 0.9491, 'A': 1.0, 'R': 0.9519, 'P': 0.952}
+
+[user]$ python 7_analyze_metrics_macro.py -tc cm_tags_common.csv -c 4 -d cm_probs.npy -l labels.npy -a
+Final # of tags: 2585
+cm_probs.npy: {'thres': 0.2493, 'F1': 0.7148, 'F2': 0.7226, 'MCC': 0.7266, 'A': 0.9998, 'R': 0.74, 'P': 0.7397}
+```
+
+## Caveats
+
+The swinv2_v3 tagger has got an unfair home advantage, in that out of the 20116 validation samples, only 2908 are guaranteed to not have been part of the training set.
+
+Gathering a more fair validation set is left as an excersise for the reader.  
+The exact datasets splits use for wd_v3 models are available here: https://huggingface.co/datasets/SmilingWolf/wdtagger-v3-seed
+
+The analysis script removes tags that have no positive samples in the val set.  
+It would probably be a good idea to only select tags that have 5+ samples.  
+It's a fairly trivial change to make to the analysis script, if one feels so inclined.
+
+I have only used the tags that have the exact same name and category to build the common tag set. I haven't adjusted for aliases and implications.

val_dataset.csv

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