Ejemplo de redes profundas en Deep Learning

Autor: | Última modificación: 17 de agosto de 2022 | Tiempo de Lectura: 4 minutos
Temas en este post:

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")
Ejemplo de redes profundas en Deep Learning 1
# 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)
Ejemplo de redes profundas en Deep Learning 2
Ejemplo de redes profundas en Deep Learning 3
Ejemplo de redes profundas en Deep Learning 4
Ejemplo de redes profundas en Deep Learning 5
Ejemplo de redes profundas en Deep Learning 6
Ejemplo de redes profundas en Deep Learning 7
Ejemplo de redes profundas en Deep Learning 8
Ejemplo de redes profundas en Deep Learning 9
Ejemplo de redes profundas en Deep Learning 10
Ejemplo de redes profundas en Deep Learning 11
Ejemplo de redes profundas en Deep Learning 12
Ejemplo de redes profundas en Deep Learning 13
Ejemplo de redes profundas en Deep Learning 14
Ejemplo de redes profundas en Deep Learning 15
Ejemplo de redes profundas en Deep Learning 16
Ejemplo de redes profundas en Deep Learning 17
Ejemplo de redes profundas en Deep Learning 18
Ejemplo de redes profundas en Deep Learning 19
Ejemplo de redes profundas en Deep Learning 20
Ejemplo de redes profundas en Deep Learning 21
Ejemplo de redes profundas en Deep Learning 22

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!

👉 Descubre más del Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp ¡Descarga el temario!

👉 Prueba el Bootcamp Gratis por una Semana ¡Empieza ahora mismo!

👉 Conoce nuestros otros Bootcamps en Programación y Tecnología

[email protected]

¿Sabías que hay más de 5.000 vacantes para desarrolladores de Big Data sin cubrir en España? 

En KeepCoding llevamos desde 2012 guiando personas como tú a áreas de alta empleabilidad y alto potencial de crecimiento en IT con formación de máxima calidad.

 

Porque creemos que un buen trabajo es fuente de libertad, independencia, crecimiento y eso ¡cambia historias de vida!


¡Da el primer paso!