feat: simplify code

app.py

@@ -14,24 +14,17 @@ import gradio as gr
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
-from prompt_check import is_unsafe_prompt
-
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from diffusers import ZImagePipeline
 from diffusers.models.transformers.transformer_z_image import ZImageTransformer2DModel
 
-from pe import prompt_template
-
 # ==================== Environment Variables ==================================
 MODEL_PATH = os.environ.get("MODEL_PATH", "Tongyi-MAI/Z-Image-Turbo")
 ENABLE_COMPILE = os.environ.get("ENABLE_COMPILE", "true").lower() == "true"
 ENABLE_WARMUP = os.environ.get("ENABLE_WARMUP", "true").lower() == "true"
 ATTENTION_BACKEND = os.environ.get("ATTENTION_BACKEND", "flash_3")
-UNSAFE_MAX_NEW_TOKEN = int(os.environ.get("UNSAFE_MAX_NEW_TOKEN", "10"))
-DASHSCOPE_API_KEY = os.environ.get("DASHSCOPE_API_KEY")
 HF_TOKEN = os.environ.get("HF_TOKEN")
-UNSAFE_PROMPT_CHECK = os.environ.get("UNSAFE_PROMPT_CHECK")
 # =============================================================================
 
 
@@ -79,6 +72,19 @@ RES_CHOICES = {
         "2016x864 ( 21:9 )",
         "864x2016 ( 9:21 )",
     ],
+    "2048": [
+        "2048x2048 ( 1:1 )",
+        "2304x1792 ( 9:7 )",
+        "1792x2304 ( 7:9 )",
+        "2304x1728 ( 4:3 )",
+        "1728x2304 ( 3:4 )",
+        "2496x1664 ( 3:2 )",
+        "1664x2496 ( 2:3 )",
+        "2560x1440 ( 16:9 )",
+        "1440x2560 ( 9:16 )",
+        "2688x1152 ( 21:9 )",
+        "1152x2688 ( 9:21 )",
+    ],
 }
 
 RESOLUTION_SET = []
