Crea y entrena tu primera red neuronal convolucional con Tensor Flow

para los que trabajan con jupyter note hay que cambiar tf.train.AdamOptimizer() por tf.optimizers.Adam()

Explicacion del funcionamiento de las capas que usamos.

La primera capa de esta red, tf.keras.layers.Flatten, transforma el formato de las imagenes de un arreglo bi-dimensional (de 28 por 28 pixeles) a un arreglo uni dimensional (de 28*28 pixeles = 784 pixeles). Observe esta capa como una capa no apilada de filas de pixeles en la misma imagen y alineandolo. Esta capa no tiene parametros que aprender; solo reformatea el set de datos.

Despues de que los pixeles estan “aplanados”, la secuencia consiste de dos capastf.keras.layers.Dense. Estas estan densamente conectadas, o completamente conectadas. La primera capa Dense tiene 128 nodos (o neuronas). La segunda (y ultima) capa es una capa de 10 nodos softmax que devuelve un arreglo de 10 probabilidades que suman a 1. Cada nodo contiene una calificacion que indica la probabilidad que la actual imagen pertenece a una de las 10 clases.

Estoy un poco decepcionado de este curso debido a que ya conozco un poco del tema y no estamos trabajando con una red neuronal convolucional, en la clase introductoria del módulo la profesora explicó algo sobre cómo realmente funciona una red convolucional y después en esta clase práctica implementa una red neuronal fully conected aún cunado el tema de la clase no sugiere eso, además la profesora no explica correctamente partes complejas y claves si queremos entender realmente el machine learning como los optimizadores (adam en este caso), cuando lo implementa dice (no recuerdo bien) q es debido a la complejidad de la red porque habían varias neuronas en la capa de salida (10 si no me equivoco ) me parece q es bastante pobre el curso sinceramente. Sin ánimos de ofender y con el mayor respeto expreso mi sentir. Gracias

Por si quedan dudas de los conceptos:
“Loss function —Esto mide que tan exacto es el modelo durante el entrenamiento. Quiere minimizar esta funcion para dirigir el modelo en la direccion adecuada.
Optimizer — Esto es como el modelo se actualiza basado en el set de datos que ve y la funcion de perdida.
Metrics — Se usan para monitorear los pasos de entrenamiento y de pruebas. El siguiente ejemplo usa accuracy (exactitud) , la fraccion de la imagenes que son correctamente clasificadas.”(TensorFlow)
https://www.tensorflow.org/tutorials/keras/classification

La arquitectura de red mostrada en clase no corresponde a una red neuronal convolucional, solo se muestran tres capas, la primera aplica el flatten necesario para las dos siguiente capas que realizan la siguiente operación:

output = activation(dot(input, kernel) + bias)

Que es la multiplicación de matrices típica de las capas lineales de una red neuronal.

Pensaba que en la siguiente clase irían a corregir lo dicho en esta o implementar la convolución con el fin de generar conclusiones a modo de comparativa, pero no. Por lo tanto no entiendo el motivo de explicar esto como redes neuronales convolucionales.

cuando escribí la línea 11,obtenía un error. El error decía que no existía AdamOptimizer(). Entonces cambié

tf.train.AdamOptimizer()

por

tf.compat.v1.train.AdamOptimizer()

y ya funcionó

A mi en el model.fit me hace el calculo sobre 1875 no sobre los 60000

Para los que pasen por aqui y no funcione la parte del compiler, está deprecado AdamOptimizer, usen este código:

model.compile(optimizer = tf.keras.optimizers.Adam(),
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

Para los que les da error en la linea siguiente:

model.compile(optimizer=tf.AdamOptimizer(), loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])

Deben cambiar lo siguiente, así funciona:

model.compile(optimizer = tf.keras.optimizers.Adam(), loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])

Por si tienen problemas con errores al llamar a las funciones, esto es debido a que en las actualizaciones de TensorFlow pudieron reubicar dichas funciones en otras secciones de la libreria.
Les comparto mi código, basado en la version 2.2.0 de TensorFlow

import tensorflow as tf
from tensorflow.keras.datasets import fashion_mnist
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.nn import relu, softmax

fashion = fashion_mnist

(train_set, train_labels), (test_set, test_labels) = fashion.load_data()

layers = [Flatten(input_shape=(28,28)),
          Dense(128, activation=relu),
          Dense(10, activation=softmax)]

model = Sequential(layers)

model.compile(optimizer=Adam(),
              loss='sparse_categorical_crossentropy', 
              metrics=['accuracy'])

model.fit(x=train_set, y=train_labels, epochs=5)

model.evaluate(x=test_set, y=test_labels)

model.predict(test_set)

