Upload gpt_oss_vllm_harmony.py

gpt_oss_vllm_harmony.py

@@ -0,0 +1,608 @@
+# /// script
+# requires-python = ">=3.12,<3.13"  # Required for vllm==0.10.1+gptoss
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "torch",
+#     "openai-harmony",  # Official OpenAI harmony library
+#     "vllm==0.10.1+gptoss",  # Specific version for GPT OSS models
+#     "tqdm",
+# ]
+# 
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/gpt-oss/"
+# 
+# [[tool.uv.index]]
+# url = "https://download.pytorch.org/whl/nightly/cu128"
+# 
+# [tool.uv]
+# index-strategy = "unsafe-best-match"
+# ///
+"""
+Generate responses with transparent reasoning using OpenAI GPT OSS models with harmony format.
+
+This script uses the official openai_harmony library for proper message formatting
+and channel parsing, as recommended in the OpenAI cookbook.
+
+Example usage:
+    # Generate haiku with reasoning
+    uv run gpt_oss_vllm_harmony.py \\
+        --input-dataset davanstrien/haiku_dpo \\
+        --output-dataset username/haiku-reasoning \\
+        --prompt-column question
+    
+    # Any prompt dataset with custom settings
+    uv run gpt_oss_vllm_harmony.py \\
+        --input-dataset username/prompts \\
+        --output-dataset username/responses-with-reasoning \\
+        --prompt-column prompt \\
+        --reasoning-level high \\
+        --max-samples 100
+    
+    # HF Jobs execution
+    hf jobs uv run --flavor a10g-small \\
+        https://huggingface.co/datasets/uv-scripts/openai-reasoning/raw/main/gpt_oss_vllm_harmony.py \\
+        --input-dataset username/prompts \\
+        --output-dataset username/responses-with-reasoning
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from datasets import Dataset, load_dataset
+from huggingface_hub import DatasetCard, get_token, login
+from openai_harmony import (
+    HarmonyEncodingName,
+    load_harmony_encoding,
+    Conversation,
+    Message,
+    Role,
+    SystemContent,
+    DeveloperContent,
+)
+from torch import cuda
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+
+# Enable HF Transfer for faster downloads
+os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+# TODO: Change logging level back to INFO after initial testing
+logging.basicConfig(
+    level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+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 parse_harmony_messages(entries: List, prompt: str) -> Dict[str, str]:
+    """
+    Parse harmony message entries into think/content structure.
+    
+    The harmony format produces structured messages with different channels:
+    - analysis: Chain of thought reasoning
+    - final: User-facing response
+    - commentary: Tool calls (if any)
+    """
+    think = ""
+    content = ""
+    
+    # Log what we received for debugging
+    logger.debug(f"[VERBOSE] Parsing {len(entries)} harmony entries")
+    
+    for i, entry in enumerate(entries):
+        entry_dict = entry.to_dict()
+        logger.debug(f"[VERBOSE] Entry {i}: {json.dumps(entry_dict, indent=2)}")
+        
+        # Extract content based on the message structure
+        if "content" in entry_dict:
+            if isinstance(entry_dict["content"], list):
+                for content_item in entry_dict["content"]:
+                    if content_item.get("type") == "text":
+                        text = content_item.get("text", "")
+                        # Determine channel based on content or metadata
+                        # This is a simplified approach - adjust based on actual harmony output
+                        if "analysis" in str(entry_dict).lower() or i == 0:
+                            think += text + "\n"
+                        else:
+                            content += text + "\n"
+            elif isinstance(entry_dict["content"], str):
+                # Simple string content
+                if i == 0:  # First message is often reasoning
+                    think = entry_dict["content"]
+                else:
+                    content = entry_dict["content"]
+    
+    # Clean up whitespace
+    think = think.strip()
+    content = content.strip()
+    
+    # If we didn't parse anything, use the first entry as content
+    if not think and not content and entries:
+        content = str(entries[0].to_dict())
+    
+    return {
+        "prompt": prompt,
+        "think": think,
+        "content": content,
+        "raw_output": json.dumps([e.to_dict() for e in entries], indent=2)
+    }
+
+
+def create_dataset_card(
+    input_dataset: str,
+    model_id: str,
+    prompt_column: str,
+    reasoning_level: str,
+    num_examples: int,
+    generation_time: str,
+    tensor_parallel_size: int,
+    temperature: float,
+    max_tokens: int,
+) -> str:
+    """Create a dataset card documenting the generation process."""
+    return f"""---
+tags:
+- generated
+- synthetic
+- reasoning
+- openai-gpt-oss
+- harmony-format
+---
+
+# Generated Responses with Reasoning (Harmony Format)
+
+This dataset contains AI-generated responses with transparent chain-of-thought reasoning using OpenAI GPT OSS models and the official harmony format.
+
+## Generation Details
+
+- **Source Dataset**: [{input_dataset}](https://huggingface.co/datasets/{input_dataset})
+- **Model**: [{model_id}](https://huggingface.co/{model_id})
+- **Reasoning Level**: {reasoning_level}
+- **Number of Examples**: {num_examples:,}
+- **Generation Date**: {generation_time}
+- **Format**: Official OpenAI Harmony format
+
+## Dataset Structure
+
+Each example contains:
+- `prompt`: The input prompt from the source dataset
+- `think`: The model's internal reasoning process (analysis channel)
+- `content`: The final response (final channel)
+- `raw_output`: Complete harmony format output
+- `reasoning_level`: The reasoning effort level used
+- `model`: Model identifier
+
+## Generation Script
+
+Generated using [uv-scripts/openai-reasoning](https://huggingface.co/datasets/uv-scripts/openai-reasoning) with official harmony format.
+
+To reproduce:
+```bash
+uv run gpt_oss_vllm_harmony.py \\
+    --input-dataset {input_dataset} \\
+    --output-dataset <your-dataset> \\
+    --prompt-column {prompt_column} \\
+    --model-id {model_id} \\
+    --reasoning-level {reasoning_level}
+```
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset_hub_id: str,
+    prompt_column: str = "prompt",
+    model_id: str = "openai/gpt-oss-20b",
+    reasoning_level: str = "high",
+    max_samples: Optional[int] = None,
+    temperature: float = 0.7,
+    max_tokens: int = 512,
+    gpu_memory_utilization: float = 0.90,
+    tensor_parallel_size: Optional[int] = None,
+    hf_token: Optional[str] = None,
+):
+    """
+    Main generation pipeline using official harmony format.
+
+    Args:
+        input_dataset: Source dataset on Hugging Face Hub
+        output_dataset_hub_id: Where to save results on Hugging Face Hub
+        prompt_column: Column containing the prompts
+        model_id: OpenAI GPT OSS model to use
+        reasoning_level: Reasoning effort level (high/medium/low)
+        max_samples: Maximum number of samples to process
+        temperature: Sampling temperature
+        max_tokens: Maximum tokens to generate
+        gpu_memory_utilization: GPU memory utilization factor
+        tensor_parallel_size: Number of GPUs to use (auto-detect if None)
+        hf_token: Hugging Face authentication token
+    """
+    generation_start_time = datetime.now().isoformat()
+
+    # GPU check and configuration
+    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}"
+        )
+
+    # Authentication
+    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'")
+        sys.exit(1)
+
+    logger.info("HuggingFace token found, authenticating...")
+    login(token=HF_TOKEN)
+
+    # Initialize harmony encoding
+    logger.info("Loading harmony encoding...")
+    encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+    
+    # Get stop tokens from harmony
+    stop_token_ids = encoding.stop_tokens_for_assistant_action()
+    logger.info(f"[VERBOSE] Harmony stop token IDs: {stop_token_ids}")
+
+    # Initialize vLLM
+    logger.info(f"Loading model: {model_id}")
+    logger.info("Note: vLLM will handle batching automatically for optimal throughput")
+    try:
+        llm = LLM(
+            model=model_id,
+            tensor_parallel_size=tensor_parallel_size,
+            gpu_memory_utilization=gpu_memory_utilization,
+            trust_remote_code=True,
+            dtype="bfloat16",
+        )
+        logger.info("[VERBOSE] Model loaded successfully")
+    except Exception as e:
+        logger.error(f"Failed to load model with vLLM: {e}")
+        if "mxfp4" in str(e).lower():
+            logger.error("This appears to be a quantization format issue.")
+            logger.error("The model uses mxfp4 quantization which requires specific support.")
+        sys.exit(1)
+
+    # Create sampling parameters
+    sampling_params = SamplingParams(
+        temperature=temperature,
+        max_tokens=max_tokens,
+        stop_token_ids=stop_token_ids,
+    )
+    logger.info(f"[VERBOSE] Sampling params: temp={temperature}, max_tokens={max_tokens}")
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    dataset = load_dataset(input_dataset, split="train")
+
+    # Validate prompt column
+    if prompt_column not in dataset.column_names:
+        logger.error(
+            f"Column '{prompt_column}' not found. Available columns: {dataset.column_names}"
+        )
+        sys.exit(1)
+
+    # Limit samples if requested
+    if max_samples:
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+    total_examples = len(dataset)
+    logger.info(f"Processing {total_examples:,} examples")
+
+    # Prepare prompts using harmony format
+    logger.info(f"Preparing prompts with harmony format and reasoning_level={reasoning_level}...")
+    prefill_ids_list = []
+    prompts = []
+
+    for i, example in enumerate(tqdm(dataset, desc="Preparing prompts")):
+        prompt_text = example[prompt_column]
+        prompts.append(prompt_text)
+        
+        # Create harmony conversation
+        # Inject reasoning level into developer message
+        developer_content = DeveloperContent.new()
+        if reasoning_level:
+            developer_content = developer_content.with_instructions(
+                f"Reasoning: {reasoning_level}"
+            )
+        
+        convo = Conversation.from_messages([
+            Message.from_role_and_content(Role.SYSTEM, SystemContent.new()),
+            Message.from_role_and_content(Role.DEVELOPER, developer_content),
+            Message.from_role_and_content(Role.USER, prompt_text),
+        ])
+        
+        # Render to token IDs
+        prefill_ids = encoding.render_conversation_for_completion(convo, Role.ASSISTANT)
+        prefill_ids_list.append(prefill_ids)
+        
+        # Log first few examples
+        if i < 10:
+            logger.info(f"[VERBOSE] Example {i} original text: {prompt_text[:200]}...")
+            logger.info(f"[VERBOSE] Example {i} prefill length: {len(prefill_ids)} tokens")
+
+    # Generate responses with vLLM
+    logger.info(f"Starting generation for {len(prefill_ids_list):,} prompts...")
+    logger.info("[VERBOSE] Using prompt_token_ids for generation")
+    
+    start_time = time.time()
+    outputs = llm.generate(
+        prompt_token_ids=prefill_ids_list,
+        sampling_params=sampling_params,
+    )
+    end_time = time.time()
+    
+    generation_time = end_time - start_time
+    logger.info(f"\n[VERBOSE] Generation Performance Metrics:")
+    logger.info(f"[VERBOSE]   - Total time: {generation_time:.2f} seconds")
+    logger.info(f"[VERBOSE]   - Throughput: {len(outputs) / generation_time:.2f} prompts/second")
+    logger.info(f"[VERBOSE]   - Average time per prompt: {generation_time / len(outputs):.2f} seconds")
+
+    # Parse outputs using harmony format
+    logger.info("Parsing generated outputs with harmony format...")
+    results = []
+    
+    # Track statistics
+    parse_stats = {"success": 0, "empty": 0, "error": 0}
+
+    for i, output in enumerate(tqdm(outputs, desc="Parsing outputs")):
+        gen = output.outputs[0]
+        text = gen.text
+        output_tokens = gen.token_ids
+        
+        logger.debug(f"[VERBOSE] Output {i}: {len(output_tokens)} tokens, {len(text)} chars")
+        
+        try:
+            # Parse with harmony
+            entries = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
+            
+            # Convert to our format
+            parsed = parse_harmony_messages(entries, prompts[i])
+            
+            if parsed["think"] or parsed["content"]:
+                parse_stats["success"] += 1
+            else:
+                parse_stats["empty"] += 1
+            
+            # Verbose logging for first 10 examples
+            if i < 10:
+                logger.info(f"\n[VERBOSE] ========== Example {i} Output ==========")
+                logger.info(f"[VERBOSE] Original prompt: {prompts[i][:200]}...")
+                logger.info(f"[VERBOSE] Raw text output: {text}")
+                logger.info(f"[VERBOSE] Harmony entries: {len(entries)}")
+                for j, entry in enumerate(entries):
+                    logger.info(f"[VERBOSE] Entry {j}: {json.dumps(entry.to_dict(), indent=2)}")
+                logger.info(f"[VERBOSE] Parsed think ({len(parsed['think'])} chars): {parsed['think'][:500]}...")
+                logger.info(f"[VERBOSE] Parsed content ({len(parsed['content'])} chars): {parsed['content'][:500]}...")
+                logger.info(f"[VERBOSE] ====================================\n")
+            
+        except Exception as e:
+            logger.error(f"[VERBOSE] Error parsing output {i}: {e}")
+            parse_stats["error"] += 1
+            # Fallback: use raw text
+            parsed = {
+                "prompt": prompts[i],
+                "think": "",
+                "content": text,
+                "raw_output": text
+            }
+        
+        result = {
+            "prompt": parsed["prompt"],
+            "think": parsed["think"],
+            "content": parsed["content"],
+            "raw_output": parsed["raw_output"],
+            "reasoning_level": reasoning_level,
+            "model": model_id,
+        }
+        results.append(result)
+    
+    # Log parsing statistics
+    logger.info(f"\n[VERBOSE] Parsing Statistics:")
+    logger.info(f"[VERBOSE]   - Successfully parsed: {parse_stats['success']} ({parse_stats['success']/len(outputs)*100:.1f}%)")
+    logger.info(f"[VERBOSE]   - Empty results: {parse_stats['empty']} ({parse_stats['empty']/len(outputs)*100:.1f}%)")
+    logger.info(f"[VERBOSE]   - Parse errors: {parse_stats['error']} ({parse_stats['error']/len(outputs)*100:.1f}%)")
+
+    # Create dataset
+    logger.info("Creating output dataset...")
+    output_dataset = Dataset.from_list(results)
+
+    # Create dataset card
+    logger.info("Creating dataset card...")
+    card_content = create_dataset_card(
+        input_dataset=input_dataset,
+        model_id=model_id,
+        prompt_column=prompt_column,
+        reasoning_level=reasoning_level,
+        num_examples=total_examples,
+        generation_time=generation_start_time,
+        tensor_parallel_size=tensor_parallel_size,
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+
+    # Push to hub
+    logger.info(f"Pushing dataset to: {output_dataset_hub_id}")
+    output_dataset.push_to_hub(output_dataset_hub_id, token=HF_TOKEN)
+
+    # Push dataset card
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset_hub_id, token=HF_TOKEN)
+
+    logger.info("✅ Generation complete!")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset_hub_id}"
+    )
+    
+    # Final summary
+    logger.info(f"\n[VERBOSE] ========== FINAL SUMMARY ==========")
+    logger.info(f"[VERBOSE] Model: {model_id}")
+    logger.info(f"[VERBOSE] Reasoning level: {reasoning_level}")
+    logger.info(f"[VERBOSE] Examples processed: {total_examples}")
+    logger.info(f"[VERBOSE] Temperature: {temperature}")
+    logger.info(f"[VERBOSE] Max tokens: {max_tokens}")
+    logger.info(f"[VERBOSE] GPU config: {tensor_parallel_size} GPU(s)")
+    logger.info(f"[VERBOSE] ====================================")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        parser = argparse.ArgumentParser(
+            description="Generate responses with reasoning using OpenAI GPT OSS models (Harmony format)",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
+Examples:
+  # Generate haiku with reasoning
+  uv run gpt_oss_vllm_harmony.py \\
+    --input-dataset davanstrien/haiku_dpo \\
+    --output-dataset username/haiku-reasoning \\
+    --prompt-column question
+  
+  # Any prompt dataset
+  uv run gpt_oss_vllm_harmony.py \\
+    --input-dataset username/prompts \\
+    --output-dataset username/responses-reasoning \\
+    --reasoning-level high \\
+    --max-samples 100
+  
+  # Use larger 120B model (requires 4x L40S GPUs)
+  uv run gpt_oss_vllm_harmony.py \\
+    --input-dataset username/prompts \\
+    --output-dataset username/responses-reasoning \\
+    --model-id openai/gpt-oss-120b \\
+    --tensor-parallel-size 4
+            """,
+        )
+
+        parser.add_argument(
+            "--input-dataset",
+            type=str,
+            required=True,
+            help="Input dataset on Hugging Face Hub",
+        )
+        parser.add_argument(
+            "--output-dataset",
+            type=str,
+            required=True,
+            help="Output dataset name on Hugging Face Hub",
+        )
+        parser.add_argument(
+            "--prompt-column",
+            type=str,
+            default="prompt",
+            help="Column containing prompts (default: prompt)",
+        )
+        parser.add_argument(
+            "--model-id",
+            type=str,
+            default="openai/gpt-oss-20b",
+            help="Model to use (default: openai/gpt-oss-20b)",
+        )
+        parser.add_argument(
+            "--reasoning-level",
+            type=str,
+            choices=["high", "medium", "low"],
+            default="high",
+            help="Reasoning effort level (default: high)",
+        )
+        parser.add_argument(
+            "--max-samples", type=int, help="Maximum number of samples to process"
+        )
+        parser.add_argument(
+            "--temperature",
+            type=float,
+            default=0.7,
+            help="Sampling temperature (default: 0.7)",
+        )
+        parser.add_argument(
+            "--max-tokens",
+            type=int,
+            default=512,
+            help="Maximum tokens to generate (default: 512)",
+        )
+        parser.add_argument(
+            "--gpu-memory-utilization",
+            type=float,
+            default=0.90,
+            help="GPU memory utilization (default: 0.90)",
+        )
+        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(
+            input_dataset=args.input_dataset,
+            output_dataset_hub_id=args.output_dataset,
+            prompt_column=args.prompt_column,
+            model_id=args.model_id,
+            reasoning_level=args.reasoning_level,
+            max_samples=args.max_samples,
+            temperature=args.temperature,
+            max_tokens=args.max_tokens,
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            tensor_parallel_size=args.tensor_parallel_size,
+            hf_token=args.hf_token,
+        )
+    else:
+        # Show HF Jobs example when run without arguments
+        print("""
+OpenAI GPT OSS Reasoning Generation Script (Harmony Format)
+==========================================================
+
+This script requires arguments. For usage information:
+    uv run gpt_oss_vllm_harmony.py --help
+
+Example HF Jobs command for 20B model:
+    hf jobs uv run \\
+        --flavor a10g-large \\  # 20B model requires ~40GB memory
+        https://huggingface.co/datasets/uv-scripts/openai-reasoning/raw/main/gpt_oss_vllm_harmony.py \\
+        --input-dataset davanstrien/haiku_dpo \\
+        --output-dataset username/haiku-reasoning \\
+        --prompt-column question \\
+        --reasoning-level high
+
+Example HF Jobs command for 120B model:
+    hf jobs uv run \\
+        --flavor l40s-4x \\  # 120B model requires ~240GB memory
+        https://huggingface.co/datasets/uv-scripts/openai-reasoning/raw/main/gpt_oss_vllm_harmony.py \\
+        --input-dataset username/prompts \\
+        --output-dataset username/responses-reasoning \\
+        --model-id openai/gpt-oss-120b \\
+        --reasoning-level high
+        """)