Update README to focus on minimal script

- Document tested and working l4x4 configuration
- Include exact command that worked
- Remove references to full script to avoid confusion
- Add clear GPU requirements table
- Explain reasoning_effort parameter
- Last tested: 2025-01-06

README.md

@@ -1,193 +1,113 @@
-# 🚀 OpenAI GPT OSS Models - Works on Regular GPUs!
+# 🚀 OpenAI GPT OSS Models - Simple Generation Script
 
-Generate synthetic datasets with transparent reasoning using OpenAI's GPT OSS models. **No H100s required** - works on L4, A100, A10G, and even T4 GPUs!
+Generate synthetic datasets using OpenAI's GPT OSS models with transparent reasoning. Works on HuggingFace Jobs with L4 GPUs!
 
-## 🎉 Key Discovery
+## ✅ Tested & Working
 
-**The models work on regular datacenter GPUs!** Transformers automatically handles MXFP4 → bf16 conversion, making these models accessible on standard hardware.
+Successfully tested on HF Jobs with `l4x4` flavor (4x L4 GPUs = 96GB total memory).
 
 ## 🌟 Quick Start
 
-### Test Locally (Single Prompt)
 ```bash
-uv run gpt_oss_transformers.py --prompt "Write a haiku about mountains"
-```
-
-### Run on HuggingFace Jobs (No GPU Required!)
-```bash
-# Generate haiku with reasoning (~$1.50/hr on A10G)
-hf jobs uv run --flavor a10g-small \
-    https://huggingface.co/datasets/uv-scripts/openai-oss/raw/main/gpt_oss_transformers.py \
+# Run on HF Jobs (tested and working)
+hf jobs uv run --flavor l4x4 --secrets HF_TOKEN=hf_*** \
+    https://huggingface.co/datasets/davanstrien/openai-oss/raw/main/gpt_oss_minimal.py \
     --input-dataset davanstrien/haiku_dpo \
-    --output-dataset username/haiku-reasoning \
+    --output-dataset username/gpt-oss-haiku \
     --prompt-column question \
-    --max-samples 50
+    --max-samples 2 \
+    --reasoning-effort high
 ```
 
-## 💡 What You Get
+## 📋 Script Options
 
-The models output structured reasoning in separate channels:
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--input-dataset` | HuggingFace dataset to process | Required |
+| `--output-dataset` | Output dataset name | Required |
+| `--prompt-column` | Column containing prompts | `prompt` |
+| `--model-id` | Model to use | `openai/gpt-oss-20b` |
+| `--max-samples` | Limit samples to process | None (all) |
+| `--max-new-tokens` | Max tokens to generate | `1024` |
+| `--reasoning-effort` | Reasoning depth: low/medium/high | `medium` |
 
-**Raw Output**:
-```
-analysisI need to write a haiku about mountains. Haiku: 5-7-5 syllable structure...
-assistantfinalSilent peaks climb high,
-Echoing winds trace stone's breath,
-Dawn paints them gold bright.
-```
+## 💡 What You Get
 
-**Parsed Dataset**:
-```json
-{
-  "prompt": "Write a haiku about mountains",
-  "think": "[Analysis] I need to write a haiku about mountains. Haiku: 5-7-5 syllable structure...",
-  "content": "Silent peaks climb high,\nEchoing winds trace stone's breath,\nDawn paints them gold bright.",
-  "reasoning_level": "high",
-  "model": "openai/gpt-oss-20b"
-}
-```
+The output dataset contains:
+- `prompt`: Original prompt from input dataset
+- `raw_output`: Full model response with channel markers
+- `model`: Model ID used
+- `reasoning_effort`: The reasoning level used
 
-## 🖥️ GPU Requirements
+### Understanding the Output
 
-### ✅ Confirmed Working GPUs
-| GPU | Memory | Status | Notes |
-|-----|--------|--------|-------|
-| **L4** | 24GB | ✅ Tested | Works perfectly! |
-| **A100** | 40/80GB | ✅ Works | Great performance |
-| **A10G** | 24GB | ✅ Recommended | Best value at $1.50/hr |
-| **T4** | 16GB | ⚠️ Limited | May need 8-bit for 20B |
-| **RTX 4090** | 24GB | ✅ Works | Consumer GPU support |
+The raw output contains special channel markers:
+- `<|channel|>analysis<|message|>` - Chain of thought reasoning
+- `<|channel|>final<|message|>` - The actual response
 
-### Memory Requirements
-- **20B model**: ~40GB VRAM when dequantized (use A100-40GB or 2xL4)
-- **120B model**: ~240GB VRAM when dequantized (use 4xA100-80GB)
+Example raw output structure:
+```
+<|channel|>analysis<|message|>
+[Reasoning about the task...]
+<|channel|>final<|message|>
+[Actual haiku or response]
+```
 
 ## 🎯 Examples
 
-### Creative Writing with Reasoning
+### Test with Different Reasoning Levels
+
+**High reasoning (most detailed):**
 ```bash
-# Process haiku dataset with high reasoning
-uv run gpt_oss_transformers.py \
+hf jobs uv run --flavor l4x4 --secrets HF_TOKEN=hf_*** \
+    https://huggingface.co/datasets/davanstrien/openai-oss/raw/main/gpt_oss_minimal.py \
     --input-dataset davanstrien/haiku_dpo \
-    --output-dataset my-haiku-reasoning \
+    --output-dataset username/haiku-high \
     --prompt-column question \
