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 鈥渢raining鈥 y 鈥渧alidation鈥 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=[鈥榩ositivo鈥,鈥榥egativo鈥橾

tf.keras.layers .dense (len(classes) , activation =鈥榮igmoud鈥)

??? 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.