classify-dataset-sglang.py

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "sglang[all]",
#     "flashinfer-python",
#     "transformers",
#     "torch",
#     "datasets",
#     "huggingface-hub[hf_transfer]",
# ]
# 
# [[tool.uv.index]]
# name = "flashinfer"
# url = "https://flashinfer.ai/whl/cu121/torch2.4/"
# ///

"""
Classify text columns in Hugging Face datasets using SGLang with reasoning-aware models.

This script provides efficient GPU-based classification with optional reasoning support,
optimized for models like SmolLM3-3B that use <think> tokens for chain-of-thought.

Example:
    # Fast classification without reasoning
    uv run classify-dataset-sglang.py \\
        --input-dataset imdb \\
        --column text \\
        --labels "positive,negative" \\
        --output-dataset user/imdb-classified

    # Complex classification with reasoning
    uv run classify-dataset-sglang.py \\
        --input-dataset arxiv-papers \\
        --column abstract \\
        --labels "reasoning_systems,agents,multimodal,robotics,other" \\
        --output-dataset user/arxiv-classified \\
        --reasoning

HF Jobs example:
    hf jobs uv run --flavor l4x1 \\
        https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-dataset-sglang.py \\
        --input-dataset user/emails \\
        --column content \\
        --labels "spam,ham" \\
        --output-dataset user/emails-classified \\
        --reasoning
"""

import argparse
import logging
import os
import sys
from typing import List, Dict, Any, Optional, Tuple
import json
import re

import torch
from datasets import load_dataset, Dataset
from huggingface_hub import HfApi, get_token
import sglang as sgl

# Default model - SmolLM3 with reasoning capabilities
DEFAULT_MODEL = "HuggingFaceTB/SmolLM3-3B"

# 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 SGLang with reasoning support",
        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})",
    )
    parser.add_argument(
        "--reasoning",
        action="store_true",
        help="Enable reasoning mode (allows model to think through complex cases)",
    )
    parser.add_argument(
        "--save-reasoning",
        action="store_true",
        help="Save reasoning traces to a separate column (requires --reasoning)",
    )
    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=None,
        help="Hugging Face API token (default: auto-detect from HF_TOKEN env var or huggingface-cli login)",
    )
    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=500,
        help="Maximum tokens to generate (default: 500 for reasoning, 50 for non-reasoning)",
    )
    parser.add_argument(
        "--batch-size",
        type=int,
        default=32,
        help="Batch size for processing (default: 32)",
    )
    parser.add_argument(
        "--grammar-backend",
        type=str,
        default="xgrammar",
        choices=["outlines", "xgrammar", "llguidance"],
        help="Grammar backend for structured outputs (default: xgrammar)",
    )

    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 = f"{text[:MAX_TEXT_LENGTH]}..."

    return text


def validate_text(text: str) -> bool:
    """Check if text is valid for classification."""
    return bool(text and len(text) >= MIN_TEXT_LENGTH)


def create_classification_prompt(text: str, labels: List[str], reasoning: bool) -> str:
    """Create a prompt for classification with optional reasoning mode."""
    if reasoning:
        system_prompt = "You are a helpful assistant that thinks step-by-step before answering."
    else:
        system_prompt = "You are a helpful assistant. /no_think"
    
    user_prompt = f"""Classify this text as one of: {', '.join(labels)}

Text: {text}

Classification:"""
    
    # Format as a conversation
    return f"<|system|>\n{system_prompt}\n<|user|>\n{user_prompt}\n<|assistant|>\n"


def create_ebnf_grammar(labels: List[str]) -> str:
    """Create an EBNF grammar that constrains output to one of the given labels."""
    # Escape any special characters in labels
    escaped_labels = [f'"{label}"' for label in labels]
    choices = ' | '.join(escaped_labels)
    return f"root ::= {choices}"


def parse_reasoning_output(output: str, label: str) -> Optional[str]:
    """Extract reasoning from output if present."""
    # Look for thinking tags
    if "<think>" in output and "</think>" in output:
        start = output.find("<think>")
        end = output.find("</think>") + len("</think>")
        reasoning = output[start:end]
        return reasoning
    return None


def classify_batch_with_sglang(
    engine: sgl.Engine,
    texts: List[str],
    labels: List[str],
    args: argparse.Namespace
) -> List[Dict[str, Any]]:
    """Classify texts using SGLang with optional reasoning."""
    
    # Prepare prompts
    prompts = []
    valid_indices = []
    
    for i, text in enumerate(texts):
        processed_text = preprocess_text(text)
        if validate_text(processed_text):
            prompt = create_classification_prompt(processed_text, labels, args.reasoning)
            prompts.append(prompt)
            valid_indices.append(i)
    
    if not prompts:
        return [{"label": None, "reasoning": None} for _ in texts]
    
    # Set max tokens based on reasoning mode
    max_tokens = args.max_tokens if args.reasoning else 50
    
    # Create EBNF grammar for label constraints
    ebnf_grammar = create_ebnf_grammar(labels)
    
    # Set up sampling parameters with EBNF constraint
    sampling_params = {
        "temperature": args.temperature,
        "max_new_tokens": max_tokens,
        "ebnf": ebnf_grammar,  # This ensures output is one of the valid labels
    }
    
    try:
        # Generate with structured output constraint
        outputs = engine.generate(prompts, sampling_params)
        
        # Process outputs
        results = [{"label": None, "reasoning": None} for _ in texts]
        
        for idx, output in enumerate(outputs):
            original_idx = valid_indices[idx]
            
            # The output text should be just the label due to EBNF constraint
            classification = output.text.strip().strip('"')  # Remove quotes if present
            
            # Extract reasoning if present and requested
            reasoning = None
            if args.reasoning and args.save_reasoning:
                # Get the full output including reasoning
                # Note: We need to check if SGLang provides access to full output with reasoning
                reasoning = parse_reasoning_output(output.text, classification)
            
            results[original_idx] = {
                "label": classification,
                "reasoning": reasoning
            }
        
        return results
        
    except Exception as e:
        logger.error(f"Error during batch classification: {e}")
        # Return None labels for all texts in case of error
        return [{"label": None, "reasoning": None} for _ in texts]


