GENERACIÓN DE TEXTO con Redes Recurrentes en Python (Tutorial)
Вставка
- Опубліковано 13 лип 2024
- 🔥🔥Academia Online🔥🔥: cursos.codificandobits.com/
🔥🔥Asesorías y formación personalizada🔥🔥: www.codificandobits.com/servi...
En este tercer video de la serie "Redes Neuronales Recurrentes" veremos cómo entrenar una Red Recurrente en Python y Keras capaz de generar texto.
Descarga el código fuente en este enlace: www.codificandobits.com/blog/...
🔴 ** VISITA WWW.CODIFICANDOBITS.COM **
En el sitio web encontrarán artículos y podrán descargar material útil para el desarrollo de aplicaciones de Machine Learning y Ciencia de Datos. También podrán ponerse en contacto conmigo si están interesados en servicios de formación, charlas o asesorías... Y muy pronto podrán acceder a los cursos online que estoy preparando.
🔴 ** LOS DEMÁS VIDEOS DE LA SERIE **
🎥 Introducción a las Redes Neuronales Recurrentes: • Introducción a las Red...
🎥 Redes Neuronales Recurrentes: Explicación Detallada: • Redes Neuronales Recur...
🎥 ¿Qué es una Red LSTM?: • ¿Qué es una red LSTM?
🎥 Tutorial Predicción de Acciones en la Bolsa con Python y Keras (Redes LSTM): • Predicción de acciones...
🔴 ** ÚNETE A CODIFICANDO BITS Y SÍGUEME EN MIS REDES SOCIALES **
✅ Sitio web: www.codificandobits.com
✅ Suscríbete: ua-cam.com/users/codificando...
✅ Facebook: / codificandobits
✅ Instagram: / codificandobits
✅ Twitter: / codificandobits
🔴 ** ACERCA DE MÍ **
Soy Miguel Sotaquirá, el creador de Codificando Bits. Tengo formación como Ingeniero Electrónico, y un Doctorado en Bioingeniería, y desde el año 2017 me he convertido en un apasionado por el Machine Learning y el Data Science, y en la actualidad me dedico por completo a divulgar contenido y a brindar asesoría a personas y empresas sobre estos temas.
🔴 ** ACERCA DE CODIFICANDO BITS **
El objetivo de Codificando Bits es inspirar y difundir el conocimiento en las áreas de Machine Learning y Data Science.
#machinelearning - Наука та технологія
🔥🔥Academia Online🔥🔥: cursos.codificandobits.com/
🔥🔥Asesorías y formación personalizada🔥🔥: www.codificandobits.com/servicios/
Excelente Miguel... lo que estaba necesitando para entender el tema de RNN..
Excelente curso Miguel. Te felicito por lo bien que explicas. Sigue así. Espero con ansias el próximo video de la serie.
Gracias por tu comentario Pablo. Esto lo anima a uno a seguir publicando videos.
Y nos vemos en el próximo video! Un saludo!
Explica genial! muchas gracias
Como SIEMPRE... GENIAL.
Gracias de nuevo por tus comentarios José Manuel, y espero sigas conectado al canal!
Excelente como todos los videos. Gran trabajo. Gracias
Gracias por tu comentario Jorge. Un saludo!
Gracias por tus videos amigo , enserio no llegaba a comprender estos conceptos pero tu video me ayudo bastante a mejorar mi AI
Qué bueno que te guste el contenido del canal. Un saludo!
Excelente video, y un gran aporte.
Gracias por tu comentario Ericson, un saludo!
Hola muchas gracias por compartir conocimiento!
Hola Diego. Gracias por tu comentario y un saludo!
Hola Miguel, agradezco mucho tus videos, se ve un muy buen trabajo detrás de ellos. Me surge una inquietud, ¿qué libros tienes en la mesita en este vídeo?
Gran video
😉
Genial Miguel. Si quisiéramos hacer este mismo ejercicio pero con nombre de personas qué deberíamos hacer? Solo cambiar el data set?
Excelentes videos, solo un pequeño aporte, para garantizar la reproducibilidad de Keras en mi caso suelo usar
import os
import numpy as np
import random as rn
SEED = 42
os.environ['PYTHONHASHSEED'] = str(SEED)
np.random.seed(SEED)
rn.seed(SEED)
Hola Víctor. Gracias por tu comentario, no había usado esta sintaxis que sugieres. Un saludo!
Una explicación concisa y clara. No obstante yo quería aprender esto para hacer mi propia librería de redes neuronales artificiales, y me ha costado muchísimo entender cómo hacerlo para estas redes, y las redes neuronales recurrentes LSTM.
Hola Octavio, gracias por tu comentario. 😬😬😬 qué buen proyecto el de implementar tu propia librería de redes neuronales. Yo creo que las LSTM son, de todas, una de las arquitecturas más difíciles de implementar desde cero, pues están los temas convencionales del entrenamiento y backpropagation (comunes a todas las arquitecturas) pero además está el tema del manejo de las secuencias y de la misma arquitectura LSTM que de por sí tiene muchos elementos.
Te sugiero este enlace, con una implementación LSTM "from scratch" muy buena: www.kaggle.com/navjindervirdee/lstm-neural-network-from-scratch
Un saludo!
@@codificandobits Muchas gracias.
excelente video, Hola Miguel tendras el codigo de la definicion de la variable tam_alfabeto?
Otra duda que tengo, en el minuto 7.55 donde muestra el print de iteraciones y error, a que se refiere con error
Podría hacer algún ejemplo en tensorflow basado con Many to one para análisis de sentimientos
Hola Mónica. Tensorflow y análisis de sentimientos están en el listado de videos por venir.
En la serie que comenzará próximamente hablaré en principio de Tensorflow 2.0. Un saludo!
de las 3858 palabras que hablaste solo a prendí 5 jejeje
Muy buen vídeo, mejor te contacto y te pago para que me hagas algo que necesito.
Mas adelante me pongo en contacto, muy excelente video.
Ja, ja, ja!!! ¿Y por qué sólo aprendiste 5? ¿Muy confusa la explicación?
Claro que sí, me puedes escribir a codificandobits@gmail.com.
Un saludo!
@@codificandobits hey mi querido profesor, yo no se mucho, use colab de Google y me funcionó muy bien.
Uso un programa y quiero hacer otro así que te hablo por el correo.
@@vozdominicana Perfecto, quedo pendiente!
Hola , muy bien explicado tu video y conciso tal como me gusta (Y)
Por otro lado quería preguntarte porque razón se tiene que poner en formato onehot ? porque no se podía dejar con el vector con números? y una pregunta más...
esta RNN cuando pones que tiene 25 neuronas de la capa oculta , como es que se toman los valores ya que en tus ejemplos solo vemos como funciona con 1 neurona, es decir muestras 1 neurona como entra 1 caracter y parece que funciona bien con 1 ... cual es el objeto de tener 24 neuronas más o es que talvez cada caracter va a las 25 neuronas tal cual para que cada neurona se comporte con mayor peso de prediccion a cada letra del alfabeto? y como es que cada neurona toma una entrada , muchas gracias de antemano por tu respuestas.
El vector onehot son los valores de 0..1.
Respecto a la segunda pregunta, tengo la misma duda. ¿Cómo funciona la recurrencia en n neuronas?
Entiendo que la entrada es un vector onehot de 27 elementos que representa una letra alfabética (carácter de una palabra), ¿pero es así para cada neurona?
@@Moustacheru lo resolviste compañero ? hice una red neuronal que genere texto, paseme su correo o telegram para compartir experiencias amigo
Buenas, hice un trabajo similar, tome de ejemplo el tuyo, me pareció muy bueno tu video, tengo eso si una consulta, en caso de querer mostrar una métrica, como podría hacerlo?
lo resolviste compañero ? hice una red neuronal que genere texto, paseme su correo o telegram para compartir experiencias amigo
Interesante video, tengo una duda con una red recurrente se podria hacer una IA que "hable" (es decir, que a inputs de texto del usuario, responda con ouputs de texto que tengan un minimo de sentido)
Es posible, y en este caso te refieres a un "chatbot". Las redes recurrentes funcionan bien, aunque tendrías mejores resultados usando Redes Transformer.
En el canal encontrarás el video "Construyo un chatbot de voz" en donde verás el principio de funcionamiento. ¡Un saludo!
@@codificandobits gracias por su respuesta
Buen día Miguel, muchas gracias por el curso, me interesa aprender sobre las redes recurrentes, y la verdad es bastante entendible la forma en que nos explica, me esta sirviendo bastante. Viendo el video, me surgió una duda, ¿Por qué motivo se usan 25 neuronas? ¿Qué pasa si se usan más o menos neuronas?
Muchas gracias por el curso.
Lo sigo viendo, saludos cordiales.
Hola Edgar. Es una muy buena pregunta, pero a la vez es una pregunta difícil de responder. El problema de las redes neuronales (y convolucionales y recurrentes y, en general, todas las arquitecturas del Deep Learning) es que no existe una forma analítica de predecir el tamaño de la red (número de capas y/o número de neuronas por capa).
Esto se debe a que los datos con que se entrena la red son muy diversos y usualmente son de tipo perceptual (imágenes, video, audio) y por ello resulta imposible obtener una representación matemática de los mismos. Así que la forma de determinar el tamaño más adecuado de la red es a través de la validación: entrenando el modelo y luego verificando que tenga una precisión alta con el set de prueba.
Así que para responder a tu pregunta: si se incluyen más o menos neuronas se vería afectada la precisión al momento de validar. Si esta precisión mejora quiere decir que ese nuevo número de neuronas resultará más adecuado.
Un saludo!
@@codificandobits muchas gracias Miguel por la explicación. Se podra usar Tensorflow con Java en lugar de Python? Saludos cordiales.
Excelente Miguel, podrías regalarme nombres de libros para redes recurrentes
Gracias por tu comentario Víctor. Se me ocurre el libro de referencia en Deep Learning: the Deep Learning book! Un saludo!
#Miguel, no he podido compilar el código, me da un error en el Optimizador SGD
import numpy as np
np.random.seed(5)
from keras.layers import Input, Dense, SimpleRNN
from keras.models import Model
from keras.optimizers import SGD
from keras.utils import to_categorical
from keras import backend as K
# 1. LECTURA DEL SET DE DATOS
# ===========================================================
nombres = open('nombres_dinosaurios.txt','r').read()
nombres = nombres.lower()
# Crear diccionario (listado de caracteres que no se repiten)
alfabeto = list(set(nombres))
tam_datos, tam_alfabeto = len(nombres), len(alfabeto)
print("En total hay %d caracteres, y el diccionario tiene un tamaño de %d caracteres." % (tam_datos, tam_alfabeto))
# Conversión de caracteres a índices y viceversa
car_a_ind = { car:ind for ind,car in enumerate(sorted(alfabeto))}
ind_a_car = { ind:car for ind,car in enumerate(sorted(alfabeto))}
#print(car_a_ind)
#print(ind_a_car)
# 2. MODELO
# ===========================================================
n_a = 25 # Número de neuronas en la capa oculta
entrada = Input(shape=(None,tam_alfabeto))
a0 = Input(shape=(n_a,))
celda_recurrente = SimpleRNN(n_a, activation='tanh', return_state = True) #return_state entregua a la salida el estado oculto actualizado
capa_salida = Dense(tam_alfabeto, activation='softmax')
salida = []
hs, _ = celda_recurrente(entrada, initial_state=a0)
salida.append(capa_salida(hs))
modelo = Model([entrada,a0],salida) #Entradas y salidas
#modelo.summary()
opt = SGD(learning_rate=0.0005)
modelo.compile(optimizer=opt, loss='categorical_crossentropy')
# 3. EJEMPLOS DE ENTRENAMIENTO
# ===========================================================
# Crear lista con ejemplos de entrenamiento y mezclarla aleatoriamente
with open("nombres_dinosaurios.txt") as f:
ejemplos = f.readlines()
ejemplos = [x.lower().strip() for x in ejemplos]
np.random.shuffle(ejemplos)
# Crear ejemplos de entrenamiento usando un generador
def train_generator():
while True:
# Tomar un ejemplo aleatorio
ejemplo = ejemplos[np.random.randint(0,len(ejemplos))]
# Convertir el ejemplo a representación numérica
X = [None] + [car_a_ind[c] for c in ejemplo]
# Crear "Y", resultado de desplazar "X" un caracter a la derecha
Y = X[1:] + [car_a_ind['
']]
# Representar "X" y "Y" en formato one-hot
x = np.zeros((len(X),1,tam_alfabeto))
onehot = to_categorical(X[1:],tam_alfabeto).reshape(len(X)-1,1,tam_alfabeto)
x[1:,:,:] = onehot
y = to_categorical(Y,tam_alfabeto).reshape(len(X),tam_alfabeto)
# Activación inicial (matriz de ceros)
a = np.zeros((len(X), n_a))
yield (x, a), y
# 4. ENTRENAMIENTO
# ===========================================================
BATCH_SIZE = 80 # Número de ejemplos de entrenamiento a usar en cada iteración
NITS = 2000 # Número de iteraciones
for j in range(NITS):
historia = modelo.fit(train_generator(), steps_per_epoch=BATCH_SIZE, epochs=1, verbose=0)
# Imprimir evolución del entrenamiento cada 1000 iteraciones
if j%1000 == 0:
print('
Iteración: %d, Error: %f' % (j, historia.history['loss'][0]) + '
')
import tensorflow as tf
# 5. GENERACIÓN DE NOMBRES USANDO EL MODELO ENTRENADO
# ===========================================================
def generar_nombre(modelo,car_a_num,tam_alfabeto,n_a):
# Inicializar x y a con ceros
x = np.zeros((1, 1, tam_alfabeto))
a = np.zeros((1, n_a))
# Nombre generado y caracter de fin de linea
nombre_generado = ''
fin_linea = '
'
car = -1
# Iterar sobre el modelo y generar predicción hasta tanto no se alcance
# "fin_linea" o el nombre generado llegue a los 50 caracteres
contador = 0
while (car != fin_linea and contador != 50):
# Generar predicción usando la celda RNN
a, _ = celda_recurrente(tf.constant(x), initial_state= tf.constant(a))
y = capa_salida(a)
prediccion = y.numpy()
# Escoger aleatoriamente un elemento de la predicción (el elemento con
# con probabilidad más alta tendrá más opciones de ser seleccionado)
ix = np.random.choice(list(range(tam_alfabeto)),p=prediccion.ravel())
# Convertir el elemento seleccionado a caracter y añadirlo al nombre generado
car = ind_a_car[ix]
nombre_generado += car
# Crear x_(t+1) = y_t, y a_t = a_(t-1)
x = to_categorical(ix,tam_alfabeto).reshape(1,1,tam_alfabeto)
a = a.numpy()
# Actualizar contador y continuar
contador += 1
# Agregar fin de línea al nombre generado en caso de tener más de 50 caracteres
if (contador == 50):
nombre_generado += '
'
print(nombre_generado)
# Generar 100 ejemplos de nombres generados por el modelo ya entrenado
for i in range(10):
generar_nombre(modelo,car_a_ind,tam_alfabeto,n_a)
Brother me dices como hago para instalar las librerias que van al comienzo por favor. Si se que es pip install pero de ahi que mas pongo
Hola David. Debes instalar tensorflow 2, que por defecto ya viene con keras. Acá un enlace: www.tensorflow.org/install. Revisa y me cuentas si tienes algún problema
@@codificandobits logro hacer la instalacion pero me sale el siguiente error: mega.nz/file/7MIwHKKI#zPluaO7AT6Jt-2LWy-8lQjpmoJDi8S8W8JU8NwcoCsI
@@davidjolley456 hola Mega.nz es un drive probablemente tengas que descargarlo y crear una cuenta
Tengo una pregunta un poco puntillosa.
¿Del dataset de 1536 palabras, 717 tienen la terminación "saurus", porque este patrón no se ve reflejado en los nombres generados?
Perdón por la molestia, espero tengas tiempo y oportunidad de contestar.
Muchas gracias por el vídeo y por el canal, son excelentes.
Hola Rodrigo. Gracias por tu comentario y qué pregunta tan interesante.
Esto se debe a que estamos usando una red recurrente básica, que tiene una memoria de corto plazo. Así, a pesar de que el patrón "saurus" se repite en buena parte del set, se trata de una secuencia (palabra) relativamente extensa (6 caracteres).
El hecho de tener una red con memoria de corto plazo, y un patrón relativamente largo, hace que la red no alcance a percibir este patrón y por tanto no logra aprenderlo.
Un saludo!
No soy experto, pero tal vez se deba a la importancia que se le da a ciertos parámetros en el entrenamiento, tengo entendido que eso se puede ver con un análisis de 'feature impact' ( aun soy aprendiz, saludos)
@@AlexGonzalez-lp3hd Alex, el feature impact se refiere más a los algoritmos tradicionales de "machine learning", en donde antes de entrar a la red neuronal se lleva a cabo una etapa de "extracción de características" (feature extraction). Sin embargo en el caso de las redes recurrentes (o convolucionales, o de los modelos Deep Learning en general) no se usa esta etapa.
@@codificandobits Wow, muchas gracias por la aclaración. Haces buen trabajo. Saludos
Su voz me suena similar a la de Goku adulto
Ja, ja, ja... se parece! No me había dado cuenta 😂😂