Cómo utilizar TensorFlow 2.0 con Python
Redes neuronales con TensorFlow
Introducción a TensorFlow 2.0
Manejo y preprocesamiento de datos para redes neuronales
Uso de data pipelines
Cómo cargar bases de datos JSON
Cargar bases de datos CSV y BASE 64
Preprocesamiento y limpieza de datos
Keras datasets
Datasets generators
Aprende a buscar bases de datos para deep learning
Cómo distribuir los datos
Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones
Optimización de precisión de modelos
Métodos de regularización: overfitting y underfitting
Recomendaciones prácticas para ajustar un modelo
Métricas para medir la eficiencia de un modelo: callback
Monitoreo del entrenamiento en tiempo real: early stopping y patience
KerasTuner: construyendo el modelo
KerasTuner: buscando la mejor configuración para tu modelo
Almacenamiento y carga de modelos
Almacenamiento y carga de modelos: pesos y arquitectura
Criterios para almacenar los modelos
Fundamentos de aprendizaje por transferencia
Introducción al aprendizaje por transferencia
Cuándo utilizar aprendizaje por transferencia
Carga de sistemas pre-entrenados en Keras
API funcional de Keras
Uso sistemas pre-entrenados de TensorFlow Hub
Resultados de entrenamiento
Introducción a variables relevantes del TensorBoard
Análisis y publicación de resultados del entrenamiento
Introducción al despliegue de modelos en producción
Siguientes pasos con deep learning
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Uso sistemas pre-entrenados de TensorFlow Hub
24/28Para esta ocasión importaremos modelos desde TensorFlow Hub, una plataforma dedicada a la divulgación de configuraciones por parte de la comunidad.
Tensorflow Hub con Keras
Para usar el hub, debemos importarlo.
python
import tensorflow_hub as hub
Antes de todo, debemos detectar qué configuración usaremos, para esta ocasión usaremos la arquitectura MobileNetV1.
Este modelo es secuencial, por lo que stackearemos sus capas en un modelo de este tipo.
Para los modelos del hub, basta con agregar una capa de entrada, añadir la capa de KerasLayer con la URL del sitio (no olvides configurarlo como no entrenable) y a partir de este punto podrás inyectar tu propia arquitectura.
```python module_url = "https://tfhub.dev/google/imagenet/mobilenet_v1_050_160/classification/4"
model_hub = tf.keras.Sequential([ tf.keras.layers.InputLayer(input_shape = (150, 150, 3)), hub.KerasLayer(module_url, trainable = False), tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation = "relu"), tf.keras.layers.Dropout(rate = 0.2), tf.keras.layers.Dense(len(classes), activation = "softmax") ]) ```
Antes de compilar la red debemos hacer build al modelo, siendo explícitos en las dimensiones de su tensor, en este caso MobileNet soporta frames de video, por lo que para usarlo como detector de imágenes bastará con anular esta dimensión.
python
model_hub.build((None, 150, 150, 3))
model_hub.summary()
Podemos notar en la arquitectura que se añade toda la capa cargada y posteriormente nuestra arquitectura.
```python Model: "sequential"
Layer (type) Output Shape Param #
keras_layer_2 (KerasLayer) (None, 1001) 1343049
flatten_2 (Flatten) (None, 1001) 0
dense (Dense) (None, 128) 128256
dropout (Dropout) (None, 128) 0
dense_1 (Dense) (None, 24) 3096
================================================================= Total params: 1,474,401 Trainable params: 131,352 Non-trainable params: 1,343,049
```
El proceso de compilación y entrenamiento será el tradicional.
```python model_hub.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"])
history_hub = model_hub.fit( train_generator_resize, epochs = 5, validation_data = validation_generator_resize ) ```
Podemos notar que el rendimiento es menor al de Inception, pero en contraparte su tiempo de procesamiento es menor.
python
57/57 [==============================] - 5s 91ms/step - loss: 0.4389 - accuracy: 0.8461
Este tipo de modelos son útiles a la hora de procesar imágenes en vivo (como en cámaras de drones). Pero traen en consecuencias una pérdida de precisión, dependerá de tu proyecto aceptar estas alternativas o sacrificar tiempo de cómputo por mejores resultados.
Contribución creada por Sebastián Franco Gómez.
Aportes 4
Preguntas 3
Un codificador de Fraces
import tensorflow_hub as hub
embed = hub.load("https://tfhub.dev/google/universal-sentence-encoder/4")
embeddings = embed(["Hello world!", "How are you?"])
import tensorflow_hub as hub
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
# Cargar el modelo Universal Sentence Encoder
embed = hub.load("https://tfhub.dev/google/universal-sentence-encoder/4")
# Codificar frases en vectores de incrustación
sentences = ["Hello world!", "How are you?"]
embeddings = embed(sentences)
# Calcular similitud de coseno entre las frases
similarity_matrix = cosine_similarity(np.array(embeddings))
print(similarity_matrix)
para la instalacion de hub, si no la tienen
!pip install --upgrade tensorflow_hub
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?