Blame for classifier/classify.py

"""Train both classifiers, enrich every dataset shard, and upload the result."""

import json
import multiprocessing
import subprocess
import time
from pathlib import Path

import fire
import numpy as numpy
import polars as polars
import torch
from sentence_transformers import SentenceTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.preprocessing import StandardScaler

HERE = Path(__file__).resolve().parent
MODEL = "intfloat/multilingual-e5-small"
REPO = "duarteocarmo/bagaco3"
TARGETS = ("educational_score", "category")
MAX_CHARS = 1_500
CHUNK_SIZE = 20_000


def classifier() -> LogisticRegression:
    return LogisticRegression(
        class_weight="balanced",
        max_iter=5_000,
        random_state=42,
    )


def features_for(
    *,
    texts: list[str],
    model: SentenceTransformer,
    scaler: StandardScaler,
    batch_size: int,
) -> numpy.ndarray:
    embeddings = model.encode(
        inputs=[text[:MAX_CHARS] for text in texts],
        batch_size=batch_size,
        normalize_embeddings=True,
        show_progress_bar=False,
    )
    lengths = numpy.log1p(numpy.array([len(text) for text in texts])).reshape(-1, 1)
    return numpy.column_stack(tup=(embeddings, scaler.transform(X=lengths) * 0.1))


def evaluation_for(
    *,
    labels: list,
    features: numpy.ndarray,
) -> dict:
    splitter = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
    train_indices, test_indices = next(splitter.split(X=features, y=labels))
    evaluator = classifier().fit(
        X=features[train_indices],
        y=[labels[index] for index in train_indices],
    )
    actual = [labels[index] for index in test_indices]
    predicted = evaluator.predict(X=features[test_indices])
    report_labels = sorted(set(labels))
    return {
        "labels": report_labels,
        "classification_report": classification_report(
            y_true=actual,
            y_pred=predicted,
            labels=report_labels,
            output_dict=True,
            zero_division=0,
        ),
        "confusion_matrix": confusion_matrix(
            y_true=actual,
            y_pred=predicted,
            labels=report_labels,
        ).tolist(),
    }


def load_model(*, device: str) -> SentenceTransformer:
    model_kwargs = {"torch_dtype": torch.float16} if device.startswith("cuda") else {}
    precision = "float16" if model_kwargs else "float32"
    print(f"Loading {MODEL} on {device} with {precision}", flush=True)
    return SentenceTransformer(
        model_name_or_path=MODEL,
        device=device,
        model_kwargs=model_kwargs,
    )


def train_classifiers(
    *,
    output_dir: Path,
    device: str,
    batch_size: int,
) -> tuple[SentenceTransformer, StandardScaler, dict[str, LogisticRegression]]:
    annotations = polars.read_parquet(
        source=HERE / "data/annotated.parquet",
        columns=["text", *TARGETS],
    ).drop_nulls()
    texts = annotations.get_column("text").to_list()
    lengths = numpy.log1p(numpy.array([len(text) for text in texts])).reshape(-1, 1)
    scaler = StandardScaler().fit(X=lengths)
    model = load_model(device=device)
    print(
        f"Encoding {annotations.height:,} annotated rows and training classifiers",
        flush=True,
    )
    features = features_for(
        texts=texts,
        model=model,
        scaler=scaler,
        batch_size=batch_size,
    )
    labels = {target: annotations.get_column(target).to_list() for target in TARGETS}
    metrics = {
        target: evaluation_for(labels=labels[target], features=features)
        for target in TARGETS
    }
    classifiers = {
        target: classifier().fit(X=features, y=labels[target]) for target in TARGETS
    }
    (output_dir / "classification_metrics.json").write_text(
        json.dumps(obj=metrics, indent=2) + "\n",
        encoding="utf-8",
    )
    print(
        f"Trained and evaluated both classifiers on {annotations.height:,} rows",
        flush=True,
    )
    return model, scaler, classifiers


