Enhance dataset card creation with filtering statistics and add option to skip long prompts

generate-responses.py

@@ -87,8 +87,25 @@ def create_dataset_card(
     tensor_parallel_size: int,
     num_examples: int,
     generation_time: str,
+    num_skipped: int = 0,
+    max_model_len_used: Optional[int] = None,
 ) -> str:
     """Create a comprehensive dataset card documenting the generation process."""
+    filtering_section = ""
+    if num_skipped > 0:
+        skip_percentage = (num_skipped / num_examples) * 100
+        processed = num_examples - num_skipped
+        filtering_section = f"""
+
+### Filtering Statistics
+
+- **Total Examples**: {num_examples:,}
+- **Processed**: {processed:,} ({100 - skip_percentage:.1f}%)
+- **Skipped (too long)**: {num_skipped:,} ({skip_percentage:.1f}%)
+- **Max Model Length Used**: {max_model_len_used:,} tokens
+
+Note: Prompts exceeding the maximum model length were skipped and have empty responses."""
+    
     return f"""---
 viewer: false
 tags:
@@ -107,7 +124,7 @@ This dataset contains generated responses for prompts from [{source_dataset}](ht
 - **Messages Column**: `{messages_column}`
 - **Model**: [{model_id}](https://huggingface.co/{model_id})
 - **Number of Examples**: {num_examples:,}
-- **Generation Date**: {generation_time}
+- **Generation Date**: {generation_time}{filtering_section}
 
 ### Sampling Parameters
 
@@ -143,7 +160,7 @@ uv run https://huggingface.co/datasets/uv-scripts/vllm/raw/main/generate-respons
     --temperature {sampling_params.temperature} \\
     --top-p {sampling_params.top_p} \\
     --top-k {sampling_params.top_k} \\
-    --max-tokens {sampling_params.max_tokens}
+    --max-tokens {sampling_params.max_tokens}{f' \\\\\\n    --max-model-len {max_model_len_used}' if max_model_len_used else ''}
 ```
 """
 
@@ -163,6 +180,7 @@ def main(
     gpu_memory_utilization: float = 0.90,
     max_model_len: Optional[int] = None,
     tensor_parallel_size: Optional[int] = None,
+    skip_long_prompts: bool = True,
     hf_token: Optional[str] = None,
 ):
     """
@@ -183,6 +201,7 @@ def main(
         gpu_memory_utilization: GPU memory utilization factor
         max_model_len: Maximum model context length (None uses model default)
         tensor_parallel_size: Number of GPUs to use (auto-detect if None)
+        skip_long_prompts: Skip prompts exceeding max_model_len instead of failing
         hf_token: Hugging Face authentication token
     """
     generation_start_time = datetime.now().isoformat()
@@ -254,29 +273,72 @@ def main(
         )
         sys.exit(1)
 
+    # Get effective max length for filtering
+    if max_model_len is not None:
+        effective_max_len = max_model_len
+    else:
+        # Get model's default max length
+        effective_max_len = llm.llm_engine.model_config.max_model_len
+    logger.info(f"Using effective max model length: {effective_max_len}")
+
     # Process messages and apply chat template
     logger.info("Applying chat template to messages...")
-    prompts = []
-    for example in tqdm(dataset, desc="Processing messages"):
+    all_prompts = []
+    valid_prompts = []
+    valid_indices = []
+    skipped_info = []
+    
+    for i, example in enumerate(tqdm(dataset, desc="Processing messages")):
         messages = example[messages_column]
         # Apply chat template
         prompt = tokenizer.apply_chat_template(
             messages, tokenize=False, add_generation_prompt=True
         )
-        prompts.append(prompt)
+        all_prompts.append(prompt)
+        
+        # Count tokens if filtering is enabled
+        if skip_long_prompts:
+            tokens = tokenizer.encode(prompt)
+            if len(tokens) <= effective_max_len:
+                valid_prompts.append(prompt)
+                valid_indices.append(i)
+            else:
+                skipped_info.append((i, len(tokens)))
+        else:
+            valid_prompts.append(prompt)
+            valid_indices.append(i)
+    
+    # Log filtering results
+    if skip_long_prompts and skipped_info:
+        logger.warning(f"Skipped {len(skipped_info)} prompts that exceed max_model_len ({effective_max_len} tokens)")
+        logger.info("Skipped prompt details (first 10):")
+        for idx, (prompt_idx, token_count) in enumerate(skipped_info[:10]):
+            logger.info(f"  - Example {prompt_idx}: {token_count} tokens (exceeds by {token_count - effective_max_len})")
+        if len(skipped_info) > 10:
+            logger.info(f"  ... and {len(skipped_info) - 10} more")
+        
+        skip_percentage = (len(skipped_info) / total_examples) * 100
+        if skip_percentage > 10:
+            logger.warning(f"WARNING: {skip_percentage:.1f}% of prompts were skipped!")
+    
+    if not valid_prompts:
+        logger.error("No valid prompts to process after filtering!")
+        sys.exit(1)
 
     # Generate responses - vLLM handles batching internally
-    logger.info(f"Starting generation for {len(prompts):,} prompts...")
+    logger.info(f"Starting generation for {len(valid_prompts):,} valid prompts...")
     logger.info("vLLM will handle batching and scheduling automatically")
 
-    outputs = llm.generate(prompts, sampling_params)
+    outputs = llm.generate(valid_prompts, sampling_params)
 
-    # Extract generated text
+    # Extract generated text and create full response list
     logger.info("Extracting generated responses...")
-    responses = []
-    for output in outputs:
+    responses = [""] * total_examples  # Initialize with empty strings
+    
+    for idx, output in enumerate(outputs):
+        original_idx = valid_indices[idx]
         response = output.outputs[0].text.strip()
-        responses.append(response)
+        responses[original_idx] = response
 
     # Add responses to dataset
     logger.info("Adding responses to dataset...")
@@ -292,6 +354,8 @@ def main(
         tensor_parallel_size=tensor_parallel_size,
         num_examples=total_examples,
         generation_time=generation_start_time,
+        num_skipped=len(skipped_info) if skip_long_prompts else 0,
+        max_model_len_used=effective_max_len if skip_long_prompts else None,
     )
 
     # Push dataset to hub
@@ -416,6 +480,18 @@ Examples:
             type=str,
             help="Hugging Face token (can also use HF_TOKEN env var)",
         )
+        parser.add_argument(
+            "--skip-long-prompts",
+            action="store_true",
+            default=True,
+            help="Skip prompts that exceed max_model_len instead of failing (default: True)",
+        )
+        parser.add_argument(
+            "--no-skip-long-prompts",
+            dest="skip_long_prompts",
+            action="store_false",
+            help="Fail on prompts that exceed max_model_len",
+        )
 
         args = parser.parse_args()
 
@@ -434,6 +510,7 @@ Examples:
             gpu_memory_utilization=args.gpu_memory_utilization,
             max_model_len=args.max_model_len,
             tensor_parallel_size=args.tensor_parallel_size,
+            skip_long_prompts=args.skip_long_prompts,
             hf_token=args.hf_token,
         )
     else: