Upload hintgenerate_gemma.py with huggingface_hub

hintgenerate_gemma.py

@@ -0,0 +1,499 @@
+#!/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 inspect
+import os
+import sys
+from typing import Any, Dict, List, Optional
+
+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/"
+
+
+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 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("--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)
+
+    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()