Seguramente habéis desarrollado lo que es una shallow-net. Ahora, a partir de dos capas ocultas en adelante, es cuando podemos hablar de redes neuronales profundas. En este post, te presentamos un ejercicio de redes neuronales profundas en Deep Learning.

Ejercicio de redes neuronales profundas

Vamos a realizar una nueva modificación en la función para este ejercicio de redes neuronales profundas (debemos definirla en una nueva celda con las modificaciones).

Concretamente, vamos a darle más profundidad a nuestra red añadiendo tres capas ocultas más, a parte de las que ya tenemos, es decir, nuestra deep net estará compuesta por la entrada, cuatro capas ocultas con 200, 100, 60 y 30 neuronas, respectivamente, y la capa de salida con las 10 neuronas. Además, vamos a hacer dos modificaciones más y vamos a extraer como parámetros de entrada a la función la capa de activación de las hidden layers y el optimizador.

Con estos cambios, el nuevo método del ejercicio de redes neuronales profundas tendrá la siguiente cabecera:

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

Te recomendamos copiar y pegar el código de la función anterior en una nueva celda, añade tres capas ocultas extras y modifica la función de activación y el optimizador según el parámetro de entrada a la función.

Tras haber realizado las modificaciones oportunas y disponiendo de la función train_deep_net, llama a dicho método pasándole como parámetros de entrada los siguientes valores: learning_rate = 0.005, batch_size = 128, num_epochs = 50, act_function = tf.nn.relu y optimizer = tf.train.AdamOptimizer.

¿Qué se puede observar de las curvas de pérdidas de training y validation? Se puede observar un claro patrón de overfitting. ¿Y a qué se debe dicho efecto? El modelo está sobreajustando los pesos a los datos de entrenamiento y su capacidad de generalización ante nuevas muestras de test se ve perjudicada.

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)

En el desarrollo de este post, te hemos presentado un ejercicio de redes neuronales profundas, ahora, te recomendamos que lo lleves a cabo y practiques por tu cuenta para comprender el Deep Learning de forma más profunda.

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!