Cómo utilizar TensorFlow 2.0 con Python

1

Redes neuronales con TensorFlow

2

Introducción a TensorFlow 2.0

Manejo y preprocesamiento de datos para redes neuronales

3

Uso de data pipelines

4

Cómo cargar bases de datos JSON

5

Cargar bases de datos CSV y BASE 64

6

Preprocesamiento y limpieza de datos

7

Keras datasets

8

Datasets generators

9

Aprende a buscar bases de datos para deep learning

10

Cómo distribuir los datos

11

Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

Optimización de precisión de modelos

12

Métodos de regularización: overfitting y underfitting

13

Recomendaciones prácticas para ajustar un modelo

14

Métricas para medir la eficiencia de un modelo: callback

15

KerasTuner: buscando la mejor configuración para tu modelo

16

KerasTuner: buscando la mejor configuración para tu modelo

17

Monitoreo del entrenamiento en tiempo real: early stopping y patience

18

KerasTuner: construyendo el modelo

19

KerasTuner: buscando la mejor configuración para tu modelo

20

KerasTuner: buscando la mejor configuración para tu modelo

21

KerasTuner: buscando la mejor configuración para tu modelo

Almacenamiento y carga de modelos

22

Almacenamiento y carga de modelos: pesos y arquitectura

23

Criterios para almacenar los modelos

Fundamentos de aprendizaje por transferencia

24

Introducción al aprendizaje por transferencia

25

Cuándo utilizar aprendizaje por transferencia

26

Carga de sistemas pre-entrenados en Keras

27

API funcional de Keras

28

Uso sistemas pre-entrenados de TensorFlow Hub

Resultados de entrenamiento

29

Introducción a variables relevantes del TensorBoard

30

Análisis y publicación de resultados del entrenamiento

31

Introducción al despliegue de modelos en producción

32

Siguientes pasos con deep learning

33

Comparte tu proyecto de detección de señas y certifícate

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

11/33
Recursos

Ya tenemos todas las configuraciones previas para programar nuestra red, lo siguiente será definir una arquitectura, compilar el modelo y revisar el rendimiento de la red.

Creando el modelo de red neuronal

Definiremos un modelo con la clase Sequential de Keras, esta nos permitirá apilar varias capas una encima de otra para lograr el efecto de aprendizaje profundo.

La primera capa será de entrada, donde recibiremos una imagen de 28x28 píxeles en un solo canal, una vez recibida será aplanada para ser procesada como un array unidimensional. En cambio, las siguientes 2 capas serán capas profundas con 256 y 128 neuronas respectivamente, y tendrán como función de activación la ReLU.

La capa de salida será una capa de 24 neuronas (una por cada posible clase) de activación Softmax que nos retornará un array con las probabilidades de cada letra.

model_base = tf.keras.models.Sequential(
    [tf.keras.layers.Flatten(input_shape = (28, 28, 1)),
    tf.keras.layers.Dense(256, activation = "relu"),
    tf.keras.layers.Dense(128, activation = "relu"),
    tf.keras.layers.Dense(len(classes), activation = "softmax")]
)

Si llamamos el método summary obtendremos un resumen de la arquitectura de la red.

model_base.summary()

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param 
=================================================================
 flatten_2 (Flatten)         (None, 784)               0         
                                                                 
 dense_5 (Dense)             (None, 256)               200960    
                                                                 
 dense_6 (Dense)             (None, 128)               32896     
                                                                 
 dense_7 (Dense)             (None, 24)                3096      
                                                                 
=================================================================
Total params: 236,952
Trainable params: 236,952
Non-trainable params: 0
_________________________________________________________________

Compilación y entrenamiento del modelo

Compilaremos el modelo definiendo un optimizador, para este caso determinamos adam, un algoritmo que permite actualizar automáticamente el learning rate según el desempeño de la red. Como función de pérdida aplicaremos categorical cross entropy y la métrica de éxito será la precisión.

Entrenaremos el modelo con el image generator de entrenamiento, durante 20 épocas y con los datos de validación.

model_base.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"])

history = model_base.fit(
    train_generator,
    epochs = 20,
    validation_data = validation_generator
)

En la época final tendremos una precisión casi total durante el entrenamiento pero un rendimiento diferente sobre los datos de validación.

Epoch 20/20
215/215 [==============================] - 6s 27ms/step - loss: 0.0101 - accuracy: 0.9999 - val_loss: 1.3020 - val_accuracy: 0.7572

Si evaluamos el modelo, nos encontraremos con una precisión del 76%, donde entrenamiento era casi absoluta.

results = model_base.evaluate(test_generator)
57/57 [==============================] - 2s 36ms/step - loss: 1.2101 - accuracy: 0.7616

Análisis del desempeño de la red

