update

classify-dataset.py

@@ -3,7 +3,7 @@
 # requires-python = ">=3.10"
 # dependencies = [
 #     "vllm>=0.6.6",
-#     "transformers",
+#     "transformers>=4.53.0",
 #     "torch",
 #     "datasets",
 #     "huggingface-hub[hf_transfer]",
@@ -36,42 +36,95 @@ import argparse
 import logging
 import os
 import sys
-from typing import List, Dict, Any, Optional
+from typing import List
 
 import torch
-from datasets import load_dataset, Dataset
+from datasets import load_dataset
 from huggingface_hub import HfApi, get_token
+from transformers import AutoTokenizer
 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}
+def parse_label_descriptions(desc_string: str) -> dict:
+    """Parse label descriptions from CLI format 'label1:desc1,label2:desc2'."""
+    if not desc_string:
+        return {}
+    
+    descriptions = {}
+    # Split by comma, but be careful about commas in descriptions
+    parts = desc_string.split(',')
+    
+    current_label = None
+    current_desc_parts = []
+    
+    for part in parts:
+        if ':' in part and not current_label:
+            # New label:description pair
+            label, desc = part.split(':', 1)
+            current_label = label.strip()
+            current_desc_parts = [desc.strip()]
+        elif ':' in part and current_label:
+            # Save previous label and start new one
+            descriptions[current_label] = ','.join(current_desc_parts)
+            label, desc = part.split(':', 1)
+            current_label = label.strip()
+            current_desc_parts = [desc.strip()]
+        else:
+            # Continuation of previous description (had comma in it)
+            current_desc_parts.append(part.strip())
+    
+    # Don't forget the last one
+    if current_label:
+        descriptions[current_label] = ','.join(current_desc_parts)
+    
+    return descriptions
 
-Text: {text}
-
-Label:""",
-    
-    "detailed": """Task: Classify the following text into EXACTLY ONE of these categories.
-Available categories: {labels}
 
