TecNoticias, tu portal de información

Uso de la corrección de errores gramaticales: etiquetar, no reescribir (GECTor)

“Una carrera entre dos robots para corregir errores tipográficos en un correo electrónico en la playa”, creado por DALL.E 2Las canalizaciones de procesamiento de lenguaje natural (NLP) se basan en modelos de aprendizaje automático que consumen, analizan y/o transforman datos textuales para varios propósitos. Por ejemplo, Google Translate recibe el texto entrante en un idioma y devuelve un texto saliente en el idioma de destino (esta tarea se denomina Traducción automática). Algoritmos de análisis de sentimiento, reciben datos textuales y determinan si el texto es positivo, negativo o neutral. Modelos de resumen de texto, reciba entradas textuales y resúmalas en salidas textuales más pequeñas. Hay muchos factores que pueden afectar el rendimiento/calidad de salida de tales modelos y uno de ellos es la calidad del texto entrante. Específicamente, el ruido, en forma de texto erróneo, puede afectar negativamente la calidad del resultado de los modelos de traducción automática neuronal (Belinkov y Bisk, 2018). Por lo tanto, se han realizado esfuerzos centrados en mejorar la corrección gramatical de los datos textuales entrantes a través de las canalizaciones de NLP, antes de que dichos datos textuales lleguen a las tareas posteriores de traducción automática, análisis de sentimientos, resumen de texto, etc. Los modelos de corrección de errores gramaticales generalmente utilizan dos enfoques: Generación de texto de secuencia a secuencia (seq2seq), que se puede pensar como un motor de traducción que traduce de un idioma dado al mismo idioma, mientras corrige los errores gramaticales (por ejemplo, Yuan y Briscoe, 2014) Etiquetado de secuencia, donde el texto entrante es tokenizados, etiquetados y luego mapeados nuevamente a tokens corregidos (por ejemplo, Malmi, et al., 2019) Si bien se ha documentado que el enfoque de traducción automática neuronal seq2seq logra un rendimiento de vanguardia (por ejemplo, Vaswani et al., 2017), pero todavía adolece de ciertas deficiencias, como: (1) la inferencia y la generación de resultados toman mucho tiempo, (2) el entrenamiento requiere grandes cantidades de datos y (3) la arquitectura neuronal del modo Hace que la interpretación de los resultados sea un desafío, en comparación con las arquitecturas no neuronales (Omelianchuk, et al., 2020). Para superar estas deficiencias, el enfoque del que hablaremos y luego implementaremos en esta publicación es un etiquetador de secuencia que utiliza un codificador Transformer. El trabajo de Omelianchuk, et al., 2020 está previamente entrenado en datos sintéticos. Luego, los modelos pre-entrenados se ajustan en dos etapas. Una etapa incluye puramente corpus erróneos y luego la segunda etapa de ajuste fino incluye una combinación de datos erróneos y libres de errores. El trabajo resultante es hasta diez veces más rápido que un sistema Transformer seq2seq y está disponible públicamente en GitHub. Este enfoque mejora la preocupación por el tiempo de inferencia de los modelos seq2seq y puede lograr un mayor nivel de personalización con datos de entrenamiento más pequeños, ya que se basa en un modelo preentrenado pero aún deja la interpretabilidad y la explicabilidad como una oportunidad de mejora para el trabajo futuro. En la próxima sección, usaremos esta biblioteca para implementar un enfoque para corregir errores gramaticales en una oración dada. Luego, crearemos una interfaz de usuario visual para demostrar los resultados. Dividiré esta sección en tres pasos:Preparar los Requisitos: Este paso incluye clonar el repositorio, descargar el modelo previamente entrenado e instalar los requisitos necesarios para implementar el modelo de corrección de errores gramaticales. Utilizo la interfaz de línea de comandos (CLI) para estos pasos.Implementación del modelo: Implementar y probar el modelo de corrección de errores gramaticales. Implemento estos pasos en un cuaderno Jupyter.Interfaz de usuario: Crear una interfaz de usuario para mejorar la experiencia del usuario

2.1. Preparar los requisitos

El primer paso para preparar los requisitos es clonar el repositorio disponible públicamente en nuestro sistema local. En otras palabras, crearemos una copia de la biblioteca de GitHub en nuestra computadora, usando el siguiente comando: git clone https://github.com/grammarly/gector.gitHay tres modelos preentrenados disponibles. Para esta parte del ejercicio, nos basaremos en el que usa RoBERTa como codificador preentrenado, que tiene el puntaje general más alto entre los modelos existentes. Avancemos y descarguemos el modelo pre-entrenado, usando el siguiente comando: wget https://grammarly-nlp-data-public.s3.amazonaws.com/gector/roberta_1_gectorv2.th Ahora que tenemos el modelo descargado en nuestro local, Lo voy a mover al directorio “gector”, que está en el directorio que clonamos de GitHub, usando el siguiente comando:mv roberta_1_gectorv2.th ./gector/gectorA continuación, iremos al directorio apropiado para comenzar a ejecutar el modelo, usando el siguiente comando: cd ./gectorEste paquete se basa en otras bibliotecas para ejecutarse, por lo que vamos a instalar estos requisitos, con el siguiente comando: pip install -r requisitos.txt Ahora tenemos todos los archivos en los lugares correctos para comenzar creando el modelo de corrección de errores gramaticales en el siguiente paso.

2.2. Implementar el modelo

Ahora que tenemos todos los directorios y archivos necesarios para este modelo, vamos a empezar a usar la biblioteca. Seguiremos los siguientes pasos: Importar los paquetes necesarios. Crear una instancia del modelo. Probar el modelo en una oración con errores gramaticales para ver el resultado. Para ello, utilizaremos la siguiente frase: “she are looking at sky”. ¿Cuál esperas que sea la oración corregida? ¡Escriba eso y compárelo con el resultado! # Importar bibliotecas
from gector.gec_model import GecBERTModel# Crear una instancia del modelo
modelo = GecBERTModel(vocab_path = “./data/output_vocabulary”, model_paths = [“./gector/roberta_1_gectorv2.th”])# Agrega la oración con errores gramaticales
sent = ‘she are looking at sky’# Crea una lista vacía para almacenar el
lote = []
lote.append(enviado.split())
lote_final, actualizaciones_totales = modelo.handle_batch(lote)
actualizado_enviado = ” “.join(final_batch[0])
print(f”Oración original: {enviado}\n”)
print(f”Oración actualizada: {actualizado_enviado}”)Resultados:¡La oración actualizada es bastante sorprendente! Veamos los cambios: Mayúscula “ella” a “Ella” al comienzo de la oración Se cambió “son” a “es” para tener una concordancia sujeto-verbo para “ella” y “es” Se agregó “el” antes de “cielo” Se agregó un punto al final de la oración Todos estos son buenos cambios y son exactamente lo que habría hecho yo mismo, si tuviera que corregir la oración, pero… ¿y si tuviéramos una oración más complicada? Combinemos los tiempos y veamos cómo funciona el modelo.# Agregue la oración con errores gramaticales
sent = ‘ella mira el cielo ayer mientras se cepillaba el cabello’# Crea una lista vacía para almacenar el
lote = []
lote.append(enviado.split())
lote_final, actualizaciones_totales = modelo.handle_batch(lote)
actualizado_enviado = ” “.join(final_batch[0])
print(f”Oración original: {enviado}\n”)
print(f”Oración actualizada: {actualizado_enviado}”)Resultados:Esto también es muy interesante. Resumamos los cambios: Mayúscula “ella” a “Ella” al comienzo de la oración Se cambió “mira” a “mirada”, que ahora está de acuerdo con “ayer” Se agregó “el” antes de “cielo” Se agregó la letra que faltaba a ” mientras” Se cambió “cepillado” por “cepillado”, que es la forma esperada después de “mientras” Observe que el modelo decidió que el tiempo verbal pretendido es el pasado. Otro enfoque podría haber sido decidir que el tiempo verbal buscado está presente y cambiar “ayer” por “hoy”, pero según los datos entrenados, el modelo decidió ir con el tiempo pasado. Ahora veamos un ejemplo más y veamos si podemos empujar los límites del modelo y confundirlo con tiempos verbales:# Agregue la oración con errores gramaticales
sent = ‘estaba mirando el cielo más tarde hoy mientras se cepillaba el cabello’# Crea una lista vacía para almacenar el
lote = []
lote.append(enviado.split())
lote_final, actualizaciones_totales = modelo.handle_batch(lote)
actualizado_enviado = ” “.join(final_batch[0])
print(f”Oración original: {enviado}\n”)
print(f”Oración actualizada: {actualizado_enviado}”)Resultados:Finalmente hemos encontrado un caso límite donde el modelo no reconoce el tiempo verbal correcto. La oración actualizada trata sobre “más tarde hoy”, lo que implica el tiempo futuro, mientras que el modelo genera la oración en tiempo pasado. Entonces, ¿por qué esto es más desafiante para el modelo que antes? La respuesta es que “más tarde hoy” implica tiempo en dos palabras, lo que requiere un nivel más profundo de conciencia contextual del modelo. Tenga en cuenta que sin la palabra “más tarde”, habríamos tenido una oración completamente aceptable de la siguiente manera:En este contexto, “hoy” podría referirse a hoy más temprano (es decir, en el pasado), lo que haría que la corrección gramatical fuera completamente aceptable. Pero en el ejemplo original, “más tarde hoy” no es reconocido por el modelo como una indicación del tiempo futuro. Como nota general, es una buena práctica probar estos modelos en varios casos de uso para conocer dichas limitaciones.

2.3. Interfaz de usuario

Ahora que hemos visto algunos ejemplos, haremos dos actualizaciones para mejorar la experiencia del usuario a través de una interfaz de usuario: Cree una función que acepte una oración y devuelva la oración actualizada (es decir, gramaticalmente corregida) Agregue una interfaz visual para facilitar el uso# Definir una función para corregir errores gramaticales de una oración dada
def correct_grammar(enviado):
lote = []
lote.append(enviado.split())
lote_final, actualizaciones_totales = modelo.handle_batch(lote)
actualizado_enviado = ” “.join(final_batch[0])
return updated_sent Probemos la función en una de nuestras oraciones y asegurémonos de que funcione según lo previsto.
print(f”Oración actualizada: {correct_grammar(sent = sent)}”)Resultados:La función funciona como se esperaba. A continuación, agregaremos una interfaz de usuario visual para mejorar la experiencia del usuario. Para ello vamos a utilizar Gradio, que es una librería Python de código abierto para crear demos y aplicaciones web, como veremos a continuación.Insinuación: Si no tiene esto instalado, puede instalarlo con el siguiente comando: pip install gradio Con Gradio instalado, continuemos con la importación y creación de la interfaz de usuario de la siguiente manera: # Import Gradio
importar gradio como gr# Crear una instancia de la clase Interface
demo = gr.Interfaz(fn = gramática_correcta, entradas = gr.Textbox(líneas = 1, marcador de posición = ‘¡Agregue su oración aquí!’), salidas = ‘texto’)# Inicie la demostración
demo.launch()Resultados:Interfaz de usuario del modelo de corrección de errores gramaticales (usando Gradio) Ahora que tenemos la interfaz de demostración, ¡probemos nuestra oración nuevamente y veamos cómo funciona! Simplemente escribimos la oración en el cuadro del lado izquierdo y presionamos “Enviar”. Luego, los resultados se mostrarán en el cuadro en el lado derecho de la siguiente manera:Resultados del modelo de corrección de errores gramaticales (usando Gradio) La demostración funciona como se esperaba. ¡Pruébalo y prueba otras oraciones para ver cómo funciona!