<jupyter_start><jupyter_text><jupyter_code>from google.colab import drive
drive.mount('/gdrive')
%cd /gdrive/My Drive/Colab Notebooks/dataset_IA2/textos
!ls
import tensorflow as tf
import tensorflow_datasets as tfds
import os
import numpy as np
BUFFER_SIZE = 10000
BATCH_SIZE = 64
TAKE_SIZE = 5000


text1 = open('cronicas_marianela.txt',mode='r',encoding='utf-8-sig').read()


historia=text1.rsplit()#separamos en texto en palabras separadas por espacio
#historia
vocab=np.unique(historia)# se crea el vocabulario sacando las palabras unicas
print(len(vocab))
vocab_size=len(vocab)# el tamanio del vocabulario
indxPalabra = {u:i for i, u in enumerate(vocab)}# creamos un diccionario con las palabras como key y numeros como valor
palabras = np.array(vocab)# se crea un array con las palabras

text_as_int = np.array([indxPalabra[c] for c in historia])
text_as_int# los valores de las palabras
#print(indxPalabra)
#print(palabras)
print(len(historia))
#se crea lotes de 100 palabras para entrenar 
palabras_dataset = tf.data.Dataset.from_tensor_slices(text_as_int)
seq_length = 100 
sequences = palabras_dataset.batch(seq_length+1, drop_remainder=True)
for i in palabras_dataset.take(5):
  print(palabras[i.numpy()])
#una vista de 5 lotes de 100
for item in sequences.take(5):
  print(repr('\\'.join(palabras[item.numpy()])))
def split_input_target(chunk):
    input_text = chunk[:-1]
    target_text = chunk[1:]
    return input_text, target_text

train_data = sequences.map(split_input_target)
for input_example, target_example in  train_data.take(1):
  print ('Input data: ', repr('\\'.join(palabras[input_example.numpy()])))
  print ('Target data:', repr('\\'.join(palabras[target_example.numpy()])))
train_data
# una vista del valor introducido y la palabra que esperamos que continue
for i, (input_idx, target_idx) in enumerate(zip(input_example[:5], target_example[:5])):
    print("Step {:4d}".format(i))
    print("  input: {} ({:s})".format(input_idx, repr(palabras[input_idx])))
    print("  expected output: {} ({:s})".format(target_idx, repr(palabras[target_idx])))

train_data1= train_data.shuffle(BUFFER_SIZE).batch(BATCH_SIZE,drop_remainder=True)

train_data1

embedding_dim = 256
rnn_units = 1024
#se crea el constructor del modelo
def build_model(vocab_size, embedding_dim, rnn_units, batch_size):
  model = tf.keras.Sequential([
    tf.keras.layers.Embedding(vocab_size, embedding_dim,
                              batch_input_shape=[batch_size, None]),
    tf.keras.layers.LSTM(rnn_units,
                        return_sequences=True,
                        stateful=True,
                        recurrent_initializer='glorot_uniform'),
    tf.keras.layers.Dense(vocab_size)
  ])
  return model
model = build_model(
  vocab_size = vocab_size,
  embedding_dim=embedding_dim,
  rnn_units=rnn_units,
  batch_size=BATCH_SIZE)
model.summary()
for input_example_batch, target_example_batch in train_data1.take(1):
  print("Input:", input_example_batch.shape, "# (batch_size, sequence_length)")
  print("Target:", target_example_batch.shape, "# (batch_size, sequence_length)")

for input_example_batch, target_example_batch in train_data1.take(1):  
    example_batch_predictions = model(input_example_batch)
    print("Prediction: ", example_batch_predictions.shape, "# (batch_size, sequence_length, vocab_size)")
