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

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

14/28
Recursos

Cuando entrenamos nuestros modelos requerimos de monitorear su desempe帽o durante el entrenamiento, esto nos dar谩 tiempo de reacci贸n para entender por qu茅 rinden como rinden. En esta ocasi贸n manejaremos callbacks personalizados para monitorear el desempe帽o de nuestra red en t茅rminos de precisi贸n y p茅rdida.

Aplicando callbacks a nuestro modelo

Para esta ocasi贸n crearemos un modelo llamado model_callbacks, virtualmente ser谩 id茅ntico al 煤ltimo modelo trabajado, pero cambiaremos levemente el comportamiento del entrenamiento cuando sea llamado.

```python model_callback = tf.keras.models.Sequential([ tf.keras.layers.Conv2D(75, (3,3), activation = "relu", input_shape = (28, 28, 1)), tf.keras.layers.MaxPool2D((2,2)), tf.keras.layers.Flatten(), tf.keras.layers.Dense(256, kernel_regularizer = regularizers.l2(1e-5), activation = "relu"), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(128, kernel_regularizer = regularizers.l2(1e-5), activation = "relu"), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(len(classes), activation = "softmax") ])

model_callback.summary()

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

Crearemos nuestro propio callback desde la clase Callback que nos ofrece Keras.

Podemos activar un callback en cualquier momento del ciclo de vida del modelo, para esta ocasi贸n podemos elegir si activarlo al inicio de cada 茅poca, durante el entrenamiento o al final, para esta ocasi贸n elegiremos el 煤ltimo caso.

Crearemos nuestra clase TrainingCallback que heredar谩 de Callback, definiremos la funci贸n on_epoch_end que se activar谩 cada que termine una 茅poca y recibir谩 como par谩metros el objeto mismo, la 茅poca y los logs (que contendr谩n las m茅tricas de la red).

Obtenemos la precisi贸n de los logs y la comparamos, para esta ocasi贸n determinaremos que el modelo se detenga si es mayor a 95% o 0.95, si es as铆, entonces daremos un peque帽o mensaje pantalla y setearemos la variable self.model.stop_training en verdadero para detenerlo prematuramente.

```python from tensorflow.keras.callbacks import Callback

class TrainingCallback(Callback): def on_epoch_end(self, epoch, logs = {}): if logs.get("accuracy") > 0.95: print("Lo logramos, nuestro modelo llego a 95%, detenemos nuestro modelo") self.model.stop_training = True ```

Para hacer efectivo este callback, creamos una instancia y lo inyectamos al momento de entrenar el modelo en el par谩metro de callbacks, puedes notar que recibe una lista, por lo que puedes agregar cuantos quieras.

```python callback = TrainingCallback()

history_callback = model_callback.fit( train_generator, epochs = 20, callbacks = [callback], validation_data = validation_generator ) ```

El entrenamiento empezar谩, y al cumplirse la condici贸n el entrenamiento se detendr谩 prematuramente.

python Epoch 3/20 215/215 [==============================] - ETA: 0s - loss: 0.1442 - accuracy: 0.9673Lo logramos, nuestro modelo llego a 95%, detenemos nuestro modelo 215/215 [==============================] - 46s 213ms/step - loss: 0.1442 - accuracy: 0.9673 - val_loss: 0.5947 - val_accuracy: 0.8428

Personalizando callbacks

Puedes personalizar tus propios callbacks que podr谩s usar en diferentes etapas (entrenamiento, testing y predicci贸n), para este ejemplo mostraremos en pantalla un mensaje seg煤n el inicio de cada etapa del entrenamiento.

```python from tensorflow.keras.callbacks import Callback

class TrainingCallback(Callback): def on_train_begin(self, logs=None): print('Starting training....')

def on_epoch_begin(self, epoch, logs=None): print('Starting epoch {}'.format(epoch))

def on_train_batch_begin(self, batch, logs=None): print('Training: Starting batch {}'.format(batch))

def on_train_batch_end(self, batch, logs=None): print('Training: Finished batch {}'.format(batch))

def on_epoch_end(self, epoch, logs=None): print('Finished epoch {}'.format(epoch))