def classify_shard(
    *,
    source_file: Path,
    output_file: Path,
    model: SentenceTransformer,
    scaler: StandardScaler,
    classifiers: dict[str, LogisticRegression],
    batch_size: int,
) -> polars.DataFrame:
    if output_file.exists():
        return polars.read_parquet(
            source=output_file,
            columns=[*TARGETS, "char_len"],
        )
    with source_file.open(mode="rb") as file:
        if file.read(4) != b"PAR1":
            raise RuntimeError(f"{source_file} is a Git LFS pointer; run git lfs pull")
    data = polars.read_parquet(source=source_file, low_memory=True)
    predictions = {target: [] for target in TARGETS}
    for chunk in data.iter_slices(n_rows=CHUNK_SIZE):
        features = features_for(
            texts=chunk.get_column("text").to_list(),
            model=model,
            scaler=scaler,
            batch_size=batch_size,
        )
        for target in TARGETS:
            predictions[target].extend(
                classifiers[target].predict(X=features).tolist()
            )
    columns = {
        target: polars.Series(values=values)
        for target, values in predictions.items()
    }
    columns["char_len"] = polars.col("text").str.len_chars()
    classified = data.with_columns(**columns)
    temporary_file = output_file.with_suffix(".parquet.tmp")
    classified.write_parquet(file=temporary_file, compression="zstd")
    temporary_file.replace(output_file)
    return classified.select([*TARGETS, "char_len"])


def summary_for(*, data: polars.DataFrame, target: str) -> polars.DataFrame:
    return data.group_by(target).agg(
        polars.len().cast(polars.UInt64).alias("rows"),
        polars.col("char_len").cast(polars.UInt64).sum().alias("total_chars"),
    )


def format_duration(*, seconds: float) -> str:
    minutes, seconds = divmod(int(seconds), 60)
    hours, minutes = divmod(minutes, 60)
    return f"{hours:d}h {minutes:02d}m {seconds:02d}s"


def classify_dataset(
    *,
    source_files: list[Path],
    output_dir: Path,
    model: SentenceTransformer,
    scaler: StandardScaler,
    classifiers: dict[str, LogisticRegression],
    batch_size: int,
) -> dict[str, list[polars.DataFrame]]:
    summaries = {target: [] for target in TARGETS}
    classification_seconds = 0.0
    classified_count = 0
    total_to_classify = sum(
        not (output_dir / source_file.name).exists() for source_file in source_files
    )
    print(
        f"Classifying {len(source_files):,} shards on {model.device}",
        flush=True,
    )
    for index, source_file in enumerate(source_files, start=1):
        started_at = time.monotonic()
        output_file = output_dir / source_file.name
        existed = output_file.exists()
        classified = classify_shard(
            source_file=source_file,
            output_file=output_file,
            model=model,
            scaler=scaler,
            classifiers=classifiers,
            batch_size=batch_size,
        )
        for target in TARGETS:
            summaries[target].append(summary_for(data=classified, target=target))
        action = "Kept" if existed else "Classified"
        if not existed:
            classification_seconds += time.monotonic() - started_at
            classified_count += 1
        remaining = total_to_classify - classified_count
        eta = classification_seconds / classified_count * remaining if classified_count else 0
        print(
            f"{action} shard {index:,}/{len(source_files):,} "
            f"({source_file.name}): {classified.height:,} rows; "
            f"ETA {format_duration(seconds=eta)}",
            flush=True,
        )
    return summaries


def classify_worker(
    *,
    worker_index: int,
    source_files: list[Path],
    output_dir: Path,
    scaler: StandardScaler,
    classifiers: dict[str, LogisticRegression],
    batch_size: int,
) -> None:
    device = f"cuda:{worker_index}"
    model = load_model(device=device)
    classify_dataset(
        source_files=source_files,
        output_dir=output_dir,
        model=model,
        scaler=scaler,
        classifiers=classifiers,
        batch_size=batch_size,
    )


def classify_in_parallel(
    *,
    source_files: list[Path],
    output_dir: Path,
    scaler: StandardScaler,
    classifiers: dict[str, LogisticRegression],
    batch_size: int,
    workers: int,
) -> None:
    context = multiprocessing.get_context(method="spawn")
    processes = [
        context.Process(
            target=classify_worker,
            kwargs={
                "worker_index": worker_index,
                "source_files": source_files[worker_index::workers],
                "output_dir": output_dir,
                "scaler": scaler,
                "classifiers": classifiers,
                "batch_size": batch_size,
            },
        )
        for worker_index in range(workers)
    ]
    started_at = time.monotonic()
    for process in processes:
        process.start()
    for process in processes:
        process.join()
    failed = [process.exitcode for process in processes if process.exitcode != 0]
    if failed:
        raise RuntimeError(f"Classifier workers failed with exit codes {failed}")
    elapsed = time.monotonic() - started_at
    print(
        f"Completed {len(source_files):,} shards with {workers} workers in "
        f"{format_duration(seconds=elapsed)}",
        flush=True,
    )


