| """Train a sparse text classifier.""" |
|
|
| import fire |
| import numpy as numpy |
| import polars as polars |
| 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 |
|
|
| MINIMUM_PER_CATEGORY = 100 |
| RANDOM_STATE = 42 |
|
|
|
|
| def sample_data(data: polars.DataFrame, sample_size: int) -> polars.DataFrame: |
| data = data.with_row_index(name="row_index") |
| category_sample = data.group_by("category").map_groups( |
| lambda group: group.sample(n=MINIMUM_PER_CATEGORY, seed=RANDOM_STATE) |
| ) |
| remaining_sample = ( |
| data.join( |
| category_sample.select("row_index"), |
| on="row_index", |
| how="anti", |
| ) |
| .sample(n=sample_size - category_sample.height, seed=RANDOM_STATE) |
| ) |
| return polars.concat(items=[category_sample, remaining_sample]).drop("row_index") |
|
|
|
|
| def main( |
| target: str = "educational_score", |
| data: str = "data/annotated.parquet", |
| sample_size: int = 36_000, |
| test_size: float = 0.2, |
| model: str = "intfloat/multilingual-e5-small", |
| device: str = "mps", |
| batch_size: int = 64, |
| ) -> None: |
| sampled_data = sample_data( |
| data=polars.read_parquet(source=data), |
| sample_size=sample_size, |
| ) |
| texts = [str(text)[:1500] for text in sampled_data.get_column("text")] |
| labels = sampled_data.get_column(target).to_list() |
| splitter = StratifiedShuffleSplit( |
| n_splits=1, |
| test_size=test_size, |
| random_state=RANDOM_STATE, |
| ) |
| train_indices, test_indices = next(splitter.split(X=texts, y=labels)) |
| embeddings = SentenceTransformer(model_name_or_path=model, device=device).encode( |
| inputs=texts, |
| batch_size=batch_size, |
| normalize_embeddings=True, |
| show_progress_bar=True, |
| ) |
| text_lengths = numpy.log1p( |
| numpy.array([len(str(text)) for text in sampled_data.get_column("text")]) |
| ).reshape(-1, 1) |
| length_scaler = StandardScaler().fit(X=text_lengths[train_indices]) |
| embeddings = numpy.column_stack( |
| tup=(embeddings, length_scaler.transform(X=text_lengths) * 0.1) |
| ) |
| train_labels = [labels[index] for index in train_indices] |
| test_labels = [labels[index] for index in test_indices] |
|
|
| classifier = LogisticRegression( |
| C=1.0, |
| class_weight="balanced", |
| max_iter=5_000, |
| random_state=RANDOM_STATE, |
| ) |
| classifier.fit(X=embeddings[train_indices], y=train_labels) |
| predictions = classifier.predict(X=embeddings[test_indices]) |
| print( |
| classification_report( |
| y_true=test_labels, |
| y_pred=predictions, |
| zero_division="warn", |
| ) |
| ) |
| matrix = confusion_matrix( |
| y_true=test_labels, |
| y_pred=predictions, |
| labels=classifier.classes_, |
| ) |
| print(f"Confusion matrix (labels: {classifier.classes_.tolist()}):\n{matrix}") |
|
|
|
|
| if __name__ == "__main__": |
| fire.Fire(component=main) |
|
|
