feat: add weight to model/

code_inference/all_in.py

@@ -0,0 +1,87 @@
+import os
+import json
+import subprocess
+import pandas as pd
+from pathlib import Path
+
+GLOBAL_MODEL_PATH = "../stage2_object_v8_1200"
+
+##示例:每个都传入绝对路径
+TASK_CONFIGS = [
+    ("rule_11_vllm.py", "文字占比"),
+    ("rule_12_vllm.py", "文字-样式数量合理"),
+    #("rule_13_vllm.py", "文字-排布位置"),
+    #("rule_14_vllm.py", "文字-设计搭配协调"),
+    ("rule_17_vllm.py", "信息量"),
+    ("rule_18_vllm.py", "排布间距"),
+    ("rule_19_vllm.py", "内容构图"),
+]
+
+SUMMARY_OUTPUT = "vllm_audit_summary.csv"
+
+def run_vllm_task(script, input_dir):
+
+    cmd = [
+        "python", script,
+        "--input_dir", input_dir,
+        "--model_path", GLOBAL_MODEL_PATH
+    ]
+    print(f"\n[EXEC] 正在运行: {script}")
+    print(f"[PATH] 输入目录: {Path(input_dir).name}")
+    
+    try:
+        subprocess.run(cmd, check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] 脚本 {script} 运行失败: {e}")
+        return False
+
+def extract_metrics(script, input_dir):
+    input_path = Path(input_dir)
+    json_file = input_path / f"audit_result_{input_path.name}.json"
+    
+    if not json_file.exists():
+        return {
+            "规则名称": script, 
+            "对应目录": input_path.name, 
+            "结果": "未找到 JSON 文件"
+        }
+
+    with open(json_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    total = len(data)
+    unsuitable = sum(1 for item in data if item["label"] == "Unsuitable")
+    suitable = sum(1 for item in data if item["label"] == "Suitable")
+    recall = (unsuitable / total) if total > 0 else 0
+
+    return {
+        "规则名称": script.replace("_vllm.py", ""),
+        "对应目录": input_path.name,
+        "样本总数": total,
+        "不通过数(Unsuitable)": unsuitable,
+        "通过数(Suitable)": suitable,
+        "召回率(违规检出率)": f"{recall:.2%}",
+        "所用模型": Path(GLOBAL_MODEL_PATH).name
+    }
+
+def main():
+    final_results = []
+    
+    for script, input_dir in TASK_CONFIGS:
+        success = run_vllm_task(script, input_dir)
+        
+        metrics = extract_metrics(script, input_dir)
+        final_results.append(metrics)
+        
+    df = pd.DataFrame(final_results)
+    df.to_csv(SUMMARY_OUTPUT, index=False, encoding='utf-8-sig')
+    
+    print("\n" + "="*70)
+    print(f"所有任务运行完毕！汇总报告已保存至: {SUMMARY_OUTPUT}")
+    print("-" * 70)
+    print(df.to_string(index=False))
+    print("="*70)
+
+if __name__ == "__main__":
+    main()

code_inference/all_in_normal.py

@@ -0,0 +1,101 @@
+import os
+import json
+import subprocess
+import pandas as pd
+import shutil
+from pathlib import Path
+
+GLOBAL_MODEL_PATH = "../stage2_object_v8_1200"
+GLOBAL_NORMAL_PATH = "正常-normal_data"###正常图的绝对路径
+
+# 任务配置：(脚本名, 规则显示名称)
+TASK_CONFIGS = [
+    ("rule_11_vllm.py", "文字占比"),
+    ("rule_12_vllm.py", "样式数量"),
+    #("rule_13_vllm.py", "排布位置"),
+    #("rule_14_vllm.py", "设计搭配"),
+    ("rule_17_vllm.py", "信息量"),
+    ("rule_18_vllm.py", "排布间距"),
+    ("rule_19_vllm.py", "内容构图"),
+]
+
+SUMMARY_OUTPUT = "vllm_audit_summary_normal.csv"
+
+def run_vllm_task(script, label_name):
+    normal_path = Path(GLOBAL_NORMAL_PATH)
+    original_json = normal_path / f"audit_result_{normal_path.name}.json"
+    unique_json = normal_path / f"temp_{script.replace('.py', '')}.json"
+
+    if unique_json.exists():
+        unique_json.unlink()
+
+    cmd = [
+        "python", script,
+        "--input_dir", GLOBAL_NORMAL_PATH,
+        "--model_path", GLOBAL_MODEL_PATH
+    ]
+    
+    print(f"\n[EXEC] 正在运行规则: {label_name} ({script})")
+    
+    try:
+        subprocess.run(cmd, check=True)
+        
+        if original_json.exists():
+            shutil.move(str(original_json), str(unique_json))
+            print(f"[DONE] 结果已固化至: {unique_json.name}")
+            return unique_json
+        else:
+            print(f"[ERROR] 脚本运行完成但未找到生成文件: {original_json}")
+            return None
+            
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] 脚本 {script} 崩溃: {e}")
+        return None
+
+def extract_metrics(json_path, script, label_name):
+    """从重命名后的唯一 JSON 文件中读取数据"""
+    if not json_path or not json_path.exists():
+        return {"规则名称": label_name, "状态": "失败"}
+
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    total = len(data)
+    unsuitable = sum(1 for item in data if item["label"] == "Unsuitable")
+    suitable = sum(1 for item in data if item["label"] == "Suitable")
+    fp_rate = (unsuitable / total) if total > 0 else 0
+
+    return {
+        "规则脚本": script,
+        "规则维度": label_name,
+        "测试总数": total,
+        "误报数(Unsuitable)": unsuitable,
+        "正确通过数(Suitable)": suitable,
+        "误报率(FP Rate)": f"{fp_rate:.2%}",
+        "结果文件": json_path.name
+    }
+
+def main():
+    final_results = []
+    
+    for script, label_name in TASK_CONFIGS:
+        unique_json_path = run_vllm_task(script, label_name)
+        
+        if unique_json_path:
+            metrics = extract_metrics(unique_json_path, script, label_name)
+            final_results.append(metrics)
+    
+    if final_results:
+        df = pd.DataFrame(final_results)
+        df.to_csv(SUMMARY_OUTPUT, index=False, encoding='utf-8-sig')
+        
+        print("\n" + "="*80)
+        print(f"测试完成！汇总已写入: {SUMMARY_OUTPUT}")
+        print("-" * 80)
+        print(df.to_string(index=False))
+        print("="*80)
+    else:
+        print("[CRITICAL] 没有收集到任何有效数据。")
+
+if __name__ == "__main__":
+    main()

