Explicación de la generación de texto con LSTM

Este artículo fue publicado como parte del Blogatón de ciencia de datos.

Una guía completa sobre la generación de texto usando LSTM

Generación de Texto con LSTM — Fuente: papel de desarrollo

¡Hey gente!

En este artículo, vamos a hablar sobre la generación de texto usando LSTM con ejemplos completos. también veremos conceptos relacionados con LSTM como una revisión rápida.

En la próxima generación, predecimos el siguiente carácter de una palabra dada de una secuencia. Los datos de texto pueden verse como una secuencia de palabras o una secuencia de datos individuales. Para la predicción de secuencia, hemos utilizado modelos de aprendizaje profundo como RNN/LSTM/GRU.

Ya escribí un artículo muy detallado sobre la idea de RNN, luego discutí por qué RNN no es práctico y expliqué RNN y GRU con ejemplos. puedes referirte a esto liga.

Índice del contenido

Introducción a LSTM
¿Por qué falla RNN?
Comprender la arquitectura LSTM y varias puertas
La idea de la generación de texto
Implementación de Generación de Texto usando LSTM

Introducción

La generación de texto puede considerarse una característica muy importante de las herramientas basadas en IA. resulta muy útil en máquinas que se supone que se vuelven más interactivas con los humanos. Los dispositivos inteligentes como los altavoces inteligentes y los asistentes domésticos utilizan la generación de texto en algunas formas.

Casos de uso de generación de texto

Los motores de búsqueda
Chatbots
Resumen de texto
Respuesta a la pregunta

¿Por qué RNN no es práctico para la generación de texto?

RNN tiene un gran problema de gradientes que se desvanecen y explotan. por lo tanto, RNN no puede contener información secuencial más larga y, en la tarea de generación de texto, necesitamos particularmente un modelo que pueda memorizar una secuencia larga de datos. para este propósito, LSTM entró en escena.

LSTM (Memoria a Largo Corto Plazo)

Como sabemos, RNN no puede retener / memorizar datos secuenciales durante mucho tiempo y comienza a olvidar las entradas anteriores y llega una nueva entrada. Para solucionar este problema, LSTM está diseñado con varias puertas.

LSTM resuelve el problema del aprendizaje de la memoria a corto plazo mediante el uso de diferentes tipos de puertas.

Cuando entra una nueva entrada en RNN, modifica la información existente sin decidir si la entrada entrante es importante o no, mientras que en el caso de las puertas LSTM están disponibles para permitir que solo las entradas importantes modifiquen la información existente.

En las puertas LSTM, decida qué datos se ignorarán y cuáles se alimentarán para el entrenamiento. hay 3 puertas en LSTM:

Puerta de entrada
Puerta de salida
Olvidar puerta

Olvidar puerta

Esta puerta es responsable de seleccionar la información relevante y descartar la información irrelevante. después de seleccionar la información relevante, se pasa a través de la puerta de entrada.

Primero, la información del estado actual y el estado oculto anterior se pasa a través de la función de activación. aquí estará la función de activación sigmoide. La función de activación sigmoidea devuelve un valor entre 0 y 1. Un valor más cercano a 0 significa que la información actual debe ignorarse; de lo contrario, debe pasarse a través de la puerta de entrada.

Puerta de entrada

Esta puerta es responsable de agregar información al modelo mediante el uso de la función de activación sigmoide. Uso de la función de activación tanhcrea una matriz de información que se pasa a través de la puerta de entrada. la matriz de información contiene valores que van desde -1 a 1 y un sigmoid función filtrar y mantener qué información debe agregarse al modelo y qué información debe descartarse.

Puerta de salida

Output Gate es responsable de generar los siguientes estados ocultos junto con los estados de celda que se transfieren al siguiente paso de tiempo. Crea un estado oculto usando la función de activación. tanhy su valor oscila entre -1 y 1.

La idea de la generación de texto

La generación de texto no es más que una serie continua de predicciones de la siguiente palabra. Como ya sabemos que los datos de texto son una secuencia de palabras, usando estas secuencias podemos predecir la siguiente palabra.

Implementación de la generación de texto

Hay varios pasos enumerados para la generación de texto: -

Cargue las bibliotecas necesarias
Cargue los datos textuales
Realice una limpieza de texto si es necesario
Preparación de datos para entrenamiento.
Definir y entrenar el modelo LSTM
Predicción

