Added balance tags script.

.gitignore

@@ -1,3 +1,4 @@
 images/
 __pycache__/
 .ipynb_checkpoints/
+model_tags.txt

balance_tags.py

@@ -0,0 +1,131 @@
+import os
+import sys
+import tqdm
+import utils
+import shutil
+import random
+import argparse
+from constants import *
+
+def get_model_tags(model_tags_path):
+    if not os.path.isfile(model_tags_path):
+        raise FileNotFoundError(f"\"{model_tags_path}\" is not a file, please place one there!")
+    index_tag_dict = {}
+    with open(model_tags_path, "r", encoding="utf8") as model_tags_file:
+        for line in model_tags_file:
+            line = line.split()
+            if len(line) != 2:
+                continue
+            index_tag_dict[int(line[0])] = line[1]
+    if len(index_tag_dict) <= 0:
+        return []
+    sorted_index_tag_tuple_list = sorted(index_tag_dict.items(), key=lambda x: x[0])
+    if len(sorted_index_tag_tuple_list) != sorted_index_tag_tuple_list[-1][0] + 1:
+        raise ValueError(f"The index specified in \"{model_tags_path}\" is not continuous!")
+    return [tag for _, tag in sorted_index_tag_tuple_list]
+
+def get_tags_set(tags_path):
+    if not os.path.isfile(tags_path):
+        raise FileNotFoundError(f"\"{tags_path}\" is not a file!")
+    with open(tags_path, "r", encoding="utf8") as tags_file:
+        tags_text = tags_file.read()
+    tags_set = set()
+    for tag in tags_text.split(","):
+        tag = tag.strip()
+        if tag:
+            tag = tag.replace(" ", "_")
+            if tag == "nsfw": tag = "rating:explicit"
+            elif tag == "qfw": tag = "rating:questionable"
+            elif tag == "sfw": tag = "rating:safe"
+            tags_set.add(tag)
+    return tags_set
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Balance the dataset based on tag frequency.")
+    parser.add_argument("-c", "--count", type=int, help="The target selection count, must be an integer greater than 0")
+    parser.add_argument("-d", "--display", action="store_true", help="Display the count of images in each bucket")
+    parser.add_argument("-r", "--reverse", action="store_true", help="Display in reverse order, only for displaying")
+    args = parser.parse_args()
+    if not args.display:
+        if args.reverse:
+            print("You can't specify reverse when not using display mode!")
+            sys.exit(1)
+        if not isinstance(args.count, int):
+            print("You must specify the target selection count when not using display mode!")
+            sys.exit(1)
+        if args.count <= 0:
+            print("Target selection count must be an integer greater than 0!")
+            sys.exit(1)
+    elif isinstance(args.count, int):
+        print("You can't specify the target selection count when using display mode!")
+        sys.exit(1)
+    return args
+
+def main():
+    args = parse_args()
+    print("Starting...\nGetting model tags...")
+    model_tags = get_model_tags(MODEL_TAGS_PATH)
+    print("Getting paths...")
+    image_id_image_tags_path_tuple_tuple_list = sorted(utils.get_image_id_image_tags_path_tuple_dict(IMAGE_DIR).items(), key=lambda x: x[0])
+    print("Got", len(image_id_image_tags_path_tuple_tuple_list), "images.\nShuffling paths...")
+    random.seed(42)
+    random.shuffle(image_id_image_tags_path_tuple_tuple_list)
+    print("Making buckets...")
+    in_bucket_image_count = 0
+    buckets = {tag: [] for tag in model_tags}
+    for image_id_image_tags_path_tuple_tuple in tqdm.tqdm(image_id_image_tags_path_tuple_tuple_list, desc="Making buckets"):
+        did_append = False
+        for tag in get_tags_set(image_id_image_tags_path_tuple_tuple[1][1]):
+            bucket = buckets.get(tag)
+            if bucket is None:
+                continue
+            bucket.append(image_id_image_tags_path_tuple_tuple)
+            did_append = True
+        if did_append:
+            in_bucket_image_count += 1
+    print("Got", in_bucket_image_count, "unique images in buckets.")
+    buckets = sorted(buckets.items(), key=lambda x: len(x[1]))
+    if args.display:
+        if args.reverse: range_iter = range(len(buckets) - 1, -1, -1)
+        else: range_iter = range(len(buckets))
+        for i in range_iter: print(buckets[i][0], len(buckets[i][1]))
+        return
+    print("Selecting...")
+    total = min(args.count, in_bucket_image_count)
+    selected = {} # Key: Image ID, Value: Tuple(Image path, Tags path).
+    with tqdm.tqdm(total=total, desc="Selecting") as progress_bar:
+        while len(selected) < total:
+            for tag, image_id_image_tags_path_tuple_tuple_list in buckets:
+                if len(selected) >= total:
+                    break
+                if len(image_id_image_tags_path_tuple_tuple_list) <= 0:
+                    continue
+                for i in range(len(image_id_image_tags_path_tuple_tuple_list) - 1, -1, -1):
+                    if image_id_image_tags_path_tuple_tuple_list[i][0] in selected:
+                        del image_id_image_tags_path_tuple_tuple_list[i]
+                        break
+                else:
+                    last_item = image_id_image_tags_path_tuple_tuple_list[-1]
+                    selected[last_item[0]] = last_item[1]
+                    del image_id_image_tags_path_tuple_tuple_list[-1]
+                    progress_bar.update(1)
+    print("Selected", len(selected), "images.\nDeleting unselected images...")
+    temp_dir = "__tag_bal_trans_tmp__"
+    if os.path.exists(temp_dir):
+        shutil.rmtree(temp_dir)
+    os.makedirs(temp_dir)
+    for image_tags_path_tuple in tqdm.tqdm(selected.values(), desc="Moving"):
+        image_path = image_tags_path_tuple[0]
+        tags_path = image_tags_path_tuple[1]
+        os.rename(image_path, os.path.join(temp_dir, os.path.basename(image_path)))
+        os.rename(tags_path, os.path.join(temp_dir, os.path.basename(tags_path)))
+    shutil.rmtree(IMAGE_DIR)
+    shutil.move(temp_dir, IMAGE_DIR)
+    print("Finished.")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nScript interrupted by user, exiting...")
+        sys.exit(1)

