Update app.py

app.py

@@ -1,15 +1,17 @@
 import os
 import json
+import time
+import shutil
 import warnings
+from html import escape
+from pathlib import Path
+from typing import Optional
 
 import gradio as gr
-import huggingface_hub
-import numpy as np
-import onnxruntime as rt
-import pandas as pd
+from huggingface_hub import snapshot_download
 from PIL import Image, ImageFile
-from huggingface_hub import login
 
+from handler import EndpointHandler
 from translator import translate_texts
 
 # ------------------------------------------------------------------
@@ -97,7 +99,6 @@ def validate_and_open_image(image_path: str) -> Image.Image:
             f"图片总像素过大：{total_pixels:,}，超过限制 {MAX_IMAGE_PIXELS:,}。"
         )
 
-    # 估算解码为 RGB 后的内存占用
     estimated_decompressed_bytes = total_pixels * 3
     if estimated_decompressed_bytes > MAX_DECOMPRESSED_BYTES:
         raise ImageValidationError(
@@ -106,7 +107,6 @@ def validate_and_open_image(image_path: str) -> Image.Image:
             f"超过限制 {_format_size(MAX_DECOMPRESSED_BYTES)}。"
         )
 
-    # 第二次打开，真正加载像素数据
     try:
         with Image.open(image_path) as img:
             img.load()
@@ -123,108 +123,195 @@ def validate_and_open_image(image_path: str) -> Image.Image:
 
 
 # ------------------------------------------------------------------
-# 模型配置
+# 新版 PixAI Tagger v0.9 模型配置
 # ------------------------------------------------------------------
-MODEL_REPO = "SmilingWolf/wd-eva02-large-tagger-v3"
-MODEL_FILENAME = "model.onnx"
-LABEL_FILENAME = "selected_tags.csv"
+ASSETS_REPO_ID = os.environ.get("ASSETS_REPO_ID", "pixai-labs/pixai-tagger-v0.9")
+ASSETS_REVISION = os.environ.get("ASSETS_REVISION")
+MODEL_DIR = os.environ.get("MODEL_DIR", "./assets")
+
+HF_TOKEN = (
+    os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    or os.environ.get("HF_TOKEN")
+    or os.environ.get("HUGGINGFACE_TOKEN")
+    or os.environ.get("HUGGINGFACEHUB_API_TOKEN")
+)
+
+REQUIRED_FILES = [
+    "model_v0.9.pth",
+    "tags_v0.9_13k.json",
+    "char_ip_map.json",
+]
+
+
+def ensure_assets(repo_id: str, revision: Optional[str], target_dir: str) -> None:
+    """
+    下载 pixai-labs/pixai-tagger-v0.9 所需资源，并复制到 handler 期望的本地目录。
+    如果文件已经存在，则不会重复下载。
+    """
+    target = Path(target_dir)
+    target.mkdir(parents=True, exist_ok=True)
+
+    missing = [fname for fname in REQUIRED_FILES if not (target / fname).exists()]
+    if not missing:
+        return
+
+    snapshot_path = snapshot_download(
+        repo_id=repo_id,
+        revision=revision,
+        allow_patterns=REQUIRED_FILES,
+        token=HF_TOKEN,
+    )
+
+    for fname in REQUIRED_FILES:
+        src = Path(snapshot_path) / fname
+        dst = target / fname
+
+        if not src.exists():
+            raise FileNotFoundError(
+                f"模型资源缺失：'{fname}' 未在 {repo_id} @ {revision or 'default'} 中找到。"
+            )
+
+        if src.resolve() != dst.resolve():
+            shutil.copyfile(src, dst)
 
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-if HF_TOKEN:
-    login(token=HF_TOKEN)
-else:
-    print("⚠️ 未检测到 HF_TOKEN，私有模型可能下载失败")
 
 # ------------------------------------------------------------------
-# Tagger 类 (全局实例化)
+# Tagger 类：使用新版 EndpointHandler
 # ------------------------------------------------------------------
 class Tagger:
     def __init__(self):
-        self.hf_token = HF_TOKEN
-        self.tag_names = []
-        self.categories = {}
-        self.model = None
-        self.input_size = 0
+        self.handler = None
+        self.device = "unknown"
         self._load_model_and_labels()
 
-    def _load_model_and_labels(self):
+    def _load_model_and_labels(self) -> None:
         try:
-            label_path = huggingface_hub.hf_hub_download(
-                MODEL_REPO, LABEL_FILENAME, token=self.hf_token, resume_download=True
-            )
-            model_path = huggingface_hub.hf_hub_download(
-                MODEL_REPO, MODEL_FILENAME, token=self.hf_token, resume_download=True
-            )
-
-            tags_df = pd.read_csv(label_path)
-            self.tag_names = tags_df["name"].tolist()
-            self.categories = {
-                "rating": np.where(tags_df["category"] == 9)[0],
-                "general": np.where(tags_df["category"] == 0)[0],
-                "character": np.where(tags_df["category"] == 4)[0],
-            }
-            self.model = rt.InferenceSession(model_path)
-            self.input_size = self.model.get_inputs()[0].shape[1]
-            print("✅ 模型和标签加载成功")
+            ensure_assets(ASSETS_REPO_ID, ASSETS_REVISION, MODEL_DIR)
+            self.handler = EndpointHandler(MODEL_DIR)
+            self.device = getattr(self.handler, "device", "unknown")
+            print(f"✅ PixAI Tagger v0.9 加载成功，设备：{str(self.device).upper()}")
         except Exception as e:
-            print(f"❌ 模型或标签加载失败: {e}")
-            raise RuntimeError(f"模型初始化失败: {e}")
-
-    def _preprocess(self, img: Image.Image) -> np.ndarray:
-        if img is None:
-            raise ValueError("输入图像不能为空")
-        if img.mode != "RGB":
-            img = img.convert("RGB")
-        size = max(img.size)
-        canvas = Image.new("RGB", (size, size), (255, 255, 255))
-        canvas.paste(img, ((size - img.width) // 2, (size - img.height) // 2))
-        if size != self.input_size:
-            canvas = canvas.resize((self.input_size, self.input_size), Image.BICUBIC)
-        return np.array(canvas)[:, :, ::-1].astype(np.float32)  # to BGR
-
-    def predict(self, img: Image.Image, gen_th: float = 0.35, char_th: float = 0.85):
-        if self.model is None:
+            print(f"❌ PixAI Tagger v0.9 加载失败: {e}")
+            raise RuntimeError(f"模型初始化失败: {e}") from e
+
+    @staticmethod
+    def _display_tag(tag: str) -> str:
+        return str(tag).replace("_", " ")
+
+    @staticmethod
+    def _get_score(scores: dict, tag: str) -> float:
+        """
+        handler 通常以原始 tag 作为分数字典 key。
+        这里额外兼容空格/下划线两种写法，避免 key 不一致时取不到分数。
+        """
+        if not isinstance(scores, dict):
+            return 0.0
+
+        candidates = [
+            tag,
+            str(tag).replace("_", " "),
+            str(tag).replace(" ", "_"),
+        ]
+
+        for key in candidates:
+            if key in scores:
+                try:
+                    return float(scores[key])
+                except Exception:
+                    return 0.0
+
+        return 0.0
+
+    def predict(self, img: Image.Image, gen_th: float = 0.30, char_th: float = 0.85):
+        """
+        返回结构保持原 app.py 的 UI 处理习惯：
+        - general：通用/特征标签，带置信度
+        - characters：角色标签，带置信度
+        - ips：IP 标签，新模型不返回评分标签，因此原 ratings 改为 ips，且 IP 不展示伪造置信度
+        """
+        if self.handler is None:
             raise RuntimeError("模型未成功加载，无法进行预测。")
-        inp_name = self.model.get_inputs()[0].name
-        outputs = self.model.run(None, {inp_name: self._preprocess(img)[None, ...]})[0][0]
-
-        res = {"ratings": {}, "general": {}, "characters": {}}
-        tag_categories_for_translation = {"ratings": [], "general": [], "characters": []}
-
-        for idx in self.categories["rating"]:
-            tag_name = self.tag_names[idx].replace("_", " ")
-            res["ratings"][tag_name] = float(outputs[idx])
-            tag_categories_for_translation["ratings"].append(tag_name)
-
-        for idx in self.categories["general"]:
-            if outputs[idx] > gen_th:
-                tag_name = self.tag_names[idx].replace("_", " ")
-                res["general"][tag_name] = float(outputs[idx])
-                tag_categories_for_translation["general"].append(tag_name)
-
-        for idx in self.categories["character"]:
-            if outputs[idx] > char_th:
-                tag_name = self.tag_names[idx].replace("_", " ")
-                res["characters"][tag_name] = float(outputs[idx])
-                tag_categories_for_translation["characters"].append(tag_name)
-
-        res["general"] = dict(sorted(res["general"].items(), key=lambda kv: kv[1], reverse=True))
-        res["characters"] = dict(sorted(res["characters"].items(), key=lambda kv: kv[1], reverse=True))
-        res["ratings"] = dict(sorted(res["ratings"].items(), key=lambda kv: kv[1], reverse=True))
 
-        tag_categories_for_translation["general"] = list(res["general"].keys())
-        tag_categories_for_translation["characters"] = list(res["characters"].keys())
-        tag_categories_for_translation["ratings"] = list(res["ratings"].keys())
-
-        return res, tag_categories_for_translation
+        if img is None:
+            raise ValueError("输入图像不能为空。")
+
+        params = {
+            "general_threshold": float(gen_th),
+            "character_threshold": float(char_th),
+            "mode": "threshold",
+            "topk_general": 25,
+            "topk_character": 10,
+            "include_scores": True,
+        }
+
+        data = {
+            "inputs": img,
+            "parameters": params,
+        }
+
+        started = time.time()
+        out = self.handler(data)
+        latency = round(time.time() - started, 4)
+
+        feature_tags = out.get("feature", []) or []
+        character_tags = out.get("character", []) or []
+        ip_tags = out.get("ip", []) or []
+
+        feature_scores = out.get("feature_scores", {}) or {}
+        character_scores = out.get("character_scores", {}) or {}
+
+        general = {
+            self._display_tag(tag): self._get_score(feature_scores, tag)
+            for tag in feature_tags
+        }
+        characters = {
+            self._display_tag(tag): self._get_score(character_scores, tag)
+            for tag in character_tags
+        }
+
+        # IP 标签没有评分，使用 None 表示“不显示置信度”
+        ips = {
+            self._display_tag(tag): None
+            for tag in ip_tags
+        }
+
+        general = dict(sorted(general.items(), key=lambda kv: kv[1], reverse=True))
+        characters = dict(sorted(characters.items(), key=lambda kv: kv[1], reverse=True))
+
+        res = {
+            "general": general,
+            "characters": characters,
+            "ips": ips,
+        }
+
+        tag_categories_for_translation = {
+            "general": list(general.keys()),
+            "characters": list(characters.keys()),
+            "ips": list(ips.keys()),
+        }
+
+        raw_meta = {
+            "device": str(self.device),
+            "latency_s_total": latency,
+            "_params": out.get("_params", params),
+            "_timings": out.get("_timings", {}),
+        }
+
+        return res, tag_categories_for_translation, raw_meta
 
 
 # 全局 Tagger 实例
 try:
     tagger_instance = Tagger()
 except RuntimeError as e:
-    print(f"应用启动时Tagger初始化失败: {e}")
-    tagger_instance = None  # 允许应用启动，但在处理时会失败
+    print(f"应用启动时 Tagger 初始化失败: {e}")
+    tagger_instance = None
+
+DEVICE_LABEL = (
+    f"设备：{str(tagger_instance.device).upper()}"
+    if tagger_instance is not None
+    else "设备：UNKNOWN"
+)
 
 # ------------------------------------------------------------------
 # Gradio UI
@@ -263,6 +350,7 @@ custom_css = """
 .tag-score {
     color: #999;
     font-size: 0.9em;
+    white-space: nowrap;
 }
 .btn-analyze-container {
     margin-top: 15px;
@@ -333,11 +421,14 @@ function copyToClipboard(text) {
 }
 """
 
+
 with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=custom_css, js=_js_functions) as demo:
     gr.Markdown("# 🖼️ AI 图像标签分析器")
     gr.Markdown(
         "上传图片自动识别标签，支持中英文显示和一键复制。"
         "[NovelAI在线绘画](https://nai.idlecloud.cc/)\n\n"
+        f"**当前模型：pixai-labs/pixai-tagger-v0.9**　|　**{DEVICE_LABEL}**\n\n"
+        "说明：新版模型不再返回评分标签，本页面已将原“评分标签”区域改为“IP 标签”。"
     )
 
     state_res = gr.State({})
@@ -346,22 +437,39 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
 
     with gr.Row():
         with gr.Column(scale=1):
-            # 改为 filepath，确保可以拿到原始文件路径与体积进行校验
             img_in = gr.Image(type="filepath", label="上传图片", height=300)
 
             btn = gr.Button("🚀 开始分析", variant="primary", elem_classes=["btn-analyze-container"])
 
             with gr.Accordion("⚙️ 高级设置", open=False):
-                gen_slider = gr.Slider(0, 1, value=0.35, step=0.01, label="通用标签阈值", info="越高 → 标签更少更准")
-                char_slider = gr.Slider(0, 1, value=0.85, step=0.01, label="角色标签阈值", info="推荐保持较高阈值")
-                show_tag_scores = gr.Checkbox(True, label="在列表中显示标签置信度")
+                gen_slider = gr.Slider(
+                    0,
+                    1,
+                    value=0.30,
+                    step=0.01,
+                    label="通用标签阈值",
+                    info="越高 → 标签更少更准",
+                )
+                char_slider = gr.Slider(
+                    0,
+                    1,
+                    value=0.85,
+                    step=0.01,
+                    label="角色标签阈值",
+                    info="推荐保持较高阈值",
+                )
+                show_tag_scores = gr.Checkbox(
+                    True,
+                    label="在列表中显示标签置信度",
+                    info="IP 标签不返回置信度，因此不会显示分数。",
+                )
 
             with gr.Accordion("📊 标签汇总设置", open=True):
                 gr.Markdown("选择要包含在下方汇总文本框中的标签类别：")
                 with gr.Row():
                     sum_general = gr.Checkbox(True, label="通用标签", min_width=50)
                     sum_char = gr.Checkbox(True, label="角色标签", min_width=50)
-                    sum_rating = gr.Checkbox(False, label="评分标签", min_width=50)
+                    sum_ip = gr.Checkbox(False, label="IP 标签", min_width=50)
                 sum_sep = gr.Dropdown(["逗号", "换行", "空格"], value="逗号", label="标签之间的分隔符")
                 sum_show_zh = gr.Checkbox(False, label="在汇总中显示中文翻译")
 
@@ -372,19 +480,24 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
                 with gr.TabItem("🏷️ 通用标签"):
                     out_general = gr.HTML(label="General Tags")
                 with gr.TabItem("👤 角色标签"):
-                    gr.Markdown("<p style='color:gray; font-size:small;'>提示：角色标签推测基于截至2024年2月的数据。</p>")
+                    gr.Markdown("<p style='color:gray; font-size:small;'>提示：角色标签由模型推断，建议保持较高阈值。</p>")
                     out_char = gr.HTML(label="Character Tags")
-                with gr.TabItem("⭐ 评分标签"):
-                    out_rating = gr.HTML(label="Rating Tags")
+                with gr.TabItem("🌐 IP 标签"):
+                    gr.Markdown("<p style='color:gray; font-size:small;'>提示：新版模型输出 IP 标签，但不返回评分标签/评分置信度。</p>")
+                    out_ip = gr.HTML(label="IP Tags")
 
             gr.Markdown("### 标签汇总结果")
             out_summary = gr.Textbox(
                 label="标签汇总",
                 placeholder="分析完成后，此处将显示汇总的英文标签...",
                 lines=5,
-                show_copy_button=True
+                show_copy_button=True,
             )
 
+            with gr.Accordion("🧾 推理元数据", open=False):
+                out_meta = gr.JSON(label="Metadata")
+
+
     # ----------------- 辅助函数 -----------------
     def format_tags_html(tags_dict, translations_list, category_name, show_scores=True, show_translation_in_list=True):
         if not tags_dict:
@@ -399,24 +512,37 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
 
         for i, tag in enumerate(tag_keys):
             score = tags_dict[tag]
-            escaped_tag = tag.replace("'", "\\'")
+            safe_tag_text = escape(str(tag))
+            js_arg = json.dumps(str(tag), ensure_ascii=False)
 
             html += '<div class="tag-item">'
-            tag_display_html = f'<span class="tag-en" onclick="copyToClipboard(\'{escaped_tag}\')">{tag}</span>'
+
+            tag_display_html = (
+                f'<span class="tag-en" onclick=\'copyToClipboard({js_arg})\'>{safe_tag_text}</span>'
+            )
 
             if show_translation_in_list and i < len(translations_list) and translations_list[i]:
-                tag_display_html += f'<span class="tag-zh">({translations_list[i]})</span>'
+                tag_display_html += f'<span class="tag-zh">({escape(str(translations_list[i]))})</span>'
+
+            html += f"<div>{tag_display_html}</div>"
 
-            html += f'<div>{tag_display_html}</div>'
-            if show_scores:
+            if show_scores and isinstance(score, (int, float)):
                 html += f'<span class="tag-score">{score:.3f}</span>'
-            html += '</div>'
-        html += '</div>'
+
+            html += "</div>"
+
+        html += "</div>"
         return html
 
+
     def generate_summary_text_content(
-        current_res, current_translations_dict,
-        s_gen, s_char, s_rat, s_sep_type, s_show_zh
+        current_res,
+        current_translations_dict,
+        s_gen,
+        s_char,
+        s_ip,
+        s_sep_type,
+        s_show_zh,
     ):
         if not current_res:
             return "请先分析图像或选择要汇总的标签类别。"
@@ -430,8 +556,8 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
             categories_to_summarize.append("general")
         if s_char:
             categories_to_summarize.append("characters")
-        if s_rat:
-            categories_to_summarize.append("ratings")
+        if s_ip:
+            categories_to_summarize.append("ips")
 
         if not categories_to_summarize:
             return "请至少选择一个标签类别进行汇总。"
@@ -447,6 +573,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
                         tags_to_join.append(f"{en_tag}/*{cat_translations[i]}*/")
                     else:
                         tags_to_join.append(en_tag)
+
                 if tags_to_join:
                     summary_parts.append(separator.join(tags_to_join))
 
@@ -455,16 +582,30 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
         final_summary = joiner.join(summary_parts)
         return final_summary if final_summary else "选定的类别中没有找到标签。"
 
+
     def process_image_and_generate_outputs(
-        image_path, g_th, c_th, s_scores,
-        s_gen, s_char, s_rat, s_sep, s_zh_in_sum
+        image_path,
+        g_th,
+        c_th,
+        s_scores,
+        s_gen,
+        s_char,
+        s_ip,
+        s_sep,
+        s_zh_in_sum,
     ):
         if image_path is None:
             yield (
                 gr.update(interactive=True, value="🚀 开始分析"),
                 gr.update(visible=True, value="❌ 请先上传图片。"),
-                "", "", "", "",
-                {}, {}, {}
+                "",
+                "",
+                "",
+                "",
+                {},
+                {},
+                {},
+                {},
             )
             return
 
@@ -472,8 +613,14 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
             yield (
                 gr.update(interactive=True, value="🚀 开始分析"),
                 gr.update(visible=True, value="❌ 分析器未成功初始化，请检查控制台错误。"),
-                "", "", "", "",
-                {}, {}, {}
+                "",
+                "",
+                "",
+                "",
+                {},
+                {},
+                {},
+                {},
             )
             return
 
@@ -484,26 +631,34 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
             gr.HTML(value="<p>分析中...</p>"),
             gr.HTML(value="<p>分析中...</p>"),
             gr.update(value="分析中，请稍候..."),
-            {}, {}, {}
+            {},
+            {},
+            {},
+            {},
         )
 
         try:
             img = validate_and_open_image(image_path)
