pin xet

gpt_oss_transformers.py

@@ -3,40 +3,42 @@
 # dependencies = [
 #     "datasets",
 #     "huggingface-hub[hf_transfer]",
+#     "hf-xet >= 1.1.7",
 #     "torch",
-#     "transformers>=4.45.0",
+#     "transformers>=4.55.0",
 #     "tqdm",
 #     "accelerate",
-#     "kernels>=0.9.0",  # For Flash Attention 3 support (optional but recommended)
 # ]
 # ///
 """
-Generate responses with transparent reasoning using OpenAI's open source GPT OSS models.
+Generate responses with transparent reasoning using OpenAI's GPT OSS models.
 
-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.
+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
 
 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
     
-    # 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 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_transformers.py \\
-        --input-dataset username/prompts \\
-        --output-dataset username/responses-with-reasoning
+        --input-dataset davanstrien/haiku_dpo \\
+        --output-dataset username/haiku-reasoning \\
+        --prompt-column question
 """
 
 import argparse
@@ -89,34 +91,79 @@ def parse_channels(raw_output: str) -> Dict[str, str]:
     """
     Extract think/content from GPT OSS channel-based output.
 
-    Expected format:
-    <|start|>assistant<|channel|>analysis<|message|>CHAIN_OF_THOUGHT<|end|>
-    <|start|>assistant<|channel|>final<|message|>ACTUAL_MESSAGE
+    The actual output format is simpler than expected:
+    analysisREASONING_TEXTassistantfinalRESPONSE_TEXT
+
+    Sometimes includes commentary channel:
+    commentaryMETA_TEXTanalysisREASONING_TEXTassistantfinalRESPONSE_TEXT
     """
-    think = ""
-    content = ""
+    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 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 reasoning (analysis and/or commentary)
+    reasoning_parts = []
 
-    # 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.group(1).strip()
+    # 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 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()
+        )
 
     # If no channels found, treat entire output as content
-    if not think and not content:
-        content = raw_output.strip()
+    if not result["think"] and not result["content"]:
+        result["content"] = raw_output.strip()
 
-    return {"think": think, "content": content, "raw_output": raw_output}
+    return result
 
 
 def create_dataset_card(
@@ -227,10 +274,11 @@ def main(
     logger.info("HuggingFace token found, authenticating...")
     login(token=HF_TOKEN)
 
-    # Load tokenizer
+    # Load tokenizer (always use padding_side="left" for generation)
     logger.info(f"Loading tokenizer: {model_id}")
     tokenizer = AutoTokenizer.from_pretrained(
-        model_id, padding_side="left" if "120b" in model_id else "right"
+        model_id,
+        padding_side="left",  # Always use left padding for generation
     )
 
     # Add padding token if needed
@@ -252,58 +300,49 @@ def main(
 
     # Load model
     logger.info(f"Loading model: {model_id}")
-    logger.info("This may take a few minutes for large models...")
-    # Note: GPT OSS models are MXFP4 quantized out of the box
-    # The quantization will be dequantized to bf16 during loading
-    logger.info("Note: MXFP4 quantization will be dequantized to bf16 for inference")
-    
+    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.warning(f"GPU has {gpu_memory:.1f}GB but 20B model needs ~40GB when dequantized")
-            logger.warning("Consider using --flavor a10g-large (48GB) or a100-large (80GB)")
+            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")
 
     try:
-        # Try Flash Attention 3 first for better performance
-        logger.info("Attempting to load with Flash Attention 3 (optimized)")
+        # 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,
-            attn_implementation="kernels-community/vllm-flash-attn3",  # Flash Attention with Sinks
+            torch_dtype=torch.bfloat16,  # Can also use "auto"
+            # DO NOT USE: attn_implementation="kernels-community/vllm-flash-attn3"
             **model_kwargs,
         )
         model.eval()
-        logger.info("Successfully loaded with Flash Attention 3")
+        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("\nThe GPT OSS models require significant memory:")
-        logger.error("- 20B model: ~40GB VRAM (use a10g-large or a100-large)")
-        logger.error("- 120B model: ~240GB VRAM (use 4xa100 or 8xl40s)")
+        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:
-        if "kernels" in str(e) or "flash" in str(e).lower() or "attn" in str(e).lower():
-            logger.info(f"Flash Attention 3 not available (needs 'kernels' package)")
-            logger.info("Using eager attention instead (standard implementation)")
-            try:
-                model = AutoModelForCausalLM.from_pretrained(
-                    model_id,
-                    torch_dtype=torch.bfloat16,
-                    attn_implementation="eager",  # Fallback to eager attention
-                    **model_kwargs,
-                )
-                model.eval()
-                logger.info("Successfully loaded with eager attention")
-            except torch.cuda.OutOfMemoryError as oom_error:
-                logger.error(f"Out of memory with eager attention: {oom_error}")
-                logger.error("The model requires more GPU memory than available")
-                sys.exit(1)
-            except Exception as eager_error:
-                logger.error(f"Failed with eager attention: {eager_error}")
-                sys.exit(1)
-        else:
-            logger.error(f"Unexpected error loading model: {e}")
-            sys.exit(1)
+        logger.error(f"Error loading model: {e}")
+        sys.exit(1)
 
     # Generation configuration
     generation_config = GenerationConfig(
@@ -336,29 +375,36 @@ 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 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
-            )
+        # 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,
+        )
         prompts.append(prompt)
 
     # Generate responses in batches