Distribución normal y uniforme de inicialización de pesos

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

La distribución normal y uniforme de inicialización de pesos es una de las alternativas para este tipo de análisis en el procesamiento del Big Data por medio del Deep Learning. De manera que, como buen data scientist, debes conocer a qué se dedica este tipo de opción para los problemas de los datos.

Por esta razón, en este post, te explicamos qué es la distribución normal y uniforme de inicialización de pesos en Deep Learning.

Distribución normal y uniforme de inicialización de pesos

La distribución normal y uniforme de inicialización de pesos es una de las formas de emplear este tipo de cálculo. De manera que inicializar los pesos usando una distribución uniforme en la que se definen un [upper_bound,lower_bound], todos los números dentro del rango tienen la misma probabilidad de ser escogidos.

Por ejemplo, para una distribución entre [−0.2,0.2]:

W = np.random.uniform(low=-0.2, high=0.2, size=(768, 10))

Con esta instrucción, inicializaremos la matriz de pesos W con valores extraídos del rango entre [−0.2,0.2], donde todos ellos tienen la misma probabilidad de ser extraídos.

También podemos hacerlo con una distribución normal o Gaussiana, la cual viene definida como: p(x)=12πσ2e−(x−μ)22σ2.

Distribución normal y uniforme de inicialización de pesos 1

Donde, como ya sabes:

  • μ es la media.
  • σ es la desviación estándar.
  • σ2 es la varianza.
Distribución normal y uniforme de inicialización de pesos 2

Así que podríamos inicializar nuestros pesos con una distribución normal con μ=0 y σ=0.2, por ejemplo, de la siguiente forma:

W = np.random.normal(0.0, 0.2, size=(768, 10))

Ejemplo de distribución normal truncada

Para que comprendas cómo funciona la distribución normal y uniforme de inicialización de pesos, te presentamos un breve ejemplo con un distribución normal truncada:

# definimos la función para entrenar nuestra red con los parámetros deseados
def train_network_decay_fnact_wNT_b1_mse(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
  
  # y creamos las variables W y b para el entrenamiento
  W = tf.Variable(tf.truncated_normal([784, 10], mean=0.0, stddev=1.0, dtype=tf.float32, seed=42, name=None))
  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: esta vez, 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))
  cost = tf.reduce_mean(tf.squared_difference(pred, y))

  # calculamos los gradientes o 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")
# probamos la tanh, weights = 1, bias = 1 y loss_fn = mse
activation_function = tf.nn.tanh
learning_rate = 0.1
lr_decay = 1e-3
n_epochs = 10
batch_size = 128
train_network_decay_fnact_wNT_b1_mse(activation_function, learning_rate, lr_decay, batch_size, n_epochs)
Distribución normal y uniforme de inicialización de pesos 3

¿Cuál es el siguiente paso?

Ahora que ya comprendes cómo funciona la distribución normal y uniforme de inicialización de pesos, te animamos a emplearla en tu procesamiento de los macrodatos con Deep Learning. Además, sabemos que aún queda mucho más por aprender.

Es por esto que nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning es ideal para que avances con tu formación. Con él, podrás contar con una serie de módulos que te pondrán en contexto con los desarrolladores y herramientas más importantes para el procesamiento de los macrodatos, como Machine Learning, Spark & Scala, Tableau, Hadoop, etc. Todo ello de forma tanto teórica como práctica y con el acompañamiento de grandes profesionales y expertos en el universo del Big Data. ¿A qué esperas 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!