draft

generate-embeddings.py

@@ -0,0 +1,321 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "sentence-transformers>=3.0.0",
+#     "batched>=0.1.0",
+#     "torch",
+#     "huggingface-hub[hf_transfer]",
+#     "tqdm",
+#     "numpy",
+# ]
+# ///
+
+"""
+Generate embeddings for text datasets using Sentence Transformers with dynamic batching.
+
+This script efficiently generates embeddings for large datasets using GPU acceleration
+and dynamic batching for optimal throughput.
+
+Example usage:
+    # Basic usage
+    uv run generate-embeddings.py \
+        imdb \
+        imdb-embeddings \
+        --model-name sentence-transformers/all-MiniLM-L6-v2
+
+    # With custom batch size and column
+    uv run generate-embeddings.py \
+        scientific-papers \
+        paper-embeddings \
+        --model-name BAAI/bge-base-en-v1.5 \
+        --text-column abstract \
+        --batch-size 64
+
+    # Process subset for testing
+    uv run generate-embeddings.py \
+        my-dataset \
+        my-embeddings \
+        --max-samples 1000
+"""
+
+import argparse
+import logging
+import os
+import sys
+from typing import List, Optional
+
+import batched
+import numpy as np
+import torch
+from datasets import Dataset, load_dataset
+from huggingface_hub import login
+from sentence_transformers import SentenceTransformer
+from tqdm import tqdm
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def estimate_batch_size(model: SentenceTransformer, sample_text: str, gpu_memory_gb: float = None) -> int:
+    """Estimate optimal batch size based on available GPU memory."""
+    if not torch.cuda.is_available():
+        return 32  # CPU fallback
+    
+    if gpu_memory_gb is None:
+        # Get available GPU memory
+        gpu_memory_gb = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+    
+    # Get model size estimate
+    model_params = sum(p.numel() for p in model.parameters())
+    model_size_gb = (model_params * 4) / (1024**3)  # Assuming float32
+    
+    # Estimate based on model size and available memory
+    # Conservative estimate: use 60% of available memory for batching
+    available_for_batch = (gpu_memory_gb - model_size_gb) * 0.6
+    
+    # Estimate memory per sample (very rough approximation)
+    # Assuming average token length of 256, embedding dim of model.get_sentence_embedding_dimension()
+    embedding_dim = model.get_sentence_embedding_dimension()
+    memory_per_sample_gb = (256 * embedding_dim * 4) / (1024**3)
+    
+    estimated_batch_size = int(available_for_batch / memory_per_sample_gb)
+    
+    # Clamp to reasonable values
+    estimated_batch_size = max(8, min(estimated_batch_size, 512))
+    
+    logger.info(f"Estimated optimal batch size: {estimated_batch_size}")
+    return estimated_batch_size
+
+
+class EmbeddingGenerator:
+    """Wrapper class for embedding generation with dynamic batching."""
+    
+    def __init__(self, model: SentenceTransformer, batch_size: Optional[int] = None):
+        self.model = model
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = self.model.to(self.device)
+        
+        # Estimate batch size if not provided
+        if batch_size is None:
+            sample_text = "This is a sample text for batch size estimation."
+            batch_size = estimate_batch_size(model, sample_text)
+        
+        self.batch_size = batch_size
+        logger.info(f"Using device: {self.device}")
+        logger.info(f"Using batch size: {self.batch_size}")
+    
+    @batched.dynamically(timeout_ms=30000)
+    def generate_embeddings(self, texts: List[str]) -> List[np.ndarray]:
+        """Generate embeddings with dynamic batching."""
+        # Convert to tensors for GPU processing
+        embeddings = self.model.encode(
+            texts,
+            convert_to_tensor=True,
+            show_progress_bar=False,  # We'll use our own progress bar
+            device=self.device,
+            batch_size=self.batch_size  # Pass batch size to encode
+        )
+        # Convert back to numpy arrays
+        return embeddings.cpu().numpy()
+
+
+def process_dataset(
+    dataset: Dataset,
+    model: SentenceTransformer,
+    text_column: str,
+    batch_size: Optional[int] = None,
+    show_progress: bool = True
+) -> Dataset:
+    """Process dataset to add embeddings."""
+    
+    # Initialize embedding generator
+    generator = EmbeddingGenerator(model, batch_size)
+    
+    # Get texts
+    texts = dataset[text_column]
+    
+    # Filter out None/empty texts
+    valid_indices = []
+    valid_texts = []
+    for i, text in enumerate(texts):
+        if text and isinstance(text, str) and text.strip():
+            valid_indices.append(i)
+            valid_texts.append(text)
+    
+    if len(valid_texts) == 0:
+        logger.error(f"No valid texts found in column '{text_column}'")
+        sys.exit(1)
+    
+    logger.info(f"Processing {len(valid_texts)} valid texts (filtered {len(texts) - len(valid_texts)} invalid)")
+    
+    # Generate embeddings with progress bar
+    all_embeddings = []
+    
+    if show_progress:
+        # Process in chunks to show progress
+        chunk_size = generator.batch_size * 10  # Process multiple batches at once
+        for i in tqdm(range(0, len(valid_texts), chunk_size), desc="Generating embeddings"):
+            chunk = valid_texts[i:i + chunk_size]
+            chunk_embeddings = generator.generate_embeddings(chunk)
+            all_embeddings.extend(chunk_embeddings)
+    else:
+        all_embeddings = generator.generate_embeddings(valid_texts)
+    
+    # Create new dataset with embeddings
+    # Initialize with None for all indices
+    embedding_column = [None] * len(texts)
+    for idx, embedding in zip(valid_indices, all_embeddings):
+        embedding_column[idx] = embedding.tolist()
+    
+    # Add embeddings to dataset
+    dataset = dataset.add_column("embeddings", embedding_column)
+    
+    return dataset
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate embeddings for text datasets",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    
+    parser.add_argument(
+        "input_dataset",
+        type=str,
+        help="Input dataset ID from Hugging Face Hub",
+    )
+    parser.add_argument(
+        "output_dataset",
+        type=str,
+        help="Output dataset ID for Hugging Face Hub",
+    )
+    parser.add_argument(
+        "--model-name",
+        type=str,
+        default="sentence-transformers/all-MiniLM-L6-v2",
+        help="Sentence Transformer model to use (default: all-MiniLM-L6-v2)",
+    )
+    parser.add_argument(
+        "--text-column",
+        type=str,
+        default="text",
+        help="Name of the text column in the input dataset (default: text)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=None,
+        help="Batch size for processing (default: auto-detect based on GPU memory)",
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        default=None,
+        help="Maximum number of samples to process (default: all)",
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="train",
+        help="Dataset split to use (default: train)",
+    )
+    parser.add_argument(
+        "--hf-token",
+        type=str,
+        default=None,
+        help="Hugging Face API token",
+    )
+    parser.add_argument(
+        "--private",
+        action="store_true",
+        help="Make the output dataset private",
+    )
+    parser.add_argument(
+        "--normalize",
+        action="store_true",
+        help="Normalize embeddings to unit length",
+    )
+    
+    args = parser.parse_args()
+    
+    # Check GPU availability
+    if not torch.cuda.is_available():
+        logger.warning("CUDA is not available. Running on CPU will be slower.")
+        response = input("Continue anyway? (y/n): ")
+        if response.lower() != 'y':
+            sys.exit(0)
+    
+    # Login to Hugging Face
+    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
+    if hf_token:
+        login(token=hf_token)
+    else:
+        logger.warning("No HF token provided. You may not be able to push to the Hub.")
+    
+    # Load input dataset
+    logger.info(f"Loading dataset: {args.input_dataset}")
+    dataset = load_dataset(args.input_dataset, split=args.split)
+    
+    # Validate text column exists
+    if args.text_column not in dataset.column_names:
+        logger.error(f"Column '{args.text_column}' not found in dataset.")
+        logger.error(f"Available columns: {dataset.column_names}")
+        sys.exit(1)
+    
+    # Limit samples if requested
+    if args.max_samples:
+        dataset = dataset.select(range(min(args.max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+    
+    # Load model
+    logger.info(f"Loading model: {args.model_name}")
+    model = SentenceTransformer(args.model_name)
+    
+    # Set normalization if requested
+    if args.normalize:
+        model.normalize_embeddings = True
+        logger.info("Embeddings will be normalized to unit length")
+    
+    # Log model info
+    embedding_dim = model.get_sentence_embedding_dimension()
+    logger.info(f"Embedding dimension: {embedding_dim}")
+    logger.info(f"Max sequence length: {model.max_seq_length}")
+    
+    # Process dataset
+    dataset_with_embeddings = process_dataset(
+        dataset,
+        model,
+        args.text_column,
+        args.batch_size
+    )
+    
+    # Log statistics
+    logger.info(f"\n✅ Generated embeddings for {len(dataset_with_embeddings)} samples")
+    logger.info(f"Embedding dimension: {embedding_dim}")
+    
+    # Show sample
+    sample = dataset_with_embeddings[0]
+    logger.info(f"\nSample:")
+    logger.info(f"Text: {sample[args.text_column][:100]}...")
+    if sample['embeddings'] is not None:
+        logger.info(f"Embedding shape: {len(sample['embeddings'])}")
+        logger.info(f"Embedding (first 5 values): {sample['embeddings'][:5]}")
+    
+    # Push to Hub
+    logger.info(f"\nPushing dataset to Hub: {args.output_dataset}")
+    dataset_with_embeddings.push_to_hub(args.output_dataset, private=args.private)
+    
+    logger.info(f"\n✅ Dataset with embeddings available at: https://huggingface.co/datasets/{args.output_dataset}")
+
+
+if __name__ == "__main__":
+    # Show example command if no args provided
+    if len(sys.argv) == 1:
+        print("Example command:")
+        print("uv run generate-embeddings.py imdb imdb-embeddings --model-name sentence-transformers/all-MiniLM-L6-v2")
+        print("\nFor HF Jobs:")
+        print("hf jobs run --gpu a10 uv run generate-embeddings.py <input> <output> --model-name <model>")
+    
+    main()