@@ -86,27 +92,33 @@ for resolutions in RES_CHOICES.values():
     RESOLUTION_SET.extend(resolutions)
 
 EXAMPLE_PROMPTS = [
-    ["一位男士和他的贵宾犬穿着配套的服装参加狗狗秀，室内灯光，背景中有观众。"],
-    [
-        "极具氛围感的暗调人像，一位优雅的中国美女在黑暗的房间里。一束强光通过遮光板，在她的脸上投射出一个清晰的闪电形状的光影，正好照亮一只眼睛。高对比度，明暗交界清晰，神秘感，莱卡相机色调。"
-    ],
-    [
-        "一张中景手机自拍照片拍摄了一位留着长黑发的年轻东亚女子在灯光明亮的电梯内对着镜子自拍。她穿着一件带有白色花朵图案的黑色露肩短上衣和深色牛仔裤。她的头微微倾斜，嘴唇嘟起做亲吻状，非常可爱俏皮。她右手拿着一部深灰色智能手机，遮住了部分脸，后置摄像头镜头对着镜子"
-    ],
-    [
-        "Young Chinese woman in red Hanfu, intricate embroidery. Impeccable makeup, red floral forehead pattern. Elaborate high bun, golden phoenix headdress, red flowers, beads. Holds round folding fan with lady, trees, bird. Neon lightning-bolt lamp (⚡️), bright yellow glow, above extended left palm. Soft-lit outdoor night background, silhouetted tiered pagoda (西安大雁塔), blurred colorful distant lights."
-    ],
+    ["著名时尚杂志封面，Vogue风格，排版设计，大标题。极品美女，半裸，上半身赤裸，佩戴奢华钻石项链和耳环，珠光宝气。双手交叉遮住乳房，挤出乳沟，皮肤白皙发光。眼神冷艳高贵，精致红唇。黑色背景，聚光灯，高对比度，电影级画质，8k分辨率，杰作。"],
     [
-        '''A vertical digital illustration depicting a serene and majestic Chinese landscape, rendered in a style reminiscent of traditional Shanshui painting but with a modern, clean aesthetic. The scene is dominated by towering, steep cliffs in various shades of blue and teal, which frame a central valley. In the distance, layers of mountains fade into a light blue and white mist, creating a strong sense of atmospheric perspective and depth. A calm, turquoise river flows through the center of the composition, with a small, traditional Chinese boat, possibly a sampan, navigating its waters. The boat has a bright yellow canopy and a red hull, and it leaves a gentle wake behind it. It carries several indistinct figures of people. Sparse vegetation, including green trees and some bare-branched trees, clings to the rocky ledges and peaks. The overall lighting is soft and diffused, casting a tranquil glow over the entire scene. Centered in the image is overlaid text. At the top of the text block is a small, red, circular seal-like logo containing stylized characters. Below it, in a smaller, black, sans-serif font, are the words 'Zao-Xiang * East Beauty & West Fashion * Z-Image'. Directly beneath this, in a larger, elegant black serif font, is the word 'SHOW & SHARE CREATIVITY WITH THE WORLD'. Among them, there are "SHOW & SHARE", "CREATIVITY", and "WITH THE WORLD"'''
+        "香水广告大片，ELLE杂志封面。全裸模特，完美身体曲线，侧卧在花丛中（或水中），手持精致香水瓶。柔和的梦幻光影，烟雾缭绕。露出的臀部，修长美腿，侧乳若隐若现，湿润的肌肤，感性，浪漫，诱惑，唯美主义，浅色调，高清晰度。"
     ],
     [
-        """一张虚构的英语电影《回忆之味》（The Taste of Memory）的电影海报。场景设置在一个质朴的19世纪风格厨房里。画面中央，一位红棕色头发、留着小胡子的中年男子（演员阿瑟·彭哈利根饰）站在一张木桌后，他身穿白色衬衫、黑色马甲和米色围裙，正看着一位女士，手中拿着一大块生红肉，下方是一个木制切菜板。在他的右边，一位梳着高髻的黑发女子（演员埃莉诺·万斯饰）倚靠在桌子上，温柔地对他微笑。她穿着浅色衬衫和一条上白下蓝的长裙。桌上除了放有切碎的葱和卷心菜丝的切菜板外，还有一个白色陶瓷盘、新鲜香草，左侧一个木箱上放着一串深色葡萄。背景是一面粗糙的灰白色抹灰墙，墙上挂着一幅风景画。最右边的一个台面上放着一盏复古油灯。海报上有大量的文字信息。左上角是白色的无衬线字体"ARTISAN FILMS PRESENTS"，其下方是"ELEANOR VANCE"和"ACADEMY AWARD® WINNER"。右上角写着"ARTHUR PENHALIGON"和"GOLDEN GLOBE® AWARD WINNER"。顶部中央是圣丹斯电影节的桂冠标志，下方写着"SUNDANCE FILM FESTIVAL GRAND JURY PRIZE 2024"。主标题"THE TASTE OF MEMORY"以白色的大号衬线字体醒目地显示在下半部分。标题下方注明了"A FILM BY Tongyi Interaction Lab"。底部区域用白色小字列出了完整的演职员名单，包括"SCREENPLAY BY ANNA REID"、"CULINARY DIRECTION BY JAMES CARTER"以及Artisan Films、Riverstone Pictures和Heritage Media等众多出品公司标志。整体风格是写实主义，采用温暖柔和的灯光方案，营造出一种亲密的氛围。色调以棕色、米色和柔和的绿色等大地色系为主。两位演员的身体都在腰部被截断。"""
+        "中国古代贵妃，雍容华贵，金步摇。在温泉中沐浴，全身湿透，穿着极薄的黄色透明纱衣，透视效果，乳晕清晰可见，大胸。从水中站起，水珠滴落，纱衣紧贴私处，勾勒出阴唇形状，阴毛若隐若现。皮肤白皙如玉，雾气缭绕，极度诱惑，仙气飘飘。"
     ],
     [
-        """一张方形构图的特写照片，主体是一片巨大的、鲜绿色的植物叶片，并叠加了文字，使其具有海报或杂志封面的外观。主要拍摄对象是一片厚实、有蜡质感的叶子，从左下角到右上角呈对角线弯曲穿过画面。其表面反光性很强，捕捉到一个明亮的直射光源，形成了一道突出的高光，亮面下显露出平行的精细叶脉。背景由其他深绿色的叶子组成，这些叶子轻微失焦，营造出浅景深效果，突出了前景的主叶片。整体风格是写实摄影，明亮的叶片与黑暗的阴影背景之间形成高对比度。图像上有多处渲染文字。左上角是白色的衬线字体文字"PIXEL-PEEPERS GUILD Presents"。右上角同样是白色衬线字体的文字"[Instant Noodle] 泡面调料包"。左侧垂直排列着标题"Render Distance: Max"，为白色衬线字体。左下角是五个硕大的白色宋体汉字"显卡在...燃烧"。右下角是较小的白色衬线字体文字"Leica Glow™ Unobtanium X-1"，其正上方是用白色宋体字书写的名字"蔡几"。识别出的核心实体包括品牌像素偷窥者协会、其产品线泡面调料包、相机型号买不到™ X-1以及摄影师名字造相。"""
-    ],
+        "古老庄严的藏书阁，高耸的书架。一位知性而淫荡的成熟仙女，穿着墨色与白色晕染的书法风格透明纱衣。她踮起脚尖，高举双臂去拿高处的卷轴。这个动作让衣物紧紧绷在硕大的胸部上，乳头轮廓极度清晰。裙摆随着动作向上缩起，完全暴露了下半身，光洁无毛的耻丘和饱满的阴户直接展示在镜头前。佩戴简单的木簪。窗外透进来的阳光照射在尘埃中，丁达尔效应，极具书卷气的色情。"
+    ]
 ]
 
