Con este post acabo el bloque de NLP con la generación de texto predictivo.
Un solo Notebook, muy sencillo, y dos modelos igualmente sencillos. Para asegurarme que funciona la forma de preparar los datos y los modelos los he probado con dos datasets totalmente diferentes.
https://storage.googleapis.com/tensorflow-1-public/course3/irish-lyrics-eof.txt
https://www.kaggle.com/code/roblexnana/generating-text-for-nlp-using-simplernn-with/data
Puntos Cubiertos de NLP del examen TensorFlow Developer.
(4) Natural language processing (NLP)
You need to understand how to use neural networks to solve natural language processing problems
using TensorFlow. You need to know how to:
❏ Build natural language processing systems using TensorFlow.
❏ Prepare text to use in TensorFlow models.
❏ Build models that identify the category of a piece of text using binary categorization
❏ Build models that identify the category of a piece of text using multi-class categorization
TensorFlow Certificate Candidate Handbook 3
❏ Use word embeddings in your TensorFlow model.
❏ Use LSTMs in your model to classify text for either binary or multi-class categorization.
❏ Add RNN and GRU layers to your model.
❏ Use RNNS, LSTMs, GRUs and CNNs in models that work with text.
❏ Train LSTMs on existing text to generate text (such as songs and poetry)
Puntos claves del notebook.
Como ya vimos en el post anterior, en el que trataba la clasificación de sentimientos en el texto por NLP, el punto más importante es el de la preparación de los textos para ser tratados.
El notebook de generación de texto lo podéis encontrar en el repositorio de Github.
El tratamiento de los datos para la generación del texto es curioso, por qué no tenemos Labels, la tenemos que sacar nosotros mismos del texto. Una label, no es nada más que una feature seguida de la siguiente palabra del texto. Lo mejor es explicarlo con un sencillo ejemplo.
Frase. “Hola Como Estas”
Feature: “Hola” Label:”Hola Como”
Feature: “Hola Como” Label:”Hola Como Estas”
Y así para todo el texto que forme parte del dataset. Antes de hacerlo tokenizamos el texto, igual que lo hicimos para la clasificación de sentimientos.
# Initialize the Tokenizer class
tokenizer = Tokenizer(num_words = vocab_size)
# Generate the word index dictionary for the training sentences
tokenizer.fit_on_texts(corpus)
word_index = tokenizer.word_index
total_words = len(word_index) + 1
print(f'number of words in word_index: {len(word_index)}')
print (total_words)
Primero creamos el diccionario, tokenizando las palabras. Lo que significa que a cada palabra se le asigna un número como identificador.
Ahora tenemos que crear las Labels, de la forma que hemos visto en el ejemplo, pero con los identificadrs y no con las palabras.
input_sequences = []
for line in corpus:
clean_sequence = cleanText(line)
#clean_sequence = line
token_list = tokenizer.texts_to_sequences([clean_sequence])[0]
for i in range(1, len(token_list)):
n_gram_sequence = token_list[:i+1]
input_sequences.append(n_gram_sequence)
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'))
xs, labels = input_sequences[:,:-1],input_sequences[:,-1]
ys = tf.keras.utils.to_categorical(labels, num_classes=total_words)
Con este código obteemos las features y las labels. En este formato:
[[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 423] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 423 12]]
Tenemos dos features. El label de la primera será: [12]. Que al juntarlo con el [423] nos da el segundo feature. Esta rellanados con 0’s a la izquierda para que los datos al entrar en el modelo tengan todos la misma forma.
Modelos.
def get_model(kindmodel):
switcher = {
#FLATTEN
#38s 35ms/step - loss: 0.3960 - accuracy: 0.8109 - val_loss: 1.2877 - val_accuracy: 0.6138
0:tf.keras.models.Sequential([
tf.keras.layers.Embedding(total_words, embedding_dim, input_length=max_sequence_len-1),
tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(lstm_units)),
tf.keras.layers.Dense(total_words, activation='softmax')]),
1:tf.keras.models.Sequential([
tf.keras.layers.Embedding(total_words, embedding_dim, input_length=max_sequence_len-1),
tf.keras.layers.LSTM(100),
tf.keras.layers.Dropout(0.1),
tf.keras.layers.Dense(total_words, activation='softmax')]),
}
return switcher.get(kindmodel, None)
Esta vez tan solo he usado dos modelos, como veis son muy parecidos. El primero la capa LSTM esta dentro de una Bidirectional, mientras que el segundo utiliza un poco de dropout.
Los dos se ejecutan muy rápidamente, el modelo 0 obtiene mejores números en Accuracy y Loss que el modelo 1, en los dos datasets.
Generando Texto.
def generate_text(seed_text, next_words, model, max_sequence_len):
output_word = ""
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')
probabilities = model.predict(token_list, verbose=0)
predicted = np.argmax(probabilities, axis=-1)[0]
print (predicted)
if predicted != 0:
output_word = tokenizer.index_word[predicted]
seed_text += " "+output_word
return seed_text
A esta función le pasamos la semilla a utilizar para la generación de texto, es decir la frase desde la que queremos partir, la cantidad de palabras que queremos obtener como resultado, el modelo a usar, y la longitud máxima de la frase con la que hemos entrenado el modelo.
al llamar a la función predict del modelo, nos devuelve una lista con todos los tokens y una probabilidad. con np.argmax, seleccionamos la que tiene la probabilidad mas alta.
generate_text(seed_text, 1, model0, max_sequence_len) 'Come here and look'
Bueno, pues no esta del todo mal. Algo de sentido tiene.
Si os interesa, os recomiendo encarecidamente que paséis por el repositorio de github, os bajéis el notebook y juguéis con él. Es muy sencillo, probad diferentes datasets, si podéis en idiomas diferentes…
Continuamos preparando el Examen de TensorFlow.
Bueno, pues ya queda tan solo el apartado de las series…. y lo que mas pereza me da, mirarme Pychar, que no acabo de entender porque es el entorno en el que la gente de Google ha decidido ejecutar el examen.
Os dejó el resto de entradas que he preparado para pasar el Examen.
Veremos lo impresionantemente sencillo que puede ser obtener mejoras de rendimiento significativas usando la generación automática de código en Graph Read more
Realizar un entreno desde 0 de uno de los Grandes Modelos de Lenguaje actuales es una acción al alcance de Read more
LangChain el responsable de buscar entre nuestra información almacenada en ChromaDB, para pasársela al Modelo de lenguaje utilizado
Usando los ML Agents de Unity he empezado a crear lo que se llaman NPC's. Son aquellos caracteres que pueblan Read more