classification/benchmark_encode_batch_size.py

# /// script
# dependencies = [
#     "sentence-transformers",
#     "torch",
#     "numpy<2",
#     "polars[pyarrow]",
#     "pyarrow",
#     "huggingface_hub",
# ]
# requires-python = ">=3.10"
# ///
"""
Benchmark sentence-transformer encode batch sizes on a representative sample.

Usage:
    uv run classification/benchmark_encode_batch_size.py

Useful env vars:
    REPO_ID=duarteocarmo/fineweb2-bagaco2
    INPUT_PREFIX=fineweb2-ptpt-prototype/
    MODEL_NAME=intfloat/multilingual-e5-small
    SAMPLE_ROWS=12000
    PARQUET_COUNT=2
    MAX_CHARS=800
    BATCH_SIZES=1024,1536,2048,2560,3072,3584,4096
"""

import os
import subprocess
import time
from pathlib import Path
from types import SimpleNamespace

import polars
from huggingface_hub import HfApi

config = SimpleNamespace(
    repo_id=os.getenv("REPO_ID", "duarteocarmo/fineweb2-bagaco2"),
    input_prefix=os.getenv("INPUT_PREFIX", "fineweb2-ptpt-prototype/"),
    model_name=os.getenv("MODEL_NAME", "intfloat/multilingual-e5-small"),
    download_dir=Path(os.getenv("DOWNLOAD_DIR", "./shard_cache")),
    sample_rows=int(os.getenv("SAMPLE_ROWS", "12000")),
    parquet_count=int(os.getenv("PARQUET_COUNT", "2")),
    max_chars=int(os.getenv("MAX_CHARS", "800")),
    batch_sizes=[
        int(value)
        for value in os.getenv(
            "BATCH_SIZES", "1024,1536,2048,2560,3072,3584,4096"
        ).split(",")
        if value.strip()
    ],
)


def get_device() -> str:
    import torch

    if torch.cuda.is_available():
        return "cuda"
    if torch.backends.mps.is_available():
        return "mps"
    return "cpu"


def run_hf_download(*args: str) -> None:
    command = ["hf", "download", config.repo_id, "--repo-type", "dataset", *args]
    subprocess.run(args=command, check=True)


def list_input_parquets() -> list[str]:
    api = HfApi()
    files = api.list_repo_files(repo_id=config.repo_id, repo_type="dataset")
    parquet_files = sorted(
        file_path
        for file_path in files
        if file_path.startswith(config.input_prefix) and file_path.endswith(".parquet")
    )
    return parquet_files


def download_input_parquets(parquet_files: list[str]) -> list[Path]:
    config.download_dir.mkdir(parents=True, exist_ok=True)
    local_paths: list[Path] = []

    for parquet_file in parquet_files:
        run_hf_download(
            "--local-dir",
            str(config.download_dir),
            parquet_file,
        )
        local_paths.append(config.download_dir / parquet_file)

    return local_paths


def load_texts() -> list[str]:
    parquet_files = list_input_parquets()[: config.parquet_count]
    if not parquet_files:
        raise RuntimeError(
            f"No parquet files found under {config.repo_id}/{config.input_prefix}"
        )

    local_paths = download_input_parquets(parquet_files=parquet_files)
    texts: list[str] = []

    for local_path in local_paths:
        df = polars.read_parquet(local_path).select("text")
        texts.extend(df["text"].to_list())
        if len(texts) >= config.sample_rows:
            break

    truncated = [
        text[: config.max_chars].strip() for text in texts[: config.sample_rows]
    ]
    truncated = [text for text in truncated if text]
    if not truncated:
        raise RuntimeError("No texts loaded for benchmarking")

    print(
        f"Loaded {len(truncated)} texts from {len(local_paths)} parquet files for benchmarking"
    )
    return truncated


def load_model(device: str):
    from sentence_transformers import SentenceTransformer

    model_kwargs = {}
    if device in ("cuda", "mps"):
        model_kwargs["torch_dtype"] = "float16"

    model = SentenceTransformer(
        config.model_name,
        device=device,
        model_kwargs=model_kwargs,
    )
    print(f"Loaded {config.model_name} on {device}")
    return model


def warm_up(model, texts: list[str]) -> None:
    warmup_size = min(len(texts), 256)
    if warmup_size == 0:
        return
    model.encode(
        texts[:warmup_size],
        batch_size=min(warmup_size, 256),
        show_progress_bar=False,
    )


def benchmark_batch_size(model, texts: list[str], batch_size: int, device: str) -> dict:
    import torch

    if device == "cuda":
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()

    started_at = time.perf_counter()
    try:
        embeddings = model.encode(
            texts,
            batch_size=batch_size,
            show_progress_bar=False,
        )
    except torch.OutOfMemoryError:
        if device == "cuda":
            torch.cuda.empty_cache()
        return {"batch_size": batch_size, "status": "oom"}
    except RuntimeError as exc:
        if "out of memory" not in str(exc).lower():
            raise
        if device == "cuda":
            torch.cuda.empty_cache()
        return {"batch_size": batch_size, "status": "oom"}

    elapsed_seconds = time.perf_counter() - started_at
    throughput = len(texts) / elapsed_seconds if elapsed_seconds > 0 else 0.0
    result = {
        "batch_size": batch_size,
        "status": "ok",
        "seconds": elapsed_seconds,
        "texts": len(texts),
        "throughput": throughput,
        "embedding_shape": tuple(embeddings.shape),
    }

    if device == "cuda":
        peak_memory = torch.cuda.max_memory_allocated() / 1024**3
        result["peak_cuda_gb"] = peak_memory

    return result


def print_result(result: dict) -> None:
    if result["status"] == "oom":
        print(f"batch_size={result['batch_size']}: OOM")
        return

    peak_memory = result.get("peak_cuda_gb")
    if peak_memory is None:
        print(
            f"batch_size={result['batch_size']}: {result['throughput']:.0f} texts/s in {result['seconds']:.1f}s"
        )
        return

    print(
        f"batch_size={result['batch_size']}: {result['throughput']:.0f} texts/s in {result['seconds']:.1f}s, peak_cuda={peak_memory:.2f} GiB"
    )


def main() -> None:
    device = get_device()
    print(f"Device: {device}")
    print(f"Batch sizes: {config.batch_sizes}")

    texts = load_texts()
    model = load_model(device=device)
    warm_up(model=model, texts=texts)

    results = []
    for batch_size in config.batch_sizes:
        result = benchmark_batch_size(
            model=model,
            texts=texts,
            batch_size=batch_size,
            device=device,
        )
        results.append(result)
        print_result(result=result)

    successful = [result for result in results if result["status"] == "ok"]
    if not successful:
        print("No successful batch size found")
        return

    fastest = max(successful, key=lambda result: result["throughput"])
    print("\nRecommended batch size:")
    print_result(result=fastest)


if __name__ == "__main__":
    main()