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

API funcional de Keras

23/28
Recursos

Hasta ahora solo hemos usado explícitamente modelos secuenciales (donde las capas conectan directa y linealmente), para esta ocasión estamos manejando un modelo funcional, por lo que la conexión de capas debe ser explícita.

Conectando las nuevas capas

Anteriormente cortamos la configuración de InceptionV3 en el mixed7 para considerarlo nuestra última capa no entrenable.

python last_layers = pre_trained_model.get_layer("mixed7") last_output = last_layers.output

Ahora la conectaremos con nuestras capas personalizadas. Recuerda que como manejamos un modelo funcional, debemos expresar explícitamente desde cuál capa viene conectada, esto lo haremos con la notación de paréntesis al final de la definición de cada objeto.

Aplanaremos todos los datos desde una capa flatten, agregaremos una capa densa de 128 neuronas con activación relu y un dropout de 20%, finalmente definiremos la nueva salida con 24 neuronas de activación softmax (la configuración original trae 1000 posibles outputs pero podemos personalizarla a voluntad).

Con todas las capas conectadas, definiremos el modelo final con la clase Model de Keras, esta recibirá el inicio y el final del modelo.

```python x = tf.keras.layers.Flatten()(last_output) x = tf.keras.layers.Dense(128, activation = "relu")(x) x = tf.keras.layers.Dropout(0.2)(x) x = tf.keras.layers.Dense(len(classes), activation = "softmax")(x)

model_keras = tf.keras.Model(pre_trained_model.input, x)

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

Al compilar y resumir el modelo podemos notar que todas las capas después de mixed7 no existen, además de que la cantidad de parámetros bajó de casi 22 millones a casi 14, además solo 5 son entrenables (lo que reducirá la complejidad del modelo).

python Total params: 13,795,384 Trainable params: 4,820,120 Non-trainable params: 8,975,264

Entrenando el nuevo modelo

Entrenaremos el nuevo modelo con los nuevos generadores durante 5 épocas. Notarás que el entrenamiento durará mucho más tiempo pero no tendremos que crear las abstracciones del modelo desde 0.

python history_keras = model_keras.fit( train_generator_resize, epochs = 5, validation_data = validation_generator_resize )

Podemos notar que incluso después de la primer iteración el accuracy y val_accuracy mantuvieron un tiempo de entrenamiento excelente, donde en la épica final tuvimos una aproximación total en entrenamiento, una pérdida mínima y una precisión en validación del 98.95%.

```python Epoch 1/5 215/215 [==============================] - 37s 118ms/step - loss: 0.1648 - accuracy: 0.9545 - val_loss: 0.0509 - val_accuracy: 0.9832

Epoch 5/5 215/215 [==============================] - 24s 111ms/step - loss: 9.9922e-04 - accuracy: 0.9999 - val_loss: 0.0385 - val_accuracy: 0.9895 ```

Para corroborar los resultados de validación evaluaremos el modelo en el subset de pruebas.

```python model_keras.evaluate(test_generator_resize)

57/57 [==============================] - 7s 119ms/step - loss: 0.0463 - accuracy: 0.9865 [0.04633770138025284, 0.9864751696586609] ```

Obtuvimos una precisión de más del 98% en 8597 imágenes, un rendimiento más que aceptable para nuestro modelo.

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

Aportes 9

Preguntas 5

Ordenar por:

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

The gradient, que es una revista de inteligencia artificial, habla de que ya hay modelos muy potentes pero que que toman mucho su tiempo, por eso ya se habla de models Fundation, modelos pre entrenados que son pontentes para que sean llevados a otras areas de conocimiento

No había comentado en las clases anteriores, pero este curso está EXCELENTE!!!

¿Podría cortar el modelo en una capa diferente a un mixed? Por ejemplo cortarlo en un Conv2D.

Decidí usar un dataset para clasificar imágenes sísmicas (350 imagenes aprox en total). El mejor resultado de val_accuracy que obtuve fue de 0.62. Con Transfer Learning usando InceptionV3 llegó hasta 0.86 (usando la misma cantidad de épocas, 20). Que tema tan interesante

En paralelo estos siguiendo el proyecto de clasificación de tumores, hice uso del modelo NASNetLarge, pero al parecer necesito entender cómo aplicarlo mejor, ya que no logré mejorar el 60% de accuracy.

En mi caso, pase de tener un val\_accuracy de 71% a uno de 92% un cambio realmente sorprendente. 🤣
  • Definir el Modelo de Keras:
    Utiliza Keras para definir tu modelo de aprendizaje profundo. Puedes usar cualquier modelo que desees, como InceptionResNetV2, VGG16, etc.
    Agrega las capas necesarias para tu tarea específica, como capas de convolución, capas de agrupamiento, capas completamente conectadas

x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(512, activation='relu')(x)
x = Dropout(0.5)(x)
predictions = Dense(num_classes, activation='softmax')(x)

model = Model(inputs=base_model.input, outputs=predictions

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

model.fit(train_generator_resize, epochs=5, validation_data=validation_generator_resize)
Epoch 1/5
215/215 [==============================] - 373s 1s/step - loss: 0.2519 - accuracy: 0.9255 - val_loss: 1.8500 - val_accuracy: 0.4999
Epoch 2/5
215/215 [==============================] - 254s 1s/step - loss: 0.0531 - accuracy: 0.9865 - val_loss: 0.1807 - val_accuracy: 0.9487
Epoch 3/5
215/215 [==============================] - 254s 1s/step - loss: 0.0263 - accuracy: 0.9933 - val_loss: 0.0511 - val_accuracy: 0.9844
Epoch 4/5
215/215 [==============================] - 255s 1s/step - loss: 0.0286 - accuracy: 0.9933 - val_loss: 0.0912 - val_accuracy: 0.9835
Epoch 5/5
215/215 [==============================] - 252s 1s/step - loss: 0.0227 - accuracy: 0.9944 - val_loss: 10.7682 - val_accuracy: 0.6457
<keras.src.callbacks.History at 0x797e5e6367d0>

Esta clase es extremadamente util e interesante, aprendi demasiado :3

modelillo.evaluate(test\_generator) \[0.10160410404205322, 0.9761573076248169] gono