Add vLLM-based text classification script

- Zero-shot classification using vLLM with guided decoding
- Supports any HuggingFace dataset with text columns
- Guaranteed valid outputs through structured generation
- Optimized for GPU inference with automatic batching
- Three prompt styles: simple, detailed, reasoning
- Ready for HF Jobs with vLLM image support

README.md

@@ -0,0 +1,217 @@
+---
+viewer: false
+tags: [uv-script, classification, vllm, structured-outputs, gpu-required]
+---
+
+# Dataset Classification with vLLM
+
+Efficient text classification for Hugging Face datasets using vLLM with structured outputs. This script provides GPU-accelerated classification with guaranteed valid outputs through guided decoding.
+
+## 🚀 Quick Start
+
+```bash
+# Classify IMDB reviews
+uv run classify-dataset.py \
+  --input-dataset stanfordnlp/imdb \
+  --column text \
+  --labels "positive,negative" \
+  --output-dataset user/imdb-classified
+```
+
+That's it! No installation, no setup - just `uv run`.
+
+## 📋 Requirements
+
+- **GPU Required**: This script uses vLLM for efficient inference
+- Python 3.10+
+- UV (will handle all dependencies automatically)
+- vLLM >= 0.6.6 (for guided decoding support)
+
+## 🎯 Features
+
+- **Guaranteed valid outputs** using vLLM's guided decoding with outlines
+- **Zero-shot classification** with structured generation
+- **GPU-optimized** with vLLM's automatic batching for maximum efficiency
+- **Robust text handling** with preprocessing and validation
+- **Three prompt styles** for different use cases
+- **Automatic progress tracking** and detailed statistics
+- **Direct Hub integration** - read and write datasets seamlessly
+
+## 💻 Usage
+
+### Basic Classification
+
+```bash
+uv run classify-dataset.py \
+  --input-dataset <dataset-id> \
+  --column <text-column> \
+  --labels <comma-separated-labels> \
+  --output-dataset <output-id>
+```
+
+### Arguments
+
+**Required:**
+- `--input-dataset`: Hugging Face dataset ID (e.g., `stanfordnlp/imdb`, `user/my-dataset`)
+- `--column`: Name of the text column to classify
+- `--labels`: Comma-separated classification labels (e.g., `"spam,ham"`)
+- `--output-dataset`: Where to save the classified dataset
+
+**Optional:**
+- `--model`: Model to use (default: `HuggingFaceTB/SmolLM3-3B`)
+- `--prompt-style`: Choose from `simple`, `detailed`, or `reasoning` (default: `simple`)
+- `--split`: Dataset split to process (default: `train`)
+- `--max-samples`: Limit samples for testing
+- `--temperature`: Generation temperature (default: 0.1)
+- `--guided-backend`: Backend for guided decoding (default: `outlines`)
+- `--hf-token`: Hugging Face token (or use `HF_TOKEN` env var)
+
+### Prompt Styles
+
+- **simple**: Direct classification prompt
+- **detailed**: Emphasizes exact category matching
+- **reasoning**: Includes brief analysis before classification
+
+All styles benefit from structured output guarantees - the model can only output valid labels!
+
+## 📊 Examples
+
+### Sentiment Analysis
+```bash
+uv run classify-dataset.py \
+  --input-dataset stanfordnlp/imdb \
+  --column text \
+  --labels "positive,negative" \
+  --output-dataset user/imdb-sentiment
+```
+
+### Support Ticket Classification
+```bash
+uv run classify-dataset.py \
+  --input-dataset user/support-tickets \
+  --column content \
+  --labels "bug,feature_request,question,other" \
+  --output-dataset user/tickets-classified \
+  --prompt-style reasoning
+```
+
+### News Categorization
+```bash
+uv run classify-dataset.py \
+  --input-dataset ag_news \
+  --column text \
+  --labels "world,sports,business,tech" \
+  --output-dataset user/ag-news-categorized \
+  --model meta-llama/Llama-3.2-3B-Instruct
+```
+
+## 🚀 Running on HF Jobs
+
+This script is optimized for [Hugging Face Jobs](https://huggingface.co/docs/hub/spaces-gpu-jobs) (requires Pro subscription or Team/Enterprise organization):
+
+```bash
+# Run on L4 GPU with vLLM image
+hf jobs uv run \
+  --flavor l4x1 \
+  --image vllm/vllm-openai:latest \
+  classify-dataset.py \
+  --input-dataset stanfordnlp/imdb \
+  --column text \
+  --labels "positive,negative" \
+  --output-dataset user/imdb-classified
+
+# Run on A10 GPU with custom model
+hf jobs uv run \
+  --flavor a10g-large \
+  --image vllm/vllm-openai:latest \
+  classify-dataset.py \
+  --input-dataset user/reviews \
+  --column review_text \
+  --labels "1,2,3,4,5" \
+  --output-dataset user/reviews-rated \
+  --model mistralai/Mistral-7B-Instruct-v0.3 \
+  --prompt-style detailed
+```
+
+### GPU Flavors
+- `t4-small`: Budget option for smaller models
+- `l4x1`: Good balance for 7B models
+- `a10g-small`: Fast inference for 3B models
+- `a10g-large`: More memory for larger models
+- `a100-large`: Maximum performance
+
+## 🔧 Advanced Usage
+
+### Using Different Models
+
+The default model is SmolLM3-3B, but you can use any instruction-tuned model:
+
+```bash
+# Larger model for complex classification
+uv run classify-dataset.py \
+  --input-dataset user/legal-docs \
+  --column text \
+  --labels "contract,patent,brief,memo,other" \
+  --output-dataset user/legal-classified \
+  --model Qwen/Qwen2.5-7B-Instruct
+```
+
+### Large Datasets
+
+vLLM automatically handles batching for optimal performance. For very large datasets, it will process efficiently without manual intervention:
+
+```bash
+uv run classify-dataset.py \
+  --input-dataset user/huge-dataset \
+  --column text \
+  --labels "A,B,C" \
+  --output-dataset user/huge-classified
+```
+
+## 📈 Performance
+
+- **SmolLM3-3B**: ~50-100 texts/second on A10
+- **7B models**: ~20-50 texts/second on A10
+- vLLM automatically optimizes batching for best throughput
+
+## 🤝 How It Works
+
+1. **vLLM**: Provides efficient GPU batch inference
+2. **Guided Decoding**: Uses outlines to guarantee valid label outputs
+3. **Structured Generation**: Constrains model outputs to exact label choices
+4. **UV**: Handles all dependencies automatically
+
+The script loads your dataset, preprocesses texts, classifies each one using guided decoding to ensure only valid labels are generated, then saves the results as a new column in the output dataset.
+
+## 🐛 Troubleshooting
+
+### CUDA Not Available
+This script requires a GPU. Run it on:
+- A machine with NVIDIA GPU
+- HF Jobs (recommended)
+- Cloud GPU instances
+
+### Out of Memory
+- Use a smaller model
+- Use a larger GPU (e.g., a100-large)
+
+### Invalid/Skipped Texts
+- Texts shorter than 3 characters are skipped
+- Empty or None values are marked as invalid
+- Very long texts are truncated to 4000 characters
+
+### Classification Quality
+- With guided decoding, outputs are guaranteed to be valid labels
+- For better results, use clear and distinct label names
+- Try the `reasoning` prompt style for complex classifications
+- Use a larger model for nuanced tasks
+
+### vLLM Version Issues
+If you see `ImportError: cannot import name 'GuidedDecodingParams'`:
+- Your vLLM version is too old (requires >= 0.6.6)
+- The script specifies the correct version in its dependencies
+- UV should automatically install the correct version
+
+## 📝 License
+
+This script is provided as-is for use with the UV Scripts organization.

classify-dataset.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "vllm>=0.6.6",
+#     "transformers",
+#     "torch",
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+# ]
+# ///
+
+"""
+Classify text columns in Hugging Face datasets using vLLM with structured outputs.
+
+This script provides efficient GPU-based classification with guaranteed valid outputs,
+optimized for running on HF Jobs.
+
+Example:
+    uv run classify-dataset.py \\
+        --input-dataset imdb \\
+        --column text \\
+        --labels "positive,negative" \\
+        --output-dataset user/imdb-classified
+
+HF Jobs example:
+    hfjobs run --flavor a10 uv run classify-dataset.py \\
+        --input-dataset user/emails \\
+        --column content \\
+        --labels "spam,ham" \\
+        --output-dataset user/emails-classified \\
+        --prompt-style reasoning
+"""
+
+import argparse
+import logging
+import os
+import sys
+from typing import List, Dict, Any, Optional
+
+import torch
+from datasets import load_dataset, Dataset
+from huggingface_hub import HfApi
+from vllm import LLM, SamplingParams
+from vllm.sampling_params import GuidedDecodingParams
+
+# Default model - SmolLM3 for good balance of speed and quality
+DEFAULT_MODEL = "HuggingFaceTB/SmolLM3-3B"
+
+# Prompt styles for classification
+PROMPT_STYLES = {
+    "simple": """Classify this text as one of: {labels}
+
+Text: {text}
+
+Label:""",
+    
+    "detailed": """Task: Classify the following text into EXACTLY ONE of these categories.
+Available categories: {labels}
+
+Text to classify:
+{text}
+
+Category:""",
+    
+    "reasoning": """Analyze the following text and determine which category it belongs to.
+Available categories: {labels}
+
+Text to analyze:
+{text}
+
+Brief analysis: Let me examine the key aspects of this text.
+Category:""",
+}
+
+# Minimum text length for valid classification
+MIN_TEXT_LENGTH = 3
+
+# Maximum text length (in characters) to avoid context overflow
+MAX_TEXT_LENGTH = 4000
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Classify text in HuggingFace datasets using vLLM with structured outputs",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    
+    # Required arguments
+    parser.add_argument(
+        "--input-dataset",
+        type=str,
+        required=True,
+        help="Input dataset ID on Hugging Face Hub"
+    )
+    parser.add_argument(
+        "--column",
+        type=str,
+        required=True,
+        help="Name of the text column to classify"
+    )
+    parser.add_argument(
+        "--labels",
+        type=str,
+        required=True,
+        help="Comma-separated list of classification labels (e.g., 'positive,negative')"
+    )
+    parser.add_argument(
+        "--output-dataset",
+        type=str,
+        required=True,
+        help="Output dataset ID on Hugging Face Hub"
+    )
+    
+    # Optional arguments
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=DEFAULT_MODEL,
+        help=f"Model to use for classification (default: {DEFAULT_MODEL})"
+    )
+    # Removed --batch-size argument as vLLM handles batching internally
+    parser.add_argument(
+        "--prompt-style",
+        type=str,
+        choices=list(PROMPT_STYLES.keys()),
+        default="simple",
+        help="Prompt style to use (default: simple)"
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        default=None,
+        help="Maximum number of samples to process (for testing)"
+    )
+    parser.add_argument(
+        "--hf-token",
+        type=str,
+        default=os.environ.get("HF_TOKEN"),
+        help="Hugging Face API token (default: HF_TOKEN env var)"
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="train",
+        help="Dataset split to process (default: train)"
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.1,
+        help="Temperature for generation (default: 0.1)"
+    )
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        default=50,
+        help="Maximum tokens to generate (default: 50)"
+    )
+    parser.add_argument(
+        "--guided-backend",
+        type=str,
+        default="outlines",
+        help="Guided decoding backend (default: outlines)"
+    )
+    
+    return parser.parse_args()
+
+
+def preprocess_text(text: str) -> str:
+    """Preprocess text for classification."""
+    if not text or not isinstance(text, str):
+        return ""
+    
+    # Strip whitespace
+    text = text.strip()
+    
+    # Truncate if too long
+    if len(text) > MAX_TEXT_LENGTH:
+        text = text[:MAX_TEXT_LENGTH] + "..."
+        
+    return text
+
+
+def validate_text(text: str) -> bool:
+    """Check if text is valid for classification."""
+    if not text or len(text) < MIN_TEXT_LENGTH:
+        return False
+    return True
+
+
+def prepare_prompts(
+    texts: List[str],
+    labels: List[str],
+    prompt_template: str
+) -> tuple[List[str], List[int]]:
+    """Prepare prompts for classification, filtering invalid texts."""
+    prompts = []
+    valid_indices = []
+    
+    for i, text in enumerate(texts):
+        processed_text = preprocess_text(text)
+        if validate_text(processed_text):
+            prompt = prompt_template.format(
+                labels=", ".join(labels),
+                text=processed_text
+            )
+            prompts.append(prompt)
+            valid_indices.append(i)
+    
+    return prompts, valid_indices
+
+
+def main():
+    args = parse_args()
+    
+    # Check CUDA availability
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Please run on a machine with GPU support or use HF Jobs.")
+        sys.exit(1)
+    
+    logger.info(f"CUDA available. Using device: {torch.cuda.get_device_name(0)}")
+    
+    # Parse and validate labels
+    labels = [label.strip() for label in args.labels.split(",")]
+    if len(labels) < 2:
+        logger.error("At least two labels are required for classification.")
+        sys.exit(1)
+    logger.info(f"Classification labels: {labels}")
+    
+    # Load dataset
+    logger.info(f"Loading dataset: {args.input_dataset}")
+    try:
+        dataset = load_dataset(args.input_dataset, split=args.split)
+        
+        # Limit samples if specified
+        if args.max_samples:
+            dataset = dataset.select(range(min(args.max_samples, len(dataset))))
+            logger.info(f"Limited dataset to {len(dataset)} samples")
+        
+        logger.info(f"Loaded {len(dataset)} samples from split '{args.split}'")
+    except Exception as e:
+        logger.error(f"Failed to load dataset: {e}")
+        sys.exit(1)
+    
+    # Verify column exists
+    if args.column not in dataset.column_names:
+        logger.error(f"Column '{args.column}' not found in dataset.")
+        logger.error(f"Available columns: {dataset.column_names}")
+        sys.exit(1)
+    
+    # Extract texts
+    texts = dataset[args.column]
+    
+    # Initialize vLLM
+    logger.info(f"Initializing vLLM with model: {args.model}")
+    logger.info(f"Using guided decoding backend: {args.guided_backend}")
+    try:
+        llm = LLM(
+            model=args.model,
+            trust_remote_code=True,
+            dtype="auto",
+            gpu_memory_utilization=0.95,
+            guided_decoding_backend=args.guided_backend,
+        )
+    except Exception as e:
+        logger.error(f"Failed to initialize vLLM: {e}")
+        sys.exit(1)
+    
+    # Set up guided decoding parameters
+    guided_params = GuidedDecodingParams(choice=labels)
+    
+    # Set up sampling parameters with structured output
+    sampling_params = SamplingParams(
+        guided_decoding=guided_params,
+        temperature=args.temperature,
+        max_tokens=args.max_tokens,
+    )
+    
+    # Get prompt template
+    prompt_template = PROMPT_STYLES[args.prompt_style]
+    logger.info(f"Using prompt style '{args.prompt_style}'")
+    logger.info("Using structured output with guided_choice - outputs guaranteed to be valid labels")
+    
+    # Prepare all prompts
+    logger.info("Preparing prompts for classification...")
+    all_prompts, valid_indices = prepare_prompts(texts, labels, prompt_template)
+    
+    if not all_prompts:
+        logger.error("No valid texts found for classification.")
+        sys.exit(1)
+    
+    logger.info(f"Prepared {len(all_prompts)} valid prompts out of {len(texts)} texts")
+    
+    # Let vLLM handle batching internally
+    logger.info("Starting classification (vLLM will handle batching internally)...")
+    
+    try:
+        # Generate all classifications at once - vLLM handles batching
+        outputs = llm.generate(all_prompts, sampling_params)
+        
+        # Map results back to original indices
+        all_classifications = [None] * len(texts)
+        for idx, output in enumerate(outputs):
+            original_idx = valid_indices[idx]
+            generated_text = output.outputs[0].text.strip()
+            all_classifications[original_idx] = generated_text
+        
+        # Count statistics
+        valid_texts = len(valid_indices)
+        total_texts = len(texts)
+        
+    except Exception as e:
+        logger.error(f"Classification failed: {e}")
+        sys.exit(1)
+    
+    # Add classifications to dataset
+    dataset = dataset.add_column("classification", all_classifications)
+    
+    # Calculate statistics
+    none_count = total_texts - valid_texts
+    if none_count > 0:
+        logger.warning(f"{none_count} texts were too short or invalid for classification")
+    
+    # Show classification distribution
+    label_counts = {label: all_classifications.count(label) for label in labels}
+    logger.info("Classification distribution:")
+    for label, count in label_counts.items():
+        percentage = count / total_texts * 100 if total_texts > 0 else 0
+        logger.info(f"  {label}: {count} ({percentage:.1f}%)")
+    if none_count > 0:
+        none_percentage = none_count / total_texts * 100
+        logger.info(f"  Invalid/Skipped: {none_count} ({none_percentage:.1f}%)")
+    
+    # Log success rate
+    success_rate = (valid_texts / total_texts * 100) if total_texts > 0 else 0
+    logger.info(f"Classification success rate: {success_rate:.1f}%")
+    
+    # Save to Hub
+    logger.info(f"Pushing dataset to Hub: {args.output_dataset}")
+    try:
+        dataset.push_to_hub(
+            args.output_dataset,
+            token=args.hf_token,
+            commit_message=f"Add classifications using {args.model} with structured outputs"
+        )
+        logger.info(f"Successfully pushed to: https://huggingface.co/datasets/{args.output_dataset}")
+    except Exception as e:
+        logger.error(f"Failed to push to Hub: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("Example HF Jobs command:")
+        print("hf jobs uv run \\")
+        print("  --flavor l4x1 \\")
+        print("  --image vllm/vllm-openai:latest \\")
+        print("  classify-dataset.py \\")
+        print("  --input-dataset stanfordnlp/imdb \\")
+        print("  --column text \\")
+        print("  --labels 'positive,negative' \\")
+        print("  --output-dataset user/imdb-classified")
+        sys.exit(0)
+    
+    main()