File size: 5,003 Bytes

---
library_name: peft
license: mit
base_model: FacebookAI/xlm-roberta-large
tags:
- generated_from_trainer
datasets:
- conll2002
model-index:
- name: roberta-large-ner-qlorafinetune
  results: []
language:
- es
---

<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->

# roberta-large-ner-qlorafinetune

Este modelo afinado con [FacebookAI/xlm-roberta-large](https://huggingface.co/FacebookAI/xlm-roberta-large)  sobre conll2002 dataset. El importante
resultado importante tiene que ver con el bcth_size=32 y fue cuantificado con PEFT para correrlo en una GPU de 14 Gz.

## Model description

More information needed

## Intended uses & limitations

Para usar el modelo y tratar de que las etiquetas funcionen correctamente les comparto un script que usa el modelo
como pipeline:

``` from transformers import AutoConfig, AutoTokenizer, AutoModelForTokenClassification
from peft import PeftModel
import torch

# Paso 1: Configuración manual del modelo base
base_model_name = "xlm-roberta-large"  # Usar nombre directo para evitar conflictos
num_labels = 9  # Total de clases NER (BIO)

# Definir mapeo de etiquetas (ajustar según tu dataset)
id2label = {
    0: "O",
    1: "B-PER",
    2: "I-PER",
    3: "B-ORG",
    4: "I-ORG",
    5: "B-LOC",
    6: "I-LOC",
    7: "B-MISC",
    8: "I-MISC"
}

# Cargar configuración del modelo BASE y modificar
config = AutoConfig.from_pretrained(
    base_model_name,
    num_labels=num_labels,
    id2label=id2label,
    label2id={v: k for k, v in id2label.items()}
)

# Paso 2: Cargar modelo base CON CONFIGURACIÓN CORRECTA
base_model = AutoModelForTokenClassification.from_pretrained(
    base_model_name,
    config=config,
    ignore_mismatched_sizes=True
)

# Paso 3: Cargar adaptador PEFT
peft_model_id = "raulgdp/roberta-large-ner-qlorafinetune"
model = PeftModel.from_pretrained(base_model, peft_model_id)
model = model.merge_and_unload()

# Paso 4: Configurar tokenizador CORRECTAMENTE
tokenizer = AutoTokenizer.from_pretrained(
    base_model_name,  # Usar el modelo base directamente
    add_prefix_space=True,  # Necesario para RoBERTa
    use_fast=True
)

# Función mejorada de decodificación
def decode_predictions(text, predictions, word_ids):
    current_word = ""
    current_label = ""
    previous_word_id = None
    results = []

    for idx, word_id in enumerate(word_ids):
        if word_id is None:
            continue

        # Obtener token y etiqueta
        token = tokenizer.decode(inputs["input_ids"][0][idx]).replace(" ", "")
        label = model.config.id2label[predictions[idx]]

        # Manejar subpalabras
        if word_id != previous_word_id:
            if previous_word_id is not None:
                results.append((current_word.strip(), current_label))
            current_word = token
            current_label = label
        else:
            current_word += token.replace("##", "").replace("Ġ", "")

        previous_word_id = word_id

    if current_word:
        results.append((current_word.strip(), current_label))

    return results

# Texto de prueba
text = (
    "La Federación Nacional de Cafeteros de Colombia es una entidad del estado, "
    "creada en los años 70’s. El primer presidente el Dr Augusto Guerra contó con "
    "el aval de la Asociación Colombiana de Aviación. En varias ciudades "
    "colombianas; Cali, Medellín, Corozal funciona la entidad. Estas personas "
    "vienen del Instituto Colombiano del Café ubicado en la calle Cali"
)

# Tokenización profesional
inputs = tokenizer(
    text,
    return_tensors="pt",
    truncation=True,
    padding="max_length",
    max_length=128,
    return_offsets_mapping=False
)

# Obtener word_ids CORRECTAMENTE
word_ids = [i if i is not None else -1 for i in inputs.word_ids(0)]

# Inferencia
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
inputs = {k: v.to(device) for k, v in inputs.items()}

with torch.no_grad():
    outputs = model(**inputs)
predictions = torch.argmax(outputs.logits, dim=-1)[0].cpu().numpy()

# Decodificar resultados
entities = decode_predictions(text, predictions, word_ids)

# Mostrar solo entidades relevantes
for word, label in entities:
    if label != "O":
        print(f"{word:35} {label}") 

```

## Training and evaluation data

More information needed

## Training procedure

### Training hyperparameters

The following hyperparameters were used during training:
- learning_rate: 0.0004
- train_batch_size: 32
- eval_batch_size: 32
- seed: 42
- optimizer: Use paged_adamw_8bit with betas=(0.9,0.999) and epsilon=1e-08 and optimizer_args=No additional optimizer arguments
- lr_scheduler_type: linear
- training_steps: 1820
- mixed_precision_training: Native AMP

### Training results



### Framework versions

- PEFT 0.14.0
- Transformers 4.49.0
- Pytorch 2.6.0+cu118
- Datasets 3.2.0
- Tokenizers 0.21.0