Ejemplo de redes neuronales en Deep Learning

Contenido del Bootcamp Dirigido por: | Última modificación: 18 de abril de 2024 | Tiempo de Lectura: 4 minutos

Algunos de nuestros reconocimientos:

Premios KeepCoding

Si todo ha ido bien en el ejemplo propuesto en el post sobre las capas ocultas de las neuronas en Deep Learning, la perceptrón simple con TensorFlow será capaz de reconocer con una precisión en torno al 92% dígitos del 0 al 9 escritos a mano. Así que ahora, en este artículo, te exponemos un ejemplo de redes neuronales en Deep Learning.

Ejemplo de redes neuronales en Deep Learning

En primer lugar, hay que escribir:

# Imports necesarios
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

# Importamos el dataset MNIST y cargamos los datos
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)

A continuación, vamos a incluir una primera hidden layer o capa oculta de 200 neuronas al perceptrón simple que hemos desarrollado en el ejercicio anterior para descubrir el efecto de dar profundidad a nuestra red, creando ya un multilayer perceptron. Para ello, habrá que definir las variables (W1, B1) y (W2, B2) en TensorFlow y recalcular las predicciones como  Y^=softmax(Y1∗W2+B2) siendo Y1=sigmoid(X∗W1+B1).

Ejemplo de redes neuronales en Deep Learning

Para las redes neuronales en Deep Learning hay que tener en cuenta que, conforme le damos profundidad a la red, es importante inicializar los pesos (W1 y W2 en nuestro caso) con valores aleatorios siguiendo una distribución gaussiana. De otra forma, el optimizador puede quedarse atascado en la posición inicial y no ser capaz de moverse en la dirección del mínimo de la función de pérdidas. Por ello, utilizaremos la función de TensorFlow tf.truncated_normal, tal y como se indica en la documentación de TF.

Además, vamos a aprovechar este ejercicio para convertir nuestro código en una función cuya cabecera será la siguiente:

def train_shallow_net(learning_rate, batch_size, num_epochs)

Nota: Copia y pega el código anterior en una nueva celda y conviértelo en función. Posteriormente, añade la segunda capa oculta.

  1. Tras la modificación, se debe ejecutar la función train_shallow_net con sus parámetros de entrada tomando el valor del apartado anterior. ¿Qué sucede? No se percibe la influencia de hacer la red más profunda, puesto que el número de épocas es pequeño para ello.
  2. Ahora, lanza de nuevo el entrenamiento de nuestra shallow net, pero con un valor de n_epochs = 1000. ¿Qué sucede ahora? ¿Se aprecia la influencia de darle profundidad a la red? ¿Existe overfitting? Ahora sí se aprecia la mejora, concretamente obtenemos una precisión en torno al 97% SIN overfitting (esto es importantísimo).
def train_shallow_net(learning_rate, batch_size, num_epochs):
  # 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.reduce_sum(Y_true * tf.log(Y_pred), reduction_indices=1)) #(X)
  #loss = tf.reduce_mean(-tf.reduce_sum(Y_true*tf.log(Y_pred), reduction_indices=1))

  # Optimizador SGD
  train = tf.train.GradientDescentOptimizer(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)
    
# Lanzamos entrenamiento
lr = 0.005
b_size = 128
n_epochs = 1000
train_shallow_net(lr, b_size, n_epochs)

Conoce más sobre el Big Data

En este post, te hemos expuesto un breve ejemplo de redes neuronales en Deep Learning. Recuerda llevar a cabo cada uno de estos pasos para obtener un resultado efectivo.

Desde KeepCoding, te aconsejamos continuar aprendiendo sobre las herramientas Big Data como redes neuronales en Deep Learning, por lo que te ofrecemos nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning¡Échale un vistazo y apúntate!

¡CONVOCATORIA ABIERTA!

Big Data, IA & Machine Learning

Full Stack Bootcamp

Clases en Directo | Profesores en Activo | Temario 100% actualizado