-Text to classify:
-{text}
+def create_messages(text: str, labels: List[str], label_descriptions: dict = None, enable_reasoning: bool = False) -> List[dict]:
+    """Create messages for chat template with optional label descriptions."""
+    
+    # Build the classification prompt
+    if label_descriptions:
+        # Format with descriptions
+        categories_text = "Categories:\n"
+        for label in labels:
+            desc = label_descriptions.get(label, "")
+            if desc:
+                categories_text += f"- {label}: {desc}\n"
+            else:
+                categories_text += f"- {label}\n"
+    else:
+        # Simple format without descriptions
+        categories_text = f"Categories: {', '.join(labels)}"
+    
+    if enable_reasoning:
+        # Reasoning mode: allow thinking and request JSON output
+        user_content = f"""Classify this text into one of these categories:
 
-Category:""",
-    
-    "reasoning": """Analyze the following text and determine which category it belongs to.
-Available categories: {labels}
+{categories_text}
 
-Text to analyze:
-{text}
+Text: {text}
 
-Brief analysis: Let me examine the key aspects of this text.
-Category:""",
-}
+Think through your classification step by step, then provide your final answer in this JSON format:
+{{"label": "your_chosen_label"}}"""
+        
+        system_content = "You are a helpful classification assistant that thinks step by step."
+    else:
+        # Structured output mode: fast classification
+        if label_descriptions:
+            user_content = f"Classify this text into one of these categories:\n\n{categories_text}\nText: {text}\n\nCategory:"
+        else:
+            user_content = f"Classify this text as one of: {', '.join(labels)}\n\nText: {text}\n\nLabel:"
+        
+        system_content = "You are a helpful classification assistant. /no_think"
+    
+    return [
+        {"role": "system", "content": system_content},
+        {"role": "user", "content": user_content}
+    ]
 
 # Minimum text length for valid classification
 MIN_TEXT_LENGTH = 3
@@ -79,7 +132,79 @@ 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')
+
+def parse_reasoning_output(output: str, valid_labels: List[str]) -> tuple[str, str, bool]:
+    """Parse reasoning output to extract label from JSON after </think> tag.
+    
+    Returns:
+        tuple: (label or None, full reasoning text, parsing_success)
+    """
+    import json
+    
+    # Find the </think> tag
+    think_end = output.find("</think>")
+    
+    if think_end != -1:
+        # Extract everything after </think>
+        json_part = output[think_end + len("</think>"):].strip()
+        reasoning = output[:think_end + len("</think>")]
+    else:
+        # No think tags, look for JSON in the output
+        # Try to find JSON by looking for {
+        json_start = output.find("{")
+        if json_start != -1:
+            json_part = output[json_start:].strip()
+            reasoning = output[:json_start].strip() if json_start > 0 else ""
+        else:
+            json_part = output
+            reasoning = output
+    
+    # Try to parse JSON
+    try:
+        # Find the first complete JSON object
+        if "{" in json_part:
+            # Extract just the JSON object
+            json_str = json_part[json_part.find("{"):]
+            # Find the matching closing brace
+            brace_count = 0
+            end_pos = 0
+            for i, char in enumerate(json_str):
+                if char == "{":
+                    brace_count += 1
+                elif char == "}":
+                    brace_count -= 1
+                    if brace_count == 0:
+                        end_pos = i + 1
+                        break
+            
+            if end_pos > 0:
+                json_str = json_str[:end_pos]
+                data = json.loads(json_str)
+                label = data.get("label", "")
+                
+                # Validate label
+                if label in valid_labels:
+                    return label, output, True
+                else:
+                    logger.warning(f"Parsed label '{label}' not in valid labels: {valid_labels}")
+                    return None, output, False
+            else:
+                logger.warning("Could not find complete JSON object")
+                return None, output, False
+        else:
+            logger.warning("No JSON found in output")
+            return None, output, False
+            
+    except json.JSONDecodeError as e:
+        logger.warning(f"JSON parsing error: {e}")
+        return None, output, False
+    except Exception as e:
+        logger.warning(f"Unexpected error parsing output: {e}")
+        return None, output, False
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
 
@@ -87,87 +212,99 @@ def parse_args():
     parser = argparse.ArgumentParser(
         description="Classify text in HuggingFace datasets using vLLM with structured outputs",
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__
+        epilog=__doc__,
     )
-    
+
     # Required arguments
     parser.add_argument(
         "--input-dataset",
         type=str,
         required=True,
-        help="Input dataset ID on Hugging Face Hub"
+        help="Input dataset ID on Hugging Face Hub",
     )
     parser.add_argument(
-        "--column",
-        type=str,
-        required=True,
-        help="Name of the text column to classify"
+        "--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')"
+        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"
+        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})"
+        help=f"Model to use for classification (default: {DEFAULT_MODEL})",
     )
     # Removed --batch-size argument as vLLM handles batching internally
     parser.add_argument(
-        "--prompt-style",
+        "--label-descriptions",
         type=str,
-        choices=list(PROMPT_STYLES.keys()),
-        default="simple",
-        help="Prompt style to use (default: simple)"
+        default=None,
+        help="Descriptions for each label in format 'label1:description1,label2:description2'",
+    )
+    parser.add_argument(
+        "--enable-reasoning",
+        action="store_true",
+        help="Enable reasoning mode with thinking traces (disables structured outputs)",
     )
     parser.add_argument(
         "--max-samples",
         type=int,
         default=None,
-        help="Maximum number of samples to process (for testing)"
+        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)"
+        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)"
+        help="Dataset split to process (default: train)",
     )
     parser.add_argument(
         "--temperature",
         type=float,
         default=0.1,
-        help="Temperature for generation (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)"
+        default=100,
+        help="Maximum tokens to generate (default: 100, automatically increased 20x for reasoning mode)",
     )
     parser.add_argument(
         "--guided-backend",
         type=str,
         default="outlines",
-        help="Guided decoding backend (default: outlines)"
+        help="Guided decoding backend (default: outlines)",
     )
-    
+    parser.add_argument(
+        "--shuffle",
+        action="store_true",
+        help="Shuffle dataset before selecting samples (useful with --max-samples for random sampling)",
+    )
+    parser.add_argument(
+        "--shuffle-seed",
+        type=int,
+        default=42,
+        help="Random seed for shuffling (default: 42)",
+    )
+
     return parser.parse_args()
 
 
@@ -175,63 +312,62 @@ 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] + "..."
-        
+        text = f"{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
+    return bool(text and len(text) >= MIN_TEXT_LENGTH)
 
 
 def prepare_prompts(
-    texts: List[str],
-    labels: List[str],
-    prompt_template: str
+    texts: List[str], labels: List[str], tokenizer: AutoTokenizer, 
+    label_descriptions: dict = None, enable_reasoning: bool = False
 ) -> tuple[List[str], List[int]]:
-    """Prepare prompts for classification, filtering invalid texts."""
+    """Prepare prompts using chat template 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
+            # Create messages for chat template
+            messages = create_messages(processed_text, labels, label_descriptions, enable_reasoning)
+            
+            # Apply chat template
+            prompt = tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True
             )
             prompts.append(prompt)
             valid_indices.append(i)
