Ejemplo de una red neuronal profunda en TensorFlow

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

Un ejemplo de una red neuronal profunda en TensorFlow te ayudará a comprender con más profundidad y desde la práctica cómo se implementan las redes neuronales profundas dentro del manejo de los macrodatos.

Por ello, en este post, te presentamos un ejemplo de una red neuronal profunda en TensorFlow.

Ejemplo de una red neuronal profunda en TensorFlow

A partir de dos capas ocultas en adelante es cuando podemos hablar de redes neuronales profundas. Ahora vamos a realizar una nueva modificación en nuestra función (debemos definirla en una nueva celda con las modificaciones).

Concretamente, para este ejemplo de una red neuronal profunda en TensorFlow vamos a darle más profundidad a nuestra red añadiendo tres capas ocultas más, además de las que ya tenemos; es decir, nuestra deep net estará compuesta por la entrada, cuatro capas ocultas con 200, 100, 60 y 30 neuronas, respectivamente, y la capa de salida con las 10 neuronas.

Además, vamos a hacer dos modificaciones más y vamos a extraer como parámetros de entrada a la función la capa de activación de las hidden layers y el optimizador. Con estos cambios, el nuevo método tendrá la siguiente cabecera:

def train_deep_net(learning_rate, batch_size, num_epochs, act_function, optimizer)

Para el ejemplo de una red neuronal profunda en TensorFlow, copia y pega el código de la función anterior en una nueva celda, añade tres capas ocultas extra y modifica la función de activación y el optimizador según el parámetro de entrada a la función.

def train_deep_net(learning_rate, batch_size, num_epochs, act_function, optimizer):
  # Creamos placeholders para almacenanar los datos de entrada y los labels
  X = tf.placeholder(tf.float32, [None, 784]) #(X) # Imágenes del mnist: 28*28 = 784
  Y_true = tf.placeholder(tf.float32, [None, 10]) #(X) # Número indicando la clase 0-9 => 10 clases

  # Creamos e inicializamos las variables W y b con valores aleatorios que sigan una distribución normal
  W1 = tf.Variable(tf.truncated_normal([784, 200], stddev=0.1)) #(X)
  B1 = tf.Variable(tf.zeros([200])) #(X)
  W2 = tf.Variable(tf.truncated_normal([200, 100], stddev=0.1)) #(X)
  B2 = tf.Variable(tf.zeros([100])) #(X)
  W3 = tf.Variable(tf.truncated_normal([100, 60], stddev=0.1)) #(X)
  B3 = tf.Variable(tf.zeros([60])) #(X)
  W4 = tf.Variable(tf.truncated_normal([60, 30], stddev=0.1)) #(X)
  B4 = tf.Variable(tf.zeros([30])) #(X)
  W5 = tf.Variable(tf.truncated_normal([30, 10], stddev=0.1)) #(X)
  B5 = tf.Variable(tf.zeros([10])) #(X)

  # Calculamos las predicciones
  Y1 = act_function(tf.matmul(X,W1) + B1) #(X)
  Y2 = act_function(tf.matmul(Y1,W2) + B2) #(X)
  Y3 = act_function(tf.matmul(Y2,W3) + B3) #(X)
  Y4 = act_function(tf.matmul(Y3,W4) + B4) #(X)
  Y_logits = tf.matmul(Y4,W5) + B5 
  Y_pred = tf.nn.softmax(Y_logits)

  # Ahora, en el ejemplo de una red neuronal profunda en TensorFlow definimos función de pérdidas (Cross_entropy)
  loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=Y_logits, labels=Y_true)) 
  #loss = tf.reduce_mean(-tf.reduce_sum(Y_true * tf.log(Y_pred), reduction_indices=1)) #(X)
  #loss = tf.reduce_mean(-tf.reduce_sum(Y_true*tf.log(Y_pred), reduction_indices=1))

  # Optimizador SGD
  train = optimizer(lr).minimize(loss) #(X)

  # % de predicciones correctas en un determinado batch (i.e. accuracy)
  is_correct = tf.equal(tf.argmax(Y_pred,1), tf.argmax(Y_true,1))
  accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
def train_deep_net(learning_rate, batch_size, num_epochs, act_function, optimizer):
  # Creamos placeholders para ir almacenando los datos de entrada y los labels
  X = tf.placeholder(tf.float32, [None, 784]) #(X) # Imágenes del mnist: 28*28 = 784
  Y_true = tf.placeholder(tf.float32, [None, 10]) #(X) # Número indicando la clase 0-9 => 10 clases

  # Creamos e inicializamos las variables W y b con valores aleatorios que sigan una distribución normal
  W1 = tf.Variable(tf.truncated_normal([784, 200], stddev=0.1)) #(X)
  B1 = tf.Variable(tf.zeros([200])) #(X)
  W2 = tf.Variable(tf.truncated_normal([200, 100], stddev=0.1)) #(X)
  B2 = tf.Variable(tf.zeros([100])) #(X)
  W3 = tf.Variable(tf.truncated_normal([100, 60], stddev=0.1)) #(X)
  B3 = tf.Variable(tf.zeros([60])) #(X)
  W4 = tf.Variable(tf.truncated_normal([60, 30], stddev=0.1)) #(X)
  B4 = tf.Variable(tf.zeros([30])) #(X)
  W5 = tf.Variable(tf.truncated_normal([30, 10], stddev=0.1)) #(X)
  B5 = tf.Variable(tf.zeros([10])) #(X)

  # Calculamos las predicciones del ejemplo de una red neuronal profunda en TensorFlow
  Y1 = act_function(tf.matmul(X,W1) + B1) #(X)
  Y2 = act_function(tf.matmul(Y1,W2) + B2) #(X)
  Y3 = act_function(tf.matmul(Y2,W3) + B3) #(X)
  Y4 = act_function(tf.matmul(Y3,W4) + B4) #(X)
  Y_logits = tf.matmul(Y4,W5) + B5 
  Y_pred = tf.nn.softmax(Y_logits)

  # Definimos función de pérdidas (Cross_entropy)
  loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=Y_logits, labels=Y_true)) 
  #loss = tf.reduce_mean(-tf.reduce_sum(Y_true * tf.log(Y_pred), reduction_indices=1)) #(X)
  #loss = tf.reduce_mean(-tf.reduce_sum(Y_true*tf.log(Y_pred), reduction_indices=1))

  # Optimizador SGD
  train = optimizer(lr).minimize(loss) #(X)

  # % de predicciones correctas en un determinado batch (i.e. accuracy)
  is_correct = tf.equal(tf.argmax(Y_pred,1), tf.argmax(Y_true,1))
  accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
 # Gráficar losses por época
    plt.plot(np.arange(0, n_epochs), loss_epoch_tr) #(X)
    plt.plot(np.arange(0, n_epochs), loss_epoch_val)
    plt.legend(['train', 'val'], loc='upper left')
    plt.title('Training Loss') #(X)
    plt.xlabel('Epoch #') #(X)
    plt.ylabel('Loss') #(X)
    
b_size = 128
n_epochs = 50
lr = 0.005
act_function = tf.nn.relu
#optimizer = tf.train.GradientDescentOptimizer
optimizer = tf.train.AdamOptimizer
train_deep_net(lr, b_size, n_epochs, act_function, optimizer)
Ejemplo de una red neuronal profunda en TensorFlow 1
Ejemplo de una red neuronal profunda en TensorFlow 2

¿Cuál es el siguiente paso?

En este post, te hemos expuesto un ejemplo de una red neuronal profunda en TensorFlow. Sin embargo, debes tener en cuenta que este proceso requiere de una gran constancia en el ensayo. Por ello, te animamos a seguir practicando. Si aún no sabes cómo, en KeepCoding te ofrecemos el Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning.

Por medio de esta formación de alta calidad, se te presentarán las teorías del aprendizaje automático con énfasis en algoritmos de regresión y clasificación. De manera que, con el tiempo, serás capaz de conocer las ventajas y desventajas de los distintos algoritmos analizados. Además, adquirirás experiencia gracias a que se fusionan los fundamentos con ejemplos prácticos y realistas para que puedas aplicarlos. ¡Pide información, inscríbete ahora y sigue aprendiendo!

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