#!/usr/bin/env python3 """ Meta-Learner Trainer with Fold-Consistency Analysis Trains a configurable meta-learner on top of OOF predictions from one or two ensemble runs (CE and/or KL), analyses rule stability across folds, and benchmarks inference time vs accuracy tradeoff. Usage: python meta_learner_trainer.py \ --ce_oof_path ce_ensemble.parquet \ --kl_oof_path kl_ensemble.parquet \ --data_path data.parquet \ --label_col category \ --mapping_dict_path mapping.json \ --ce_config_path ce_ensemble_config.json \ --kl_config_path kl_ensemble_config.json \ --meta_type lgbm \ --model_subset videberta-base,mlm_listing_checkpoint-32442,tfidf_lgbm \ --use_derived_features \ --fold_consistency_threshold 0.5 \ --k_folds 5 \ --output_dir meta_outputs Notes: - OOF parquets must contain columns like: {model_clean_name}_logprob_{class} as produced by ensemble_distillation_generator.py - model_subset filters by the "clean name" (model_name.split('/')[-1]) - If kl_oof_path is omitted, only CE OOF probs are used - Inference benchmarking simulates per-model forward pass timing on CPU to reflect production conditions (no GPU guarantee at serving time) """ import argparse import gc import json import pickle import time import warnings from pathlib import Path from itertools import combinations # Shared MetaLearner class — also imported by meta_learner_inference.py. # Must be imported (not defined inline) so pickle/joblib deserialisation works # from any script that loads a saved MetaLearner instance. import sys as _sys, os as _os _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__))) from meta_learner_core import MetaLearner # noqa: E402 import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec import seaborn as sns from scipy.stats import spearmanr from scipy.optimize import minimize from sklearn.linear_model import LogisticRegression, Ridge from sklearn.calibration import CalibratedClassifierCV from sklearn.model_selection import StratifiedKFold from sklearn.metrics import precision_recall_fscore_support, log_loss from sklearn.preprocessing import LabelEncoder import lightgbm as lgb warnings.filterwarnings("ignore") # ============================================================================= # ARGUMENT PARSING # ============================================================================= def parse_args(): p = argparse.ArgumentParser() # --- Data inputs --- p.add_argument("--ce_oof_path", type=str, default=None, help="Parquet with CE ensemble OOF logprob columns") p.add_argument("--kl_oof_path", type=str, default=None, help="Parquet with KL student OOF logprob columns (optional)") p.add_argument("--data_path", type=str, required=True, help="Original data parquet with labels") p.add_argument("--label_col", type=str, required=True) p.add_argument("--mapping_dict_path", type=str, required=True, help="JSON mapping label -> integer index") p.add_argument("--ce_config_path", type=str, default=None, help="JSON config used to train CE ensemble") p.add_argument("--kl_config_path", type=str, default=None, help="JSON config used to train KL student ensemble") # --- Model selection --- p.add_argument("--unknown_label_value", type=str, default="N", help="Raw label string in data that represents the unknown/null class " "(maps to the 'UNKNOWN' OOF column). Default: 'N'.") p.add_argument("--model_subset", type=str, default=None, help="Comma-separated clean model names to include. " "If omitted, all trained models are used.") p.add_argument("--ensemble_source", type=str, default="both", choices=["ce", "kl", "both"], help="Which ensemble(s) to draw OOF features from.") # --- Meta-learner --- p.add_argument("--meta_type", type=str, default="lgbm", choices=["lgbm", "logistic", "ridge", "weighted_avg", "mlp"], help="Meta-learner architecture. " "lgbm: LightGBM — best with derived features (entropy, KL div). " "ridge: Ridge regression OvR + softmax — fastest, rarely overfits, " "strong baseline for pure probability stacking. " "logistic: Multinomial logistic with isotonic calibration. " "weighted_avg: Nelder-Mead optimized blend weights — most interpretable. " "mlp: small MLP with dropout — best when adding embeddings.") p.add_argument("--use_derived_features", action="store_true", help="Append entropy, KL-divergence, and per-class diff features.") p.add_argument("--compare_meta_types", action="store_true", help="Run ALL meta-learner types on the full feature set and print a " "comparison table. Useful for choosing --meta_type.") # --- Fold-consistency --- p.add_argument("--k_folds", type=int, default=5) p.add_argument("--fold_consistency_threshold", type=float, default=0.5, help="Max coefficient-of-variation for a feature to be " "considered 'stable'. Features above this CV are flagged.") p.add_argument("--seed", type=int, default=42) # --- Combination selection strategy --- p.add_argument("--selection_strategy", type=str, default="greedy", choices=["greedy", "exhaustive"], help="Strategy for the accuracy-vs-speed model subset sweep. " "greedy (default): forward selection — start with best single " "model, greedily add the most complementary model at each step. " "O(n^2) evaluations. Finds near-optimal subsets without exhaustive " "enumeration. " "exhaustive: try all subsets up to --max_combo_size (original " "behaviour). Use only for small n_models.") p.add_argument("--greedy_max_models", type=int, default=6, help="Maximum number of models to select in greedy forward selection. " "Selection stops earlier if F1 improvement < --greedy_min_gain.") p.add_argument("--greedy_min_gain", type=float, default=0.001, help="Minimum CV F1 gain to continue greedy selection. " "Stops adding models once the marginal gain falls below this.") # --- Option 2: OOF embeddings from fine-tuned fold models --- p.add_argument("--use_oof_embeddings", action="store_true", help="Extract [CLS] embeddings from each fine-tuned fold model using " "the same K-fold OOF structure. PCA-reduced per model (per-fold " "fit to avoid leakage), then concatenated to the feature matrix. " "Requires --text_col, --ce_artifacts_dir / --kl_artifacts_dir.") p.add_argument("--oof_emb_n_components", type=int, default=32, help="PCA components to keep per model for OOF embeddings.") p.add_argument("--oof_emb_batch_size", type=int, default=16, help="Batch size for OOF embedding extraction inference.") p.add_argument("--oof_emb_ce_cache", type=str, default="oof_emb_ce.parquet", help="Parquet cache path for CE OOF embeddings. Re-used on subsequent " "runs if the file exists and column count matches.") p.add_argument("--oof_emb_kl_cache", type=str, default="oof_emb_kl.parquet", help="Parquet cache path for KL OOF embeddings.") # --- Option 3: Frozen encoder embeddings --- p.add_argument("--frozen_encoder", type=str, default=None, help="Path or HuggingFace name of a pretrained encoder to use as a " "frozen feature extractor. No fine-tuning involved — embeddings " "are extracted once and cached. Example: " "pretrained_checkpoints/MikeGreen2710__mlm_listing_checkpoint-32442") p.add_argument("--frozen_encoder_tokenizer", type=str, default=None, help="Tokenizer for --frozen_encoder. Defaults to --frozen_encoder " "itself if not set. Example: VinAI/phobert-base") p.add_argument("--frozen_emb_n_components", type=int, default=64, help="PCA components for frozen encoder embeddings.") p.add_argument("--frozen_emb_batch_size", type=int, default=32, help="Batch size for frozen embedding extraction.") p.add_argument("--frozen_emb_cache", type=str, default="frozen_emb.parquet", help="Parquet cache path for frozen encoder embeddings.") # --- Inference benchmarking --- p.add_argument("--benchmark_n_samples", type=int, default=200, help="Number of samples to use for timing the base model forward passes.") p.add_argument("--benchmark_repeats", type=int, default=5, help="Repeats per model for the latency benchmark (median is taken).") p.add_argument("--benchmark_device", type=str, default="cpu", help="Device for base-model latency benchmarking ('cpu' or 'cuda'). " "Use the device that matches your production serving environment.") p.add_argument("--text_col", type=str, default=None, help="Column in --data_path containing raw text, used for tokenisation " "during base-model latency benchmarking. Required when " "--ce_artifacts_dir or --kl_artifacts_dir is provided.") p.add_argument("--max_length", type=int, default=256, help="Tokenisation max_length for the latency benchmark.") p.add_argument("--ce_artifacts_dir", type=str, default=None, help="Root artifact directory from the CE ensemble run " "(contains {model_safe_name}/fold_1/model/). " "When provided, each CE model is loaded and timed individually.") p.add_argument("--kl_artifacts_dir", type=str, default=None, help="Root artifact directory from the KL student ensemble run. " "When provided, each KL model is loaded and timed individually.") p.add_argument("--max_combo_size", type=int, default=3, help="Maximum subset size for the accuracy-vs-speed combination sweep. " "All subsets of size 1..max_combo_size are evaluated. " "Warning: combinatorial — keep <=4 for large model counts.") p.add_argument("--ce_metadata_path", type=str, default=None, help="Path to the CE ensemble metadata JSON (e.g. ensemble_metadata.json). " "If latency_ms is already present it will be reused; otherwise models " "are timed and the result is written back to this file.") p.add_argument("--kl_metadata_path", type=str, default=None, help="Path to the KL ensemble metadata JSON (e.g. ensemble_metadata_kl_round1.json). " "Same read/write behaviour as --ce_metadata_path.") # --- Output --- p.add_argument("--output_dir", type=str, default="meta_outputs") p.add_argument("--export_label", type=str, default=None, help="Label from accuracy_vs_speed.csv to export as a deployment " "artifact. If not set, the best F1 config is exported. " "Example: 'lgbm/KL:mlm_listing_che+KL:rembert'") p.add_argument("--export_only", action="store_true", help="Skip all training, benchmarking, and sweep steps. " "Load an existing --results_csv, re-train only the chosen " "config's meta-learner on the OOF parquets, and write " "deployment artifacts. Use after a full run to export a " "different config without repeating expensive CV/benchmarking.") p.add_argument("--results_csv", type=str, default=None, help="Path to an existing accuracy_vs_speed.csv produced by a " "previous full run. Required when --export_only is set.") return p.parse_args() # ============================================================================= # UTILITIES # ============================================================================= def load_mapping(path: str) -> dict: with open(path) as f: return json.load(f) def get_class_order_from_mapping(mapping: dict) -> list: """ Reconstruct the class index order used by ensemble_distillation_generator. The generator assigns: known classes → mapping_value - ordinal_min_label (so sort by value asc) unknown class → ordinal_num_classes (always placed last) We identify "unknown" as any entry whose value is < 0. """ known = sorted([(k, v) for k, v in mapping.items() if v >= 0], key=lambda x: x[1]) unknown = [k for k, v in mapping.items() if v < 0] return [k for k, _ in known] + unknown def get_active_models(config_path: str) -> list[dict]: """ Return models with use=True from the config. The 'trained' flag has been removed from config files — the filesystem (artifact_exists) is the source of truth for whether a model has been trained. Here we only need the list of enabled model configs to know which OOF columns to expect in the parquet and how to configure serving. """ with open(config_path) as f: configs = json.load(f) return [c for c in configs if c.get("use", True)] def clean_name(model_name: str) -> str: return model_name.split("/")[-1] def logprob_cols_for_model(df_cols: list, model_clean_name: str, class_order: list = None) -> list: """ Return logprob columns for a model in the correct class-index order. class_order: list of class-name strings ordered by their 0-based index, as returned by get_class_order_from_mapping(mapping). When provided, columns are returned in that order so that col i corresponds to class i — matching how y is encoded. Falls back to alphabetical if not provided (fine for LightGBM features, broken for weighted_avg argmax comparisons). """ prefix = f"{model_clean_name}_logprob_" available = {c.split("_logprob_")[1]: c for c in df_cols if c.startswith(prefix)} if class_order is not None: ordered = [available[cls] for cls in class_order if cls in available] covered = set(ordered) ordered += [c for c in sorted(available.values()) if c not in covered] return ordered return sorted(available.values()) def get_class_order_from_mapping(mapping: dict) -> list: """ Return class name strings in 0-based index order, matching the generator. Known classes (value >= 0) first, sorted by value. Unknown (value < 0) last. """ known = sorted([(k, v) for k, v in mapping.items() if v >= 0], key=lambda x: x[1]) unknown = [k for k, v in mapping.items() if v < 0] return [k for k, _ in known] + unknown def entropy(probs: np.ndarray, eps: float = 1e-7) -> np.ndarray: p = np.clip(probs, eps, 1.0) return -np.sum(p * np.log(p), axis=1) def kl_div_row(p: np.ndarray, q: np.ndarray, eps: float = 1e-7) -> np.ndarray: """Symmetric KL divergence between two prob arrays, row-wise.""" p = np.clip(p, eps, 1.0) q = np.clip(q, eps, 1.0) return 0.5 * (np.sum(p * np.log(p / q), axis=1) + np.sum(q * np.log(q / p), axis=1)) # ============================================================================= # FEATURE BUILDER # ============================================================================= class OOFFeatureBuilder: """ Builds a feature matrix from OOF probability columns. Feature groups: base : raw per-class probs for every selected model derived : entropy, argmax, per-pair KL divergence, CE-KL diff """ def __init__(self, ce_df, kl_df, ce_models, kl_models, model_subset=None, use_derived=True, ensemble_source="both", class_order=None): self.ce_df = ce_df self.kl_df = kl_df self.ce_models = ce_models # list of clean names self.kl_models = kl_models # list of clean names self.subset = set(model_subset) if model_subset else None self.use_derived = use_derived self.source = ensemble_source self.class_order = class_order # ordered class names from mapping # Resolved model lists self._ce_active = self._filter(self.ce_models, "ce") self._kl_active = self._filter(self.kl_models, "kl") self.feature_names = [] def _filter(self, names, source): if source == "ce" and self.source == "kl": return [] if source == "kl" and self.source == "ce": return [] if self.subset: return [n for n in names if n in self.subset] return names def _get_probs(self, df, model_name): cols = logprob_cols_for_model(list(df.columns), model_name, self.class_order) if not cols: return None, [] return df[cols].values, cols def build(self): blocks = [] names = [] # --- CE base probs --- for m in self._ce_active: probs, cols = self._get_probs(self.ce_df, m) if probs is None: print(f" [WARN] CE model {m}: no logprob columns found — skipping") continue blocks.append(probs) names.extend([f"CE_{m}_{c.split('_logprob_')[1]}" for c in cols]) # --- KL base probs --- for m in self._kl_active: if self.kl_df is None: break probs, cols = self._get_probs(self.kl_df, m) if probs is None: print(f" [WARN] KL model {m}: no logprob columns found — skipping") continue blocks.append(probs) names.extend([f"KL_{m}_{c.split('_logprob_')[1]}" for c in cols]) if not blocks: raise ValueError("No features built — check model_subset and OOF column names.") X = np.hstack(blocks) # --- Derived features --- if self.use_derived: derived_blocks = [] derived_names = [] n_classes = blocks[0].shape[1] all_probs = {} for i, m in enumerate(self._ce_active): p, _ = self._get_probs(self.ce_df, m) if p is None: continue all_probs[f"CE_{m}"] = p ent = entropy(p) derived_blocks.append(ent.reshape(-1, 1)) derived_names.append(f"CE_{m}_entropy") am = np.argmax(p, axis=1).reshape(-1, 1).astype(float) derived_blocks.append(am) derived_names.append(f"CE_{m}_argmax") for m in self._kl_active: if self.kl_df is None: break p, _ = self._get_probs(self.kl_df, m) if p is None: continue all_probs[f"KL_{m}"] = p ent = entropy(p) derived_blocks.append(ent.reshape(-1, 1)) derived_names.append(f"KL_{m}_entropy") am = np.argmax(p, axis=1).reshape(-1, 1).astype(float) derived_blocks.append(am) derived_names.append(f"KL_{m}_argmax") # Pairwise symmetric KL between CE and KL versions of same model for m in self._ce_active: ce_key = f"CE_{m}" kl_key = f"KL_{m}" if ce_key in all_probs and kl_key in all_probs: div = kl_div_row(all_probs[ce_key], all_probs[kl_key]) derived_blocks.append(div.reshape(-1, 1)) derived_names.append(f"CE_KL_{m}_sym_kl") diff = all_probs[ce_key] - all_probs[kl_key] derived_blocks.append(diff) derived_names.extend( [f"CE_KL_{m}_diff_class{i}" for i in range(diff.shape[1])]) # Pairwise disagreement between CE models ce_prob_list = [(k, v) for k, v in all_probs.items() if k.startswith("CE_")] for (n1, p1), (n2, p2) in combinations(ce_prob_list, 2): div = kl_div_row(p1, p2) derived_blocks.append(div.reshape(-1, 1)) derived_names.append(f"CE_pair_{n1}_vs_{n2}_kl") if derived_blocks: X = np.hstack([X] + derived_blocks) names.extend(derived_names) self.feature_names = names return X, names # ============================================================================= # META-LEARNER WRAPPER # ============================================================================= # MetaLearner lives in meta_learner_core.py — imported below. # See that file to modify the class. # ============================================================================= # FOLD CONSISTENCY ANALYSER # ============================================================================= def fold_consistency_analysis(X, y, feature_names, meta_type, n_classes, k_folds, seed, threshold, n_prob_cols=None): """ Train a meta-learner on each fold's training split, record feature importances, then compute coefficient-of-variation across folds. Returns: fold_importances : (k_folds, n_features) array cv_per_feature : (n_features,) array of CV values stable_mask : boolean mask of stable features (CV <= threshold) """ print(f"\n{'='*60}") print("FOLD CONSISTENCY ANALYSIS") print(f"{'='*60}") kfold = StratifiedKFold(n_splits=k_folds, shuffle=True, random_state=seed) fold_importances = [] fold_val_f1s = [] for fold, (train_idx, val_idx) in enumerate(kfold.split(X, y)): X_tr, X_val = X[train_idx], X[val_idx] y_tr, y_val = y[train_idx], y[val_idx] meta = MetaLearner(meta_type, n_classes, seed, n_prob_cols=n_prob_cols).fit(X_tr, y_tr) val_preds = np.argmax(meta.predict_proba(X_val), axis=1) f1 = precision_recall_fscore_support( y_val, val_preds, average="macro", zero_division=0)[2] fold_val_f1s.append(f1) print(f" Fold {fold+1}/{k_folds} — Val Macro F1: {f1:.4f}") imp = meta.get_feature_importances() if imp is not None: fold_importances.append(imp) if not fold_importances: print(" [WARN] Meta-learner does not expose feature importances.") return None, None, None, fold_val_f1s fold_importances = np.array(fold_importances) # (k, n_features) # Normalise each fold's importances to sum to 1 (comparable scale) fold_importances_norm = (fold_importances / fold_importances.sum(axis=1, keepdims=True).clip(min=1e-9)) mean_imp = fold_importances_norm.mean(axis=0) std_imp = fold_importances_norm.std(axis=0) cv = np.where(mean_imp > 1e-9, std_imp / mean_imp, np.inf) stable_mask = cv <= threshold n_stable = stable_mask.sum() print(f"\n Feature stability (CV threshold={threshold}):") print(f" Stable features : {n_stable}/{len(feature_names)}") print(f" Mean Val F1 : {np.mean(fold_val_f1s):.4f} ± {np.std(fold_val_f1s):.4f}") # Top 20 most stable important features rank = np.argsort(-mean_imp) print(f"\n Top-20 features by mean importance (stable=✓, unstable=✗):") for i, idx in enumerate(rank[:20]): tag = "✓" if stable_mask[idx] else "✗" print(f" {tag} [{cv[idx]:.2f} CV] {feature_names[idx]:<60s} " f"imp={mean_imp[idx]:.4f}") return fold_importances_norm, cv, stable_mask, fold_val_f1s # ============================================================================= # INFERENCE TIME BENCHMARK # ============================================================================= # ============================================================================= # PER-MODEL LATENCY BENCHMARKING # ============================================================================= def _get_model_fold_dir(artifacts_dir: str, model_name: str, stage: str = None) -> Path: """ Resolve the saved fold-1 model directory for a given model. Mirrors the artifact naming in ensemble_distillation_generator.py: artifact_name = model_name (or model_name + "__stage1" / "__stage2") safe_name = artifact_name.replace("/", "__") """ artifact_name = model_name if stage is None else f"{model_name}__{stage}" safe_name = artifact_name.replace("/", "__") return Path(artifacts_dir) / safe_name / "fold_1" / "model" def _normalise_device(device_str: str) -> str: """Map user-friendly aliases ('gpu') to PyTorch device strings ('cuda').""" return "cuda" if device_str.lower() == "gpu" else device_str.lower() def benchmark_transformer_model( original_model_name: str, tokenizer_name: str, texts: list, max_length: int, device: str, n_repeats: int, drop_token_type_ids: bool = False, use_fp16: bool = False, use_bf16: bool = False, ) -> float: """ Load the BASE ENCODER of a model from its original pretrained checkpoint and time its forward pass. Why the base encoder, not the saved fold model? ------------------------------------------------ The generator saves models as custom nn.Module wrappers: - MultimodalClassificationModel (models with other_cols) - OrdinalRegressionModel (task_type=ordinal) These are not AutoModelForSequenceClassification and cannot be loaded with it — their state_dict keys have 'base_model.*' prefixes that AutoModel* classes do not recognise. For latency benchmarking this does not matter: the transformer encoder is >99% of inference time. The classification/ordinal head and the extra tabular features (other_cols) add <1ms and are not what we are comparing across models. We load from the ORIGINAL pretrained checkpoint (always available, always has model_type, no custom wrapper) and apply the same dtype (fp16/bf16) that was used during training so the timing reflects production conditions. """ import torch from transformers import AutoModel, AutoTokenizer device = _normalise_device(device) tok_src = tokenizer_name if tokenizer_name else original_model_name tokenizer = AutoTokenizer.from_pretrained(tok_src, trust_remote_code=True) dtype = (torch.bfloat16 if use_bf16 else torch.float16 if use_fp16 else torch.float32) model = AutoModel.from_pretrained( original_model_name, trust_remote_code=True, torch_dtype=dtype) model.eval() model.to(device) enc = tokenizer( texts, padding=True, truncation=True, max_length=max_length, return_tensors="pt" ) if drop_token_type_ids: enc.pop("token_type_ids", None) enc = {k: v.to(device) for k, v in enc.items()} is_cuda = device.startswith("cuda") # Warmup with torch.no_grad(): _ = model(**enc) if is_cuda: torch.cuda.synchronize() times = [] for _ in range(n_repeats): if is_cuda: torch.cuda.synchronize() t0 = time.perf_counter() with torch.no_grad(): _ = model(**enc) if is_cuda: torch.cuda.synchronize() times.append(time.perf_counter() - t0) del model, enc if is_cuda: torch.cuda.empty_cache() gc.collect() return float(np.median(times)) * 1000.0 # ms def benchmark_lgbm_model(artifacts_dir: str, texts: list, n_tabular_features: int, n_repeats: int) -> float: """ Load the TF-IDF + LightGBM pipeline pickle from fold_1 and time it. n_tabular_features: len(cfg["other_cols"]) — the number of extra numeric columns that were appended during training (on_front_street, etc.). For timing we pad with zeros: the values don't affect latency, only the feature count matters for the LightGBM predict call. """ from scipy.sparse import hstack, csr_matrix pkl_path = Path(artifacts_dir) / "tfidf_lgbm" / "fold_1" / "model.pkl" if not pkl_path.exists(): return None with open(pkl_path, "rb") as f: bundle = pickle.load(f) cal = bundle["calibrated_model"] wtf = bundle["word_tfidf"] ctf = bundle["char_tfidf"] X = hstack([wtf.transform(texts), ctf.transform(texts)]) if n_tabular_features > 0: tab_zeros = csr_matrix((len(texts), n_tabular_features), dtype="float32") X = hstack([X, tab_zeros]) times = [] for _ in range(n_repeats): t0 = time.perf_counter() _ = cal.predict_proba(X) times.append(time.perf_counter() - t0) return float(np.median(times)) * 1000.0 # ms # ============================================================================= # EMBEDDING EXTRACTION — OPTIONS 2 AND 3 # ============================================================================= def _load_encoder_from_fold(fold_model_dir, original_model_name, use_fp16, use_bf16, device): """ Load just the base transformer encoder from a saved fold checkpoint. The generator saves models as custom wrappers (MultimodalClassificationModel, OrdinalRegressionModel) whose state_dict keys have a "base_model." prefix. We strip that prefix to reconstruct the plain AutoModel state dict. For models saved as plain AutoModelForSequenceClassification (no other_cols), keys are direct and strict=False discards the classifier head automatically. """ import torch from transformers import AutoModel fold_model_dir = Path(fold_model_dir) st_path = fold_model_dir / "model.safetensors" use_safe = st_path.exists() if not use_safe: st_path = fold_model_dir / "pytorch_model.bin" if not st_path.exists(): raise FileNotFoundError("No weights file in " + str(fold_model_dir)) if use_safe: from safetensors.torch import load_file raw_sd = load_file(str(st_path)) else: raw_sd = torch.load(str(st_path), map_location="cpu", weights_only=True) # Strip "base_model." prefix (custom wrapper models) encoder_sd = {k[len("base_model."):]: v for k, v in raw_sd.items() if k.startswith("base_model.")} if not encoder_sd: # Plain AutoModelForSequenceClassification — use full state dict, # strict=False will ignore classifier/pooler keys. encoder_sd = raw_sd dtype = (torch.bfloat16 if use_bf16 else torch.float16 if use_fp16 else torch.float32) encoder = AutoModel.from_pretrained( original_model_name, trust_remote_code=True, dtype=dtype) missing, unexpected = encoder.load_state_dict(encoder_sd, strict=False) n_loaded = len(encoder_sd) - len(unexpected) print(" weights loaded={} missing={} unexpected={}".format( n_loaded, len(missing), len(unexpected))) encoder.eval() encoder.to(device) return encoder def _encode_texts(encoder, tokenizer, texts, max_length, device, batch_size, drop_token_type_ids): """Run encoder on texts, return CLS embeddings as float32 numpy array.""" import torch all_embs = [] for start in range(0, len(texts), batch_size): batch = texts[start:start + batch_size] enc = tokenizer(batch, padding=True, truncation=True, max_length=max_length, return_tensors="pt") if drop_token_type_ids: enc.pop("token_type_ids", None) enc = {k: v.to(device) for k, v in enc.items()} with torch.no_grad(): out = encoder(**enc) cls = out.last_hidden_state[:, 0, :].float().cpu().numpy() all_embs.append(cls) return np.vstack(all_embs) def extract_oof_embeddings(ce_configs, kl_configs, ce_artifacts_dir, kl_artifacts_dir, texts, y, max_length, device, n_components, batch_size, k_folds, seed, ce_cache, kl_cache): """ Option 2: extract OOF embeddings from fine-tuned fold checkpoints. For each model and each fold: 1. Load the fold-k checkpoint encoder (fine-tuned weights). 2. Encode the fold-k validation samples -> raw CLS embeddings. After all folds, fit PCA on the full OOF embedding matrix for each model (PCA directions from embedding geometry, no label involvement — safe). Results are cached; subsequent calls with the same cache path are instant. split_unknown_stage models: use stage1 checkpoint (trained on all samples as binary; stage2 only covers known samples so cannot fill the full OOF matrix). """ from sklearn.decomposition import PCA from transformers import AutoTokenizer device = _normalise_device(device) kfold = StratifiedKFold(n_splits=k_folds, shuffle=True, random_state=seed) def _extract_one_ensemble(configs, artifacts_dir, tag, cache_path): cache = Path(cache_path) if cache.exists(): print(" [{}] Loading cached OOF embeddings <- {}".format(tag, cache_path)) df_c = pd.read_parquet(cache) return df_c.values, list(df_c.columns) blocks, names = [], [] trained = [c for c in configs if c.get("use", True)] for cfg in trained: mname = cfg["model_name"] cname = clean_name(mname) tok_name = cfg.get("tokenizer_name") or mname drop_tti = cfg.get("drop_token_type_ids", False) split_unk = cfg.get("split_unknown_stage", False) use_fp16 = cfg.get("use_fp16", False) use_bf16 = cfg.get("use_bf16", False) # For split_unknown_stage use stage1 (covers all samples) stage = "stage1" if split_unk else None task = cfg.get("task_type", "classification") if task == "tfidf_lgbm": print(" [{}] {} is tfidf_lgbm — no embeddings, skipping".format(tag, cname)) continue print(" [{}] OOF embeddings: {} ...".format(tag, cname)) tokenizer = AutoTokenizer.from_pretrained(tok_name, trust_remote_code=True) n_samples = len(texts) raw_oof = None # (n_samples, hidden_dim) filled fold by fold for fold_idx, (_, val_idx) in enumerate(kfold.split(texts, y)): fold_n = fold_idx + 1 artifact_name = (mname if stage is None else mname + "__" + stage) safe_name = artifact_name.replace("/", "__") fold_dir = (Path(artifacts_dir) / safe_name / ("fold_" + str(fold_n)) / "model") if not fold_dir.exists(): print(" [WARN] fold {} dir not found: {}".format(fold_n, fold_dir)) continue encoder = _load_encoder_from_fold( fold_dir, mname, use_fp16, use_bf16, device) val_texts = [texts[i] for i in val_idx] val_embs = _encode_texts( encoder, tokenizer, val_texts, max_length, device, batch_size, drop_tti) # (n_val, H) if raw_oof is None: raw_oof = np.zeros((n_samples, val_embs.shape[1]), dtype=np.float32) raw_oof[val_idx] = val_embs del encoder gc.collect() import torch if device.startswith("cuda"): torch.cuda.empty_cache() print(" fold {}/{} done".format(fold_n, k_folds)) if raw_oof is None: print(" [{}] {} — no folds loaded, skipping".format(tag, cname)) continue # PCA fitted on full OOF matrix (no label info in embeddings -> safe) n_keep = min(n_components, raw_oof.shape[1], raw_oof.shape[0]) pca = PCA(n_components=n_keep, random_state=seed) reduced = pca.fit_transform(raw_oof).astype(np.float32) var = pca.explained_variance_ratio_.sum() print(" PCA {}->{} var_explained={:.1%}".format( raw_oof.shape[1], n_keep, var)) blocks.append(reduced) names.extend(["{}_OOF_{}_pc{}".format(tag, cname, i) for i in range(n_keep)]) if not blocks: return np.zeros((len(texts), 0), dtype=np.float32), [] X_emb = np.hstack(blocks) emb_df = pd.DataFrame(X_emb, columns=names) emb_df.to_parquet(cache_path) print(" [{}] OOF embeddings cached -> {} shape={}".format( tag, cache_path, X_emb.shape)) return X_emb, names X_ce, n_ce = _extract_one_ensemble( ce_configs, ce_artifacts_dir, "CE", ce_cache) if ce_artifacts_dir else ( np.zeros((len(texts), 0)), []) X_kl, n_kl = _extract_one_ensemble( kl_configs, kl_artifacts_dir, "KL", kl_cache) if kl_artifacts_dir else ( np.zeros((len(texts), 0)), []) parts = [x for x in [X_ce, X_kl] if x.shape[1] > 0] nparts = n_ce + n_kl if not parts: return np.zeros((len(texts), 0), dtype=np.float32), [] return np.hstack(parts), nparts def extract_frozen_embeddings(model_name, tokenizer_name, texts, max_length, device, n_components, batch_size, cache_path): """ Option 3: extract embeddings from a frozen (non-fine-tuned) pretrained encoder. No fold structure needed — pretrained weights never see labels so there is no leakage risk. PCA is fitted on the full dataset. Results are cached. """ from sklearn.decomposition import PCA from transformers import AutoModel, AutoTokenizer import torch cache = Path(cache_path) if cache.exists(): print(" Loading cached frozen embeddings <- {}".format(cache_path)) df_c = pd.read_parquet(cache) return df_c.values, list(df_c.columns) device = _normalise_device(device) cname = clean_name(model_name) tok_src = tokenizer_name if tokenizer_name else model_name print(" Frozen encoder embeddings: {} ({} samples)...".format( model_name, len(texts))) tokenizer = AutoTokenizer.from_pretrained(tok_src, trust_remote_code=True) encoder = AutoModel.from_pretrained(model_name, trust_remote_code=True) encoder.eval() encoder.to(device) all_embs = [] n_batches = (len(texts) + batch_size - 1) // batch_size for b_idx, start in enumerate(range(0, len(texts), batch_size)): batch = texts[start:start + batch_size] enc = tokenizer(batch, padding=True, truncation=True, max_length=max_length, return_tensors="pt") enc = {k: v.to(device) for k, v in enc.items()} with torch.no_grad(): out = encoder(**enc) cls = out.last_hidden_state[:, 0, :].float().cpu().numpy() all_embs.append(cls) if b_idx % 50 == 0 or b_idx == n_batches - 1: print(" batch {}/{}".format(b_idx + 1, n_batches)) del encoder gc.collect() if device.startswith("cuda"): torch.cuda.empty_cache() embeddings = np.vstack(all_embs) # (n_samples, H) n_keep = min(n_components, embeddings.shape[1], embeddings.shape[0]) pca = PCA(n_components=n_keep) reduced = pca.fit_transform(embeddings).astype(np.float32) var = pca.explained_variance_ratio_.sum() print(" PCA {}->{} var_explained={:.1%}".format( embeddings.shape[1], n_keep, var)) col_names = ["FROZEN_{}_pc{}".format(cname, i) for i in range(n_keep)] pd.DataFrame(reduced, columns=col_names).to_parquet(cache_path) print(" Frozen embeddings cached -> {} shape={}".format( cache_path, reduced.shape)) # CRITICAL: save the fitted PCA + the exact tokenisation settings so that # inference reproduces the SAME transform. Re-fitting PCA on inference data # would yield different components and break the meta-learner. import joblib pca_path = str(Path(cache_path).with_suffix("")) + "_pca.joblib" joblib.dump({ "pca": pca, "col_names": col_names, "model_name": model_name, "tokenizer_name": tok_src, "max_length": max_length, "n_components": n_keep, "hidden_dim": embeddings.shape[1], }, pca_path) print(" Frozen PCA transform saved -> {}".format(pca_path)) return reduced, col_names def _load_metadata(path: str) -> dict: if path and Path(path).exists(): with open(path) as f: return json.load(f) return {} def _save_metadata(path: str, data: dict): with open(path, "w") as f: json.dump(data, f, indent=2) print(f" Saved latency_ms → {path}") def build_latency_map( ce_configs: list, kl_configs: list, ce_artifacts_dir: str, kl_artifacts_dir: str, ce_metadata_path: str, kl_metadata_path: str, texts: list, max_length: int, device: str, n_repeats: int, ) -> dict: """ Return a latency map: {"CE:{clean_name}": ms, "KL:{clean_name}": ms, ...} For each ensemble (CE / KL): 1. Load its metadata JSON. 2. If "latency_ms" key already exists → use cached values, skip loading models. 3. Otherwise → benchmark every trained model, write results back to the metadata file. Latency is stored in metadata as {clean_name: ms} (no CE/KL prefix, since each metadata file already belongs to one ensemble). The combined latency_map uses the "CE:" / "KL:" prefix so callers can look up models unambiguously. """ latency_map = {} device = _normalise_device(device) # "gpu" -> "cuda" etc. def _bench_ensemble(configs, artifacts_dir, metadata_path, tag): """Handle one ensemble (CE or KL): check cache, bench if needed, write back.""" meta = _load_metadata(metadata_path) cached = meta.get("latency_ms", {}) # {clean_name: ms} # Check which trained models already have cached latency trained = [c for c in configs if c.get("use", True)] trained_names = [clean_name(c["model_name"]) for c in trained] missing_names = [n for n in trained_names if n not in cached] if not missing_names: print(f" [{tag}] All {len(trained_names)} model latencies loaded from {metadata_path}") for n in trained_names: latency_map[f"{tag}:{n}"] = cached[n] return # Some or all need benchmarking if cached: print(f" [{tag}] {len(cached)} cached, {len(missing_names)} need benchmarking: " f"{missing_names}") else: print(f" [{tag}] No cached latencies in {metadata_path} — timing all models.") newly_measured = {} def _bench_one(cfg): mname = cfg["model_name"] cname = clean_name(mname) task = cfg.get("task_type", "classification") tok_name = cfg.get("tokenizer_name", None) drop_tti = cfg.get("drop_token_type_ids", False) split_unk = cfg.get("split_unknown_stage", False) use_fp16 = cfg.get("use_fp16", False) use_bf16 = cfg.get("use_bf16", False) # Use cache if available if cname in cached: print(f" [{tag}] {cname}: using cached {cached[cname]:.1f} ms") latency_map[f"{tag}:{cname}"] = cached[cname] return print(f" [{tag}] Timing {cname} ...") if task == "tfidf_lgbm": n_tab = len(cfg.get("other_cols", [])) ms = benchmark_lgbm_model(artifacts_dir, texts, n_tab, n_repeats) if ms is None: print(f" [WARN] pickle not found — skipping") return elif split_unk: # 2-stage model: encoder runs twice (once per stage) with the same # base architecture, so we time once and double it. ms_single = benchmark_transformer_model( mname, tok_name, texts, max_length, device, n_repeats, drop_tti, use_fp16, use_bf16) ms = ms_single * 2.0 print(f" encoder x2 (stage1+stage2): {ms:.1f} ms / {len(texts)} samples") else: ms = benchmark_transformer_model( mname, tok_name, texts, max_length, device, n_repeats, drop_tti, use_fp16, use_bf16) print(f" {ms:.1f} ms / {len(texts)} samples") latency_map[f"{tag}:{cname}"] = ms newly_measured[cname] = round(ms, 3) for cfg in trained: _bench_one(cfg) # Write back to metadata only if we measured anything new if newly_measured and metadata_path: meta["latency_ms"] = {**cached, **newly_measured} meta["latency_benchmark_n_samples"] = len(texts) meta["latency_benchmark_device"] = device _save_metadata(metadata_path, meta) if ce_artifacts_dir: _bench_ensemble(ce_configs, ce_artifacts_dir, ce_metadata_path, "CE") if kl_artifacts_dir: _bench_ensemble(kl_configs, kl_artifacts_dir, kl_metadata_path, "KL") return latency_map def lookup_subset_latency(ce_sub, kl_sub, latency_map, extra_latency_ms: float = 0.0): """ Sum latencies for all models in a subset. Returns (total_ms, any_missing). extra_latency_ms: fixed overhead to add to every config regardless of which base models are selected (e.g. frozen encoder that always runs at inference, OOF embedding encoders that run at inference time). """ total = extra_latency_ms missing = [] for m in ce_sub: key = f"CE:{m}" if key in latency_map: total += latency_map[key] else: missing.append(key) for m in kl_sub: key = f"KL:{m}" if key in latency_map: total += latency_map[key] else: missing.append(key) return total, missing def benchmark_inference(X_subset, meta_learner, n_repeats=20): """Median wall-clock time for a single predict_proba call over X_subset.""" times = [] for _ in range(n_repeats): t0 = time.perf_counter() _ = meta_learner.predict_proba(X_subset) times.append(time.perf_counter() - t0) return np.median(times), np.std(times) # ============================================================================= # COMPLEMENTARITY ANALYSIS & GREEDY FORWARD SELECTION # ============================================================================= def compute_complementarity_matrix(X_all, y, tagged, n_classes): """ For every pair of models, compute the joint error ratio: P(A wrong AND B wrong) / P(A wrong OR B wrong) Low ratio = high complementarity (errors on different samples). High ratio = redundant pair. tagged: list of (clean_name, "CE"|"KL") """ preds = {} for i, (name, src) in enumerate(tagged): key = f"{src}:{name}" start = i * n_classes probs = X_all[:, start:start + n_classes] preds[key] = np.argmax(probs, axis=1) keys = list(preds.keys()) wrong = {k: (preds[k] != y) for k in keys} rows = [] for i, a in enumerate(keys): for j, b in enumerate(keys): if i >= j: continue both = (wrong[a] & wrong[b]).sum() either = (wrong[a] | wrong[b]).sum() ratio = both / max(either, 1) rows.append({"model_a": a, "model_b": b, "joint_error_ratio": round(ratio, 4), "a_err_rate": round(wrong[a].mean(), 4), "b_err_rate": round(wrong[b].mean(), 4)}) return pd.DataFrame(rows).sort_values("joint_error_ratio") def greedy_forward_selection(X_full, y, tagged, n_classes, class_order, df_ce, df_kl, use_derived, meta_type, k_folds, seed, max_models, min_gain, extra_features=None): """ Greedy forward selection of model subsets. Start with best single model; at each step add the candidate that gives the largest CV F1 gain. Stop when max_models reached or gain < min_gain. Returns singles + every greedy prefix as (label, ce_subset, kl_subset). extra_features: optional (n_samples, d) numpy array of fixed features (e.g. frozen encoder embeddings, OOF embeddings) that are concatenated to every subset's feature matrix. These are fixed regardless of which base models are selected — they represent encoders that always run at serving time. """ kfold = StratifiedKFold(n_splits=k_folds, shuffle=True, random_state=seed) def _cv_f1(ce_sub, kl_sub): b = OOFFeatureBuilder( ce_df=df_ce, kl_df=df_kl, ce_models=ce_sub, kl_models=kl_sub, use_derived=use_derived, ensemble_source="both", class_order=class_order, ) try: Xs, _ = b.build() except ValueError: return 0.0 n_prob = Xs.shape[1] # prob cols before any embeddings are appended if extra_features is not None and extra_features.shape[1] > 0: Xs = np.hstack([Xs, extra_features]) f1s = [] for tr, val in kfold.split(Xs, y): m = MetaLearner(meta_type, n_classes, seed, n_prob_cols=n_prob).fit(Xs[tr], y[tr]) p = np.argmax(m.predict_proba(Xs[val]), axis=1) f1s.append(precision_recall_fscore_support( y[val], p, average="macro", zero_division=0)[2]) return float(np.mean(f1s)) remaining = list(tagged) selected = [] best_f1 = 0.0 path = [] print(" Greedy forward selection" f" (max_models={max_models}, min_gain={min_gain}):") for step in range(max_models): best_candidate = None best_candidate_f1 = best_f1 for candidate in remaining: trial = selected + [candidate] ce_sub = [n for n, s in trial if s == "CE"] kl_sub = [n for n, s in trial if s == "KL"] f1 = _cv_f1(ce_sub, kl_sub) if f1 > best_candidate_f1: best_candidate_f1 = f1 best_candidate = candidate if best_candidate is None or (best_candidate_f1 - best_f1) < min_gain: print(f" Step {step+1}: no gain >={min_gain:.4f} — stopping.") break selected.append(best_candidate) remaining.remove(best_candidate) gain = best_candidate_f1 - best_f1 best_f1 = best_candidate_f1 name, src = best_candidate ce_sub = [n for n, s in selected if s == "CE"] kl_sub = [n for n, s in selected if s == "KL"] label = "+".join(f"{s}:{n.split('__')[-1][:15]}" for n, s in selected) short = name.split("__")[-1][:25] print(f" Step {step+1}: +{src}:{short:<25} " f"F1={best_f1:.4f} gain=+{gain:.4f}") path.append((label, list(ce_sub), list(kl_sub), best_f1)) # Singles always included for reference singles = [] for name, src in tagged: ce_sub = [name] if src == "CE" else [] kl_sub = [name] if src == "KL" else [] lbl = f"{src}:{name.split('__')[-1][:25]}" singles.append((lbl, ce_sub, kl_sub)) path_configs = [(lbl, ce, kl) for lbl, ce, kl, _ in path] seen = set() result = [] for cfg in singles + path_configs: key = (frozenset(f"CE:{m}" for m in cfg[1]) | frozenset(f"KL:{m}" for m in cfg[2])) if key not in seen: seen.add(key) result.append(cfg) return result def build_subset_configs(ce_models, kl_models, max_combo_size=3): """ Generate candidate model subsets for the accuracy-vs-speed sweep. Each model is tagged with its source ("CE" or "KL"). All subsets of size 1..max_combo_size are generated, plus the full ALL_CE, ALL_KL, and ALL_CE+KL aggregates. Returns list of (label, ce_subset, kl_subset) tuples. """ # Tag every model with its source so we can split them back out tagged = [(m, "CE") for m in ce_models] + [(m, "KL") for m in kl_models] n_total = len(tagged) seen = set() configs = [] def add(label, ce_sub, kl_sub): key = (frozenset(f"CE:{m}" for m in ce_sub) | frozenset(f"KL:{m}" for m in kl_sub)) if key not in seen: seen.add(key) configs.append((label, list(ce_sub), list(kl_sub))) # All subsets of size 1..max_combo_size cap = min(max_combo_size, n_total) for size in range(1, cap + 1): for combo in combinations(tagged, size): ce_sub = [m for m, src in combo if src == "CE"] kl_sub = [m for m, src in combo if src == "KL"] # Build a readable label: prefix only when mixing sources parts = [f"CE:{m.split('__')[-1][:18]}" if src == "CE" else f"KL:{m.split('__')[-1][:18]}" for m, src in combo] label = "+".join(parts) if len(parts) <= 3 else f"COMBO_{len(parts)}m" add(label, ce_sub, kl_sub) # Full aggregates (always include regardless of max_combo_size) add("ALL_CE", ce_models, []) if kl_models: add("ALL_KL", [], kl_models) add("ALL_CE+KL", ce_models, kl_models) return configs # ============================================================================= # PLOTTING # ============================================================================= def plot_fold_consistency(fold_importances, cv, feature_names, stable_mask, output_dir): """Heatmap of per-fold importances for top features, and CV bar plot.""" # weighted_avg importances cover only the leading prob columns (see # MetaLearner.get_feature_importances) — align names/counts to the array. feature_names = list(feature_names)[:fold_importances.shape[1]] top_n = min(30, fold_importances.shape[1]) mean_imp = fold_importances.mean(axis=0) top_idx = np.argsort(-mean_imp)[:top_n] fig, axes = plt.subplots(1, 2, figsize=(18, 8)) fig.suptitle("Fold Consistency Analysis", fontsize=14, fontweight="bold") # Heatmap data = fold_importances[:, top_idx] cols = [feature_names[i] for i in top_idx] # Truncate long names for display cols_short = [c[-40:] if len(c) > 40 else c for c in cols] sns.heatmap(data.T, ax=axes[0], xticklabels=[f"Fold {i+1}" for i in range(len(fold_importances))], yticklabels=cols_short, cmap="YlOrRd", fmt=".3f", annot=True, annot_kws={"size": 6}, linewidths=0.3) axes[0].set_title("Normalised Importance per Fold (Top Features)") axes[0].tick_params(axis='y', labelsize=6) # CV bar chart cv_top = cv[top_idx] colours = ["#2ecc71" if stable_mask[i] else "#e74c3c" for i in top_idx] axes[1].barh(range(top_n), cv_top[::-1], color=colours[::-1]) axes[1].set_yticks(range(top_n)) axes[1].set_yticklabels(cols_short[::-1], fontsize=6) axes[1].axvline(x=cv.mean(), color="grey", linestyle="--", label=f"mean CV={cv.mean():.2f}") axes[1].set_xlabel("Coefficient of Variation (lower = more stable)") axes[1].set_title("Feature Stability (green=stable, red=unstable)") axes[1].legend(fontsize=8) plt.tight_layout() out = Path(output_dir) / "fold_consistency.png" plt.savefig(out, dpi=150, bbox_inches="tight") plt.close() print(f" Saved → {out}") def plot_accuracy_vs_speed(results_df, output_dir): """Scatter plot: inference time (x) vs macro F1 (y), annotated by config label.""" fig, ax = plt.subplots(figsize=(12, 7)) # Colour by whether the config uses KL features colours = ["#3498db" if "KL" in r["label"] else "#e67e22" for _, r in results_df.iterrows()] time_col = "est_total_ms" if "est_total_ms" in results_df.columns else "meta_overhead_ms" scatter = ax.scatter(results_df[time_col], results_df["meta_f1"], c=colours, s=120, alpha=0.85, edgecolors="white", linewidth=0.5) for _, row in results_df.iterrows(): ax.annotate(row["label"], (row[time_col], row["meta_f1"]), textcoords="offset points", xytext=(6, 3), fontsize=7) ax.set_xlabel(f"Estimated Total Inference Time ({time_col}, ms) for {len(results_df)} samples") ax.set_ylabel("Meta-Learner Macro F1 (OOF CV)") ax.set_title("Accuracy vs Inference Speed\n(blue=KL involved, orange=CE only)") ax.grid(True, alpha=0.3) # Pareto frontier pareto = _pareto_frontier(results_df[[time_col, "meta_f1"]].values) if len(pareto) >= 2: pareto = pareto[np.argsort(pareto[:, 0])] ax.plot(pareto[:, 0], pareto[:, 1], "k--", linewidth=1.2, alpha=0.6, label="Pareto frontier") ax.legend(fontsize=9) plt.tight_layout() out = Path(output_dir) / "accuracy_vs_speed.png" plt.savefig(out, dpi=150, bbox_inches="tight") plt.close() print(f" Saved → {out}") def _pareto_frontier(points): """Return points on the Pareto frontier (minimise time, maximise F1).""" dominated = np.zeros(len(points), dtype=bool) for i in range(len(points)): for j in range(len(points)): if i == j: continue # j dominates i if j is faster AND has >= F1 if points[j, 0] <= points[i, 0] and points[j, 1] >= points[i, 1]: if points[j, 0] < points[i, 0] or points[j, 1] > points[i, 1]: dominated[i] = True break return points[~dominated] def plot_model_agreement(X, feature_names, ce_models, kl_models, n_classes, output_dir): """ Pairwise Spearman correlation between each model's argmax predictions. Helps visualise which models are redundant. """ argmax_preds = {} for m in ce_models: idx = [i for i, f in enumerate(feature_names) if f.startswith(f"CE_{m}_") and "_entropy" not in f and "_argmax" not in f and "_kl" not in f and "_diff" not in f] if idx: probs = X[:, idx] argmax_preds[f"CE_{m[:20]}"] = np.argmax(probs, axis=1) for m in kl_models: idx = [i for i, f in enumerate(feature_names) if f.startswith(f"KL_{m}_") and "_entropy" not in f and "_argmax" not in f and "_kl" not in f and "_diff" not in f] if idx: probs = X[:, idx] argmax_preds[f"KL_{m[:20]}"] = np.argmax(probs, axis=1) if len(argmax_preds) < 2: return keys = list(argmax_preds.keys()) n = len(keys) corr_mat = np.eye(n) for i in range(n): for j in range(i+1, n): rho, _ = spearmanr(argmax_preds[keys[i]], argmax_preds[keys[j]]) corr_mat[i, j] = corr_mat[j, i] = rho fig, ax = plt.subplots(figsize=(max(6, n), max(5, n-1))) sns.heatmap(corr_mat, xticklabels=keys, yticklabels=keys, annot=True, fmt=".2f", cmap="coolwarm", vmin=-1, vmax=1, ax=ax, linewidths=0.3) ax.set_title("Pairwise Spearman Correlation of Model Argmax Predictions\n" "(high correlation = redundant pair)") plt.tight_layout() out = Path(output_dir) / "model_agreement.png" plt.savefig(out, dpi=150, bbox_inches="tight") plt.close() print(f" Saved → {out}") # ============================================================================= # MAIN # ============================================================================= # ============================================================================= # DEPLOYMENT EXPORT # ============================================================================= def _export_deployment(export_row, results_df, out_dir, ce_configs, kl_configs, df_ce, df_kl, y, idx_to_label, class_order, extra_features_arr, n_classes, args, time_col_s): """ Re-train a meta-learner for the chosen config on the full training set and write all deployment artifacts to out_dir/deployment/: meta_learner.pkl - joblib-serialised MetaLearner deployment_config.json - everything the inference script needs """ import joblib export_dir = out_dir / "deployment" export_dir.mkdir(exist_ok=True) label = export_row["label"] exp_mt = export_row["meta_type"] exp_ce = [m for m in str(export_row.get("ce_models", "")).split(",") if m] exp_kl = [m for m in str(export_row.get("kl_models", "")).split(",") if m] print("\n Exporting deployment artifacts for:", label) # Re-train on full training data (not just a fold) exp_builder = OOFFeatureBuilder( ce_df=df_ce, kl_df=df_kl, ce_models=exp_ce, kl_models=exp_kl, use_derived=args.use_derived_features, ensemble_source="both", class_order=class_order, ) X_exp, fn_exp = exp_builder.build() n_prob_exp = X_exp.shape[1] if extra_features_arr is not None and extra_features_arr.shape[1] > 0: X_exp = np.hstack([X_exp, extra_features_arr]) exp_meta = MetaLearner(exp_mt, n_classes, args.seed, n_prob_cols=n_prob_exp).fit(X_exp, y) meta_path = export_dir / "meta_learner.pkl" joblib.dump({ "model": exp_meta, "feature_names": fn_exp, "n_prob_cols": n_prob_exp, "n_classes": n_classes, "class_order": class_order, "idx_to_label": idx_to_label, }, meta_path) print(" meta_learner.pkl ->", meta_path) # Per-model serving info: everything the inference script needs to load # and run each model (architecture, tokenizer, fold paths, other_cols, dtype) def _model_info(cname, source): cfgs = ce_configs if source == "CE" else kl_configs for c in cfgs: if clean_name(c["model_name"]) == cname: return c return {} def _verify_other_cols(model_name, artifacts_dir, declared_cols, split_unk): """ Cross-check declared other_cols against the actual trained checkpoint. The checkpoint's head input width tells us whether tabular features were used at training: a multimodal head has input dim = hidden + len(other_cols), a plain head has input dim = hidden. If the declared other_cols disagree with the checkpoint, the config is stale — trust the checkpoint and warn. Returns the corrected other_cols (possibly cleared to []). """ if not artifacts_dir: return declared_cols try: from safetensors.torch import load_file safe_name = model_name.replace("/", "__") if split_unk: safe_name += "__stage1" # Find fold_1 model dir base = Path(artifacts_dir) / ("pretrained_checkpoints__" + safe_name) if not base.exists(): base = Path(artifacts_dir) / safe_name st = base / "fold_1" / "model" / "model.safetensors" if not st.exists(): return declared_cols # can't verify, keep declared sd = load_file(str(st)) # Find the head's input width head_in = None hidden = None for k, v in sd.items(): kk = k[len("base_model."):] if k.startswith("base_model.") else k first = kk.split(".", 1)[0] if first in ("classifier", "feature_extractor") and kk.endswith(".weight"): # First head linear: input width is v.shape[1] if kk in ("classifier.0.weight", "feature_extractor.0.weight", "classifier.weight"): if head_in is None or kk.endswith("0.weight"): head_in = v.shape[1] # encoder hidden size: word embeddings width if "embeddings.word_embeddings.weight" in kk: hidden = v.shape[1] if head_in is None or hidden is None: return declared_cols checkpoint_tab = head_in - hidden # tabular feature count in checkpoint declared_tab = len(declared_cols or []) if checkpoint_tab != declared_tab: print(" [WARN] {}: declared other_cols={} ({} features) but " "checkpoint head expects {} tabular features. " "Trusting checkpoint.".format( clean_name(model_name), declared_cols, declared_tab, checkpoint_tab)) if checkpoint_tab <= 0: return [] # checkpoint expects tab but declared has wrong count — keep declared # names if count matches, else warn and keep as-is return declared_cols except Exception as e: print(" [NOTE] Could not verify other_cols for {}: {}".format( clean_name(model_name), e)) return declared_cols def _portable(path): """Deployment configs must survive machine moves (VM1 <-> VM2 <-> HF). Store artifact dirs relative to the project root (cwd at export time); the inference script's resolver finds them via its cwd rule on any machine. Absolute paths are kept only if outside the project tree.""" if not path: return None rp = Path(path).resolve() try: return str(rp.relative_to(Path.cwd())) except ValueError: return str(rp) model_entries = [] for cname in exp_ce: c = _model_info(cname, "CE") ce_art = _portable(args.ce_artifacts_dir) verified_cols = _verify_other_cols( c.get("model_name", cname), ce_art, c.get("other_cols", []), c.get("split_unknown_stage", False)) model_entries.append({ "source": "CE", "clean_name": cname, "model_name": c.get("model_name", cname), "tokenizer_name": c.get("tokenizer_name"), "task_type": c.get("task_type", "classification"), "split_unknown_stage": c.get("split_unknown_stage", False), "other_cols": verified_cols, "drop_token_type_ids": c.get("drop_token_type_ids", False), "use_fp16": c.get("use_fp16", False), "use_bf16": c.get("use_bf16", False), "artifacts_dir": ce_art, }) for cname in exp_kl: c = _model_info(cname, "KL") kl_art = _portable(args.kl_artifacts_dir) verified_cols = _verify_other_cols( c.get("model_name", cname), kl_art, c.get("other_cols", []), c.get("split_unknown_stage", False)) model_entries.append({ "source": "KL", "clean_name": cname, "model_name": c.get("model_name", cname), "tokenizer_name": c.get("tokenizer_name"), "task_type": c.get("task_type", "classification"), "split_unknown_stage": c.get("split_unknown_stage", False), "other_cols": verified_cols, "drop_token_type_ids": c.get("drop_token_type_ids", False), "use_fp16": c.get("use_fp16", False), "use_bf16": c.get("use_bf16", False), "artifacts_dir": kl_art, }) # Store meta_learner_path as just the filename — it always lives next to # the config. This makes the deployment dir portable (move it anywhere and # inference still works without editing the JSON). # artifacts_dir paths are absolute — they live outside the deployment dir. # frozen_emb_cache: absolute path (may be in a different experiment subdir). deployment_cfg = { "label": label, "meta_type": exp_mt, "meta_f1_cv": float(export_row["meta_f1"]), "est_total_ms": float(export_row.get(time_col_s, 0)), "benchmark_n_samples": args.benchmark_n_samples, "n_classes": n_classes, "class_order": class_order, "idx_to_label": {str(k): v for k, v in idx_to_label.items()}, "k_folds": args.k_folds, "use_derived_features": args.use_derived_features, "max_length": args.max_length, "n_prob_cols": n_prob_exp, "meta_learner_path": meta_path.name, # filename only — resolved relative to config dir "models": model_entries, "frozen_encoder": args.frozen_encoder, "frozen_encoder_tokenizer": args.frozen_encoder_tokenizer, "frozen_emb_n_components": args.frozen_emb_n_components if args.frozen_encoder else None, "frozen_emb_cache": str(Path(args.frozen_emb_cache).resolve()) if args.frozen_encoder and args.frozen_emb_cache else None, } cfg_path = export_dir / "deployment_config.json" with open(cfg_path, "w") as f: json.dump(deployment_cfg, f, indent=2) print(" deployment_config ->", cfg_path) print("\n To run inference:") print(" python meta_learner_inference.py \\") print(" --config", cfg_path, "\\") print(" --data_path \\") print(" --text_col text \\") print(" --output_path predictions.parquet") def main(): args = parse_args() out_dir = Path(args.output_dir) out_dir.mkdir(parents=True, exist_ok=True) # ── Fast export-only path ───────────────────────────────────────────────── if args.export_only: if not args.results_csv: raise ValueError("--results_csv is required when --export_only is set.") if not Path(args.results_csv).exists(): raise FileNotFoundError("results_csv not found: " + args.results_csv) print("\n" + "="*60) print("META-LEARNER TRAINER [export-only mode]") print("="*60) print("Loading existing results from:", args.results_csv) results_df = pd.read_csv(args.results_csv) best = results_df.sort_values("meta_f1", ascending=False).iloc[0] # Minimal data reload for re-training the meta-learner df_data = pd.read_parquet(args.data_path) df_ce = pd.read_parquet(args.ce_oof_path) if args.ce_oof_path else None df_kl = pd.read_parquet(args.kl_oof_path) if args.kl_oof_path else None mapping = load_mapping(args.mapping_dict_path) known = sorted([(k, v) for k, v in mapping.items() if v >= 0], key=lambda x: x[1]) unknown = [(k, v) for k, v in mapping.items() if v < 0] n_known = len(known) label_to_idx = {} for new_idx, (label_str, _) in enumerate(known): label_to_idx[label_str] = new_idx for i, (label_str, _) in enumerate(unknown): label_to_idx[label_str] = n_known + i idx_to_label = {v: k for k, v in label_to_idx.items()} n_classes = len(label_to_idx) class_order = get_class_order_from_mapping(mapping) raw_labels = df_data[args.label_col].astype(str).values valid_mask = np.array([l in label_to_idx for l in raw_labels]) y = np.array([label_to_idx[l] for l in raw_labels[valid_mask]]) if df_ce is not None: df_ce = df_ce.iloc[valid_mask].reset_index(drop=True) if df_kl is not None: df_kl = df_kl.iloc[valid_mask].reset_index(drop=True) # Load configs ce_configs = get_active_models(args.ce_config_path) if args.ce_config_path else [] kl_configs = get_active_models(args.kl_config_path) if args.kl_config_path else [] # Load frozen embeddings if applicable extra_features_arr = None if args.frozen_encoder and args.frozen_emb_cache: cache = Path(args.frozen_emb_cache) if cache.exists(): print("Loading cached frozen embeddings from:", args.frozen_emb_cache) emb_df = pd.read_parquet(args.frozen_emb_cache) extra_features_arr = emb_df.values[valid_mask] else: print("[WARN] frozen_emb_cache not found — embeddings will not be included.") # Pick export row if args.export_label: match = results_df[results_df["label"] == args.export_label] export_row = match.iloc[0] if not match.empty else best if match.empty: print("[WARN] --export_label not found; using best F1 config.") else: export_row = best time_col_s = "est_total_ms" if "est_total_ms" in results_df.columns else "meta_overhead_ms" _export_deployment( export_row=export_row, results_df=results_df, out_dir=out_dir, ce_configs=ce_configs, kl_configs=kl_configs, df_ce=df_ce, df_kl=df_kl, y=y, idx_to_label=idx_to_label, class_order=class_order, extra_features_arr=extra_features_arr, n_classes=n_classes, args=args, time_col_s=time_col_s, ) return # ── Full training path ──────────────────────────────────────────────────── print("\n" + "="*60) print("META-LEARNER TRAINER") print("="*60) # --- Load data --- print("\n[1] Loading data...") df_data = pd.read_parquet(args.data_path) df_ce = pd.read_parquet(args.ce_oof_path) if args.ce_oof_path else None df_kl = pd.read_parquet(args.kl_oof_path) if args.kl_oof_path else None mapping = load_mapping(args.mapping_dict_path) # Encode labels exactly as the generator does: # known classes (value >= 0): 0-based index = value - ordinal_min_label # unknown classes (value < 0): placed last, index = n_known_classes + i # valid_mask keeps any row whose label string is a key in mapping. # Rows whose label string is not in mapping at all (e.g. NaN coerced to "nan") are dropped. known = sorted([(k, v) for k, v in mapping.items() if v >= 0], key=lambda x: x[1]) unknown = [(k, v) for k, v in mapping.items() if v < 0] n_known = len(known) label_to_idx = {} for new_idx, (label_str, _) in enumerate(known): label_to_idx[label_str] = new_idx # "ON_MAIN_STREET" -> 0, etc. for i, (label_str, _) in enumerate(unknown): label_to_idx[label_str] = n_known + i # "UNKNOWN" -> 5 idx_to_label = {v: k for k, v in label_to_idx.items()} n_classes = len(label_to_idx) raw_labels = df_data[args.label_col].astype(str).values valid_mask = np.array([l in label_to_idx for l in raw_labels]) if not valid_mask.all(): dropped = (~valid_mask).sum() examples = list(set(raw_labels[~valid_mask]))[:5] print(f" Dropping {dropped} rows with label strings not in mapping. Examples: {examples}") y = np.array([label_to_idx[l] for l in raw_labels[valid_mask]]) print(f" Label mapping (from mapping.json):") for idx in range(n_classes): lbl = idx_to_label[idx] count = int((y == idx).sum()) print(f" class {idx}: '{lbl}' [{count:,} samples]") # Align all dataframes to valid rows if df_ce is not None: df_ce = df_ce.iloc[valid_mask].reset_index(drop=True) if df_kl is not None: df_kl = df_kl.iloc[valid_mask].reset_index(drop=True) print(f" Samples: {len(y):,} | Classes: {n_classes}") # --- Load configs --- ce_configs = get_active_models(args.ce_config_path) if args.ce_config_path else [] ce_model_names = [clean_name(c["model_name"]) for c in ce_configs] kl_model_names = [] if args.kl_config_path: kl_configs = get_active_models(args.kl_config_path) kl_model_names = [clean_name(c["model_name"]) for c in kl_configs] # Apply model_subset filter model_subset = None if args.model_subset: model_subset = [s.strip() for s in args.model_subset.split(",")] print(f" Filtering to subset: {model_subset}") print(f" CE models: {ce_model_names}") print(f" KL models: {kl_model_names}") # --- Build features --- print("\n[2] Building OOF feature matrix...") class_order = get_class_order_from_mapping(mapping) builder = OOFFeatureBuilder( ce_df=df_ce, kl_df=df_kl, ce_models=ce_model_names, kl_models=kl_model_names, model_subset=model_subset, use_derived=args.use_derived_features, ensemble_source=args.ensemble_source, class_order=class_order, ) X, feature_names = builder.build() print(f" Feature matrix shape: {X.shape}") print(f" Feature groups:") for prefix in ["CE_", "KL_", "CE_KL_", "CE_pair_"]: count = sum(1 for f in feature_names if f.startswith(prefix)) if count: print(f" {prefix:<12} {count} features") # Sanity check: class_order (from mapping) drives both y encoding and column ordering. # Both should always be ✓ now. Printed so any future regression is immediately visible. print(f" Label ↔ OOF column alignment (class_order from mapping):") all_ok = True for i, cls in enumerate(class_order): expected_y_label = idx_to_label.get(i, "???") ok = (cls == expected_y_label) tag = "✓" if ok else f"✗ y has '{expected_y_label}'" if not ok: all_ok = False count = int((y == i).sum()) print(f" class {i}: '{cls}' {tag} [{count:,} samples]") if all_ok: print(" All aligned.") print() # --- Embedding features (Options 2 and 3) --- extra_features_arr = None # populated below if any embedding flags are set X_oof_emb = np.zeros((len(y), 0), dtype=np.float32) X_frozen = np.zeros((len(y), 0), dtype=np.float32) emb_needs_text = args.use_oof_embeddings or args.frozen_encoder if emb_needs_text and not args.text_col: raise ValueError("--text_col is required when using --use_oof_embeddings " "or --frozen_encoder.") if emb_needs_text: all_texts = df_data.iloc[valid_mask][args.text_col].fillna("").tolist() emb_device = _normalise_device(args.benchmark_device) if args.use_oof_embeddings: need_dirs = (not args.ce_artifacts_dir and not args.kl_artifacts_dir) if need_dirs: raise ValueError("--use_oof_embeddings requires at least one of " "--ce_artifacts_dir / --kl_artifacts_dir.") print("\n[2b] Extracting OOF embeddings (Option 2)...") X_oof_emb, oof_emb_names = extract_oof_embeddings( ce_configs = ce_configs, kl_configs = kl_configs, ce_artifacts_dir = args.ce_artifacts_dir, kl_artifacts_dir = args.kl_artifacts_dir, texts = all_texts, y = y, max_length = args.max_length, device = emb_device, n_components = args.oof_emb_n_components, batch_size = args.oof_emb_batch_size, k_folds = args.k_folds, seed = args.seed, ce_cache = args.oof_emb_ce_cache, kl_cache = args.oof_emb_kl_cache, ) if X_oof_emb.shape[1] > 0: X = np.hstack([X, X_oof_emb]) feature_names = feature_names + oof_emb_names print(" Added {} OOF embedding features. " "Total features: {}".format(len(oof_emb_names), X.shape[1])) if args.frozen_encoder: print("\n[2c] Extracting frozen encoder embeddings (Option 3)...") X_frozen, frozen_names = extract_frozen_embeddings( model_name = args.frozen_encoder, tokenizer_name = args.frozen_encoder_tokenizer, texts = all_texts, max_length = args.max_length, device = emb_device, n_components = args.frozen_emb_n_components, batch_size = args.frozen_emb_batch_size, cache_path = args.frozen_emb_cache, ) if X_frozen.shape[1] > 0: X = np.hstack([X, X_frozen]) feature_names = feature_names + frozen_names print(" Added {} frozen embedding features. " "Total features: {}".format(len(frozen_names), X.shape[1])) # Collect fixed embedding features to pass into greedy selection and sweep. # These are "always-on" at serving time — every request runs these encoders # regardless of which base models are selected. extra_feature_parts = [] if args.use_oof_embeddings and "X_oof_emb" in dir(): if X_oof_emb.shape[1] > 0: extra_feature_parts.append(X_oof_emb) if args.frozen_encoder and "X_frozen" in dir(): if X_frozen.shape[1] > 0: extra_feature_parts.append(X_frozen) extra_features_arr = (np.hstack(extra_feature_parts) if extra_feature_parts else None) if extra_features_arr is not None: print(" Fixed embedding features for sweep/greedy: {} dims".format( extra_features_arr.shape[1])) # --- Model agreement plot --- print("\n[3] Plotting model agreement...") plot_model_agreement(X, feature_names, builder._ce_active, builder._kl_active, n_classes, out_dir) # --- Fold consistency analysis --- print("\n[4] Running fold consistency analysis...") # n_prob_cols: columns that are valid probability distributions. # Embedding columns appended after are real-valued and not prob distributions. n_prob_cols = X.shape[1] - (extra_features_arr.shape[1] if extra_features_arr is not None else 0) fold_importances, cv, stable_mask, fold_f1s = fold_consistency_analysis( X=X, y=y, feature_names=feature_names, meta_type=args.meta_type, n_classes=n_classes, k_folds=args.k_folds, seed=args.seed, threshold=args.fold_consistency_threshold, n_prob_cols=n_prob_cols, ) if fold_importances is not None: plot_fold_consistency(fold_importances, cv, feature_names, stable_mask, out_dir) # Save stability report stability_df = pd.DataFrame({ "feature": list(feature_names)[:fold_importances.shape[1]], "mean_importance": fold_importances.mean(axis=0), "std_importance": fold_importances.std(axis=0), "cv": cv, "stable": stable_mask, }).sort_values("mean_importance", ascending=False) stability_df.to_csv(out_dir / "feature_stability.csv", index=False) print(f" Saved → {out_dir / 'feature_stability.csv'}") # --- Train final meta-learner on stable features --- print("\n[5] Training final meta-learner...") X_final = X if stable_mask is not None and len(stable_mask) != X.shape[1]: # weighted_avg importances (hence this mask) cover only the leading # prob columns; column selection would also break the per-model # n_classes block structure its blending relies on. Keep all features. print(" Stability mask covers %d of %d columns (weighted_avg " "prob-cols only) — skipping stable-feature selection." % (len(stable_mask), X.shape[1])) stable_mask = None if stable_mask is not None and stable_mask.any() and stable_mask.sum() > n_classes: print(f" Using {stable_mask.sum()} stable features out of {X.shape[1]}") X_final = X[:, stable_mask] feature_names_final = [f for f, s in zip(feature_names, stable_mask) if s] else: print(" Using all features (stable mask not applicable or too few stable).") feature_names_final = feature_names final_meta = MetaLearner(args.meta_type, n_classes, args.seed, n_prob_cols=n_prob_cols).fit(X_final, y) final_preds = np.argmax(final_meta.predict_proba(X_final), axis=1) final_f1 = precision_recall_fscore_support(y, final_preds, average="macro", zero_division=0)[2] print(f" Final meta-learner (train) Macro F1: {final_f1:.4f}") print(f" Cross-val Macro F1: {np.mean(fold_f1s):.4f} ± {np.std(fold_f1s):.4f}") # --- Accuracy vs Speed sweep --- print("\n[6] Accuracy vs Inference Speed analysis...") bm_idx = np.random.default_rng(args.seed).choice( len(X), size=min(args.benchmark_n_samples, len(X)), replace=False) # Build per-model latency map by loading and timing each checkpoint latency_map = {} has_latency = args.ce_artifacts_dir or args.kl_artifacts_dir if has_latency: if not args.text_col: raise ValueError("--text_col is required when --ce_artifacts_dir or " "--kl_artifacts_dir is provided.") texts_for_bench = df_data.iloc[valid_mask][args.text_col].fillna("").tolist() texts_for_bench = [texts_for_bench[i] for i in bm_idx] print(f" Benchmarking base model latency on {len(texts_for_bench)} samples " f"(device={args.benchmark_device}, repeats={args.benchmark_repeats})...") latency_map = build_latency_map( ce_configs = ce_configs if args.ce_artifacts_dir else [], kl_configs = kl_configs if args.kl_artifacts_dir else [], ce_artifacts_dir = args.ce_artifacts_dir, kl_artifacts_dir = args.kl_artifacts_dir, ce_metadata_path = args.ce_metadata_path, kl_metadata_path = args.kl_metadata_path, texts = texts_for_bench, max_length = args.max_length, device = args.benchmark_device, n_repeats = args.benchmark_repeats, ) print(f" Latency map ({len(latency_map)} models):") for k, v in sorted(latency_map.items()): print(f" {k:<60s} {v:.1f} ms / {len(texts_for_bench)} samples") else: print(" NOTE: --ce_artifacts_dir / --kl_artifacts_dir not provided.") print(" Only meta overhead is timed. Transformer latency dominates in production.") print(" Re-run with those flags for realistic per-model timing.") # Measure inference-time latency of embedding encoders. # These run on EVERY request at serving time regardless of which base models # are selected — they are a fixed overhead added to every config's total_ms. # The parquet cache is only for training; at serving time you re-run them. extra_inference_ms = 0.0 extra_notes = [] if args.frozen_encoder and has_latency: print(" Timing frozen encoder inference latency...") frozen_ms = benchmark_transformer_model( original_model_name = args.frozen_encoder, tokenizer_name = args.frozen_encoder_tokenizer, texts = texts_for_bench, max_length = args.max_length, device = args.benchmark_device, n_repeats = args.benchmark_repeats, use_fp16 = False, use_bf16 = False, ) extra_inference_ms += frozen_ms extra_notes.append("frozen_encoder={:.1f}ms".format(frozen_ms)) print(" Frozen encoder: {:.1f} ms / {} samples".format( frozen_ms, len(texts_for_bench))) if args.use_oof_embeddings and has_latency: # OOF encoders at serving time = run each fine-tuned base model a second # time to extract embeddings. We approximate as the sum of CE encoder # latencies (stage1 for split_unknown models) since those are already # in latency_map and represent the same forward pass cost. oof_enc_ms = 0.0 for cfg in ce_configs: if not cfg.get("use", True): continue if cfg.get("task_type") == "tfidf_lgbm": continue cname = clean_name(cfg["model_name"]) key = "CE:" + cname if key in latency_map: oof_enc_ms += latency_map[key] extra_inference_ms += oof_enc_ms extra_notes.append("oof_emb_encoders={:.1f}ms".format(oof_enc_ms)) print(" OOF embedding encoder overhead: {:.1f} ms / {} samples".format( oof_enc_ms, len(texts_for_bench))) if extra_notes: print(" Fixed inference overhead per request: {:.1f} ms ({})".format( extra_inference_ms, ", ".join(extra_notes))) else: extra_inference_ms = 0.0 # --- Complementarity table (always computed, cheap) --- all_tagged = ([(m, "CE") for m in builder._ce_active] + [(m, "KL") for m in builder._kl_active]) # Build base-probs-only feature matrix for complementarity (no derived features) b_base = OOFFeatureBuilder( ce_df=df_ce, kl_df=df_kl, ce_models=builder._ce_active, kl_models=builder._kl_active, use_derived=False, ensemble_source="both", class_order=class_order) X_base, _ = b_base.build() comp_df = compute_complementarity_matrix(X_base, y, all_tagged, n_classes) comp_path = out_dir / "complementarity.csv" comp_df.to_csv(comp_path, index=False) print(" Model pair complementarity (top-10 most complementary pairs):") print(comp_df.head(10).to_string(index=False)) print(" Full table saved ->", comp_path) # --- Subset generation and meta-type comparison --- # When --compare_meta_types: run greedy selection for every meta-learner type # so the comparison reflects (learner, subset) pairs — not just which learner # wins on the full feature set. Different learners may reach their plateau with # different numbers of models. Results are merged into a single sweep table. # # Without --compare_meta_types: run greedy/exhaustive for --meta_type only. META_TYPES = ["ridge", "logistic", "weighted_avg", "lgbm", "mlp"] types_to_run = META_TYPES if args.compare_meta_types else [args.meta_type] results = [] all_subset_configs = {} # meta_type -> list of (label, ce_sub, kl_sub) for mt in types_to_run: if args.compare_meta_types: print() print(" ---- meta_type:", mt, "----") if args.selection_strategy == "greedy": mt_configs = greedy_forward_selection( X_full=X_base, y=y, tagged=all_tagged, n_classes=n_classes, class_order=class_order, df_ce=df_ce, df_kl=df_kl, use_derived=args.use_derived_features, meta_type=mt, k_folds=args.k_folds, seed=args.seed, max_models=args.greedy_max_models, min_gain=args.greedy_min_gain, extra_features=extra_features_arr, ) print(" Greedy selected", len(mt_configs), "configs for", mt) else: mt_configs = build_subset_configs( builder._ce_active, builder._kl_active, max_combo_size=args.max_combo_size, ) if mt == types_to_run[0]: print(" Exhaustive:", len(mt_configs), "subsets (max_combo_size={})".format(args.max_combo_size)) all_subset_configs[mt] = mt_configs # Flatten: tag each config with its meta_type for the results table sweep_tasks = [] # (meta_type, label, ce_sub, kl_sub) seen_labels = set() for mt, cfgs in all_subset_configs.items(): for label, ce_sub, kl_sub in cfgs: tagged_label = label if not args.compare_meta_types else mt + "/" + label sweep_tasks.append((mt, tagged_label, ce_sub, kl_sub)) seen_labels.add(tagged_label) # When only one meta_type, deduplicate configs evaluated multiple times if not args.compare_meta_types: seen = set() deduped = [] for task in sweep_tasks: key = (task[0], frozenset(task[2]), frozenset(task[3])) if key not in seen: seen.add(key) deduped.append(task) sweep_tasks = deduped kfold_cv = StratifiedKFold(n_splits=args.k_folds, shuffle=True, random_state=args.seed) # Build a lookup of pre-computed single-model OOF F1 scores. # For single-model sweep configs the meta-learner is a no-op, so we skip # expensive CV and use the pre-computed OOF F1 directly. # # Source: metadata.json (written by the generator), NOT the config file. # The config no longer stores oof_f1 — that was removed to keep configs # immutable. metadata.json is the canonical record of training results. def _load_f1_from_metadata(meta_path): """Return {clean_name: oof_f1} from a metadata.json, or {} if unavailable.""" if not meta_path or not Path(meta_path).exists(): return {} with open(meta_path) as f: meta = json.load(f) names = meta.get("model_names", []) scores = meta.get("f1_scores", []) return {clean_name(n): float(s) for n, s in zip(names, scores)} ce_f1_map = _load_f1_from_metadata(args.ce_metadata_path) kl_f1_map = _load_f1_from_metadata(args.kl_metadata_path) single_model_f1: dict = {} # "CE:" | "KL:" -> oof_f1 for cfg in ce_configs: cname = clean_name(cfg["model_name"]) if cname in ce_f1_map: single_model_f1["CE:" + cname] = ce_f1_map[cname] for cfg in kl_configs: cname = clean_name(cfg["model_name"]) if cname in kl_f1_map: single_model_f1["KL:" + cname] = kl_f1_map[cname] if single_model_f1: print(" Single-model F1 loaded from metadata ({} models):".format( len(single_model_f1))) for k, v in sorted(single_model_f1.items()): print(" {:<55s} {:.4f}".format(k, v)) else: print(" [NOTE] No single-model F1 from metadata " "(--ce_metadata_path / --kl_metadata_path not set or files missing).") print(" Single-model configs will run full CV instead of using cached F1.") for mt, label, ce_sub, kl_sub in sweep_tasks: n_base_models = len(ce_sub) + len(kl_sub) # --- Fast path: single-model configs --- # The meta-learner sees only one model's OOF probs -> it cannot improve on # the model's own OOF F1. Skip CV and read from metadata directly. # (weighted_avg weight = [1.0], ridge/logistic ≈ identity on well-calibrated # probs, lgbm/mlp may marginally differ but not worth the compute.) if n_base_models == 1: key = ("CE:" + ce_sub[0]) if ce_sub else ("KL:" + kl_sub[0]) if key in single_model_f1: mean_f1 = single_model_f1[key] cv_f1s = [mean_f1] # single value — std will be 0 # Still time the meta overhead (fast, just one predict call) sub_builder = OOFFeatureBuilder( ce_df=df_ce, kl_df=df_kl, ce_models=ce_sub, kl_models=kl_sub, use_derived=args.use_derived_features, ensemble_source="both", class_order=class_order) try: X_sub, _ = sub_builder.build() except ValueError: continue n_prob_sub = X_sub.shape[1] if extra_features_arr is not None and extra_features_arr.shape[1] > 0: X_sub = np.hstack([X_sub, extra_features_arr]) m_bench = MetaLearner(mt, n_classes, args.seed, n_prob_cols=n_prob_sub).fit(X_sub, y) base_ms, missing = lookup_subset_latency(ce_sub, kl_sub, latency_map, extra_inference_ms) meta_med_ms, _ = benchmark_inference(X_sub[bm_idx], m_bench, n_repeats=20) meta_med_ms *= 1000 total_ms = base_ms + meta_med_ms total_per_smp = total_ms / max(len(bm_idx), 1) tag_str = label + " [F1 from metadata]" print(" ", tag_str) if has_latency: print(" F1={:.4f} models={} transformer={:.1f}ms " "meta={:.2f}ms total={:.1f}ms / {} samples".format( mean_f1, n_base_models, base_ms, meta_med_ms, total_ms, len(bm_idx))) else: print(" F1={:.4f} models={} meta_overhead={:.2f}ms".format( mean_f1, n_base_models, meta_med_ms)) results.append({ "label": label, "meta_type": mt, "ce_models": ",".join(ce_sub), "kl_models": ",".join(kl_sub), "n_models": n_base_models, "meta_f1": round(mean_f1, 4), "f1_std": 0.0, "base_model_ms": round(base_ms - extra_inference_ms, 2), "extra_enc_ms": round(extra_inference_ms, 2), "transformer_ms": round(base_ms, 2), "meta_overhead_ms": round(meta_med_ms, 3), "est_total_ms": round(total_ms, 2), "ms_per_sample": round(total_per_smp, 5), }) continue # skip the full CV block below sub_builder = OOFFeatureBuilder( ce_df=df_ce, kl_df=df_kl, ce_models=ce_sub, kl_models=kl_sub, use_derived=args.use_derived_features, ensemble_source="both", class_order=class_order, ) try: X_sub, fn_sub = sub_builder.build() except ValueError: continue # Append fixed embedding features (frozen encoder, OOF embeddings). # These are identical for every subset — they don't depend on which # base models are selected, only on the text input. n_prob_sub = X_sub.shape[1] # record before appending embeddings if extra_features_arr is not None and extra_features_arr.shape[1] > 0: X_sub = np.hstack([X_sub, extra_features_arr]) # CV F1 — use the meta_type for this task, not the global --meta_type cv_f1s = [] for tr_idx, val_idx in kfold_cv.split(X_sub, y): m = MetaLearner(mt, n_classes, args.seed, n_prob_cols=n_prob_sub).fit(X_sub[tr_idx], y[tr_idx]) preds = np.argmax(m.predict_proba(X_sub[val_idx]), axis=1) f1 = precision_recall_fscore_support(y[val_idx], preds, average="macro", zero_division=0)[2] cv_f1s.append(f1) mean_f1 = np.mean(cv_f1s) # Meta overhead — use the task's meta_type m_bench = MetaLearner(mt, n_classes, args.seed, n_prob_cols=n_prob_sub).fit(X_sub, y) X_bm = X_sub[bm_idx] meta_med_ms, _ = benchmark_inference(X_bm, m_bench, n_repeats=20) meta_med_ms *= 1000 # Per-model transformer latency (sum over all models in subset) n_base_models = len(ce_sub) + len(kl_sub) base_ms, missing = lookup_subset_latency(ce_sub, kl_sub, latency_map, extra_inference_ms) total_ms = base_ms + meta_med_ms total_per_smp = total_ms / max(len(bm_idx), 1) if missing and has_latency: print(f" {label} [WARN missing latency for: {missing}]") else: print(f" {label}") if has_latency: print(f" F1={mean_f1:.4f} models={n_base_models} " f"transformer={base_ms:.1f}ms meta={meta_med_ms:.2f}ms " f"total={total_ms:.1f}ms / {len(bm_idx)} samples") else: print(f" F1={mean_f1:.4f} models={n_base_models} " f"meta_overhead={meta_med_ms:.2f}ms (⚠ transformer latency not measured)") results.append({ "label": label, "meta_type": mt, "ce_models": ",".join(ce_sub), "kl_models": ",".join(kl_sub), "n_models": n_base_models, "meta_f1": round(mean_f1, 4), "f1_std": round(np.std(cv_f1s), 4), "base_model_ms": round(base_ms - extra_inference_ms, 2), "extra_enc_ms": round(extra_inference_ms, 2), "transformer_ms": round(base_ms, 2), "meta_overhead_ms": round(meta_med_ms, 3), "est_total_ms": round(total_ms, 2), "ms_per_sample": round(total_per_smp, 5), }) results_df = pd.DataFrame(results).sort_values("meta_f1", ascending=False) results_df.to_csv(out_dir / "accuracy_vs_speed.csv", index=False) print(f"\n Saved → {out_dir / 'accuracy_vs_speed.csv'}") print("\n Top configs by F1:") display_cols = ["meta_type", "label", "meta_f1", "f1_std", "base_model_ms", "extra_enc_ms", "meta_overhead_ms", "est_total_ms", "n_models"] display_cols = [c for c in display_cols if c in results_df.columns] print(results_df[display_cols].to_string(index=False)) plot_accuracy_vs_speed(results_df, out_dir) # --- Summary --- print("\n" + "="*60) print("SUMMARY") print("="*60) best = results_df.iloc[0] time_col_s = "est_total_ms" if "est_total_ms" in results_df.columns else "meta_overhead_ms" pareto_pts = _pareto_frontier(results_df[[time_col_s, "meta_f1"]].values) fastest_pareto_ms = min(p[0] for p in pareto_pts) fastest_pareto = results_df[results_df[time_col_s] == fastest_pareto_ms].iloc[0] print(f" Best F1 config : {best['label']} " f"(F1={best['meta_f1']:.4f}, total={best[time_col_s]:.1f}ms / {args.benchmark_n_samples} samples)") print(f" Fastest Pareto cfg : {fastest_pareto['label']} " f"(F1={fastest_pareto['meta_f1']:.4f}, total={fastest_pareto[time_col_s]:.1f}ms / {args.benchmark_n_samples} samples)") print(f"\n Outputs in: {out_dir}/") print("="*60) # --- Deployment export --- # Select config row to export (explicit label or best F1) if args.export_label: match = results_df[results_df["label"] == args.export_label] export_row = match.iloc[0] if not match.empty else best if match.empty: print("[WARN] --export_label not found; exporting best F1 config.") else: export_row = best _export_deployment( export_row = export_row, results_df = results_df, out_dir = out_dir, ce_configs = ce_configs, kl_configs = kl_configs, df_ce = df_ce, df_kl = df_kl, y = y, idx_to_label = idx_to_label, class_order = class_order, extra_features_arr = extra_features_arr, n_classes = n_classes, args = args, time_col_s = time_col_s, ) if __name__ == "__main__": main()