Este es el art铆culo 16 de mi serie de art铆culos sobre Python para PNL. En mi art铆culo anterior expliqu茅 c贸mo se puede utilizar la t茅cnica N-Grams para desarrollar un relleno de texto autom谩tico simple en Python. El modelo N-Gram es b谩sicamente una forma de convertir datos de texto en forma num茅rica para que puedan ser utilizados por algoritmos estad铆sticos.
Antes de N-Grams, expliqu茅 la bolsa de palabras y los enfoques TF-IDF, que tambi茅n se pueden usar para generar vectores de caracter铆sticas num茅ricas a partir de datos de texto. Hasta ahora hemos estado utilizando aplicaciones de Machine Learning para realizar diferentes tareas de PNL como clasificaci贸n de texto, modelado de temas, an谩lisis sentimental, resumen de texto, etc. En este art铆culo comenzaremos nuestra discusi贸n sobre t茅cnicas de aprendizaje profundo para PNL.
Los enfoques de aprendizaje profundo consisten en diferentes tipos de redes neuronales densamente conectadas. Estos enfoques han demostrado ser eficientes para resolver varias tareas complejas, como autom贸viles aut贸nomos, generaci贸n de im谩genes, segmentaci贸n de im谩genes, etc. Los enfoques de aprendizaje profundo tambi茅n han demostrado ser bastante eficientes para tareas de PNL.
En este art铆culo, estudiaremos las incrustaciones de palabras para tareas de PNL que involucran aprendizaje profundo. Veremos c贸mo se pueden usar las incrustaciones de palabras para realizar una tarea de clasificaci贸n simple utilizando una red neuronal profunda en la biblioteca Keras de Python .
Problemas con los enfoques de vector de caracter铆sticas codificadas en caliente
Contenido
Un posible inconveniente con los enfoques de vector de caracter铆sticas codificadas en un solo uso, como N-Grams, bolsa de palabras y el enfoque TF-IDF, es que el vector de caracter铆sticas de cada documento puede ser enorme. Por ejemplo, si tiene medio mill贸n de palabras 煤nicas en su corpus y desea representar una oraci贸n que contenga 10 palabras, su vector de caracter铆sticas ser谩 un vector codificado en caliente de medio mill贸n de dimensiones donde solo 10 铆ndices tendr谩n 1. Esto es un desperdicio de espacio y aumenta la complejidad del algoritmo de manera exponencial, lo que resulta en la maldici贸n de la dimensionalidad .
Incrustaciones de palabras
En las incrustaciones de palabras, cada palabra se representa como un vector denso de n dimensiones. Las palabras que son similares tendr谩n un vector similar. Las t茅cnicas de inserci贸n de palabras como GloVe y Word2Vec han demostrado ser extremadamente eficientes para convertir palabras en los correspondientes vectores densos. El tama帽o del vector es peque帽o y ninguno de los 铆ndices del vector est谩 vac铆o.
Implementaci贸n de incrustaciones de palabras con modelos secuenciales de Keras
La biblioteca Keras es una de las bibliotecas de aprendizaje profundo m谩s famosas y de uso com煤n para Python que se basa en TensorFlow .
Keras admite dos tipos de API: secuenciales y funcionales. En esta secci贸n veremos c贸mo se utilizan las incrustaciones de palabras con la API secuencial de Keras. En la siguiente secci贸n, explicar茅 c贸mo implementar el mismo modelo a trav茅s de la API funcional de Keras.
Para implementar incrustaciones de palabras, la biblioteca de Keras contiene una capa llamada Embedding(). La capa de incrustaci贸n se implementa en forma de clase en Keras y normalmente se usa como una primera capa en el modelo secuencial para tareas de PNL.
La capa de incrustaci贸n se puede utilizar para realizar tres tareas en Keras:
- Se puede usar para aprender incrustaciones de palabras y guardar el modelo resultante
- Se puede utilizar para aprender las incrustaciones de palabras adem谩s de realizar las tareas de PNL como clasificaci贸n de texto, an谩lisis de sentimientos, etc.
- Se puede usar para cargar incrustaciones de palabras previamente entrenadas y usarlas en un nuevo modelo
En este art铆culo, veremos el segundo y tercer caso de uso de la capa Embedding. El primer caso de uso es un subconjunto del segundo caso de uso.
Veamos c贸mo se ve la capa de incrustaci贸n:
embedding_layer = Embedding(200, 32, input_length=50)
El primer par谩metro en la capa embeddig es el tama帽o del vocabulario o el n煤mero total de palabras 煤nicas en un corpus. El segundo par谩metro es el n煤mero de dimensiones para cada vector de palabra. Por ejemplo, si desea que cada vector de palabra tenga 32 dimensiones, deber谩 especificar 32 como segundo par谩metro. Y finalmente, el tercer par谩metro es la longitud de la oraci贸n de entrada.
La salida de la incrustaci贸n de palabras es un vector 2D donde las palabras se representan en filas, mientras que sus dimensiones correspondientes se presentan en columnas. Finalmente, si desea conectar directamente su capa de incrustaci贸n de palabras con una capa densamente conectada, primero debe aplanar sus incrustaciones de palabras 2D en 1D. Estos conceptos ser谩n m谩s comprensibles una vez que veamos la incorporaci贸n de palabras en acci贸n.
Incrustaciones de palabras personalizadas
Como dije anteriormente, Keras se puede usar para aprender incrustaciones de palabras personalizadas o se puede usar para cargar incrustaciones de palabras previamente entrenadas. En esta secci贸n, veremos c贸mo se puede usar la capa de incrustaci贸n de Keras para aprender incrustaciones de palabras personalizadas.
Realizaremos tareas de clasificaci贸n de texto simples que utilizar谩n incrustaciones de palabras. Ejecute el siguiente script para descargar las bibliotecas necesarias:
from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.embeddings import Embedding
A continuaci贸n, necesitamos definir nuestro conjunto de datos. Usaremos un conjunto de datos personalizado muy simple que contendr谩 rese帽as sobre pel铆culas. El siguiente script crea nuestro conjunto de datos:
corpus = [
# Positive Reviews
'This is an excellent movie',
'The move was fantastic I like it',
'You should watch it is brilliant',
'Exceptionally good',
'Wonderfully directed and executed I like it',
'Its a fantastic series',
'Never watched such a brillent movie',
'It is a Wonderful movie',
# Negtive Reviews
"horrible acting",
'waste of money',
'pathetic picture',
'It was very boring',
'I did not like the movie',
'The movie was horrible',
'I will not recommend',
'The acting is pathetic'
]
Nuestro corpus tiene 8 cr铆ticas positivas y 8 cr铆ticas negativas. El siguiente paso es crear un conjunto de etiquetas para nuestros datos.
sentiments = array([1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0])
Puede ver que los primeros 8 elementos de la matriz de sentimientos contienen 1, que corresponde a un sentimiento positivo. Los 煤ltimos 8 elementos son cero y corresponden al sentimiento negativo.
Anteriormente dijimos que el primer par谩metro de la Embedding()capa es el vocabulario, o n煤mero de palabras 煤nicas en el corpus. Primero busquemos el n煤mero total de palabras en nuestro corpus:
from nltk.tokenize import word_tokenize
all_words = []
for sent in corpus:
tokenize_word = word_tokenize(sent)
for word in tokenize_word:
all_words.append(word)
En el script anterior, simplemente iteramos a trav茅s de cada oraci贸n en nuestro corpus y luego convertimos la oraci贸n en palabras. Luego, iteramos a trav茅s de la lista de todas las palabras y agregamos las palabras a la all_wordslista. Una vez que ejecute el script anterior, deber铆a ver todas las palabras en el all_wordsdiccionario. Sin embargo, no queremos las palabras duplicadas.
Podemos recuperar todas las palabras 煤nicas de una lista pasando la lista a la setfunci贸n, como se muestra a continuaci贸n.
unique_words = set(all_words)
print(len(unique_words))
En el resultado ver谩 “45”, que es el n煤mero de palabras 煤nicas en nuestro corpus. Agregaremos un b煤fer de 5 a nuestro tama帽o de vocabulario y estableceremos el valor de vocab_length50.
La capa de incrustaci贸n espera que las palabras est茅n en forma num茅rica. Por lo tanto, necesitamos convertir las oraciones de nuestro corpus en n煤meros. Una forma de convertir texto en n煤meros es utilizando la one_hotfunci贸n de la keras.preprocessing.textbiblioteca. La funci贸n toma la oraci贸n y la longitud total del vocabulario y devuelve la oraci贸n en forma num茅rica.
embedded_sentences = [one_hot(sent, vocab_length) for sent in corpus]
print(embedded_sentences )
En el script anterior, convertimos todas las oraciones de nuestro corpus a su forma num茅rica y las mostramos en la consola. La salida se ve as铆:
[[31, 12, 31, 14, 9], [20, 3, 20, 16, 18, 45, 14], [16, 26, 29, 14, 12, 1], [16, 23], [32, 41, 13, 20, 18, 45, 14], [15, 28, 16, 43], [7, 9, 31, 28, 31, 9], [14, 12, 28, 46, 9], [4, 22], [5, 4, 9], [23, 46], [14, 20, 32, 14], [18, 1, 26, 45, 20, 9], [20, 9, 20, 4], [18, 8, 26, 34], [20, 22, 12, 23]]
Puede ver que nuestra primera oraci贸n conten铆a cinco palabras, por lo tanto, tenemos cinco n煤meros enteros en el primer elemento de la lista. Adem谩s, observe que la 煤ltima palabra de la primera oraci贸n fue “pel铆cula” en el primer elemento de la lista, y tenemos el d铆gito 9 en el quinto lugar de la matriz 2D resultante, lo que significa que “pel铆cula” se ha codificado como 9 y as铆 sucesivamente. .
La capa de incrustaci贸n espera que las oraciones tengan el mismo tama帽o. Sin embargo, nuestras oraciones codificadas son de diferentes tama帽os. Una forma de hacer que todas las oraciones tengan un tama帽o uniforme es aumentar la longitud de todas las oraciones y hacerla igual a la longitud de la oraci贸n m谩s grande. Primero busquemos la oraci贸n m谩s grande en nuestro corpus y luego aumentaremos la longitud de todas las oraciones a la longitud de la oraci贸n m谩s grande. Para hacerlo, ejecute el siguiente script:
word_count = lambda sentence: len(word_tokenize(sentence))
longest_sentence = max(corpus, key=word_count)
length_long_sentence = len(word_tokenize(longest_sentence))
En la oraci贸n anterior, usamos una expresi贸n lambda para encontrar la longitud de todas las oraciones. Luego usamos la maxfunci贸n para devolver la oraci贸n m谩s larga. Finalmente, la oraci贸n m谩s larga se convierte en palabras y el n煤mero de palabras se cuenta usando la lenfunci贸n.
A continuaci贸n, para hacer que todas las oraciones tengan el mismo tama帽o, agregaremos ceros a los 铆ndices vac铆os que se crear谩n como resultado de aumentar la longitud de la oraci贸n. Para agregar los ceros al final de las oraciones, podemos usar el pad_sequencesm茅todo. El primer par谩metro es la lista de oraciones codificadas de tama帽os desiguales, el segundo par谩metro es el tama帽o de la oraci贸n m谩s larga o el 铆ndice de relleno, mientras que el 煤ltimo par谩metro es paddingdonde especificas postagregar relleno al final de las oraciones.
Ejecute el siguiente script:
padded_sentences = pad_sequences(embedded_sentences, length_long_sentence, padding='post')
print(padded_sentences)
En la salida, deber铆a ver oraciones con relleno.
[[31 12 31 14 9 0 0]
[20 3 20 16 18 45 14]
[16 26 29 14 12 1 0]
[16 23 0 0 0 0 0]
[32 41 13 20 18 45 14]
[15 28 16 43 0 0 0]
[ 7 9 31 28 31 9 0]
[14 12 28 46 9 0 0]
[ 4 22 0 0 0 0 0]
[ 5 4 9 0 0 0 0]
[23 46 0 0 0 0 0]
[14 20 32 14 0 0 0]
[18 1 26 45 20 9 0]
[20 9 20 4 0 0 0]
[18 8 26 34 0 0 0]
[20 22 12 23 0 0 0]]
Puede ver ceros al final de las oraciones rellenas.
Ahora tenemos todo lo que necesitamos para crear un modelo de clasificaci贸n de sentimientos utilizando incrustaciones de palabras.
Crearemos un modelo de clasificaci贸n de texto muy simple con una capa de incrustaci贸n y sin capas ocultas. Mira el siguiente gui贸n:
model = Sequential()
model.add(Embedding(vocab_length, 20, input_length=length_long_sentence))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
En el script de arriba, creamos un Sequentialmodelo y agregamos la Embeddingcapa como la primera capa al modelo. La longitud del vocabulario la especifica el vocab_lengthpar谩metro. La dimensi贸n de cada vector de palabra ser谩 20 y input_lengthser谩 la longitud de la oraci贸n m谩s larga, que es 7. A continuaci贸n, la Embeddingcapa se aplana para que pueda usarse directamente con la capa densamente conectada. Dado que es un problema de clasificaci贸n binaria, usamos la sigmoidfunci贸n como funci贸n de p茅rdida en la capa densa.
A continuaci贸n, compilaremos el modelo e imprimiremos el resumen de nuestro modelo, como se muestra a continuaci贸n:
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['acc'])
print(model.summary())
El resumen del modelo es el siguiente:
Layer (type) Output Shape Param #
=================================================================
embedding_1 (Embedding) (None, 7, 20) 1000
_________________________________________________________________
flatten_1 (Flatten) (None, 140) 0
_________________________________________________________________
dense_1 (Dense) (None, 1) 141
=================================================================
Total params: 1,141
Trainable params: 1,141
Non-trainable params: 0
Puede ver que la primera capa tiene 1000 par谩metros entrenables. Esto se debe a que nuestro tama帽o de vocabulario es 50 y cada palabra se presentar谩 como un vector de 20 dimensiones. Por lo tanto, el n煤mero total de par谩metros entrenables ser谩 1000. De manera similar, la salida de la capa de incrustaci贸n ser谩 una oraci贸n con 7 palabras donde cada palabra est谩 representada por un vector de 20 dimensiones. Sin embargo, cuando se aplana la salida 2D, obtenemos un vector de 140 dimensiones (7 x 20). El vector aplanado est谩 conectado directamente a la capa densa que contiene 1 neurano.
Ahora entrenemos el modelo en nuestros datos usando el fitm茅todo, como se muestra a continuaci贸n:
model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
El modelo se entrenar谩 durante 100 茅pocas.
Entrenaremos y probaremos el modelo usando el mismo corpus. Ejecute el siguiente script para evaluar el rendimiento del modelo en nuestro corpus:
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))
En el resultado, ver谩 que la precisi贸n del modelo es 1,00, es decir, 100 por ciento.
Nota : En las aplicaciones del mundo real, los conjuntos de prueba y de tren deben ser diferentes. Veremos un ejemplo de eso cuando realicemos la clasificaci贸n de texto en algunos datos del mundo real en un pr贸ximo art铆culo.
Carga de incrustaciones de palabras previamente entrenadas
En la secci贸n anterior, entrenamos las incrustaciones de palabras personalizadas. Sin embargo, tambi茅n podemos utilizar incrustaciones de palabras previamente entrenadas.
Existen varios tipos de incrustaciones de palabras previamente entrenadas, sin embargo, usaremos las incrustaciones de palabras GloVe de Stanford NLP, ya que es la m谩s famosa y de uso com煤n. Las incrustaciones de palabras se pueden descargar desde este enlace .
El archivo m谩s peque帽o se llama “Glove.6B.zip”. El tama帽o del archivo es de 822 MB. El archivo contiene 50, 100, 200 y 300 vectores de palabras dimensionales para 400k palabras. Usaremos el vector de 100 dimensiones.
El proceso es bastante similar. Primero tenemos que importar las bibliotecas requeridas:
from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.embeddings import Embedding
A continuaci贸n, tenemos que crear nuestro corpus seguido de las etiquetas.
corpus = [
# Positive Reviews
'This is an excellent movie',
'The move was fantastic I like it',
'You should watch it is brilliant',
'Exceptionally good',
'Wonderfully directed and executed I like it',
'Its a fantastic series',
'Never watched such a brillent movie',
'It is a Wonderful movie',
# Negtive Reviews
"horrible acting",
'waste of money',
'pathetic picture',
'It was very boring',
'I did not like the movie',
'The movie was horrible',
'I will not recommend',
'The acting is pathetic'
]
sentiments = array([1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0])
En la 煤ltima secci贸n, usamos la one_hotfunci贸n para convertir texto en vectores. Otro enfoque es utilizar la Tokenizerfunci贸n de la keras.preprocessing.textbiblioteca.
Simplemente tienes que pasar tu corpus al m茅todo Tokenizer‘s fit_on_text.
word_tokenizer = Tokenizer()
word_tokenizer.fit_on_texts(corpus)
Para obtener el n煤mero de palabras 煤nicas en el texto, simplemente puede contar la longitud del word_indexdiccionario del word_tokenizerobjeto. Recuerde agregar 1 con el tama帽o del vocabulario. Esto es para almacenar las dimensiones de las palabras para las que no existen incrustaciones de palabras previamente entrenadas.
vocab_length = len(word_tokenizer.word_index) + 1
Finalmente, para convertir oraciones en su contraparte num茅rica, llame a la texts_to_sequencesfunci贸n y p谩selo por todo el corpus.
embedded_sentences = word_tokenizer.texts_to_sequences(corpus)
print(embedded_sentences)
En la salida, ver谩 las oraciones en su forma num茅rica:
[[14, 3, 15, 16, 1], [4, 17, 6, 9, 5, 7, 2], [18, 19, 20, 2, 3, 21], [22, 23], [24, 25, 26, 27, 5, 7, 2], [28, 8, 9, 29], [30, 31, 32, 8, 33, 1], [2, 3, 8, 34, 1], [10, 11], [35, 36, 37], [12, 38], [2, 6, 39, 40], [5, 41, 13, 7, 4, 1], [4, 1, 6, 10], [5, 42, 13, 43], [4, 11, 3, 12]]
El siguiente paso es encontrar el n煤mero de palabras en la oraci贸n m谩s larga y luego aplicar relleno a las oraciones que tienen una longitud m谩s corta que la longitud de la oraci贸n m谩s larga.
from nltk.tokenize import word_tokenize
word_count = lambda sentence: len(word_tokenize(sentence))
longest_sentence = max(corpus, key=word_count)
length_long_sentence = len(word_tokenize(longest_sentence))
padded_sentences = pad_sequences(embedded_sentences, length_long_sentence, padding='post')
print(padded_sentences)
Las oraciones rellenas se ven as铆:
[[14 3 15 16 1 0 0]
[ 4 17 6 9 5 7 2]
[18 19 20 2 3 21 0]
[22 23 0 0 0 0 0]
[24 25 26 27 5 7 2]
[28 8 9 29 0 0 0]
[30 31 32 8 33 1 0]
[ 2 3 8 34 1 0 0]
[10 11 0 0 0 0 0]
[35 36 37 0 0 0 0]
[12 38 0 0 0 0 0]
[ 2 6 39 40 0 0 0]
[ 5 41 13 7 4 1 0]
[ 4 1 6 10 0 0 0]
[ 5 42 13 43 0 0 0]
[ 4 11 3 12 0 0 0]]
Hemos convertido nuestras oraciones en una secuencia de n煤meros acolchada. El siguiente paso es cargar las incrustaciones de palabras de GloVe y luego crear nuestra matriz de incrustaci贸n que contiene las palabras en nuestro corpus y sus valores correspondientes de las incrustaciones de GloVe. Ejecute el siguiente script:
from numpy import array
from numpy import asarray
from numpy import zeros
embeddings_dictionary = dict()
glove_file = open('E:/Datasets/Word Embeddings/glove.6B.100d.txt', encoding="utf8")
En el script anterior, adem谩s de cargar las incrustaciones de GloVe, tambi茅n importamos algunas bibliotecas. Veremos el uso de estas bibliotecas en la pr贸xima secci贸n. Aqu铆 observe que cargamos el glove.6B.100d.txtarchivo. Este archivo contiene 100 incrustaciones de palabras dimensionales. Tambi茅n creamos un diccionario vac铆o que almacenar谩 nuestras incrustaciones de palabras.
Si abre el archivo, ver谩 una palabra al principio de cada l铆nea seguida de un conjunto de 100 n煤meros. Los n煤meros forman el vector de 100 dimensiones de la palabra al principio de cada l铆nea.
Crearemos un diccionario que contendr谩 palabras como claves y los correspondientes 100 vectores dimensionales como valores, en forma de matriz. Ejecute el siguiente script:
for line in glove_file:
records = line.split()
word = records[0]
vector_dimensions = asarray(records[1:], dtype="float32")
embeddings_dictionary [word] = vector_dimensions
glove_file.close()
El diccionario embeddings_dictionaryahora contiene palabras y las correspondientes incrustaciones GloVe para todas las palabras.
Queremos incrustaciones de palabras solo para aquellas palabras que est谩n presentes en nuestro corpus. Crearemos una matriz num茅rica bidimensional de 44 (tama帽o del vocabulario) filas y 100 columnas. La matriz inicialmente contendr谩 ceros. La matriz se nombrar谩 comoembedding_matrix
A continuaci贸n, iteraremos a trav茅s de cada palabra en nuestro corpus recorriendo el word_tokenizer.word_indexdiccionario que contiene nuestras palabras y su 铆ndice correspondiente.
Cada palabra se pasar谩 como clave para embedding_dictionaryrecuperar el vector de 100 dimensiones correspondiente a la palabra. El vector de 100 dimensiones se almacenar谩 en el 铆ndice correspondiente de la palabra en el embedding_matrix. Mira el siguiente gui贸n:
embedding_matrix = zeros((vocab_length, 100))
for word, index in word_tokenizer.word_index.items():
embedding_vector = embeddings_dictionary.get(word)
if embedding_vector is not None:
embedding_matrix[index] = embedding_vector
Nuestro embedding_matrixahora contiene incrustaciones de palabras previamente entrenadas para las palabras de nuestro corpus.
Ahora estamos listos para crear nuestro modelo secuencial. Mira el siguiente gui贸n:
model = Sequential()
embedding_layer = Embedding(vocab_length, 100, weights=[embedding_matrix], input_length=length_long_sentence, trainable=False)
model.add(embedding_layer)
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
El gui贸n sigue siendo el mismo, excepto por la capa de inserci贸n. Aqu铆, en la capa de incrustaci贸n, el primer par谩metro es el tama帽o del vacabulario. El segundo par谩metro es la dimensi贸n vectorial del vector de salida. Dado que estamos utilizando incrustaciones de palabras previamente entrenadas que contienen un vector dimensional 100, establecemos la dimensi贸n vectorial en 100.
Otro atributo muy importante de la Embedding()capa que no usamos en la 煤ltima secci贸n es weights. Puede pasar su matriz de incrustaci贸n previamente entrenada como pesos predeterminados para el weightspar谩metro. Y dado que no estamos entrenando la capa de incrustaci贸n, el trainableatributo se ha establecido en False.
Compilemos nuestro modelo y veamos el resumen de nuestro modelo:
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['acc'])
print(model.summary())
De nuevo lo estamos usando adamcomo optizer para minimizar la p茅rdida. La funci贸n de p茅rdida que se utiliza es binary_crossentropy. Y queremos ver los resultados en forma de precisi贸n, por lo que accse ha pasado como valor para el metricsatributo.
El resumen del modelo es el siguiente:
Layer (type) Output Shape Param #
=================================================================
embedding_1 (Embedding) (None, 7, 100) 4400
_________________________________________________________________
flatten_1 (Flatten) (None, 700) 0
_________________________________________________________________
dense_1 (Dense) (None, 1) 701
=================================================================
Total params: 5,101
Trainable params: 701
Non-trainable params: 4,400
_________________________________________________________________
Puede ver que dado que tenemos 44 palabras en nuestro vocabulario y cada palabra se representar谩 como un vector de 100 dimensiones, el n煤mero de par谩metros para la capa de incrustaci贸n ser谩 44 x 100 = 4400. El resultado de la capa de incrustaci贸n ser谩 un vector 2D con 7 filas (1 por cada palabra en la oraci贸n) y 100 columnas. La salida de la capa de incrustaci贸n se aplanar谩 para que se pueda utilizar con la capa densa. Finalmente, la capa densa se usa para hacer predicciones.
Ejecute el siguiente script para entrenar los algoritmos:
model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
Una vez que el algoritmo est茅 entrenado, ejecute el siguiente script para evaluar el rendimiento del algoritmo.
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))
En la salida, deber铆a ver que la precisi贸n es 1.000, es decir, 100%.
Incrustaciones de Word con la API funcional de Keras
En la 煤ltima secci贸n, vimos c贸mo se pueden usar las incrustaciones de palabras con la API secuencial de Keras. Si bien la API secuencial es un buen punto de partida para principiantes, ya que le permite crear r谩pidamente modelos de aprendizaje profundo, es extremadamente importante saber c贸mo funciona la API funcional de Keras. La mayor铆a de los modelos avanzados de aprendizaje profundo que involucran m煤ltiples entradas y salidas utilizan la API funcional.
En esta secci贸n, veremos c贸mo podemos implementar la capa de incrustaci贸n con la API funcional de Keras.
El resto del gui贸n sigue siendo similar al de la 煤ltima secci贸n. El 煤nico cambio estar谩 en el desarrollo de un modelo de aprendizaje profundo. Implementemos el mismo modelo de aprendizaje profundo que implementamos en la 煤ltima secci贸n con Keras Functional API.
from keras.models import Model
from keras.layers import Input
deep_inputs = Input(shape=(length_long_sentence,))
embedding = Embedding(vocab_length, 100, weights=[embedding_matrix], input_length=length_long_sentence, trainable=False)(deep_inputs) # line A
flatten = Flatten()(embedding)
hidden = Dense(1, activation='sigmoid')(flatten)
model = Model(inputs=deep_inputs, outputs=hidden)
En la API funcional de Keras, debe definir la capa de entrada por separado antes de la capa de incrustaci贸n. En la capa de entrada, simplemente debe pasar la longitud del vector de entrada. Para especificar esa capa anterior como entrada a la siguiente capa, la capa anterior se pasa como par谩metro dentro del par茅ntesis, al final de la siguiente capa.
Por ejemplo, en el script anterior, puede ver que deep_inputsse pasa como par谩metro al final de la capa de incrustaci贸n. Del mismo modo, embeddingse pasa como entrada al final de la Flatten()capa y as铆 sucesivamente.
Finalmente, en el Model(), debes pasar la capa de entrada y la capa de salida final.
Ahora compilemos el modelo y echemos un vistazo al resumen del modelo.
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['acc'])
print(model.summary())
La salida se ve as铆:
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) (None, 7) 0
_________________________________________________________________
embedding_1 (Embedding) (None, 7, 100) 4400
_________________________________________________________________
flatten_1 (Flatten) (None, 700) 0
_________________________________________________________________
dense_1 (Dense) (None, 1) 701
=================================================================
Total params: 5,101
Trainable params: 701
Non-trainable params: 4,400
En el resumen del modelo, puede ver la capa de entrada como una capa separada antes de la capa de incrustaci贸n. El resto del modelo sigue siendo el mismo.
Finalmente, el proceso para ajustar y evaluar el modelo es el mismo que se usa en la API secuencial:
model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))
En la salida, ver谩 una precisi贸n de 1.000, es decir, 100 por ciento.
Conclusi贸n
Para usar datos de texto como entrada al modelo de aprendizaje profundo, necesitamos convertir texto en n煤meros. Sin embargo, a diferencia de los modelos de Machine Learning, el paso de vectores dispersos de grandes tama帽os puede afectar enormemente a los modelos de aprendizaje profundo. Por lo tanto, necesitamos convertir nuestro texto en peque帽os vectores densos. Las incrustaciones de palabras nos ayudan a convertir texto en vectores densos.
En este art铆culo, vimos c贸mo se pueden implementar las incrustaciones de palabras con la biblioteca de aprendizaje profundo de Keras. Implementamos las incrustaciones de palabras personalizadas y utilizamos incrustaciones de palabras previamente entrenadas para resolver tareas de clasificaci贸n simples. Finalmente, tambi茅n vimos c贸mo implementar incrustaciones de palabras con la API funcional de Keras.