question_generation
1.0.0
La generación de preguntas es la tarea de generar automáticamente preguntas a partir de un párrafo de texto. La forma más directa de esto es la generación de preguntas con cuenta de respuesta. En la generación de preguntas conscientes de respuesta, el modelo se presenta con la respuesta y el pasaje y se le pide que genere una pregunta para esa respuesta considerando el contexto del pasaje. Si bien hay muchos documentos disponibles para la tarea QG, todavía no es tan convencional como QA. Una de las razones es que la mayoría de los documentos anteriores utilizan modelos complicados/tuberías de procesamiento y no tienen modelos previamente capacitados disponibles. Pocos documentos recientes, específicamente Unilm y ProPhetnet tienen pesos pre-capacitados SOTA disponibles para QG, pero el uso parece bastante complicado.
Este proyecto está dirigido como un estudio de código abierto en la generación de preguntas con transformadores previamente capacitados (específicamente modelos SEQ-2-seq) utilizando métodos de extremo a extremo directo sin tuberías muy complicadas. El objetivo es proporcionar scripts simplificados de procesamiento de datos y capacitación y tuberías fáciles de usar para la inferencia.
Los experimentos iniciales se realizan utilizando el conjunto de datos Squadv1 y el modelo T5 con diferentes formatos de procesamiento de entrada como se describe a continuación.
Para los modelos de respuesta, el texto de entrada se puede procesar de dos maneras.
1. Formato de prepend:
Aquí la respuesta simplemente se agrega antes del contexto y se separa por el token SEP. Por ejemplo
42 [SEP] 42 is the answer to life, the universe and everything.
Para el modelo T5, la entrada se procesa así
answer: 42 context: 42 is the answer to life, the universe and everything.
2. Formato de resaltado
Aquí el lapso de respuesta se resalta dentro del texto con tokens especiales de resaltado.
<hl> 42 <hl> is the answer to life, the universe and everything.
Esta idea se propone en el documento "Un modelo recurrente basado en Bert para la generación de preguntas". Ver Sección 4.3
Como los modelos conscientes de la respuesta necesitan respuestas para generar preguntas, necesitamos algo que pueda extraer respuesta como tramos del texto. Esto se puede hacer utilizando varios métodos como NER, alcance de frase sustantivo, etc. Pero aquí se capacita un modelo para extraer respuesta como tramos, para ver cómo funcionará. Con T5, el alcance de la respuesta se realiza utilizando el texto a formato.
Como el formato destacado necesitará saber que la posición de la respuesta extraída abarca la entrada para la extracción de respuestas se procesa de la siguiente manera
<hl> tokens.<sep> .Por ejemplo para este texto
Python is a programming language. Created by Guido van Rossum and first released in 1991.
Se crearán los siguientes ejemplos
Texto de entrada: <hl> Python is a programming language. <hl> Created by Guido van Rossum and first released in 1991.
Texto del objetivo: Python <sep>
y
Texto de entrada: Python is a programming language. <hl> Created by Guido van Rossum and first released in 1991 <hl>.
Texto del objetivo: Guido van Rossum <sep> 1991 <sep>
En el momento de la inferencia, el texto se divide en oraciones y cada oración se resalta.
Para la generación de preguntas conscientes de la respuesta, generalmente necesitamos 3 modelos, primero que extraerá la respuesta como los tramos, el segundo modelo generará preguntas sobre esa respuesta y el tercero será un modelo de control de calidad que tomará la pregunta y producirá una respuesta, entonces podemos comparar las dos respuestas para ver si la pregunta generada es correcta o no.
Tener 3 modelos para tareas individuales es una gran complejidad, por lo que el objetivo es crear un modelo de varias tareas que pueda hacer todas estas 3 tareas
El modelo T5 está ajustado de forma múltiple utilizando prefijos de tareas como se describe en el documento.
En la generación de preguntas de extremo a extremo, el modelo está aks para generar preguntas sin proporcionar las respuestas. Este artículo analiza estas ideas con más detalle. Aquí el modelo T5 está capacitado para generar múltiples preguntas simultáneamente simplemente proporcionando el contexto. Las preguntas se separan por el token <sep> . Así es como se procesan los ejemplos
Texto de entrada: Python is a programming language. Created by Guido van Rossum and first released in 1991.
Texto del objetivo: Who created Python ? <sep> When was python released ? <sep>
Todos los detalles de capacitación se pueden encontrar en este proyecto Wandb
Resultados en el conjunto de desarrollo Squad1.0 utilizando enfoques anteriores. Para la decodificación, la búsqueda de haz con Num_Beams 4 se usa con la longitud de decodificación máxima establecida en 32.
Para los modelos de QA-QG multitarea, las puntuaciones EM y F1 están privadas como QA-EM y QA-F1.
El paquete NLG-EVAL se utiliza para calcular las métricas.
| Nombre | Bleu-4 | METEORITO | Ruge-l | Qa-EM | QA-F1 | Formato QG |
|---|---|---|---|---|---|---|
| T5-base-QG-HL | 21.3226 | 27.0854 | 43.5962 | - | - | destacar |
| T5-BASE-QA-QG-HL | 21.0141 | 26.9113 | 43.2484 | 82.46 | 90.272 | destacar |
| t5-small-qa-qg-hl | 18.9872 | 25.2217 | 40.7893 | 76.121 | 84.904 | destacar |
| t5-small-qg-hl | 18.5921 | 24.9915 | 40.1886 | - | - | destacar |
| T5-Small-QG-Prepre | 18.2791 | 24.6722 | 39.958 | - | - | prever |
transformers==3.0.0
nltk
nlp==0.2.0 # only if you want to fine-tune.
Después de instalar nltk do
python -m nltk.downloader punktUse la tubería WHCH MIMICS? Transformers Pipeline para una fácil inferencia.
La tubería se divide en 3 tareas
question-generation : para modelos de generación de preguntas de tarea única.multitask-qa-qg : para QA de tareas múltiples, modelos QG.e2e-qg : para la generación de preguntas de extremo a extremo. from pipelines import pipeline
nlp = pipeline ( "question-generation" )
nlp ( "42 is the answer to life, the universe and everything." )
= > [{ 'answer' : '42' , 'question' : 'What is the answer to life, the universe and everything?' }]prepend formato
nlp = pipeline ( "question-generation" , model = "valhalla/t5-small-qg-prepend" , qg_format = "prepend" )
nlp ( "42 is the answer to life, the universe and everything." )
= > [{ 'answer' : '42 ' , 'question' : 'What is the answer to life, the universe, and everything?' }] nlp = pipeline ( "multitask-qa-qg" )
# to generate questions simply pass the text
nlp ( "42 is the answer to life, the universe and everything." )
= > [{ 'answer' : '42' , 'question' : 'What is the answer to life, the universe and everything?' }]
# for qa pass a dict with "question" and "context"
nlp ({
"question" : "What is 42 ?" ,
"context" : "42 is the answer to life, the universe and everything."
})
= > 'the answer to life, the universe and everything' nlp = pipeline ( "e2e-qg" )
nlp ( "Python is a programming language. Created by Guido van Rossum and first released in 1991." )
= > [
'What is a programming language?' ,
'Who created Python?' ,
'When was Python first released?'
] De manera predeterminada, ambas tuberías usarán los modelos T5-Small*, para usar los otros modelos, pase la ruta a través del parámetro model .
Por defecto, la tubería question-generation descargará el modelo Valhalla/T5-Small-QG-HL con formato QG highlight . Si desea utilizar el formato Prepend, proporcione la ruta al modelo Prepend y establezca qg_format en "prepend" . Para extraer la respuesta como los tramos, utiliza el modelo Valhalla/T5-Small-Qa-Qg-HL, puede proporcionar un modelo diferente a través del parámetro ans_model .
El modelo multitask-qa-qg es para modelos multitarea que pueden extraer respuestas como tramos, hacer QG y QA, por lo que no necesitará ans_model separado. Por defecto, el modelo Valhalla/T5-Small-Qa-Qg-HL se usa con formato highlight . Si desea utilizar el formato Prepend, proporcione la ruta al modelo Prepend y establezca qg_format en "prepend"
La tubería e2e-qg es para la generación de preguntas de extremo a extremo. Estos modelos pueden generar múltiples preguntas simultáneamente sin supervisión de respuesta. Por defecto, usa Valhalla/T5-Small-E2E-QG
Para admitir diferentes formatos de datos, el entrenador espera un conjunto de datos en caché preprocesado, por lo que puede procesar los datos de la manera que desee. El conjunto de datos almacenados en caché debe guardarse usando torch.save y debe devolver un dict con las teclas source_ids , target_ids , attention_mask de __getitem__ .
source_ids : texto de origen codificadotarget_ids : texto de destino codificadoattention_mask : máscara de atención para el source_ids El T2TDataCollator se encarga de preparar input_ids y labels correctas. También recorta los lotes dinámicamente para eliminar los tokens de acolchado excesivos, para acelerar el entrenamiento.
data/squad_multitask contiene el conjunto de datos de escuadrón modificado para la generación de preguntas conscientes de respuesta (usando formatos de prepend y resaltar), respuesta a preguntas (texto a texto), extracción de respuesta y generación de preguntas de extremo a extremo. ¿Este conjunto de datos se puede cargar usando el impresionante? Biblioteca nlp , esto hace que el procesamiento sea muy fácil.
Para procesar y almacenar en caché, el conjunto de datos use el script prepare_data.py . Cargará el tokenizador correcto dependiendo del argumento model_type . Agrega dos tokens nuevos <sep> y <hl> al tokenizer y lo guarda en la ruta {model_type}_qg_tokenizer . Debe pasar este tokenizador al guión de ajuste fino.
Los conjuntos de datos se guardarán en data/ directorio. Debe proporcionar nombres de archivo usando argumentos train_file_name y valid_file_name .
Procesar datos para la generación de preguntas de tarea única con stop stop_qg_format
python prepare_data.py
--task qg
--model_type t5
--dataset_path data/squad_multitask/
--qg_format highlight_qg_format
--max_source_length 512
--max_target_length 32
--train_file_name train_data_qg_hl_t5.pt
--valid_file_name valid_data_qg_hl_t5.pt Datos de proceso para QA-QG multitarea con resalta_qg_format
valid_for_qg_only se utiliza para decidir si el conjunto de validación solo debe contener datos para la tarea QG. Para mis experimentos de tareas múltiples, utilicé datos de validación con solo tarea QG para que la curva de pérdida de evaluación pueda compararse con otros modelos de tareas individuales
python prepare_data.py
--task multi
--valid_for_qg_only
--model_type t5
--dataset_path data/squad_multitask/
--qg_format highlight_qg_format
--max_source_length 512
--max_target_length 32
--train_file_name train_data_qa_qg_hl_t5.pt
--valid_file_name valid_data_qg_hl_t5.pt conjunto de datos de procesos para la generación de preguntas de extremo a extremo
python prepare_data.py
--task e2e_qg
--valid_for_qg_only
--model_type t5
--dataset_path data/squad_multitask/
--qg_format highlight_qg_format
--max_source_length 512
--max_target_length 32
--train_file_name train_data_e2e_qg_t5.pt
--valid_file_name valid_data_e2e_qg_t5.pt Use el script run_qg.py para comenzar a entrenar. Utiliza la clase Transformers Trainer para entrenar a los modelos.
python run_qg.py
--model_name_or_path t5-small
--model_type t5
--tokenizer_name_or_path t5_qg_tokenizer
--output_dir t5-small-qg-hl
--train_file_path data/train_data_qg_hl_t5.pt
--valid_file_path data/valid_data_qg_hl_t5.pt
--per_device_train_batch_size 32
--per_device_eval_batch_size 32
--gradient_accumulation_steps 8
--learning_rate 1e-4
--num_train_epochs 10
--seed 42
--do_train
--do_eval
--evaluate_during_training
--logging_steps 100o si quieres entrenarlo desde el guión o el cuaderno
from run_qg import run_qg
args_dict = {
"model_name_or_path" : "t5-small" ,
"model_type" : "t5" ,
"tokenizer_name_or_path" : "t5_qg_tokenizer" ,
"output_dir" : "t5-small-qg-hl" ,
"train_file_path" : "data/train_data_qg_hl_t5.pt" ,
"valid_file_path" : "data/valid_data_qg_hl_t5.pt" ,
"per_device_train_batch_size" : 32 ,
"per_device_eval_batch_size" : 32 ,
"gradient_accumulation_steps" : 8 ,
"learning_rate" : 1e-4 ,
"num_train_epochs" : 10 ,
"seed" : 42 ,
"do_train" : True ,
"do_eval" : True ,
"evaluate_during_training" : True ,
"logging_steps" : 100
}
# start training
run_qg ( args_dict ) Use el script eval.py para evaluar el modelo.
python eval.py
--model_name_or_path t5-base-qg-hl
--valid_file_path valid_data_qg_hl_t5.pt
--model_type t5
--num_beams 4
--max_decoding_length 32
--output_path hypothesis_t5-base-qg-hl.txtEsto guardará la salida en el archivo {output_path}.
Para calcular las métricas, instale el paquete NLG-EVAL y ejecute
nlg-eval --hypothesis=hypothesis_t5-base-qg-hl.txt --references=data/references.txt --no-skipthoughts --no-glove 