def on_train_end(self, logs=None): print('Finished training!') ``` En la secci贸n de recursos puedes encontrar ejemplos para los casos de test y predicci贸n, adem谩s de documentaci贸n al respecto.

Contribuci贸n creada por Sebasti谩n Franco G贸mez.

Aportes 4

Preguntas 1

Ordenar por:

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

una lectura que complementa bien la clase, sobre todo para personalizar los callbacks

https://www.tensorflow.org/guide/keras/custom_callback?hl=es-419

Los Callbacks son 煤tiles para tener visibilidad de los estados internos y las estad铆sticas del modelo durante el entrenamiento.

La gran ventaja, es que se puede visualizar informaci贸n en puntos espec铆ficos indicados, y entender que est谩 pasando con el rendimiento del modelo.

M茅tricas clave para la evaluaci贸n de modelos mediante devoluciones de llamada:

P茅rdida

La funci贸n de p茅rdida mide el error entre las predicciones del modelo y los valores objetivo verdaderos.
Una p茅rdida menor indica un mejor rendimiento.
Las funciones de p茅rdida comunes incluyen el error cuadr谩tico medio (MSE) para tareas de regresi贸n y la entrop铆a cruzada categ贸rica para tareas de clasificaci贸n.


Exactitud

La precisi贸n mide la proporci贸n de predicciones clasificadas correctamente.
Es una m茅trica simple e intuitiva para tareas de clasificaci贸n.
Sin embargo, puede resultar enga帽oso para conjuntos de datos desequilibrados, donde el modelo puede priorizar la predicci贸n de la clase mayoritaria incluso si tiene un desempe帽o deficiente en la clase minoritaria.


Precisi贸n

La precisi贸n mide la proporci贸n de predicciones positivas que realmente son correctas.
Es particularmente 煤til para tareas donde los falsos positivos tienen costos elevados.


Recordar

La recuperaci贸n mide la proporci贸n de casos positivos reales que el modelo identifica correctamente.
Es importante para tareas en las que pasar por alto los verdaderos aspectos positivos puede tener consecuencias importantes.


Puntuaci贸n F1

La puntuaci贸n F1 es una m茅trica equilibrada que considera tanto la precisi贸n como la recuperaci贸n.
Se calcula como la media arm贸nica de precisi贸n y recuperaci贸n.
Una puntuaci贸n F1 m谩s alta indica un mejor rendimiento general entre precisi贸n y recuperaci贸n.


AUC (脕rea bajo la curva ROC)

El AUC mide la capacidad del modelo para distinguir entre casos positivos y negativos en todos los umbrales posibles.
Es una m茅trica independiente del umbral que proporciona una evaluaci贸n m谩s completa de la capacidad de discriminaci贸n del modelo.

from tensorflow.keras.callbacks import Callback

OPCION 1

Se va mejorando el accuracy, si despues de 1 epochs (patience=1) no mejora, se detiene
Es decir, cuando detecta deterioro se detiene

early = tf.keras.callbacks.EarlyStopping(monitor=鈥榓ccuracy鈥,patience=1)

model.fit(train_images,
train_labels,
batch_size=64,
callbacks=[early],
epochs=10)

OPCION 2

En el archivo mi_modelo.hdf5 guardara los mejores pesos del modelo

checkpoint = tf.keras.callbacks.ModelCheckpoint(filepath=鈥榤ejor_modelo.hdf5鈥,
verbose=1,
monitor=鈥榓ccuracy鈥,
save_best_only=True)

hist = model.fit(datagen.flow(x_train, y_train, batch_size=128),
callbacks=[chekcpoint],
steps_per_epoch=x_train.shape[0] // 128,
epochs=20,
verbose=2,
shuffle=True, #??
validation_data=(x_valid, y_valid) # <-
)

#tiene el mejor modelo

model2 = model
model2.load_weights(鈥./mejor_modelo.hdf5鈥)
model2.evaluate(test_image, test_labels)
Error, Accuracy

Resumen, tomo archivo hdf5 cuando tuve los mejores pesos
Y luego lo cargo, y verifico su error y su accuracy

OPCION 3

from tensorflow.keras.callbacks import Callback

class TrainingCallback(Callback):
def on_epoch_end(self, epoch, logs = {}):
if logs.get(鈥渁ccuracy鈥) > 0.90:
print("Modelo llego a 95%, STOP "+str(epoch))
self.model.stop_training = True

callback = TrainingCallback()

history=model.fit(train_images,
train_labels,
batch_size=64,
callbacks = [callback],
epochs=40)