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!
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 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?
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!
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.
@@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.
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!
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?
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!
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
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.
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)
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?
🔥🔥Academia Online: codificandobits.com 🔥🔥
🔥🔥Asesorías y formación personalizada: 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!
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.
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!
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!
Excelente como todos los videos. Gran trabajo. Gracias
Gracias por tu comentario Jorge. Un saludo!
Explica genial! muchas gracias
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?
Genial Miguel. Si quisiéramos hacer este mismo ejercicio pero con nombre de personas qué deberíamos hacer? Solo cambiar el data set?
Excelente video, y un gran aporte.
Gracias por tu comentario Ericson, un saludo!
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
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
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!
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.
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
Gran video
😉
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!
Como SIEMPRE... GENIAL.
Gracias de nuevo por tus comentarios José Manuel, y espero sigas conectado al canal!
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
#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)
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
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!
Su voz me suena similar a la de Goku adulto
Ja, ja, ja... se parece! No me había dado cuenta 😂😂