Upload 9 files

app.py

@@ -1,520 +1,823 @@
-import os, io, copy, json, requests, spaces, gradio as gr, numpy as np
-import argparse, huggingface_hub, onnxruntime as rt, pandas as pd, traceback, tempfile, zipfile, re, ast, time
+import os, io, json, requests, spaces, argparse, traceback, tempfile, zipfile, re, ast, time
+import gradio as gr
+import numpy as np
+import huggingface_hub
+import onnxruntime as ort
+import pandas as pd
 from datetime import datetime, timezone
 from collections import defaultdict
 from PIL import Image, ImageOps
-from modules.booru import booru_gradio, on_select
 from apscheduler.schedulers.background import BackgroundScheduler
-from modules.classifyTags import classify_tags, process_tags
-from modules.beautify_model import beautify_list, beautify_class
-from modules.tag_enhancer import prompt_summarizer
+from modules.classifyTags import categorize_tags_output, generate_tags_json
+from modules.pixai import create_pixai_interface
+from modules.booru import create_booru_interface
 
-os.environ['PYTORCH_ENABLE_MPS_FALLBACK']='1'
-os.environ['OMP_NUM_THREADS'] = '8'  # Optimize CPU utilization? Test...
-#os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+""" For GPU install all the requirements.txt and the following:
+pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu126
+pip install onnxruntime-gpu
+"""
 
-TITLE = "Multi-Tagger v1.3"
-DESCRIPTION = """
-Multi-Tagger is a versatile application for advanced image analysis and captioning. Supports <b>CUDA</b> and <b>CPU</b>.
+""" It's recommended to create a venv:
+python -m venv venv
+venv\Scripts\activate
+pip install ...
+python app.py
 """
 
-# Dataset v3 series of models:
-SWINV2_MODEL_DSV3_REPO = "SmilingWolf/wd-swinv2-tagger-v3"
-CONV_MODEL_DSV3_REPO = "SmilingWolf/wd-convnext-tagger-v3"
-VIT_MODEL_DSV3_REPO = "SmilingWolf/wd-vit-tagger-v3"
-VIT_LARGE_MODEL_DSV3_REPO = "SmilingWolf/wd-vit-large-tagger-v3"
-EVA02_LARGE_MODEL_DSV3_REPO = "SmilingWolf/wd-eva02-large-tagger-v3"
-# Dataset v2 series of models:
-MOAT_MODEL_DSV2_REPO = "SmilingWolf/wd-v1-4-moat-tagger-v2"
-SWIN_MODEL_DSV2_REPO = "SmilingWolf/wd-v1-4-swinv2-tagger-v2"
-CONV_MODEL_DSV2_REPO = "SmilingWolf/wd-v1-4-convnext-tagger-v2"
-CONV2_MODEL_DSV2_REPO = "SmilingWolf/wd-v1-4-convnextv2-tagger-v2"
-VIT_MODEL_DSV2_REPO = "SmilingWolf/wd-v1-4-vit-tagger-v2"
-# IdolSankaku series of models:
-EVA02_LARGE_MODEL_IS_DSV1_REPO = "deepghs/idolsankaku-eva02-large-tagger-v1"
-SWINV2_MODEL_IS_DSV1_REPO = "deepghs/idolsankaku-swinv2-tagger-v1"
-# Files to download from the repos
-MODEL_FILENAME = "model.onnx"
-LABEL_FILENAME = "selected_tags.csv"
-
-kaomojis=['0_0', '(o)_(o)', '+_+', '+_-', '._.', '<o>_<o>', '<|>_<|>', '=_=', '>_<', '3_3', '6_9', '>_o', '@_@', '^_^', 'o_o', 'u_u', 'x_x', '|_|', '||_||']
-def parse_args()->argparse.Namespace:parser=argparse.ArgumentParser();parser.add_argument('--score-slider-step', type=float, default=.05);parser.add_argument('--score-general-threshold', type=float, default=.35);parser.add_argument('--score-character-threshold', type=float, default=.85);parser.add_argument('--share', action='store_true');return parser.parse_args()
-def load_labels(dataframe)->list[str]:name_series=dataframe['name'];name_series=name_series.map(lambda x:x.replace('_', ' ')if x not in kaomojis else x);tag_names=name_series.tolist();rating_indexes=list(np.where(dataframe['category']==9)[0]);general_indexes=list(np.where(dataframe['category']==0)[0]);character_indexes=list(np.where(dataframe['category']==4)[0]);return tag_names, rating_indexes, general_indexes, character_indexes
-def mcut_threshold(probs):sorted_probs=probs[probs.argsort()[::-1]];difs=sorted_probs[:-1]-sorted_probs[1:];t=difs.argmax();thresh=(sorted_probs[t]+sorted_probs[t+1])/2;return thresh
+TITLE = 'Multi-Tagger v1.3'
+DESCRIPTION = '\nMulti-Tagger is a versatile application for advanced image analysis and captioning. Supports <b>CUDA</b> and <b>CPU</b>.\n'
+
+SWINV2_MODEL_DSV3_REPO = 'SmilingWolf/wd-swinv2-tagger-v3'
+CONV_MODEL_DSV3_REPO = 'SmilingWolf/wd-convnext-tagger-v3'
+VIT_MODEL_DSV3_REPO = 'SmilingWolf/wd-vit-tagger-v3'
+VIT_LARGE_MODEL_DSV3_REPO = 'SmilingWolf/wd-vit-large-tagger-v3'
+EVA02_LARGE_MODEL_DSV3_REPO = 'SmilingWolf/wd-eva02-large-tagger-v3'
+MOAT_MODEL_DSV2_REPO = 'SmilingWolf/wd-v1-4-moat-tagger-v2'
+SWIN_MODEL_DSV2_REPO = 'SmilingWolf/wd-v1-4-swinv2-tagger-v2'
+CONV_MODEL_DSV2_REPO = 'SmilingWolf/wd-v1-4-convnext-tagger-v2'
+CONV2_MODEL_DSV2_REPO = 'SmilingWolf/wd-v1-4-convnextv2-tagger-v2'
+VIT_MODEL_DSV2_REPO = 'SmilingWolf/wd-v1-4-vit-tagger-v2'
+EVA02_LARGE_MODEL_IS_DSV1_REPO = 'deepghs/idolsankaku-eva02-large-tagger-v1'
+SWINV2_MODEL_IS_DSV1_REPO = 'deepghs/idolsankaku-swinv2-tagger-v1'
+
+# Global variables for model components (for memory management)
+CURRENT_MODEL = None
+CURRENT_MODEL_NAME = None
+CURRENT_TAGS_DF = None
+CURRENT_TAG_NAMES = None
+CURRENT_RATING_INDEXES = None
+CURRENT_GENERAL_INDEXES = None
+CURRENT_CHARACTER_INDEXES = None
+CURRENT_MODEL_TARGET_SIZE = None
+
+# Custom CSS for gallery styling
+css = """
+#custom-gallery {--row-height: 180px;display: grid;grid-auto-rows: min-content;gap: 10px;}
+#custom-gallery .thumbnail-item {height: var(--row-height);width: 100%;position: relative;overflow: hidden;border-radius: 8px;box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);transition: transform 0.2s ease,  box-shadow 0.2s ease;}
+#custom-gallery .thumbnail-item:hover {transform: translateY(-3px);box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);}
+#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: contain;margin: 0 auto;display: block;}
+#custom-gallery .thumbnail-item img.portrait {max-width: 100%;}
+#custom-gallery .thumbnail-item img.landscape {max-height: 100%;}
+.gallery-container {max-height: 500px;overflow-y: auto;padding-right: 0px;--size-80: 500px;}
+.thumbnails {display: flex;position: absolute;bottom: 0;width: 120px;overflow-x: scroll;padding-top: 320px;padding-bottom: 280px;padding-left: 4px;flex-wrap: wrap;}
+#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: initial;width: fit-content;margin: 0px auto;display: block;}
+"""
+
+MODEL_FILENAME = 'model.onnx'
+LABEL_FILENAME = 'selected_tags.csv'
+
 class Timer:
-	def __init__(self):self.start_time=time.perf_counter();self.checkpoints=[('Start', self.start_time)]
-	def checkpoint(self, label='Checkpoint'):now=time.perf_counter();self.checkpoints.append((label, now))
-	def report(self, is_clear_checkpoints=True):
-		max_label_length=max(len(label)for(label, _)in self.checkpoints);prev_time=self.checkpoints[0][1]
-		for(label, curr_time)in self.checkpoints[1:]:elapsed=curr_time-prev_time;print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds");prev_time=curr_time
-		if is_clear_checkpoints:self.checkpoints.clear();self.checkpoint()
-	def report_all(self):
-		print('\n> Execution Time Report:');max_label_length=max(len(label)for(label, _)in self.checkpoints)if len(self.checkpoints)>0 else 0;prev_time=self.start_time
-		for(label, curr_time)in self.checkpoints[1:]:elapsed=curr_time-prev_time;print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds");prev_time=curr_time
-		total_time=self.checkpoints[-1][1]-self.start_time;print(f"{'Total Execution Time'.ljust(max_label_length)}: {total_time:.3f} seconds\n");self.checkpoints.clear()
-	def restart(self):self.start_time=time.perf_counter();self.checkpoints=[('Start', self.start_time)]
+    """Utility class for measuring execution time of different operations"""
+
+    def __init__(self):
+        self.start_time = time.perf_counter()
+        self.checkpoints = [('Start', self.start_time)]
+
+    def checkpoint(self, label='Checkpoint'):
+        """Add a checkpoint with a label"""
+        now = time.perf_counter()
+        self.checkpoints.append((label, now))
+
+    def report(self, is_clear_checkpoints=True):
+        """Report time elapsed since last checkpoint"""
+        max_label_length = max(len(label) for (label, _) in self.checkpoints) if self.checkpoints else 0
+        prev_time = self.checkpoints[0][1] if self.checkpoints else self.start_time
+
+        for (label, curr_time) in self.checkpoints[1:]:
+            elapsed = curr_time - prev_time
+            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
+            prev_time = curr_time
+
+        if is_clear_checkpoints:
+            self.checkpoints.clear()
+            self.checkpoint()
+
+    def report_all(self):
+        """Report all checkpoint times including total execution time"""
+        print('\n> Execution Time Report:')
+        max_label_length = max(len(label) for (label, _) in self.checkpoints) if len(self.checkpoints) > 0 else 0
+        prev_time = self.start_time
+
+        for (label, curr_time) in self.checkpoints[1:]:
+            elapsed = curr_time - prev_time
+            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
+            prev_time = curr_time
+
+        total_time = self.checkpoints[-1][1] - self.start_time if self.checkpoints else 0
+        print(f"{'Total Execution Time'.ljust(max_label_length)}: {total_time:.3f} seconds\n")
+        self.checkpoints.clear()
+
+    def restart(self):
+        """Restart the timer"""
+        self.start_time = time.perf_counter()
+        self.checkpoints = [('Start', self.start_time)]
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--score-slider-step', type=float, default=0.05)
+    parser.add_argument('--score-general-threshold', type=float, default=0.35)
+    parser.add_argument('--score-character-threshold', type=float, default=0.85)
+    parser.add_argument('--share', action='store_true')
+    return parser.parse_args()
+
+def load_labels(dataframe) -> tuple:
+    """Load tag names and their category indexes from the dataframe"""
+    name_series = dataframe['name']
+    tag_names = name_series.tolist()
+
+    # Find indexes for different tag categories
+    rating_indexes = list(np.where(dataframe['category'] == 9)[0])
+    general_indexes = list(np.where(dataframe['category'] == 0)[0])
+    character_indexes = list(np.where(dataframe['category'] == 4)[0])
+
+    return tag_names, rating_indexes, general_indexes, character_indexes
+
+def mcut_threshold(probs):
+    """Calculate threshold using Maximum Change in second derivative (MCut) method"""
+    sorted_probs = probs[probs.argsort()[::-1]]
+    difs = sorted_probs[:-1] - sorted_probs[1:]
+    t = difs.argmax()
+    thresh = (sorted_probs[t] + sorted_probs[t + 1]) / 2
+    return thresh
+
+def _download_model_files(model_repo):
+    """Download model files from HuggingFace Hub"""
+    csv_path = huggingface_hub.hf_hub_download(model_repo, LABEL_FILENAME)
+    model_path = huggingface_hub.hf_hub_download(model_repo, MODEL_FILENAME)
+    return csv_path, model_path
+
+def create_optimized_ort_session(model_path):
+    """Create an optimized ONNX Runtime session with GPU support"""
+    # Configure session options for better performance
+    sess_options = ort.SessionOptions()
+    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+    sess_options.intra_op_num_threads = 0  # Use all available cores
+    sess_options.execution_mode = ort.ExecutionMode.ORT_PARALLEL
+    sess_options.enable_mem_pattern = True
+    sess_options.enable_cpu_mem_arena = True
+
+    # Check available providers
+    available_providers = ort.get_available_providers()
+    print(f"Available ONNX Runtime providers: {available_providers}")
+
+    # Configure execution providers (prefer CUDA if available)
+    providers = []
+
+    # Use CUDA if available
+    if 'CUDAExecutionProvider' in available_providers:
+        providers.append('CUDAExecutionProvider')
+        print("Using CUDA provider for ONNX inference")
+    else:
+        print("CUDA provider not available, falling back to CPU")
+
+    # Always include CPU as fallback
+    providers.append('CPUExecutionProvider')
+
+    try:
+        session = ort.InferenceSession(model_path, sess_options, providers=providers)
+        print(f"Model loaded with providers: {session.get_providers()}")
+        return session
+    except Exception as e:
+        print(f"Failed to create ONNX session: {e}")
+        raise
+
+def _load_model_components_optimized(model_repo):
+    """Load and optimize model components"""
+    global CURRENT_MODEL, CURRENT_MODEL_NAME, CURRENT_TAGS_DF, CURRENT_TAG_NAMES
+    global CURRENT_RATING_INDEXES, CURRENT_GENERAL_INDEXES, CURRENT_CHARACTER_INDEXES, CURRENT_MODEL_TARGET_SIZE
+
+    # Only reload if model changed
+    if model_repo == CURRENT_MODEL_NAME and CURRENT_MODEL is not None:
+        return
+
+    # Download files
+    csv_path, model_path = _download_model_files(model_repo)
+
+    # Load optimized ONNX model
+    CURRENT_MODEL = create_optimized_ort_session(model_path)
+
+    # Load tags
+    tags_df = pd.read_csv(csv_path)
+    tag_names, rating_indexes, general_indexes, character_indexes = load_labels(tags_df)
+
+    # Store in global variables
+    CURRENT_TAGS_DF = tags_df
+    CURRENT_TAG_NAMES = tag_names
+    CURRENT_RATING_INDEXES = rating_indexes
+    CURRENT_GENERAL_INDEXES = general_indexes
+    CURRENT_CHARACTER_INDEXES = character_indexes
+
+    # Get model input size
+    _, height, width, _ = CURRENT_MODEL.get_inputs()[0].shape
+    CURRENT_MODEL_TARGET_SIZE = height
+    CURRENT_MODEL_NAME = model_repo
+
+def _raw_predict(image_array, model_session):
+    """Run raw prediction using the model session"""
+    input_name = model_session.get_inputs()[0].name
+    label_name = model_session.get_outputs()[0].name
+    preds = model_session.run([label_name], {input_name: image_array})[0]
+    return preds[0].astype(float)
+
+def unload_model():
+    """Explicitly unload the current model from memory"""
+    global CURRENT_MODEL, CURRENT_MODEL_NAME, CURRENT_TAGS_DF, CURRENT_TAG_NAMES
+    global CURRENT_RATING_INDEXES, CURRENT_GENERAL_INDEXES, CURRENT_CHARACTER_INDEXES, CURRENT_MODEL_TARGET_SIZE
+
+    # Delete the model session
+    if CURRENT_MODEL is not None:
+        del CURRENT_MODEL
+        CURRENT_MODEL = None
+
+    # Clear other large objects
+    CURRENT_TAGS_DF = None
+    CURRENT_TAG_NAMES = None
+    CURRENT_RATING_INDEXES = None
+    CURRENT_GENERAL_INDEXES = None
+    CURRENT_CHARACTER_INDEXES = None
+    CURRENT_MODEL_TARGET_SIZE = None
+    CURRENT_MODEL_NAME = None
+
+    # Force garbage collection
+    import gc
+    gc.collect()
+
+    # Clear CUDA cache if using GPU
+    try:
+        import torch
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except ImportError:
+        pass
+
+def cleanup_after_processing():
+    """Cleanup resources after processing"""
+    unload_model()
+
 class Predictor:
+    """Main predictor class for handling image tagging"""
+
     def __init__(self):
-        self.model_target_size = None
+        self.model_components = None
         self.last_loaded_repo = None
-    def download_model(self, model_repo):
-        csv_path = huggingface_hub.hf_hub_download(model_repo, LABEL_FILENAME, )
-        model_path = huggingface_hub.hf_hub_download(model_repo, MODEL_FILENAME, )
-        return csv_path, model_path
+
     def load_model(self, model_repo):
-        if model_repo == self.last_loaded_repo:
+        """Load model if not already loaded"""
+        if model_repo == self.last_loaded_repo and self.model_components is not None:
             return
-        csv_path, model_path = self.download_model(model_repo)
-        tags_df = pd.read_csv(csv_path)
-        sep_tags = load_labels(tags_df)
-        self.tag_names = sep_tags[0]
-        self.rating_indexes = sep_tags[1]
-        self.general_indexes = sep_tags[2]
-        self.character_indexes = sep_tags[3]
-        model = rt.InferenceSession(model_path)
-        _, height, width, _ = model.get_inputs()[0].shape
-        self.model_target_size = height
+        _load_model_components_optimized(model_repo)
         self.last_loaded_repo = model_repo
-        self.model = model
+
     def prepare_image(self, path):
+        """Prepare image for model input"""
         image = Image.open(path)
-        image = image.convert("RGBA")
-        target_size = self.model_target_size
-        canvas = Image.new("RGBA", image.size, (255, 255, 255))
+        image = image.convert('RGBA')
+        target_size = CURRENT_MODEL_TARGET_SIZE
+
+        # Create white background and composite
+        canvas = Image.new('RGBA', image.size, (255, 255, 255))
         canvas.alpha_composite(image)
-        image = canvas.convert("RGB")
-        # Pad image to square
+        image = canvas.convert('RGB')
+
+        # Pad 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 = Image.new('RGB', (max_dim, max_dim), (255, 255, 255))
         padded_image.paste(image, (pad_left, pad_top))
-        # Resize
+
+        # Resize if needed
         if max_dim != target_size:
-            padded_image = padded_image.resize(
-                (target_size, target_size),
-                Image.BICUBIC,
-            )
-        # Convert to numpy array
+            padded_image = padded_image.resize((target_size, target_size), Image.BICUBIC)
+
+        # Convert to array and preprocess
         image_array = np.asarray(padded_image, dtype=np.float32)
-        # Convert PIL-native RGB to BGR
-        image_array = image_array[:, :, ::-1]
+        image_array = image_array[:, :, ::-1]  # BGR to RGB
         return np.expand_dims(image_array, axis=0)
 
     def create_file(self, content: str, directory: str, fileName: str) -> str:
-        # Write the content to a file
+        """Create a file with the given content"""
         file_path = os.path.join(directory, fileName)
         if fileName.endswith('.json'):
-            with open(file_path, 'w', encoding="utf-8") as file:
+            with open(file_path, 'w', encoding='utf-8') as file:
                 file.write(content)
         else:
-            with open(file_path, 'w+', encoding="utf-8") as file:
+            with open(file_path, 'w+', encoding='utf-8') as file:
                 file.write(content)
         return file_path
-    def predict(
-        self,
-        gallery,
-        model_repo,
-        model_repo_2,
-        general_thresh,
-        general_mcut_enabled,
-        character_thresh,
-        character_mcut_enabled,
-        characters_merge_enabled,
-        beautify_model_repo,
-        additional_tags_prepend,
-        additional_tags_append,
-        tag_results,
-        progress=gr.Progress()
-        ):
-        # Clear tag_results before starting a new prediction
+
+    def predict(self, gallery, model_repo, model_repo_2, general_thresh, general_mcut_enabled,
+                character_thresh, character_mcut_enabled, characters_merge_enabled,
+                additional_tags_prepend, additional_tags_append, tag_results, progress=gr.Progress()):
+        """Main prediction function for processing images"""
         tag_results.clear()
         gallery_len = len(gallery)
         print(f"Predict load model: {model_repo}, gallery length: {gallery_len}")
-        timer = Timer()  # Create a timer
-        progressRatio = 0.5 if beautify_model_repo else 1
+
+        timer = Timer()
+        progressRatio = 1
         progressTotal = gallery_len + 1
         current_progress = 0
-        # Initialize variables that need to be accessible throughout the function
-        final_categorized_output = ""
-        categorized_output_strings = []
         txt_infos = []
         output_dir = tempfile.mkdtemp()
+
         if not os.path.exists(output_dir):
             os.makedirs(output_dir)
+
+        # Load initial model
         self.load_model(model_repo)
-        current_progress += progressRatio/progressTotal;
-        progress(current_progress, desc="Initialize wd model finished")
-        timer.checkpoint(f"Initialize wd model")
-        if beautify_model_repo:
-            print(f"Load model {beautify_model_repo}")
-            beautify = beautify_class(beautify_model_repo, loadModel=True)
-            current_progress += progressRatio/progressTotal;
-            progress(current_progress, desc="Initialize beautify model finished")
-            timer.checkpoint(f"Initialize beautify model")
+        current_progress += progressRatio / progressTotal
+        progress(current_progress, desc='Initialize wd model finished')
+        timer.checkpoint("Initialize wd model")
         timer.report()
-        # Dictionary to track counters for each filename
+
         name_counters = defaultdict(int)
-        for idx, value in enumerate(gallery):
+
+        for (idx, value) in enumerate(gallery):
             try:
+                # Handle duplicate filenames
                 image_path = value[0]
                 image_name = os.path.splitext(os.path.basename(image_path))[0]
-                # Increment the counter for the current name
                 name_counters[image_name] += 1
                 if name_counters[image_name] > 1:
                     image_name = f"{image_name}_{name_counters[image_name]:02d}"
+
+                # Prepare image
                 image = self.prepare_image(image_path)
-                # Run first model
                 print(f"Gallery {idx:02d}: Starting run first model ({model_repo})...")
+
+                # Load and run first model
                 self.load_model(model_repo)
-                input_name = self.model.get_inputs()[0].name
-                label_name = self.model.get_outputs()[0].name
-                preds = self.model.run([label_name], {input_name: image})[0]
-                labels = list(zip(self.tag_names, preds[0].astype(float)))
-                # Process first model results
-                ratings_names = [labels[i] for i in self.rating_indexes]
+                preds = _raw_predict(image, CURRENT_MODEL)
+                labels = list(zip(CURRENT_TAG_NAMES, preds))
+
+                # Process ratings
+                ratings_names = [labels[i] for i in CURRENT_RATING_INDEXES]
                 rating = dict(ratings_names)
 
-                general_names = [labels[i] for i in self.general_indexes]
+                # Process general tags
+                general_names = [labels[i] for i in CURRENT_GENERAL_INDEXES]
                 if general_mcut_enabled:
                     general_probs = np.array([x[1] for x in general_names])
                     general_thresh_temp = mcut_threshold(general_probs)
                 else:
                     general_thresh_temp = general_thresh
