ruff format

classify-dataset.py

@@ -54,7 +54,9 @@ from toolz import concat, keymap, partition_all
 from tqdm.auto import tqdm
 from vllm import LLM
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
 
@@ -62,9 +64,11 @@ def check_gpu_availability():
     """Check if CUDA is available and log GPU information."""
     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 NVIDIA GPU or use HF Jobs with GPU flavor.")
+        logger.error(
+            "Please run on a machine with NVIDIA GPU or use HF Jobs with GPU flavor."
+        )
         sys.exit(1)
-    
+
     gpu_name = torch.cuda.get_device_name(0)
     gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
     logger.info(f"GPU detected: {gpu_name} with {gpu_memory:.1f} GB memory")
@@ -75,25 +79,24 @@ def get_model_id2label(hub_model_id: str) -> Optional[dict[int, str]]:
     """Extract label mapping from model's config.json on Hugging Face Hub."""
     try:
         response = httpx.get(
-            hf_hub_url(hub_model_id, filename="config.json"),
-            follow_redirects=True
+            hf_hub_url(hub_model_id, filename="config.json"), follow_redirects=True
         )
         if response.status_code != 200:
             logger.warning(f"Could not fetch config.json for {hub_model_id}")
             return None
-        
+
         data = response.json()
         id2label = data.get("id2label")
-        
+
         if id2label is None:
             logger.info("No id2label mapping found in config.json")
             return None
-        
+
         # Convert string keys to integers
         label_map = keymap(int, id2label)
         logger.info(f"Found label mapping: {label_map}")
         return label_map
-    
+
     except Exception as e:
         logger.warning(f"Failed to parse config.json: {e}")
         return None
@@ -102,11 +105,11 @@ def get_model_id2label(hub_model_id: str) -> Optional[dict[int, str]]:
 def get_top_label(output, label_map: Optional[dict[int, str]] = None):
     """
     Extract the top predicted label and confidence score from vLLM output.
-    
+
     Args:
         output: vLLM ClassificationRequestOutput
         label_map: Optional mapping from label indices to label names
-    
+
     Returns:
         Tuple of (label, confidence_score)
     """
@@ -114,7 +117,7 @@ def get_top_label(output, label_map: Optional[dict[int, str]] = None):
     probs = F.softmax(logits, dim=0)
     top_idx = torch.argmax(probs).item()
     top_prob = probs[top_idx].item()
-    
+
     # Use label name if mapping available, otherwise use index
     label = label_map.get(top_idx, str(top_idx)) if label_map else str(top_idx)
     return label, top_prob
@@ -130,7 +133,7 @@ def main(
 ):
     """
     Main classification pipeline.
-    
+
     Args:
         hub_model_id: Hugging Face model ID for classification
         src_dataset_hub_id: Input dataset on Hugging Face Hub
@@ -141,58 +144,62 @@ def main(
     """
     # GPU check
     check_gpu_availability()
-    
+
     # Authentication
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
     if HF_TOKEN:
         login(token=HF_TOKEN)
     else:
-        logger.error("HF_TOKEN is required. Set via --hf-token or HF_TOKEN environment variable.")
+        logger.error(
+            "HF_TOKEN is required. Set via --hf-token or HF_TOKEN environment variable."
+        )
         sys.exit(1)
-    
+
     # Initialize vLLM with classification task
     logger.info(f"Loading model: {hub_model_id}")
     llm = LLM(model=hub_model_id, task="classify")
-    
+
     # Get label mapping if available
     id2label = get_model_id2label(hub_model_id)
-    
+
     # Load dataset
     logger.info(f"Loading dataset: {src_dataset_hub_id}")
     dataset = load_dataset(src_dataset_hub_id, split="train")
     total_examples = len(dataset)
     logger.info(f"Dataset loaded with {total_examples:,} examples")
-    
+
     # Extract text column
     if inference_column not in dataset.column_names:
-        logger.error(f"Column '{inference_column}' not found. Available columns: {dataset.column_names}")
+        logger.error(
+            f"Column '{inference_column}' not found. Available columns: {dataset.column_names}"
+        )
         sys.exit(1)
-    
+
     prompts = dataset[inference_column]
-    
+
     # Process in batches
     logger.info(f"Starting classification with batch size {batch_size:,}")
     all_results = []
