¿Quieres entrenar tu propia red neuronal? Con este ejercicio de redes neuronales profundas que he preparado para ti, podrás crear un modelo de inteligencia artificial capaz de predecir tendencias, clasificar imágenes o entender el lenguaje humano. Fascinante, ¿no?

Para que puedas realizar este ejercicio de redes neuronales profundas, tienes que haber desarrollado un shallow-net o red neuronal poco profunda. Ten en cuenta que, a partir de dos capas ocultas en adelante, es cuando podemos hablar de redes neuronales profundas.

¿Qué encontrarás en este post?

Ejercicio de redes neuronales profundas: Paso a paso

Crea una nueva versión de la función train_deep_net

Abre una nueva celda en tu entorno de trabajo.
Copia el código original de la función y pega una copia para modificarla.

Añade más profundidad a la red neuronal

Introduce tres capas ocultas adicionales a las que ya existen. Configura las capas ocultas con las siguientes neuronas:

Primera capa oculta: 200 neuronas.
Segunda capa oculta: 100 neuronas.
Tercera capa oculta: 60 neuronas.
Cuarta capa oculta (nueva): 30 neuronas.
Asegúrate de usar activaciones personalizables (se definirán como parámetros de entrada).

Haz que la función acepte más parámetros

Modifica la cabecera de la función para incluir dos nuevos parámetros:

act_function: La función de activación que se usará en las capas ocultas.

optimizer: El optimizador a emplear para minimizar la pérdida.

La cabecera final de la función te debe quedar así:

def train_deep_net(learning_rate, batch_size, num_epochs, act_function, optimizer):

Configura las funciones de activación y optimización

Cambia la definición de las capas ocultas para que utilicen act_function como activación.
Sustituye el optimizador original por una instancia dinámica que use el parámetro optimizer para definir el tipo de optimizador y el learning rate.

Llama a la nueva función con los parámetros correctos

Usa los siguientes valores para probar la función:

learning_rate = 0.005

batch_size = 128

num_epochs = 50

act_function = tf.nn.relu

optimizer = tf.train.AdamOptimizer

Ejemplo de llamada:

train_deep_net(learning_rate=0.005, batch_size=128, num_epochs=50, act_function=tf.nn.relu, optimizer=tf.train.AdamOptimizer)

Analiza las curvas de pérdida

Observa las curvas de pérdidas de entrenamiento y validación. Es probable que notes overfitting en las gráficas:

La pérdida en entrenamiento es significativamente menor que en validación.
Esto indica que el modelo está sobreajustando los datos de entrenamiento y pierde capacidad de generalización.

Ajusta el modelo para reducir el overfitting (si necesario)

Si detectas overfitting:

Considera añadir técnicas como regularización (e.g., Dropout o L2 regularization).
Aumenta el tamaño del conjunto de datos si es posible.
Reduce la complejidad del modelo, disminuyendo el número de neuronas o capas.

Grafica las curvas de pérdida

Utiliza el código incluido para graficar las pérdidas por época para entrenamiento y validación:

plt.plot(np.arange(0, n_epochs), loss_epoch_tr) 
plt.plot(np.arange(0, n_epochs), loss_epoch_val) 
plt.legend(['train', 'val'], loc='upper left') 
plt.title('Training Loss') 
plt.xlabel('Epoch #') 
plt.ylabel('Loss') 
plt.show()

Evalúa en el conjunto de prueba

Al final del entrenamiento, mide el rendimiento del modelo en el conjunto de prueba para obtener la precisión y la pérdida final:

a_test, l_test = sess.run([accuracy, loss], feed_dict={X: mnist.test.images, Y_true: mnist.test.labels}) 
print("[INFO]: Accuracy en test = {} - Losses en test = {}".format(a_test, l_test))

Código completo del ejercicio de redes neuronales profundas