+
                 general_res = [x for x in general_names if x[1] > general_thresh_temp]
                 general_res = dict(general_res)
-                character_names = [labels[i] for i in self.character_indexes]
+
+                # Process character tags
+                character_names = [labels[i] for i in CURRENT_CHARACTER_INDEXES]
                 if character_mcut_enabled:
                     character_probs = np.array([x[1] for x in character_names])
                     character_thresh_temp = mcut_threshold(character_probs)
                     character_thresh_temp = max(0.15, character_thresh_temp)
                 else:
                     character_thresh_temp = character_thresh
+
                 character_res = [x for x in character_names if x[1] > character_thresh_temp]
                 character_res = dict(character_res)
-                # Collect tags from first model
                 character_list_1 = list(character_res.keys())
+
+                # Sort general tags by confidence
                 sorted_general_list_1 = sorted(general_res.items(), key=lambda x: x[1], reverse=True)
                 sorted_general_list_1 = [x[0] for x in sorted_general_list_1]
-                # Run second model if selected and different from first
+
+                # Handle second model if provided
                 if model_repo_2 and model_repo_2 != model_repo:
                     print(f"Gallery {idx:02d}: Starting run second model ({model_repo_2})...")
                     self.load_model(model_repo_2)
-                    preds_2 = self.model.run([label_name], {input_name: image})[0]
-                    labels_2 = list(zip(self.tag_names, preds_2[0].astype(float)))
-                    # Process second model results
-                    general_names_2 = [labels_2[i] for i in self.general_indexes]
+                    preds_2 = _raw_predict(image, CURRENT_MODEL)
+                    labels_2 = list(zip(CURRENT_TAG_NAMES, preds_2))
+
+                    # Process general tags from second model
+                    general_names_2 = [labels_2[i] for i in CURRENT_GENERAL_INDEXES]
                     if general_mcut_enabled:
                         general_probs_2 = np.array([x[1] for x in general_names_2])
                         general_thresh_temp_2 = mcut_threshold(general_probs_2)
                     else:
                         general_thresh_temp_2 = general_thresh
+
                     general_res_2 = [x for x in general_names_2 if x[1] > general_thresh_temp_2]
                     general_res_2 = dict(general_res_2)
-                    character_names_2 = [labels_2[i] for i in self.character_indexes]
+
+                    # Process character tags from second model
+                    character_names_2 = [labels_2[i] for i in CURRENT_CHARACTER_INDEXES]
                     if character_mcut_enabled:
                         character_probs_2 = np.array([x[1] for x in character_names_2])
                         character_thresh_temp_2 = mcut_threshold(character_probs_2)
                         character_thresh_temp_2 = max(0.15, character_thresh_temp_2)
                     else:
                         character_thresh_temp_2 = character_thresh
+
                     character_res_2 = [x for x in character_names_2 if x[1] > character_thresh_temp_2]
                     character_res_2 = dict(character_res_2)
-                    # Collect tags from second model
                     character_list_2 = list(character_res_2.keys())
+
+                    # Sort general tags from second model
                     sorted_general_list_2 = sorted(general_res_2.items(), key=lambda x: x[1], reverse=True)
                     sorted_general_list_2 = [x[0] for x in sorted_general_list_2]
-                    # Combine results from both models (+ remove duplicates)
+
+                    # Combine results from both models
                     combined_character_list = list(set(character_list_1 + character_list_2))
                     combined_general_list = list(set(sorted_general_list_1 + sorted_general_list_2))
                 else:
-                    # Only first model was used
                     combined_character_list = character_list_1
                     combined_general_list = sorted_general_list_1
-                # Remove values from combined_character_list that already exist in combined_general_list
-                combined_character_list = [item for item in combined_character_list if item not in combined_general_list]
-                # Handle prepend/append tags
-                prepend_list = [tag.strip() for tag in additional_tags_prepend.split(",") if tag.strip()]
-                append_list = [tag.strip() for tag in additional_tags_append.split(",") if tag.strip()]
+
+                # Remove characters from general tags if merging is disabled
+                if not characters_merge_enabled:
+                    combined_character_list = [item for item in combined_character_list
+                                             if item not in combined_general_list]
+
+                # Handle additional tags
+                prepend_list = [tag.strip() for tag in additional_tags_prepend.split(',') if tag.strip()]
+                append_list = [tag.strip() for tag in additional_tags_append.split(',') if tag.strip()]
+
+                # Avoid duplicates in prepend/append lists
                 if prepend_list and append_list:
                     append_list = [item for item in append_list if item not in prepend_list]
-                # Remove values from combined_general_list that already exist in prepend_list or append_list
+
+                # Remove prepended tags from main list
                 if prepend_list:
                     combined_general_list = [item for item in combined_general_list if item not in prepend_list]
+
+                # Remove appended tags from main list
                 if append_list:
                     combined_general_list = [item for item in combined_general_list if item not in append_list]
+
+                # Combine all tags
                 combined_general_list = prepend_list + combined_general_list + append_list
-                sorted_general_strings = ", ".join((combined_character_list if characters_merge_enabled else []) + combined_general_list).replace("(", "\\(").replace(")", "\\)")
-                classified_tags, unclassified_tags = classify_tags(combined_general_list)
-                # Create a single string of ALL categorized tags for the current image
-                categorized_output_string = ', '.join([', '.join(tags) for tags in classified_tags.values()])
-                categorized_output_strings.append(categorized_output_string)
-                # Collect all categorized output strings into a single string
-                final_categorized_output = ', '.join(categorized_output_strings).replace("(", "\\(").replace(")", "\\)")
-                # Create a .txt file for "Output (string)" and "Categorized Output (string)"
-                txt_content = f"Output (string): {sorted_general_strings}\nCategorized Output (string): {final_categorized_output}"
+
+                # Format output string
+                sorted_general_strings = ', '.join(
+                    (combined_character_list if characters_merge_enabled else []) +
+                    combined_general_list
+                ).replace('(', '\\(').replace(')', '\\)').replace('_', ' ')
+
+                # Generate categorized output
+                categorized_strings = categorize_tags_output(sorted_general_strings, character_res).replace('(', '\\(').replace(')', '\\)')
+                categorized_json = generate_tags_json(sorted_general_strings, character_res)
+                
+                # Create output files
+                txt_content = f"Output (string): {sorted_general_strings}\n\nCategorized Output: {categorized_strings}"
                 txt_file = self.create_file(txt_content, output_dir, f"{image_name}_output.txt")
-                txt_infos.append({"path": txt_file, "name": f"{image_name}_output.txt"})
-                # Create a .json file for "Categorized (tags)"
-                json_content = json.dumps(classified_tags, indent=4)
-                json_file = self.create_file(json_content, output_dir, f"{image_name}_categorized_tags.json")
-                txt_infos.append({"path": json_file, "name": f"{image_name}_categorized_tags.json"})
-                # Save a copy of the uploaded image in PNG format
+                txt_infos.append({'path': txt_file, 'name': f"{image_name}_output.txt"})
+
+                # Save image copy
                 image_path = value[0]
                 image = Image.open(image_path)
-                image.save(os.path.join(output_dir, f"{image_name}.png"), format="PNG")
-                txt_infos.append({"path": os.path.join(output_dir, f"{image_name}.png"), "name": f"{image_name}.png"})
-                current_progress += progressRatio/progressTotal;
-                progress(current_progress, desc=f"image{idx:02d}, predict finished")
-                timer.checkpoint(f"image{idx:02d}, predict finished")
-                if beautify_model_repo:
-                    print(f"Starting beautify...")
-                    beautify_strings = beautify.beautify(sorted_general_strings)
-                    # Handle potential None returns from beautify
-                    if beautify_strings is None:
-                        beautify_strings = "Beautify failed - see console logs"
-                    else:
-                        beautify_strings = re.sub(r"Title:", "", beautify_strings)
-                        beautify_strings = re.sub(r"\n+", ",", beautify_strings)
-                        beautify_strings = re.sub(r",,+", ",", beautify_strings)
-                    sorted_general_strings += ",\n\n" + beautify_strings
-                    current_progress += progressRatio/progressTotal;
-                    progress(current_progress, desc=f"image{idx:02d}, beautify finished!")
-                    timer.checkpoint(f"image{idx:02d}, beautify finished!")
-                txt_file = self.create_file(sorted_general_strings, output_dir, image_name + ".txt")
-                txt_infos.append({"path":txt_file, "name": image_name + ".txt"})
-
-                # Store the result in tag_results using image_path as the key
+                image.save(os.path.join(output_dir, f"{image_name}.png"), format='PNG')
+                txt_infos.append({'path': os.path.join(output_dir, f"{image_name}.png"), 'name': f"{image_name}.png"})
+
+                # Create tags text file
+                txt_file = self.create_file(sorted_general_strings, output_dir, image_name + '.txt')
+                # Create categorized tags file
+                categorized_file = self.create_file(categorized_strings, output_dir, f"{image_name}_categorized.txt")
+                txt_infos.append({'path': categorized_file, 'name': f"{image_name}_categorized.txt"})
+                txt_infos.append({'path': txt_file, 'name': image_name + '.txt'})
+                
+                # Create JSON file
+                json_content = json.dumps(categorized_json, indent=2, ensure_ascii=False)
+                json_file = self.create_file(json_content, output_dir, f"{image_name}_categorized.json")
+                txt_infos.append({'path': json_file, 'name': f"{image_name}_categorized.json"})
+
+                # Store results
                 tag_results[image_path] = {
-                    "strings": sorted_general_strings,
-                    "strings2": categorized_output_string,  # Store the categorized output string here
-                    "classified_tags": classified_tags,
-                    "rating": rating,
-                    "character_res": character_res,
-                    "general_res": general_res,
-                    "unclassified_tags": unclassified_tags,
-                    "summarize_tags": ""  # Initialize as empty string
+                    'strings': sorted_general_strings,
+                    'categorized_strings': categorized_strings,
+                    'categorized_json': categorized_json,
+                    'rating': rating,
+                    'character_res': character_res,
+                    'general_res': general_res
                 }
+
+                # Update progress
+                current_progress += progressRatio / progressTotal
+                progress(current_progress, desc=f"image{idx:02d}, predict finished")
+                timer.checkpoint(f"image{idx:02d}, predict finished")
                 timer.report()
+
             except Exception as e:
                 print(traceback.format_exc())
-                print("Error predict: " + str(e))
-        # Zip creation logic:
+                print('Error predict: ' + str(e))
+
+        # Create download zip
         download = []
         if txt_infos is not None and len(txt_infos) > 0:
-            downloadZipPath = os.path.join(output_dir, "Multi-Tagger-" + datetime.now().strftime("%Y%m%d-%H%M%S") + ".zip")
+            downloadZipPath = os.path.join(
+                output_dir,
+                'Multi-Tagger-' + datetime.now().strftime('%Y%m%d-%H%M%S') + '.zip'
+            )
             with zipfile.ZipFile(downloadZipPath, 'w', zipfile.ZIP_DEFLATED) as taggers_zip:
                 for info in txt_infos:
-                    # Get file name from lookup
-                    taggers_zip.write(info["path"], arcname=info["name"])
+                    taggers_zip.write(info['path'], arcname=info['name'])
+                # If using GPU, model will auto unload after zip file creation
+                cleanup_after_processing() # Comment here to turn off this behavior
             download.append(downloadZipPath)
-        # End zip creation logic
 
-        if beautify_model_repo:
-            beautify.release_vram()
-            del beautify
         progress(1, desc=f"Predict completed")
-        timer.report_all()  # Print all recorded times
-        print("Predict is complete.")
-        # Make sure all required variables are returned with proper defaults
-        if 'sorted_general_strings' not in locals():
-            sorted_general_strings = ""
-        if 'final_categorized_output' not in locals():
-            final_categorized_output = ""
-        if 'classified_tags' not in locals():
-            classified_tags = {}
-        if 'rating' not in locals():
-            rating = {}
-        if 'character_res' not in locals():
-            character_res = {}
-        if 'general_res' not in locals():
-            general_res = {}
-        if 'unclassified_tags' not in locals():
-            unclassified_tags = []
-
-        return download, sorted_general_strings, final_categorized_output, classified_tags, rating, character_res, general_res, unclassified_tags, tag_results
+        timer.report_all()
+        print('Predict is complete.')
+
+        # Return first image results as default
+        first_image_results = '', {}, {}, {}, '', {}
+        if gallery and len(gallery) > 0:
+            first_image_path = gallery[0][0]
+            if first_image_path in tag_results:
+                first_result = tag_results[first_image_path]
+                character_tags_formatted = ", ".join([name.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+                                                    for name in first_result['character_res'].keys()])
+                first_image_results = (
+                    first_result['strings'],
+                    first_result['rating'],
+                    character_tags_formatted,
+                    first_result['general_res'],
+                    first_result.get('categorized_strings', ''),
+                    first_result.get('categorized_json', {})
+                )
+
+
+        return (
+            download,
+            first_image_results[0],
+            first_image_results[1],
+            first_image_results[2],
+            first_image_results[3],
+            first_image_results[4],
+            first_image_results[5],
+            tag_results
+        )
+
 def get_selection_from_gallery(gallery: list, tag_results: dict, selected_state: gr.SelectData):
+    # Return first image results if no selection
+    if not selected_state and gallery and len(gallery) > 0:
+        first_image_path = gallery[0][0]
+        if first_image_path in tag_results:
+            first_result = tag_results[first_image_path]
+            character_tags_formatted = ", ".join([name.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+                                                for name in first_result['character_res'].keys()])
+            return (
+                first_result['strings'],
+                first_result['rating'],
+                character_tags_formatted,
+                first_result['general_res'],
+                first_result.get('categorized_strings', ''),
+                first_result.get('categorized_json', {})
+            )
+
     if not selected_state:
-        return selected_state
-    tag_result = { 
-        "strings": "", 
-        "strings2": "", 
-        "classified_tags": "{}", 
-        "rating": "", 
-        "character_res": "", 
-        "general_res": "", 
-        "unclassified_tags": "{}", 
-        "summarize_tags": "" 
-    }
-    if selected_state.value["image"]["path"] in tag_results:
-        tag_result = tag_results[selected_state.value["image"]["path"]]
-    return (selected_state.value["image"]["path"], selected_state.value["caption"]), tag_result["strings"], tag_result["strings2"], tag_result["classified_tags"], tag_result["rating"], tag_result["character_res"], tag_result["general_res"], tag_result["unclassified_tags"], tag_result["summarize_tags"]
-def append_gallery(gallery:list, image:str):
-	if gallery is None:gallery=[]
-	if not image:return gallery, None
-	gallery.append(image);return gallery, None
-def extend_gallery(gallery:list, images):
-	if gallery is None:gallery=[]
-	if not images:return gallery
-	gallery.extend(images);return gallery
-def remove_image_from_gallery(gallery:list, selected_image:str):
-	if not gallery or not selected_image:return gallery
-	selected_image=ast.literal_eval(selected_image)
-	if selected_image in gallery:gallery.remove(selected_image)
-	return gallery
+        return '', {}, '', {}, '', {}
+
+    # Get selected image path
+    selected_value = selected_state.value
+    image_path = None
+
+    if isinstance(selected_value, dict) and 'image' in selected_value:
+        image_path = selected_value['image']['path']
+    elif isinstance(selected_value, (list, tuple)) and len(selected_value) > 0:
+        image_path = selected_value[0]
+    else:
+        image_path = str(selected_value)
+
+    # Return stored results
+    if image_path in tag_results:
+        result = tag_results[image_path]
+
+        character_tags_formatted = ", ".join([name.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+                                            for name in result['character_res'].keys()])
+        return (
+            result['strings'],
+            result['rating'],
+            character_tags_formatted, 
+            result['general_res'],
+            result.get('categorized_strings', ''),
+            result.get('categorized_json', {})
+        )
+
+    return '', {}, '', {}, '', {}
+
+def append_gallery(gallery: list, image: str):
+    """Add a single image to the gallery"""
+    if gallery is None:
+        gallery = []
+    if not image:
+        return gallery, None
+    gallery.append(image)
+    return gallery, None
+
+def extend_gallery(gallery: list, images):
+    """Add multiple images to the gallery"""
+    if gallery is None:
+        gallery = []
+    if not images:
+        return gallery
+    gallery.extend(images)
+    return gallery
+
+# Parse arguments and initialize predictor
 args = parse_args()
 predictor = Predictor()
 dropdown_list = [
-    EVA02_LARGE_MODEL_DSV3_REPO,
-    VIT_LARGE_MODEL_DSV3_REPO,
-    SWINV2_MODEL_DSV3_REPO,
-    CONV_MODEL_DSV3_REPO,
-    VIT_MODEL_DSV3_REPO,
-    # ---
-    MOAT_MODEL_DSV2_REPO,
-    SWIN_MODEL_DSV2_REPO,
-    CONV_MODEL_DSV2_REPO,
-    CONV2_MODEL_DSV2_REPO,
-    VIT_MODEL_DSV2_REPO,
-    # ---
-    EVA02_LARGE_MODEL_IS_DSV1_REPO,
-    SWINV2_MODEL_IS_DSV1_REPO,
+    EVA02_LARGE_MODEL_DSV3_REPO, VIT_LARGE_MODEL_DSV3_REPO, SWINV2_MODEL_DSV3_REPO,
+    CONV_MODEL_DSV3_REPO, VIT_MODEL_DSV3_REPO, MOAT_MODEL_DSV2_REPO,
+    SWIN_MODEL_DSV2_REPO, CONV_MODEL_DSV2_REPO, CONV2_MODEL_DSV2_REPO,
+    VIT_MODEL_DSV2_REPO, EVA02_LARGE_MODEL_IS_DSV1_REPO, SWINV2_MODEL_IS_DSV1_REPO
 ]
+
 def _restart_space():
-	HF_TOKEN=os.getenv('HF_TOKEN')
-	if not HF_TOKEN:raise ValueError('HF_TOKEN environment variable is not set.')
-	huggingface_hub.HfApi().restart_space(repo_id='Werli/Multi-Tagger', token=HF_TOKEN, factory_reboot=False)
-scheduler=BackgroundScheduler()
-# Add a job to restart the space every 2 days (172800 seconds)
-restart_space_job = scheduler.add_job(_restart_space, "interval", seconds=172800)
+    """Restart the HuggingFace Space periodically for stability"""
+    HF_TOKEN = os.getenv('HF_TOKEN')
+    if not HF_TOKEN:
+        raise ValueError('HF_TOKEN environment variable is not set.')
+    huggingface_hub.HfApi().restart_space(
+        repo_id='Werli/Multi-Tagger',
+        token=HF_TOKEN,
+        factory_reboot=False
+    )
+
+# Setup scheduler for periodic restarts
+scheduler = BackgroundScheduler()
+restart_space_job = scheduler.add_job(_restart_space, 'interval', seconds=172800)
 scheduler.start()
-next_run_time_utc=restart_space_job.next_run_time.astimezone(timezone.utc)
-NEXT_RESTART=f"Next Restart: {next_run_time_utc.strftime('%Y-%m-%d %H:%M:%S')} (UTC) - The space will restart every 2 days to ensure stability and performance. It uses a background scheduler to handle the restart process."
+next_run_time_utc = restart_space_job.next_run_time.astimezone(timezone.utc)
+NEXT_RESTART = f"Next Restart: {next_run_time_utc.strftime('%Y-%m-%d %H:%M:%S')} (UTC) - The space will restart every 2 days to ensure stability and performance. It uses a background scheduler to handle the restart process."
 
-css = """
-#custom-gallery {--row-height: 180px;display: grid;grid-auto-rows: min-content;gap: 10px;}
-#custom-gallery .thumbnail-item {height: var(--row-height);width: 100%;position: relative;overflow: hidden;border-radius: 8px;box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);transition: transform 0.2s ease,  box-shadow 0.2s ease;}
-#custom-gallery .thumbnail-item:hover {transform: translateY(-3px);box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);}
-#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: contain;margin: 0 auto;display: block;}
-#custom-gallery .thumbnail-item img.portrait {max-width: 100%;}
-#custom-gallery .thumbnail-item img.landscape {max-height: 100%;}
-.gallery-container {max-height: 500px;overflow-y: auto;padding-right: 0px;--size-80: 500px;}
-.thumbnails {display: flex;position: absolute;bottom: 0;width: 120px;overflow-x: scroll;padding-top: 320px;padding-bottom: 280px;padding-left: 4px;flex-wrap: wrap;}
-#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: initial;width: fit-content;margin: 0px auto;display: block;}
-"""
-with gr.Blocks(title=TITLE, css=css, theme="Werli/Multi-Tagger", fill_width=True) as demo:
+with gr.Blocks(title=TITLE, css=css, theme='Werli/Purple-Crimson-Gradio-Theme', fill_width=True) as demo:
     gr.Markdown(value=f"<h1 style='text-align: center; margin-bottom: 1rem'>{TITLE}</h1>")
-    #gr.Markdown(value=DESCRIPTION)
     gr.Markdown(value=f"<p style='text-align: center;'>{DESCRIPTION}</p>")
-    with gr.Tab(label="Waifu Diffusion"):
+
+    with gr.Tab(label='Waifu Diffusion'):
         with gr.Row():
             with gr.Column():
-                submit = gr.Button(value="START", variant="primary", size="lg")
-                with gr.Column(variant="panel"):
-                    # Create an Image component for uploading images
-                    image_input = gr.Image(label="Upload an Image or clicking paste from clipboard button", type="filepath", sources=["upload", "clipboard"], height=150)
+
+                with gr.Column(variant='panel'):
+                    image_input = gr.Image(
+                        label='Upload an Image or clicking paste from clipboard button',
+                        type='filepath',
+                        sources=['upload', 'clipboard'],
+                        height=150
+                    )
                     with gr.Row():
-                        upload_button = gr.UploadButton("Upload multiple images", file_types=["image"], file_count="multiple", size="sm")
-                        remove_button = gr.Button("Remove Selected Image", size="sm")
+                        upload_button = gr.UploadButton(
+                            'Upload multiple images',
+                            file_types=['image'],
+                            file_count='multiple',
+                            size='sm'
+                        )
                     gallery = gr.Gallery(
                         columns=2,
-                        show_share_button=False, 
-                        interactive=True, 
-                        height="auto",
-                        label="Grid of images", 
-                        preview=False, 
-                        elem_id="custom-gallery"  # Added for custom styling
+                        show_share_button=False,
+                        interactive=True,
+                        height='auto',
+                        label='Grid of images',
+                        preview=False,
+                        elem_id='custom-gallery'
+                    )
+                submit = gr.Button(value='Analyze Images', variant='primary', size='lg')
+                with gr.Column(variant='panel'):
+                    model_repo = gr.Dropdown(
+                        dropdown_list,
+                        value=EVA02_LARGE_MODEL_DSV3_REPO,
+                        label='1st Model'
                     )
-                with gr.Column(variant="panel"):
-                    model_repo = gr.Dropdown(dropdown_list, value=EVA02_LARGE_MODEL_DSV3_REPO, label="1st Model", )
-                    PLUS = "+?"
+                    PLUS = '+?'
                     gr.Markdown(value=f"<p style='text-align: center;'>{PLUS}</p>")