-            res, tag_categories_original_order = tagger_instance.predict(img, g_th, c_th)
+            res, tag_categories_original_order, meta = tagger_instance.predict(img, g_th, c_th)
 
             all_tags_to_translate = []
-            for cat_key in ["general", "characters", "ratings"]:
+            for cat_key in ["general", "characters", "ips"]:
                 all_tags_to_translate.extend(tag_categories_original_order.get(cat_key, []))
 
             all_translations_flat = []
             if all_tags_to_translate:
-                all_translations_flat = translate_texts(all_tags_to_translate, src_lang="auto", tgt_lang="zh")
+                try:
+                    all_translations_flat = translate_texts(all_tags_to_translate, src_lang="auto", tgt_lang="zh")
+                except Exception as translate_error:
+                    print(f"⚠️ 标签翻译失败，将仅显示英文标签：{translate_error}")
+                    all_translations_flat = [""] * len(all_tags_to_translate)
 
             current_translations_dict = {}
             offset = 0
-            for cat_key in ["general", "characters", "ratings"]:
+            for cat_key in ["general", "characters", "ips"]:
                 cat_original_tags = tag_categories_original_order.get(cat_key, [])
                 num_tags_in_cat = len(cat_original_tags)
+
                 if num_tags_in_cat > 0:
                     current_translations_dict[cat_key] = all_translations_flat[offset: offset + num_tags_in_cat]
                     offset += num_tags_in_cat