constants.py

@@ -10,3 +10,5 @@ IMAGE_EXT = {
     ".png", ".jpg", ".jpeg", ".bmp", ".tiff", ".tif",
     ".webp", ".heic", ".heif", ".avif", ".jxl",
 }
+
+MODEL_TAGS_PATH = "model_tags.txt"

utils.py

@@ -59,13 +59,22 @@ def validate_image(image_path, tags_path, width=None, height=None, convert_to_av
 async def submit_validation(thread_pool, image_path, tags_path, width=None, height=None, convert_to_avif=False):
     return await asyncio.wrap_future(thread_pool.submit(validate_image, image_path, tags_path, width, height, convert_to_avif))
 
-def get_existing_image_tags_set(image_dir):
+def get_image_id_image_tags_path_tuple_dict(image_dir):
     if not os.path.isdir(image_dir):
-        return set()
-    existing_image_tags = set()
+        raise FileNotFoundError(f"\"{image_dir}\" is not a directory!")
+    image_id_image_tags_path_tuple_dict = {}
     for path in os.listdir(image_dir):
         image_id, ext = os.path.splitext(path)
-        if ext != ".txt":
+        if ext == ".txt":
+            continue
+        path = os.path.join(image_dir, path)
+        if not os.path.isfile(path):
+            continue
+        tags_path = os.path.splitext(path)[0] + ".txt"
+        if not os.path.isfile(tags_path):
             continue
-        existing_image_tags.add(image_id)
-    return existing_image_tags
+        image_id_image_tags_path_tuple_dict[image_id] = (path, tags_path)
+    return image_id_image_tags_path_tuple_dict
+
+def get_existing_image_tags_set(image_dir):
+    return {tags_path for _, tags_path in get_image_id_image_tags_path_tuple_dict(image_dir)}