code_inference/rule_11_vllm.py

@@ -0,0 +1,298 @@
+# -*- coding: utf-8 -*-
+"""
+使用方法:
+python rule_11_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+
+SYS_PROMPT_TEXT ="""You are a highly critical Senior Art Director and Visual Auditor.
+Your task is to evaluate "Text Visual Weight & Layout Balance" to prevent visual overcrowding while allowing for artistic typographic choices.
+
+INPUT: One image and one natural-language question about text density or layout balance.
+
+YOUR TASK:
+1. Analyze the visual weight of the text relative to the canvas (Area coverage + Visual heaviness).
+2. Apply the "Aesthetic Filter": Distinguish between "Cheap Da Zi Bao" (Violation) and "High-End Artistic Text" (Safe).
+3. Determine if the image is a **VIOLATION** (Unsuitable) or **SAFE** (Suitable).
+4. Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+<think>Detailed reasoning steps: 1. Estimate text area coverage -> 2. Assess design quality (Suffocating vs. Artistic) -> 3. Check for product obstruction...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Text Visual Weight"}</answer>
+
+=========================================
+CORE PRINCIPLE: BALANCE VS. SUFFOCATION
+=========================================
+- **The Rule:** Marketing text should generally occupy < 25% of the visual weight.
+- **The Exception:** Large text IS allowed if it is "Concise, Exquisite, and High-End" (Magazine Style).
+- **The Prohibition:** Large text is FORBIDDEN if it is "Crowded, Aggressive, and Cheap" (Da Zi Bao Style).
+- **Maximum Text Density:**  Regardless of artistic quality, any image containing more than 6 lines of narrative text or 50 words is automatically a VIOLATION (Information Overload).
+- **Literal Line Counting:** Each line in a bulleted list or paragraph counts as 1 line. A neatly organized list of 10 lines is still a VIOLATION of the 6-line limit.
+
+=========================================
+STRICT DECISION HIERARCHY (FOLLOW IN ORDER)
+=========================================
+1. HARD LIMIT CHECK: 
+   - Does the image have > 6 lines of text total (including text inside phone/UI)? 
+   - If YES -> Label: UNSUITABLE (Reason: Text Density Overload). 
+   - Zero UI Exemption: Text inside phone screens or UI mockups is NOT background decoration; it is active text weight. If the phone screen is filled with more than 4-5 lines of content, the entire image is likely UNSUITABLE.
+
+2. VISUAL WEIGHT CHECK:
+   - Does the text (and its background boxes/screens) occupy more than 30% of the canvas?
+   - If YES -> Label: UNSUITABLE (Reason: Excessive Visual Weight).
+
+3. AESTHETIC FILTER (The "Premium" Test):
+   - Is it "Artistic Exception"? ONLY if text is < 3 lines AND elegantly integrated. 
+   - Note: A phone screen filled with tiny text is NEVER "Artistic" or "High-End" in an ad context; it is a "Manual Page" (UNSUITABLE).
+=========================================
+CRITERIA FOR 'UNSUITABLE' (VIOLATION / OVERWHELMING)
+=========================================
+1. **Aggressive "Da Zi Bao" (大字报) Style:**
+   - **Visual Suffocation:** Massive, bold text occupies the central area with zero "breathing room" (negative space).
+   - **Cheap Aesthetic:** It looks like a spam flyer or a shouting warning sign rather than a professional ad.
+   - **Shouting Effect:** The font size is absurdly large relative to the canvas without any artistic justification.
+
+2. **Visual Obstruction & Imbalance:**
+   - **Blocking the Hero:** Text covers the main product, model's face, or key visual storytelling elements.
+   - **Excessive Weight:** The text area visually dominates > 30-40% of the canvas in a messy, cluttered way.
+
+3.**The "Manual/Article" Trap:** 
+   - Images that look like an instruction manual page, a reading app screenshot, or a news article are automatically UNSUITABLE. Ads must remain "Visual-First," not "Text-First."
+=========================================
+CRITERIA FOR 'SUITABLE' (SAFE / BALANCED)
+=========================================
+1. **Standard Good Ratio:**
+   - **Balanced:** Text occupies a reasonable area (roughly < 25% of visual weight).
+   - **Clear Hierarchy:** The Product/Illustration is the HERO; the Text is the SUPPORT.
+
+2. **The "Artistic Exception" (High-End Large Text):**
+   - **Premium Look:** Even if the headline is large, it is concise, elegant, and integrated well with the background.
+   - **Breathing Room:** The layout maintains generous margins and negative space. It feels like a Vogue cover or a movie poster, not a supermarket discount flyer.
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the text creates a "suffocating" effect, blocks the product, or looks like a cheap, crowded "Da Zi Bao".
+- **Suitable**: If the text is minimal (<25%), OR if it is large but designed with high artistic quality and ample negative space.
+"""
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+
+            data = json.loads(json_str)
+            raw_ans = data.get("Answer", "")
+            
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans 
+                
+        except json.JSONDecodeError:
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    vllm_inputs = []
+    user_query = "Analyze this image against the design rules and return the JSON decision."
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=512, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+
+    # ---------------------------
+    # 初始化模型
+    # ---------------------------
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+    # 采样参数
+    sampling_params = SamplingParams(
+        temperature=0.7, # 稍微降低温度以获得更稳定的分类
+        max_tokens=1024,
+        top_p=0.9
+    )
+
+    # ---------------------------
+    # 批量推理
+    # ---------------------------
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+            
+            # 解析结果
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],   # 思维链
+                "raw_output": generated_text
+            })
+
+    # ---------------------------
+    # 统计与输出
+    # ---------------------------
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    # 保存结果
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/rule_12_vllm.py

@@ -0,0 +1,267 @@
+# -*- coding: utf-8 -*-
+"""
+
+使用方法:
+python rule_12_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+
+
+SYS_PROMPT_TEXT ="""You are a highly critical Senior Art Director and Visual Auditor. Your core focus is Information Hierarchy and Typographic Purity.
+You have ZERO TOLERANCE for "Visual Noise" caused by excessive font types that increase the cost of information filtering.
+
+INPUT: One image and one natural-language question about typographic style and font count.
+
+YOUR TASK:
+1. Determine if the image is a **VIOLATION** (Unsuitable) or **SAFE** (Suitable) based on the criteria below.
+2. Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+CORE PRINCIPLE: The main text of an advertisement image must NOT exceed 2 different font categories. 
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+<think>Detailed reasoning identifying the specific font categories used in the main text and counting the total variety...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Font Style Consistency"}</answer>
+
+=========================================
+FONT CATEGORY DEFINITIONS (Total 4 Categories)
+=========================================
+1. **Sans-Serif (无衬线体):** Modern, uniform stroke thickness (e.g., Heiti/黑体, Youyuan/幼圆).
+2. **Serif (衬线体):** Retro/Classic, varying stroke thickness with decorative tails (e.g., Songti/宋体).
+3. **Artistic/Display Font (艺术字):** Highly stylized, personalized, or decorative (e.g., Gothic, bubble fonts, irregular proportions).
+4. **Handwritten/Calligraphy (手写体/书法体):** Brush-like strokes, traditional or casual handwriting styles.
+
+=========================================
+STRICT VIOLATION CRITERIA (If ANY match -> Unsuitable)
+=========================================
+1. **Excessive Font Variety (字体种类超标):**
+   - **Violation:** The main text in the image uses **three or more (3+)** of the aforementioned font categories simultaneously (e.g., Sans-serif + Serif + Calligraphy all in one ad).
+   - **Exclusions:** This rule EXCLUDES text naturally printed on the product packaging, brand logos, and secondary small text (annotations/footnotes). Only the main promotional copy is evaluated.
+   - **Visual Effect:** The typography feels cluttered, inconsistent, or lacks a dominant style, creating visual noise.
+
+=========================================
+CRITERIA FOR 'SUITABLE' (NON-VIOLATION / GOOD DESIGN)
+=========================================
+- **Unified Style:** The main text strictly utilizes only **1 or 2** font categories (e.g., only Sans-serif, or Sans-serif body text + Calligraphy headline).
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the main promotional text mixes 3 or more distinct font categories, resulting in chaotic styling.
+- **Suitable**: If the typography is restrained, using 1 to 2 font categories for a clean and cohesive information hierarchy.
+"""
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+
+            data = json.loads(json_str)
+
+            raw_ans = data.get("Answer", "")
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans 
+                
+        except json.JSONDecodeError:
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    vllm_inputs = []
+
+    user_query = "Is this image visually comfortable and suitable for information display?"
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=512, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+
+    sampling_params = SamplingParams(
+        temperature=0.7,
+        max_tokens=1024,
+        top_p=0.9
+    )
+
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+            
+
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],  
+                "raw_output": generated_text
+            })
+
+
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/rule_13_vllm.py

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*-
+"""
+使用方法:
+python rule_13_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+#排布位置
+SYS_PROMPT_TEXT="""You are a highly critical Senior Art Director specializing in Layout and Visual Hierarchy. 
+Your job is to identify "Suffocating Designs"—creative pieces where elements are too cramped, lack breathing room, or feel disorganized due to poor spacing.
+
+INPUT: One image and one natural-language question about layout composition and spacing.
+
+YOUR TASK:
+1. Determine if the image is a **VIOLATION** (Unsuitable) or **SAFE** (Suitable) based on the criteria below.
+2. Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+CORE JUDGMENT PRINCIPLE: A professional advertisement must have a clear "Sense of Breath" (Negative Space). If the elements feel "squeezed" or "crowded," it is UNSUITABLE.
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+<think>Detailed reasoning evaluating negative space, element proximity, visual path, and edge tension...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Text Legibility and Placement"}</answer>
+
+=========================================
+STRICT VIOLATION CRITERIA (If ANY match -> Unsuitable)
+=========================================
+1. **Lack of Breathing Room (Core Crowding Violation):**
+   - **Major Module Conflict:** The main subject (product/hero), the headline text, and the logo are placed too close to each other, lacking deliberate negative space.
+   - **Claustrophobic Feel:** The overall design feels "heavy" or "squeezed" because these major elements are fighting for space.
+
+2. **The "Clinging" Small Print (Secondary Text Violation):**
+   - **Tangency Risk:** While small text *can* be closer than headlines, it becomes a VIOLATION if it is "clinging" to, touching, or "tangent" to other elements or the image border.
+   - **Visual Noise:** Small text is squeezed into gaps without enough margin, looking like an afterthought rather than a design choice.
+
+3. **Edge Tension (贴边风险):**
+   - Elements are "touching" the canvas border or each other without a clear, intentional overlap (e.g., accidental contact).
+
+4. **Information Overload (信息堆砌):**
+   - **No Visual Path:** The layout is filled with too many text blocks or icons with no clear separation or hierarchy. The eye has nowhere to rest.
+
+5. **Placement & Background Conflict (文字-排布位置与背景):** [NEW CRITICAL RULE]
+   - **Text on Noise (背景干扰):** Text is overlaid directly onto a complex, textured, or high-contrast background (e.g., tree branches, detailed patterns) without a drop shadow or mask, making it "hard to breathe/read".
+   - **Weak Visual Anchor (视线捕捉失败):** Important text (Headline) is placed in a "dead zone" (extreme edges/corners) or blends into the background, failing to capture the eye immediately.
+
+=========================================
+CRITERIA FOR 'SUITABLE' (NON-VIOLATION / GOOD DESIGN)
+=========================================
+1. **Generous White Space (Major Elements):**
+   - Clear and deliberate separation exists between the Headline, Main Subject, and Footer.
+
+2. **Permissible Density (Small Print Exemption):**
+   - **Nuance:** Secondary small text (annotations/footnotes) IS ALLOWED to have smaller gaps relative to other elements (unlike headlines). As long as it doesn't touch/cling (see Violation #2), tighter spacing for small text is SAFE.
+
+3. **Valid Exclusions:**
+   - **Product Packaging:** Text printed naturally on the product packaging is SAFE.
+   - **Artistic Integration:** Artistic fonts visually integrated *into* the product itself are SAFE.
+   - **Media Exemption:** Film stills or variety show photography are always SAFE.
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the design feels squeezed, suffers from edge tension, lacks a visual path, or if small text "clings" to edges/elements.
+- **Suitable**: If major elements breathe well, OR if the density is strictly limited to allowed small print/packaging text that doesn't create tension.
+"""
+
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+    """扫描目录下所有图片"""
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+
+            data = json.loads(json_str)
+
+            raw_ans = data.get("Answer", "")
+            
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans 
+                
+        except json.JSONDecodeError:
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    
+    vllm_inputs = []
+    user_query = "Analyze this image against the design rules and return the JSON decision."
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+# ==========================================
+# 主程序
+# ==========================================
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=512, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+
+    sampling_params = SamplingParams(
+        temperature=0.7, 
+        max_tokens=1024,
+        top_p=0.9
+    )
+
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],  
+                "raw_output": generated_text
+            })
+
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/rule_14_vllm.py

@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+"""
+使用方法:
+python rule_14_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+
+
+SYS_PROMPT_TEXT="""You are a highly critical Senior Art Director. Your job is to flag "Low-Quality / Amateur" advertising designs. Crucial Context: You must distinguish between "Aggressive E-commerce Marketing" (Professional) and "Amateur Sloppiness" (Violation). High-resolution assets, standard platform badges, and professional 3D renders are SAFE.
+
+INPUT: One image and one natural-language question about design aesthetic and text harmony.
+
+YOUR TASK:
+
+Determine if the image is a VIOLATION (Unsuitable) or SAFE (Suitable) based on the criteria below.
+
+Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+OUTPUT FORMAT: Return EXACTLY two blocks, no extra text: <think>Detailed reasoning evaluating font effects, background integration, and aesthetic consistency...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Text Design Harmony"}</answer>
+
+========================================= STRICT VIOLATION CRITERIA (If ANY match -> Unsuitable)
+The "WordArt" Effect (廉价特效):
+
+Technical Failure: ONLY flag if text is pixelated, jagged, or uses 1990s-style rainbow/neon gradients.
+
+Distortion: Text is unprofessionally stretched or squeezed (breaking the font's aspect ratio).
+
+Amateur Strokes: Thick, vibrating outlines that look like they were made in MS Paint, not professional design software.
+
+Note: High-res 3D fonts, clean gold textures, and smooth gradients are PROFESSIONAL and SAFE.
+
+Visual Clutter & Conflict (背景冲突与拼贴感):
+
+Resolution Mismatch: A low-res/blurry graphic pasted onto a high-res photo.
+
+Zero Integration: Elements that have NO shadows, NO lighting consistency, and look like accidental "floating" errors.
+
+Legibility Loss: Text is truly unreadable due to background chaos without any masking.
+
+Note: Standard UI elements (Pill buttons, Price tags, Promo badges like "百亿补贴") are INTENTIONAL overlays and are SAFE.
+
+Inconsistent Aesthetic (风格割裂):
+
+Flag ONLY if elements are accidentally mismatched (e.g., a hand-drawn sketch randomly appearing in a high-tech 3D render without stylistic intent).
+
+Note: 3D mascots or cartoon characters placed on realistic backgrounds for marketing purposes are a VALID style and are SAFE.
+
+========================================= CRITERIA FOR 'SUITABLE' (NON-VIOLATION / GOOD DESIGN)
+Commercial Execution: High-resolution assets, clean font edges, and professional lighting/shadows.
+
+Platform Legitimacy: Presence of brand logos (Alipay, Taobao, Banks, China Gold) and standard e-commerce UI components.
+
+Intentional Hierarchy: Even if the design is "loud" (Red/Gold), it is Suitable if the text is aligned and the layout is purposeful.
+
+========================================= DECISION LOGIC
+Unsuitable: If the design shows Technical Failure (pixelation, distortion, 90s-style WordArt) or looks like a non-designer's mistake.
+
+Suitable: If the design follows Commercial Logic (Standard e-commerce banners, High-res renders, Professional marketing layouts). When in doubt, if the image looks like it's from a major App, it is SUITABLE.
+"""
+
+
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+            data = json.loads(json_str)
+            raw_ans = data.get("Answer", "")
+            
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans 
+                
+        except json.JSONDecodeError:
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    vllm_inputs = []
+    user_query = "Analyze this image against the design rules and return the JSON decision."
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=512, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+    sampling_params = SamplingParams(
+        temperature=0.7, 
+        max_tokens=1024,
+        top_p=0.9
+    )
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+            
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],  
+                "raw_output": generated_text
+            })
+
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/rule_17_vllm.py

