"""ML1 · funciones compartidas: carga, variables, AUC estratificada con pesos.""" import numpy as np, pandas as pd SEM = 20261022 NUM_P = ['num_ofertas','baja','min_rel','max_rel','disp','ofertas_anormales','log_pbl','log_vee','duracion','plazo_ofertas','dias_adjudicar', 'sara','financiacion_ue','n_lotes','n_adj_lote'] CAT = ['procedimiento','tramitacion','tipo_contrato','tipo_organo'] NUM_C = ['org_n_prev','org_ou_prev','org_nof_prev','org_nadj_prev','org_nadj_ratio_prev','org_baja_prev','org_nsp_prev','org_anul_prev','hhi_prev','merc_nemp_prev'] NUM_A = ['edad_adj','es_ute'] NUM_A2 = ['adj_n_prev','es_pyme'] CONJ = { 'P': NUM_P + NUM_C + NUM_A + CAT, 'D1': ['org_n_prev','log_pbl','tipo_contrato','procedimiento','tipo_organo'], 'D3': NUM_P + NUM_C + CAT, 'D4': NUM_P + NUM_C + NUM_A + NUM_A2 + CAT, 'X1': NUM_P + ['procedimiento','tramitacion','tipo_contrato'], # exploratorio (enmienda 22-oct): proceso puro } LOG1P = {'num_ofertas','n_lotes','n_adj_lote','org_n_prev','org_nadj_prev','merc_nemp_prev','duracion','plazo_ofertas','dias_adjudicar','edad_adj','adj_n_prev','org_nof_prev'} def carga(w='/w/tmp'): L = pd.read_csv(f'{w}/ds_lotes.csv', dtype={'cpv_division': str}, low_memory=False).set_index('idx').sort_index() assert (L.index.values == np.arange(len(L))).all() for c in CAT: L[c] = pd.Categorical(L[c].fillna('sin_dato')) for c in NUM_P + NUM_C + NUM_A + NUM_A2: L[c] = pd.to_numeric(L[c], errors='coerce').astype(float) S = pd.read_csv(f'{w}/ds_estratos.csv', dtype={'cpv_division': str, 'vars': str}, keep_default_na=False) S['org'] = L['org'].values[S['idx'].values] return L, S def matriz(L, cols): """DataFrame con categorías como códigos float (NaN = sin dato), y máscara de categóricas.""" X = pd.DataFrame(index=L.index) cat = [] for c in cols: if c in CAT: v = L[c].cat.codes.astype(float).values; v[v < 0] = np.nan; X[c] = v; cat.append(True) else: X[c] = L[c].values; cat.append(False) return X, np.array(cat) class Estrat: """AUC estratificada Σ U_s / Σ n1 n0 con pesos por fila; el orden se calcula una vez y el bootstrap solo cambia pesos.""" def __init__(self, estrato, score, y): estrato = np.asarray(estrato); score = np.asarray(score, float); y = np.asarray(y, int) _, sid = np.unique(estrato, return_inverse=True) o = np.lexsort((score, sid)); self.o = o s2, sc2 = sid[o], score[o]; self.y = y[o]; self.sid = s2 nuevo = np.r_[True, (s2[1:] != s2[:-1]) | (sc2[1:] != sc2[:-1])] self.run = np.cumsum(nuevo) - 1; self.nrun = self.run[-1] + 1 if len(o) else 0 self.run_sid = s2[nuevo]; self.ns = sid.max() + 1 if len(o) else 0 primero_estrato = np.r_[True, self.run_sid[1:] != self.run_sid[:-1]] self.ini_estrato_run = np.maximum.accumulate(np.where(primero_estrato, np.arange(self.nrun), 0)) def auc(self, w=None): w = np.ones(len(self.o)) if w is None else np.asarray(w, float)[self.o] P = np.bincount(self.run, w * self.y, self.nrun); C = np.bincount(self.run, w * (1 - self.y), self.nrun) cc = np.cumsum(C); antes = cc - C base = np.r_[0.0, cc][self.ini_estrato_run] U = (P * (antes - base + 0.5 * C)).sum() Ps = np.bincount(self.run_sid, P, self.ns); Cs = np.bincount(self.run_sid, C, self.ns) D = (Ps * Cs).sum() return U / D if D > 0 else np.nan def boot(est, grupos, B=2000, seed=SEM): """grupos: array por fila (antes de ordenar) con el conglomerado. Devuelve (lo, hi, n_grupos).""" g = np.asarray(grupos); u, gi = np.unique(g, return_inverse=True); n = len(u) rng = np.random.default_rng(seed); vals = [] for _ in range(B): cnt = rng.multinomial(n, np.full(n, 1 / n)).astype(float) v = est.auc(cnt[gi]) if v == v: vals.append(v) vals = np.sort(vals) return float(np.quantile(vals, 0.025)), float(np.quantile(vals, 0.975)), n