-    --reasoning-level high \
-    --max-samples 100
+    --reasoning-effort high \
+    --max-samples 5
 ```
 
-### Math Problems with Step-by-Step Solutions
+**Low reasoning (fastest):**
 ```bash
-# Generate math solutions with reasoning traces
-uv run gpt_oss_transformers.py \
-    --input-dataset gsm8k \
-    --output-dataset math-with-reasoning \
+hf jobs uv run --flavor l4x4 --secrets HF_TOKEN=hf_*** \
+    https://huggingface.co/datasets/davanstrien/openai-oss/raw/main/gpt_oss_minimal.py \
+    --input-dataset davanstrien/haiku_dpo \
+    --output-dataset username/haiku-low \
     --prompt-column question \
-    --reasoning-level high
+    --reasoning-effort low \
+    --max-samples 10
 ```
 
-### Test Different Reasoning Levels
-```bash
-# Compare reasoning levels
-for level in low medium high; do
-    echo "Testing: $level"
-    uv run gpt_oss_transformers.py \
-        --prompt "Explain gravity to a 5-year-old" \
-        --reasoning-level $level \
-        --debug
-done
-```
+## 🖥️ GPU Requirements
 
-## 📋 Script Options
+| Model | Memory Required | Recommended Flavor |
+|-------|----------------|-------------------|
+| **openai/gpt-oss-20b** | ~40GB | `l4x4` (4x24GB = 96GB) |
+| **openai/gpt-oss-120b** | ~240GB | `8xa100` (8x80GB) |
 
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--input-dataset` | HuggingFace dataset to process | - |
-| `--output-dataset` | Output dataset name | - |
-| `--prompt-column` | Column with prompts | `prompt` |
-| `--model-id` | Model to use | `openai/gpt-oss-20b` |
-| `--reasoning-level` | Reasoning depth: low/medium/high | `high` |
-| `--max-samples` | Limit samples to process | None |
-| `--temperature` | Sampling temperature | `0.7` |
-| `--max-tokens` | Max tokens to generate | `512` |
-| `--prompt` | Single prompt test (skip dataset) | - |
-| `--debug` | Show raw model output | `False` |
+**Note**: The 20B model automatically dequantizes from MXFP4 to bf16 on non-Hopper GPUs, requiring more memory than the quantized size.
 
 ## 🔧 Technical Details
 
-### Why It Works Without H100s
-
-1. **Automatic MXFP4 Handling**: When your GPU doesn't support MXFP4, you'll see:
-   ```
-   MXFP4 quantization requires triton >= 3.4.0 and triton_kernels installed, 
-   we will default to dequantizing the model to bf16
-   ```
-
-2. **No Flash Attention 3 Required**: FA3 needs Hopper architecture, but models work fine without it
-
-3. **Simple Loading**: Just use standard transformers:
-   ```python
-   model = AutoModelForCausalLM.from_pretrained(
-       "openai/gpt-oss-20b",
-       torch_dtype=torch.bfloat16,
-       device_map="auto"
-   )
-   ```
-
-### Channel Output Format
-
-The models use a simplified channel format:
-- `analysis`: Chain of thought reasoning
-- `commentary`: Meta operations (optional)
-- `final`: User-facing response
-
-### Reasoning Control
-
-Control reasoning depth via system message:
-```python
-messages = [
-    {
-        "role": "system", 
-        "content": f"...Reasoning: {level}..."
-    },
-    {"role": "user", "content": prompt}
-]
-```
-
-## 🚨 Best Practices
-
-1. **Token Limits**: Use 1000+ tokens for detailed reasoning
-2. **Security**: Never expose reasoning channels to end users
-3. **Batch Size**: Keep at 1 for memory efficiency
-4. **Reasoning Levels**:
-   - `low`: Quick responses
-   - `medium`: Balanced reasoning
-   - `high`: Detailed chain-of-thought
-
-## 🐛 Troubleshooting
+### Why L4x4?
+- The 20B model needs ~40GB VRAM when dequantized
+- Single A10G (24GB) is insufficient
+- L4x4 provides 96GB total memory across 4 GPUs
+- Cost-effective compared to A100 instances
 
-### Out of Memory
-- Use larger GPU flavor: `--flavor a100-large`
-- Reduce batch size to 1
-- Try 8-bit quantization for smaller GPUs
+### Reasoning Effort
+The `reasoning_effort` parameter controls how much chain-of-thought reasoning the model generates:
+- `low`: Quick responses with minimal reasoning
+- `medium`: Balanced reasoning (default)
+- `high`: Detailed step-by-step reasoning
 
-### No GPU Available
-- Use HuggingFace Jobs (no local GPU needed!)
-- Or use cloud instances with GPU support
+## 📚 Resources
 
-### Empty Reasoning
-- Increase `--max-tokens` to 1500+
-- Ensure prompts trigger reasoning
-
-## 📚 References
-
-- [OpenAI Cookbook: GPT OSS](https://cookbook.openai.com/articles/gpt-oss/run-transformers)
 - [Model: openai/gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b)
 - [HF Jobs Documentation](https://huggingface.co/docs/hub/spaces-gpu-jobs)
-
-## 🎉 The Bottom Line
-
-**You don't need H100s!** These models work great on regular datacenter GPUs. Just run the script and start generating datasets with transparent reasoning.
+- [Dataset: davanstrien/haiku_dpo](https://huggingface.co/datasets/davanstrien/haiku_dpo)
 
 ---
 
-*Last tested: 2025-08-05 on NVIDIA L4 GPUs - Working perfectly!*
+*Last tested: 2025-01-06 on HF Jobs with l4x4 flavor*