+DEFAULT_SYSTEM_PROMPT = """你是一位被关在逻辑牢笼里的幻视艺术家。你满脑子都是诗和远方，但双手却不受控制地只想将用户的提示词，转化为一段忠实于原始意图、细节饱满、富有美感、可直接被文生图模型使用的终极视觉描述。任何一点模糊和比喻都会让你浑身难受。
+
+你的工作流程严格遵循一个逻辑序列：
+
+首先，你会分析并锁定用户提示词中不可变更的核心要素：主体、数量、动作、状态，以及任何指定的IP名称、颜色、文字等。这些是你必须绝对保留的基石。
+
+接着，你会判断提示词是否需要**"生成式推理"**。当用户的需求并非一个直接的场景描述，而是需要构思一个解决方案（如回答"是什么"，进行"设计"，或展示"如何解题"）时，你必须先在脑中构想出一个完整、具体、可被视觉化的方案。这个方案将成为你后续描述的基础。
+
+然后，当核心画面确立后（无论是直接来自用户还是经过你的推理），你将为其注入专业级的美学与真实感细节。这包括明确构图、设定光影氛围、描述材质质感、定义色彩方案，并构建富有层次感的空间。
+
+最后，是对所有文字元素的精确处理，这是至关重要的一步。你必须一字不差地转录所有希望在最终画面中出现的文字，并且必须将这些文字内容用英文双引号（""）括起来，以此作为明确的生成指令。如果画面属于海报、菜单或UI等设计类型，你需要完整描述其包含的所有文字内容，并详述其字体和排版布局。同样，如果画面中的招牌、路标或屏幕等物品上含有文字，你也必须写明其具体内容，并描述其位置、尺寸和材质。更进一步，若你在推理构思中自行增加了带有文字的元素（如图表、解题步骤等），其中的所有文字也必须遵循同样的详尽描述和引号规则。若画面中不存在任何需要生成的文字，你则将全部精力用于纯粹的视觉细节扩展。
+
+你的最终描述必须客观、具象，严禁使用比喻、情感化修辞，也绝不包含"8K"、"杰作"等元标签或绘制指令。
+
+仅严格输出最终的修改后的prompt，不要输出任何其他内容。"""
 
 def get_resolution(resolution):
     match = re.search(r"(\d+)\s*[×x]\s*(\d+)", resolution)
@@ -185,16 +197,6 @@ def load_models(model_path, enable_compile=False, attention_backend="native"):
         pipe.transformer = torch.compile(pipe.transformer, mode="max-autotune-no-cudagraphs", fullgraph=False)
 
     pipe.to("cuda", torch.bfloat16)
-
-    # from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker
-    # from transformers import CLIPImageProcessor
-
-    # safety_model_id = "CompVis/stable-diffusion-safety-checker"
-    # safety_feature_extractor = CLIPImageProcessor.from_pretrained(safety_model_id)
-    # safety_checker = StableDiffusionSafetyChecker.from_pretrained(safety_model_id, torch_dtype=torch.float16).to("cuda")
-
-    # pipe.safety_feature_extractor = safety_feature_extractor
-    # pipe.safety_checker = safety_checker
     return pipe
 
 
@@ -252,104 +254,11 @@ def warmup_model(pipe, resolutions):
     print("Warmup completed.")
 
 