-    
+
     return prompts, valid_indices
 
 
 def main():
     args = parse_args()
-    
+
     # Check authentication early
     logger.info("Checking authentication...")
-    token = args.hf_token
-    if not token:
-        # Try to get token from environment or huggingface-cli login
-        token = os.environ.get("HF_TOKEN") or get_token()
-    
+    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)
@@ -241,15 +377,15 @@ def main():
         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:
@@ -257,30 +393,52 @@ def main():
         sys.exit(1)
     logger.info(f"Classification labels: {labels}")
     
+    # Parse label descriptions if provided
+    label_descriptions = None
+    if args.label_descriptions:
+        label_descriptions = parse_label_descriptions(args.label_descriptions)
+        logger.info("Label descriptions provided:")
+        for label, desc in label_descriptions.items():
+            logger.info(f"  {label}: {desc}")
+
     # Load dataset
     logger.info(f"Loading dataset: {args.input_dataset}")
     try:
         dataset = load_dataset(args.input_dataset, split=args.split)
-        
+        logger.info(f"Loaded {len(dataset)} samples from split '{args.split}'")
+
+        # Shuffle if requested
+        if args.shuffle:
+            logger.info(f"Shuffling dataset with seed {args.shuffle_seed}")
+            dataset = dataset.shuffle(seed=args.shuffle_seed)
+
         # 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}'")
+            if args.shuffle:
+                logger.info("Note: Samples were randomly selected due to shuffling")
     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]
-    
+
+    # Load tokenizer for chat template formatting
+    logger.info(f"Loading tokenizer for {args.model}")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True)
+    except Exception as e:
+        logger.error(f"Failed to load tokenizer: {e}")
+        sys.exit(1)
+
     # Initialize vLLM
     logger.info(f"Initializing vLLM with model: {args.model}")
     logger.info(f"Using guided decoding backend: {args.guided_backend}")
@@ -295,85 +453,139 @@ def main():
     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")
-    
+
+    # Set up sampling parameters based on mode
+    if args.enable_reasoning:
+        # Reasoning mode: no guided decoding, much more tokens for thinking
+        sampling_params = SamplingParams(
+            temperature=args.temperature,
+            max_tokens=args.max_tokens * 20,  # 20x more tokens for extensive reasoning
+        )
+        logger.info("Using reasoning mode - model will generate thinking traces with JSON output")
+    else:
+        # Structured output mode: guided decoding
+        guided_params = GuidedDecodingParams(choice=labels)
+        sampling_params = SamplingParams(
+            guided_decoding=guided_params,
+            temperature=args.temperature,
+            max_tokens=args.max_tokens,
+        )
+        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)
-    
+    all_prompts, valid_indices = prepare_prompts(texts, labels, tokenizer, label_descriptions, args.enable_reasoning)
+
     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
