guerrerotook/CIMA-4.8-ADR-NER

from datasets import load_dataset
ds = load_dataset("guerrerotook/cima-section48-ner", "react-active-freq-sys")
label_names = ds["train"].features["ner_tags"].feature.names
print(label_names)
# ['O', 'B-REACT', 'I-REACT', 'B-ACTIVE', 'I-ACTIVE', 'B-FREQ', 'I-FREQ', 'B-SYS', 'I-SYS']

example = ds["train"][5]
for tok, tag_id in zip(example["tokens"], example["ner_tags"]):
    print(f"{tok}\t{label_names[tag_id]}")

data/<config>/train.parquet   ← canónico, recomendado para HF Datasets
data/<config>/test.parquet
conll/<config>/train.conll    ← BIO plano, recomendado para seqeval/flair/spaCy
conll/<config>/test.conll
stats/<config>.json           ← estadísticas por split (label counts, etc.)

import numpy as np
from datasets import load_dataset
from transformers import (
    AutoTokenizer,
    AutoModelForTokenClassification,
    DataCollatorForTokenClassification,
    Trainer,
    TrainingArguments,
)
from seqeval.metrics import classification_report, f1_score

ds = load_dataset("guerrerotook/cima-section48-ner", "react-active-freq-sys")
label_names = ds["train"].features["ner_tags"].feature.names
num_labels = len(label_names)

model_name = "PlanTL-GOB-ES/roberta-base-biomedical-es"
tokenizer = AutoTokenizer.from_pretrained(model_name, add_prefix_space=True)

def tokenize_and_align(batch):
    enc = tokenizer(
        batch["tokens"],
        is_split_into_words=True,
        truncation=True,
        max_length=256,
    )
    labels = []
    for i, tag_seq in enumerate(batch["ner_tags"]):
        word_ids = enc.word_ids(batch_index=i)
        prev = None
        seq = []
        for w in word_ids:
            if w is None:
                seq.append(-100)
            elif w != prev:
                seq.append(tag_seq[w])
            else:
                seq.append(-100)
            prev = w
        labels.append(seq)
    enc["labels"] = labels
    return enc

tok_ds = ds.map(tokenize_and_align, batched=True, remove_columns=ds["train"].column_names)

model = AutoModelForTokenClassification.from_pretrained(
    model_name,
    num_labels=num_labels,
    id2label={i: n for i, n in enumerate(label_names)},
    label2id={n: i for i, n in enumerate(label_names)},
)

def compute_metrics(p):
    preds = np.argmax(p.predictions, axis=2)
    true_labels = [
        [label_names[l] for l in lab if l != -100]
        for lab in p.label_ids
    ]
    pred_labels = [
        [label_names[pr] for pr, l in zip(pre, lab) if l != -100]
        for pre, lab in zip(preds, p.label_ids)
    ]
    return {"f1": f1_score(true_labels, pred_labels)}

args = TrainingArguments(
    output_dir="./cima-ner-ft",
    eval_strategy="epoch",
    per_device_train_batch_size=16,
    num_train_epochs=10,
    learning_rate=2e-5,
)
trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tok_ds["train"],
    eval_dataset=tok_ds["test"],
    tokenizer=tokenizer,
    data_collator=DataCollatorForTokenClassification(tokenizer),
    compute_metrics=compute_metrics,
)
trainer.train()

from huggingface_hub import hf_hub_download

path = hf_hub_download(
    repo_id="guerrerotook/cima-section48-ner",
    filename="conll/react-active-freq-sys/train.conll",
    repo_type="dataset",
)

def parse_conll(path):
    sentences, current_tokens, current_tags = [], [], []
    with open(path, encoding="utf-8") as f:
        for line in f:
            line = line.rstrip("\n")
            if line.startswith("#") or not line:
                if current_tokens:
                    sentences.append((current_tokens, current_tags))
                    current_tokens, current_tags = [], []
                continue
            tok, tag = line.split("\t")
            current_tokens.append(tok)
            current_tags.append(tag)
    if current_tokens:
        sentences.append((current_tokens, current_tags))
    return sentences

sentences = parse_conll(path)
print(f"{len(sentences):,} sentencias")

from transformers import pipeline

ner = pipeline(
    "token-classification",
    model="guerrerotook/cima-roberta-ner-react-active-freq-sys",
    aggregation_strategy="simple",
)
text = (
    "El medicamento puede producir cefalea, mareo y, con menos frecuencia, "
    "trombocitopenia. La hipertensión es POCO FRECUENTE."
)
for ent in ner(text):
    print(f"{ent['entity_group']:<8s} {ent['score']:.3f}  {ent['word']}")

from datasets import load_dataset, ClassLabel, Sequence

ds = load_dataset("guerrerotook/cima-section48-ner", "react-active-freq-sys")
src = ds["train"].features["ner_tags"].feature.names  # ['O', 'B-REACT', ...]

KEEP = {"O", "B-REACT", "I-REACT"}
remap = {i: (src.index(t) if t in KEEP else 0) for i, t in enumerate(src)}

def to_react_only(example):
    example["ner_tags"] = [remap[t] if src[t] in KEEP else 0 for t in example["ner_tags"]]
    return example

ds_react = ds.map(to_react_only)

@thesis{guerreroros2026cima,
  author  = {Guerrero Guirado, Luis Miguel y Ros Munoz, Salvador},
  title   = {Detección de reacciones adversas de medicamentos en textos clínicos: Un estudio comparativo de los modelos basados en BERT y modelos LLMs},
  school  = {Universidad Nacional de Educación a Distancia (UNED)},
  year    = {2026},
  type    = {Trabajo Fin de Grado},
}