@@ -524,17 +679,22 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
                 s_scores,
                 True,
             )
-            rating_html = format_tags_html(
-                res.get("ratings", {}),
-                current_translations_dict.get("ratings", []),
-                "ratings",
+            ip_html = format_tags_html(
+                res.get("ips", {}),
+                current_translations_dict.get("ips", []),
+                "ips",
                 s_scores,
                 True,
             )
 
             summary_text = generate_summary_text_content(
-                res, current_translations_dict,
-                s_gen, s_char, s_rat, s_sep, s_zh_in_sum
+                res,
+                current_translations_dict,
+                s_gen,
+                s_char,
+                s_ip,
+                s_sep,
+                s_zh_in_sum,
             )
 
             yield (
@@ -542,11 +702,12 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
                 gr.update(visible=True, value="✅ 分析完成!"),
                 general_html,
                 char_html,
-                rating_html,
+                ip_html,
                 gr.update(value=summary_text),
                 res,
                 current_translations_dict,
-                tag_categories_original_order
+                tag_categories_original_order,
+                meta,
             )
 
         except ImageValidationError as e:
@@ -557,48 +718,82 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
                 "<p>图片已被安全策略拒绝</p>",
                 "<p>图片已被安全策略拒绝</p>",
                 gr.update(value=f"错误: {str(e)}", placeholder="上传图片未通过安全校验..."),
-                {}, {}, {}
+                {},
+                {},
+                {},
+                {},
             )
         except Exception as e:
             import traceback