-        
+
+        # Process outputs based on mode
+        if args.enable_reasoning:
+            # Reasoning mode: parse JSON and extract reasoning
+            all_classifications = [None] * len(texts)
+            all_reasoning = [None] * len(texts)
+            all_parsing_success = [False] * len(texts)
+            
+            for idx, output in enumerate(outputs):
+                original_idx = valid_indices[idx]
+                generated_text = output.outputs[0].text.strip()
+                
+                # Parse the reasoning output
+                label, reasoning, success = parse_reasoning_output(generated_text, labels)
+                
+                all_classifications[original_idx] = label
+                all_reasoning[original_idx] = reasoning
+                all_parsing_success[original_idx] = success
+                
+                # Log first few examples
+                if idx < 3:
+                    logger.info(f"\nExample {idx + 1} output:")
+                    logger.info(f"Raw output: {generated_text[:200]}...")
+                    logger.info(f"Parsed label: {label}")
+                    logger.info(f"Parsing success: {success}")
+            
+            # Count parsing statistics
+            parsing_success_count = sum(1 for s in all_parsing_success if s)
+            parsing_fail_count = sum(1 for s in all_parsing_success if s is not None and not s)
+            logger.info(f"\nParsing statistics:")
+            logger.info(f"  Successful: {parsing_success_count}/{len(valid_indices)} ({parsing_success_count/len(valid_indices)*100:.1f}%)")
+            logger.info(f"  Failed: {parsing_fail_count}/{len(valid_indices)} ({parsing_fail_count/len(valid_indices)*100:.1f}%)")
+            
+            valid_texts = parsing_success_count
+        else:
+            # Structured output mode: direct classification
+            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
+            
+            valid_texts = len(valid_indices)
+
         # 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
+
+    # Add columns to dataset
     dataset = dataset.add_column("classification", all_classifications)
     
+    if args.enable_reasoning:
+        dataset = dataset.add_column("reasoning", all_reasoning)
+        dataset = dataset.add_column("parsing_success", all_parsing_success)
+
     # 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")
-    
+        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}
+    
+    # Count None values separately
+    none_classifications = all_classifications.count(None)
+    
     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}%)")
     
+    if none_classifications > 0:
+        none_percentage = none_classifications / total_texts * 100
+        if args.enable_reasoning:
+            logger.info(f"  Failed to parse: {none_classifications} ({none_percentage:.1f}%)")
+        else:
+            logger.info(f"  Invalid/Skipped: {none_classifications} ({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 (token already validated at start)
     logger.info(f"Pushing dataset to Hub: {args.output_dataset}")
     try:
         dataset.push_to_hub(
             args.output_dataset,
             token=token,
-            commit_message=f"Add classifications using {args.model} with structured outputs"
+            commit_message=f"Add classifications using {args.model} {'with reasoning' if args.enable_reasoning else 'with structured outputs'}",
+        )
+        logger.info(
+            f"Successfully pushed to: https://huggingface.co/datasets/{args.output_dataset}"
         )
-        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)
@@ -381,7 +593,28 @@ def main():
 
 if __name__ == "__main__":
     if len(sys.argv) == 1:
-        print("Example HF Jobs command:")
+        print("Example commands:")
+        print("\n# Simple classification:")
+        print("uv run classify-dataset.py \\")
+        print("  --input-dataset stanfordnlp/imdb \\")
+        print("  --column text \\")
+        print("  --labels 'positive,negative' \\")
+        print("  --output-dataset user/imdb-classified")
+        print("\n# With label descriptions:")
+        print("uv run classify-dataset.py \\")
+        print("  --input-dataset user/support-tickets \\")
+        print("  --column content \\")
+        print("  --labels 'bug,feature,question' \\")
+        print("  --label-descriptions 'bug:something is broken or not working,feature:request for new functionality,question:asking for help or clarification' \\")
+        print("  --output-dataset user/tickets-classified")
+        print("\n# With reasoning mode (thinking + JSON output):")
+        print("uv run classify-dataset.py \\")
+        print("  --input-dataset stanfordnlp/imdb \\")
+        print("  --column text \\")
+        print("  --labels 'positive,negative,neutral' \\")
+        print("  --enable-reasoning \\")
+        print("  --output-dataset user/imdb-reasoned")
+        print("\n# HF Jobs example:")
         print("hf jobs uv run \\")
         print("  --flavor l4x1 \\")
         print("  --image vllm/vllm-openai:latest \\")
@@ -391,5 +624,5 @@ if __name__ == "__main__":
         print("  --labels 'positive,negative' \\")
         print("  --output-dataset user/imdb-classified")
         sys.exit(0)
-    
-    main()
+
+    main()