def main():
    args = parse_args()

    # Validate reasoning arguments
    if args.save_reasoning and not args.reasoning:
        logger.error("--save-reasoning requires --reasoning to be enabled")
        sys.exit(1)

    # Check authentication early
    logger.info("Checking authentication...")
    token = args.hf_token or (os.environ.get("HF_TOKEN") or get_token())

    if not token:
        logger.error("No authentication token found. Please either:")
        logger.error("1. Run 'huggingface-cli login'")
        logger.error("2. Set HF_TOKEN environment variable")
        logger.error("3. Pass --hf-token argument")
        sys.exit(1)

    # Validate token by checking who we are
    try:
        api = HfApi(token=token)
        user_info = api.whoami()
        logger.info(f"Authenticated as: {user_info['name']}")
    except Exception as e:
        logger.error(f"Authentication failed: {e}")
        logger.error("Please check your token is valid")
        sys.exit(1)

    # 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 SGLang Engine
    logger.info(f"Initializing SGLang Engine with model: {args.model}")
    logger.info(f"Reasoning mode: {'enabled' if args.reasoning else 'disabled (fast mode)'}")
    logger.info(f"Grammar backend: {args.grammar_backend}")
    
    try:
        # Determine reasoning parser based on model
        reasoning_parser = None
        if "smollm3" in args.model.lower() or "qwen" in args.model.lower():
            reasoning_parser = "qwen"  # Uses <think> tokens
        elif "deepseek-r1" in args.model.lower():
            reasoning_parser = "deepseek-r1"
        
        engine_kwargs = {
            "model_path": args.model,
            "trust_remote_code": True,
            "dtype": "auto",
            "grammar_backend": args.grammar_backend,
        }
        
        if reasoning_parser and args.reasoning:
            engine_kwargs["reasoning_parser"] = reasoning_parser
            logger.info(f"Using reasoning parser: {reasoning_parser}")
        
        engine = sgl.Engine(**engine_kwargs)
        logger.info("SGLang engine initialized successfully")
    except Exception as e:
        logger.error(f"Failed to initialize SGLang: {e}")
        sys.exit(1)

    # Process in batches
    logger.info(f"Starting classification with batch size {args.batch_size}...")
    all_results = []
    
    for i in range(0, len(texts), args.batch_size):
        batch_end = min(i + args.batch_size, len(texts))
        batch_texts = texts[i:batch_end]
        
        logger.info(f"Processing batch {i//args.batch_size + 1}/{(len(texts) + args.batch_size - 1)//args.batch_size}")
        
        batch_results = classify_batch_with_sglang(
            engine, batch_texts, labels, args
        )
        all_results.extend(batch_results)

    # Extract labels and reasoning
    all_labels = [r["label"] for r in all_results]
    all_reasoning = [r["reasoning"] for r in all_results] if args.save_reasoning else None

    # Add classifications to dataset
    dataset = dataset.add_column("classification", all_labels)
    
    # Add reasoning column if requested
    if args.save_reasoning and args.reasoning:
        dataset = dataset.add_column("reasoning", all_reasoning)
        logger.info("Added reasoning traces to dataset")

    # Calculate statistics
    valid_count = sum(1 for label in all_labels if label is not None)
    invalid_count = len(all_labels) - valid_count
    
    if invalid_count > 0:
        logger.warning(
            f"{invalid_count} texts were too short or invalid for classification"
        )

    # Show classification distribution
    label_counts = {label: all_labels.count(label) for label in labels}
    logger.info("Classification distribution:")
    for label, count in label_counts.items():
        percentage = count / len(all_labels) * 100 if all_labels else 0
        logger.info(f"  {label}: {count} ({percentage:.1f}%)")
    if invalid_count > 0:
        none_percentage = invalid_count / len(all_labels) * 100
        logger.info(f"  Invalid/Skipped: {invalid_count} ({none_percentage:.1f}%)")

    # Log success rate
    success_rate = (valid_count / len(all_labels) * 100) if all_labels 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:
        commit_msg = f"Add classifications using {args.model} with SGLang"
        if args.reasoning:
            commit_msg += " (reasoning mode)"
        
        dataset.push_to_hub(
            args.output_dataset,
            token=token,
            commit_message=commit_msg,
        )
        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)

    # Clean up
    engine.shutdown()
    logger.info("SGLang engine shutdown complete")


if __name__ == "__main__":
    if len(sys.argv) == 1:
        print("Example HF Jobs commands:")
        print("\n# Fast classification (no reasoning):")
        print("hf jobs uv run \\")
        print("  --flavor l4x1 \\")
        print("  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-dataset-sglang.py \\")
        print("  --input-dataset stanfordnlp/imdb \\")
        print("  --column text \\")
        print("  --labels 'positive,negative' \\")
        print("  --output-dataset user/imdb-classified")
        print("\n# Complex classification with reasoning:")
        print("hf jobs uv run \\")
        print("  --flavor l4x1 \\")
        print("  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-dataset-sglang.py \\")
        print("  --input-dataset arxiv-papers \\")
        print("  --column abstract \\")
        print("  --labels 'reasoning_systems,agents,multimodal,robotics,other' \\")
        print("  --output-dataset user/arxiv-classified \\")
        print("  --reasoning --save-reasoning")
        sys.exit(0)

    main()