+
             tb_str = traceback.format_exc()
             print(f"处理时发生错误: {e}\n{tb_str}")
             yield (
                 gr.update(interactive=True, value="🚀 开始分析"),
                 gr.update(visible=True, value=f"❌ 处理失败: {str(e)}"),
-                "<p>处理出错</p>", "<p>处理出错</p>", "<p>处理出错</p>",
+                "<p>处理出错</p>",
+                "<p>处理出错</p>",
+                "<p>处理出错</p>",
                 gr.update(value=f"错误: {str(e)}", placeholder="分析失败..."),
-                {}, {}, {}
+                {},
+                {},
+                {},
+                {},
             )
 
+
     def update_summary_display(
-        s_gen, s_char, s_rat, s_sep, s_zh_in_sum,
-        current_res_from_state, current_translations_from_state
+        s_gen,
+        s_char,
+        s_ip,
+        s_sep,
+        s_zh_in_sum,
+        current_res_from_state,
+        current_translations_from_state,
     ):
         if not current_res_from_state:
             return gr.update(placeholder="请先完成一次图像分析以生成汇总。", value="")
 
         new_summary_text = generate_summary_text_content(
-            current_res_from_state, current_translations_from_state,
-            s_gen, s_char, s_rat, s_sep, s_zh_in_sum
+            current_res_from_state,
+            current_translations_from_state,
+            s_gen,
+            s_char,
+            s_ip,
+            s_sep,
+            s_zh_in_sum,
         )
         return gr.update(value=new_summary_text)
 