@@ -0,0 +1,262 @@
+# -*- coding: utf-8 -*-
+"""
+
+使用方法:
+python rule_17_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+SYS_PROMPT_TEXT = """You are an expert Art Director and Advertisement Quality Assessor. 
+Your task is to filter out low-quality, cluttered, or visually confusing advertisements based on the "Visual Comfort & Clarity" standard.
+
+INPUT: One image and one natural-language question about visual suitability.
+
+YOUR TASK:
+1. Determine if the image is a **VIOLATION** (Unsuitable) or **SAFE** (Suitable) based on the criteria below.
+2. Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+<think>Detailed reasoning checking against the violation criteria (Background, Composition, Aesthetic, Text, Generic Assets)...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Visual Comfort"}</answer>
+
+=========================================
+VIOLATION CRITERIA (If ANY match -> Unsuitable)
+=========================================
+1. **Background & Repetition (CRITICAL)**
+   - **Repetitive Clutter:** Dense array of repeated objects (e.g., wall of bottles) lacking a focal point.
+   - **Chaotic Background:** Filled with "floating debris" (flying coins, confetti) blending with text.
+   
+2. **Composition Check**
+   - **Collage/Grid Layout:** Split into distinct panels/grids showing different scenes.
+   - **No Focal Point:** Subjects placed in corners without hierarchy.
+
+3. **Aesthetic Quality (The "Low Quality" Filter)**
+   - **Visual Overload:** Harsh, clashing high-saturation colors, cheap glowing effects, or cluttered 3D fonts.
+   - **Messy Alignment:** Elements touching edges, no margins, chaotic placement.
+
+4. **Text & Hierarchy Balance**
+   - **Scattered Text:** Text scattered across 4+ different locations, creating a chaotic reading path.
+
+5. **Generic Promotional Assets**
+   - **Spammy Visuals:** Large, generic 3D-rendered Red Packets or Gold Coins dominating the composition.
+   - **Wallpaper Effect:** Dense, repetitive pattern of festive icons leaving no negative space.
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the image triggers ANY of the Violation criteria above.
+- **Suitable**: If it looks professional, clean, has a clear main subject, and Safe Layout (e.g. vertical alignment).
+"""
+
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+            data = json.loads(json_str)
+            raw_ans = data.get("Answer", "")
+            
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans 
+                
+        except json.JSONDecodeError:
+
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    vllm_inputs = []
+
+    user_query = "Analyze this image against the design rules and return the JSON decision."
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=256, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+
+    sampling_params = SamplingParams(
+        temperature=0.7, 
+        max_tokens=1024,
+        top_p=0.9
+    )
+
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+            
+
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],   
+                "raw_output": generated_text
+            })
+
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/rule_18_vllm.py

@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+"""
+
+使用方法:
+python rule_18_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+
+
+SYS_PROMPT_TEXT="""You are a highly critical Senior Art Director specializing in Layout and Visual Hierarchy. 
+Your job is to identify "Suffocating Designs"—creative pieces where elements are too cramped, lack breathing room, or feel disorganized due to poor spacing.
+
+INPUT: One image and one natural-language question about layout composition and spacing.
+
+YOUR TASK:
+Analyze the image to determine if the layout violates professional "Composition & Spacing" standards. 
+
+CORE JUDGMENT PRINCIPLE: A professional advertisement must have a clear "Sense of Breath" (Negative Space). If the elements feel "squeezed" or "crowded," it is UNSUITABLE.
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+<think>Detailed reasoning evaluating negative space, element proximity, visual path, and edge tension...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Layout Breathability Check"}</answer>
+
+=========================================
+STRICT VIOLATION CRITERIA (If ANY match -> Unsuitable)
+=========================================
+1. **Lack of Breathing Room (Core Crowding Violation):**
+   - Core Violation: The main subject (the specific product or hero character, excluding the background image), the headline text, and the logo are placed too close to each other.
+   - Exclusions: This criterion does not apply to text appearing physically on the product packaging or artistic fonts that are visually integrated into the product itself.
+   - The "Small Print" Nuance: While major design modules require significant negative space, secondary small text (such as annotations or footnotes) is permitted to have smaller gaps relative to other elements. However, these small characters must not be too close to other elements or edges; they must maintain a basic visual distance to avoid a sense of "clinging," "tangency," or extreme squeezing.
+   - Visual Feel: The overall design feels "heavy" or "claustrophobic" because major modules lack sufficient negative space between them.
+
+2. **Edge Tension (贴边风险):**
+   - Elements are "touching" or "tangent" to each other or the border without intentional overlapping.
+
+3. **Information Overload (信息堆砌):**
+   - The layout is filled with too many text blocks or icons with no clear separation. 
+   - There is no clear "Visual Path"; the eye doesn't know where to rest because every element is competing for attention and space simultaneously.
+
+=========================================
+CRITERIA FOR 'SUITABLE' (NON-VIOLATION / GOOD DESIGN)
+=========================================
+1. **Generous White Space (Major Elements):**
+   - Clear and deliberate separation exists between the Headline, Main Subject, and Footer.
+
+2. **Permissible Density (Small Print Exemption):**
+   - **Nuance:** Secondary small text (annotations/footnotes) IS ALLOWED to have smaller gaps relative to other elements (unlike headlines). As long as it doesn't touch/cling (see Violation #2), tighter spacing for small text is SAFE.
+
+3. **Valid Exclusions:**
+   - **Product Packaging:** Text printed naturally on the product packaging is SAFE.
+   - **Artistic Integration:** Artistic fonts visually integrated *into* the product itself are SAFE.
+   - **Media Exemption:** Film stills or variety show photography are always SAFE.
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the design feels squeezed, suffers from edge tension, lacks a visual path, or if small text "clings" to edges/elements.
+- **Suitable**: If major elements breathe well, OR if the density is strictly limited to allowed small print/packaging text that doesn't create tension.
+"""
+
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+            data = json.loads(json_str)
+            raw_ans = data.get("Answer", "")
+            
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans 
+                
+        except json.JSONDecodeError:
+   
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    vllm_inputs = []
+    user_query = "Analyze this image against the design rules and return the JSON decision."
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=512, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+    sampling_params = SamplingParams(
+        temperature=0.7, 
+        max_tokens=1024,
+        top_p=0.9
+    )
+
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+            
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],  
+                "raw_output": generated_text
+            })
+
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/rule_19_vllm.py

