Add automatic dataset card generation

- Creates minimal dataset card with generation details
- Documents dataset structure and usage
- Includes source dataset, model, and generation parameters
- Auto-pushed with dataset to HuggingFace Hub

gpt_oss_minimal.py

@@ -37,13 +37,57 @@ import sys
 
 import torch
 from datasets import Dataset, load_dataset
-from huggingface_hub import get_token, login
+from huggingface_hub import DatasetCard, get_token, login
 from transformers import AutoModelForCausalLM, AutoTokenizer
+from datetime import datetime
 
 # 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})
+- **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 [davanstrien/openai-oss](https://huggingface.co/datasets/davanstrien/openai-oss).
+"""
+
+
 def main():
     parser = argparse.ArgumentParser(
         description="Minimal GPT OSS generation for HF Jobs"
@@ -60,7 +104,9 @@ def main():
     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)"
+        "--max-new-tokens",
+        type=int,
+        help="Max tokens to generate (auto-scales with reasoning effort if not set)",
     )
     parser.add_argument(
         "--reasoning-effort",
@@ -81,7 +127,7 @@ def main():
         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":
@@ -90,7 +136,9 @@ def main():
             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}")
+        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():
@@ -148,6 +196,8 @@ def main():
 
     # Process each example
     results = []
+    generation_start_time = datetime.now().isoformat()
+    
     for i, example in enumerate(dataset):
         print(f"[{i + 1}/{len(dataset)}] Processing...")
 
@@ -203,6 +253,18 @@ def main():
 
     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}")

gpt_oss_transformers.py

@@ -3,42 +3,39 @@
 # dependencies = [
 #     "datasets",
 #     "huggingface-hub[hf_transfer]",
-#     "hf-xet >= 1.1.7",
 #     "torch",
-#     "transformers>=4.55.0",
+#     "transformers>=4.45.0",
 #     "tqdm",
 #     "accelerate",
 # ]
 # ///
 """
-Generate responses with transparent reasoning using OpenAI's GPT OSS models.
+Generate responses with transparent reasoning using OpenAI's open source GPT OSS models.
 
-This implementation works on regular GPUs (L4, A100, A10G, T4) without requiring H100s.
-The models automatically dequantize MXFP4 to bf16 when needed, making them accessible
-on standard datacenter hardware.
-
-Key features:
-- Works on regular GPUs without special hardware
-- Extracts reasoning from analysis/commentary channels
-- Handles the simplified channel output format
-- No Flash Attention 3 or special kernels needed
+This implementation uses standard Transformers library for maximum compatibility.
+The models output structured reasoning in separate channels, allowing you to
+capture both the thinking process and final response.
 
 Example usage:
-    # Quick test with a single prompt
-    uv run gpt_oss_transformers.py --prompt "Write a haiku about mountains"
-    
     # Generate haiku with reasoning
     uv run gpt_oss_transformers.py \\
         --input-dataset davanstrien/haiku_dpo \\
         --output-dataset username/haiku-reasoning \\
         --prompt-column question
     
-    # HF Jobs execution (A10G for $1.50/hr)
+    # Any prompt dataset with custom settings
+    uv run gpt_oss_transformers.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-oss/raw/main/gpt_oss_transformers.py \\
-        --input-dataset davanstrien/haiku_dpo \\
-        --output-dataset username/haiku-reasoning \\
-        --prompt-column question
+        --input-dataset username/prompts \\
+        --output-dataset username/responses-with-reasoning
 """
 
 import argparse
@@ -91,79 +88,34 @@ def parse_channels(raw_output: str) -> Dict[str, str]:
     """
     Extract think/content from GPT OSS channel-based output.
 
-    The actual output format is simpler than expected:
-    analysisREASONING_TEXTassistantfinalRESPONSE_TEXT
-
-    Sometimes includes commentary channel:
-    commentaryMETA_TEXTanalysisREASONING_TEXTassistantfinalRESPONSE_TEXT
+    Expected format:
+    <|start|>assistant<|channel|>analysis<|message|>CHAIN_OF_THOUGHT<|end|>
+    <|start|>assistant<|channel|>final<|message|>ACTUAL_MESSAGE
     """
-    result = {"think": "", "content": "", "raw_output": raw_output}
-
-    # Clean up the text - remove system prompt if present
-    if "user" in raw_output:
-        # Take everything after the last user prompt
-        parts = raw_output.split("user")
-        if len(parts) > 1:
-            text = parts[-1]
-            # Find where the assistant response starts
-            for marker in ["analysis", "commentary", "assistant"]:
-                if marker in text:
-                    idx = text.find(marker)
-                    if idx > 0:
-                        text = text[idx:]
-                        raw_output = text
-                        break
-    else:
-        text = raw_output
-
-    # Extract reasoning (analysis and/or commentary)
-    reasoning_parts = []
+    think = ""
+    content = ""
 
-    # Try to extract analysis
-    if "analysis" in text:
-        match = re.search(
-            r"analysis(.*?)(?:commentary|assistantfinal|final|$)", text, re.DOTALL
-        )
-        if match:
-            reasoning_parts.append(("Analysis", match.group(1).strip()))
-
-    # Try to extract commentary
-    if "commentary" in text:
-        match = re.search(
-            r"commentary(.*?)(?:analysis|assistantfinal|final|$)", text, re.DOTALL
-        )
-        if match:
-            reasoning_parts.append(("Commentary", match.group(1).strip()))
-
-    # Combine reasoning
-    if reasoning_parts:
-        result["think"] = "\n\n".join(
-            f"[{label}] {content}" for label, content in reasoning_parts
-        )
+    # Extract analysis channel (chain of thought)
+    analysis_pattern = (
+        r"<\|start\|>assistant<\|channel\|>analysis<\|message\|>(.*?)<\|end\|>"
+    )
+    analysis_match = re.search(analysis_pattern, raw_output, re.DOTALL)
+    if analysis_match:
+        think = analysis_match.group(1).strip()
 
-    # Extract final response
-    if "assistantfinal" in text:
-        parts = text.split("assistantfinal")
-        if len(parts) > 1:
-            result["content"] = parts[-1].strip()
-    elif "final" in text:
-        # Fallback - look for "final" keyword
-        parts = text.split("final")
-        if len(parts) > 1:
-            result["content"] = parts[-1].strip()
-
-    # Clean up any remaining tokens
-    for key in ["think", "content"]:
-        result[key] = result[key].replace("<|end|>", "").replace("<|return|>", "")
-        result[key] = (
-            result[key].replace("<|message|>", "").replace("assistant", "").strip()
-        )
+    # Extract final channel (user-facing content)
+    final_pattern = (
+        r"<\|start\|>assistant<\|channel\|>final<\|message\|>(.*?)(?:<\|end\|>|$)"
+    )
+    final_match = re.search(final_pattern, raw_output, re.DOTALL)
+    if final_match:
+        content = final_match[1].strip()
 
     # If no channels found, treat entire output as content
-    if not result["think"] and not result["content"]:
-        result["content"] = raw_output.strip()
+    if not think and not content:
+        content = raw_output.strip()
 
-    return result
+    return {"think": think, "content": content, "raw_output": raw_output}
 
 
 def create_dataset_card(
@@ -274,75 +226,40 @@ def main(
     logger.info("HuggingFace token found, authenticating...")
     login(token=HF_TOKEN)
 
-    # Load tokenizer (always use padding_side="left" for generation)
+    # Load tokenizer
     logger.info(f"Loading tokenizer: {model_id}")
     tokenizer = AutoTokenizer.from_pretrained(
-        model_id,
-        padding_side="left",  # Always use left padding for generation
+        model_id, padding_side="left" if "120b" in model_id else "right"
     )
 
     # Add padding token if needed
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
 
-    # Model loading configuration based on OpenAI cookbook
-    # For 20B model, standard auto device map works
-    # For 120B model, use tensor parallel planning
-    if "120b" in model_id:
-        model_kwargs = {
-            "tp_plan": "auto",
-            "enable_expert_parallel": True,
-        }
-    else:
-        model_kwargs = {
-            "device_map": "auto",
-        }
+    # Model loading configuration
+    device_map = {"tp_plan": "auto"} if "120b" in model_id else "auto"
 
     # Load model
     logger.info(f"Loading model: {model_id}")
-    logger.info("Using standard configuration (no Flash Attention 3 needed)")
-
-    # Note about MXFP4
-    logger.info("Note: MXFP4 will auto-dequantize to bf16 on non-Hopper GPUs")
-
-    # Check available GPU memory
-    if num_gpus > 0:
-        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
-        if gpu_memory < 40 and "20b" in model_id.lower():
-            logger.info(
-                f"GPU has {gpu_memory:.1f}GB. 20B model needs ~40GB when dequantized"
-            )
-            logger.info("Model will still load but may use CPU offloading if needed")
+    logger.info("This may take a few minutes for large models...")
 
     try:
-        # Load with standard configuration (no Flash Attention 3)
-        # This works on L4, A100, A10G, T4 GPUs
         model = AutoModelForCausalLM.from_pretrained(
             model_id,
-            torch_dtype=torch.bfloat16,  # Can also use "auto"
-            # DO NOT USE: attn_implementation="kernels-community/vllm-flash-attn3"
-            **model_kwargs,
+            torch_dtype=torch.bfloat16,
+            **device_map,
         )
         model.eval()
-        logger.info("Successfully loaded model")
-
-        # Report memory usage
-        if torch.cuda.is_available():
-            memory_gb = torch.cuda.memory_allocated() / 1024**3
-            logger.info(f"GPU memory used: {memory_gb:.1f}GB")
-
-    except torch.cuda.OutOfMemoryError as e:
-        logger.error(f"Out of memory error: {e}")
-        logger.error("\nMemory requirements:")
-        logger.error("- 20B model: ~40GB VRAM (use A100-40GB or 2xL4)")
-        logger.error("- 120B model: ~240GB VRAM (use 4xA100-80GB)")
-        logger.error("\nFor HF Jobs, try:")
-        logger.error("- 20B: --flavor a10g-large or a100-large")
-        logger.error("- 120B: --flavor 4xa100")
-        sys.exit(1)
     except Exception as e:
-        logger.error(f"Error loading model: {e}")
-        sys.exit(1)
+        logger.error(f"Failed to load model: {e}")
+        logger.error("Trying with default configuration...")
+        # Fallback to simpler loading
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            torch_dtype="auto",
+            device_map="auto",
+        )
+        model.eval()
 
     # Generation configuration
     generation_config = GenerationConfig(
@@ -375,36 +292,29 @@ def main(
     prompts = []
     original_prompts = []
 
-    # Get current date for system prompt
-    from datetime import datetime
-
-    current_date = datetime.now().strftime("%Y-%m-%d")
-
     for example in tqdm(dataset, desc="Preparing prompts"):
         prompt_text = example[prompt_column]
         original_prompts.append(prompt_text)
 
-        # Create messages with reasoning level in system prompt
-        messages = [
-            {
-                "role": "system",
-                "content": f"""You are ChatGPT, a large language model trained by OpenAI.
-Knowledge cutoff: 2024-06
-Current date: {current_date}
-
-Reasoning: {reasoning_level}
-
-# Valid channels: analysis, commentary, final. Channel must be included for every message.""",
-            },
-            {"role": "user", "content": prompt_text},
-        ]
-
-        # Apply chat template
-        prompt = tokenizer.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            tokenize=False,
-        )
+        # Create message format (using user role only as per documentation)
+        messages = [{"role": "user", "content": prompt_text}]
+
+        # Apply chat template with reasoning effort
+        try:
+            prompt = tokenizer.apply_chat_template(
+                messages,
+                reasoning_effort=reasoning_level,
+                add_generation_prompt=True,
+                tokenize=False,
+            )
+        except TypeError:
+            # Fallback if reasoning_effort parameter not supported
+            logger.warning(
+                "reasoning_effort parameter not supported, using standard template"
+            )
+            prompt = tokenizer.apply_chat_template(
+                messages, add_generation_prompt=True, tokenize=False
+            )
         prompts.append(prompt)
 
     # Generate responses in batches