+
     btn.click(
         process_image_and_generate_outputs,
         inputs=[
-            img_in, gen_slider, char_slider, show_tag_scores,
-            sum_general, sum_char, sum_rating, sum_sep, sum_show_zh
+            img_in,
+            gen_slider,
+            char_slider,
+            show_tag_scores,
+            sum_general,
+            sum_char,
+            sum_ip,
+            sum_sep,
+            sum_show_zh,
         ],
         outputs=[
-            btn, processing_info,
-            out_general, out_char, out_rating,
+            btn,
+            processing_info,
+            out_general,
+            out_char,
+            out_ip,
             out_summary,
-            state_res, state_translations_dict, state_tag_categories_for_translation
+            state_res,
+            state_translations_dict,
+            state_tag_categories_for_translation,
+            out_meta,
         ],
     )
 
-    summary_controls = [sum_general, sum_char, sum_rating, sum_sep, sum_show_zh]
+    summary_controls = [sum_general, sum_char, sum_ip, sum_sep, sum_show_zh]
     for ctrl in summary_controls:
         ctrl.change(
             fn=update_summary_display,
@@ -606,7 +801,8 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI 图像标签分析器", css=cus
             outputs=[out_summary],
         )
 
+
 if __name__ == "__main__":
     if tagger_instance is None:
         print("CRITICAL: Tagger 未能初始化，应用功能将受限。请检查之前的错误信息。")
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.queue(max_size=8).launch(server_name="0.0.0.0", server_port=7860)