-                    model_repo_2 = gr.Dropdown([None] + dropdown_list, value=None, label="2nd Model (Optional)", info="Select another model for diversified results.", )
-                with gr.Row():
-                    general_thresh = gr.Slider(0, 1, step=args.score_slider_step, value=args.score_general_threshold, label="General Tags Threshold", scale=3, )
-                    general_mcut_enabled = gr.Checkbox(value=False, label="Use MCut threshold", scale=1, )
+                    model_repo_2 = gr.Dropdown(
+                        [None] + dropdown_list,
+                        value=None,
+                        label='2nd Model (Optional)',
+                        info='Select another model for diversified results.'
+                    )
+
                 with gr.Row():
-                    character_thresh = gr.Slider(0, 1, step=args.score_slider_step, value=args.score_character_threshold, label="Character Tags Threshold", scale=3, )
-                    character_mcut_enabled = gr.Checkbox(value=False, label="Use MCut threshold", scale=1, )
+                    general_thresh = gr.Slider(
+                        0, 1,
+                        step=args.score_slider_step,
+                        value=args.score_general_threshold,
+                        label='General Tags Threshold',
+                        scale=3
+                    )
+                    general_mcut_enabled = gr.Checkbox(
+                        value=False,
+                        label='Use MCut threshold',
+                        scale=1
+                    )
+
                 with gr.Row():
-                    characters_merge_enabled = gr.Checkbox(value=True, label="Merge characters into the string output", scale=1, )
+                    character_thresh = gr.Slider(
+                        0, 1,
+                        step=args.score_slider_step,
+                        value=args.score_character_threshold,
+                        label='Character Tags Threshold',
+                        scale=3
+                    )
+                    character_mcut_enabled = gr.Checkbox(
+                        value=False,
+                        label='Use MCut threshold',
+                        scale=1
+                    )
+
                 with gr.Row():
-                    beautify_model_repo = gr.Dropdown([None] + beautify_list, value=None, label="Beautify Model", info="Use a model to describe or 'beautify' a single image into a readable English article.", )
+                    characters_merge_enabled = gr.Checkbox(
+                        value=False,
+                        label='Merge characters into the string output',
+                        scale=1
+                    )
+
                 with gr.Row():
-                    additional_tags_prepend = gr.Text(label="Prepend Additional tags (comma split)")
-                    additional_tags_append  = gr.Text(label="Append Additional tags (comma split)")
+                    additional_tags_prepend = gr.Text(
+                        label='Prepend Additional tags (comma split)'
+                    )
+                    additional_tags_append = gr.Text(
+                        label='Append Additional tags (comma split)'
+                    )
+
                 with gr.Row():
                     clear = gr.ClearButton(
-                        components=[gallery, model_repo, general_thresh, general_mcut_enabled, character_thresh, character_mcut_enabled, characters_merge_enabled, beautify_model_repo, additional_tags_prepend, additional_tags_append, ], variant="secondary", size="lg", )
-                with gr.Row():
-                    rating = gr.Label(label="Rating")
-            with gr.Column(variant="panel"):
-                download_file = gr.File(label="Download")  # 0
-                character_res = gr.Label(label="Output (characters)")  # 1
-                sorted_general_strings = gr.Textbox(label="Output", show_label=True, show_copy_button=True, lines=5)  # 2
-                final_categorized_output = gr.Textbox(label="Categorized", info="If tagging multiple images and got long tags,  please select an image to display tags correctly.", show_label=True, show_copy_button=True, lines=5)  # 3
-                pe_generate_btn = gr.Button(value="SUMMARIZE TAGS", size="lg", variant="primary") # 4
-                summarize_tags = gr.Textbox(label="Summarized Tags", show_label=True, show_copy_button=True, lines=6)  # 5
-                prompt_summarizer_model = gr.Radio(["Medium", "Long", "Flux"], label="Model Choice", value="Medium", info="Summarize your prompts with medium or long answers. It's recommended for Flux.") # 6
-                categorized = gr.JSON(label="Categorized (tags) - JSON")  # 7
-                general_res = gr.Label(label="Output (tags)")  # 8
-                unclassified = gr.JSON(label="Unclassified (tags)")  # 9
-                clear.add([download_file, sorted_general_strings, final_categorized_output, categorized, rating, character_res, general_res, unclassified, prompt_summarizer_model, summarize_tags, ])
+                        components=[
+                            gallery, model_repo, general_thresh, general_mcut_enabled,
+                            character_thresh, character_mcut_enabled, characters_merge_enabled,
+                            additional_tags_prepend, additional_tags_append
+                        ],
+                        variant='secondary',
+                        size='lg'
+                    )
+
+            with gr.Column(variant='panel'):
+                download_file = gr.File(label='Download')
+                character_res = gr.Textbox(
+                    label="Character tags",
+                    show_copy_button=True,
+                    lines=3
+                )
+                sorted_general_strings = gr.Textbox(
+                    label='Output',
+                    show_label=True,
+                    show_copy_button=True,
+                    lines=5
+                )
+                categorized_strings = gr.Textbox(
+                    label='Categorized',
+                    show_label=True,
+                    show_copy_button=True,
+                    lines=5
+                )
+                tags_json = gr.JSON(
+                    label='Categorized Tags (JSON)',
+                    visible=True
+                )
+                rating = gr.Label(label='Rating')
+                general_res = gr.Textbox(
+                    label="General tags",
+                    show_copy_button=True,
+                    lines=3,
+                    visible=False # Temp  
+                )
+            # State to store results
             tag_results = gr.State({})