sampled_indices = tf.random.categorical(example_batch_predictions[0], num_samples=1)
sampled_indices_characters = tf.squeeze(sampled_indices,axis=-1).numpy()
print(sampled_indices_characters)
print("Input: \n", repr("//".join(palabras[input_example_batch[0]])))
print()
print("Next Char Predictions: \n", repr("//".join(palabras[sampled_indices_characters ])))
def loss(labels, logits):
  return tf.keras.losses.sparse_categorical_crossentropy(labels, logits, from_logits=True)


example_batch_loss  = loss(target_example_batch, example_batch_predictions)
print("Prediction shape: ", example_batch_predictions.shape, " # (batch_size, sequence_length, vocab_size)")
print("scalar_loss:      ", example_batch_loss.numpy().mean())
model.compile(optimizer='adam', loss=loss)
# directorio
checkpoint_dir = 'training_checkpoints'
# nombre fichero
checkpoint_prefix = os.path.join(checkpoint_dir, "modelEpoch_{epoch}")

checkpoint_callback=tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_prefix,
    save_weights_only=True)
EPOCHS=50
history = model.fit(train_data1, epochs=EPOCHS, callbacks=[checkpoint_callback])
tf.train.latest_checkpoint(checkpoint_dir)
model = build_model(vocab_size, embedding_dim, rnn_units, batch_size=1)

model.load_weights(tf.train.latest_checkpoint(checkpoint_dir))

model.build(tf.TensorShape([1, None]))
model.summary()
#se crea un diccionario con numeros como key y las palabras como valor
pa_num = {i:u for i, u in enumerate(vocab)}


def generate_text(model, start_string):
  # Evaluation step (generating text using the learned model)

  # Number of characters to generate
  num_generate = 100
  
 
  # Convertir nuestra cadena de inicio a números (vectorización)
  try:
    input_eval = [indxPalabra[start_string]]
    input_eval = tf.expand_dims(input_eval, 0)
  

    # Cadena vacía para almacenar nuestros resultados
    text_generated = []

    # Las bajas temperaturas dan como resultado un texto más predecible.
    # Temperaturas más altas resultan en texto más sorprendente.
    # Experimente para encontrar la mejor configuración.
    temperature = 1.0

    # Here batch size == 1
    # Aquí tamaño del lote == 1
    model.reset_states()
    for i in range(num_generate):
        predictions = model(input_eval)
        
        # eliminar la dimensión del lote
        predictions = tf.squeeze(predictions, 0)
        
        # utilizando una distribución categórica para predecir el carácter devuelto por el modelo
        predictions = predictions / temperature
        predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()
        #print(predicted_id)
        # Pasamos el carácter predicho como la siguiente entrada al modelo
        # junto con el estado oculto anterior
        if i%10!=0:
          text_generated.append(' '+pa_num[predicted_id])
        else:
          text_generated.append('\n'+pa_num[predicted_id])
     

    return (start_string + ''.join(text_generated))
  except:
    print('La palabra que introdujo no se reconoce') 
print(generate_text(model, start_string="cosas"))
print(generate_text(model, start_string="ambiciosa"))
print(generate_text(model, start_string="cosas"))
##############################   COMENTARIOS   ########################################


# como se puede ver en los resultados de prediccion 
# aunque introdujamos la misma palabra nos generara una historia diferente 

# si introducimos palabras que no ubiecen estado en el archivo .txt dara un error 
# y no generrara ningun resultados

# como la generacion es con palabras no tiene mucha coherencia a la hora 
# de leer toda la historia<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11416702478154993, 'fraction_numerical': 0.010170462684429164, 'mean_word_length': 5.008605851979346, 'pattern_counts': {'":': 0, '<': 5, '<?xml version=': 0, '>': 5, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '1', 'dir': 'jupyter-structured-clean-dedup', 'id': '542681', 'license': 'Apache-2.0', 'n_tokens_mistral': 2415, 'n_tokens_neox': 2356, 'n_words': 535, 'path': 'modelos/RNN_Palabras/Copia_de_practica_leer_texto.ipynb', 'repo_name': 'LuisFerRosas/IA_2', 'size': '6981'}