Upload hintgenerate_gemma2.py with huggingface_hub

hintgenerate_gemma2.py

@@ -0,0 +1,1055 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Gemma-based hint generation entrypoint.
+
+This is a dedicated wrapper around `hintgenerate.py` with Gemma-local defaults.
+It keeps the same processing pipeline and most CLI flags, but changes:
+
+1. default `--model-name` to the provided Gemma checkpoint
+2. local HF loader preference for Gemma-family models
+3. default `--workers` to 1 for local inference stability
+
+Example:
+
+python3 hintgenerate_gemma.py \
+  --use-json \
+  --json-path /path/to/editing.json \
+  --image-root /path/to/images \
+  --out-root ./gemma_hint_runs \
+  --grid-mode auto \
+  --model-max-tokens 4096
+"""
+
+import argparse
+import copy
+import inspect
+import io
+import os
+import re
+import sys
+from typing import Any, Dict, List, Optional
+
+import hintgenerate as hg
+
+from hintgenerate import (
+    GATEWAY_BASE_URL,
+    DEFAULT_TIMEOUT,
+    MAX_RETRIES_ENV,
+    GeminiGatewayClient,
+    KeyedRateLimiter,
+    _patch_bitsandbytes_compat,
+    _patch_torch_distributed_tensor_compat,
+    _patch_torch_module_compat,
+    assert_local_openai_server_ready,
+    is_local_model_name,
+    is_local_openai_base_url,
+    logger,
+    resolve_model_name,
+    run_json_mode,
+    run_parquet_mode,
+)
+
+
+GEMMA_MODEL_PATH = "/mnt/bn/yuanpengtu/svgthink/google/gemma-4-31B-it/"
+_GEMMA_REFINE_ROUNDS = 3
+
+
+class GemmaHintClient(GeminiGatewayClient):
+    """
+    Official Gemma 4 local loader.
+
+    Per the official Hugging Face Gemma 4 docs:
+    - processor: AutoProcessor / Gemma4Processor
+    - multimodal model: AutoModelForMultimodalLM
+    """
+
+    def __init__(self, *args, local_processor_path: str = "", local_processor_class: str = "", **kwargs):
+        self.local_processor_path = str(local_processor_path or "").strip()
+        self.local_processor_class = str(local_processor_class or "").strip()
+        self.local_device_map = str(kwargs.pop("local_device_map", "auto") or "auto").strip()
+        self.local_max_memory_per_gpu_gb = kwargs.pop("local_max_memory_per_gpu_gb", None)
+
+        sig = inspect.signature(GeminiGatewayClient.__init__)
+        allowed = set(sig.parameters.keys()) - {"self"}
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k in allowed}
+        super().__init__(*args, **filtered_kwargs)
+
+        # Old hintgenerate.py may not know these attributes.
+        self.local_processor_path = str(local_processor_path or getattr(self, "local_processor_path", "")).strip()
+        self.local_processor_class = str(local_processor_class or getattr(self, "local_processor_class", "")).strip()
+
+    def _select_local_loader_candidates(self, transformers_mod):
+        auto_multimodal = getattr(transformers_mod, "AutoModelForMultimodalLM", None)
+        gemma4_cond = getattr(transformers_mod, "Gemma4ForConditionalGeneration", None)
+        auto_image_text = getattr(transformers_mod, "AutoModelForImageTextToText", None)
+        auto_vision2seq = getattr(transformers_mod, "AutoModelForVision2Seq", None)
+        auto_causal_lm = getattr(transformers_mod, "AutoModelForCausalLM", None)
+        auto_model = getattr(transformers_mod, "AutoModel", None)
+
+        return [
+            loader
+            for loader in (
+                auto_multimodal,
+                gemma4_cond,
+                auto_image_text,
+                auto_vision2seq,
+                auto_causal_lm,
+                auto_model,
+            )
+            if loader is not None
+        ]
+
+    def _get_local_processor_candidates(self, transformers_mod):
+        proc_path = self.local_processor_path or self.model
+        candidates = []
+        seen = set()
+
+        def _push(name: str):
+            if not name or name in seen:
+                return
+            klass = getattr(transformers_mod, name, None)
+            if klass is not None:
+                candidates.append((name, klass, proc_path))
+                seen.add(name)
+
+        if self.local_processor_class:
+            _push(self.local_processor_class)
+
+        for name in ("Gemma4Processor", "AutoProcessor"):
+            _push(name)
+
+        if candidates:
+            return candidates
+        return super()._get_local_processor_candidates(transformers_mod)
+
+    @staticmethod
+    def _load_from_pretrained(factory, path: str, trust_remote_code: bool = True, use_fast: Optional[bool] = None):
+        kwargs: Dict[str, Any] = {}
+        if trust_remote_code:
+            kwargs["trust_remote_code"] = True
+        if use_fast is not None:
+            kwargs["use_fast"] = use_fast
+
+        try:
+            return factory.from_pretrained(path, **kwargs)
+        except TypeError:
+            kwargs.pop("use_fast", None)
+            try:
+                return factory.from_pretrained(path, **kwargs)
+            except TypeError:
+                kwargs.pop("trust_remote_code", None)
+                return factory.from_pretrained(path, **kwargs)
+
+    def _load_local_processor(self, transformers_mod):
+        tried = []
+        for label, factory, path in self._get_local_processor_candidates(transformers_mod):
+            if factory is None or not path:
+                continue
+            try:
+                proc = self._load_from_pretrained(factory, path, trust_remote_code=True, use_fast=None)
+                logger.info(f"Loaded local processor via {label}: path={path}")
+                return proc
+            except Exception as e:
+                tried.append(f"{label}@{path}: {e}")
+
+        dir_snaps = []
+        seen_paths = []
+        for _, _, path in self._get_local_processor_candidates(transformers_mod):
+            if not path or path in seen_paths or not os.path.isdir(path):
+                continue
+            seen_paths.append(path)
+            try:
+                names = sorted(os.listdir(path))
+                if len(names) > 24:
+                    names = names[:24] + ["..."]
+                dir_snaps.append(f"{path}: {names}")
+            except Exception:
+                continue
+
+        detail = "\n".join(f"- {x}" for x in tried) if tried else "- no processor candidates available"
+        snapshot = ("\nDirectory snapshot:\n" + "\n".join(dir_snaps)) if dir_snaps else ""
+        raise RuntimeError(
+            "Failed to load a local processor for official Gemma 4 multimodal inference.\n"
+            f"Tried:\n{detail}{snapshot}\n"
+            "Use the official Gemma 4 path or model id (for example `google/gemma-4-31B-it`) "
+            "with a recent `transformers` version that provides `Gemma4Processor` and "
+            "`AutoModelForMultimodalLM`."
+        )
+
+    def _ensure_local_model_loaded(self):
+        if self._local_load_error is not None:
+            raise self._local_load_error
+
+        if self._local_model is not None and self._processor is not None:
+            return
+
+        with self._local_lock:
+            if self._local_load_error is not None:
+                raise self._local_load_error
+            if self._local_model is not None and self._processor is not None:
+                return
+
+            try:
+                import torch
+                import transformers
+            except Exception as e:
+                raise RuntimeError(
+                    "Local model mode requires torch and transformers to be installed in this environment."
+                ) from e
+
+            self._torch = torch
+            _patch_torch_module_compat(torch)
+            _patch_torch_distributed_tensor_compat(torch)
+
+            if getattr(transformers, "Gemma4Processor", None) is None and getattr(transformers, "AutoProcessor", None) is None:
+                raise RuntimeError(
+                    "This transformers build does not provide Gemma4Processor/AutoProcessor for Gemma 4. "
+                    "Upgrade transformers to a version with official Gemma 4 support."
+                )
+
+            loader_candidates = self._select_local_loader_candidates(transformers)
+            if not loader_candidates:
+                version = getattr(transformers, "__version__", "unknown")
+                raise RuntimeError(
+                    "This transformers build does not provide any usable Gemma 4 model loader "
+                    f"(checked AutoModelForMultimodalLM, Gemma4ForConditionalGeneration, "
+                    f"AutoModelForImageTextToText, AutoModelForVision2Seq, AutoModelForCausalLM, AutoModel). "
+                    f"Current transformers version: {version}. "
+                    "Upgrade transformers to a version with official Gemma 4 support."
+                )
+
+            bits_and_bytes_config = getattr(transformers, "BitsAndBytesConfig", None)
+
+            model_kwargs: Dict[str, Any] = {
+                "trust_remote_code": True,
+                "device_map": self.local_device_map or "auto",
+                "low_cpu_mem_usage": True,
+            }
+
+            if self.local_max_memory_per_gpu_gb:
+                try:
+                    gpu_count = int(torch.cuda.device_count())
+                except Exception:
+                    gpu_count = 0
+                if gpu_count > 0:
+                    per_gpu = f"{int(self.local_max_memory_per_gpu_gb)}GiB"
+                    model_kwargs["max_memory"] = {idx: per_gpu for idx in range(gpu_count)}
+                    model_kwargs["max_memory"]["cpu"] = "256GiB"
+
+            torch_dtype = self._resolve_local_torch_dtype(torch)
+            if torch_dtype is not None:
+                model_kwargs["dtype"] = torch_dtype
+
+            if self.local_load_in_4bit or self.local_load_in_8bit:
+                _patch_bitsandbytes_compat()
+                if bits_and_bytes_config is None:
+                    raise RuntimeError("bitsandbytes support requires a recent transformers installation.")
+                quant_kwargs = {
+                    "load_in_4bit": self.local_load_in_4bit,
+                    "load_in_8bit": self.local_load_in_8bit,
+                }
+                if self.local_cpu_offload:
+                    quant_kwargs["llm_int8_enable_fp32_cpu_offload"] = True
+                if self.local_load_in_4bit:
+                    quant_kwargs["bnb_4bit_compute_dtype"] = torch_dtype or torch.bfloat16
+                    quant_kwargs["bnb_4bit_quant_type"] = "nf4"
+                    quant_kwargs["bnb_4bit_use_double_quant"] = True
+                model_kwargs["quantization_config"] = bits_and_bytes_config(**quant_kwargs)
+                model_kwargs.pop("dtype", None)
+                if self.local_cpu_offload:
+                    offload_dir = self.local_offload_dir or os.path.join(os.getcwd(), ".hf_offload")
+                    os.makedirs(offload_dir, exist_ok=True)
+                    model_kwargs["offload_folder"] = offload_dir
+                    model_kwargs["offload_state_dict"] = True
+
+            self._processor = self._load_local_processor(transformers)
+
+            last_err = None
+            loader_names = [getattr(loader, "__name__", str(loader)) for loader in loader_candidates]
+            logger.info(f"Local loader order: {loader_names}")
+            for loader in loader_candidates:
+                if loader is None:
+                    continue
+                try:
+                    self._local_model = loader.from_pretrained(self.model, **model_kwargs)
+                    break
+                except Exception as e:
+                    last_err = e
+
+            if self._local_model is None:
+                self._local_load_error = last_err or RuntimeError("unknown local model load error")
+                raise RuntimeError(f"Failed to load local model from {self.model}: {last_err}") from last_err
+
+            self._local_model.eval()
+            self._local_load_error = None
+
+            if hasattr(self._local_model, "hf_device_map"):
+                for dev in self._local_model.hf_device_map.values():
+                    if dev not in ("cpu", "disk", "meta"):
+                        if isinstance(dev, int):
+                            dev = f"cuda:{dev}"
+                        self._local_input_device = dev
+                        break
+
+            if self._local_input_device is None:
+                model_device = getattr(self._local_model, "device", None)
+                if model_device is not None:
+                    if isinstance(model_device, int):
+                        model_device = f"cuda:{model_device}"
+                    self._local_input_device = model_device
+
+            gpu_count = 0
+            try:
+                gpu_count = int(torch.cuda.device_count())
+            except Exception:
+                gpu_count = 0
+            logger.info(
+                f"Loaded local HF model: model={self.model} "
+                f"dtype={self.local_dtype} 4bit={self.local_load_in_4bit} 8bit={self.local_load_in_8bit} "
+                f"device_map={self.local_device_map or 'auto'} visible_gpus={gpu_count} "
+                f"cpu_offload={self.local_cpu_offload} offload_dir={self.local_offload_dir or 'auto'}"
+            )
+            if hasattr(self._local_model, "hf_device_map"):
+                logger.info(f"HF device map: {self._local_model.hf_device_map}")
+
+    def _generate_local(self, messages: List[dict], max_tokens: int) -> str:
+        inputs = self._messages_to_local_inputs(messages)
+
+        do_sample = self.temperature > 0
+        generate_kwargs: Dict[str, Any] = {
+            "max_new_tokens": max(64, int(max_tokens)),
+            "use_cache": True,
+            "do_sample": do_sample,
+            "return_dict_in_generate": False,
+        }
+
+        generation_config = copy.deepcopy(getattr(self._local_model, "generation_config", None))
+        if generation_config is not None:
+            for name in ("top_k", "top_p", "typical_p", "min_p", "epsilon_cutoff", "eta_cutoff"):
+                if hasattr(generation_config, name):
+                    setattr(generation_config, name, None)
+            if hasattr(generation_config, "do_sample"):
+                generation_config.do_sample = do_sample
+            if hasattr(generation_config, "temperature"):
+                generation_config.temperature = max(0.01, float(self.temperature)) if do_sample else None
+            generate_kwargs["generation_config"] = generation_config
+
+        if do_sample:
+            generate_kwargs["temperature"] = max(0.01, float(self.temperature))
+        else:
+            generate_kwargs["temperature"] = None
+
+        tokenizer = getattr(self._processor, "tokenizer", None)
+        pad_token_id = getattr(tokenizer, "pad_token_id", None)
+        eos_token_id = getattr(tokenizer, "eos_token_id", None)
+        if pad_token_id is None and eos_token_id is not None:
+            pad_token_id = eos_token_id
+        if pad_token_id is not None:
+            generate_kwargs["pad_token_id"] = pad_token_id
+        if eos_token_id is not None:
+            generate_kwargs["eos_token_id"] = eos_token_id
+
+        with self._torch.inference_mode():
+            output_ids = self._local_model.generate(**inputs, **generate_kwargs)
+
+        input_ids = inputs.get("input_ids") if hasattr(inputs, "get") else None
+        if input_ids is not None and getattr(output_ids, "shape", None) is not None:
+            prompt_len = input_ids.shape[-1]
+            output_ids = output_ids[:, prompt_len:]
+
+        decoded = self._processor.batch_decode(output_ids, skip_special_tokens=True)
+        text = (decoded[0] if decoded else "").strip()
+        if text:
+            return text
+
+        decoded_raw = self._processor.batch_decode(output_ids, skip_special_tokens=False)
+        return (decoded_raw[0] if decoded_raw else "").strip()
+
+
+GEMMA_SYSTEM_PROMPT = """You are a precise SVG hint generator for general image edits.
+
+Your task is to generate an SVG hint that highlights the true edited region between the original image and the edited image.
+
+Rules:
+- Use the ORIGINAL image and EDITED image as the main source of truth.
+- Use the EDGES image only to refine the boundary of a real edited region after comparing the original and edited images.
+- You may also receive an automatically extracted REFERENCE OVERLAY and a REFERENCE CROP. Treat them only as weak localization hints.
+- Ignore obvious registration noise, border artifacts, decorative frame edges, shadows, and repeated texture patterns.
+- Mark the edited region with 1 to 3 concise shapes unless the edit is clearly disconnected.
+- Prefer compact outer contours over noisy scribbles.
+- Do not outline unchanged background structure.
+- Use numeric absolute coordinates in the 0..1000 viewBox. Do not use percentages.
+- Use only <polygon>, <polyline>, or <path>.
+- Do not output <text>, labels, legends, or callout boxes.
+- Return exactly one JSON object with key "svg".
+"""
+
+GEMMA_REFINE_SYSTEM_PROMPT = """You are refining an existing SVG hint for a general image edit.
+
+You will be given:
+1. ORIGINAL image
+2. EDITED image
+3. EDGES image
+4. REFERENCE OVERLAY
+5. REFERENCE CROP
+6. CURRENT HINT OVERLAY
+7. CURRENT SVG text
+
+Refinement rules:
+- Preserve parts of the current hint that already align with the real edited region.
+- Remove strokes that point to unchanged structure, borders, shadows, or decorative elements.
+- If the current hint is badly misplaced, replace it completely with a better compact hint.
+- Use the reference images only as weak localization hints.
+- Use numeric absolute coordinates in the 0..1000 viewBox. Do not use percentages.
+- Use only <polygon>, <polyline>, or <path>.
+- Return exactly one JSON object with key "svg".
+"""
+
+
+def _gemma_extract_reference_regions(mask_u8, topk: int = 3):
+    if mask_u8 is None or getattr(mask_u8, "size", 0) == 0:
+        return []
+
+    cnts, _ = hg.cv2.findContours(mask_u8, hg.cv2.RETR_EXTERNAL, hg.cv2.CHAIN_APPROX_SIMPLE)
+    if not cnts:
+        return []
+
+    h, w = mask_u8.shape[:2]
+    min_area = max(12.0, w * h * 0.00035)
+    regions = []
+    for c in cnts:
+        area = float(hg.cv2.contourArea(c))
+        if area < min_area:
+            continue
+        epsilon = max(2.0, 0.015 * hg.cv2.arcLength(c, True))
+        approx = hg.cv2.approxPolyDP(c, epsilon, True)
+        pts = [(float(pt[0]), float(pt[1])) for pt in approx.reshape(-1, 2)]
+        if len(pts) < 3:
+            x, y, bw, bh = hg.cv2.boundingRect(c)
+            pts = [
+                (float(x), float(y)),
+                (float(x + bw), float(y)),
+                (float(x + bw), float(y + bh)),
+                (float(x), float(y + bh)),
+            ]
+        x, y, bw, bh = hg.cv2.boundingRect(c)
+        regions.append(
+            {
+                "bbox": [int(x), int(y), int(x + bw), int(y + bh)],
+                "area": area,
+                "points": pts,
+            }
+        )
+
+    regions.sort(key=lambda item: item["area"], reverse=True)
+    return regions[: max(1, int(topk))]
+
+
+def _gemma_render_reference_overlay(base_img, regions, size):
+    overlay = base_img.convert("RGBA").resize(size, hg.Image.LANCZOS)
+    draw = hg.ImageDraw.Draw(overlay, "RGBA")
+    for idx, region in enumerate(regions, start=1):
+        pts = region.get("points") or []
+        if len(pts) >= 3:
+            draw.polygon(pts, outline=(255, 196, 0, 255), fill=(255, 196, 0, 36))
+            draw.line(pts + [pts[0]], fill=(255, 196, 0, 255), width=4)
+        bbox = region.get("bbox") or []
+        if len(bbox) == 4:
+            x1, y1, x2, y2 = bbox
+            draw.rectangle((x1, y1, x2, y2), outline=(0, 255, 255, 255), width=2)
+            font = hg._get_font(max(18, int(round(min(size) * 0.035))))
+            draw.text((x1 + 4, max(0, y1 - 24)), f"R{idx}", font=font, fill=(0, 255, 255, 255))
+    return overlay.convert("RGB")
+
+
+def _gemma_build_reference_crop(o_small, e_small, regions, size):
+    w, h = size
+    if regions:
+        x1, y1, x2, y2 = regions[0].get("bbox", [0, 0, w, h])
+    else:
+        x1, y1, x2, y2 = 0, 0, w, h
+
+    pad_x = max(12, int(round((x2 - x1) * 0.18)))
+    pad_y = max(12, int(round((y2 - y1) * 0.18)))
+    cx1 = max(0, x1 - pad_x)
+    cy1 = max(0, y1 - pad_y)
+    cx2 = min(w, x2 + pad_x)
+    cy2 = min(h, y2 + pad_y)
+
+    crop_o = o_small.crop((cx1, cy1, cx2, cy2)).convert("RGBA")
+    crop_e = e_small.crop((cx1, cy1, cx2, cy2)).convert("RGBA")
+    crop_ref = crop_o.copy()
+    draw = hg.ImageDraw.Draw(crop_ref, "RGBA")
+    for idx, region in enumerate(regions, start=1):
+        bbox = region.get("bbox") or []
+        pts = region.get("points") or []
+        adj_pts = []
+        for x, y in pts:
+            xx = float(x) - cx1
+            yy = float(y) - cy1
+            if 0 <= xx <= (cx2 - cx1) and 0 <= yy <= (cy2 - cy1):
+                adj_pts.append((xx, yy))
+        if len(adj_pts) >= 3:
+            draw.polygon(adj_pts, outline=(255, 196, 0, 255), fill=(255, 196, 0, 36))
+            draw.line(adj_pts + [adj_pts[0]], fill=(255, 196, 0, 255), width=4)
+        if len(bbox) == 4:
+            bx1, by1, bx2, by2 = bbox
+            bx1 -= cx1
+            by1 -= cy1
+            bx2 -= cx1
+            by2 -= cy1
+            if bx2 >= 0 and by2 >= 0 and bx1 <= (cx2 - cx1) and by1 <= (cy2 - cy1):
+                draw.rectangle((bx1, by1, bx2, by2), outline=(0, 255, 255, 255), width=2)
+                font = hg._get_font(max(18, int(round(min(crop_ref.size) * 0.06))))
+                draw.text((max(0, bx1 + 4), max(0, by1 - 24)), f"R{idx}", font=font, fill=(0, 255, 255, 255))
+
+    panel = hg.Image.new("RGB", (crop_o.width * 3, crop_o.height), (0, 0, 0))
+    panel.paste(crop_o.convert("RGB"), (0, 0))
+    panel.paste(crop_e.convert("RGB"), (crop_o.width, 0))
+    panel.paste(crop_ref.convert("RGB"), (crop_o.width * 2, 0))
+    return panel
+
+
+def build_gemma_messages(du_o, du_e, du_edges, du_ref_overlay, du_ref_crop, w, h, instruction, regions):
+    ref_text = "none"
+    if regions:
+        items = []
+        for idx, region in enumerate(regions[:3], start=1):
+            bbox = region.get("bbox") or []
+            if len(bbox) == 4:
+                items.append(f"R{idx}=({bbox[0]},{bbox[1]})-({bbox[2]},{bbox[3]})")
+        if items:
+            ref_text = "; ".join(items)
+
+    user_text = (
+        f"Instruction: {instruction}\n"
+        f"Canvas: {w}x{h} pixels.\n"
+        "Inputs:\n"
+        "1. ORIGINAL image\n"
+        "2. EDITED image\n"
+        "3. EDGES image derived from the edited image\n\n"
+        "4. REFERENCE OVERLAY with auto-extracted candidate regions\n"
+        "5. REFERENCE CROP panel: original crop | edited crop | reference overlay crop\n\n"
+        f"Reference regions: {ref_text}\n\n"
+        "Guidelines:\n"
+        "1. Compare ORIGINAL and EDITED first to determine the real semantic edit.\n"
+        "2. Use the EDGES image only to tighten the boundary of a region that is visibly edited in the EDITED image.\n"
+        "3. Use the REFERENCE OVERLAY and REFERENCE CROP only as weak localization hints. If they disagree with the actual visible edit, trust the ORIGINAL and EDITED images.\n"
+        "4. Ignore isolated thin artifacts near image borders or decorative structures unless they are clearly part of the real edit.\n"
+        "5. Produce a compact hint around the real edited region.\n"
+        "6. Use numeric absolute coordinates in the 0..1000 viewBox. Do not use percentages.\n"
+        "7. Return only the JSON object with the svg field.\n"
+    )
+    return [
+        {"role": "system", "content": GEMMA_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image_url", "image_url": {"url": du_o}},
+                {"type": "image_url", "image_url": {"url": du_e}},
+                {"type": "image_url", "image_url": {"url": du_edges}},
+                {"type": "image_url", "image_url": {"url": du_ref_overlay}},
+                {"type": "image_url", "image_url": {"url": du_ref_crop}},
+            ],
+        },
+    ]
+
+
+def build_gemma_refine_messages(
+    du_o,
+    du_e,
+    du_edges,
+    du_ref_overlay,
+    du_ref_crop,
+    du_hint_overlay,
+    w,
+    h,
+    instruction,
+    current_svg,
+    round_idx: int,
+):
+    svg_text = str(current_svg or "").strip()
+    if len(svg_text) > 6000:
+        svg_text = svg_text[:6000]
+
+    user_text = (
+        f"Instruction: {instruction}\n"
+        f"Canvas: {w}x{h} pixels.\n"
+        f"Refinement round: {round_idx}\n\n"
+        "Task:\n"
+        "Refine the CURRENT HINT OVERLAY so it better matches the real edit between ORIGINAL and EDITED.\n\n"
+        "Guidelines:\n"
+        "1. Compare ORIGINAL and EDITED first.\n"
+        "2. Inspect CURRENT HINT OVERLAY and identify wrong strokes or missing coverage.\n"
+        "3. Use EDGES only to tighten a boundary that is visibly part of the edit.\n"
+        "4. Use REFERENCE OVERLAY and REFERENCE CROP only as weak hints.\n"
+        "5. Output a complete corrected SVG, not a delta.\n"
+        "6. Use numeric absolute coordinates in the 0..1000 viewBox. Do not use percentages.\n\n"
+        f"Current SVG candidate:\n{svg_text}"
+    )
+    return [
+        {"role": "system", "content": GEMMA_REFINE_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image_url", "image_url": {"url": du_o}},
+                {"type": "image_url", "image_url": {"url": du_e}},
+                {"type": "image_url", "image_url": {"url": du_edges}},
+                {"type": "image_url", "image_url": {"url": du_ref_overlay}},
+                {"type": "image_url", "image_url": {"url": du_ref_crop}},
+                {"type": "image_url", "image_url": {"url": du_hint_overlay}},
+            ],
+        },
+    ]
+
+
+def _gemma_filter_shapes(shapes: List[dict]) -> List[dict]:
+    return [s for s in (shapes or []) if s.get("type") != "text"]
+
+
+def _gemma_parse_shapes_safe(svg_raw: str, w: int, h: int) -> List[dict]:
+    if not svg_raw:
+        return []
+    try:
+        return _gemma_filter_shapes(hg._parse_svg_shapes(svg_raw, w, h))
+    except Exception:
+        return []
+
+
+def _gemma_shapes_mask(shapes: List[dict], w: int, h: int):
+    canvas = hg.Image.new("L", (w, h), 0)
+    draw = hg.ImageDraw.Draw(canvas)
+    line_w = max(4, int(round(min(w, h) * 0.01)))
+    for s in shapes:
+        t = str(s.get("type") or "")
+        if t in ("polygon", "polyline"):
+            pts = [(float(x), float(y)) for x, y in (s.get("points") or [])]
+            if len(pts) >= 3:
+                draw.polygon(pts, fill=255)
+                draw.line(pts + [pts[0]], fill=255, width=line_w)
+            elif len(pts) >= 2:
+                draw.line(pts, fill=255, width=line_w)
+    return hg.np.array(canvas, dtype=hg.np.uint8)
+
+
+def _gemma_mask_bbox(mask_arr) -> Optional[List[int]]:
+    ys, xs = hg.np.where(mask_arr > 0)
+    if len(xs) == 0 or len(ys) == 0:
+        return None
+    return [int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max())]
+
+
+def _gemma_bbox_iou(a: Optional[List[int]], b: Optional[List[int]]) -> float:
+    if not a or not b:
+        return 0.0
+    ax1, ay1, ax2, ay2 = a
+    bx1, by1, bx2, by2 = b
+    ix1 = max(ax1, bx1)
+    iy1 = max(ay1, by1)
+    ix2 = min(ax2, bx2)
+    iy2 = min(ay2, by2)
+    iw = max(0, ix2 - ix1 + 1)
+    ih = max(0, iy2 - iy1 + 1)
+    inter = iw * ih
+    if inter <= 0:
+        return 0.0
+    area_a = max(1, (ax2 - ax1 + 1) * (ay2 - ay1 + 1))
+    area_b = max(1, (bx2 - bx1 + 1) * (by2 - by1 + 1))
+    return float(inter) / float(max(1, area_a + area_b - inter))
+
+
+def _gemma_score_shapes(shapes: List[dict], reference_mask_u8, w: int, h: int) -> float:
+    if not shapes:
+        return -1.0
+    pred_mask = _gemma_shapes_mask(shapes, w, h) > 0
+    ref_mask = reference_mask_u8 > 0
+    pred_area = int(pred_mask.sum())
+    ref_area = int(ref_mask.sum())
+    if pred_area <= 0 or ref_area <= 0:
+        return -1.0
+    inter = int((pred_mask & ref_mask).sum())
+    precision = float(inter) / float(max(1, pred_area))
+    recall = float(inter) / float(max(1, ref_area))
+    f1 = 0.0 if (precision + recall) <= 0 else (2.0 * precision * recall / (precision + recall))
+    pred_bbox = _gemma_mask_bbox(pred_mask)
+    ref_bbox = _gemma_mask_bbox(ref_mask)
+    bbox_iou = _gemma_bbox_iou(pred_bbox, ref_bbox)
+    total_points = sum(len(s.get("points") or []) for s in shapes)
+    complexity_penalty = max(0, len(shapes) - 4) * 0.03 + max(0, total_points - 180) * 0.0004
+    return (0.65 * f1) + (0.20 * precision) + (0.15 * bbox_iou) - complexity_penalty
+
+
+def _process_row_gemma(
+    client: GeminiGatewayClient,
+    row,
+    out_dir: str,
+    idx_tag: str,
+    max_side_start: int,
+    grid_mode: str = "auto",
+    grid_cell: int = 64,
+    stroke_width: int = 5,
+    label_scale: float = 0.045,
+    verify: bool = False,
+    verify_threshold: float = 0.65,
+    reject_dir: Optional[str] = None,
+    roi_topk: int = 5,
+    model_max_tokens: int = 4096,
+):
+    sid = str(getattr(row, "image_id", idx_tag))
+    sid = re.sub(r"[^A-Za-z0-9._-]+", "", sid)
+
+    os.makedirs(out_dir, exist_ok=True)
+    png_path = os.path.join(out_dir, f"hints_{sid}.png")
+    html_path = os.path.join(out_dir, f"hints_{sid}.html")
+
+    try:
+        in_cell = getattr(row, "image_file", None)
+        tgt_cell = getattr(row, "edited_file", None)
+        o_bytes = hg._bytes_from_cell(in_cell)
+        e_bytes = hg._bytes_from_cell(tgt_cell)
+        o_img = hg.Image.open(io.BytesIO(o_bytes)).convert("RGBA")
+        e_img = hg.Image.open(io.BytesIO(e_bytes)).convert("RGBA")
+    except Exception as e:
+        logger.error(f"[{sid}] 图像加载失败: {e}")
+        return
+
+    w0, h0 = o_img.size
+    du_o, du_e, (wc, hc) = hg.make_adaptive_payload(
+        o_img,
+        e_img,
+        max_side_start=max_side_start,
+        with_grid=(grid_mode != "off"),
+        grid_cell=grid_cell,
+    )
+
+    o_small = o_img.resize((wc, hc), hg.Image.LANCZOS)
+    e_small = e_img.resize((wc, hc), hg.Image.LANCZOS)
+    mask_u8, _diff_img, e_aligned = hg._make_diff_precise(o_small, e_small, (wc, hc))
+    edges_img = hg._make_edges(e_aligned, (wc, hc))
+    ref_regions = _gemma_extract_reference_regions(mask_u8, topk=max(1, min(roi_topk, 3)))
+    ref_overlay = _gemma_render_reference_overlay(o_small, ref_regions, (wc, hc))
+    ref_crop = _gemma_build_reference_crop(o_small, e_small, ref_regions, (wc, hc))
+
+    du_edges = hg._to_data_url(hg._encode_jpeg(edges_img, 65))
+    du_ref_overlay = hg._to_data_url(hg._encode_jpeg(ref_overlay, 80))
+    du_ref_crop = hg._to_data_url(hg._encode_jpeg(ref_crop, 82))
+
+    instr = getattr(row, "edit_instruction", "") or ""
+    msgs = build_gemma_messages(du_o, du_e, du_edges, du_ref_overlay, du_ref_crop, wc, hc, instr, ref_regions)
+
+    out = client.chat_force_svg_html(msgs, max_tokens=model_max_tokens)
+    raw_resp = (out.get("raw") or "").strip()
+    mode = out.get("mode", "unknown")
+
+    if not raw_resp:
+        logger.error(f"[{sid}] 模型返回为空，跳过该任务。")
+        return
+
+    svg_raw, _ = hg._extract_svg_or_html_from_raw(raw_resp)
+    if not svg_raw and hg._looks_like_svg_payload(raw_resp):
+        svg_raw = raw_resp
+
+    if not svg_raw:
+        logger.error(f"[{sid}] 未找到有效的 SVG 负载 (mode={mode})。")
+        hg._save_raw_fail(out_dir, sid, raw_resp, f"nopayload_{mode}")
+        return
+
+    current_svg = svg_raw
+    current_shapes_small = _gemma_parse_shapes_safe(current_svg, wc, hc)
+    if not current_shapes_small:
+        logger.warning(f"[{sid}] 解析成功但未找到任何形状。")
+        hg._save_raw_fail(out_dir, sid, raw_resp, f"noshapes_{mode}")
+        return
+    current_score = _gemma_score_shapes(current_shapes_small, mask_u8, wc, hc)
+    logger.info(f"[{sid}] 初始 hint score={current_score:.4f}")
+
+    for round_idx in range(1, int(max(0, _GEMMA_REFINE_ROUNDS)) + 1):
+        hint_overlay_small = hg._render_hint_preview(e_small, current_shapes_small, stroke_width, label_scale)
+        du_hint_overlay = hg._to_data_url(hg._encode_jpeg(hint_overlay_small.convert("RGB"), 82))
+        refine_msgs = build_gemma_refine_messages(
+            du_o=du_o,
+            du_e=du_e,
+            du_edges=du_edges,
+            du_ref_overlay=du_ref_overlay,
+            du_ref_crop=du_ref_crop,
+            du_hint_overlay=du_hint_overlay,
+            w=wc,
+            h=hc,
+            instruction=instr,
+            current_svg=current_svg,
+            round_idx=round_idx,
+        )
+        refine_out = client.chat_force_svg_html(refine_msgs, max_tokens=model_max_tokens)
+        refine_raw = (refine_out.get("raw") or "").strip()
+        if not refine_raw:
+            continue
+        refine_svg, _ = hg._extract_svg_or_html_from_raw(refine_raw)
+        if not refine_svg and hg._looks_like_svg_payload(refine_raw):
+            refine_svg = refine_raw
+        if not refine_svg:
+            logger.info(f"[{sid}] refine round {round_idx}: no valid svg payload")
+            continue
+        refine_shapes_small = _gemma_parse_shapes_safe(refine_svg, wc, hc)
+        if not refine_shapes_small:
+            logger.info(f"[{sid}] refine round {round_idx}: parse yielded no shapes")
+            continue
+        refine_score = _gemma_score_shapes(refine_shapes_small, mask_u8, wc, hc)
+        if refine_score > current_score:
+            current_svg = refine_svg
+            current_shapes_small = refine_shapes_small
+            current_score = refine_score
+            logger.info(f"[{sid}] refine round {round_idx}: accepted score={current_score:.4f}")
+        else:
+            logger.info(
+                f"[{sid}] refine round {round_idx}: rejected candidate score={refine_score:.4f} "
+                f"<= current={current_score:.4f}"
+            )
+
+    scaled_shapes = _gemma_parse_shapes_safe(current_svg, w0, h0)
+    if not scaled_shapes:
+        logger.error(f"[{sid}] 最终 refined SVG 在原图尺度下解析失败。")
+        hg._save_raw_fail(out_dir, sid, current_svg, f"refinefail_{mode}")
+        return
+
+    hint_overlay_img_mem = hg._render_hint_preview(o_img, scaled_shapes, stroke_width, label_scale)
+    hg._draw_shapes_on_image(
+        base_img=o_img,
+        shapes=scaled_shapes,
+        out_path=png_path,
+        stroke_width=stroke_width,
+        label_scale=label_scale,
+    )
+
+    svg_clean = hg._shapes_to_svg(scaled_shapes, w0, h0)
+    du_orig_full = hg._to_data_url(hg._encode_jpeg(o_img.convert("RGB"), 85))
+    final_html = hg._build_overlay_html(du_orig_full, svg_clean, w0, h0)
+    with open(html_path, "w", encoding="utf-8") as f:
+        f.write(final_html)
+
+    if verify:
+        verdict = hg.verify_hint_with_model(
+            client=client,
+            o_img=o_img,
+            e_img=e_img,
+            hint_overlay_img=hint_overlay_img_mem,
+            max_side=1024,
+            max_tokens=700,
+        )
+        ok = bool(verdict.get("ok", False))
+        score = float(verdict.get("score", 0.0) or 0.0)
+        if (not ok) or (score < float(verify_threshold)):
+            logger.warning(f"[{sid}] 验证未通过 (Score: {score})，移动至 reject 目录。")
+            target_reject_dir = reject_dir or os.path.join(out_dir, "_reject")
+            os.makedirs(target_reject_dir, exist_ok=True)
+            try:
+                os.rename(png_path, os.path.join(target_reject_dir, f"hints_{sid}.png"))
+            except Exception:
+                pass
+            try:
+                os.rename(html_path, os.path.join(target_reject_dir, f"hints_{sid}.html"))
+            except Exception:
+                pass
+
+    logger.info(f"[{sid}] 任务完成：{png_path} final_score={current_score:.4f}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--use-json", action="store_true")
+    parser.add_argument("--json-path", default="", help="Path to editing.json")
+    parser.add_argument("--image-root", default="", help="Root for json images")
+    parser.add_argument("--data-dir", default="", help="Dir with parquets")
+    parser.add_argument(
+        "--base-url",
+        default=GATEWAY_BASE_URL,
+        help="OpenAI-compatible API base URL for remote gateways or local /v1 servers.",
+    )
+    parser.add_argument(
+        "--force-api",
+        action="store_true",
+        help="Treat --model-name as an API model id even if it looks like a local path.",
+    )
+
+    parser.add_argument("--out-root", default="./gemma_hint_runs")
+    parser.add_argument("--max-side-start", type=int, default=480)
+    parser.add_argument("--limit-rows", type=int, default=None)
+    parser.add_argument("--rpm", type=int, default=1200)
+    parser.add_argument("--workers", type=int, default=1)
+    parser.add_argument("--grid-mode", default="auto", choices=["auto", "off"])
+    parser.add_argument("--grid-cell", type=int, default=64)
+
+    parser.add_argument("--stroke-width", type=int, default=6)
+    parser.add_argument("--label-scale", type=float, default=0.050)
+
+    parser.add_argument("--roi-topk", type=int, default=5)
+    parser.add_argument("--model-max-tokens", type=int, default=4096)
+    parser.add_argument("--refine-rounds", type=int, default=3)
+
+    parser.add_argument("--verify", action="store_true")
+    parser.add_argument("--verify-threshold", type=float, default=0.3)
+
+    parser.add_argument("--log-missing", action="store_true")
+
+    parser.add_argument(
+        "--model-name",
+        default=os.environ.get("GEMMA_HINT_MODEL", GEMMA_MODEL_PATH),
+        help="Gemma checkpoint path or remote model id.",
+    )
+    parser.add_argument(
+        "--local-model-dtype",
+        default=os.environ.get("LOCAL_MODEL_DTYPE", "bfloat16"),
+        help="Torch dtype for local HF loading: auto, bfloat16, float16, float32",
+    )
+    parser.add_argument("--local-load-in-4bit", action="store_true")
+    parser.add_argument("--local-load-in-8bit", action="store_true")
+    parser.add_argument("--local-offload-dir", default="")
+    parser.add_argument(
+        "--local-device-map",
+        default=os.environ.get("LOCAL_DEVICE_MAP", "auto"),
+        help="HF device_map for local model loading, e.g. auto, balanced, balanced_low_0, sequential.",
+    )
+    parser.add_argument(
+        "--local-max-memory-per-gpu-gb",
+        type=int,
+        default=None,
+        help="Optional per-GPU max memory budget in GiB when using multi-GPU sharding.",
+    )
+    parser.add_argument(
+        "--local-processor-path",
+        default=os.environ.get("GEMMA_HINT_PROCESSOR_PATH", ""),
+        help="Optional directory containing tokenizer/processor files if they are separate from model weights.",
+    )
+    parser.add_argument(
+        "--local-processor-class",
+        default=os.environ.get("GEMMA_HINT_PROCESSOR_CLASS", ""),
+        help="Optional explicit processor class name, e.g. Gemma3Processor or PaliGemmaProcessor.",
+    )
+    parser.add_argument("--temperature", type=float, default=0.2)
+    parser.add_argument("--no-stop", action="store_true")
+
+    parser.add_argument("--session", action="store_true")
+    parser.add_argument("--session-keep-turns", type=int, default=4)
+
+    parser.add_argument(
+        "--keys",
+        nargs="+",
+        default=[],
+        help="API keys for gateway usage. Ignored in local model mode.",
+    )
+    return parser
+
+
+def build_client_pool(args) -> List[GemmaHintClient]:
+    model_name = resolve_model_name(args.model_name)
+    use_local_model = is_local_model_name(model_name) and (not args.force_api)
+    use_local_openai_server = (not use_local_model) and is_local_openai_base_url(args.base_url)
+
+    if args.force_api and (args.local_load_in_4bit or args.local_load_in_8bit):
+        raise RuntimeError("--force-api cannot be used together with --local-load-in-4bit/--local-load-in-8bit")
+    if args.local_load_in_4bit and args.local_load_in_8bit:
+        raise RuntimeError("Use at most one of --local-load-in-4bit / --local-load-in-8bit")
+    if use_local_model and not os.path.isdir(model_name):
+        raise RuntimeError(f"Local model path does not exist or is not a directory: {model_name}")
+    if use_local_model and (args.local_load_in_4bit or args.local_load_in_8bit):
+        if not args.local_offload_dir:
+            args.local_offload_dir = os.path.join(args.out_root, "_hf_offload")
+        os.makedirs(args.local_offload_dir, exist_ok=True)
+
+    keys: List[str] = []
+    limiter: Optional[KeyedRateLimiter] = None
+    if not use_local_model:
+        keys = args.keys or []
+        if not keys:
+            env_keys = os.environ.get("GPT_KEYS", "").strip()
+            if env_keys:
+                keys = [k.strip() for k in env_keys.split(",") if k.strip()]
+        if not keys and not use_local_openai_server:
+            raise RuntimeError("No API keys provided. Use --keys or set GPT_KEYS.")
+        if keys:
+            limiter = KeyedRateLimiter(rpm_per_key=args.rpm, keys=keys)
+        elif use_local_openai_server:
+            logger.warning(f"Using local OpenAI-compatible server without API key: base_url={args.base_url}")
+            assert_local_openai_server_ready(args.base_url)
+
+    num_workers = int(max(1, args.workers))
+    if use_local_model and num_workers != 1:
+        logger.warning("Local Gemma backend detected; forcing workers=1.")
+        num_workers = 1
+        args.workers = 1
+
+    clients: List[GemmaHintClient] = []
+    for i in range(num_workers):
+        api_key = keys[i % len(keys)] if keys else ""
+        clients.append(
+            GemmaHintClient(
+                api_key=api_key,
+                limiter=limiter,
+                base_url=args.base_url,
+                model=model_name,
+                timeout=DEFAULT_TIMEOUT,
+                max_retries=MAX_RETRIES_ENV,
+                temperature=args.temperature,
+                local_dtype=args.local_model_dtype,
+                local_load_in_4bit=args.local_load_in_4bit,
+                local_load_in_8bit=args.local_load_in_8bit,
+                local_cpu_offload=(args.local_load_in_4bit or args.local_load_in_8bit),
+                local_offload_dir=args.local_offload_dir,
+                local_device_map=args.local_device_map,
+                local_max_memory_per_gpu_gb=args.local_max_memory_per_gpu_gb,
+                local_processor_path=args.local_processor_path,
+                local_processor_class=args.local_processor_class,
+                force_api=args.force_api,
+                enable_stop=(not args.no_stop),
+                session_mode=args.session,
+                session_keep_turns=args.session_keep_turns,
+            )
+        )
+    args.model_name = model_name
+    return clients
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    logger.remove()
+    logger.add(sys.stderr, level="INFO")
+    os.makedirs(args.out_root, exist_ok=True)
+
+    global _GEMMA_REFINE_ROUNDS
+    _GEMMA_REFINE_ROUNDS = int(max(0, args.refine_rounds))
+
+    hg.SYSTEM_PROMPT = GEMMA_SYSTEM_PROMPT
+    hg.build_messages = build_gemma_messages
+    hg.process_row = _process_row_gemma
+
+    clients = build_client_pool(args)
+    use_local_model = is_local_model_name(args.model_name) and (not args.force_api)
+    backend = "local_hf" if use_local_model else "api"
+
+    if args.use_json or (args.json_path and os.path.isfile(args.json_path)):
+        if not args.json_path or not args.image_root:
+            raise RuntimeError("JSON mode requires --json-path and --image-root")
+        logger.info(
+            f"Running Gemma hint generation in JSON mode... "
+            f"backend={backend} workers={args.workers} model={args.model_name}"
+        )
+        run_json_mode(args, clients)
+        return
+
+    if not args.data_dir:
+        raise RuntimeError("Parquet mode requires --data-dir")
+    logger.info(
+        f"Running Gemma hint generation in Parquet mode... "
+        f"backend={backend} workers={args.workers} model={args.model_name}"
+    )
+    run_parquet_mode(args, clients)
+
+
+if __name__ == "__main__":
+    main()