-            # Define the event listener to add the uploaded image to the gallery
-            image_input.change(append_gallery, inputs=[gallery, image_input], outputs=[gallery, image_input])
-            # When the upload button is clicked,  add the new images to the gallery
-            upload_button.upload(extend_gallery, inputs=[gallery, upload_button], outputs=gallery)
-            # Event to update the selected image when an image is clicked in the gallery
-            selected_image = gr.Textbox(label="Selected Image", visible=False)
-            gallery.select(get_selection_from_gallery, inputs=[gallery, tag_results], outputs=[selected_image, sorted_general_strings, final_categorized_output, categorized, rating, character_res, general_res, unclassified, summarize_tags])
-            # Event to remove a selected image from the gallery
-            remove_button.click(remove_image_from_gallery, inputs=[gallery, selected_image], outputs=gallery)
-            # Event to for the Prompt Beautify Button
-            pe_generate_btn.click(lambda tags, model:prompt_summarizer('', '', tags, model)[0], inputs=[final_categorized_output, prompt_summarizer_model], outputs=[summarize_tags])
-        submit.click(predictor.predict, inputs=[gallery, model_repo, model_repo_2, general_thresh, general_mcut_enabled, character_thresh, character_mcut_enabled, characters_merge_enabled, beautify_model_repo, additional_tags_prepend, additional_tags_append, tag_results, ], outputs=[download_file, sorted_general_strings, final_categorized_output, categorized, rating, character_res, general_res, unclassified, tag_results, ], )
+
+            # Event handlers
+            image_input.change(
+                append_gallery,
+                inputs=[gallery, image_input],
+                outputs=[gallery, image_input]
+            )
+
+            upload_button.upload(
+                extend_gallery,
+                inputs=[gallery, upload_button],
+                outputs=gallery
+            )
+
+            gallery.select(
+                get_selection_from_gallery,
+                inputs=[gallery, tag_results],
+                outputs=[sorted_general_strings, rating, character_res, general_res, categorized_strings, tags_json]
+            )
+
+        submit.click(
+            predictor.predict,
+            inputs=[
+                gallery, model_repo, model_repo_2, general_thresh, general_mcut_enabled,
+                character_thresh, character_mcut_enabled, characters_merge_enabled,
+                additional_tags_prepend, additional_tags_append, tag_results
+            ],
+            outputs=[download_file, sorted_general_strings, rating, character_res, general_res, categorized_strings, tags_json, tag_results]
+        )
+
         gr.Examples(
-            [["images/1girl.png", VIT_LARGE_MODEL_DSV3_REPO, 0.35, False, 0.85, False]], 
-            inputs=[image_input, model_repo, general_thresh, general_mcut_enabled, character_thresh, character_mcut_enabled, ],)
-        gr.Markdown(NEXT_RESTART)
+            [['images/1girl.png', EVA02_LARGE_MODEL_DSV3_REPO, 0.35, False, 0.85, False]],
+            inputs=[image_input, model_repo, general_thresh, general_mcut_enabled, character_thresh, character_mcut_enabled]
+        )
+        gr.Markdown('[Based on SmilingWolf/wd-tagger](https://huggingface.co/spaces/SmilingWolf/wd-tagger) <p style="text-align:right"><a href="https://huggingface.co/spaces/John6666/danbooru-tags-transformer-v2-with-wd-tagger-b">Prompt Enhancer</a></p>')
+    with gr.Tab("PixAI"):
+        pixai_interface = create_pixai_interface()
     with gr.Tab("Booru Image Fetcher"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### ⚙️ Search Parameters")
-                site = gr.Dropdown(label="Select Source", choices=["Gelbooru (Not working)", "Rule34", "Xbooru"], value="Xbooru")
-                Tags = gr.Textbox(label="Tags (comma-separated)", placeholder="e.g. solo,  1girl,  1boy,  artist name,  character,  black hair,  granblue fantasy,  ...", lines=3)
-                exclude_tags = gr.Textbox(label="Exclude Tags (comma-separated)", placeholder="e.g. animated,  watermark,  username,  ...", lines=3)
-                score = gr.Number(label="Minimum Score", value=0)
-                count = gr.Slider(label="Number of Images", minimum=1, maximum=20, step=1, value=1)
-                Safe = gr.Checkbox(label="Include Safe", value=True)
-                Questionable = gr.Checkbox(label="Include Questionable", value=True)
-                Explicit = gr.Checkbox(label="Include Explicit (18+)", value=False)
-                submit_btn = gr.Button("Fetch Images", variant="primary")
-            with gr.Column():
-                gr.Markdown("### 📄 Results")
-                images_output = gr.Gallery(label="Images", columns=3, rows=2, object_fit="contain", height=500)
-                tags_output = gr.Textbox(label="Tags", placeholder="Select an image to display tags", lines=6, show_copy_button=True)
-                post_url_output = gr.Textbox(label="Post URL", lines=1, show_copy_button=True)
-                image_url_output = gr.Textbox(label="Image URL", lines=1, show_copy_button=True)
-        # State to store tags, URLs
-        tags_state = gr.State([])
-        post_url_state = gr.State([])
-        image_url_state = gr.State([])
-        submit_btn.click(fn=booru_gradio, inputs=[Tags, exclude_tags, score, count, Safe, Questionable, Explicit, site], outputs=[images_output, tags_state, post_url_state, image_url_state], )
-        images_output.select(fn=on_select, inputs=[tags_state, post_url_state, image_url_state], outputs=[tags_output, post_url_output, image_url_output], )
-    with gr.Tab(label="Misc"): 
-        with gr.Row():
-            with gr.Column(variant="panel"):
-                input_tags = gr.Textbox(label="Input Tags", placeholder="1girl,  cat,  horns,  blue hair,  ...\nor\n? 1girl 1234567? cat 1234567? horns 1234567? blue hair 1234567? ...", lines=4)
-                submit_button = gr.Button(value="START", variant="primary", size="lg")
-            with gr.Column(variant="panel"):
-                categorized_string = gr.Textbox(label="Categorized (string)", show_label=True, show_copy_button=True, lines=8)
-                categorized_json = gr.JSON(label="Categorized (tags) - JSON")
-                submit_button.click(process_tags, inputs=[input_tags], outputs=[categorized_string, categorized_json])
-            with gr.Column(variant="panel"):
-                pe_generate_btn = gr.Button(value="SUMMARIZE TAGS", size="lg", variant="primary")
-                summarize_tags = gr.Textbox(label="Summarized Tags", show_label=True, show_copy_button=True, lines=5)
-                prompt_summarizer_model = gr.Radio(["Medium", "Long", "Flux"], label="Model Choice", value="Medium", info="Summarize your prompts with medium or long answers. It's recommended for Flux.")
-                pe_generate_btn.click(lambda tags, model:prompt_summarizer('', '', tags, model)[0], inputs=[categorized_string, prompt_summarizer_model], outputs=[summarize_tags])
-demo.queue(max_size=10).launch(show_error=True)
+        booru_interface = create_booru_interface()
+        
+    gr.Markdown(NEXT_RESTART)
+
+demo.queue(max_size=5).launch(show_error=True)

modules/booru.py

@@ -2,6 +2,19 @@ import requests,re,base64,io,numpy as np
 from PIL import Image,ImageOps
 import torch,gradio as gr
 
+# Custom CSS for gallery styling
+css = """
+#custom-gallery {--row-height: 180px;display: grid;grid-auto-rows: min-content;gap: 10px;}
+#custom-gallery .thumbnail-item {height: var(--row-height);width: 100%;position: relative;overflow: hidden;border-radius: 8px;box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);transition: transform 0.2s ease,  box-shadow 0.2s ease;}
+#custom-gallery .thumbnail-item:hover {transform: translateY(-3px);box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);}
+#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: contain;margin: 0 auto;display: block;}
+#custom-gallery .thumbnail-item img.portrait {max-width: 100%;}
+#custom-gallery .thumbnail-item img.landscape {max-height: 100%;}
+.gallery-container {max-height: 500px;overflow-y: auto;padding-right: 0px;--size-80: 500px;}
+.thumbnails {display: flex;position: absolute;bottom: 0;width: 120px;overflow-x: scroll;padding-top: 320px;padding-bottom: 280px;padding-left: 4px;flex-wrap: wrap;}
+#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: initial;width: fit-content;margin: 0px auto;display: block;}
+"""
+
 # Helper to load image from URL
 def loadImageFromUrl(url):
     response = requests.get(url, timeout=10)
@@ -108,4 +121,41 @@ def on_select(evt: gr.SelectData, tags_list, post_url_list, image_url_list):
     idx = evt.index
     if idx < len(tags_list):
         return tags_list[idx], post_url_list[idx], image_url_list[idx]
-    return "No tags", "", ""
+    return "No tags", "", ""
+
+def create_booru_interface():
+    with gr.Blocks(css=css, fill_width=True) as demo:
+        with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### ⚙️ Search Parameters")
+                        site = gr.Dropdown(label="Select Source", choices=["Gelbooru (Not working)", "Rule34", "Xbooru"], value="Xbooru")
+                        Tags = gr.Textbox(label="Tags (comma-separated)", placeholder="e.g. solo,  1girl,  1boy,  artist name,  character,  black hair,  granblue fantasy,  ...", lines=3)
+                        exclude_tags = gr.Textbox(label="Exclude Tags (comma-separated)", placeholder="e.g. animated,  watermark,  username,  ...", lines=3)
+                        score = gr.Number(label="Minimum Score", value=0)
+                        count = gr.Slider(label="Number of Images", minimum=1, maximum=20, step=1, value=1)
+                        Safe = gr.Checkbox(label="Include Safe", value=True)
+                        Questionable = gr.Checkbox(label="Include Questionable", value=True)
+                        Explicit = gr.Checkbox(label="Include Explicit (18+)", value=False)
+                        submit_btn = gr.Button("Fetch Images", variant="primary")
+                    with gr.Column():
+                        gr.Markdown("### 📄 Results")
+                        images_output = gr.Gallery(
+                            columns=2,
+                            show_share_button=False,
+                            interactive=True,
+                            height='auto',
+                            label='Grid of images',
+                            preview=False,
+                            elem_id='custom-gallery'
+                        )
+                        tags_output = gr.Textbox(label="Tags", placeholder="Select an image to display tags", lines=6, show_copy_button=True)
+                        post_url_output = gr.Textbox(label="Post URL", lines=2, show_copy_button=True)
+                        image_url_output = gr.Textbox(label="Image URL", lines=2, show_copy_button=True)
+                    # State to store tags, URLs
+                    tags_state = gr.State([])
+                    post_url_state = gr.State([])
+                    image_url_state = gr.State([])
+                    submit_btn.click(fn=booru_gradio, inputs=[Tags, exclude_tags, score, count, Safe, Questionable, Explicit, site], outputs=[images_output, tags_state, post_url_state, image_url_state], )
+                    images_output.select(fn=on_select, inputs=[tags_state, post_url_state, image_url_state], outputs=[tags_output, post_url_output, image_url_output], )
+            
+    return demo

modules/classifyTags.py

@@ -1,156 +1,337 @@
-from collections import defaultdict
-import re
-# Define grouping rules (categories and keywords)
-# Provided categories and reversed_categories
-categories={
-'Explicit':['sex', '69', 'paizuri', 'cum', 'precum', 'areola_slip', 'hetero', 'erection', 'oral', 'fellatio', 'yaoi', 'ejaculation', 'ejaculating', 'masturbation', 'handjob', 'bulge', 'rape', '_rape', 'doggystyle', 'threesome', 'missionary', 'object_insertion', 'nipple', 'nipples', 'pussy', 'anus', 'penis', 'groin', 'testicles', 'testicle', 'anal', 'cameltoe', 'areolae', 'dildo', 'clitoris', 'top-down_bottom-up', 'gag', 'groping', 'gagged', 'gangbang', 'orgasm', 'femdom', 'incest', 'bukkake', 'breast_out', 'vaginal', 'vagina', 'public_indecency', 'breast_sucking', 'folded', 'cunnilingus', '_cunnilingus', 'foreskin', 'bestiality', 'footjob', 'uterus', 'womb', 'flaccid', 'defloration', 'butt_plug', 'cowgirl_position', 'reverse_cowgirl_position', 'squatting_cowgirl_position', 'reverse_upright_straddle', 'irrumatio', 'deepthroat', 'pokephilia', 'gaping', 'orgy', 'cleft_of_venus', 'futanari', 'futasub', 'futa', 'cumdrip', 'fingering', 'vibrator', 'partially_visible_vulva', 'penetration', 'penetrated', 'cumshot', 'exhibitionism', 'breast_milk', 'grinding', 'clitoral', 'urethra', 'phimosis', 'cervix', 'impregnation', 'tribadism', 'molestation', 'pubic_hair', 'clothed_female_nude_male', 'clothed_male_nude_female', 'clothed_female_nude_female', 'clothed_male_nude_male', 'sex_machine', 'milking_machine', 'ovum', 'chikan', 'pussy_juice_drip_through_clothes', 'ejaculating_while_penetrated', 'suspended_congress', 'reverse_suspended_congress', 'spread_pussy_under_clothes', 'anilingus', 'reach-around', 'humping', 'consensual_tentacles', 'tentacle_pit', 'cum_in_'],
-'Appearance Status':['backless', 'bandaged_neck', 'bleeding', 'blood', '_blood', 'blush', 'body_writing', 'bodypaint', 'bottomless', 'breath', 'bruise', 'butt_crack', 'cold', 'covered_mouth', 'crack', 'cross-section', 'crotchless', 'crying', 'curvy', 'cuts', 'dirty', 'dripping', 'drunk', 'from_mouth', 'glowing', 'hairy', 'halterneck', 'hot', 'injury', 'latex', 'leather', 'levitation', 'lipstick_mark', '_markings', 'makeup', 'mole', 'moles', 'no_bra', 'nosebleed', 'nude', 'outfit', 'pantylines', 'peeing', 'piercing', '_piercing', 'piercings', 'pregnant', 'public_nudity', 'reverse', '_skin', '_submerged', 'saliva', 'scar', 'scratches', 'see-through', 'shadow', 'shibari', 'sideless', 'skindentation', 'sleeping', 'tan', 'soap_bubbles', 'steam', 'steaming_body', 'stitches', 'sweat', 'sweatdrop', 'sweaty', 'tanlines', 'tattoo', 'tattoo', 'tears', 'topless', 'transparent', 'trefoil', 'trembling', 'veins', 'visible_air', 'wardrobe_malfunction', 'wet', 'x-ray', 'unconscious', 'handprint'],
-'Action Pose':['afloat', 'afterimage', 'against_fourth_wall', 'against_wall', 'aiming', 'all_fours',"another's_mouth",'arm_', 'arm_support', 'arms_', 'arms_behind_back', 'asphyxiation', 'attack', 'back', 'ballet', 'bara', 'bathing', 'battle', 'bdsm', 'beckoning', 'bent_over', 'bite_mark', 'biting', 'bondage', 'breast_suppress', 'breathing', 'burning', 'bust_cup', 'carry', 'carrying', 'caught', 'chained', 'cheek_squash', 'chewing', 'cigarette', 'clapping', 'closed_eye', 'come_hither', 'cooking', 'covering', 'cuddling', 'dancing', '_docking', 'destruction', 'dorsiflexion', 'dreaming', 'dressing', 'drinking', 'driving', 'dropping', 'eating', 'exercise', 'expansion', 'exposure', 'facing', 'failure', 'fallen_down', 'falling', 'feeding', 'fetal_position', 'fighting', 'finger_on_trigger', 'finger_to_cheek', 'finger_to_mouth', 'firing', 'fishing', 'flashing', 'fleeing', 'flexible', 'flexing', 'floating', 'flying', 'fourth_wall', 'freediving', 'frogtie', '_grab', 'girl_on_top', 'giving', 'grabbing', 'grabbing_', 'gymnastics', '_hold', 'hadanugi_dousa', 'hairdressing', 'hand_', 'hand_on', 'hand_on_wall', 'hands_', 'headpat', 'hiding', 'holding', 'hug', 'hugging', 'imagining', 'in_container', 'in_mouth', 'in_palm', 'jealous', 'jumping', 'kabedon', 'kicking', 'kiss', 'kissing', 'kneeling', '_lift', 'lactation', 'laundry', 'licking', 'lifted_by_self', 'looking', 'lowleg', 'lying', 'melting', 'midair', 'moaning', '_open', 'on_back', 'on_bed', 'on_ground', 'on_lap', 'on_one_knee', 'one_eye_closed', 'open_', 'over_mouth', 'own_mouth', '_peek', '_pose', '_press', '_pull', 'padding', 'paint', 'painting_(action)', 'palms_together', 'pee', 'peeking', 'pervert', 'petting', 'pigeon-toed', 'piggyback', 'pinching', 'pinky_out', 'pinned', 'plantar_flexion', 'planted', 'playing', 'pocky', 'pointing', 'poke', 'poking', 'pouring', 'pov', 'praying', 'presenting', 'profanity', 'pulled_by_self', 'pulling', 'pump_action', 'punching', '_rest', 'raised', 'reaching', 'reading', 'reclining', 'reverse_grip', 'riding', 'running', '_slip', 'salute', 'screaming', 'seiza', 'selfie', 'sewing', 'shaking', 'shoe_dangle', 'shopping', 'shouting', 'showering', 'shushing', 'singing', 'sitting', 'slapping', 'smell', 'smelling', 'smoking', 'smother', 'solo', 'spanked', 'spill', 'spilling', 'spinning', 'splashing', 'split', 'squatting', 'squeezed', 'breasts_squeezed_together', 'standing', 'standing_on_', 'staring', 'straddling', 'strangling', 'stretching', 'surfing', 'suspension', 'swimming', 'talking', 'teardrop', 'tearing_clothes', 'throwing', 'tied_up', 'tiptoes', 'toe_scrunch', 'toothbrush', 'trigger_discipline', 'tripping', 'tsundere', 'turning_head', 'twitching', 'two-handed', 'tying', '_up', 'unbuttoned', 'undressed', 'undressing', 'unsheathed', 'unsheathing', 'unzipped', 'unzipping', 'upright_straddle', 'v', 'V', 'vore', '_wielding', 'wading', 'walk-in', 'walking', 'wariza', 'waving', 'wedgie', 'wrestling', 'writing', 'yawning', 'yokozuwari', '_conscious', 'massage', 'struggling', 'shrugging', 'drugged', 'tentacles_under_clothes', 'restrained_by_tentacles', 'tentacles_around_arms', 'tentacles_around_legs', 'restrained_legs', 'restrained_tail', 'restrained_arms', 'tentacles_on_female', 'archery', 'cleaning', 'tempura', 'facepalm', 'sadism'],
-'Headwear':['antennae', 'antlers', 'aura', 'bandaged_head', 'bandana', 'bandeau', 'beanie', 'beanie', 'beret', 'bespectacled', 'blindfold', 'bonnet', '_cap', 'circlet', 'crown', '_drill', '_drills', 'diadem', '_eyewear', 'ear_covers', 'ear_ornament', 'ear_tag', 'earbuds', 'earclip', 'earmuffs', 'earphones', 'earpiece', 'earring', 'earrings', 'eyeliner', 'eyepatch', 'eyewear_on_head', 'facial', 'fedora', 'glasses', 'goggles', '_headwear', 'hachimaki', 'hair_bobbles', 'hair_ornament', 'hair_rings', 'hair_tie', 'hairband', 'hairclip', 'hairpin', 'hairpods', 'halo', 'hat', 'head-mounted_display', 'head_wreath', 'headband', 'headdress', 'headgear', 'headphones', 'headpiece', 'headset', 'helm', 'helmet', 'hood', 'kabuto_(helmet)', 'kanzashi', '_mask', 'maid_headdress', 'mask', 'mask', 'mechanical_ears', 'mechanical_eye', 'mechanical_horns', 'mob_cap', 'monocle', 'neck_ruff', 'nightcap', 'on_head', 'pince-nez', 'qingdai_guanmao', 'scarf_over_mouth', 'scrunchie', 'sunglasses',"tam_o'_shanter",'tate_eboshi', 'tiara', 'topknot', 'turban', 'veil', 'visor', 'wig', 'mitre', 'tricorne', 'bicorne'],
-'Handwear':['arm_warmers', 'armband', 'armlet', 'bandaged_arm', 'bandaged_fingers', 'bandaged_hand', 'bandaged_wrist', 'bangle', 'bracelet', 'bracelets', 'bracer', 'cuffs', 'elbow_pads', '_gauntlets', '_glove', '_gloves', 'gauntlets', 'gloves', 'kote', 'kurokote', 'mechanical_arm', 'mechanical_arms', 'mechanical_hands', 'mittens', 'mitts', 'nail_polish', 'prosthetic_arm', 'wrist_cuffs', 'wrist_guards', 'wristband', 'yugake'],
-'One-Piece Outfit':['bodystocking', 'bodysuit', 'dress', 'furisode', 'gown', 'hanfu', 'jumpsuit', 'kimono', 'leotard', 'microdress', 'one-piece', 'overalls', 'robe', 'spacesuit', 'sundress', 'yukata'],
-'Upper Body Clothing':['aiguillette', 'apron', '_apron', 'armor', '_armor', 'ascot', 'babydoll', 'bikini', '_bikini', 'blazer', '_blazer', 'blouse', '_blouse', 'bowtie', '_bowtie', 'bra', '_bra', 'breast_curtain', 'breast_curtains', 'breast_pocket', 'breastplate', 'bustier', 'camisole', 'cape', 'capelet', 'cardigan', 'center_opening', 'chemise', 'chest_jewel', 'choker', 'cloak', 'coat', 'coattails', 'collar', '_collar', 'corset', 'criss-cross_halter', 'crop_top', 'dougi', 'feather_boa', 'gakuran', 'hagoromo', 'hanten_(clothes)', 'haori', 'harem_pants', 'harness', 'hoodie', 'jacket', '_jacket', 'japanese_clothes', 'kappougi', 'kariginu', 'lapels', 'lingerie', '_lingerie', 'maid', 'mechanical_wings', 'mizu_happi', 'muneate', 'neckerchief', 'necktie', 'negligee', 'nightgown', 'pajamas', '_pajamas', 'pauldron', 'pauldrons', 'plunging_neckline', 'raincoat', 'rei_no_himo', 'sailor_collar', 'sarashi', 'scarf', 'serafuku', 'shawl', 'shirt', 'shoulder_', 'sleepwear', 'sleeve', 'sleeveless', 'sleeves', '_sleeves', 'sode', 'spaghetti_strap', 'sportswear', 'strapless', 'suit', 'sundress', 'suspenders', 'sweater', 'swimsuit', '_top', '_torso', 't-shirt', 'tabard', 'tailcoat', 'tank_top', 'tasuki', 'tie_clip', 'tunic', 'turtleneck', 'tuxedo', '_uniform', 'undershirt', 'uniform', 'v-neck', 'vambraces', 'vest', 'waistcoat'],
-'Lower Body Clothing':['bare_hips', 'bloomers', 'briefs', 'buruma', 'crotch_seam', 'cutoffs', 'denim', 'faulds', 'fundoshi', 'g-string', 'garter_straps', 'hakama', 'hip_vent', 'jeans', 'knee_pads', 'loincloth', 'mechanical_tail', 'microskirt', 'miniskirt', 'overskirt', 'panties', 'pants', 'pantsu', 'panty_straps', 'pelvic_curtain', 'petticoat', 'sarong', 'shorts', 'side_slit', 'skirt', 'sweatpants', 'swim_trunks', 'thong', 'underwear', 'waist_cape'],
-'Foot & Legwear':['anklet', 'bandaged_leg', 'boot', 'boots', '_footwear', 'flats', 'flip-flops', 'geta', 'greaves', '_heels', 'kneehigh', 'kneehighs', '_legwear', 'leg_warmers', 'leggings', 'loafers', 'mary_janes', 'mechanical_legs', 'okobo', 'over-kneehighs', 'pantyhose', 'prosthetic_leg', 'pumps', '_shoe', '_sock', 'sandals', 'shoes', 'skates', 'slippers', 'sneakers', 'socks', 'spikes', 'tabi', 'tengu-geta', 'thigh_strap', 'thighhighs', 'uwabaki', 'zouri', 'legband', 'ankleband'],
-'Other Accessories':['alternate_', 'anklet', 'badge', 'beads', 'belt', 'belts', 'bow', 'brooch', 'buckle', 'button', 'buttons', '_clothes', '_costume', '_cutout', 'casual', 'charm', 'clothes_writing', 'clothing_aside', 'costume', 'cow_print', 'cross', 'd-pad', 'double-breasted', 'drawstring', 'epaulettes', 'fabric', 'fishnets', 'floral_print', 'formal', 'frills', '_garter', 'gem', 'holster', 'jewelry', '_knot', 'lace', 'lanyard', 'leash', 'magatama', 'mechanical_parts', 'medal', 'medallion', 'naked_bandage', 'necklace', '_ornament', '(ornament)', 'o-ring', 'obi', 'obiage', 'obijime', '_pin', '_print', 'padlock', 'patterned_clothing', 'pendant', 'piercing', 'plaid', 'pocket', 'polka_dot', 'pom_pom_(clothes)', 'pom_pom_(clothes)', 'pouch', 'ribbon', '_ribbon', '_stripe', '_stripes', 'sash', 'shackles', 'shimenawa', 'shrug_(clothing)', 'skin_tight', 'spandex', 'strap', 'sweatband', '_trim', 'tassel', 'zettai_ryouiki', 'zipper'],
-'Facial Expression':['ahegao', 'anger_vein', 'angry', 'annoyed', 'confused', 'drooling', 'embarrassed', 'expressionless', 'eye_contact', '_face', 'frown', 'fucked_silly', 'furrowed_brow', 'glaring', 'gloom_(expression)', 'grimace', 'grin', 'happy', 'jitome', 'laughing', '_mouth', 'nervous', 'notice_lines', 'o_o', 'parted_lips', 'pout', 'puff_of_air', 'restrained', 'sad', 'sanpaku', 'scared', 'scowl', 'serious', 'shaded_face', 'shy', 'sigh', 'sleepy', 'smile', 'smirk', 'smug', 'snot', 'spoken_ellipsis', 'spoken_exclamation_mark', 'spoken_interrobang', 'spoken_question_mark', 'squiggle', 'surprised', 'tareme', 'tearing_up', 'thinking', 'tongue', 'tongue_out', 'torogao', 'tsurime', 'turn_pale', 'wide-eyed', 'wince', 'worried', 'heartbeat'],
-'Facial Emoji':['!!', '!', '!?', '+++', '+_+', '...', '...?', '._.', '03:00', '0_0', ':/', ':3', ':<', ':>', ':>=', ':d', ':i', ':o', ':p', ':q', ':t', ':x', ':|', ';(', ';)', ';3', ';d', ';o', ';p', ';q', '=_=', '>:(', '>:)', '>_<', '>_o', '>o<', '?', '??', '@_@', '\\m/', '\n/', '\\o/', '\\||/', '^^^', '^_^', 'c:', 'd:', 'o_o', 'o3o', 'u_u', 'w', 'x', 'x_x', 'xd', 'zzz', '|_|'],
-'Head':['afro', 'ahoge', 'animal_ear_fluff', '_bangs', '_bun', 'bald', 'beard', 'blunt_bangs', 'blunt_ends', 'bob_cut', 'bowl_cut', 'braid', 'braids', 'buzz_cut', 'circle_cut', 'colored_tips', 'cowlick', 'dot_nose', 'dreadlocks', '_ear', '_ears', '_eye', '_eyes', 'enpera', 'eyeball', 'eyebrow', 'eyebrow_cut', 'eyebrows', 'eyelashes', 'eyeshadow', 'faceless', 'facepaint', 'facial_mark', 'fang', 'forehead', 'freckles', 'goatee', '_hair', '_horn', '_horns', 'hair_', 'hair_bun', 'hair_flaps', 'hair_intakes', 'hair_tubes', 'half_updo', 'head_tilt', 'heterochromia', 'hime_cut', 'hime_cut', 'horns', 'in_eye', 'inverted_bob', 'kemonomimi_mode', 'lips', 'mascara', 'mohawk', 'mouth_', 'mustache', 'nose', 'one-eyed', 'one_eye', 'one_side_up', '_pupils', 'parted_bangs', 'pompadour', 'ponytail', 'ringlets', '_sclera', 'sideburns', 'sidecut', 'sidelock', 'sidelocks', 'skull', 'snout', 'stubble', 'swept_bangs', 'tails', 'teeth', 'third_eye', 'twintails', 'two_side_up', 'undercut', 'updo', 'v-shaped_eyebrows', 'whiskers', 'tentacle_hair'],
-'Hands':['_arm', '_arms', 'claws', '_finger', '_fingers', 'fingernails', '_hand', '_nail', '_nails', 'palms', 'rings', 'thumbs_up'],
-'Upper Body':['abs', 'armpit', 'armpits', 'backboob', 'belly', 'biceps', 'breast_rest', 'breasts', 'button_gap', 'cleavage', 'collarbone', 'dimples_of_venus', 'downblouse', 'flat_chest', 'linea_alba', 'median_furrow', 'midriff', 'nape', 'navel', 'pectorals', 'ribs', '_shoulder', '_shoulders', 'shoulder_blades', 'sideboob', 'sidetail', 'spine', 'stomach', 'strap_gap', 'toned', 'underboob', 'underbust'],
-'Lower Body':['ankles', 'ass', 'barefoot', 'crotch', 'feet', 'highleg', 'hip_bones', 'hooves', 'kneepits', 'knees', 'legs', 'soles', 'tail', 'thigh_gap', 'thighlet', 'thighs', 'toenail', 'toenails', 'toes', 'wide_hips'],
-'Creature':['(animal)', 'anglerfish', 'animal', 'bear', 'bee', 'bird', 'bug', 'butterfly', 'cat', 'chick', 'chicken', 'chinese_zodiac', 'clownfish', 'coral', 'crab', 'creature', 'crow', 'dog', 'dove', 'dragon', 'duck', 'eagle', 'fish', 'fish', 'fox', 'fox', 'frog', 'frog', 'goldfish', 'hamster', 'horse', 'jellyfish', 'ladybug', 'lion', 'mouse', 'octopus', 'owl', 'panda', 'penguin', 'pig', 'pigeon', 'rabbit', 'rooster', 'seagull', 'shark', 'sheep', 'shrimp', 'snail', 'snake', 'squid', 'starfish', 'tanuki', 'tentacles', 'goo_tentacles', 'plant_tentacles', 'crotch_tentacles', 'mechanical_tentacles', 'squidward_tentacles', 'suction_tentacles', 'penis_tentacles', 'translucent_tentacles', 'back_tentacles', 'red_tentacles', 'green_tentacles', 'blue_tentacles', 'black_tentacles', 'pink_tentacles', 'purple_tentacles', 'face_tentacles', 'tentacles_everywhere', 'milking_tentacles', 'tiger', 'turtle', 'weasel', 'whale', 'wolf', 'parrot', 'sparrow', 'unicorn'],
-'Plant':['bamboo', 'bouquet', 'branch', 'bush', 'cherry_blossoms', 'clover', 'daisy', '(flower)', 'flower', 'flower', 'gourd', 'hibiscus', 'holly', 'hydrangea', 'leaf', 'lily_pad', 'lotus', 'moss', 'palm_leaf', 'palm_tree', 'petals', 'plant', 'plum_blossoms', 'rose', 'spider_lily', 'sunflower', 'thorns', 'tree', 'tulip', 'vines', 'wisteria', 'acorn'],
-'Food':['apple', 'baguette', 'banana', 'baozi', 'beans', 'bento', 'berry', 'blueberry', 'bread', 'broccoli', 'burger', 'cabbage', 'cake', 'candy', 'carrot', 'cheese', 'cherry', 'chili_pepper', 'chocolate', 'coconut', 'cookie', 'corn', 'cream', 'crepe', 'cucumber', 'cucumber', 'cupcake', 'curry', 'dango', 'dessert', 'doughnut', 'egg', 'eggplant', '_(food)', '_(fruit)', 'food', 'french_fries', 'fruit', 'grapes', 'ice_cream', 'icing', 'lemon', 'lettuce', 'lollipop', 'macaron', 'mandarin_orange', 'meat', 'melon', 'mochi', 'mushroom', 'noodles', 'omelet', 'omurice', 'onigiri', 'onion', 'pancake', 'parfait', 'pasties', 'pastry', 'peach', 'pineapple', 'pizza', 'popsicle', 'potato', 'pudding', 'pumpkin', 'radish', 'ramen', 'raspberry', 'rice', 'roasted_sweet_potato', 'sandwich', 'sausage', 'seaweed', 'skewer', 'spitroast', 'spring_onion', 'strawberry', 'sushi', 'sweet_potato', 'sweets', 'taiyaki', 'takoyaki', 'tamagoyaki', 'tempurakanbea', 'toast', 'tomato', 'vegetable', 'wagashi', 'wagashi', 'watermelon', 'jam', 'popcorn'],
-'Beverage':['alcohol', 'beer', 'coffee', 'cola', 'drink', 'juice', 'juice_box', 'milk', 'sake', 'soda', 'tea', '_tea', 'whiskey', 'wine', 'cocktail'],
-'Music':['band', 'baton_(conducting)', 'beamed', 'cello', 'concert', 'drum', 'drumsticks', 'eighth_note', 'flute', 'guitar', 'harp', 'horn', '(instrument)', 'idol', 'instrument', 'k-pop', 'lyre', '(music)', 'megaphone', 'microphone', 'music', 'musical_note', 'phonograph', 'piano', 'plectrum', 'quarter_note', 'recorder', 'sixteenth_note', 'sound_effects', 'trumpet', 'utaite', 'violin', 'whistle'],
-'Weapons & Equipment':['ammunition', 'arrow_(projectile)', 'axe', 'bandolier', 'baseball_bat', 'beretta_92', 'bolt_action', 'bomb', 'bullet', 'bullpup', 'cannon', 'chainsaw', 'crossbow', 'dagger', 'energy_sword', 'explosive', 'fighter_jet', 'gohei', 'grenade', 'gun', 'hammer', 'handgun', 'holstered', 'jet', 'katana', 'knife', 'kunai', 'lance', 'mallet', 'nata_(tool)', 'polearm', 'quiver', 'rapier', 'revolver', 'rifle', 'rocket_launcher', 'scabbard', 'scope', 'scythe', 'sheath', 'sheathed', 'shield', 'shotgun', 'shuriken', 'spear', 'staff', 'suppressor', 'sword', 'tank', 'tantou', 'torpedo', 'trident', '(weapon)', 'wand', 'weapon', 'whip', 'yumi_(bow)', 'h&k_hk416', 'rocket_launcher', 'heckler_&_koch', '_weapon'],
-'Vehicles':['aircraft', 'airplane', 'bicycle', 'boat', 'car', 'caterpillar_tracks', 'flight_deck', 'helicopter', 'motor_vehicle', 'motorcycle', 'ship', 'spacecraft', 'spoiler_(automobile)', 'train', 'truck', 'watercraft', 'wheel', 'wheelbarrow', 'wheelchair', 'inflatable_raft'],
-'Buildings':['apartment', 'aquarium', 'architecture', 'balcony', 'building', 'cafe', 'castle', 'church', 'gym', 'hallway', 'hospital', 'house', 'library', '(place)', 'porch', 'restaurant', 'restroom', 'rooftop', 'shop', 'skyscraper', 'stadium', 'stage', 'temple', 'toilet', 'tower', 'train_station', 'veranda'],
-'Indoor':['bath', 'bathroom', 'bathtub', 'bed', 'bed_sheet', 'bedroom', 'blanket', 'bookshelf', 'carpet', 'ceiling', 'chair', 'chalkboard', 'classroom', 'counter', 'cupboard', 'curtains', 'cushion', 'dakimakura', 'desk', 'door', 'doorway', 'drawer', '_floor', 'floor', 'futon', 'indoors', 'interior', 'kitchen', 'kotatsu', 'locker', 'mirror', 'pillow', 'room', 'rug', 'school_desk', 'shelf', 'shouji', 'sink', 'sliding_doors', 'stairs', 'stool', 'storeroom', 'table', 'tatami', 'throne', 'window', 'windowsill', 'bathhouse', 'chest_of_drawers'],
-'Outdoor':['alley', 'arch', 'beach', 'bridge', 'bus_stop', 'bush', 'cave', '(city)', 'city', 'cliff', 'crescent', 'crosswalk', 'day', 'desert', 'fence', 'ferris_wheel', 'field', 'forest', 'grass', 'graveyard', 'hill', 'lake', 'lamppost', 'moon', 'mountain', 'night', 'ocean', 'onsen', 'outdoors', 'path', 'pool', 'poolside', 'railing', 'railroad', 'river', 'road', 'rock', 'sand', 'shore', 'sky', 'smokestack', 'snow', 'snowball', 'snowman', 'street', 'sun', 'sunlight', 'sunset', 'tent', 'torii', 'town', 'tree', 'turret', 'utility_pole', 'valley', 'village', 'waterfall'],
-'Objects':['anchor', 'android', 'armchair', '(bottle)', 'backpack', 'bag', 'ball', 'balloon', 'bandages', 'bandaid', 'bandaids', 'banknote', 'banner', 'barcode', 'barrel', 'baseball', 'basket', 'basketball', 'beachball', 'bell', 'bench', 'binoculars', 'board_game', 'bone', 'book', 'bottle', 'bowl', 'box', 'box_art', 'briefcase', 'broom', 'bucket', '(chess)', '(computer)', '(computing)', '(container)', 'cage', 'calligraphy_brush', 'camera', 'can', 'candle', 'candlestand', 'cane', 'card', 'cartridge', 'cellphone', 'chain', 'chandelier', 'chess', 'chess_piece', 'choko_(cup)', 'chopsticks', 'cigar', 'clipboard', 'clock', 'clothesline', 'coin', 'comb', 'computer', 'condom', 'controller', 'cosmetics', 'couch', 'cowbell', 'crazy_straw', 'cup', 'cutting_board', 'dice', 'digital_media_player', 'doll', 'drawing_tablet', 'drinking_straw', 'easel', 'electric_fan', 'emblem', 'envelope', 'eraser', 'feathers', 'figure', 'fire', 'fishing_rod', 'flag', 'flask', 'folding_fan', 'fork', 'frying_pan', '(gemstone)', 'game_console', 'gears', 'gemstone', 'gift', 'glass', 'glowstick', 'gold', 'handbag', 'handcuffs', 'handheld_game_console', 'hose', 'id_card', 'innertube', 'iphone',"jack-o'-lantern",'jar', 'joystick', 'key', 'keychain', 'kiseru', 'ladder', 'ladle', 'lamp', 'lantern', 'laptop', 'letter', 'letterboxed', 'lifebuoy', 'lipstick', 'liquid', 'lock', 'lotion', '_machine', 'map', 'marker', 'model_kit', 'money', 'monitor', 'mop', 'mug', 'needle', 'newspaper', 'nintendo', 'nintendo_switch', 'notebook', '(object)', 'ofuda', 'orb', 'origami', '(playing_card)', 'pack', 'paddle', 'paintbrush', 'pan', 'paper', 'parasol', 'patch', 'pc', 'pen', 'pencil', 'pencil', 'pendant_watch', 'phone', 'pill', 'pinwheel', 'plate', 'playstation', 'pocket_watch', 'pointer', 'poke_ball', 'pole', 'quill', 'racket', 'randoseru', 'remote_control', 'ring', 'rope', 'sack', 'saddle', 'sakazuki', 'satchel', 'saucer', 'scissors', 'scroll', 'seashell', 'seatbelt', 'shell', 'shide', 'shopping_cart', 'shovel', 'shower_head', 'silk', 'sketchbook', 'smartphone', 'soap', 'sparkler', 'spatula', 'speaker', 'spoon', 'statue', 'stethoscope', 'stick', 'sticker', 'stopwatch', 'string', 'stuffed_', 'stylus', 'suction_cups', 'suitcase', 'surfboard', 'syringe', 'talisman', 'tanzaku', 'tape', 'teacup', 'teapot', 'teddy_bear', 'television', 'test_tube', 'tiles', 'tokkuri', 'tombstone', 'torch', 'towel', 'toy', 'traffic_cone', 'tray', 'treasure_chest', 'uchiwa', 'umbrella', 'vase', 'vial', 'video_game', 'viewfinder', 'volleyball', 'wallet', 'watch', 'watch', 'whisk', 'whiteboard', 'wreath', 'wrench', 'wristwatch', 'yunomi', 'ace_of_hearts', 'inkwell', 'compass', 'ipod', 'sunscreen', 'rocket', 'cobblestone'],
-'Character Design':['+boys', '+girls', '1other', '39', '_boys', '_challenge', '_connection', '_female', '_fur', '_girls', '_interface', '_male', '_man', '_person', 'abyssal_ship', 'age_difference', 'aged_down', 'aged_up', 'albino', 'alien', 'alternate_muscle_size', 'ambiguous_gender', 'amputee', 'androgynous', 'angel', 'animalization', 'ass-to-ass', 'assault_visor', 'au_ra', 'baby', 'bartender', 'beak', 'bishounen', 'borrowed_character', 'boxers', 'boy', 'breast_envy', 'breathing_fire', 'bride', 'broken', 'brother_and_sister', 'brothers', 'camouflage', 'cheating_(relationship)', 'cheerleader', 'chibi', 'child', 'clone', 'command_spell', 'comparison', 'contemporary', 'corpse', 'corruption', 'cosplay', 'couple', 'creature_and_personification', 'crossdressing', 'crossover', 'cyberpunk', 'cyborg', 'cyclops', 'damaged', 'dancer', 'danmaku', 'darkness', 'death', 'defeat', 'demon', 'disembodied_', 'draph', 'drone', 'duel', 'dwarf', 'egyptian', 'electricity', 'elezen', 'elf', 'enmaided', 'erune', 'everyone', 'evolutionary_line', 'expressions', 'fairy', 'family', 'fangs', 'fantasy', 'fashion', 'fat', 'father_and_daughter', 'father_and_son', 'fewer_digits', 'fins', 'flashback', 'fluffy', 'fumo_(doll)', 'furry', 'fusion', 'fuuin_no_tsue', 'gameplay_mechanics', 'genderswap', 'ghost', 'giant', 'giantess', 'gibson_les_paul', 'girl', 'goblin', 'groom', 'guro', 'gyaru', 'habit', 'harem', 'harpy', 'harvin', 'heads_together', 'health_bar', 'height_difference', 'hitodama', 'horror_(theme)', 'humanization', 'husband_and_wife', 'hydrokinesis', 'hypnosis', 'hyur', 'idol', 'insignia', 'instant_loss', 'interracial', 'interspecies', 'japari_bun', 'jeweled_branch_of_hourai', 'jiangshi', 'jirai_kei', 'joints', 'karakasa_obake', 'keyhole', 'kitsune', 'knight', 'kodona', 'kogal', 'kyuubi', 'lamia', 'left-handed', 'loli', 'lolita', 'look-alike', 'machinery', 'magic', 'male_focus', 'manly', 'matching_outfits', 'mature_female', 'mecha', 'mermaid', 'meta', 'miko', 'milestone_celebration', 'military', 'mind_control', 'miniboy', 'minigirl',"miqo'te",'monster', 'monsterification', 'mother_and_daughter', 'mother_and_son', 'multiple_others', 'muscular', 'nanodesu_(phrase)', 'narrow_waist', 'nekomata', 'netorare', 'ninja', 'no_humans', 'nontraditional', 'nun', 'nurse', 'object_namesake', 'obliques', 'office_lady', 'old', 'on_body', 'onee-shota', 'oni', 'orc', 'others', 'otoko_no_ko', 'oversized_object', 'paint_splatter', 'pantyshot', 'pawpads', 'persona', 'personality', 'personification', 'pet_play', 'petite', 'pirate', 'playboy_bunny', 'player_2', 'plugsuit', 'plump', 'poi', 'pokemon', 'police', 'policewoman', 'pom_pom_(cheerleading)', 'princess', 'prosthesis', 'pun', 'puppet', 'race_queen', 'radio_antenna', 'real_life_insert', 'redesign', 'reverse_trap', 'rigging', 'robot', 'rod_of_remorse', 'sailor', 'salaryman', 'samurai', 'sangvis_ferri', 'scales', 'scene_reference', 'school', 'sheikah', 'shota', 'shrine', 'siblings', 'side-by-side', 'sidesaddle', 'sisters', 'size_difference', 'skeleton', 'skinny', 'slave', 'slime_(substance)', 'soldier', 'spiked_shell', 'spokencharacter', 'steampunk', 'streetwear', 'striker_unit', 'strongman', 'submerged', 'suggestive', 'super_saiyan', 'superhero', 'surreal', 'take_your_pick', 'tall', 'talons', 'taur', 'teacher', 'team_rocket', 'three-dimensional_maneuver_gear', 'time_paradox', 'tomboy', 'traditional_youkai', 'transformation', 'trick_or_treat', 'tusks', 'twins', 'ufo', 'under_covers', 'v-fin', 'v-fin', 'vampire', 'virtual_youtuber', 'waitress', 'watching_television', 'wedding', 'what', 'when_you_see_it', 'wife_and_wife', 'wing', 'wings', 'witch', 'world_war_ii', 'yandere', 'year_of', 'yes', 'yin_yang', 'yordle',"you're_doing_it_wrong",'you_gonna_get_raped', 'yukkuri_shiteitte_ne', 'yuri', 'zombie', '(alice_in_wonderland)', '(arknights)', '(blue_archive)', '(cosplay)', '(creature)', '(emblem)', '(evangelion)', '(fate)', '(fate/stay_night)', '(ff11)', '(fire_emblem)', '(genshin_impact)', '(grimm)', '(houseki_no_kuni)', '(hyouka)', '(idolmaster)', '(jojo)', '(kancolle)', '(kantai_collection)', '(kill_la_kill)', '(league_of_legends)', '(legends)', '(lyomsnpmp)', '(machimazo)', '(madoka_magica)', '(mecha)', '(meme)', '(nier:automata)', '(organ)', '(overwatch)', '(pokemon)', '(project_moon)', '(project_sekai)', '(sao)', '(senran_kagura)', '(splatoon)', '(touhou)', '(tsukumo_sana)', '(youkai_watch)', '(yu-gi-oh!_gx)', '(zelda)', 'sextuplets', 'imperial_japanese_army', 'extra_faces', '_miku'],
-'Composition':['abstract', 'anime_coloring', 'animification', 'back-to-back', 'bad_anatomy', 'blurry', 'border', 'bound', 'cameo', 'cheek-to-cheek', 'chromatic_aberration', 'close-up', 'collage', 'color_guide', 'colorful', 'comic', 'contrapposto', 'cover', 'cowboy_shot', 'crosshatching', 'depth_of_field', 'dominatrix', 'dutch_angle', '_focus', 'face-to-face', 'fake_screenshot', 'film_grain', 'fisheye', 'flat_color', 'foreshortening', 'from_above', 'from_behind', 'from_below', 'from_side', 'full_body', 'glitch', 'greyscale', 'halftone', 'head_only', 'heads-up_display', 'high_contrast', 'horizon', '_inset', 'inset', 'jaggy_lines', '1koma', '2koma', '3koma', '4koma', '5koma', 'leaning', 'leaning_forward', 'leaning_to_the_side', 'left-to-right_manga', 'lens_flare', 'limited_palette', 'lineart', 'lineup', 'lower_body', '(medium)', 'marker_(medium)', 'meme', 'mixed_media', 'monochrome', 'multiple_views', 'muted_color', 'oekaki', 'on_side', 'out_of_frame', 'outline', 'painting', 'parody', 'partially_colored', 'partially_underwater_shot', 'perspective', 'photorealistic', 'picture_frame', 'pillarboxed', 'portrait', 'poster_(object)', 'product_placement', 'profile', 'realistic', 'recording', 'retro_artstyle', '(style)', '_style', 'sandwiched', 'science_fiction', 'sepia', 'shikishi', 'side-by-side', 'sideways', 'sideways_glance', 'silhouette', 'sketch', 'spot_color', 'still_life', 'straight-on', 'symmetry', '(texture)', 'tachi-e', 'taking_picture', 'tegaki', 'too_many', 'traditional_media', 'turnaround', 'underwater', 'upper_body', 'upside-down', 'upskirt', 'variations', 'wide_shot', '_design', 'symbolism', 'rounded_corners', 'surrounded'],
-'Season':['akeome', 'anniversary', 'autumn', 'birthday', 'christmas', '_day', 'festival', 'halloween', 'kotoyoro', 'nengajou', 'new_year', 'spring_(season)', 'summer', 'tanabata', 'valentine', 'winter'],
-'Background':['_background', 'backlighting', 'bloom', 'bokeh', 'brick_wall', 'bubble', 'cable', 'caustics', 'cityscape', 'cloud', 'confetti', 'constellation', 'contrail', 'crowd', 'crystal', 'dark', 'debris', 'dusk', 'dust', 'egasumi', 'embers', 'emphasis_lines', 'energy', 'evening', 'explosion', 'fireworks', 'fog', 'footprints', 'glint', 'graffiti', 'ice', 'industrial_pipe', 'landscape', 'light', 'light_particles', 'light_rays', 'lightning', 'lights', 'moonlight', 'motion_blur', 'motion_lines', 'mountainous_horizon', 'nature', '(planet)', 'pagoda', 'people', 'pillar', 'planet', 'power_lines', 'puddle', 'rain', 'rainbow', 'reflection', 'ripples', 'rubble', 'ruins', 'scenery', 'shade', 'shooting_star', 'sidelighting', 'smoke', 'snowflakes', 'snowing', 'space', 'sparkle', 'sparks', 'speed_lines', 'spider_web', 'spotlight', 'star_(sky)', 'stone_wall', 'sunbeam', 'sunburst', 'sunrise', '_theme', 'tile_wall', 'twilight', 'wall_clock', 'wall_of_text', 'water', 'waves', 'wind', 'wire', 'wooden_wall', 'lighthouse'],
-'Patterns':['arrow', 'bass_clef', 'blank_censor', 'circle', 'cube', 'heart', 'hexagon', 'hexagram', 'light_censor', '(pattern)', 'pattern', 'pentagram', 'roman_numeral', '(shape)', '(symbol)', 'shape', 'sign', 'symbol', 'tally', 'treble_clef', 'triangle', 'tube', 'yagasuri'],
-'Censorship':['blur_censor', '_censor', '_censoring', 'censored', 'character_censor', 'convenient', 'hair_censor', 'heart_censor', 'identity_censor', 'maebari', 'novelty_censor', 'soap_censor', 'steam_censor', 'tail_censor', 'uncensored'],
-'Others':['2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021', '2022', '2023', '2024', 'artist', 'artist_name', 'artistic_error', 'asian', '(company)', 'character_name', 'content_rating', 'copyright', 'cover_page', 'dated', 'english_text', 'japan', 'layer', 'logo', 'name', 'numbered', 'page_number', 'pixiv_id', 'language', 'reference_sheet', 'signature', 'speech_bubble', 'subtitled', 'text', 'thank_you', 'typo', 'username', 'wallpaper', 'watermark', 'web_address', 'screwdriver', 'translated'],
-'Quality Tags':['masterpiece', '_quality', 'highres', 'absurdres', 'ultra-detailed', 'lowres']}
-
-# Create reversed_categories with escaped versions for pattern matching
-reversed_categories = {}
-for key, values in categories.items():
-    for value in values:
-        # Store both the original and escaped version for matching
-        reversed_categories[value] = key
-        if '(' in value or ')' in value:
-            escaped_value = value.replace('(', '\\(').replace(')', '\\)')
-            reversed_categories[escaped_value] = key
-
-# Precompute keyword lengths
-keyword_lengths = {keyword: len(keyword) for keyword in reversed_categories}
-
-# Trie for efficient keyword matching
-class TrieNode:
-    def __init__(self):
-        self.children = {}
-        self.category = None
-
-def build_trie(keywords):
-    root = TrieNode()
-    for keyword, category in reversed_categories.items():
-        node = root
-        for char in keyword:
-            if char not in node.children:
-                node.children[char] = TrieNode()
-            node = node.children[char]
-        node.category = category
-    return root
-
-trie_root = build_trie(reversed_categories)
-
-def find_category(trie_root, tag):
-    node = trie_root
-    for char in tag:
-        if char in node.children:
-            node = node.children[char]
-            if node.category:
-                return node.category
-        else:
-            break
-    return None
-
-def classify_tags(tags: list[str], local_test: bool = False):
-    # Dictionary for automatic classification
-    classified_tags: defaultdict[str, list] = defaultdict(list)
-    unclassified_tags: list[str] = []
-
-    # Logic for automatic grouping
-    for tag in tags:
-        classified = False
-
-        # Keep original tag for storage, create normalized version for matching
-        tag_normalized = tag.replace(" ", "_").replace("-", "_")
-
-        # Try exact match with normalized tag
-        category = find_category(trie_root, tag_normalized)
-
-        # Also try with escaped parentheses if tag contains parentheses?
-        if not category and ('(' in tag_normalized or ')' in tag_normalized):
-            tag_escaped = tag_normalized.replace("(", "\\(").replace(")", "\\)")
-            category = find_category(trie_root, tag_escaped)
-
-        if category:
-            classified = True
-            if tag not in classified_tags[category]:  # Avoid duplicates
-                classified_tags[category].append(tag)
-        else:
-            # Fuzzy match
-            tag_parts = tag_normalized.split("_")
-            found_category = None
-            for keyword, keyword_length in keyword_lengths.items():
-                if keyword in tag_normalized and keyword_length > 3:
-                    found_category = reversed_categories[keyword]
-                    break
-
-            if found_category and tag not in classified_tags[found_category]:
-                classified_tags[found_category].append(tag)
-                classified = True
-
-            if not classified and tag not in unclassified_tags:
-                unclassified_tags.append(tag)
-
-    if local_test:
-        # Output the grouping result
-        for category, tags_in_category in classified_tags.items():
-            print(f"{category}:")
-            print(", ".join(tags_in_category))
-            print()
-
-        if len(unclassified_tags) > 0:
-            print(f"\nUnclassified tags: {len(unclassified_tags)}")
-            print(f"{unclassified_tags[:200]}")  # Display some unclassified tags
-
-    return classified_tags, unclassified_tags
-
-# Code for "Tag Categorizer" tab
-def process_tags(input_tags: str):
-    # Split tags using regex to handle both commas and question marks
-    tags = []
-    for tag in re.split(r'[\?.,\n]+', input_tags):  # Fixed regex pattern
-        tag = tag.strip()
-        if tag:
-            tag = tag.replace('_', ' ')
-            if tag:  # Only add if tag is not empty after processing
-                tags.append(tag)
-
-    # Classify the cleaned tags
-    classified_tags, unclassified_tags = classify_tags(tags)
-
-    # Create the outputs
-    categorized_string = ', '.join([tag for category in classified_tags.values() for tag in category]).replace("(", "\\(").replace(")", "\\)")
-    categorized_json = {category: tags for category, tags in classified_tags.items()}
-
-    return categorized_string, categorized_json
+import re
+from collections import defaultdict
+
+# Test: Define priority tags that should always come first
+PRIORITY_TAGS = [
+    '1girl', '2girls', '3girls', '4girls', '5girls', '6+girls', 'multiple_girls',
+    '1boy', '2boys', '3boys', '4boys', '5boys', '6+boys', 'multiple_boys',
+    'male_focus', 'female_focus', 'other_focus'
+]
+
+categories = {
+'Explicit':['sex', '69', 'paizuri', 'cum', 'precum', 'areola_slip', 'hetero', 'erection', 'oral', 'fellatio', 'yaoi', 'ejaculation', 'ejaculating', 'masturbation', 'handjob', 'bulge', 'rape', '_rape', 'doggystyle', 'threesome', 'missionary', 'object_insertion', 'nipple', 'nipples', 'pussy', 'anus', 'penis', 'groin', 'testicles', 'testicle', 'anal', 'cameltoe', 'areolae', 'dildo', 'clitoris', 'top-down_bottom-up', 'gag', 'groping', 'gagged', 'gangbang', 'orgasm', 'femdom', 'incest', 'bukkake', 'breast_out', 'vaginal', 'vagina', 'public_indecency', 'breast_sucking', 'folded', 'cunnilingus', '_cunnilingus', 'foreskin', 'bestiality', 'footjob', 'uterus', 'womb', 'flaccid', 'defloration', 'butt_plug', 'cowgirl_position', 'reverse_cowgirl_position', 'squatting_cowgirl_position', 'reverse_upright_straddle', 'irrumatio', 'deepthroat', 'pokephilia', 'gaping', 'orgy', 'cleft_of_venus', 'futanari', 'futasub', 'futa', 'cumdrip', 'fingering', 'vibrator', 'partially_visible_vulva', 'penetration', 'penetrated', 'cumshot', 'exhibitionism', 'breast_milk', 'grinding', 'clitoral', 'urethra', 'phimosis', 'cervix', 'impregnation', 'tribadism', 'molestation', 'pubic_hair', 'clothed_female_nude_male', 'clothed_male_nude_female', 'clothed_female_nude_female', 'clothed_male_nude_male', 'sex_machine', 'milking_machine', 'ovum', 'chikan', 'pussy_juice_drip_through_clothes', 'ejaculating_while_penetrated', 'suspended_congress', 'reverse_suspended_congress', 'spread_pussy_under_clothes', 'anilingus', 'reach-around', 'humping', 'consensual_tentacles', 'tentacle_pit', 'cum_in_'],
+'Appearance Status':['backless', 'bandaged_neck', 'bleeding', 'blood', '_blood', 'blush', 'body_writing', 'bodypaint', 'bottomless', 'breath', 'bruise', 'butt_crack', 'cold', 'covered_mouth', 'crack', 'cross-section', 'crotchless', 'crying', 'curvy', 'cuts', 'dirty', 'dripping', 'drunk', 'from_mouth', 'glowing', 'hairy', 'halterneck', 'hot', 'injury', 'latex', 'leather', 'levitation', 'lipstick_mark', '_markings', 'makeup', 'mole', 'moles', 'no_bra', 'nosebleed', 'nude', 'outfit', 'pantylines', 'peeing', 'piercing', '_piercing', 'piercings', 'pregnant', 'public_nudity', 'reverse', '_skin', '_submerged', 'saliva', 'scar', 'scratches', 'see-through', 'shadow', 'shibari', 'sideless', 'skindentation', 'sleeping', 'tan', 'soap_bubbles', 'steam', 'steaming_body', 'stitches', 'sweat', 'sweatdrop', 'sweaty', 'tanlines', 'tattoo', 'tattoo', 'tears', 'topless', 'transparent', 'trefoil', 'trembling', 'veins', 'visible_air', 'wardrobe_malfunction', 'wet', 'x-ray', 'unconscious', 'handprint'],
+'Action Pose':['afloat', 'afterimage', 'against_fourth_wall', 'against_wall', 'aiming', 'all_fours',"another's_mouth",'arm_', 'arm_support', 'arms_', 'arms_behind_back', 'asphyxiation', 'attack', 'back', 'ballet', 'bara', 'bathing', 'battle', 'bdsm', 'beckoning', 'bent_over', 'bite_mark', 'biting', 'bondage', 'breast_suppress', 'breathing', 'burning', 'bust_cup', 'carry', 'carrying', 'caught', 'chained', 'cheek_squash', 'chewing', 'cigarette', 'clapping', 'closed_eye', 'come_hither', 'cooking', 'covering', 'cuddling', 'dancing', '_docking', 'destruction', 'dorsiflexion', 'dreaming', 'dressing', 'drinking', 'driving', 'dropping', 'eating', 'exercise', 'expansion', 'exposure', 'facing', 'failure', 'fallen_down', 'falling', 'feeding', 'fetal_position', 'fighting', 'finger_on_trigger', 'finger_to_cheek', 'finger_to_mouth', 'firing', 'fishing', 'flashing', 'fleeing', 'flexible', 'flexing', 'floating', 'flying', 'fourth_wall', 'freediving', 'frogtie', '_grab', 'girl_on_top', 'giving', 'grabbing', 'grabbing_', 'gymnastics', '_hold', 'hadanugi_dousa', 'hairdressing', 'hand_', 'hand_on', 'hand_on_wall', 'hands_', 'headpat', 'hiding', 'holding', 'hug', 'hugging', 'imagining', 'in_container', 'in_mouth', 'in_palm', 'jealous', 'jumping', 'kabedon', 'kicking', 'kiss', 'kissing', 'kneeling', '_lift', 'lactation', 'laundry', 'licking', 'lifted_by_self', 'looking', 'lowleg', 'lying', 'melting', 'midair', 'moaning', '_open', 'on_back', 'on_bed', 'on_ground', 'on_lap', 'on_one_knee', 'one_eye_closed', 'open_', 'over_mouth', 'own_mouth', '_peek', '_pose', '_press', '_pull', 'padding', 'paint', 'painting_(action)', 'palms_together', 'pee', 'peeking', 'pervert', 'petting', 'pigeon-toed', 'piggyback', 'pinching', 'pinky_out', 'pinned', 'plantar_flexion', 'planted', 'playing', 'pocky', 'pointing', 'poke', 'poking', 'pouring', 'pov', 'praying', 'presenting', 'profanity', 'pulled_by_self', 'pulling', 'pump_action', 'punching', '_rest', 'raised', 'reaching', 'reading', 'reclining', 'reverse_grip', 'riding', 'running', '_slip', 'salute', 'screaming', 'seiza', 'selfie', 'sewing', 'shaking', 'shoe_dangle', 'shopping', 'shouting', 'showering', 'shushing', 'singing', 'sitting', 'slapping', 'smell', 'smelling', 'smoking', 'smother', 'solo', 'spanked', 'spill', 'spilling', 'spinning', 'splashing', 'split', 'squatting', 'squeezed', 'breasts_squeezed_together', 'standing', 'standing_on_', 'staring', 'straddling', 'strangling', 'stretching', 'surfing', 'suspension', 'swimming', 'talking', 'teardrop', 'tearing_clothes', 'throwing', 'tied_up', 'tiptoes', 'toe_scrunch', 'toothbrush', 'trigger_discipline', 'tripping', 'tsundere', 'turning_head', 'twitching', 'two-handed', 'tying', '_up', 'unbuttoned', 'undressed', 'undressing', 'unsheathed', 'unsheathing', 'unzipped', 'unzipping', 'upright_straddle', 'v', 'V', 'vore', '_wielding', 'wading', 'walk-in', 'walking', 'wariza', 'waving', 'wedgie', 'wrestling', 'writing', 'yawning', 'yokozuwari', '_conscious', 'massage', 'struggling', 'shrugging', 'drugged', 'tentacles_under_clothes', 'restrained_by_tentacles', 'tentacles_around_arms', 'tentacles_around_legs', 'restrained_legs', 'restrained_tail', 'restrained_arms', 'tentacles_on_female', 'archery', 'cleaning', 'tempura', 'facepalm', 'sadism'],
+'Headwear':['antennae', 'antlers', 'aura', 'bandaged_head', 'bandana', 'bandeau', 'beanie', 'beanie', 'beret', 'bespectacled', 'blindfold', 'bonnet', '_cap', 'circlet', 'crown', '_drill', '_drills', 'diadem', '_eyewear', 'ear_covers', 'ear_ornament', 'ear_tag', 'earbuds', 'earclip', 'earmuffs', 'earphones', 'earpiece', 'earring', 'earrings', 'eyeliner', 'eyepatch', 'eyewear_on_head', 'facial', 'fedora', 'glasses', 'goggles', '_headwear', 'hachimaki', 'hair_', 'hair_bobbles', 'hair_ornament', 'hair_rings', 'hair_tie', 'hairband', 'hairclip', 'hairpin', 'hairpods', 'halo', 'hat', 'head-mounted_display', 'head_wreath', 'headband', 'headdress', 'headgear', 'headphones', 'headpiece', 'headset', 'helm', 'helmet', 'hood', 'kabuto_(helmet)', 'kanzashi', '_mask', 'maid_headdress', 'mask', 'mask', 'mechanical_ears', 'mechanical_eye', 'mechanical_horns', 'mob_cap', 'monocle', 'neck_ruff', 'nightcap', 'on_head', 'pince-nez', 'qingdai_guanmao', 'scarf_over_mouth', 'scrunchie', 'sunglasses',"tam_o'_shanter",'tate_eboshi', 'tiara', 'topknot', 'turban', 'veil', 'visor', 'wig', 'mitre', 'tricorne', 'bicorne'],
+'Handwear':['arm_warmers', 'armband', 'armlet', 'bandaged_arm', 'bandaged_fingers', 'bandaged_hand', 'bandaged_wrist', 'bangle', 'bracelet', 'bracelets', 'bracer', 'cuffs', 'elbow_pads', '_gauntlets', '_glove', '_gloves', 'gauntlets', 'gloves', 'kote', 'kurokote', 'mechanical_arm', 'mechanical_arms', 'mechanical_hands', 'mittens', 'mitts', 'nail_polish', 'prosthetic_arm', 'wrist_cuffs', 'wrist_guards', 'wristband', 'yugake'],
+'One-Piece Outfit':['bodystocking', 'bodysuit', 'dress', 'furisode', 'gown', 'hanfu', 'jumpsuit', 'kimono', 'leotard', 'microdress', 'one-piece', 'overalls', 'robe', 'spacesuit', 'sundress', 'yukata'],
+'Upper Body Clothing':['aiguillette', 'apron', '_apron', 'armor', '_armor', 'ascot', 'babydoll', 'bikini', '_bikini', 'blazer', '_blazer', 'blouse', '_blouse', 'bowtie', '_bowtie', 'bra', '_bra', 'breast_curtain', 'breast_curtains', 'breast_pocket', 'breastplate', 'bustier', 'camisole', 'cape', 'capelet', 'cardigan', 'center_opening', 'chemise', 'chest_jewel', 'choker', 'cloak', 'coat', 'coattails', 'collar', '_collar', 'corset', 'criss-cross_halter', 'crop_top', 'dougi', 'feather_boa', 'gakuran', 'hagoromo', 'hanten_(clothes)', 'haori', 'harem_pants', 'harness', 'hoodie', 'jacket', '_jacket', 'japanese_clothes', 'kappougi', 'kariginu', 'lapels', 'lingerie', '_lingerie', 'maid', 'mechanical_wings', 'mizu_happi', 'muneate', 'neckerchief', 'necktie', 'negligee', 'nightgown', 'pajamas', '_pajamas', 'pauldron', 'pauldrons', 'plunging_neckline', 'raincoat', 'rei_no_himo', 'sailor_collar', 'sarashi', 'scarf', 'serafuku', 'shawl', 'shirt', 'shoulder_', 'sleepwear', 'sleeve', 'sleeveless', 'sleeves', '_sleeves', 'sode', 'spaghetti_strap', 'sportswear', 'strapless', 'suit', 'sundress', 'suspenders', 'sweater', 'swimsuit', '_top', '_torso', 't-shirt', 'tabard', 'tailcoat', 'tank_top', 'tasuki', 'tie_clip', 'tunic', 'turtleneck', 'tuxedo', '_uniform', 'undershirt', 'uniform', 'v-neck', 'vambraces', 'vest', 'waistcoat'],
+'Lower Body Clothing':['bare_hips', 'bloomers', 'briefs', 'buruma', 'crotch_seam', 'cutoffs', 'denim', 'faulds', 'fundoshi', 'g-string', 'garter_straps', 'hakama', 'hip_vent', 'jeans', 'knee_pads', 'loincloth', 'mechanical_tail', 'microskirt', 'miniskirt', 'overskirt', 'panties', 'pants', 'pantsu', 'panty_straps', 'pelvic_curtain', 'petticoat', 'sarong', 'shorts', 'side_slit', 'skirt', 'sweatpants', 'swim_trunks', 'thong', 'underwear', 'waist_cape'],
+'Foot & Legwear':['anklet', 'bandaged_leg', 'boot', 'boots', '_footwear', 'flats', 'flip-flops', 'geta', 'greaves', '_heels', 'kneehigh', 'kneehighs', '_legwear', 'leg_warmers', 'leggings', 'loafers', 'mary_janes', 'mechanical_legs', 'okobo', 'over-kneehighs', 'pantyhose', 'prosthetic_leg', 'pumps', '_shoe', '_sock', 'sandals', 'shoes', 'skates', 'slippers', 'sneakers', 'socks', 'spikes', 'tabi', 'tengu-geta', 'thigh_strap', 'thighhighs', 'uwabaki', 'zouri', 'legband', 'ankleband'],
+'Other Accessories':['alternate_', 'anklet', 'badge', 'beads', 'belt', 'belts', 'bow', '_bow', 'brooch', 'buckle', 'button', 'buttons', '_clothes', '_costume', '_cutout', 'casual', 'charm', 'clothes_writing', 'clothing_aside', 'costume', 'cow_print', 'cross', 'd-pad', 'double-breasted', 'drawstring', 'epaulettes', 'fabric', 'fishnets', 'floral_print', 'formal', 'frills', '_garter', 'gem', 'holster', 'jewelry', '_knot', 'lace', 'lanyard', 'leash', 'magatama', 'mechanical_parts', 'medal', 'medallion', 'naked_bandage', 'necklace', '_ornament', '(ornament)', 'o-ring', 'obi', 'obiage', 'obijime', '_pin', '_print', 'padlock', 'patterned_clothing', 'pendant', 'piercing', 'plaid', 'pocket', 'polka_dot', 'pom_pom_(clothes)', 'pom_pom_(clothes)', 'pouch', 'ribbon', '_ribbon', '_stripe', '_stripes', 'sash', 'shackles', 'shimenawa', 'shrug_(clothing)', 'skin_tight', 'spandex', 'strap', 'sweatband', '_trim', 'tassel', 'zettai_ryouiki', 'zipper'],
+'Facial Expression':['ahegao', 'anger_vein', 'angry', 'annoyed', 'confused', 'drooling', 'embarrassed', 'expressionless', 'eye_contact', '_face', 'frown', 'fucked_silly', 'furrowed_brow', 'glaring', 'gloom_(expression)', 'grimace', 'grin', 'happy', 'jitome', 'laughing', '_mouth', 'nervous', 'notice_lines', 'o_o', 'parted_lips', 'pout', 'puff_of_air', 'restrained', 'sad', 'sanpaku', 'scared', 'scowl', 'serious', 'shaded_face', 'shy', 'sigh', 'sleepy', 'smile', 'smirk', 'smug', 'snot', 'spoken_ellipsis', 'spoken_exclamation_mark', 'spoken_interrobang', 'spoken_question_mark', 'squiggle', 'surprised', 'tareme', 'tearing_up', 'thinking', 'tongue', 'tongue_out', 'torogao', 'tsurime', 'turn_pale', 'wide-eyed', 'wince', 'worried', 'heartbeat'],
+'Facial Emoji':['!!', '!', '!?', '+++', '+_+', '...', '...?', '._.', '03:00', '0_0', ':/', ':3', ':<', ':>', ':>=', ':d', ':i', ':o', ':p', ':q', ':t', ':x', ':|', ';(', ';)', ';3', ';d', ';o', ';p', ';q', '=_=', '>:(', '>:)', '>_<', '>_o', '>o<', '?', '??', '@_@', '\\m/', '\n/', '\\o/', '\\||/', '^^^', '^_^', 'c:', 'd:', 'o_o', 'o3o', 'u_u', 'w', 'x', 'x_x', 'xd', 'zzz', '|_|'],
+'Head':['afro', 'ahoge', 'animal_ear_fluff', '_bangs', '_bun', 'bald', 'beard', 'blunt_bangs', 'blunt_ends', 'bob_cut', 'bowl_cut', 'braid', 'braids', 'buzz_cut', 'circle_cut', 'colored_tips', 'cowlick', 'dot_nose', 'dreadlocks', '_ear', '_ears', '_eye', '_eyes', 'enpera', 'eyeball', 'eyebrow', 'eyebrow_cut', 'eyebrows', 'eyelashes', 'eyeshadow', 'faceless', 'facepaint', 'facial_mark', 'fang', 'forehead', 'freckles', 'goatee', '_hair', 'very_long_hair', 'hair_bun', 'hair_flaps', 'hair_intakes', 'hair_tubes', 'tentacle_hair', '_horn', '_horns', 'half_updo', 'head_tilt', 'heterochromia', 'hime_cut', 'hime_cut', 'horns', '_in_eye', 'inverted_bob', 'kemonomimi_mode', 'lips', 'mascara', 'mohawk', 'mouth_', 'mustache', 'nose', 'one-eyed', 'one_eye', 'one_side_up', '_pupils', 'parted_bangs', 'pompadour', 'ponytail', 'ringlets', '_sclera', 'sideburns', 'sidecut', 'sidelock', 'sidelocks', 'skull', 'snout', 'stubble', 'swept_bangs', 'tails', 'teeth', 'third_eye', 'twintails', 'two_side_up', 'undercut', 'updo', 'v-shaped_eyebrows', 'whiskers'],
+'Hands':['_arm', '_arms', 'claws', '_finger', '_fingers', 'fingernails', '_hand', '_nail', '_nails', 'palms', 'rings', 'thumbs_up'],
+'Upper Body':['abs', 'armpit', 'armpits', 'backboob', 'belly', 'biceps', 'breast_rest', 'breasts', 'button_gap', 'cleavage', 'collarbone', 'dimples_of_venus', 'downblouse', 'flat_chest', 'linea_alba', 'median_furrow', 'midriff', 'nape', 'navel', 'pectorals', 'ribs', '_shoulder', '_shoulders', 'shoulder_blades', 'sideboob', 'sidetail', 'spine', 'stomach', 'strap_gap', 'toned', 'underboob', 'underbust'],
+'Lower Body':['ankles', 'ass', 'barefoot', 'crotch', 'feet', 'highleg', 'hip_bones', 'hooves', 'kneepits', 'knees', 'legs', 'soles', 'tail', 'thigh_gap', 'thighlet', 'thighs', 'toenail', 'toenails', 'toes', 'wide_hips'],
+'Creature':['(animal)', 'anglerfish', 'animal', 'bear', 'bee', 'bird', 'bug', 'butterfly', 'cat', 'chick', 'chicken', 'chinese_zodiac', 'clownfish', 'coral', 'crab', 'creature', 'crow', 'dog', 'dove', 'dragon', 'duck', 'eagle', 'fish', 'fish', 'fox', 'fox', 'frog', 'frog', 'goldfish', 'hamster', 'horse', 'jellyfish', 'ladybug', 'lion', 'mouse', 'octopus', 'owl', 'panda', 'penguin', 'pig', 'pigeon', 'rabbit', 'rooster', 'seagull', 'shark', 'sheep', 'shrimp', 'snail', 'snake', 'squid', 'starfish', 'tanuki', 'tentacles', 'goo_tentacles', 'plant_tentacles', 'crotch_tentacles', 'mechanical_tentacles', 'squidward_tentacles', 'suction_tentacles', 'penis_tentacles', 'translucent_tentacles', 'back_tentacles', 'red_tentacles', 'green_tentacles', 'blue_tentacles', 'black_tentacles', 'pink_tentacles', 'purple_tentacles', 'face_tentacles', 'tentacles_everywhere', 'milking_tentacles', 'tiger', 'turtle', 'weasel', 'whale', 'wolf', 'parrot', 'sparrow', 'unicorn'],
+'Plant':['bamboo', 'bouquet', 'branch', 'bush', 'cherry_blossoms', 'clover', 'daisy', '(flower)', 'flower', 'flower', 'gourd', 'hibiscus', 'holly', 'hydrangea', 'leaf', 'lily_pad', 'lotus', 'moss', 'palm_leaf', 'palm_tree', 'petals', 'plant', 'plum_blossoms', 'rose', 'spider_lily', 'sunflower', 'thorns', 'tree', 'tulip', 'vines', 'wisteria', 'acorn'],
+'Food':['apple', 'baguette', 'banana', 'baozi', 'beans', 'bento', 'berry', 'blueberry', 'bread', 'broccoli', 'burger', 'cabbage', 'cake', 'candy', 'carrot', 'cheese', 'cherry', 'chili_pepper', 'chocolate', 'coconut', 'cookie', 'corn', 'cream', 'crepe', 'cucumber', 'cucumber', 'cupcake', 'curry', 'dango', 'dessert', 'doughnut', 'egg', 'eggplant', '_(food)', '_(fruit)', 'food', 'french_fries', 'fruit', 'grapes', 'ice_cream', 'icing', 'lemon', 'lettuce', 'lollipop', 'macaron', 'mandarin_orange', 'meat', 'melon', 'mochi', 'mushroom', 'noodles', 'omelet', 'omurice', 'onigiri', 'onion', 'pancake', 'parfait', 'pasties', 'pastry', 'peach', 'pineapple', 'pizza', 'popsicle', 'potato', 'pudding', 'pumpkin', 'radish', 'ramen', 'raspberry', 'rice', 'roasted_sweet_potato', 'sandwich', 'sausage', 'seaweed', 'skewer', 'spitroast', 'spring_onion', 'strawberry', 'sushi', 'sweet_potato', 'sweets', 'taiyaki', 'takoyaki', 'tamagoyaki', 'tempurakanbea', 'toast', 'tomato', 'vegetable', 'wagashi', 'wagashi', 'watermelon', 'jam', 'popcorn'],
+'Beverage':['alcohol', 'beer', 'coffee', 'cola', 'drink', 'juice', 'juice_box', 'milk', 'sake', 'soda', 'tea', '_tea', 'whiskey', 'wine', 'cocktail'],
+'Music':['band', 'baton_(conducting)', 'beamed', 'cello', 'concert', 'drum', 'drumsticks', 'eighth_note', 'flute', 'guitar', 'harp', 'horn', '(instrument)', 'idol', 'instrument', 'k-pop', 'lyre', '(music)', 'megaphone', 'microphone', 'music', 'musical_note', 'phonograph', 'piano', 'plectrum', 'quarter_note', 'recorder', 'sixteenth_note', 'sound_effects', 'trumpet', 'utaite', 'violin', 'whistle'],
+'Weapons & Equipment':['ammunition', 'arrow_(projectile)', 'axe', 'bandolier', 'baseball_bat', 'beretta_92', 'bolt_action', 'bomb', 'bullet', 'bullpup', 'cannon', 'chainsaw', 'crossbow', 'dagger', 'energy_sword', 'explosive', 'fighter_jet', 'gohei', 'grenade', 'gun', 'hammer', 'handgun', 'holstered', 'jet', 'katana', 'knife', 'kunai', 'lance', 'mallet', 'nata_(tool)', 'polearm', 'quiver', 'rapier', 'revolver', 'rifle', 'rocket_launcher', 'scabbard', 'scope', 'scythe', 'sheath', 'sheathed', 'shield', 'shotgun', 'shuriken', 'spear', 'staff', 'suppressor', 'sword', 'tank', 'tantou', 'torpedo', 'trident', '(weapon)', 'wand', 'weapon', 'whip', 'yumi_(bow)', 'h&k_hk416', 'rocket_launcher', 'heckler_&_koch', '_weapon'],
+'Vehicles':['aircraft', 'airplane', 'bicycle', 'boat', 'car', 'caterpillar_tracks', 'flight_deck', 'helicopter', 'motor_vehicle', 'motorcycle', 'ship', 'spacecraft', 'spoiler_(automobile)', 'train', 'truck', 'watercraft', 'wheel', 'wheelbarrow', 'wheelchair', 'inflatable_raft'],
+'Buildings':['apartment', 'aquarium', 'architecture', 'balcony', 'building', 'cafe', 'castle', 'church', 'gym', 'hallway', 'hospital', 'house', 'library', '(place)', 'porch', 'restaurant', 'restroom', 'rooftop', 'shop', 'skyscraper', 'stadium', 'stage', 'temple', 'toilet', 'tower', 'train_station', 'veranda'],
+'Indoor':['bath', 'bathroom', 'bathtub', 'bed', 'bed_sheet', 'bedroom', 'blanket', 'bookshelf', 'carpet', 'ceiling', 'chair', 'chalkboard', 'classroom', 'counter', 'cupboard', 'curtains', 'cushion', 'dakimakura', 'desk', 'door', 'doorway', 'drawer', '_floor', 'floor', 'futon', 'indoors', 'interior', 'kitchen', 'kotatsu', 'locker', 'mirror', 'pillow', 'room', 'rug', 'school_desk', 'shelf', 'shouji', 'sink', 'sliding_doors', 'stairs', 'stool', 'storeroom', 'table', 'tatami', 'throne', 'window', 'windowsill', 'bathhouse', 'chest_of_drawers'],
+'Outdoor':['alley', 'arch', 'beach', 'bridge', 'bus_stop', 'bush', 'cave', '(city)', 'city', 'cliff', 'crescent', 'crosswalk', 'day', 'desert', 'fence', 'ferris_wheel', 'field', 'forest', 'grass', 'graveyard', 'hill', 'lake', 'lamppost', 'moon', 'mountain', 'night', 'ocean', 'onsen', 'outdoors', 'path', 'pool', 'poolside', 'railing', 'railroad', 'river', 'road', 'rock', 'sand', 'shore', 'sky', 'smokestack', 'snow', 'snowball', 'snowman', 'street', 'sun', 'sunlight', 'sunset', 'tent', 'torii', 'town', 'tree', 'turret', 'utility_pole', 'valley', 'village', 'waterfall'],
+'Objects':['anchor', 'android', 'armchair', '(bottle)', 'backpack', 'bag', 'ball', 'balloon', 'bandages', 'bandaid', 'bandaids', 'banknote', 'banner', 'barcode', 'barrel', 'baseball', 'basket', 'basketball', 'beachball', 'bell', 'bench', 'binoculars', 'board_game', 'bone', 'book', 'bottle', 'bowl', 'box', 'box_art', 'briefcase', 'broom', 'bucket', '(chess)', '(computer)', '(computing)', '(container)', 'cage', 'calligraphy_brush', 'camera', 'can', 'candle', 'candlestand', 'cane', 'card', 'cartridge', 'cellphone', 'chain', 'chandelier', 'chess', 'chess_piece', 'choko_(cup)', 'chopsticks', 'cigar', 'clipboard', 'clock', 'clothesline', 'coin', 'comb', 'computer', 'condom', 'controller', 'cosmetics', 'couch', 'cowbell', 'crazy_straw', 'cup', 'cutting_board', 'dice', 'digital_media_player', 'doll', 'drawing_tablet', 'drinking_straw', 'easel', 'electric_fan', 'emblem', 'envelope', 'eraser', 'feathers', 'figure', 'fire', 'fishing_rod', 'flag', 'flask', 'folding_fan', 'fork', 'frying_pan', '(gemstone)', 'game_console', 'gears', 'gemstone', 'gift', 'glass', 'glowstick', 'gold', 'handbag', 'handcuffs', 'handheld_game_console', 'hose', 'id_card', 'innertube', 'iphone',"jack-o'-lantern",'jar', 'joystick', 'key', 'keychain', 'kiseru', 'ladder', 'ladle', 'lamp', 'lantern', 'laptop', 'letter', 'letterboxed', 'lifebuoy', 'lipstick', 'liquid', 'lock', 'lotion', '_machine', 'map', 'marker', 'model_kit', 'money', 'monitor', 'mop', 'mug', 'needle', 'newspaper', 'nintendo', 'nintendo_switch', 'notebook', '(object)', 'ofuda', 'orb', 'origami', '(playing_card)', 'pack', 'paddle', 'paintbrush', 'pan', 'paper', 'parasol', 'patch', 'pc', 'pen', 'pencil', 'pencil', 'pendant_watch', 'phone', 'pill', 'pinwheel', 'plate', 'playstation', 'pocket_watch', 'pointer', 'poke_ball', 'pole', 'quill', 'racket', 'randoseru', 'remote_control', 'ring', 'rope', 'sack', 'saddle', 'sakazuki', 'satchel', 'saucer', 'scissors', 'scroll', 'seashell', 'seatbelt', 'shell', 'shide', 'shopping_cart', 'shovel', 'shower_head', 'silk', 'sketchbook', 'smartphone', 'soap', 'sparkler', 'spatula', 'speaker', 'spoon', 'statue', 'stethoscope', 'stick', 'sticker', 'stopwatch', 'string', 'stuffed_', 'stylus', 'suction_cups', 'suitcase', 'surfboard', 'syringe', 'talisman', 'tanzaku', 'tape', 'teacup', 'teapot', 'teddy_bear', 'television', 'test_tube', 'tiles', 'tokkuri', 'tombstone', 'torch', 'towel', 'toy', 'traffic_cone', 'tray', 'treasure_chest', 'uchiwa', 'umbrella', 'vase', 'vial', 'video_game', 'viewfinder', 'volleyball', 'wallet', 'watch', 'watch', 'whisk', 'whiteboard', 'wreath', 'wrench', 'wristwatch', 'yunomi', 'ace_of_hearts', 'inkwell', 'compass', 'ipod', 'sunscreen', 'rocket', 'cobblestone'],
+'Character Design':['+boys', '+girls', '1other', '39', '_boys', '_challenge', '_connection', '_female', '_fur', '_girls', '_interface', '_male', '_man', '_person', 'abyssal_ship', 'age_difference', 'aged_down', 'aged_up', 'albino', 'alien', 'alternate_muscle_size', 'ambiguous_gender', 'amputee', 'androgynous', 'angel', 'animalization', 'ass-to-ass', 'assault_visor', 'au_ra', 'baby', 'bartender', 'beak', 'bishounen', 'borrowed_character', 'boxers', 'boy', 'breast_envy', 'breathing_fire', 'bride', 'broken', 'brother_and_sister', 'brothers', 'camouflage', 'cheating_(relationship)', 'cheerleader', 'chibi', 'child', 'clone', 'command_spell', 'comparison', 'contemporary', 'corpse', 'corruption', 'cosplay', 'couple', 'creature_and_personification', 'crossdressing', 'crossover', 'cyberpunk', 'cyborg', 'cyclops', 'damaged', 'dancer', 'danmaku', 'darkness', 'death', 'defeat', 'demon', 'disembodied_', 'draph', 'drone', 'duel', 'dwarf', 'egyptian', 'electricity', 'elezen', 'elf', 'enmaided', 'erune', 'everyone', 'evolutionary_line', 'expressions', 'fairy', 'family', 'fangs', 'fantasy', 'fashion', 'fat', 'father_and_daughter', 'father_and_son', 'fewer_digits', 'fins', 'flashback', 'fluffy', 'fumo_(doll)', 'furry', 'fusion', 'fuuin_no_tsue', 'gameplay_mechanics', 'genderswap', 'ghost', 'giant', 'giantess', 'gibson_les_paul', 'girl', 'goblin', 'groom', 'guro', 'gyaru', 'habit', 'harem', 'harpy', 'harvin', 'heads_together', 'health_bar', 'height_difference', 'hitodama', 'horror_(theme)', 'humanization', 'husband_and_wife', 'hydrokinesis', 'hypnosis', 'hyur', 'idol', 'insignia', 'instant_loss', 'interracial', 'interspecies', 'japari_bun', 'jeweled_branch_of_hourai', 'jiangshi', 'jirai_kei', 'joints', 'karakasa_obake', 'keyhole', 'kitsune', 'knight', 'kodona', 'kogal', 'kyuubi', 'lamia', 'left-handed', 'loli', 'lolita', 'look-alike', 'machinery', 'magic', 'male_focus', 'manly', 'matching_outfits', 'mature_female', 'mecha', 'mermaid', 'meta', 'miko', 'milestone_celebration', 'military', 'mind_control', 'miniboy', 'minigirl',"miqo'te",'monster', 'monsterification', 'mother_and_daughter', 'mother_and_son', 'multiple_others', 'muscular', 'nanodesu_(phrase)', 'narrow_waist', 'nekomata', 'netorare', 'ninja', 'no_humans', 'nontraditional', 'nun', 'nurse', 'object_namesake', 'obliques', 'office_lady', 'old', 'on_body', 'onee-shota', 'oni', 'orc', 'others', 'otoko_no_ko', 'oversized_object', 'paint_splatter', 'pantyshot', 'pawpads', 'persona', 'personality', 'personification', 'pet_play', 'petite', 'pirate', 'playboy_bunny', 'player_2', 'plugsuit', 'plump', 'poi', 'pokemon', 'police', 'policewoman', 'pom_pom_(cheerleading)', 'princess', 'prosthesis', 'pun', 'puppet', 'race_queen', 'radio_antenna', 'real_life_insert', 'redesign', 'reverse_trap', 'rigging', 'robot', 'rod_of_remorse', 'sailor', 'salaryman', 'samurai', 'sangvis_ferri', 'scales', 'scene_reference', 'school', 'sheikah', 'shota', 'shrine', 'siblings', 'side-by-side', 'sidesaddle', 'sisters', 'size_difference', 'skeleton', 'skinny', 'slave', 'slime_(substance)', 'soldier', 'spiked_shell', 'spokencharacter', 'steampunk', 'streetwear', 'striker_unit', 'strongman', 'submerged', 'suggestive', 'super_saiyan', 'superhero', 'surreal', 'take_your_pick', 'tall', 'talons', 'taur', 'teacher', 'team_rocket', 'three-dimensional_maneuver_gear', 'time_paradox', 'tomboy', 'traditional_youkai', 'transformation', 'trick_or_treat', 'tusks', 'twins', 'ufo', 'under_covers', 'v-fin', 'v-fin', 'vampire', 'virtual_youtuber', 'waitress', 'watching_television', 'wedding', 'what', 'when_you_see_it', 'wife_and_wife', 'wing', 'wings', 'witch', 'world_war_ii', 'yandere', 'year_of', 'yes', 'yin_yang', 'yordle',"you're_doing_it_wrong",'you_gonna_get_raped', 'yukkuri_shiteitte_ne', 'yuri', 'zombie', '(alice_in_wonderland)', '(arknights)', '(blue_archive)', '(cosplay)', '(creature)', '(emblem)', '(evangelion)', '(fate)', '(fate/stay_night)', '(ff11)', '(fire_emblem)', '(genshin_impact)', '(grimm)', '(houseki_no_kuni)', '(hyouka)', '(idolmaster)', '(jojo)', '(kancolle)', '(kantai_collection)', '(kill_la_kill)', '(league_of_legends)', '(legends)', '(lyomsnpmp)', '(machimazo)', '(madoka_magica)', '(mecha)', '(meme)', '(nier:automata)', '(organ)', '(overwatch)', '(pokemon)', '(project_moon)', '(project_sekai)', '(sao)', '(senran_kagura)', '(splatoon)', '(touhou)', '(tsukumo_sana)', '(youkai_watch)', '(yu-gi-oh!_gx)', '(zelda)', 'sextuplets', 'imperial_japanese_army', 'extra_faces', '_miku'],
+'Composition':['abstract', 'anime_coloring', 'animification', 'back-to-back', 'bad_anatomy', 'blurry', 'border', 'bound', 'cameo', 'cheek-to-cheek', 'chromatic_aberration', 'close-up', 'collage', 'color_guide', 'colorful', 'comic', 'contrapposto', 'cover', 'cowboy_shot', 'crosshatching', 'depth_of_field', 'dominatrix', 'dutch_angle', '_focus', 'face-to-face', 'fake_screenshot', 'film_grain', 'fisheye', 'flat_color', 'foreshortening', 'from_above', 'from_behind', 'from_below', 'from_side', 'full_body', 'glitch', 'greyscale', 'halftone', 'head_only', 'heads-up_display', 'high_contrast', 'horizon', '_inset', 'inset', 'jaggy_lines', '1koma', '2koma', '3koma', '4koma', '5koma', 'leaning', 'leaning_forward', 'leaning_to_the_side', 'left-to-right_manga', 'lens_flare', 'limited_palette', 'lineart', 'lineup', 'lower_body', '(medium)', 'marker_(medium)', 'meme', 'mixed_media', 'monochrome', 'multiple_views', 'muted_color', 'oekaki', 'on_side', 'out_of_frame', 'outline', 'painting', 'parody', 'partially_colored', 'partially_underwater_shot', 'perspective', 'photorealistic', 'picture_frame', 'pillarboxed', 'portrait', 'poster_(object)', 'product_placement', 'profile', 'realistic', 'recording', 'retro_artstyle', '(style)', '_style', 'sandwiched', 'science_fiction', 'sepia', 'shikishi', 'side-by-side', 'sideways', 'sideways_glance', 'silhouette', 'sketch', 'spot_color', 'still_life', 'straight-on', 'symmetry', '(texture)', 'tachi-e', 'taking_picture', 'tegaki', 'too_many', 'traditional_media', 'turnaround', 'underwater', 'upper_body', 'upside-down', 'upskirt', 'variations', 'wide_shot', '_design', 'symbolism', 'rounded_corners', 'surrounded'],
+'Season':['akeome', 'anniversary', 'autumn', 'birthday', 'christmas', '_day', 'festival', 'halloween', 'kotoyoro', 'nengajou', 'new_year', 'spring_(season)', 'summer', 'tanabata', 'valentine', 'winter'],
+'Background':['simple_background', '_background', 'backlighting', 'bloom', 'bokeh', 'brick_wall', 'bubble', 'cable', 'caustics', 'cityscape', 'cloud', 'confetti', 'constellation', 'contrail', 'crowd', 'crystal', 'dark', 'debris', 'dusk', 'dust', 'egasumi', 'embers', 'emphasis_lines', 'energy', 'evening', 'explosion', 'fireworks', 'fog', 'footprints', 'glint', 'graffiti', 'ice', 'industrial_pipe', 'landscape', 'light', 'light_particles', 'light_rays', 'lightning', 'lights', 'moonlight', 'motion_blur', 'motion_lines', 'mountainous_horizon', 'nature', '(planet)', 'pagoda', 'people', 'pillar', 'planet', 'power_lines', 'puddle', 'rain', 'rainbow', 'reflection', 'ripples', 'rubble', 'ruins', 'scenery', 'shade', 'shooting_star', 'sidelighting', 'smoke', 'snowflakes', 'snowing', 'space', 'sparkle', 'sparks', 'speed_lines', 'spider_web', 'spotlight', 'star_(sky)', 'stone_wall', 'sunbeam', 'sunburst', 'sunrise', '_theme', 'tile_wall', 'twilight', 'wall_clock', 'wall_of_text', 'water', 'waves', 'wind', 'wire', 'wooden_wall', 'lighthouse'],
+'Patterns':['arrow', 'bass_clef', 'blank_censor', 'circle', 'cube', 'heart', 'hexagon', 'hexagram', 'light_censor', '(pattern)', 'pattern', 'pentagram', 'roman_numeral', '(shape)', '(symbol)', 'shape', 'sign', 'symbol', 'tally', 'treble_clef', 'triangle', 'tube', 'yagasuri'],
+'Censorship':['blur_censor', '_censor', '_censoring', 'censored', 'character_censor', 'convenient', 'hair_censor', 'heart_censor', 'identity_censor', 'maebari', 'novelty_censor', 'soap_censor', 'steam_censor', 'tail_censor', 'uncensored'],
+'Others':['2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021', '2022', '2023', '2024', 'artist', 'artist_name', 'artistic_error', 'asian', '(company)', 'character_name', 'content_rating', 'copyright', 'cover_page', 'dated', 'english_text', 'japan', 'layer', 'logo', 'name', 'numbered', 'page_number', 'pixiv_id', 'language', 'reference_sheet', 'signature', 'speech_bubble', 'subtitled', 'text', 'thank_you', 'typo', 'username', 'wallpaper', 'watermark', 'web_address', 'screwdriver', 'translated'],
+'Quality Tags':['masterpiece', '_quality', 'highres', 'absurdres', 'ultra-detailed', 'lowres']}
+
+# Build a trie for efficient prefix matching
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.category = None
+
+class TagTrie:
+    def __init__(self):
+        self.root = TrieNode()
+        self._build_trie()
+
+    def _build_trie(self):
+        for category, tags in categories.items():
+            for tag in tags:
+                node = self.root
+                for char in tag:
+                    if char not in node.children:
+                        node.children[char] = TrieNode()
+                    node = node.children[char]
+                node.category = category
+
+    def find_category(self, tag):
+        node = self.root
+        matched_category = None
+
+        # Try exact match first
+        for char in tag:
+            if char in node.children:
+                node = node.children[char]
+                if node.category:
+                    matched_category = node.category
+            else:
+                break
+
+        # If exact match found, return it
+        if matched_category and node.children == {}:
+            return matched_category
+
+        # If partial match found, check if it's a valid prefix
+        if matched_category:
+            return matched_category
+
+        # Try substring matching for longer than 3 characters
+        for i in range(len(tag)):
+            for j in range(i+4, len(tag)+1):  # Only check substrings longer than 3 chars
+                substring = tag[i:j]
+                node = self.root
+                valid = True
+                for char in substring:
+                    if char in node.children:
+                        node = node.children[char]
+                    else:
+                        valid = False
+                        break
+                if valid and node.category:
+                    return node.category
+
+        return None
+
+tag_trie = TagTrie()
+
+def normalize_tag(tag):
+    """Normalize tag by converting spaces/hyphens to underscores"""
+    return re.sub(r'[-\s]+', '_', tag.strip())
+
+def classify_single_tag(tag):
+    """Classify a single tag into its category"""
+    normalized_tag = normalize_tag(tag)
+
+    # Try exact match through Trie lookup first
+    category = tag_trie.find_category(normalized_tag)
+
+    # If no match and has underscores, try parts
+    if not category and '_' in normalized_tag:
+        parts = normalized_tag.split('_')
+        for part in parts:
+            if len(part) > 3:  # Only check parts longer than 3 characters
+                category = tag_trie.find_category(part)
+                if category:
+                    break
+
+    # Special handling for escaped parentheses
+    if not category and ('\\(' in normalized_tag or '\\)' in normalized_tag):
+        unescaped = normalized_tag.replace('\\(', '(').replace('\\)', ')')
+        category = tag_trie.find_category(unescaped)
+
+        if not category and '_' in unescaped:
+            parts = unescaped.split('_')
+            for part in parts:
+                if len(part) > 3:
+                    category = tag_trie.find_category(part)
+                    if category:
+                        break
+
+    return category if category else 'Uncategorized'
+
+def extract_priority_and_character_tags(tags_list, character_tags):
+    """
+    Extract priority tags and character tags from the tags list
+
+    Args:
+        tags_list (list): List of all tags
+        character_tags (dict): Dictionary of character tags with confidence scores
+
+    Returns:
+        tuple: (priority_tags, character_tag_names, remaining_tags)
+    """
+    priority_tags_found = []
+    character_tag_names = list(character_tags.keys()) if character_tags else []
+    remaining_tags = []
+
+    # Convert priority tags to set for faster lookup
+    priority_set = set(PRIORITY_TAGS)
+
+    for tag in tags_list:
+        if tag in priority_set:
+            priority_tags_found.append(tag)
+        elif tag in character_tag_names:
+            # Character tags are already handled separately
+            remaining_tags.append(tag)
+        else:
+            remaining_tags.append(tag)
+
+    return priority_tags_found, character_tag_names, remaining_tags
+
+def classify_tags_for_display(tag_string, character_tags=None):
+    """
+    Classify a string of tags and organize them by categories with priority ordering for display
+
+    Args:
+        tag_string (str): Comma-separated tags string
+        character_tags (dict): Dictionary of character tags with confidence scores
+
+    Returns:
+        str: Categorized and organized tags as a comma-separated string
+    """
+    if not tag_string:
+        return ""
+
+    # Split tags by common delimiters
+    delimiters = r'[,\n\r\.!?]+'
+    raw_tags = re.split(delimiters, tag_string)
+
+    # Clean and normalize tags
+    cleaned_tags = []
+    for tag in raw_tags:
+        tag = tag.strip()
+        if tag:
+            cleaned_tags.append(tag)
+
+    # Extract priority and character tags
+    priority_tags_found, character_tag_names, remaining_tags = extract_priority_and_character_tags(cleaned_tags, character_tags)
+
+    # Classify remaining tags
+    categorized = defaultdict(list)
+    uncategorized = []
+
+    for tag in remaining_tags:
+        # Skip character tags as they're already in their own list
+        if tag in character_tag_names:
+            continue
+
+        category = classify_single_tag(tag)
+        if category == 'Uncategorized':
+            uncategorized.append(tag)
+        else:
+            categorized[category].append(tag)
+
+    # Build result string with priority ordering
+    result_parts = []
+
+    # 1. Add priority subject tags first
+    result_parts.extend(priority_tags_found)
+
+    # 2. Add character tags next
+    result_parts.extend(character_tag_names)
+
+    # 3. Add categorized tags in category order
+    for category in categories.keys():
+        if category in categorized and categorized[category]:
+            result_parts.extend(categorized[category])
+
+    # 4. Add uncategorized tags at the end
+    result_parts.extend(uncategorized)
+
+    # Process tags: replace underscores with spaces and handle escaped characters
+    processed_tags = []
+    for tag in result_parts:
+        processed_tag = tag.replace('_', ' ').replace('\\(', '(').replace('\\)', ')')
+        processed_tags.append(processed_tag)
+
+    return ', '.join(processed_tags)
+
+def generate_categorized_json(tag_string, character_tags=None):
+    """
+    Generate JSON object organizing tags by categories
+
+    Args:
+        tag_string (str): Comma-separated tags string
+        character_tags (dict): Dictionary of character tags with confidence scores
+
+    Returns:
+        dict: JSON-compatible dictionary with categories as keys and tag lists as values
+    """
+    if not tag_string:
+        return {}
+
+    # Split tags by common delimiters
+    delimiters = r'[,\n\r\.!?]+'
+    raw_tags = re.split(delimiters, tag_string)
+
+    # Clean and normalize tags
+    cleaned_tags = []
+    for tag in raw_tags:
+        tag = tag.strip()
+        if tag:
+            cleaned_tags.append(tag)
+
+    # Extract priority and character tags
+    priority_tags_found, character_tag_names, remaining_tags = extract_priority_and_character_tags(cleaned_tags, character_tags)
+
+    # Classify remaining tags
+    categorized = defaultdict(list)
+    uncategorized = []
+
+    for tag in remaining_tags:
+        # Skip character tags as they're already in their own list
+        if tag in character_tag_names:
+            continue
+
+        category = classify_single_tag(tag)
+        if category == 'Uncategorized':
+            uncategorized.append(tag)
+        else:
+            # Store the original tag (with underscores) for JSON
+            categorized[category].append(tag)
+
+    # Build JSON result
+    json_result = {}
+
+    # Add special categories if they have content
+    if priority_tags_found:
+        # Process priority tags for display (replace underscores with spaces) # Replacement is not 100% necessary, but will do anyway
+        processed_priority = [tag.replace('_', ' ').replace('\\(', '(').replace('\\)', ')') for tag in priority_tags_found] 
+        json_result['Subject'] = processed_priority
+
+    if character_tag_names:
+        # Process character tags for display
+        processed_characters = [tag.replace('_', ' ').replace('\\(', '(').replace('\\)', ')') for tag in character_tag_names]
+        json_result['Characters'] = processed_characters
+
+    # Add categorized tags (process for display)
+    for category, tags in categorized.items():
+        if tags:
+            processed_tags = [tag.replace('_', ' ').replace('\\(', '(').replace('\\)', ')') for tag in tags]
+            json_result[category] = processed_tags
+
+    # Add uncategorized tags if any
+    if uncategorized:
+        processed_uncategorized = [tag.replace('_', ' ').replace('\\(', '(').replace('\\)', ')') for tag in uncategorized]
+        json_result['Uncategorized'] = processed_uncategorized
+
+    return json_result
+
+
+def categorize_tags_output(tag_string, character_tags=None):
+    """
+    Main function to categorize tags output for display
+
+    Args:
+        tag_string (str): Raw tags string from the model
+        character_tags (dict): Dictionary of character tags with confidence scores
+
+    Returns:
+        str: Organized, categorized tags string
+    """
+    return classify_tags_for_display(tag_string, character_tags)
+
+def generate_tags_json(tag_string, character_tags=None):
+    """
+    Main function to generate categorized JSON
+
+    Args:
+        tag_string (str): Raw tags string from the model
+        character_tags (dict): Dictionary of character tags with confidence scores
+
+    Returns:
+        dict: JSON object with categorized tags
+    """
+    return generate_categorized_json(tag_string, character_tags)

modules/pixai.py

@@ -0,0 +1,810 @@
+import os, json, zipfile, tempfile, time, traceback
+import gradio as gr
+import pandas as pd
+import numpy as np
+import onnxruntime as ort
+from collections import defaultdict
+from typing import Union, Dict, Any, Tuple, List
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from huggingface_hub.errors import EntryNotFoundError
+from datetime import datetime
+
+# Global variables for model components (for memory management)
+CURRENT_MODEL = None
+CURRENT_MODEL_NAME = None
+CURRENT_TAGS_DF = None
+CURRENT_D_IPS = None
+CURRENT_PREPROCESS_FUNC = None
+CURRENT_THRESHOLDS = None
+CURRENT_CATEGORY_NAMES = None
+
+css = """
+#custom-gallery {--row-height: 180px;display: grid;grid-auto-rows: min-content;gap: 10px;}
+#custom-gallery .thumbnail-item {height: var(--row-height);width: 100%;position: relative;overflow: hidden;border-radius: 8px;box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);transition: transform 0.2s ease,  box-shadow 0.2s ease;}
+#custom-gallery .thumbnail-item:hover {transform: translateY(-3px);box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);}
+#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: contain;margin: 0 auto;display: block;}
+#custom-gallery .thumbnail-item img.portrait {max-width: 100%;}
+#custom-gallery .thumbnail-item img.landscape {max-height: 100%;}
+.gallery-container {max-height: 500px;overflow-y: auto;padding-right: 0px;--size-80: 500px;}
+.thumbnails {display: flex;position: absolute;bottom: 0;width: 120px;overflow-x: scroll;padding-top: 320px;padding-bottom: 280px;padding-left: 4px;flex-wrap: wrap;}
+#custom-gallery .thumbnail-item img {width: auto;height: 100%;max-width: 100%;max-height: var(--row-height);object-fit: initial;width: fit-content;margin: 0px auto;display: block;}
+"""
+
+def preprocess_on_gpu(img, device='cuda'):
+    """Preprocess image on GPU using PyTorch"""
+    import torch
+    import torchvision.transforms as transforms
+    # Convert PIL to tensor and move to GPU
+    transform = transforms.Compose([transforms.Resize((448, 448)), transforms.ToTensor(), transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711])])
+    # Move to GPU if available
+    tensor_img = transform(img).unsqueeze(0)
+    if torch.cuda.is_available():
+        tensor_img = tensor_img.to(device)
+    return tensor_img.cpu().numpy()
+
+class Timer: # Report the execution time & process
+    def __init__(self):
+        self.start_time = time.perf_counter()
+        self.checkpoints = [('Start', self.start_time)]
+
+    def checkpoint(self, label='Checkpoint'):
+        now = time.perf_counter()
+        self.checkpoints.append((label, now))
+
+    def report(self, is_clear_checkpoints=True):
+        max_label_length = max(len(label) for (label, _) in self.checkpoints) if self.checkpoints else 0
+        prev_time = self.checkpoints[0][1] if self.checkpoints else self.start_time
+
+        for (label, curr_time) in self.checkpoints[1:]:
+            elapsed = curr_time - prev_time
+            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
+            prev_time = curr_time
+
+        if is_clear_checkpoints:
+            self.checkpoints.clear()
+            self.checkpoint()
+
+    def report_all(self):
+        print('\n> Execution Time Report:')
+        max_label_length = max(len(label) for (label, _) in self.checkpoints) if len(self.checkpoints) > 0 else 0
+        prev_time = self.start_time
+
+        for (label, curr_time) in self.checkpoints[1:]:
+            elapsed = curr_time - prev_time
+            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
+            prev_time = curr_time
+
+        total_time = self.checkpoints[-1][1] - self.start_time if self.checkpoints else 0
+        print(f"{'Total Execution Time'.ljust(max_label_length)}: {total_time:.3f} seconds\n") # Performance tests
+        self.checkpoints.clear()
+
+    def restart(self):
+        self.start_time = time.perf_counter()
+        self.checkpoints = [('Start', self.start_time)]
+
+def _get_repo_id(model_name: str) -> str:
+    """Get the repository ID for the specified model name."""
+    if '/' in model_name:
+        return model_name
+    else:
+        return f'deepghs/pixai-tagger-{model_name}-onnx'
+
+def _download_model_files(model_name: str):
+    """Download all required model files."""
+    repo_id = _get_repo_id(model_name)
+
+    # Download the necessary files using hf_hub_download instead of local cache...
+    model_path = hf_hub_download(
+        repo_id=repo_id,
+        filename='model.onnx',
+        library_name="pixai-tagger"
+    )
+    tags_path = hf_hub_download(
+        repo_id=repo_id,
+        filename='selected_tags.csv',
+        library_name="pixai-tagger"
+    )
+    preprocess_path = hf_hub_download(
+        repo_id=repo_id,
+        filename='preprocess.json',
+        library_name="pixai-tagger"
+    )
+    try:
+        thresholds_path = hf_hub_download(
+            repo_id=repo_id,
+            filename='thresholds.csv',
+            library_name="pixai-tagger"
+        )
+    except EntryNotFoundError:
+        thresholds_path = None
+
+    return model_path, tags_path, preprocess_path, thresholds_path
+
+def create_optimized_ort_session(model_path):
+    """Create an optimized ONNX Runtime session with GPU support"""
+    # Test: Session options for better performance
+    sess_options = ort.SessionOptions()
+    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+    sess_options.intra_op_num_threads = 0  # Use all available cores
+    sess_options.execution_mode = ort.ExecutionMode.ORT_PARALLEL
+    sess_options.enable_mem_pattern = True
+    sess_options.enable_cpu_mem_arena = True
+
+    # Check available providers
+    available_providers = ort.get_available_providers()
+    print(f"Available ONNX Runtime providers: {available_providers}")
+
+    # Use appropriate execution providers (in order of preference)
+    providers = []
+
+    # Use CUDA if available
+    if 'CUDAExecutionProvider' in available_providers:
+        cuda_provider = ('CUDAExecutionProvider', {
+            'device_id': 0,
+            'arena_extend_strategy': 'kNextPowerOfTwo',
+            'gpu_mem_limit': 4 * 1024 * 1024 * 1024,  # 4GB VRAM
+            'cudnn_conv_algo_search': 'EXHAUSTIVE',
+            'do_copy_in_default_stream': True,
+        })
+        providers.append(cuda_provider)
+        print("Using CUDA provider for ONNX inference")
+    else:
+        print("CUDA provider not available, falling back to CPU")
+
+    # Always include CPU as fallback (FOR HF)
+    providers.append('CPUExecutionProvider')
+
+    try:
+        session = ort.InferenceSession(model_path, sess_options, providers=providers)
+        print(f"Model loaded with providers: {session.get_providers()}")
+        return session
+    except Exception as e:
+        print(f"Failed to create ONNX session: {e}")
+        raise
+
+def _load_model_components_optimized(model_name: str):
+    global CURRENT_MODEL, CURRENT_MODEL_NAME, CURRENT_TAGS_DF, CURRENT_D_IPS
+    global CURRENT_PREPROCESS_FUNC, CURRENT_THRESHOLDS, CURRENT_CATEGORY_NAMES
+
+    # Only reload if model changed
+    if CURRENT_MODEL_NAME != model_name:
+        # Download files
+        model_path, tags_path, preprocess_path, thresholds_path = _download_model_files(model_name)
+
+        # Load optimized ONNX model
+        CURRENT_MODEL = create_optimized_ort_session(model_path)
+
+        # Load tags
+        CURRENT_TAGS_DF = pd.read_csv(tags_path)
+        CURRENT_D_IPS = {}
+
+        if 'ips' in CURRENT_TAGS_DF.columns:
+            CURRENT_TAGS_DF['ips'] = CURRENT_TAGS_DF['ips'].fillna('{}').map(json.loads)
+            for name, ips in zip(CURRENT_TAGS_DF['name'], CURRENT_TAGS_DF['ips']):
+                if ips:
+                    CURRENT_D_IPS[name] = ips
+
+        # Load preprocessing
+        with open(preprocess_path, 'r') as f:
+            data_ = json.load(f)
+            # Simple preprocessing function
+            def transform(img):
+                # Ensure image is in RGB mode
+                if img.mode != 'RGB':
+                    img = img.convert('RGB')
+
+                # Resize to 448x448 <- Very important.
+                img = img.resize((448, 448), Image.Resampling.LANCZOS)
+
+                # Convert to numpy array and normalize
+                img_array = np.array(img).astype(np.float32)
+
+                # Normalize pixel values to [0, 1]
+                img_array = img_array / 255.0
+
+                # Normalize with ImageNet mean and std
+                mean = np.array([0.48145466, 0.4578275, 0.40821073]).astype(np.float32)
+                std = np.array([0.26862954, 0.26130258, 0.27577711]).astype(np.float32)
+                img_array = (img_array - mean) / std
+
+                # Transpose to (C, H, W)
+                img_array = np.transpose(img_array, (2, 0, 1))
+                return img_array
+
+            CURRENT_PREPROCESS_FUNC = transform
+
+        # Load thresholds
+        CURRENT_THRESHOLDS = {}
+        CURRENT_CATEGORY_NAMES = {}
+
+        if thresholds_path and os.path.exists(thresholds_path):
+            df_category_thresholds = pd.read_csv(thresholds_path, keep_default_na=False)
+            for item in df_category_thresholds.to_dict('records'):
+                if item['category'] not in CURRENT_THRESHOLDS:
+                    CURRENT_THRESHOLDS[item['category']] = item['threshold']
+                CURRENT_CATEGORY_NAMES[item['category']] = item['name']
+        else:
+            # Default thresholds if file doesn't exist
+            CURRENT_THRESHOLDS = {0: 0.3, 4: 0.85, 9: 0.85}
+            CURRENT_CATEGORY_NAMES = {0: 'general', 4: 'character', 9: 'rating'}
+
+        CURRENT_MODEL_NAME = model_name
+
+    return (CURRENT_MODEL, CURRENT_TAGS_DF, CURRENT_D_IPS, CURRENT_PREPROCESS_FUNC,
+            CURRENT_THRESHOLDS, CURRENT_CATEGORY_NAMES)
+
+def _raw_predict(image: Image.Image, model_name: str):
+    """Make a raw prediction with the PixAI tagger model."""
+    try:
+        # Ensure we have a PIL Image
+        if not isinstance(image, Image.Image):
+            raise ValueError("Input must be a PIL Image") # <-
+
+        # Load model components
+        model, _, _, preprocess_func, _, _ = _load_model_components_optimized(model_name)
+
+        # Preprocess image
+        input_tensor = preprocess_func(image)
+
+        # Add batch dimension
+        if len(input_tensor.shape) == 3:
+            input_tensor = np.expand_dims(input_tensor, axis=0)
+
+        # Run inference
+        output_names = [output.name for output in model.get_outputs()]
+        output_values = model.run(output_names, {'input': input_tensor.astype(np.float32)})
+
+        return {name: value[0] for name, value in zip(output_names, output_values)}
+
+    except Exception as e:
+        raise RuntimeError(f"Error processing image: {str(e)}")
+
+def get_pixai_tags(
+    image: Union[str, Image.Image],
+    model_name: str = 'deepghs/pixai-tagger-v0.9-onnx',
+    thresholds: Union[float, Dict[Any, float]] = None,
+    fmt='all'
+):
+    try:
+        # Load image if it's a path
+        if isinstance(image, str):
+            pil_image = Image.open(image)
+        elif isinstance(image, Image.Image):
+            pil_image = image
+        else:
+            raise ValueError("Image must be a file path or PIL Image")
+
+        # Load model components
+        _, df_tags, d_ips, _, default_thresholds, category_names = _load_model_components_optimized(model_name)
+
+        values = _raw_predict(pil_image, model_name)
+        prediction = values.get('prediction', np.array([]))
+
+        if prediction.size == 0:
+            raise RuntimeError("Model did not return valid predictions")
+
+        tags = {}
+
+        # Process tags by category
+        for category in sorted(set(df_tags['category'].tolist())):
+            mask = df_tags['category'] == category
+            tag_names = df_tags.loc[mask, 'name']
+            category_pred = prediction[mask]
+
+            # Determine threshold for this category
+            if isinstance(thresholds, float):
+                category_threshold = thresholds
+            elif isinstance(thresholds, dict) and \
+                    (category in thresholds or category_names.get(category, '') in thresholds):
+                if category in thresholds:
+                    category_threshold = thresholds[category]
+                elif category_names.get(category, '') in thresholds:
+                    category_threshold = thresholds[category_names[category]]
+                else:
+                    category_threshold = 0.85
+            else:
+                category_threshold = default_thresholds.get(category, 0.85)
+
+            # Apply threshold
+            pred_mask = category_pred >= category_threshold
+            filtered_tag_names = tag_names[pred_mask].tolist()
+            filtered_predictions = category_pred[pred_mask].tolist()
+
+            # Sort by confidence
+            cate_tags = dict(sorted(
+                zip(filtered_tag_names, filtered_predictions),
+                key=lambda x: (-x[1], x[0])
+            ))
+
+            category_name = category_names.get(category, f"category_{category}")
+            values[category_name] = cate_tags
+            tags.update(cate_tags)
+
+        values['tag'] = tags
+
+        # Handle IPs if available
+        if 'ips' in df_tags.columns:
+            ips_mapping, ips_counts = {}, defaultdict(int)
+            for tag, _ in tags.items():
+                if tag in d_ips:
+                    ips_mapping[tag] = d_ips[tag]
+                    for ip_name in d_ips[tag]:
+                        ips_counts[ip_name] += 1
+            values['ips_mapping'] = ips_mapping
+            values['ips_count'] = dict(ips_counts)
+            values['ips'] = [x for x, _ in sorted(ips_counts.items(), key=lambda x: (-x[1], x[0]))]
+
+        # Return based on format
+        if fmt == 'all':
+            # Return all available categories
+            available_categories = [category_names.get(cat, f"category_{cat}")
+                                  for cat in sorted(set(df_tags['category'].tolist()))]
+            return tuple(values.get(cat, {}) for cat in available_categories)
+        elif fmt in values:
+            return values[fmt]
+        else:
+            return values
+
+    except Exception as e:
+        raise RuntimeError(f"Error processing image: {str(e)}")
+
+def format_ips_output(ips_result, ips_mapping):
+    """Format IP detection output as a single string with proper escaping."""
+    if not ips_result and not ips_mapping:
+        return ""
+
+    # Format detected IPs
+    ips_list = []
+    if ips_result:
+        ips_list = [ip.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+                   for ip in ips_result]
+
+    # Format character-to-IP mapping
+    mapping_list = []
+    if ips_mapping:
+        for char, ips in ips_mapping.items():
+            formatted_char = char.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+            formatted_ips = [ip.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+                            for ip in ips]
+            mapping_list.append(f"{formatted_char}: {', '.join(formatted_ips)}")
+
+    # Combine all into a single string
+    result_parts = []
+    if ips_list:
+        result_parts.append(", ".join(ips_list))
+    if mapping_list:
+        result_parts.extend(mapping_list)
+
+    return ", ".join(result_parts)
+
+def process_single_image(
+    image_path,
+    model_name="deepghs/pixai-tagger-v0.9-onnx", ###
+    general_threshold=0.3,
+    character_threshold=0.85,
+    progress=None,
+    idx=0,
+    total_images=1
+):
+    """Process a single image and return all formatted outputs."""
+    try:
+        if image_path is None:
+            return "", "", "", "", {}, {}
+
+        if progress:
+            progress((idx)/total_images, desc=f"Processing image {idx+1}/{total_images}")
+
+        # Load image from path
+        pil_image = Image.open(image_path)
+
+        # Set thresholds
+        thresholds = {
+            'general': general_threshold,
+            'character': character_threshold
+        }
+
+        # Get all tag categories
+        all_categories = get_pixai_tags(
+            pil_image, model_name, thresholds, fmt='all'
+        )
+
+        # Ensure we have at least 3 categories (general, character, rating)
+        while len(all_categories) < 3:
+            all_categories += ({},)
+
+        general_tags = all_categories[0] if len(all_categories) > 0 else {}
+        character_tags = all_categories[1] if len(all_categories) > 1 else {}
+        rating_tags = all_categories[2] if len(all_categories) > 2 else {}
+
+        # Get IP detection data
+        ips_result = get_pixai_tags(pil_image, model_name, thresholds, fmt='ips') or []
+        ips_mapping = get_pixai_tags(pil_image, model_name, thresholds, fmt='ips_mapping') or {}
+
+        # Format character tags (names only)
+        character_names = [name.replace("(", "\\(").replace(")", "\\)").replace("_", " ") # Replacement shouldn't be necessary here, but I'll do anyway
+                          for name in character_tags.keys()]
+        character_output = ", ".join(character_names)
+
+        # Format general tags (names only)
+        general_names = [name.replace("(", "\\(").replace(")", "\\)").replace("_", " ")
+                        for name in general_tags.keys()]
+        general_output = ", ".join(general_names)
+
+        # Format IP detection output
+        ips_output = format_ips_output(ips_result, ips_mapping)
+
+        # Format combined tags (Character tags first, then General tags, then IP tags)
+        combined_parts = []
+        if character_names:
+            combined_parts.append(", ".join(character_names))
+        if general_names:
+            combined_parts.append(", ".join(general_names))
+        if ips_output:
+            combined_parts.append(ips_output)
+
+        combined_output = ", ".join(combined_parts)
+
+        # Get detailed JSON data
+        json_data = {
+            "character_tags": character_tags,
+            "general_tags": general_tags,
+            "rating_tags": rating_tags,
+            "ips_result": ips_result,
+            "ips_mapping": ips_mapping
+        }
+
+        # Format rating as label-compatible dict
+        rating_output = {k.replace("(", "\\(").replace(")", "\\)").replace("_", " "): v
+                        for k, v in rating_tags.items()}
+
+        return (
+            character_output,      # Character tags
+            general_output,        # General tags
+            ips_output,            # IP Detection
+            combined_output,       # Combined tags
+            json_data,             # Detailed JSON
+            rating_output          # Rating <- Not working atm
+        )
+    except Exception as e:
+        error_msg = f"Error: {str(e)}"
+        # Return error message for all 6 outputs
+        return error_msg, error_msg, error_msg, error_msg, {}, {} # 6
+
+    """GPU"""
+def unload_model():
+    """Explicitly unload the current model from memory"""
+    global CURRENT_MODEL, CURRENT_MODEL_NAME, CURRENT_TAGS_DF, CURRENT_D_IPS
+    global CURRENT_PREPROCESS_FUNC, CURRENT_THRESHOLDS, CURRENT_CATEGORY_NAMES
+    # Delete the model session
+    if CURRENT_MODEL is not None:
+        del CURRENT_MODEL
+        CURRENT_MODEL = None
+    # Clear other large objects
+    CURRENT_TAGS_DF = None
+    CURRENT_D_IPS = None
+    CURRENT_PREPROCESS_FUNC = None
+    CURRENT_THRESHOLDS = None
+    CURRENT_CATEGORY_NAMES = None
+    CURRENT_MODEL_NAME = None
+    # Force garbage collection
+    import gc
+    gc.collect()
+    # Clear CUDA cache if using GPU
+    try:
+        import torch
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except ImportError:
+        pass
+    # print("Model unloaded and memory cleared")
+def cleanup_after_processing():
+    unload_model()
+
+def process_gallery_images(
+    gallery,
+    model_name,
+    general_threshold,
+    character_threshold,
+    progress=gr.Progress()
+):
+    """Process all images in the gallery and return results with download file."""
+    if not gallery:
+        return [], "", "", "", {}, {}, {}, None
+
+    tag_results = {}
+    txt_infos = []
+    output_dir = tempfile.mkdtemp()
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    total_images = len(gallery)
+    timer = Timer()
+
+    try:
+        for idx, image_data in enumerate(gallery):
+            try:
+                image_path = image_data[0] if isinstance(image_data, (list, tuple)) else image_data
+
+                # Process image
+                results = process_single_image(
+                    image_path, model_name, general_threshold, character_threshold,
+                    progress, idx, total_images
+                )
+
+                # Store results
+                tag_results[image_path] = {
+                    'character_tags': results[0],
+                    'general_tags': results[1],
+                    'ips_detection': results[2],
+                    'combined_tags': results[3],
+                    'json_data': results[4],
+                    'rating': results[5]
+                }
+
+                # Create output files with descriptive names
+                image_name = os.path.splitext(os.path.basename(image_path))[0]
+
+                # Save all output files with descriptive prefixes
+                files_to_create = [
+                    (f"character_tags-{image_name}.txt", results[0]),
+                    (f"general_tags-{image_name}.txt", results[1]),
+                    (f"ips_detection-{image_name}.txt", results[2]),
+                    (f"combined_tags-{image_name}.txt", results[3]),
+                    (f"detailed_json-{image_name}.json", json.dumps(results[4], indent=4, ensure_ascii=False))
+                ]
+
+                for file_name, content in files_to_create:
+                    file_path = os.path.join(output_dir, file_name)
+                    with open(file_path, 'w', encoding='utf-8') as f:
+                        f.write(content if isinstance(content, str) else content)
+                    txt_infos.append({'path': file_path, 'name': file_name})
+
+                # Copy original image
+                original_image = Image.open(image_path)
+                image_copy_path = os.path.join(output_dir, f"{image_name}{os.path.splitext(image_path)[1]}")
+                original_image.save(image_copy_path)
+                txt_infos.append({'path': image_copy_path, 'name': f"{image_name}{os.path.splitext(image_path)[1]}"})
+
+                timer.checkpoint(f"image{idx:02d}, processed")
+
+            except Exception as e:
+                print(f"Error processing image {image_path}: {str(e)}")
+                print(traceback.format_exc())
+                continue
+
+        # Create zip file
+        download_zip_path = os.path.join(output_dir, f"Multi-Tagger-{datetime.now().strftime('%Y%m%d-%H%M%S')}.zip")
+        with zipfile.ZipFile(download_zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for info in txt_infos:
+                zipf.write(info['path'], arcname=info['name'])
+                # If using GPU, model will auto unload after zip file creation
+                cleanup_after_processing() # Comment here to turn off this behavior
+
+        progress(1.0, desc="Processing complete")
+        timer.report_all()
+        print('Processing is complete.')
+
+        # Return first image results as default if available even if we are tagging 1000+ images.
+        first_image_results = ("", "", "", {}, {}, "") # 6
+        if gallery and len(gallery) > 0:
+            first_image_path = gallery[0][0] if isinstance(gallery[0], (list, tuple)) else gallery[0]
+            if first_image_path in tag_results:
+                result = tag_results[first_image_path]
+                first_image_results = (
+                    result['character_tags'],
+                    result['general_tags'],
+                    result['combined_tags'],
+                    result['json_data'],
+                    result['rating'],
+                    result['ips_detection']
+                )
+
+        return tag_results, first_image_results[0], first_image_results[1], first_image_results[2], first_image_results[3], first_image_results[4], first_image_results[5], download_zip_path
+
+    except Exception as e:
+        print(f"Error in process_gallery_images: {str(e)}")
+        print(traceback.format_exc())
+        progress(1.0, desc="Processing failed")
+        return {}, "", "", "", {}, {}, "", None
+
+def get_selection_from_gallery(gallery, tag_results, selected_state: gr.SelectData):
+    """Handle gallery image selection and update UI with stored results."""
+    if not selected_state or not tag_results:
+        return "", "", "", {}, {}, ""
+
+    # Get selected image path
+    selected_value = selected_state.value
+    if isinstance(selected_value, dict) and 'image' in selected_value:
+        image_path = selected_value['image']['path']
+    elif isinstance(selected_value, (list, tuple)) and len(selected_value) > 0:
+        image_path = selected_value[0]
+    else:
+        image_path = str(selected_value)
+
+    # Retrieve stored results
+    if image_path in tag_results:
+        result = tag_results[image_path]
+        return (
+            result['character_tags'],
+            result['general_tags'],
+            result['combined_tags'],
+            result['json_data'],
+            result['rating'],
+            result['ips_detection']
+        )
+
+    # Return empty if not found
+    return "", "", "", {}, {}, ""
+
+def append_gallery(gallery, image):
+    """Add a single image to the gallery."""
+    if gallery is None:
+        gallery = []
+    if not image:
+        return gallery, None
+    gallery.append(image)
+    return gallery, None
+
+def extend_gallery(gallery, images):
+    """Add multiple images to the gallery."""
+    if gallery is None:
+        gallery = []
+    if not images:
+        return gallery
+    gallery.extend(images)
+    return gallery
+
+def create_pixai_interface():
+    """Create the PixAI Gradio interface"""
+    with gr.Blocks(css=css, fill_width=True) as demo:
+        # gr.Markdown("Upload anime-style images to extract tags using PixAI")
+        # State to store results
+        tag_results = gr.State({})
+        selected_image = gr.Textbox(label='Selected Image', visible=False)
+
+        with gr.Row():
+            with gr.Column():
+                # Image upload section
+                with gr.Column(variant='panel'):
+                    image_input = gr.Image(
+                        label='Upload an Image or clicking paste from clipboard button',
+                        type='filepath',
+                        sources=['upload', 'clipboard'],
+                        height=150
+                    )
+                    with gr.Row():
+                        upload_button = gr.UploadButton(
+                            'Upload multiple images',
+                            file_types=['image'],
+                            file_count='multiple',
+                            size='sm'
+                        )
+                    gallery = gr.Gallery(
+                        columns=2,
+                        show_share_button=False,
+                        interactive=True,
+                        height='auto',
+                        label='Grid of images',
+                        preview=False,
+                        elem_id='custom-gallery'
+                    )
+                run_button = gr.Button("Analyze Images", variant="primary", size='lg')
+                model_dropdown = gr.Dropdown(
+                    choices=["deepghs/pixai-tagger-v0.9-onnx"],
+                    value="deepghs/pixai-tagger-v0.9-onnx",
+                    label="Model"
+                )
+                # Threshold controls
+                with gr.Row():
+                    general_threshold = gr.Slider(
+                        minimum=0.0, maximum=1.0, value=0.30, step=0.05,
+                        label="General Tags Threshold", scale=3
+                    )
+                    character_threshold = gr.Slider(
+                        minimum=0.0, maximum=1.0, value=0.85, step=0.05,
+                        label="Character Tags Threshold", scale=3
+                    )
+
+                with gr.Row():
+                    clear = gr.ClearButton(
+                        components=[gallery, model_dropdown, general_threshold, character_threshold],
+                        variant='secondary',
+                        size='lg'
+                    )
+                clear.add([tag_results])
+                detailed_json_output = gr.JSON(label="Detailed JSON")
+
+            with gr.Column(variant='panel'):
+
+                download_file = gr.File(label="Download")
+
+                # Output blocks
+                character_tags_output = gr.Textbox(
+                    label="Character tags",
+                    show_copy_button=True,
+                    lines=3
+                )
+                general_tags_output = gr.Textbox(
+                    label="General tags",
+                    show_copy_button=True,
+                    lines=3
+                )
+                ips_detection_output = gr.Textbox(
+                    label="IPs Detection",
+                    show_copy_button=True,
+                    lines=5
+                )
+                combined_tags_output = gr.Textbox(
+                    label="Combined tags",
+                    show_copy_button=True,
+                    lines=6
+                )
+                rating_output = gr.Label(label="Rating")
+
+                # Clear button targets
+                clear.add([
+                    download_file,
+                    character_tags_output,
+                    general_tags_output,
+                    ips_detection_output,
+                    combined_tags_output,
+                    rating_output,
+                    detailed_json_output
+                ])
+
+        # Event handlers
+        image_input.change(
+            append_gallery,
+            inputs=[gallery, image_input],
+            outputs=[gallery, image_input]
+        )
+
+        upload_button.upload(
+            extend_gallery,
+            inputs=[gallery, upload_button],
+            outputs=gallery
+        )
+
+        gallery.select(
+            get_selection_from_gallery,
+            inputs=[gallery, tag_results],
+            outputs=[
+                character_tags_output,
+                general_tags_output,
+                combined_tags_output,
+                detailed_json_output,
+                rating_output,
+                ips_detection_output
+            ]
+        )
+
+        run_button.click(
+            process_gallery_images,
+            inputs=[gallery, model_dropdown, general_threshold, character_threshold],
+            outputs=[
+                tag_results,
+                character_tags_output,
+                general_tags_output,
+                combined_tags_output,
+                detailed_json_output,
+                rating_output,
+                ips_detection_output,
+                download_file
+            ]
+        )
+
+        gr.Markdown('[Based on Source code for imgutils.tagging.pixai](https://dghs-imgutils.deepghs.org/main/_modules/imgutils/tagging/pixai.html) & [pixai-labs/pixai-tagger-demo](https://huggingface.co/spaces/pixai-labs/pixai-tagger-demo)')
+
+    return demo
+
+# Export public API
+__all__ = [
+    'get_pixai_tags',
+    'process_single_image',
+    'process_gallery_images',
+    'create_pixai_interface',
+    'unload_model',
+    'cleanup_after_processing'
+]

requirements.txt

@@ -1,20 +1,19 @@
---extra-index-url https://download.pytorch.org/whl/cu124
-torch==2.5.0+cu124; sys_platform != 'darwin'
-torchvision==0.20.0+cu124; sys_platform != 'darwin'
-torch==2.5.0; sys_platform == 'darwin'
-torchvision==0.20.0; sys_platform == 'darwin'
-
-gradio
-safetensors
-sentencepiece
-pillow
-requests
-numpy
-timm 
-einops 
-optimum
-accelerate
-opencv-python
-onnxruntime>=1.12.0
-matplotlib
-https://github.com/kingbri1/flash-attention/releases/download/v2.7.4.post1/flash_attn-2.7.4.post1+cu128torch2.7.0cxx11abiFALSE-cp310-cp310-linux_x86_64.whl
+torch
+gradio
+safetensors
+sentencepiece
+pillow
+requests
+numpy
+timm 
+einops 
+optimum
+accelerate
+opencv-python
+onnxruntime>=1.12.0
+matplotlib
+apscheduler
+spaces
+pandas==2.1.2
+huggingface-hub
+transformers