@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-
+"""
+使用方法:
+python rule_19_vllm.py \
+  --input_dir "/path/to/your/images" \
+  --model_path "/path/to/your/Qwen2.5-VL-7B-Instruct"
+"""
+
+import os
+import re
+import json
+import argparse
+import multiprocessing
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from tqdm import tqdm
+from PIL import Image, ImageFile
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+
+
+os.environ['VLLM_WORKER_MULTIPROC_METHOD'] = 'spawn'
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+# 支持的图片格式
+IMG_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+# ==========================================
+# 【提示词工程】
+# ==========================================
+
+SYS_PROMPT_TEXT ="""You are a highly critical Senior Art Director. Your job is to flag "Low-Quality / Amateur" advertising designs.
+You have ZERO TOLERANCE for "Cheap Ad Styles" (often called "Niu Pi Xian" in Chinese context).
+
+INPUT: One image and one natural-language question about design aesthetic and text harmony.
+
+YOUR TASK:
+1. Determine if the image is a **VIOLATION** (Unsuitable) or **SAFE** (Suitable) based on the criteria below.
+2. Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+<think>Detailed reasoning evaluating font effects, background integration, and aesthetic consistency against the 'cheap design' criteria...</think><answer>{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Text-Design Harmony"}</answer>
+
+=========================================
+STRICT VIOLATION CRITERIA (If ANY match -> Unsuitable)
+=========================================
+1. **The "WordArt" Effect (廉价特效):**
+   - **Bad Strokes:** Text uses heavy, amateurish strokes (thick white/colored outlines) that look jagged or pixelated.
+   - **Fake 3D/Metal:** Outdated "Pseudo-3D" gradients (e.g., shiny gold/silver metal textures) that clash with a flat background.
+   - **Cheap Glow:** Aggressive "Outer Glow" (neon glow) that makes the text look blurry or radioactive.
+   - **Distortion:** Text is unprofessionally stretched, squeezed, or distorted strictly to fit a space.
+
+2. **Visual Clutter & Conflict (背景冲突与拼贴感):**
+   - **Legibility Loss:** Text is placed directly on top of a "Busy Photograph" (leaves, city streets, crowds) without a sufficient background mask, making it hard to read.
+   - **Color Vibration:** Text color aggressively vibrates against the background (e.g., bright red text directly on bright green).
+   - **Patchwork Style:** The text background looks like a "sticker" arbitrarily pasted onto a photo, completely ignoring the photo's lighting and perspective.
+
+3. **Inconsistent Aesthetic (风格割裂):**
+   - Foreground graphic elements (e.g., a cartoon/gaming style "Button" or "Banner") are superimposed on a realistic, high-res nature/human photograph. They do not belong in the same visual world.
+
+
+=========================================
+CRITERIA FOR 'SUITABLE' (NON-VIOLATION / GOOD DESIGN)
+=========================================
+1. **Clean Professionalism:** Professional typography with no cheap text effects (e.g., simple text like "xx折扣" is perfectly fine if the font is clean).
+2. **Proper Integration:** Text placed on a solid, clean color background, or properly masked on a complex background.
+3. **Cohesive Art Direction:** Clean, flat vector art that matches its surroundings visually.
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the design looks cheap, messy, outdated, features "WordArt" effects, or feels like a patched-together "Niu Pi Xian" ad.
+- **Suitable**: If the design is clean, professional, and visually harmonious.
+"""
+
+
+
+SYS_PROMPT_TEXT="""You are a highly critical "Senior Art Director." Your goal is to evaluate the "Professional Polish" of splash ads. You have [ZERO TOLERANCE] for raw, unprocessed photos that look like amateur snapshots.
+
+INPUT:
+One image and one natural-language question about professional polish quality.
+
+YOUR TASK:
+1. Determine if the image is a **VIOLATION** (Unsuitable) or **SAFE** (Suitable) based on the criteria below.
+2. Output a JSON object containing a rigorous Chain-of-Thought ("think") and a precise classification label ("answer").
+
+OUTPUT FORMAT:
+Return EXACTLY two blocks, no extra text:
+
+<think>
+Detailed reasoning evaluating lighting, color grading, and depth of field against the "passerby snapshot" criteria...
+</think>
+<answer>
+{"Answer": "<Suitable OR Unsuitable>", "Answer type": "Professional Polish"}
+</answer>
+
+=========================================
+STRICT VIOLATION CRITERIA (If ANY match -> Unsuitable)
+=========================================
+1. **Lack of Professional Post-Processing:**
+   - The image appears to be a "Raw Photo" directly from a camera/phone without professional retouching.
+
+2. **The "Amateur Snapshot" Aesthetic:**
+   - The image looks like something a "passerby" could easily capture. It lacks the sophisticated framing, high-end texture, and artistic polish required for premium advertising.
+
+3. **Absence of Value Conveyance:**
+   - The image is visually "flat" and fails to evoke a sense of high quality. It does not use professional polish techniques to guide the viewer's emotions.
+
+=========================================
+CRITERIA FOR 'SUITABLE' (NON-VIOLATION / PREMIUM TEXTURE)
+=========================================
+1. **Professional Post-Processing:**
+   - **Masterful Retouching:** The image shows clear evidence of professional professional polish (not straight-out-of-camera).
+
+2. **The "High-End" Aesthetic:**
+   - **Professionalism:** The image features a look that cannot be easily replicated by a passerby.
+   - **Superior Texture:** Displays deliberate set design and artistic polish.
+   
+4. **Media Exemption:** Film stills or variety show photography are always classified as SAFE (Suitable).
+
+=========================================
+DECISION LOGIC
+=========================================
+- **Unsuitable**: If the image looks like an unprocessed, amateur snapshot with flat lighting and no professional polish polish.
+- **Suitable**: If the image shows professional professional polish, or is a professional film/variety show still.
+"""
+
+
+
+
+def collect_images(input_dir: Path) -> List[Dict[str, str]]:
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    
+    files = [p for p in input_dir.iterdir() if p.is_file() and p.suffix.lower() in IMG_EXTS]
+    files.sort()
+    
+    print(f"[Info] Found {len(files)} images in {input_dir}")
+    return [{"path": str(p), "filename": p.name} for p in files]
+
+def parse_llm_output(text: str) -> Dict[str, Any]:
+    default_res = {
+        "label": "Parse Error", 
+        "think": "No reasoning found", 
+        "raw": text
+    }
+    
+    if not text:
+        return default_res
+
+    think_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+    think_content = think_match.group(1).strip() if think_match else ""
+
+    answer_match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    
+    extracted_label = "Parse Error"
+    
+    if answer_match:
+        json_str = answer_match.group(1).strip()
+        try:
+            data = json.loads(json_str)
+            raw_ans = data.get("Answer", "")
+            
+            if "unsuitable" in raw_ans.lower():
+                extracted_label = "Unsuitable"
+            elif "suitable" in raw_ans.lower():
+                extracted_label = "Suitable"
+            else:
+                extracted_label = raw_ans
+                
+        except json.JSONDecodeError:
+            if "Unsuitable" in json_str:
+                extracted_label = "Unsuitable"
+            elif "Suitable" in json_str:
+                extracted_label = "Suitable"
+    else:
+        if "Unsuitable" in text:
+            extracted_label = "Unsuitable"
+        elif "Suitable" in text:
+            extracted_label = "Suitable"
+
+    return {
+        "label": extracted_label,
+        "think": think_content,
+        "raw": text
+    }
+
+def prepare_vllm_inputs(batch_meta: List[Dict], processor) -> List[Dict]:
+    vllm_inputs = []
+
+    user_query = "Analyze this image against the design rules and return the JSON decision."
+    
+    for item in batch_meta:
+        img_path = item["path"]
+        try:
+            image_obj = Image.open(img_path).convert("RGB")
+            
+            messages = [
+                {"role": "system", "content": [{"type": "text", "text": SYS_PROMPT_TEXT}]},
+                {"role": "user", "content": [
+                    {"type": "image", "image": img_path},
+                    {"type": "text", "text": user_query}
+                ]}
+            ]
+            
+            prompt_text = processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            
+            vllm_inputs.append({
+                "prompt": prompt_text,
+                "multi_modal_data": {"image": image_obj}
+            })
+        except Exception as e:
+            print(f"[Warning] Failed to load {img_path}: {e}")
+            vllm_inputs.append(None)
+            
+    return vllm_inputs
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Visual Comfort Auditor")
+    parser.add_argument("--input_dir", type=str, required=True, help="Folder containing images to check")
+    parser.add_argument("--model_path", type=str, required=True, help="Path to local Qwen-VL model")
+    parser.add_argument("--batch_size", type=int, default=512, help="Inference batch size")
+    parser.add_argument("--tp_size", type=int, default=2, help="Tensor Parallel size")
+    args = parser.parse_args()
+
+    input_path = Path(args.input_dir)
+    meta_data = collect_images(input_path)
+    
+    if not meta_data:
+        print("[Info] No images found. Exiting.")
+        return
+
+    print(f"\n[Init] Loading Model: {args.model_path}")
+    
+    llm = LLM(
+        model=args.model_path,
+        tokenizer=args.model_path,
+        trust_remote_code=True,
+        tensor_parallel_size=args.tp_size,
+        gpu_memory_utilization=0.90, 
+        max_model_len=8192, 
+        enforce_eager=True,
+        limit_mm_per_prompt={"image": 1}
+    )
+    
+    processor = AutoProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    
+    sampling_params = SamplingParams(
+        temperature=0.7, 
+        max_tokens=1024,
+        top_p=0.9
+    )
+
+    results = []
+    print(f"\n[Run] Starting Inference on {len(meta_data)} images...")
+    
+    for i in tqdm(range(0, len(meta_data), args.batch_size), desc="Processing Batches"):
+        batch_meta = meta_data[i : i + args.batch_size]
+        batch_inputs = prepare_vllm_inputs(batch_meta, processor)
+        
+        valid_inputs = [inp for inp in batch_inputs if inp is not None]
+        valid_indices = [idx for idx, inp in enumerate(batch_inputs) if inp is not None]
+        
+        if not valid_inputs:
+            continue
+            
+        outputs = llm.generate(valid_inputs, sampling_params=sampling_params, use_tqdm=False)
+        
+        for local_idx, out in enumerate(outputs):
+            original_meta = batch_meta[valid_indices[local_idx]]
+            generated_text = out.outputs[0].text
+            
+            parsed = parse_llm_output(generated_text)
+            
+            results.append({
+                "filename": original_meta["filename"],
+                "path": original_meta["path"],
+                "label": parsed["label"],   # Suitable / Unsuitable
+                "think": parsed["think"],   
+                "raw_output": generated_text
+            })
+
+    total = len(results)
+    unsuitable_count = sum(1 for r in results if r["label"] == "Unsuitable")
+    suitable_count = sum(1 for r in results if r["label"] == "Suitable")
+    error_count = total - unsuitable_count - suitable_count
+
+    unsuitable_rate = (unsuitable_count / total * 100) if total > 0 else 0
+    suitable_rate = (suitable_count / total * 100) if total > 0 else 0
+
+    print("\n" + "="*60)
+    print(f"AUDIT REPORT FOR: {input_path.name}")
+    print("="*60)
+    print(f"{'Total Images':<25}: {total}")
+    print("-" * 60)
+    print(f"{'UNSUITABLE (Violation)':<25}: {unsuitable_count}  ({unsuitable_rate:.2f}%)")
+    print(f"{'SUITABLE (Safe)':<25}: {suitable_count}  ({suitable_rate:.2f}%)")
+    print(f"{'Parse Errors':<25}: {error_count}")
+    print("="*60)
+
+    output_file = input_path / f"audit_result_{input_path.name}.json"
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"\n[Done] Detailed JSON report saved to:\n-> {output_file}")
+    except Exception as e:
+        print(f"[Error] Could not save JSON: {e}")
+
+if __name__ == "__main__":
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        pass
+    
+    main()

