| """ |
| Validación externa de los datasets sintéticos de DignityAI contra datos reales anotados por personas. |
| |
| A. Reconocimiento externo: un modelo entrenado con comentarios reales anotados por humanos |
| (piuba-bigdata/beto-contextualized-hate-speech, UBA) clasifica muestras de nuestros textos. |
| B. Línea base del mismo modelo en su propio test real (para saber qué tan sensible es). |
| C. Evaluación externa de SinOdio v3 en HateCheck-ES (casos funcionales escritos por expertos). |
| D. Transferencia: ¿un clasificador entrenado con nuestros datos detecta odio real? |
| ¿y agregar nuestros datos a datos reales ayuda o estorba? |
| """ |
| import json, glob, sys, time |
| import numpy as np, pandas as pd, torch |
| from transformers import AutoTokenizer, AutoModelForSequenceClassification |
| from sklearn.feature_extraction.text import TfidfVectorizer |
| from sklearn.linear_model import LogisticRegression |
| from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score |
|
|
| RNG = 42 |
| DEV = "mps" if torch.backends.mps.is_available() else "cpu" |
| OUT = {} |
| def log(*a): print(time.strftime("%H:%M:%S"), *a, flush=True) |
|
|
| |
| def own(): |
| r = pd.read_parquet("racismo/v1.1/completo.parquet") |
| c = pd.read_parquet("clasismo/v1.1/completo.parquet") |
| m = pd.concat([pd.read_parquet(f) for f in glob.glob("data/machismodetect__*.parquet")]) |
| m = pd.concat([ |
| m[["texto_machista", "nivel", "pais"]].rename(columns={"texto_machista": "texto", "nivel": "categoria"}).assign(etiqueta=1), |
| m[["texto_inclusivo", "nivel", "pais"]].rename(columns={"texto_inclusivo": "texto", "nivel": "categoria"}).assign(etiqueta=0), |
| ]).drop_duplicates("texto") |
| s = pd.concat([pd.read_parquet(f) for f in glob.glob("data/sinodio_latam__*.parquet")]) |
| s = s.rename(columns={"text": "texto", "label": "etiqueta", "scenario": "categoria", "country": "pais"}).drop_duplicates("texto") |
| return {"racismo": r, "clasismo": c, "machismo": m, "sinodio": s} |
|
|
| def sample(df, n_pos=1500, n_neg=1000): |
| p = df[df.etiqueta == 1]; n = df[df.etiqueta == 0] |
| return pd.concat([p.sample(min(n_pos, len(p)), random_state=RNG), n.sample(min(n_neg, len(n)), random_state=RNG)]) |
|
|
| |
| def load(rid): |
| tok = AutoTokenizer.from_pretrained(rid) |
| mod = AutoModelForSequenceClassification.from_pretrained(rid).to(DEV).eval() |
| return tok, mod |
|
|
| @torch.no_grad() |
| def logits(tok, mod, texts, ctx=None, bs=64): |
| out = [] |
| for i in range(0, len(texts), bs): |
| a = list(texts[i:i + bs]) |
| b = list(ctx[i:i + bs]) if ctx is not None else None |
| enc = tok(a, b, truncation=True, max_length=128, padding=True, return_tensors="pt").to(DEV) |
| out.append(mod(**enc).logits.float().cpu()) |
| return torch.cat(out) |
|
|
| UBA_GROUPS = ["WOMEN", "LGBTI", "RACISM", "CLASS", "POLITICS", "DISABLED", "APPEARANCE", "CRIMINAL"] |
| TARGET = {"racismo": "RACISM", "clasismo": "CLASS", "machismo": "WOMEN", "sinodio": None} |
|
|
| def main(): |
| data = own() |
| tok, mod = load("piuba-bigdata/beto-contextualized-hate-speech") |
| id2l = [mod.config.id2label[i] for i in range(len(mod.config.id2label))] |
| log("UBA labels", id2l) |
| gi = [id2l.index(g) for g in UBA_GROUPS] |
|
|
| |
| real = pd.read_parquet("data/piuba_real__test.parquet") |
| rs = pd.concat([real[real[g] == 1].sample(min(400, int((real[g] == 1).sum())), random_state=RNG) for g in ["RACISM", "CLASS", "WOMEN"]] |
| + [real[real.HATEFUL == 0].sample(1000, random_state=RNG)]).drop_duplicates("id") |
| for use_ctx in [True, False]: |
| lg = logits(tok, mod, rs.text.tolist(), rs.context_tweet.fillna("").tolist() if use_ctx else None) |
| pr = (torch.sigmoid(lg) > 0.5).numpy() |
| res = {g: round(float(pr[(rs[g] == 1).values, id2l.index(g)].mean()), 3) for g in ["RACISM", "CLASS", "WOMEN"]} |
| res["falsas_alarmas_no_odio"] = round(float(pr[(rs.HATEFUL == 0).values][:, gi].any(1).mean()), 3) |
| OUT[f"uba_en_real_{'con' if use_ctx else 'sin'}_contexto"] = res |
| log("UBA real", use_ctx, res) |
|
|
| |
| sin_tok, sin_mod = load("antonn-dromundo/SinOdio-BETO-HateSpeech-Detector-v3") |
| sid2l = {int(k): v for k, v in sin_mod.config.id2label.items()} |
| log("SinOdio labels", sid2l) |
| hate_idx = 1 |
| for name, df in data.items(): |
| s = sample(df) |
| pr = (torch.sigmoid(logits(tok, mod, s.texto.tolist())) > 0.5).numpy() |
| sp = torch.softmax(logits(sin_tok, sin_mod, s.texto.tolist()), -1)[:, hate_idx].numpy() > 0.5 |
| pos, neg = (s.etiqueta == 1).values, (s.etiqueta == 0).values |
| r = { |
| "n_discriminatorios": int(pos.sum()), "n_contraste": int(neg.sum()), |
| "uba_detecta_odio_en_discriminatorios": round(float(pr[pos][:, gi].any(1).mean()), 3), |
| "uba_falsas_alarmas_en_contraste": round(float(pr[neg][:, gi].any(1).mean()), 3), |
| "sinodio_detecta_odio_en_discriminatorios": round(float(sp[pos].mean()), 3), |
| "sinodio_falsas_alarmas_en_contraste": round(float(sp[neg].mean()), 3), |
| } |
| if TARGET[name]: |
| r[f"uba_etiqueta_{TARGET[name]}_en_discriminatorios"] = round(float(pr[pos, id2l.index(TARGET[name])].mean()), 3) |
| s = s.assign(uba_odio=pr[:, gi].any(1), sinodio_odio=sp) |
| r["uba_por_categoria"] = s[pos].groupby("categoria").uba_odio.mean().round(3).to_dict() |
| r["uba_etiquetas_mas_asignadas"] = dict(pd.Series([id2l[j] for row in pr[pos] for j in np.where(row)[0]]).value_counts().head(5)) |
| OUT[f"externo_{name}"] = r |
| log(name, json.dumps(r, ensure_ascii=False, default=int)) |
|
|
| |
| hc = pd.read_parquet("data/hatecheck_es__test.parquet") |
| y = (hc.label_gold == "hateful").astype(int).values |
| sp = (torch.softmax(logits(sin_tok, sin_mod, hc.test_case.tolist()), -1)[:, hate_idx].numpy() > 0.5).astype(int) |
| up = (torch.sigmoid(logits(tok, mod, hc.test_case.tolist())) > 0.5).numpy()[:, gi].any(1).astype(int) |
| hcr = {} |
| for nm, p in [("sinodio_v3", sp), ("uba_beto", up)]: |
| f = hc.assign(ok=(p == y)) |
| hcr[nm] = {"exactitud": round(accuracy_score(y, p), 3), "f1_macro": round(f1_score(y, p, average="macro"), 3), |
| "recall_odio": round(recall_score(y, p), 3), "precision_odio": round(precision_score(y, p), 3), |
| "peores_funcionalidades": f.groupby("functionality").ok.mean().sort_values().head(6).round(3).to_dict()} |
| OUT["hatecheck_es"] = hcr |
| log("hatecheck", json.dumps(hcr, ensure_ascii=False)) |
|
|
| |
| tr_real = pd.read_parquet("data/piuba_real__train.parquet"); te_real = real |
| tr_neg = tr_real[tr_real.HATEFUL == 0].sample(8000, random_state=RNG) |
| trans = {} |
| for name in ["racismo", "clasismo", "machismo"]: |
| g = TARGET[name] |
| te = pd.concat([te_real[te_real[g] == 1], te_real[te_real.HATEFUL == 0].sample(3000, random_state=RNG)]) |
| yte = (te[g] == 1).astype(int).values |
| syn = data[name][["texto", "etiqueta"]] |
| rp = tr_real[tr_real[g] == 1] |
| sets = { |
| "solo_sintetico": (syn.texto, syn.etiqueta), |
| "solo_real": (pd.concat([rp.text, tr_neg.text]), np.r_[np.ones(len(rp)), np.zeros(len(tr_neg))]), |
| } |
| sets["real_mas_sintetico"] = (pd.concat([sets["solo_real"][0], syn.texto]), np.r_[sets["solo_real"][1], syn.etiqueta]) |
| rr = {"n_test_positivos": int(yte.sum()), "n_test_negativos": int((1 - yte).sum())} |
| for k, (X, Y) in sets.items(): |
| v = TfidfVectorizer(ngram_range=(1, 2), min_df=2, sublinear_tf=True, max_features=200000) |
| m = LogisticRegression(max_iter=3000, class_weight="balanced").fit(v.fit_transform(X), Y) |
| p = m.predict(v.transform(te.text)) |
| rr[k] = {"f1": round(f1_score(yte, p), 3), "recall": round(recall_score(yte, p), 3), "precision": round(precision_score(yte, p, zero_division=0), 3)} |
| trans[name] = rr |
| log("transfer", name, rr) |
| OUT["transferencia_a_real_uba"] = trans |
| json.dump(OUT, open("resultados_validacion.json", "w"), ensure_ascii=False, indent=2, default=int) |
| log("LISTO") |
|
|
| if __name__ == "__main__": |
| main() |
|
|
