Add minimal GPT OSS script for HF Jobs

- Simplified version without channel parsing
- Stores raw outputs only
- Optimized for reliability on HF Jobs
- Works on regular GPUs (L4, A10G, A100)
- Based on official HF blog recommendations

gpt_oss_minimal.py

@@ -0,0 +1,168 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "torch",
+#     "transformers>=4.45.0",
+#     "datasets",
+#     "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 (A10G for $1.50/hr)
+    hf jobs uv run --flavor a10g-small \
+        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
+
+import torch
+from datasets import Dataset, load_dataset
+from huggingface_hub import get_token, login
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Enable fast downloads
+os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+
+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, default=1024, help="Max tokens to generate")
+    args = parser.parse_args()
+
+    # 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)
+    
+    # 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 = []
+    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 (following official blog)
+        inputs = tokenizer.apply_chat_template(
+            messages,
+            add_generation_prompt=True,
+            return_tensors="pt",
+            return_dict=True
+        ).to(model.device)
+        
+        # Generate
+        with torch.no_grad():
+            generated = model.generate(
+                **inputs, 
+                max_new_tokens=args.max_new_tokens,
+                do_sample=True,
+                temperature=0.7,
+            )
+        
+        # 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,
+        })
+        
+        # Show preview of output structure
+        if i == 0:
+            print(f"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)
+    
+    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("\nTo extract final response, look for text after '<|channel|>final<|message|>'")
+
+
+if __name__ == "__main__":
+    main()