Test push of gemma4-mtp.py for hf jobs run smoke test

gemma4-mtp.py

@@ -0,0 +1,571 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "hf-xet",
+#     "torch",
+#     "vllm",
+# ]
+#
+# ///
+"""
+Batch generation with Google Gemma 4 + Multi-Token Prediction (MTP).
+
+Wraps the vLLM serving recipe from https://recipes.vllm.ai/Google/gemma-4-26B-A4B-it
+into a batch-style UV script. Defaults pin to the recipe:
+
+  - main model:   google/gemma-4-26B-A4B-it (MoE, 26B with A4B activated)
+  - draft model:  google/gemma-4-26B-A4B-it-assistant
+  - num_speculative_tokens: 4
+
+MTP gives up to 3x faster decoding with zero quality degradation by using the
+small "assistant" draft model to predict multiple tokens per step.
+
+This script is designed for HF Jobs with the custom Day-0 image:
+    --image vllm/vllm-openai:gemma4-0505-cu129
+The image bakes in vLLM with Gemma 4 + MTP support and CUDA 12.9.
+
+Hardware: 1x A100/H100 (BF16). The 26B MoE model needs ~50 GB at 0.90 GPU mem util.
+
+Pipeline (mirrors generate-responses-chunked.py):
+  load_dataset(streaming=True) -> .map(generate_fn, batched=True) -> .push_to_hub()
+
+Example usage:
+    # HF Jobs run (the supported execution path)
+    hf jobs uv run \\
+        --flavor a100-large \\
+        --image vllm/vllm-openai:gemma4-0505-cu129 \\
+        -s HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/vllm/raw/main/gemma4-mtp.py \\
+        username/input-dataset \\
+        username/output-dataset \\
+        --prompt-column question \\
+        --max-tokens 1024
+
+    # A/B speedup measurement: same dataset, with and without MTP
+    ... gemma4-mtp.py ... --max-samples 50 --max-tokens 512
+    ... gemma4-mtp.py ... --max-samples 50 --max-tokens 512 --disable-mtp
+"""
+
+import argparse
+import logging
+import os
+import sys
+from datetime import datetime
+from typing import Optional
+
+from datasets import Features, Value, load_dataset
+from huggingface_hub import DatasetCard, get_token, login
+from torch import cuda
+from vllm import LLM, SamplingParams
+
+os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL_ID = "google/gemma-4-26B-A4B-it"
+DEFAULT_DRAFT_MODEL_ID = "google/gemma-4-26B-A4B-it-assistant"
+DEFAULT_NUM_SPEC_TOKENS = 4
+
+
+def check_gpu_availability() -> int:
+    """Check if CUDA is available and return the number of GPUs."""
+    if not cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error(
+            "Please run on a machine with NVIDIA GPU or use HF Jobs with GPU flavor."
+        )
+        sys.exit(1)
+
+    num_gpus = cuda.device_count()
+    for i in range(num_gpus):
+        gpu_name = cuda.get_device_name(i)
+        gpu_memory = cuda.get_device_properties(i).total_memory / 1024**3
+        logger.info(f"GPU {i}: {gpu_name} with {gpu_memory:.1f} GB memory")
+
+    return num_gpus
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model_id: str,
+    draft_model_id: Optional[str],
+    num_speculative_tokens: int,
+    mtp_enabled: bool,
+    messages_column: str,
+    prompt_column: Optional[str],
+    sampling_params: SamplingParams,
+    tensor_parallel_size: int,
+    num_processed: int,
+    num_batches: int,
+    generation_time: str,
+    chunk_size: int,
+    split: str,
+    max_model_len_used: Optional[int] = None,
+) -> str:
+    """Dataset card recording MTP config alongside the usual generation metadata."""
+    mtp_section = (
+        f"""
+### Multi-Token Prediction (MTP)
+
+- **MTP Enabled**: yes
+- **Draft Model**: [{draft_model_id}](https://huggingface.co/{draft_model_id})
+- **Speculative Tokens**: {num_speculative_tokens}
+
+MTP uses a small "assistant" draft model to predict multiple tokens per step,
+giving up to 3x faster decoding with zero quality degradation. Recipe:
+https://recipes.vllm.ai/Google/gemma-4-26B-A4B-it
+"""
+        if mtp_enabled
+        else """
+### Multi-Token Prediction (MTP)
+
+- **MTP Enabled**: no (`--disable-mtp` was set)
+"""
+    )
+
+    return f"""---
+tags:
+- generated
+- vllm
+- uv-script
+- gemma-4
+- multi-token-prediction
+---
+
+# Generated Responses Dataset (Gemma 4 + MTP)
+
+This dataset contains generated responses for prompts from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}),
+produced with Google Gemma 4 and vLLM's Multi-Token Prediction support.
+
+## Generation Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Source Split**: `{split}`
+- **Input Column**: `{prompt_column if prompt_column else messages_column}` ({"plain text prompts" if prompt_column else "chat messages"})
+- **Model**: [{model_id}](https://huggingface.co/{model_id})
+- **Rows Processed**: {num_processed:,}
+- **Batches**: {num_batches:,} (chunk size: {chunk_size:,})
+- **Generation Date**: {generation_time}
+- **Script**: `gemma4-mtp.py`
+{mtp_section}
+### Sampling Parameters
+
+- **Temperature**: {sampling_params.temperature}
+- **Top P**: {sampling_params.top_p}
+- **Top K**: {sampling_params.top_k}
+- **Min P**: {sampling_params.min_p}
+- **Max Tokens**: {sampling_params.max_tokens}
+- **Repetition Penalty**: {sampling_params.repetition_penalty}
+
+### Hardware Configuration
+
+- **Tensor Parallel Size**: {tensor_parallel_size}
+- **GPU Configuration**: {tensor_parallel_size} GPU(s)
+{f"- **Max Model Length**: {max_model_len_used:,} tokens" if max_model_len_used else ""}
+
+## Reproduce
+
+```bash
+hf jobs uv run \\
+    --flavor a100-large \\
+    --image vllm/vllm-openai:gemma4-0505-cu129 \\
+    -s HF_TOKEN \\
+    https://huggingface.co/datasets/uv-scripts/vllm/raw/main/gemma4-mtp.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    {"--prompt-column " + prompt_column if prompt_column else "--messages-column " + messages_column} \\
+    --split {split} \\
+    --chunk-size {chunk_size} \\
+    --temperature {sampling_params.temperature} \\
+    --top-p {sampling_params.top_p} \\
+    --max-tokens {sampling_params.max_tokens}{f" --max-model-len {max_model_len_used}" if max_model_len_used else ""}
+```
+"""
+
+
+def main(
+    src_dataset_hub_id: str,
+    output_dataset_hub_id: str,
+    model_id: str = DEFAULT_MODEL_ID,
+    draft_model_id: str = DEFAULT_DRAFT_MODEL_ID,
+    num_speculative_tokens: int = DEFAULT_NUM_SPEC_TOKENS,
+    disable_mtp: bool = False,
+    messages_column: str = "messages",
+    prompt_column: Optional[str] = None,
+    output_column: str = "response",
+    split: str = "train",
+    chunk_size: int = 500,
+    temperature: float = 0.7,
+    top_p: float = 0.95,
+    top_k: int = -1,
+    min_p: float = 0.0,
+    max_tokens: int = 2048,
+    repetition_penalty: float = 1.0,
+    gpu_memory_utilization: float = 0.90,
+    max_model_len: int = 16384,
+    tensor_parallel_size: Optional[int] = None,
+    max_samples: Optional[int] = None,
+    hf_token: Optional[str] = None,
+):
+    generation_start_time = datetime.now().isoformat()
+
+    num_gpus = check_gpu_availability()
+    if tensor_parallel_size is None:
+        tensor_parallel_size = num_gpus
+        logger.info(
+            f"Auto-detected {num_gpus} GPU(s), using tensor_parallel_size={tensor_parallel_size}"
+        )
+    else:
+        logger.info(f"Using specified tensor_parallel_size={tensor_parallel_size}")
+        if tensor_parallel_size > num_gpus:
+            logger.warning(
+                f"Requested {tensor_parallel_size} GPUs but only {num_gpus} available"
+            )
+
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN") or get_token()
+    if not HF_TOKEN:
+        logger.error("No HuggingFace token found. Please provide token via:")
+        logger.error("  1. --hf-token argument")
+        logger.error("  2. HF_TOKEN environment variable")
+        logger.error("  3. Run 'huggingface-cli login' or use login() in Python")
+        sys.exit(1)
+
+    logger.info("HuggingFace token found, authenticating...")
+    login(token=HF_TOKEN)
+
+    mtp_enabled = not disable_mtp
+    if mtp_enabled:
+        logger.info("=" * 60)
+        logger.info("MTP ENABLED")
+        logger.info(f"  draft model:        {draft_model_id}")
+        logger.info(f"  speculative tokens: {num_speculative_tokens}")
+        logger.info("=" * 60)
+    else:
+        logger.info("MTP disabled (--disable-mtp). Running plain decoding for A/B baseline.")
+
+    logger.info(f"Loading model: {model_id}")
+    vllm_kwargs = {
+        "model": model_id,
+        "tensor_parallel_size": tensor_parallel_size,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+    }
+    if mtp_enabled:
+        vllm_kwargs["speculative_config"] = {
+            "model": draft_model_id,
+            "num_speculative_tokens": num_speculative_tokens,
+        }
+
+    llm = LLM(**vllm_kwargs)
+
+    sampling_params = SamplingParams(
+        temperature=temperature,
+        top_p=top_p,
+        top_k=top_k,
+        min_p=min_p,
+        max_tokens=max_tokens,
+        repetition_penalty=repetition_penalty,
+    )
+
+    use_messages = prompt_column is None
+    input_column = messages_column if use_messages else prompt_column
+    logger.info(
+        f"Using {'messages' if use_messages else 'prompt'} column: '{input_column}'"
+    )
+
+    counters = {"rows": 0, "batches": 0}
+
+    def generate_responses(batch):
+        batch_num = counters["batches"] + 1
+        batch_rows = len(batch[input_column])
+        logger.info(
+            f"Processing batch {batch_num} ({batch_rows} rows, "
+            f"total so far: {counters['rows']:,})..."
+        )
+
+        if use_messages:
+            messages_list = batch[input_column]
+        else:
+            messages_list = [
+                [{"role": "user", "content": p}] for p in batch[input_column]
+            ]
+
+        try:
+            outputs = llm.chat(messages=messages_list, sampling_params=sampling_params)
+            batch[output_column] = [o.outputs[0].text.strip() for o in outputs]
+        except Exception:
+            logger.exception(f"Error in batch {batch_num}, filling with empty strings")
+            batch[output_column] = [""] * batch_rows
+
+        counters["rows"] += batch_rows
+        counters["batches"] += 1
+        logger.info(
+            f"Batch {batch_num} complete. Total rows processed: {counters['rows']:,}"
+        )
+        return batch
+
+    logger.info(
+        f"Loading dataset: {src_dataset_hub_id} (split={split}, streaming=True)"
+    )
+    ds = load_dataset(src_dataset_hub_id, split=split, streaming=True)
+
+    # Resolve features upfront — .take()/.map() can drop them, and
+    # IterableDataset.push_to_hub() crashes on .features=None.
+    ds_info = load_dataset(src_dataset_hub_id, split=split, streaming=True)
+    source_features = ds_info.features
+    if source_features is None:
+        logger.info("Features not available, peeking at first row to infer schema...")
+        first = next(iter(ds_info))
+        source_features = Features({k: Value("string") for k in first.keys()})
+    output_features = Features({**source_features, output_column: Value("string")})
+    logger.info(f"Dataset features: {list(output_features.keys())}")
+
+    if max_samples is not None:
+        logger.info(f"Limiting to {max_samples} samples")
+        ds = ds.take(max_samples)
+
+    logger.info(f"Setting up streaming pipeline (chunk_size={chunk_size})...")
+    ds = ds.map(generate_responses, batched=True, batch_size=chunk_size)
+    ds = ds.cast(output_features)
+
+    logger.info(f"Starting push_to_hub to: {output_dataset_hub_id}")
+    ds.push_to_hub(output_dataset_hub_id, token=HF_TOKEN)
+
+    logger.info(
+        f"Push complete! Processed {counters['rows']:,} rows in {counters['batches']} batches."
+    )
+
+    logger.info("Creating and pushing dataset card...")
+    card_content = create_dataset_card(
+        source_dataset=src_dataset_hub_id,
+        model_id=model_id,
+        draft_model_id=draft_model_id if mtp_enabled else None,
+        num_speculative_tokens=num_speculative_tokens,
+        mtp_enabled=mtp_enabled,
+        messages_column=messages_column,
+        prompt_column=prompt_column,
+        sampling_params=sampling_params,
+        tensor_parallel_size=tensor_parallel_size,
+        num_processed=counters["rows"],
+        num_batches=counters["batches"],
+        generation_time=generation_start_time,
+        chunk_size=chunk_size,
+        split=split,
+        max_model_len_used=max_model_len,
+    )
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset_hub_id, token=HF_TOKEN)
+
+    logger.info("Done!")
+    logger.info(f"Dataset: https://huggingface.co/datasets/{output_dataset_hub_id}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        parser = argparse.ArgumentParser(
+            description="Batch generation with Gemma 4 + Multi-Token Prediction via vLLM",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
+Examples:
+  # Default: Gemma 4 26B-A4B with MTP enabled
+  uv run gemma4-mtp.py input-dataset output-dataset --prompt-column question
+
+  # Quick test with 5 samples
+  uv run gemma4-mtp.py input-dataset output-dataset \\
+    --prompt-column question --max-samples 5 --chunk-size 2 --max-tokens 64
+
+  # A/B baseline: same run without MTP
+  uv run gemma4-mtp.py input-dataset output-dataset \\
+    --prompt-column question --max-samples 50 --disable-mtp
+
+  # HF Jobs (the supported path)
+  hf jobs uv run \\
+    --flavor a100-large \\
+    --image vllm/vllm-openai:gemma4-0505-cu129 \\
+    -s HF_TOKEN \\
+    https://huggingface.co/datasets/uv-scripts/vllm/raw/main/gemma4-mtp.py \\
+    input-dataset output-dataset --prompt-column question
+            """,
+        )
+
+        parser.add_argument(
+            "src_dataset_hub_id",
+            help="Input dataset on Hugging Face Hub (e.g., username/dataset-name)",
+        )
+        parser.add_argument(
+            "output_dataset_hub_id",
+            help="Output dataset name on Hugging Face Hub",
+        )
+        parser.add_argument(
+            "--model-id",
+            type=str,
+            default=DEFAULT_MODEL_ID,
+            help=f"Main model (default: {DEFAULT_MODEL_ID})",
+        )
+        parser.add_argument(
+            "--draft-model-id",
+            type=str,
+            default=DEFAULT_DRAFT_MODEL_ID,
+            help=f"MTP draft / assistant model (default: {DEFAULT_DRAFT_MODEL_ID})",
+        )
+        parser.add_argument(
+            "--num-speculative-tokens",
+            type=int,
+            default=DEFAULT_NUM_SPEC_TOKENS,
+            help=f"Tokens proposed per draft step (default: {DEFAULT_NUM_SPEC_TOKENS})",
+        )
+        parser.add_argument(
+            "--disable-mtp",
+            action="store_true",
+            help="Run without speculative decoding (for A/B speedup measurement)",
+        )
+        parser.add_argument(
+            "--messages-column",
+            type=str,
+            default="messages",
+            help="Column containing chat messages (default: messages)",
+        )
+        parser.add_argument(
+            "--prompt-column",
+            type=str,
+            help="Column containing plain text prompts (alternative to --messages-column)",
+        )
+        parser.add_argument(
+            "--output-column",
+            type=str,
+            default="response",
+            help="Column name for generated responses (default: response)",
+        )
+        parser.add_argument(
+            "--split",
+            type=str,
+            default="train",
+            help="Dataset split to process (default: train)",
+        )
+        parser.add_argument(
+            "--chunk-size",
+            type=int,
+            default=500,
+            help="Batch size for map() — prompts per llm.chat() call (default: 500)",
+        )
+        parser.add_argument(
+            "--max-samples",
+            type=int,
+            help="Maximum number of samples to process (default: all)",
+        )
+        parser.add_argument(
+            "--temperature",
+            type=float,
+            default=0.7,
+            help="Sampling temperature (default: 0.7)",
+        )
+        parser.add_argument(
+            "--top-p",
+            type=float,
+            default=0.95,
+            help="Top-p sampling parameter (default: 0.95)",
+        )
+        parser.add_argument(
+            "--top-k",
+            type=int,
+            default=-1,
+            help="Top-k sampling parameter (default: -1, disabled)",
+        )
+        parser.add_argument(
+            "--min-p",
+            type=float,
+            default=0.0,
+            help="Minimum probability threshold (default: 0.0)",
+        )
+        parser.add_argument(
+            "--max-tokens",
+            type=int,
+            default=2048,
+            help="Maximum tokens to generate (default: 2048)",
+        )
+        parser.add_argument(
+            "--repetition-penalty",
+            type=float,
+            default=1.0,
+            help="Repetition penalty (default: 1.0)",
+        )
+        parser.add_argument(
+            "--gpu-memory-utilization",
+            type=float,
+            default=0.90,
+            help="GPU memory utilization factor (default: 0.90)",
+        )
+        parser.add_argument(
+            "--max-model-len",
+            type=int,
+            default=16384,
+            help="Maximum model context length (default: 16384). Recipe default is 32768.",
+        )
+        parser.add_argument(
+            "--tensor-parallel-size",
+            type=int,
+            help="Number of GPUs to use (default: auto-detect)",
+        )
+        parser.add_argument(
+            "--hf-token",
+            type=str,
+            help="Hugging Face token (can also use HF_TOKEN env var)",
+        )
+
+        args = parser.parse_args()
+
+        main(
+            src_dataset_hub_id=args.src_dataset_hub_id,
+            output_dataset_hub_id=args.output_dataset_hub_id,
+            model_id=args.model_id,
+            draft_model_id=args.draft_model_id,
+            num_speculative_tokens=args.num_speculative_tokens,
+            disable_mtp=args.disable_mtp,
+            messages_column=args.messages_column,
+            prompt_column=args.prompt_column,
+            output_column=args.output_column,
+            split=args.split,
+            chunk_size=args.chunk_size,
+            temperature=args.temperature,
+            top_p=args.top_p,
+            top_k=args.top_k,
+            min_p=args.min_p,
+            max_tokens=args.max_tokens,
+            repetition_penalty=args.repetition_penalty,
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            max_model_len=args.max_model_len,
+            tensor_parallel_size=args.tensor_parallel_size,
+            max_samples=args.max_samples,
+            hf_token=args.hf_token,
+        )
+    else:
+        print("""
+vLLM Gemma 4 + Multi-Token Prediction (MTP) Batch Generation
+============================================================
+
+Runs Google Gemma 4 26B-A4B with the official MTP "assistant" draft model
+for up to 3x faster decoding. Defaults pin to the recipe at
+https://recipes.vllm.ai/Google/gemma-4-26B-A4B-it.
+
+Designed for HF Jobs with the custom Day-0 image:
+    --image vllm/vllm-openai:gemma4-0505-cu129
+
+For usage information:
+    uv run gemma4-mtp.py --help
+
+Example HF Jobs command:
+    hf jobs uv run \\
+        --flavor a100-large \\
+        --image vllm/vllm-openai:gemma4-0505-cu129 \\
+        -s HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/vllm/raw/main/gemma4-mtp.py \\
+        username/input-dataset \\
+        username/output-dataset \\
+        --prompt-column question \\
+        --max-tokens 1024
+""")