¿Qué es una función de activación en Deep Learning?

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

Una función de activación en Deep Learning es un conocimiento esencial para el desarrollo del manejo Big Data con redes neuronales. Por ello, en este post, te explicamos en detalle qué es una función de activación en Deep Learning.

¿Qué es una función de activación en Deep Learning?

En primer lugar, debes contar con que la magia de las redes neuronales no es solo el back-propagation. Sin las funciones de activación, las redes neuronales no funcionarían.

¿Qué pasaría si no existiese la función de activación?

¿Qué es una función de activación en Deep Learning? 1

Tendríamos que y(x)=Wx+b. Esto es una combinación lineal que sería incapaz incluso de resolver un problema como el XOR.

¿Qué es una función de activación en Deep Learning? 2

Por lo tanto, necesitamos una forma de introducir no linealidades, y de eso es de lo que se encarga la función de activación. En la siguiente imagen puedes ver algunas de las más típicas y dónde interviene en la red:

¿Qué es una función de activación en Deep Learning? 3

Aquí también puedes ver las más usadas:

¿Qué es una función de activación en Deep Learning? 4

Es difícil saber con cuál de ellas nuestra red se va a comportar mejor, pero existe una que suele dar buenos resultados casi siempre: la ReLU.

Por lo tanto, al empezar, siempre emplearemos la ReLU y, una vez consigamos unos resultados que consideremos buenos, podemos probar con la Leaky ReLU o cualquier otra que te apetezca. Cada día salen nuevas y una simple búsqueda en Google te puede llevar a alguna interesante, como la SELU, por ejemplo.

Muchas de estas funciones de activación necesitan métodos específicos de inicialización de pesos, para que estén dentro de unos valores y que el descenso del gradiente funcione adecuadamente.

Veamos qué es lo que pasa si empleamos diferentes funciones de activación con nuestra ya conocida red:

# Ejemplos de funciones de activación
# Para ello, primero hacemos los imports necesarios y, después, definimos una 
# función que creará y entrenará la red, teniendo como entrada la función de
# activación que queremos usar.

# 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)

Extracting /tmp/data/train-images-idx3-ubyte.gz
Extracting /tmp/data/train-labels-idx1-ubyte.gz
Extracting /tmp/data/t10k-images-idx3-ubyte.gz
Extracting /tmp/data/t10k-labels-idx1-ubyte.gz

# definimos la función para entrenar nuestra red con los parámetros deseados
def train_network_decay_fnact(activation_function, learning_rate, lr_decay, 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
  
  # 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 = activation_function(tf.matmul(x, W) + b)

  # ahora, definimos nuestra función de pérdidas: cros-entropía
  # a veces se llama loss y otras 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
  # e implementamos el learning rate decay
  new_W = W.assign(W - learning_rate * (1-lr_decay) * grad_W)
new_b = b.assign(b - learning_rate * (1-lr_decay) * grad_b)
 # inicializamos las variables
  init = tf.global_variables_initializer()
  
  # para almacenar el histórico de costes
  costs = []
  # inicializamos current_lr
  current_lr = learning_rate
  # 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, ¿si lo hacemos
          # 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
              Wc, bc, 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
              
          # actualizamos el learning_rate igual que lo hace tensorflow
          current_lr = current_lr * (1-lr_decay)

          # guardamos nuestro coste en el histórico
          costs.append(avg_cost)
          
          # Imprimimos las iteraciones
          # current_lr = learning_rate * (1-lr_decay) ** (epoch * batch_size + i)
          print("[{}] cost: {} lr: {}".format(epoch, avg_cost, current_lr))

      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")

Conoce más del manejo del Big Data

En este post, te hemos explicado qué es una función de activación en Deep Learning, sin embargo, como sabemos que aún queda más por aprender, te presentamos nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning. Gracias a él, aprenderás todo lo necesario sobre el Setup del entorno de programación (máquinas virtuales preconfiguradas) mientras trabajas con Spark a partir de la base (procesos de información textual), conteo de palabras, listas top N, operaciones con conjuntos… ¡Apúntate ahora y no esperes más para empezar!

👉 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!