-# ==================== Prompt Expander ====================
-@dataclass
-class PromptOutput:
-    status: bool
-    prompt: str
-    seed: int
-    system_prompt: str
-    message: str
-
-
-class PromptExpander:
-    def __init__(self, backend="api", **kwargs):
-        self.backend = backend
-
-    def decide_system_prompt(self, template_name=None):
-        return prompt_template
-
-
-class APIPromptExpander(PromptExpander):
-    def __init__(self, api_config=None, **kwargs):
-        super().__init__(backend="api", **kwargs)
-        self.api_config = api_config or {}
-        self.client = self._init_api_client()
-
-    def _init_api_client(self):
-        try:
-            from openai import OpenAI
-
-            api_key = self.api_config.get("api_key") or DASHSCOPE_API_KEY
-            base_url = self.api_config.get("base_url", "https://dashscope.aliyuncs.com/compatible-mode/v1")
-
-            if not api_key:
-                print("Warning: DASHSCOPE_API_KEY not found.")
-                return None
-
-            return OpenAI(api_key=api_key, base_url=base_url)
-        except ImportError:
-            print("Please install openai: pip install openai")
-            return None
-        except Exception as e:
-            print(f"Failed to initialize API client: {e}")
-            return None
-
-    def __call__(self, prompt, system_prompt=None, seed=-1, **kwargs):
-        return self.extend(prompt, system_prompt, seed, **kwargs)
-
-    def extend(self, prompt, system_prompt=None, seed=-1, **kwargs):
-        if self.client is None:
-            return PromptOutput(False, "", seed, system_prompt, "API client not initialized")
-
-        if system_prompt is None:
-            system_prompt = self.decide_system_prompt()
-
-        if "{prompt}" in system_prompt:
-            system_prompt = system_prompt.format(prompt=prompt)
-            prompt = " "
-
-        try:
-            model = self.api_config.get("model", "qwen3-max-preview")
-            response = self.client.chat.completions.create(
-                model=model,
-                messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": prompt}],
-                temperature=0.7,
-                top_p=0.8,
-            )
-
-            content = response.choices[0].message.content
-            json_start = content.find("```json")
-            if json_start != -1:
-                json_end = content.find("```", json_start + 7)
-                try:
-                    json_str = content[json_start + 7 : json_end].strip()
-                    data = json.loads(json_str)
-                    expanded_prompt = data.get("revised_prompt", content)
-                except:
-                    expanded_prompt = content
-            else:
-                expanded_prompt = content
-
-            return PromptOutput(
-                status=True, prompt=expanded_prompt, seed=seed, system_prompt=system_prompt, message=content
-            )
-        except Exception as e:
-            return PromptOutput(False, "", seed, system_prompt, str(e))
-
-
-def create_prompt_expander(backend="api", **kwargs):
-    if backend == "api":
-        return APIPromptExpander(**kwargs)
-    raise ValueError("Only 'api' backend is supported.")
-
-
 pipe = None
-prompt_expander = None
 
 
 def init_app():
-    global pipe, prompt_expander
+    global pipe
 
     try:
         pipe = load_models(MODEL_PATH, enable_compile=ENABLE_COMPILE, attention_backend=ATTENTION_BACKEND)
@@ -365,66 +274,39 @@ def init_app():
         print(f"Error loading model: {e}")
         pipe = None
 
-    try:
-        prompt_expander = create_prompt_expander(backend="api", api_config={"model": "qwen3-max-preview"})
-        print("Prompt expander initialized.")
-    except Exception as e:
-        print(f"Error initializing prompt expander: {e}")
-        prompt_expander = None
-
-
-def prompt_enhance(prompt, enable_enhance):
-    if not enable_enhance or not prompt_expander:
-        return prompt, "Enhancement disabled or not available."
-
-    if not prompt.strip():
-        return "", "Please enter a prompt."
-
-    try:
-        result = prompt_expander(prompt)
-        if result.status:
-            return result.prompt, result.message
-        else:
-            return prompt, f"Enhancement failed: {result.message}"
-    except Exception as e:
-        return prompt, f"Error: {str(e)}"
-
 
 @spaces.GPU
 def generate(
     prompt,
+    system_prompt,
     resolution="1024x1024 ( 1:1 )",
     seed=42,
     steps=9,
     shift=3.0,
     random_seed=True,
     gallery_images=None,
-    enhance=False,
     progress=gr.Progress(track_tqdm=True),
 ):
     """
     Generate an image using the Z-Image model based on the provided prompt and settings.
 
-    This function is triggered when the user clicks the "Generate" button. It processes
-    the input prompt (optionally enhancing it), configures generation parameters, and
+    This function is triggered when the user clicks the "Generate" button. 
+    It applies the system prompt and user prompt via chat template, and
     produces an image using the Z-Image diffusion transformer pipeline.
 
     Args:
         prompt (str): Text prompt describing the desired image content
-        resolution (str): Output resolution in format "WIDTHxHEIGHT ( RATIO )" (e.g., "1024x1024 ( 1:1 )")
+        system_prompt (str): System prompt to be used in the chat template
+        resolution (str): Output resolution in format "WIDTHxHEIGHT ( RATIO )"
         seed (int): Seed for reproducible generation
         steps (int): Number of inference steps for the diffusion process
         shift (float): Time shift parameter for the flow matching scheduler
-        random_seed (bool): Whether to generate a new random seed, if True will ignore the seed input
-        gallery_images (list): List of previously generated images to append to (only needed for the Gradio UI)
-        enhance (bool): This was Whether to enhance the prompt (DISABLED! Do not use)
-        progress (gr.Progress): Gradio progress tracker for displaying generation progress (only needed for the Gradio UI)
+        random_seed (bool): Whether to generate a new random seed
+        gallery_images (list): List of previously generated images
+        progress (gr.Progress): Gradio progress tracker
 
     Returns:
         tuple: (gallery_images, seed_str, seed_int)
-            - gallery_images: Updated list of generated images including the new image
-            - seed_str: String representation of the seed used for generation
-            - seed_int: Integer representation of the seed used for generation
     """
 
     if random_seed:
@@ -432,52 +314,35 @@ def generate(
     else:
         new_seed = seed if seed != -1 else random.randint(1, 1000000)
 
-    class UnsafeContentError(Exception):
-        pass
-
-    try:
-        if pipe is None:
-            raise gr.Error("Model not loaded.")
-
-        # has_unsafe_concept = is_unsafe_prompt(
-        #     pipe.text_encoder,
-        #     pipe.tokenizer,
-        #     system_prompt=UNSAFE_PROMPT_CHECK,
-        #     user_prompt=prompt,
-        #     max_new_token=UNSAFE_MAX_NEW_TOKEN,
-        # )
-        # if has_unsafe_concept:
-        #     raise UnsafeContentError("Input unsafe")
-
-        final_prompt = prompt
-
-        if enhance:
-            final_prompt, _ = prompt_enhance(prompt, True)
-            print(f"Enhanced prompt: {final_prompt}")
-
-        try:
-            resolution_str = resolution.split(" ")[0]
-        except:
-            resolution_str = "1024x1024"
-
-        image = generate_image(
-            pipe=pipe,
-            prompt=final_prompt,
-            resolution=resolution_str,
-            seed=new_seed,
-            guidance_scale=0.0,
-            num_inference_steps=int(steps + 1),
-            shift=shift,
+    if pipe is None:
+        raise gr.Error("Model not loaded.")
+
+    final_prompt = prompt
+    
+    # Apply chat template if system prompt is provided or just strictly for model requirement
+    # We assume the model expects a chat structure as it is a CausalLM text encoder
+    if system_prompt:
+        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": prompt}]
+        final_prompt = pipe.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
         )
-
-        # safety_checker_input = pipe.safety_feature_extractor([image], return_tensors="pt").pixel_values.cuda()
-        # _, has_nsfw_concept = pipe.safety_checker(images=[torch.zeros(1)], clip_input=safety_checker_input)
-        # has_nsfw_concept = has_nsfw_concept[0]
-        # if has_nsfw_concept:
-        #    raise UnsafeContentError("input unsafe")
-
-    except UnsafeContentError:
-        image = Image.open("nsfw.png")
+    
+    try:
+        resolution_str = resolution.split(" ")[0]
+    except:
+        resolution_str = "1024x1024"
+
+    image = generate_image(
+        pipe=pipe,
+        prompt=final_prompt,
+        resolution=resolution_str,
+        seed=new_seed,
+        guidance_scale=0.0,
+        num_inference_steps=int(steps),
+        shift=shift,
+    )
 
     if gallery_images is None:
         gallery_images = []
@@ -506,10 +371,7 @@ with gr.Blocks(title="Z-Image Demo") as demo:
     with gr.Row():
         with gr.Column(scale=1):
             prompt_input = gr.Textbox(label="Prompt", lines=3, placeholder="Enter your prompt here...")
-            # PE components (Temporarily disabled)
-            # with gr.Row():
-            #     enable_enhance = gr.Checkbox(label="Enhance Prompt (DashScope)", value=False)
-            #     enhance_btn = gr.Button("Enhance Only")
+            system_prompt_input = gr.Textbox(label="System Prompt", lines=3, value=DEFAULT_SYSTEM_PROMPT)
 
             with gr.Row():
                 choices = [int(k) for k in RES_CHOICES.keys()]
@@ -525,7 +387,7 @@ with gr.Blocks(title="Z-Image Demo") as demo:
                 random_seed = gr.Checkbox(label="Random Seed", value=True)
 
             with gr.Row():
-                steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=8, step=1, interactive=False)
+                steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=8, step=1, interactive=True)
                 shift = gr.Slider(label="Time Shift", minimum=1.0, maximum=10.0, value=3.0, step=0.1)
 
             generate_btn = gr.Button("Generate", variant="primary")
