Ejemplo de una función de activación en Deep Learning

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

Considerar cómo se comporta una función de activación en Deep Learning es de gran importancia, puesto que este es uno de los cálculos más importantes dentro del manejo de los macrodatos en Deep Learning. Por este motivo, en este post, te exponemos un ejemplo de una función de activación en Deep Learning.

Ejemplo de una función de activación en Deep Learning

Tanh es un claro ejemplo de una función de activación, puesto que esta forma parte de las principales alternativas y de las más usadas, junto a Sigmoid, ReLU, Leaky ReLU, Maxout y ELU.

Por ello, en el desarrollo de este post, te expondremos cómo se comportan Tanh como un ejemplo de una función de activación en Deep Learning.

Ejemplo de una función de activación en Deep Learning 1
# probamos la tanh
activation_function = tf.nn.tanh
learning_rate = 0.1
lr_decay = 1e-3
n_epochs = 10
batch_size = 128
train_network_decay_fnact(activation_function, learning_rate, lr_decay, batch_size, n_epochs)

0] cost: nan lr: 0.0999
[1] cost: nan lr: 0.0998001
[2] cost: nan lr: 0.0997002999
[3] cost: nan lr: 0.0996005996001
[4] cost: nan lr: 0.0995009990004999
[5] cost: nan lr: 0.0994014980014994
[6] cost: nan lr: 0.0993020965034979
[7] cost: nan lr: 0.09920279440699441
[8] cost: nan lr: 0.09910359161258742
[9] cost: nan lr: 0.09900448802097483
¡Entrenamiento finalizado!
Accuracy: 0.098

Ejemplo de una función de activación en Deep Learning 2

Ahora probemos a cambiar la inicialización de la bias, en vez de a 0s, a 1s.

# definimos la función para entrenar nuestra red con los parámetros deseados
def train_network_decay_fnact_b1(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.ones([10]))

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

  # ahora, definimos nuestra función de pérdidas: la cros-entropía
  # a veces la llaman loss, a veces 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 vez de actualizar los pesos para cada imagen, podríamos
          # 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
              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")
# probamos la tanh y bias 1 en vez de 0

activation_function = tf.nn.tanh
learning_rate = 0.1
lr_decay = 1e-3
n_epochs = 10
batch_size = 128
train_network_decay_fnact_b1(activation_function, learning_rate, lr_decay, batch_size, n_epochs)

[0] cost: 0.008607449590462947 lr: 0.06510201771893982
[1] cost: 0.0015046053062929034 lr: 0.04238272711077151
[2] cost: 0.0009448280053795052 lr: 0.02759201051342441
[3] cost: 0.000697504240373097 lr: 0.017962955573461316
[4] cost: 0.0005533601562242894 lr: 0.011694246520280062
[5] cost: 0.0004660144618832847 lr: 0.007613190441729219
[6] cost: 0.000399490859357332 lr: 0.004956340590351182
[7] cost: 0.00035307134551431404 lr: 0.003226677729341426
[8] cost: 0.00031454832165416305 lr: 0.0021006323070889344
[9] cost: 0.00028564449004060433 lr: 0.001367554016770813
Entrenamiento finalizado!!
Accuracy: 0.6698

Ejemplo de una función de activación en Deep Learning 3

¿Cuál es el siguiente paso Big Data?

En este post, te hemos expuesto un ejemplo de una función de activación en Deep Learning por medio sus alternativas más importantes, Tanh, para observar cómo se comporta. Sin embargo, sabemos que este proceso requiere de muchos más procesos para el desarrollo óptimo del Deep Learning como parte fundamental del manejo de los macrodatos, por lo que te animamos a continuar con tu proceso de aprendizaje.

Para facilitarte este proceso de formación, desde KeepCoding te brindamos el Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning, en el que aprenderás acerca del proceso de ingesta, clasificación, resguardo, procesamiento y presentación de los macrodatos gracias al uso de diferentes herramientas, lenguajes y sistemas. Podrás completarlo en menos de nueve meses y, entonces, ya serás capaz de reconocer las ventajas e inconvenientes de los distintos programas estudiados. ¡Echa un vistazo a nuestro temario e inscríbete 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!