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

Monitoreo del entrenamiento en tiempo real: early stopping y patience

16

KerasTuner: construyendo el modelo

17

KerasTuner: buscando la mejor configuraci贸n para tu modelo

Almacenamiento y carga de modelos

18

Almacenamiento y carga de modelos: pesos y arquitectura

19

Criterios para almacenar los modelos

Fundamentos de aprendizaje por transferencia

20

Introducci贸n al aprendizaje por transferencia

21

Cu谩ndo utilizar aprendizaje por transferencia

22

Carga de sistemas pre-entrenados en Keras

23

API funcional de Keras

24

Uso sistemas pre-entrenados de TensorFlow Hub

Resultados de entrenamiento

25

Introducci贸n a variables relevantes del TensorBoard

26

An谩lisis y publicaci贸n de resultados del entrenamiento

27

Introducci贸n al despliegue de modelos en producci贸n

28

Siguientes pasos con deep learning

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende Ingl茅s, Programaci贸n, AI, Ciberseguridad y m谩s a precio especial.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

1 D铆as
23 Hrs
54 Min
39 Seg

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

11/28
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 primer capa ser谩 de entrada, donde recibiremos una imagen de 28x28 pixeles en un solo canal, una vez recibida ser谩 aplanada para ser procesada como un array unidimensional.

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.

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

```python 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.

```python 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.

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

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

```python 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.

python visualizacion_resultados(history)

Rendimiento de la primer 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 13

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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 馃槂

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.

El sobreajuste es un problema com煤n en el aprendizaje autom谩tico, particularmente cuando se entrenan redes neuronales, donde el modelo aprende demasiado bien los datos de entrenamiento pero no logra generalizar de manera efectiva a datos invisibles.

  • Los resultados del modelo muetran una claro ploblema de sobreajuste
Trabajando con el dataset de **tumores cerebrales** se obtienen los siguientes resultados:![](https://static.platzi.com/media/user_upload/image-700552fd-40d3-46ba-92b1-127b1e3858e5.jpg) 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, se ha logrado una accuracy de 0.9209 y un loss 0.5740


Tomando en cuenta el curso de fundamentos de redes neuronales, realic茅 un dropout del 40% para mejorar el overffiting presentado en las gr谩ficas. Vale la pena decir que se puede mejorar
C贸digo:

#Implementar modelo y creaci贸n de capas
model_base = tf.keras.models.Sequential([#La capa siguiente depende de la anterior
    tf.keras.layers.Flatten(input_shape=(28,28,1)),                   
    tf.keras.layers.Dense(256,activation = "relu"),
    tf.keras.layers.Dropout(0.40),                                          
    tf.keras.layers.Dense(128,activation = "relu"),                                    
    tf.keras.layers.Dense(len(classes),activation = "softmax") 

])
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 ??