Cargando bibliotecas necesarias

bibliotecas para el manejo de datos

import pandas as pd import numpy as np import string, os import advertencias advertencias.filterwarnings("ignorar") advertencias.simplefilter(acción='ignorar', categoría=FuturaAdvertencia)

cargando bibliotecas de aprendizaje profundo

# establecer semillas para la reproducibilidad
desde tensorflow importar set_random_seed desde numpy.random import seed set_random_seed(2) seed(1)
# módulo keras para construir LSTM 
de keras.preprocessing.sequence import pad_sequences de keras.layers import Embedding, LSTM, Dense, Dropout from keras.preprocessing.text import Tokenizer from keras.callbacks import EarlyStopping from keras.models import Sequential import keras.utils as ku

Cargando el conjunto de datos

Usaremos Comentarios de la hora de Nueva York conjunto de datos disponible en Kaggle. puede descargar el conjunto de datos o incluso puede crear un nuevo cuaderno Kaggle utilizando este conjunto de datos.

El conjunto de datos contiene varios artículos y comentarios. Nuestro objetivo es cargar todos los artículos como titulares y fusionarlos en una lista.

# Cargando todos los titulares como una lista curr_dir = '../input/' all_headlines = [] para nombre de archivo en os.listdir(curr_dir): si 'Artículos' en nombre de archivo: article_df = pd.read_csv(curr_dir + filename) all_headlines.extend(list(article_df.headline. valores)) descanso

all_headlines = [línea por línea en all_headlines if line!= "Desconocido"] print(all_headlines[:10])

Tenemos un total de 829 titulares y los usaremos para generar texto.

Preparación del conjunto de datos

Para la preparación del conjunto de datos, nuestra primera tarea será limpiar los datos de texto, lo que incluye la eliminación de puntuaciones, palabras en minúsculas, etc.

Limpieza de datos

Definimos una función que toma un solo título a la vez y devuelve el título limpio. Usando la iteración, pasamos cada título y creamos una lista de corpus de datos limpios.

def clean_text(txt): txt = "".join(t for tin txt if t not in string.punctuation).lower() txt = txt.encode("utf8").decode("ascii",'ignore') devolver texto

corpus = [clean_text(x) for x in all_headlines] print(corpus[:10])

Generación de secuencia de n-gramas para entrenamiento

En el modelo de lenguaje NLP, se requieren datos de entrada secuenciales, y la palabra/token de entrada debe ser numérico. Aquí estamos generando n-gramas para entrenar nuestro modelo para la predicción de la siguiente palabra.

tokenizer = Tokenizer() def get_sequence_of_tokens(corpus): ## tokenización tokenizer.fit_on_texts(corpus) total_words = len(tokenizer.word_index) + 1 ## convertir datos en una secuencia de token input_sequences = [] for line in corpus: token_list = tokenizer .texts_to_sequences([line])[0] for i in range(1, len(token_list)): n_gram_sequence = token_list[:i+1] input_sequences.append(n_gram_sequence) return input_sequences, total_words

inp_sequences, total_words = get_sequence_of_tokens(corpus) print(inp_sequences[:10])

Como ves eso inp_sequence es una secuencia de n-gramas necesaria para entrenar la predicción de la siguiente palabra. teníamos 829 titulares y usando el concepto de n-gram ahora tenemos 4544 filas.

Puedes relacionar el inp_sequences con esta imagen donde se puede ver claramente que en cada paso agregamos un token a la secuencia de Semillas para el entrenamiento.

Relleno de las secuencias

La inp_sequence acabamos de hacer que tenga una longitud de secuencia variable, lo que no es favorable para el entrenamiento, usando el relleno hacemos que cada secuencia tenga la misma longitud.