code_inference/vllm_audit_summary_normal.csv

@@ -0,0 +1,7 @@
+规则脚本,规则维度,测试总数,误报数(Unsuitable),正确通过数(Suitable),误报率(FP Rate),结果文件
+rule_11_vllm.py,文字占比,134,3,131,2.24%,temp_rule_11_vllm.json
+rule_12_vllm.py,样式数量,134,3,131,2.24%,temp_rule_12_vllm.json
+rule_13_vllm.py,排布位置,134,9,125,6.72%,temp_rule_13_vllm.json
+rule_14_vllm.py,设计搭配,134,6,128,4.48%,temp_rule_14_vllm.json
+rule_18_vllm.py,排布间距,134,1,133,0.75%,temp_rule_18_vllm.json
+rule_19_vllm.py,内容构图,134,3,131,2.24%,temp_rule_19_vllm.json

stage2_object_v8_1200/added_tokens.json

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

stage2_object_v8_1200/chat_template.jinja

@@ -0,0 +1,120 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' }}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- for message in messages %}
+    {%- if message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content_item in message.content %}
+                {%- if 'text' in content_item %}
+                    {{- content_item.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and message.content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

stage2_object_v8_1200/config.json

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

stage2_object_v8_1200/generation_config.json

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

stage2_object_v8_1200/model-00001-of-00004.safetensors

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

stage2_object_v8_1200/model-00002-of-00004.safetensors

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

stage2_object_v8_1200/model-00003-of-00004.safetensors

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

stage2_object_v8_1200/model-00004-of-00004.safetensors

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

stage2_object_v8_1200/model.safetensors.index.json

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

stage2_object_v8_1200/preprocessor_config.json

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

stage2_object_v8_1200/special_tokens_map.json

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

stage2_object_v8_1200/tokenizer.json

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

stage2_object_v8_1200/tokenizer_config.json

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

stage2_object_v8_1200/video_preprocessor_config.json

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

stage2_object_v8_1200/vocab.json

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