-    
+
     for batch in tqdm(
         list(partition_all(batch_size, prompts)),
         desc="Processing batches",
-        unit="batch"
+        unit="batch",
     ):
         batch_results = llm.classify(batch)
         all_results.append(batch_results)
-    
+
     # Flatten results
     outputs = list(concat(all_results))
-    
+
     # Extract labels and probabilities
     logger.info("Extracting predictions...")
     labels_and_probs = [get_top_label(output, id2label) for output in outputs]
-    
+
     # Add results to dataset
     dataset = dataset.add_column("label", [label for label, _ in labels_and_probs])
     dataset = dataset.add_column("prob", [prob for _, prob in labels_and_probs])
-    
+
     # Push to hub
     logger.info(f"Pushing results to: {output_dataset_hub_id}")
     dataset.push_to_hub(output_dataset_hub_id, token=HF_TOKEN)
@@ -216,41 +223,40 @@ Examples:
   
   # Using environment variable for token
   HF_TOKEN=hf_xxx uv run classify-dataset.py model/name input-dataset output-dataset
-            """
+            """,
         )
-        
+
         parser.add_argument(
             "hub_model_id",
-            help="Hugging Face model ID for classification (e.g., bert-base-uncased)"
+            help="Hugging Face model ID for classification (e.g., bert-base-uncased)",
         )
         parser.add_argument(
             "src_dataset_hub_id",
-            help="Input dataset on Hugging Face Hub (e.g., username/dataset-name)"
+            help="Input dataset on Hugging Face Hub (e.g., username/dataset-name)",
         )
         parser.add_argument(
-            "output_dataset_hub_id",
-            help="Output dataset name on Hugging Face Hub"
+            "output_dataset_hub_id", help="Output dataset name on Hugging Face Hub"
         )
         parser.add_argument(
             "--inference-column",
             type=str,
             default="text",
-            help="Column containing text to classify (default: text)"
+            help="Column containing text to classify (default: text)",
         )
         parser.add_argument(
             "--batch-size",
             type=int,
             default=10_000,
-            help="Batch size for inference (default: 10,000)"
+            help="Batch size for inference (default: 10,000)",
         )
         parser.add_argument(
             "--hf-token",
             type=str,
-            help="Hugging Face token (can also use HF_TOKEN env var)"
+            help="Hugging Face token (can also use HF_TOKEN env var)",
         )
-        
+
         args = parser.parse_args()
-        
+
         main(
             hub_model_id=args.hub_model_id,
             src_dataset_hub_id=args.src_dataset_hub_id,
@@ -283,4 +289,4 @@ Example HF Jobs command:
         ' \\
         --project vllm-classify \\
         --name my-classification-job
-        """)
+        """)

generate-responses.py

@@ -42,9 +42,8 @@ import logging
 import os
 import sys
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
-import torch
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, get_token, login
 from torch import cuda
@@ -105,7 +104,7 @@ def create_dataset_card(
 - **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:
@@ -160,7 +159,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}{f' \\\\\\n    --max-model-len {max_model_len_used}' if max_model_len_used else ''}
+    --max-tokens {sampling_params.max_tokens}{f" \\\\\\n    --max-model-len {max_model_len_used}" if max_model_len_used else ""}
 ```
 """
 
@@ -287,7 +286,7 @@ def main(
     valid_prompts = []
     valid_indices = []
     skipped_info = []
-    
+
     for i, example in enumerate(tqdm(dataset, desc="Processing messages")):
         messages = example[messages_column]
         # Apply chat template
@@ -295,7 +294,7 @@ def main(
             messages, tokenize=False, add_generation_prompt=True
         )
         all_prompts.append(prompt)
-        
+
         # Count tokens if filtering is enabled
         if skip_long_prompts:
             tokens = tokenizer.encode(prompt)
@@ -307,20 +306,24 @@ def main(
         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.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})")
+            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)
@@ -334,7 +337,7 @@ def main(
     # Extract generated text and create full response list
     logger.info("Extracting generated responses...")
     responses = [""] * total_examples  # Initialize with empty strings
-    
+
     for idx, output in enumerate(outputs):
         original_idx = valid_indices[idx]
         response = output.outputs[0].text.strip()