def generar_secuencias_acolchadas(secuencias_de_entrada): max_sequence_len = max([len(x) for x in input_sequences]) input_sequences = np.array(pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')) predictores, etiqueta = input_sequences[:, :-1],input_sequences[:,-1] label = ku.to_categorical(label, num_classes=total_words) devuelve predictores, label, max_sequence_len

predictores, etiqueta, max_sequence_len = generate_padded_sequences(inp_sequences)

predictors : estos son tokens que se utilizarán como entrada para predecir la siguiente palabra.
label: es la siguiente palabra que se va a predecir.
max_sequence_len: es la longitud de la secuencia.
pad_sequence: proporcionado por Keras se usa para rellenar una matriz de tokens a una longitud determinada.
En este caso,max_sequence_len es 17.

Creación de modelos

Hasta ahora hemos preparado los datos para el entrenamiento. ahora en este paso, crearemos un modelo LSTM que tomará predictors como entrada X y labels como entrada y.

Un recordatorio rápido sobre Capas en Keras: -

Capa de entrada: Este es el encargado de tomar la secuencia de entrada.
Capa LSTM: Calcula la salida utilizando unidades LSTM y devuelve estados ocultos y de celda. En nuestro caso, hemos agregado 100 unidades en la capa, que se pueden ajustar más adelante.
Capa de abandono: Esta capa se encarga de la regularización, es decir, evita el sobreajuste. esto se hace apagando las activaciones de algunas neuronas en la capa LSTM.
Capa de salida: Calcula la probabilidad de nuestra predicción.

def create_model(max_sequence_len, total_words): input_len = max_sequence_len - 1 modelo = Sequential() # ----------Agregar capa de incrustación de entrada model.add(Embedding(total_words, 10, input_length=input_len)) # - ---------Agregar capa oculta 1: capa LSTM model.add(LSTM(100)) model.add(Dropout(0.1)) # ----------Agregar modelo de capa de salida. agregar (Dense (total_words, activación = 'softmax')) model.compile (pérdida = 'categorical_crossentropy', Optimizer = 'adam') modelo de retorno

modelo = create_model(max_sequence_len, total_words) model.summary()

Entrenando al modelo

Después de construir la arquitectura del modelo, podemos entrenar el modelo usando nuestro predictors (X_tren) y label(y_train). 100 épocas deberían ser suficientes.

model.fit(predictores, etiqueta, épocas=100, detallado=5)

Generación de Texto (Predicción)

¡¡Increíble!!

Hemos entrenado nuestra arquitectura modelo y ahora está lista para generar texto. Necesitamos escribir una función para predecir la siguiente palabra en función de las palabras de entrada. También tenemos que tokenizar la secuencia y rellenarla con el mismo sequence_length proporcionamos para el entrenamiento, y luego agregaremos cada palabra predicha como una cadena.

def generar_texto(texto_semilla, siguientes_palabras, modelo, max_sequence_len): for _ in range(next_words): token_list = tokenizer.texts_to_sequences([seed_text])[0] token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding=' pre') predicho = model.predict_classes(token_list, verbose=0) output_word = "" for word,index in tokenizer.word_index.items(): if index == predicho: output_word = word break seed_text += " "+output_word return semilla_texto.título()

seed_text : son las palabras iniciales que se pasarán para la generación de texto.
predict_classes: devolverá la identificación del token para la palabra predicha.
predicted: Su identificador de token para la palabra predicha y esto se convertirá nuevamente en una palabra usando el diccionariotokenizer.word_index .items().
next_words Es el número de próximas palabras que queremos que se pronostiquen.

Predicción

Llamar a la función generate_textgenerará texto. La función generar_texto toma las palabras iniciales y la cantidad de palabras que se van a predecir, el nombre del modelo y la longitud de la secuencia.

print (generate_text("india y pakistán", 3, modelo, max_sequence_len)) print (generate_text("presidente trump", 3, model, max_sequence_len)) print (generate_text("estados unidos", 4, modelo, max_sequence_len)) print (generate_text("donald trump", 2, modelo, max_sequence_len)) print (generate_text("nueva york", 3, modelo, max_sequence_len)) print (generate_text("ciencia y tecnología", 5, modelo, max_sequence_len))

Conclusión

En este artículo, discutimos el modelo LSTM con su arquitectura y luego discutimos la idea de la generación de texto e implementamos la generación de texto usando el modelo LSTM.

Nuestro modelo entrenado funcionó perfectamente bien, pero puede mejorar el modelo al:-

Adición de más datos para recibir formación
Ajuste fino de la arquitectura del modelo, es decir (número de unidades, capas, etc).
Ajuste fino de parámetros como (épocas, unidades, tasa de aprendizaje, función de activación, etc.)

Gracias por leer !!

Siéntase libre de golpearme en mi LinkedIn si tiene alguna sugerencia o pregunta para mí.

Referencias

https://iq.opengenus.org/text-generation-lstm/
https://www.kaggle.com/shivamb/beginners-guide-to-text-generation-using-lstms

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

Inteligencia de datos generativa