gpt_oss_minimal.py

# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "torch",
#     "transformers>=4.55.0",
#     "datasets",
#     "hf-xet >= 1.1.7",
#     "huggingface-hub[hf_transfer]",
#     "accelerate",
# ]
# ///
"""
Minimal GPT OSS generation script for HF Jobs.

Based on official HuggingFace blog recommendations.
Works on regular GPUs (L4, A10G, A100) without Flash Attention 3.

Usage:
    # Quick local test
    uv run gpt_oss_minimal.py \
        --input-dataset davanstrien/haiku_dpo \
        --output-dataset username/haiku-raw \
        --prompt-column question \
        --max-samples 2

    # HF Jobs execution (L4x4 for proper memory)
    hf jobs uv run --flavor l4x4 --secrets HF_TOKEN=hf_*** \
        https://huggingface.co/datasets/uv-scripts/openai-oss/raw/main/gpt_oss_minimal.py \
        --input-dataset davanstrien/haiku_dpo \
        --output-dataset username/haiku-raw \
        --prompt-column question
"""

import argparse
import os
import sys
from datetime import datetime

import torch
from datasets import Dataset, load_dataset
from huggingface_hub import DatasetCard, get_token, login
from transformers import AutoModelForCausalLM, AutoTokenizer

# Enable fast downloads
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"


def create_dataset_card(
    input_dataset: str,
    model_id: str,
    num_examples: int,
    reasoning_effort: str,
    generation_time: str,
) -> str:
    """Create a minimal dataset card."""
    return f"""---
tags:
- synthetic
- gpt-oss
- reasoning
---

# GPT OSS Generated Responses

This dataset was generated using OpenAI's GPT OSS model with reasoning channels.

## Generation Details

- **Source Dataset**: [{input_dataset}](https://huggingface.co/datasets/{input_dataset})
- **Model**: [{model_id}](https://huggingface.co/{model_id})
- **Model Collection**: [OpenAI GPT OSS Models](https://huggingface.co/collections/openai/gpt-oss-68911959590a1634ba11c7a4)
- **Number of Examples**: {num_examples:,}
- **Reasoning Effort**: {reasoning_effort}
- **Generation Date**: {generation_time}

## Dataset Structure

Each example contains:
- `prompt`: Original prompt from source dataset
- `raw_output`: Full model response with channel markers
- `model`: Model identifier
- `reasoning_effort`: Reasoning level used

## Usage

To extract the final response, look for text after `<|channel|>final<|message|>` in the raw_output.

Generated using [uv-scripts/openai-oss](https://huggingface.co/datasets/uv-scripts/openai-oss).
"""


def main():
    parser = argparse.ArgumentParser(
        description="Minimal GPT OSS generation for HF Jobs"
    )
    parser.add_argument(
        "--input-dataset", required=True, help="Input dataset on HF Hub"
    )
    parser.add_argument(
        "--output-dataset", required=True, help="Output dataset on HF Hub"
    )
    parser.add_argument(
        "--prompt-column", default="prompt", help="Column containing prompts"
    )
    parser.add_argument("--model-id", default="openai/gpt-oss-20b", help="Model to use")
    parser.add_argument("--max-samples", type=int, help="Limit number of samples")
    parser.add_argument(
        "--max-new-tokens",
        type=int,
        help="Max tokens to generate (auto-scales with reasoning effort if not set)",
    )
    parser.add_argument(
        "--reasoning-effort",
        choices=["low", "medium", "high"],
        default="medium",
        help="Reasoning effort level (default: medium)",
    )
    parser.add_argument(
        "--temperature",
        type=float,
        default=1.0,
        help="Sampling temperature (default: 1.0)",
    )
    parser.add_argument(
        "--top-p",
        type=float,
        default=1.0,
        help="Top-p sampling (default: 1.0)",
    )
    args = parser.parse_args()

    # Auto-scale max_new_tokens based on reasoning effort if not explicitly set
    if args.max_new_tokens is None:
        if args.reasoning_effort == "high":
            args.max_new_tokens = 2048  # More tokens for detailed reasoning
        elif args.reasoning_effort == "medium":
            args.max_new_tokens = 1024
        else:  # low
            args.max_new_tokens = 512
        print(
            f"Auto-set max_new_tokens={args.max_new_tokens} based on reasoning_effort={args.reasoning_effort}"
        )

    # Check GPU availability
    if not torch.cuda.is_available():
        print(
            "ERROR: GPU required. Use HF Jobs with --flavor a10g-small or run on GPU machine"
        )
        sys.exit(1)

    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB")

    # Authenticate
    token = os.environ.get("HF_TOKEN") or get_token()
    if not token:
        print(
            "ERROR: HF_TOKEN required. Set HF_TOKEN env var or run: huggingface-cli login"
        )
        sys.exit(1)
    login(token=token, add_to_git_credential=False)

    # Load tokenizer (following official blog)
    print(f"Loading tokenizer: {args.model_id}")
    tokenizer = AutoTokenizer.from_pretrained(args.model_id)

    # Load model (without Flash Attention 3 for compatibility)
    print(f"Loading model: {args.model_id}")
    print("Note: MXFP4 will auto-dequantize to bf16 on non-Hopper GPUs")

    model = AutoModelForCausalLM.from_pretrained(
        args.model_id,
        device_map="auto",
        torch_dtype="auto",  # Let transformers choose optimal dtype
        # NOT using: attn_implementation="kernels-community/vllm-flash-attn3"
        # as it requires H100/H200 GPUs
    )
    print("Model loaded successfully")

    # Load dataset
    print(f"Loading dataset: {args.input_dataset}")
    dataset = load_dataset(args.input_dataset, split="train")

    if args.prompt_column not in dataset.column_names:
        print(f"ERROR: Column '{args.prompt_column}' not found")
        print(f"Available columns: {dataset.column_names}")
        sys.exit(1)
    # if args.random_sample:
    #     dataset.shuffle()
    #     print(f"Random sampling enabled. Using {args.max_samples} samples.")

    # Limit samples if requested
    if args.max_samples:
        dataset = dataset.select(range(min(args.max_samples, len(dataset))))

    print(f"Processing {len(dataset)} examples")

    # Process each example
    results = []
    generation_start_time = datetime.now().isoformat()

    for i, example in enumerate(dataset):
        print(f"[{i + 1}/{len(dataset)}] Processing...")

        prompt_text = example[args.prompt_column]

        # Create messages (user message only, as per official examples)
        messages = [{"role": "user", "content": prompt_text}]

        # Apply chat template with reasoning_effort parameter
        inputs = tokenizer.apply_chat_template(
            messages,
            add_generation_prompt=True,
            return_tensors="pt",
            return_dict=True,
            reasoning_effort=args.reasoning_effort,  # "low", "medium", or "high"
        ).to(model.device)

        # Generate with user-specified or default parameters
        with torch.no_grad():
            generated = model.generate(
                **inputs,
                max_new_tokens=args.max_new_tokens,
                do_sample=True,
                temperature=args.temperature,
                top_p=args.top_p,
            )

        # Decode only the generated part (excluding input)
        response = tokenizer.decode(
            generated[0][inputs["input_ids"].shape[-1] :],
            skip_special_tokens=False,  # Keep channel markers
        )

        # Store raw output with channel markers
        results.append(
            {
                "prompt": prompt_text,
                "raw_output": response,
                "model": args.model_id,
                "reasoning_effort": args.reasoning_effort,
            }
        )

        # Show preview of output structure
        if i == 0:
            print("Sample output preview (first 200 chars):")
            print(response[:200])
            print("...")

    # Create and push dataset
    print("\nCreating output dataset...")
    output_dataset = Dataset.from_list(results)

    print(f"Pushing to {args.output_dataset}...")
    output_dataset.push_to_hub(args.output_dataset, token=token)

    # Create and push dataset card
    print("Creating dataset card...")
    card_content = create_dataset_card(
        input_dataset=args.input_dataset,
        model_id=args.model_id,
        num_examples=len(results),
        reasoning_effort=args.reasoning_effort,
        generation_time=generation_start_time,
    )
    card = DatasetCard(card_content)
    card.push_to_hub(args.output_dataset, token=token)

    print(f"\n✅ Complete!")
    print(f"Dataset: https://huggingface.co/datasets/{args.output_dataset}")
    print(f"\nOutput format:")
    print("- prompt: Original prompt")
    print("- raw_output: Full model response with channel markers")
    print("- model: Model ID used")
    print(f"- reasoning_effort: {args.reasoning_effort}")
    print(
        "\nTo extract final response, look for text after '<|channel|>final<|message|>'"
    )


if __name__ == "__main__":
    main()