def train_deep_net(learning_rate, batch_size, num_epochs, act_function, optimizer):
  # Creamos placeholders para ir almacenando los datos de entrada y los labels
  X = tf.placeholder(tf.float32, [None, 784]) #(X) # Imágenes del mnist: 28*28 = 784
  Y_true = tf.placeholder(tf.float32, [None, 10]) #(X) # Número indicando la clase 0-9 => 10 clases

  # Creamos e inicializamos las variables W y b con valores aleatorios que sigan una distribución normal


  # Calculamos las predicciones


  # Definimos función de pérdidas (Cross_entropy)
  loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=Y_logits, labels=Y_true)) # Evita las inestabilidades numéricas de log(0)


  # Optimizador SGD
  train = optimizer(lr).minimize(loss) #(X)

  # % de predicciones correctas en un determinado batch (i.e. accuracy)
  is_correct = tf.equal(tf.argmax(Y_pred,1), tf.argmax(Y_true,1))
  accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
  
  # Inicializamos variables
  init = tf.initializers.global_variables() #(X)
# Abrimos la sesión
  with tf.Session() as sess:
    sess.run(init) #(X)
    # Entrenamiento de nuestra red
    acc_epoch_tr = []
    acc_epoch_val = []
    loss_epoch_tr = []
    loss_epoch_val = []
    for epoch in range(n_epochs):
      avg_acc = 0.
      avg_loss = 0.
      steps = int(mnist.train.num_examples/batch_size) #(X) Calcular número de batches
      for i in range(steps):
        batch_X, batch_Y = mnist.train.next_batch(batch_size) #(X) # Pedir un nuevo batch del set de datos (emplear función next_batch)
        sess.run(train, feed_dict={X: batch_X, Y_true: batch_Y}) #(X) # Entrenamos 
        a,l = sess.run([accuracy, loss], feed_dict={X: batch_X, Y_true: batch_Y}) #(X) # Calculamos accuracy y cross_entropy del batch
        avg_acc += a / steps #(X) Calcular el accuracy medio de los diferentes batches
        avg_loss += l / steps #(X) Calcular las pérdidas medias de los diferentes batches
      # Almacenamos el accuracy y las losses medios para cada época
      acc_epoch_tr.append(avg_acc) #(X)
      loss_epoch_tr.append(avg_loss) #(X)
      # Calculamos accuracy y losses en validation
      a_val, l_val = sess.run([accuracy, loss], feed_dict={X: mnist.validation.images, Y_true: mnist.validation.labels}) #(X)
      acc_epoch_val.append(a_val) #(X)
      loss_epoch_val.append(l_val) #(X)
      # Sacamos información por pantalla
      print("[INFO]: Época {} ---> Acc_train = {} - Loss_train = {} - Acc_val = {} - Loss_val = {}".format(epoch, avg_acc, avg_loss, a_val, l_val)) #(X)

    # Cálculo de accuracy y losses en el conjunto de test
    a_test, l_test = sess.run([accuracy, loss], feed_dict={X: mnist.test.images, Y_true: mnist.test.labels}) #(X)
    print("[INFO]: Accuracy en test = {} - Losses en test = {}".format(a_test, l_test)) #(X)
# Gráficar losses por época
    plt.plot(np.arange(0, n_epochs), loss_epoch_tr) #(X)
    plt.plot(np.arange(0, n_epochs), loss_epoch_val)
    plt.legend(['train', 'val'], loc='upper left')
    plt.title('Training Loss') #(X)
    plt.xlabel('Epoch #') #(X)
    plt.ylabel('Loss') #(X)
    
b_size = 128
n_epochs = 50
lr = 0.005
act_function = tf.nn.relu
#optimizer = tf.train.GradientDescentOptimizer
optimizer = tf.train.AdamOptimizer
train_deep_net(lr, b_size, n_epochs, act_function, optimizer)

Espero que lleves a cabo este fantástico ejercicio de redes neuronales profundas y practiques por tu cuenta para comprender el Deep Learning.

Con el Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp tendrás un acompañamiento acertado por parte de grandes profesionales junto a una serie de módulos que te prepararán para adentrarte en el universo del Big Data.

Además, tendrás la oportunidad de aprender en remoto y en directo y obtendrás acceso a una variedad de webinars, cursos y material extra que te convertirán en todo un experto en el medio de los macrodatos. ¡Apúntate ya!