model = keras.Sequential([
                          keras.layers.Flatten(input_shape=(28,28)),
                          keras.layers.Dense(128,activation = tf.nn.relu),
                          keras.layers.Dense(10,activation = tf.nn.softmax)])

model.compile(
    optimizer = tf.train.AdamOptimizer(),
    loss = 'sparse_categorical_crossentropy',
    metrics = ['accuracy']
)

model.fit(train_images,train_labels,epochs = 5)

test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Accuracy ', test_acc)

Me hace el entrenamiento con 1875, elementos, y el test con 313, no entiendo porque toma números tan pequeños

La funcion de activacion Relu, hace que cuando se le mete un valor menor a 0, devuelve 0 y cuando se le mete un valor mayor a 0, actua como una funcion lineal normal.
La funcion de activacion Softmax transforma los numeros reales, en una distribucion de probabilidad,por ejemplo, 0.3 T-Shirt, 0.5 Sandal y 0.9 Goat, ya que goat es la que tiene mayor probabilidad es la que va a quedar

Comparto un ejemplo de una verdadera red neuronal convolucional para la clasificación de imágenes: https://www.tensorflow.org/tutorials/images/cnn
El ejemplo de esta clase es un red neuronal tradicional, donde todas las neuronas de las capas de entrada y salida están conectadas con la capa oculta (tipo “dense”) de 128 neuronas.

Desde la creación del curso, el optimizador Adam, ha ido cambiando sintaxis, dejo ésta que es la que me funcionó en nov/2020:

model.compile(optimizer = tf.optimizers.Adam(), loss = ‘sparse_categorical_crossentropy’, metrics = [‘accuracy’])

Me salió este error al momento de calcular la precisión

ValueError                                Traceback (most recent call last)

<ipython-input-181-65aaef7d17de> in <module>()
----> 1 test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
      2 # print('Precisión: ', test_acc)

3 frames

/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/data_adapter.py in __init__(self, x, y, sample_weights, sample_weight_modes, batch_size, epochs, steps, shuffle, **kwargs)
    280             label, ", ".join(str(i.shape[0]) for i in nest.flatten(data)))
    281       msg += "Please provide data which shares the same first dimension."
--> 282       raise ValueError(msg)
    283     num_samples = num_samples.pop()
    284 

ValueError: Data cardinality is ambiguous:
  x sizes: 60000
  y sizes: 10000
Please provide data which shares the same first dimension.

Si quieren aprender el porque esta red no es convolucional y que si es una red convolucional les dejo este video que lo explica:
Redes Neuronales Convolucionales - Clasificación avanzada de imágenes con IA / ML (CNN)

model.compile(optimizer = tf.keras.optimizers.Adam(), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])

tf.train.AdamOptimizer() = tf.optimizers.Adam() por si acaso

tf.optimizers.Adam()

Con cada ejecución el Accuracy cambia.

• Configurar el modelo con las funciones de activación de las neuronas, y las capas de neuronas que deseamos.
• Compilar el modelo.
• Entrenar el modelo.
• Testear el accuracy del modelo con los datos de test.

Le di epochs=100

model.fit(train_images, train_labels, epochs = 100)

Y obtuve un accuracy de entrenamiento al 97%

Probé en el dataset de prueba, y obtuve una mejoría solo del 2%

10000/10000 [==============================] - 0s 35us/sample - loss: 0.8131 - acc: 0.8867
Accuracy 0.8867

Por otro lado, creo que epochs, es la cantidad de veces que entrenas al modelo

Quedo atentos a sus comentarios y conclusiones

Para los que luchan todavía con los conceptos de las redes neuronales como Loss function, optimizer, backpropagation, etc… les dejo el primer video de una serie donde se explica muy brevemente y con ejemplos didacticos. Link del video

Tensorflow se actualizó y muchos métodos cambiaron de nombre. La verdad es un complique que haya pasado eso. El caso es que buscan el error en gogole y casi siempre muestran como solucionarlo. Otro aporte que hago, es que también se puede escoger con cual versión de TF se va a trabajar en el notebook. así: %tensorflow_version 1.x
así los códigos anteriores corren.
Y esta es la nueva sintaxis para el optimizador: tf.optimizers.Adam()

**Dos dudas:
**
Epoch es proporcionan al Accuracy ¿A mayor nùmero de Epoch el Accuracy tendera a uno?

¿Existe un número óptimo de epochs o algún algoritmo para dar con este?

Quiza les sirve, quizas no.
Pero solucione lo del optimizer asi:

optimizer=tf.optimizers.Adam()```

Alguien sabe porque mi accuracy es menor (0.6) si el codigo es exactamente el mismo?
De antemano gracias