pedramyazdipoor/persian_xlm_roberta_large

pedramyazdipoor

Pregunta y respuesta

XLM-RoBERTA es un modelo de lenguaje multilingüe preentrenado en 2.5TB de datos filtrados de CommonCrawl que contiene 100 idiomas. Fue introducido en el documento 'Unsupervised Cross-lingual Representation Learning at Scale' por Conneau et al. Este modelo multilingüe de XLM-RoBERTa grande para QA en varios idiomas está afinado en varios conjuntos de datos de QA, pero PQuAD, que es el mayor conjunto de datos persa de QA hasta ahora. Este segundo modelo es nuestro modelo base para ser afinado.

Como usar

from transformers import AutoTokenizer, AutoModelForQuestionAnswering
path = 'pedramyazdipoor/persian_xlm_roberta_large'
tokenizer = AutoTokenizer.from_pretrained(path)
model = AutoModelForQuestionAnswering.from_pretrained(path)

text = 'سلام من پدرامم 26 سالمه'
question = 'چند سالمه؟'
encoding = tokenizer(question, text, add_special_tokens=True,
                     return_token_type_ids=True,
                     return_tensors='pt',
                     padding=True,
                     return_offsets_mapping=True,
                     truncation='only_first',
                     max_length=32)
out = model(encoding['input_ids'].to(device), encoding['attention_mask'].to(device), encoding['token_type_ids'].to(device))

answer_start_index, answer_end_index = generate_indexes(out['start_logits'][0][1:], out['end_logits'][0][1:], 5, 0)
print(tokenizer.tokenize(text + question))
print(tokenizer.tokenize(text + question)[answer_start_index : (answer_end_index + 1)])

def generate_indexes(start_logits, end_logits, N, min_index):
    output_start = start_logits
    output_end = end_logits

    start_indexes = np.arange(len(start_logits))
    start_probs = output_start
    list_start = dict(zip(start_indexes, start_probs.tolist()))
    end_indexes = np.arange(len(end_logits))
    end_probs = output_end
    list_end = dict(zip(end_indexes, end_probs.tolist()))

    sorted_start_list = sorted(list_start.items(), key=lambda x: x[1], reverse=True) #Descending sort by probability
    sorted_end_list = sorted(list_end.items(), key=lambda x: x[1], reverse=True)

    final_start_idx, final_end_idx = [[] for l in range(2)]

    start_idx, end_idx, prob = 0, 0, (start_probs.tolist()[0] + end_probs.tolist()[0])
    for a in range(0, N):
        for b in range(0, N):
            if (sorted_start_list[a][1] + sorted_end_list[b][1]) > prob:
                if (sorted_start_list[a][0] 0]) and (sorted_start_list[a][0] > min_index):
                    prob = sorted_start_list[a][1] + sorted_end_list[b][1]
                    start_idx = sorted_start_list[a][0]
                    end_idx = sorted_end_list[b][0]
                    final_start_idx.append(start_idx)
                    final_end_idx.append(end_idx)

    return final_start_idx[0], final_end_idx[0]

# Dispositivos
import torch
import numpy as np

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model.eval().to(device)

Funcionalidades

Fine-tuning en el conjunto de entrenamiento de PQuAD
Tiempos de entrenamiento largos
Base de modelo de lenguaje: 'deepset/xlm-roberta-large-squad2'
Evaluación en el conjunto de prueba persa de PQuAD
Mejora sobre ParsBert en PQuAD

Casos de uso

Responder preguntas en persa
Mejora en modelos anteriores como ParsBert