Construcción de RNN y Word2Vec Embedding

En este post haremos la construcción de una red muy similar a la que hemos hecho en nuestro ejercicio de deep learning con GRU y RNN, solo que para la parte de embedding vamos a utilizar otra representación relacionada con las RNN y Word2Vec Embedding.

RNN y Word2Vec Embedding

¿Qué pasa con el hecho de que utilicemos Word2Vec para embedding? Pues que, al final, lo que vamos a hacer es añadirle preprocesamiento extra a estos datos que tenemos y no es algo tan automático como en el caso mencionado, donde simplemente hemos cogido los datos, los hemos pasado a tokens y listo.

No obstante, aquí, para hacer los embeddings de Word2Vec, se requiere un trabajo más elaborado.

Entonces, ¿qué pasos debemos seguir? Vamos a hacer un pipeline.

Pasos previos

Previo a nuestro ejercicio, debemos importar las librerías:

#RNN y Word2Vec Embedding
import gensim
import multiprocessing as mp

from tensorflow.keras. preprocessing.text import Tokenizer
from tensorflow.keras. preprocessing.sequence import pad_sequences
from tensorflow.keras. models import Sequential
from tensorflow.keras. layers import {
       Dense,
       Dropout,
       Embedding,
       LSTM,
)
from tensorflow.keras. callbacks import ReduceLROnPlateau, EarlyStopping
fron sklearn.preprocessing import LabelEncoder

También vamos a definir parámetros para utilizar en nuestro Word2Vec:

#WORD2VEC
W2V_SIZE = 300
W2V_WINDOW = 7
#32
W2V_EPOCH = 5
W2V_MIN_COUNT =10

#KERAS
SEQUENCE_LENGHT = 300

Generación del Word2Vec

En primera instancia, haremos un tokenizado:

#RNN y Word2Vec Embedding
def generate_tokenizer (train_df):
       tokenizer = Tokenizer ()
       tokenizer.fit_on_texts (train_df.text)
       vocab_size = len (tokenizer.word_index) + 1
       print (f"Total words: {vocab_size}")
       return tokenizer, vocab_size

Ahora, veamos cómo se hace la generación del Word2Vec:

#RNN y Word2Vec Embedding
def generate_word2vec (train_df):
       documents = [_text.split () for _text in train_df.text.values]
       w2v_model = gensim.models.word2vec.Word2Vec (
              size = W2V_SIZE,
              window = W2V_WINDOW,
              min_count = W2V_MIN_COUNT,
              workers = mp.cpu_count (),
)
w2v_model. build_vocab (documents)

words = w2v_model.wv.vocab.keys ()
vocab_size = len (words)
print (f"Vocab size: {vocab_size}")
w2v_model.train (documents, total_examples = len (documents), epochs = W2V_EPOCH)

return w2v_model

¿Qué hacemos en esta función? Cogemos el dataframe de entrada, que van a ser nuestros datos de entrenamiento (train_df). Tomamos los datos tokenizados y vamos a utilizar Gensim para hacer la generación de nuestro Word2Vec. Instanciamos el objeto, construimos el vocabulario con nuestros datos y después tomamos el vocabulario.

A partir del vocabulario, podemos entrenar nuestro Word2Vec.

Generación del embedding

Lo siguiente que tendríamos que hacer sería la generación del embedding:

#RNN y Word2Vec Embedding
def generate_embedding (word2vec_model, vocab_size, tokenizer):
       embedding_matrix = np.zeros ((vocab_size, W2V_SIZE))
       for word, i in tokenizer. word_index.items ():
              if word in word2vec_model.wv:
                     embedding_matrix [i] = word2vec_model.wv [word]
       return Embedding (
              vocab_size,
              W2V_SIZE,
              weights = [embedding_matrix],
              input_length = SEQUENCE_LENGTH,
              trainable = False,
)

Lo que hemos hecho ha sido una matriz a cero con numpy. Esta matriz tendrá el tamaño del vocabulario y el tamaño del Word2Vec que hayamos definido. Ahora pasamos por cada uno de los tokens que tenemos y por el tokenizer. Después, lo que hacemos es: si la palabra de la review que estamos iterando está dentro del vocabulario del Word2Vec, la añadimos a la matriz, en la posición correspondiente a la palabra le añadimos su respectiva representación en Word2Vec.

Ahora debemos crear por separado la capa de embedding, que va a tener como entrada el tamaño del vocabulario y como salida el tamaño del Word2Vec. Después le pasamos los pesos y le pasamos una lista con la matriz y le decimos que estos datos no están preentrenados.

Aquí ya tendríamos nuestra capa de embedding, la cual podríamos incorporar a una red.

Generación de la red

#RNN y Word2Vec Embedding
(X_train_index, y_train_index), (X_test_index, y_test_index) = imdb.load_data (num_words = vocabulary_size)

#RNN y Word2Vec Embedding
word2id = imdb.get_word_index ()
id2word = {i: word for word, i in word2id.items ()}

X_train_words = [  ]
for example in X_train_index:
    words = "  ".join ([id2word.get (i, "  ") for i in X_train [0]]).strip ()
X_train_words.append (words)

#RNN y Word2Vec Embedding
X_train_words [0]

#RNN y Word2Vec Embedding
tokenizer, vocab = generate_tokenizer ("  ".join (X_train_words))

Total words: 28

#RNN y Word2Vec Embedding
word2vec_model = generate_word2vec (X_train_words)

Vocab size = 115

#RNN y Word2Vec Embedding
from keras.preprocessing import sequence

max_words = 500

X_train_words = sequence.pad_sequences (X_train_words_split, maxlen = max_words)
X_test_words = sequence.pad_sequences (X_test_words_split, maxlen = max_words)

#RNN y Word2Vec Embedding
embedding_layer = generate_embedding (word2vec_model, vocab, tokenizer)

#RNN y Word2Vec Embedding
model_custom = Sequential ()
model_custom.add (embedding_layer)
model_custom.add (LSTM (100, dropout = 0.2, recurrent_dropout = 0.2))
model_custom.add (Dense (1, activation = "sigmoid"))

#RNN y Word2Vec Embedding
model_custom.summary ()

#RNN y Word2Vec Embedding
model_custom.compile (loss = "binary_crossentropy", optimizer = "adam", metrics = ["accuracy"])

Para acceder a las opciones laborales del Big Data, una de las áreas tech mejor pagadas y con mayor demanda, tenemos para ti el Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp. Con esta formación íntegra, intensiva y de alta calidad adquirirás los conocimientos necesarios para conseguir tu trabajo perfecto en este sector en pocos meses. ¡No esperes más para impulsar tu vida y solicita más información ahora!