Para entender más gráficamente lo que sucedió, crearemos la función de visualización de resultados, que comparará el rendimiento del entrenamiento sobre el rendimiento de validación tanto términos de accuracy como de loss.

def visualizacion_resultados(history):
  epochs = [i for i in range(20)]
  fig, ax = plt.subplots(1, 2)
  train_acc = history.history["accuracy"]
  train_loss = history.history["loss"]
  val_acc = history.history["val_accuracy"]
  val_loss = history.history["val_loss"]
  fig.set_size_inches(16, 9)

  ax[0].plot(epochs, train_acc, "go-", label = "Train accuracy")
  ax[0].plot(epochs, val_acc, "ro-", label = "Validation accuracy")
  ax[0].set_title("Train and Val accuracy")
  ax[0].legend()
  ax[0].set_xlabel("Epochs")
  ax[0].set_ylabel("Accuracy")

  ax[1].plot(epochs, train_loss, "go-", label = "Train Loss")
  ax[1].plot(epochs, val_loss, "ro-", label = "Validation Loss")
  ax[1].set_title("Train and Val loss")
  ax[1].legend()
  ax[1].set_xlabel("Epochs")
  ax[1].set_ylabel("Loss")

  plt.show()

Si corremos la función obtendremos información valiosísima con respecto al comportamiento del modelo.

visualizacion_resultados(history)
Rendimiento de la primera red

Puedes notar una diferencia abrupta tanto en el accuracy como en el loss, en la etapa de entrenamiento la red aprendió óptimamente y redujo la pérdida de manera constante, mientras que en validación sufrió de un rápido estancamiento, esto puede ser señal de overfitting, donde la red calcó los ejemplos y no los patrones.

Contribución creada por Sebastián Franco Gómez.

Aportes 10

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Un claro caso de overfitting, Me esta encantado el curso, Gracias maestro

Para ahorrar tiempo:

def visualizacion_resultados(history):
  epochs = [i for i in range(20)]
  fig, ax = plt.subplots(1,2)
  train_acc = history.history["accuracy"]
  train_loss = history.history["loss"]
  val_acc = history.history["val_accuracy"]
  val_loss = history.history["val_loss"]
  fig.set_size_inches(16,9)

  ax[0].plot(epochs, train_acc, "go-",label = "Entrenamiento accuracy")
  ax[0].plot(epochs, val_acc, "ro-",label = "Validación accuracy")
  ax[0].set_title("Entrenamiento y validación accuracy")
  ax[0].legend()
  ax[0].set_xlabel("Epochs")
  ax[0].set_ylabel("Accuracy")

  ax[1].plot(epochs, train_loss, "go-",label = "Entrenamiento loss")
  ax[1].plot(epochs, val_loss, "ro-",label = "Validación loss")
  ax[1].set_title("Entrenamiento y validación loss")
  ax[1].legend()
  ax[1].set_xlabel("Epochs")
  ax[1].set_ylabel("Loss")

  plt.show() 

Para que ahorren tiempo

si, es un vivo ejemplo de overfitting, y el curso esta confirmando de forma mucho mas practica todo el background que se debe de tener en NN

cada vez se pone mejor el curso 😃

El número de parámetros es la cantidad de pesos sinápticos entre capas de la red neuronal. Se puede calcular multiplicando el número de neuronas en la capa anterior, por el número de neuronas en la capa actual. Además, hay que sumarle los pesos sinápticos de los bias de cada neurona. Entonces, al resultado de la multiplicación anterior, se le suma el número de neuronas de la capa actual.

El split de validación siempre debe salir de training, es por esto que solo existen las etiquetas “training” y “validation” para los subset.
*
En el dataset de señales, hay en total 27455 imágenes de train y 7172 de test.
*
Si saco el 0.2 de validación del dataset de training al final obtengo:
train: 21974
validation: 5481
test: 7172
Es decir, las imágenes de validación no se tienen en cuenta en el training.
*
Sin embargo, si saco el 0.2 de validación del dataset de testeo (como lo hizo el profesor), obtengo:
train: 27455
validation: 1425
test: 7172
Es decir, las imágenes que estoy usando en validación, son imágenes que luego uso en el test, ya que estas no son descontadas del otro generador sino copiadas.

Existe overfitting dado que el modelo se ajusto de sobremanera a los datos de entrenamiento y no generalizó para los datos de validación.

ejemplo si estoy trabajando en una clasificacion binaria donde haria dos elecciones es positivo o es negativo

seria algo asi
classes=[‘positivo’,‘negativo’]

tf.keras.layers .dense (len(classes) , activation =‘sigmoud’)

??? esta bn ??

Trabajando con el dataset de Malaria se obtienen los siguientes resultados:

Existe una buena relación entre la curva de entrenamiento y la curva de validación, se podría decir que el modelo se ha generalizado correctamente, aunque debemos tomar en cuenta que solamente se ha logrado una precisión de 0.72.