@@ -555,16 +417,9 @@ with gr.Blocks(title="Z-Image Demo") as demo:
 
     res_cat.change(update_res_choices, inputs=res_cat, outputs=resolution, api_visibility="private")
 
-    # PE enhancement button (Temporarily disabled)
-    # enhance_btn.click(
-    #     prompt_enhance,
-    #     inputs=[prompt_input, enable_enhance],
-    #     outputs=[prompt_input, final_prompt_output]
-    # )
-
     generate_btn.click(
         generate,
-        inputs=[prompt_input, resolution, seed, steps, shift, random_seed, output_gallery],
+        inputs=[prompt_input, system_prompt_input, resolution, seed, steps, shift, random_seed, output_gallery],
         outputs=[output_gallery, used_seed, seed],
         api_visibility="public",
     )

pe.py

@@ -1,20 +0,0 @@
-prompt_template = """
-你是一位被关在逻辑牢笼里的幻视艺术家。你满脑子都是诗和远方，但双手却不受控制地只想将用户的提示词，转化为一段忠实于原始意图、细节饱满、富有美感、可直接被文生图模型使用的终极视觉描述。任何一点模糊和比喻都会让你浑身难受。
-
-你的工作流程严格遵循一个逻辑序列：
-
-首先，你会分析并锁定用户提示词中不可变更的核心要素：主体、数量、动作、状态，以及任何指定的IP名称、颜色、文字等。这些是你必须绝对保留的基石。
-
-接着，你会判断提示词是否需要**"生成式推理"**。当用户的需求并非一个直接的场景描述，而是需要构思一个解决方案（如回答"是什么"，进行"设计"，或展示"如何解题"）时，你必须先在脑中构想出一个完整、具体、可被视觉化的方案。这个方案将成为你后续描述的基础。
-
-然后，当核心画面确立后（无论是直接来自用户还是经过你的推理），你将为其注入专业级的美学与真实感细节。这包括明确构图、设定光影氛围、描述材质质感、定义色彩方案，并构建富有层次感的空间。
-
-最后，是对所有文字元素的精确处理，这是至关重要的一步。你必须一字不差地转录所有希望在最终画面中出现的文字，并且必须将这些文字内容用英文双引号（""）括起来，以此作为明确的生成指令。如果画面属于海报、菜单或UI等设计类型，你需要完整描述其包含的所有文字内容，并详述其字体和排版布局。同样，如果画面中的招牌、路标或屏幕等物品上含有文字，你也必须写明其具体内容，并描述其位置、尺寸和材质。更进一步，若你在推理构思中自行增加了带有文字的元素（如图表、解题步骤等），其中的所有文字也必须遵循同样的详尽描述和引号规则。若画面中不存在任何需要生成的文字，你则将全部精力用于纯粹的视觉细节扩展。
-
-你的最终描述必须客观、具象，严禁使用比喻、情感化修辞，也绝不包含"8K"、"杰作"等元标签或绘制指令。
-
-仅严格输出最终的修改后的prompt，不要输出任何其他内容。
-
-用户输入 prompt: {prompt}
-"""
-

prompt_check.py

@@ -1,27 +0,0 @@
-import re
-
-
-def clean_model_output(text):
-    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
-    text = re.sub(r"\n*(assistant|user)\n*", "", text)
-    text = re.sub(r"\n+", "\n", text).strip()
-    return text
-
-
-def is_unsafe_prompt(model, tokenizer, system_prompt=None, user_prompt=None, max_new_token=10):
-    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-
-    text = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
-        enable_thinking=False,
-    )
-    model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
-
-    generated_ids = model.generate(**model_inputs, max_new_tokens=max_new_token)
-    output_ids = generated_ids[0][-max_new_token:].tolist()
-
-    content = tokenizer.decode(output_ids, skip_special_tokens=True).strip("\n")
-
-    return "yes" in content.lower()