Ejemplo de redes profundas en Deep Learning

Las redes profundas en Deep Learning son una parte muy compleja y de las más importantes para el manejo de los macrodatos en este amplio campo del procesamiento Big Data. De manera que conocer cómo se desarrollan es fundamental para un buen data scientist.

Por esta razón, en este artículo, te exponemos un gran ejemplo de redes profundas en Deep Learning para que puedas emplearlas en tu procesamiento de los macrodatos.

Redes profundas en Deep Learning

Una red neuronal en Deep Learning es el corazón de los algoritmos basados en el manejo de los macrodatos dentro del Deep Learning. De forma sencilla, una red neuronal no es más que un método de aproximación de funciones.

Ahora bien, las redes profundas en Deep Learning son las redes con más de tres capas, incluyendo la de entrada y la de salida, lo que se conoce como red de aprendizaje profundo.

Cuantas más capas, mayor es la capacidad de reconocer información más compleja. En este tipo de arquitecturas, cada neurona de la capa i se conecta con todas las neuronas de la capa i+1. Es decir, a las neuronas de una capa determinada solo se les permite conectarse a las neuronas de la siguiente capa.

Las capas que componen una red neuronal se conocen como capas densas o fully connected. Cuando las conexiones hacia detrás están permitidas, se llaman redes recurrentes.

Ejemplo de redes profundas en Deep Learning

A continuación, te compartimos un ejemplo de redes profundas en Deep Learning para que aprendas cómo funcionan en el procesamiento del Big Data:

%tensorflow_version 1.x

TensorFlow 1.x selected.

# ejemplos para ver dónde llegamos con 6000 épocas y un learning rate de 0.001

# para ello, primero hacemos los imports necesarios y, después, definimos una 
# función que creará y entrenará la red

# imports necesarios
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
# 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)


# definimos la función para entrenar nuestra red con los parámetros deseados
def train_network(learning_rate, batch_size, n_epochs):
  
  # creamos los contenedores para nuestras entradas y salidas
  x = tf.placeholder(tf.float32, [None, 784]) # imágenes del mnist: 28*28=784
  y = tf.placeholder(tf.float32, [None, 10]) # número indicando la clase 0-9 => 10 clases

  # y creamos las variables W y b para el entrenamiento
  W = tf.Variable(tf.zeros([784, 10]))
  b = tf.Variable(tf.zeros([10]))

  # por último, construimos el modelo
  pred = tf.nn.softmax(tf.matmul(x, W) + b)

  # ahora, definimos nuestra función de pérdidas: cros-entropía
  # se puede llamar loss o cost, es lo mismo
  cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1))
# calculamos los gradientes (gradient descent)
  grad_W, grad_b = tf.gradients(xs=[W, b], ys=cost)

  # definimos las operaciones para actualizar los pesos con los gradientes calculados
  # y el learning rate
  new_W = W.assign(W - learning_rate * grad_W)
  new_b = b.assign(b - learning_rate * grad_b)

  # inicializamos las variables
  init = tf.global_variables_initializer()
  
  # para almacenar el histórico de costes
  costs = []
  # empezamos la sesión
  with tf.Session() as sess:
      sess.run(init)

      # entrenamiento de nuestra red
      for epoch in range(n_epochs):
          avg_cost = 0.
          total_batch = int(mnist.train.num_examples/batch_size)

          # En lugar de actualizar los pesos para cada imagen, ¿podemos
          # hacerlo de X en X imágenes?
          for i in range(total_batch):
              batch_xs, batch_ys = mnist.train.next_batch(batch_size)

              # ejecutamos la optimización
              _, _, c = sess.run([new_W, new_b ,cost], feed_dict={x: batch_xs,
                                                         y: batch_ys})

              # calculamos el coste teniendo en cuenta los batches que hay
              avg_cost += c / total_batch

          # guardamos nuestro coste en el histórico
          costs.append(avg_cost)
          # Imprimimos las iteraciones
          print("[{}] cost: {}".format(epoch, avg_cost))

      print("Entrenamiento finalizado!!")

      # comprobamos lo que ha aprendido nuestra red
      correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))

      # calculamos el accuracy (precisión)
      accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
      print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))
      
  # veamos nuestra función de pérdidas con respecto a las épocas ejecutadas
  plt.plot(np.arange(0, n_epochs), costs)
  plt.title("Training Loss")
  plt.xlabel("Epoch #")
  plt.ylabel("Loss")

# vamos a probar con 10000 épocas, a ver a dónde llega
learning_rate = 0.00001
n_epochs = 10000
batch_size = 128
train_network(learning_rate, batch_size, n_epochs)

Aprende mucho más sobre el Big Data

En este post, te hemos presentado un ejemplo muy ilustrativo de las redes profundas en Deep Learning. Sin embargo, este tipo de conocimiento requiere de una práctica constante y disciplinada para conseguir el desarrollo adecuado de cada uno de los puntos necesarios. ¡Así que todavía falta mucho más por aprender!

Nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning te permitirá consolidar tus conocimientos y poner a prueba tus destrezas, entre otras muchas cosas, en el ámbito de transformaciones y acciones en Spark. En el transcurso de esta formación intensiva, aprenderás a utilizar sus métodos de inteligencia artificial, aprendizaje automático, estadística y sistemas de bases de datos. ¡No lo dudes más, matricúlate y empieza ahora!