def summaries_for_outputs(
    *,
    source_files: list[Path],
    output_dir: Path,
) -> dict[str, list[polars.DataFrame]]:
    summaries = {target: [] for target in TARGETS}
    for source_file in source_files:
        classified = polars.read_parquet(
            source=output_dir / source_file.name,
            columns=[*TARGETS, "char_len"],
        )
        for target in TARGETS:
            summaries[target].append(summary_for(data=classified, target=target))
    return summaries


def save_class_counts(
    *,
    summaries: dict[str, list[polars.DataFrame]],
    output_dir: Path,
) -> None:
    counts = {
        target: (
            polars.concat(items=summaries[target])
            .group_by(target)
            .agg(polars.col("rows").sum(), polars.col("total_chars").sum())
            .sort(target)
            .to_dicts()
        )
        for target in TARGETS
    }
    (output_dir / "class_counts.json").write_text(
        json.dumps(obj=counts, indent=2) + "\n",
        encoding="utf-8",
    )
    print(f"Saved metrics and class counts to {output_dir}", flush=True)


def upload_outputs(*, output_dir: Path, repo: str) -> None:
    subprocess.run(
        args=[
            "uvx",
            "--from",
            "huggingface-hub",
            "hf",
            "upload-large-folder",
            repo,
            str(output_dir),
            "--repo-type=dataset",
            "--include=*.parquet",
            "--include=*.json",
        ],
        check=True,
    )
    print(
        f"Uploaded dataset to https://huggingface.co/datasets/{repo}",
        flush=True,
    )


def main(
    input_dir: str = str(HERE.parent),
    output_dir: str = str(HERE.parent / "classified"),
    repo: str = REPO,
    device: str = "cuda",
    batch_size: int = 256,
    workers: int = 1,
    dry_run: bool = False,
    upload: bool = True,
) -> None:
    """Classify the cloned dataset and optionally upload the enriched shards."""
    if device.startswith("cuda") and not torch.cuda.is_available():
        raise RuntimeError("CUDA is unavailable")
    if workers < 1:
        raise RuntimeError("workers must be at least 1")
    if workers > 1 and device != "cuda":
        raise RuntimeError("Multiple workers require device=cuda")
    if workers > torch.cuda.device_count() and device == "cuda":
        raise RuntimeError(f"Requested {workers} workers but found {torch.cuda.device_count()} GPUs")
    source_files = sorted(Path(input_dir).glob("*.parquet"))
    if not source_files:
        raise RuntimeError(f"No Parquet files found in {input_dir}")
    output_path = Path(output_dir)
    if dry_run:
        source_files = source_files[:workers]
        output_path = output_path.with_name(f"{output_path.name}-dry-run")
        if output_path.exists():
            raise RuntimeError(f"Dry-run output already exists: {output_path}")
        upload = False
        print(
            f"Dry run: processing {len(source_files)} shards with {workers} workers",
            flush=True,
        )
    output_path.mkdir(parents=True, exist_ok=True)
    model, scaler, classifiers = train_classifiers(
        output_dir=output_path,
        device=device,
        batch_size=batch_size,
    )
    if workers == 1:
        summaries = classify_dataset(
            source_files=source_files,
            output_dir=output_path,
            model=model,
            scaler=scaler,
            classifiers=classifiers,
            batch_size=batch_size,
        )
    else:
        del model
        torch.cuda.empty_cache()
        classify_in_parallel(
            source_files=source_files,
            output_dir=output_path,
            scaler=scaler,
            classifiers=classifiers,
            batch_size=batch_size,
            workers=workers,
        )
        summaries = summaries_for_outputs(
            source_files=source_files,
            output_dir=output_path,
        )
    save_class_counts(summaries=summaries, output_dir=output_path)
    if upload:
        upload_outputs(output_dir=output_path, repo=repo)


if __name__ == "__main__":
    fire.Fire(component=main)