El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Despliegue de Modelos

Siguiente ►
►

El despliegue de modelos es una etapa crucial en el ciclo de vida de un modelo de aprendizaje automático. Una vez que se ha entrenado y evaluado un modelo, el siguiente paso es ponerlo en producción para que pueda ser utilizado en aplicaciones del mundo real. En esta sección, aprenderemos cómo desplegar modelos de TensorFlow utilizando diferentes técnicas y herramientas.

Contenido

  1. Introducción al Despliegue de Modelos
  2. Guardado del Modelo
  3. Cargando el Modelo Guardado
  4. Despliegue con TensorFlow Serving
  5. Despliegue en la Nube
  6. Ejercicio Práctico
  7. Conclusión

Introducción al Despliegue de Modelos

El despliegue de modelos implica varias etapas, desde el guardado del modelo entrenado hasta su integración en una aplicación de producción. Aquí hay algunos conceptos clave:

  • Guardado del Modelo: Almacenar el modelo entrenado en un formato que pueda ser fácilmente cargado y utilizado en producción.
  • Cargando el Modelo: Recuperar el modelo guardado para realizar predicciones.
  • TensorFlow Serving: Una herramienta que facilita el despliegue de modelos de TensorFlow en un entorno de producción.
  • Despliegue en la Nube: Utilizar servicios en la nube para alojar y servir modelos de aprendizaje automático.

Guardado del Modelo

TensorFlow proporciona varias formas de guardar modelos. La más común es utilizar el formato SavedModel, que es el formato estándar para guardar modelos en TensorFlow.

Ejemplo de Guardado de un Modelo

import tensorflow as tf

# Definir un modelo simple
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compilar el modelo
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Entrenar el modelo (usando datos ficticios)
model.fit(x_train, y_train, epochs=5)

# Guardar el modelo
model.save('path_to_my_model')

En este ejemplo, hemos definido y entrenado un modelo simple, y luego lo hemos guardado en el directorio path_to_my_model.

Cargando el Modelo Guardado

Una vez que el modelo ha sido guardado, podemos cargarlo fácilmente para realizar predicciones.

Ejemplo de Carga de un Modelo

# Cargar el modelo
new_model = tf.keras.models.load_model('path_to_my_model')

# Realizar predicciones
predictions = new_model.predict(x_test)

En este ejemplo, hemos cargado el modelo guardado y lo hemos utilizado para realizar predicciones en un conjunto de datos de prueba.

Despliegue con TensorFlow Serving

TensorFlow Serving es una herramienta flexible y de alto rendimiento para servir modelos de aprendizaje automático en producción. Permite servir modelos de TensorFlow y realizar inferencias en tiempo real.

Instalación de TensorFlow Serving

Para instalar TensorFlow Serving, puedes seguir las instrucciones oficiales en la documentación de TensorFlow Serving.

Ejemplo de Despliegue con TensorFlow Serving

  1. Guardar el modelo en el formato SavedModel (ya cubierto anteriormente).
  2. Iniciar TensorFlow Serving:
tensorflow_model_server --rest_api_port=8501 --model_name=my_model --model_base_path="/path_to_my_model"
  1. Realizar una solicitud de predicción:
import requests
import json

# Datos de entrada para la predicción
data = json.dumps({"signature_name": "serving_default", "instances": x_test.tolist()})

# Realizar la solicitud POST
headers = {"content-type": "application/json"}
json_response = requests.post('http://localhost:8501/v1/models/my_model:predict', data=data, headers=headers)

# Obtener las predicciones
predictions = json.loads(json_response.text)['predictions']

En este ejemplo, hemos iniciado TensorFlow Serving para servir nuestro modelo y luego hemos realizado una solicitud de predicción utilizando la API REST.

Despliegue en la Nube

Desplegar modelos en la nube permite escalar y gestionar modelos de manera eficiente. Servicios como Google Cloud AI Platform, AWS SageMaker y Azure Machine Learning proporcionan soluciones robustas para el despliegue de modelos.

Ejemplo de Despliegue en Google Cloud AI Platform

  1. Subir el modelo a Google Cloud Storage:
gsutil cp -r path_to_my_model gs://my_bucket/path_to_my_model
  1. Desplegar el modelo en AI Platform:
gcloud ai-platform models create my_model
gcloud ai-platform versions create v1 --model=my_model --origin=gs://my_bucket/path_to_my_model --runtime-version=2.1 --python-version=3.7
  1. Realizar una solicitud de predicción:
from googleapiclient import discovery
import numpy as np

# Crear el cliente de AI Platform
service = discovery.build('ml', 'v1')

# Datos de entrada para la predicción
instances = x_test.tolist()

# Realizar la solicitud de predicción
name = 'projects/{}/models/{}/versions/{}'.format('my_project', 'my_model', 'v1')
response = service.projects().predict(name=name, body={'instances': instances}).execute()

# Obtener las predicciones
predictions = response['predictions']

En este ejemplo, hemos subido nuestro modelo a Google Cloud Storage, lo hemos desplegado en AI Platform y hemos realizado una solicitud de predicción.

Ejercicio Práctico

Ejercicio

  1. Entrena un modelo simple de TensorFlow utilizando el conjunto de datos MNIST.
  2. Guarda el modelo en el formato SavedModel.
  3. Inicia TensorFlow Serving para servir el modelo.
  4. Realiza una solicitud de predicción utilizando la API REST de TensorFlow Serving.

Solución

import tensorflow as tf
import requests
import json

# Cargar el conjunto de datos MNIST
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Definir y entrenar el modelo
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)

# Guardar el modelo
model.save('mnist_model')

# Iniciar TensorFlow Serving (en la terminal)
# tensorflow_model_server --rest_api_port=8501 --model_name=mnist_model --model_base_path="/path_to_mnist_model"

# Realizar una solicitud de predicción
data = json.dumps({"signature_name": "serving_default", "instances": x_test[:5].tolist()})
headers = {"content-type": "application/json"}
json_response = requests.post('http://localhost:8501/v1/models/mnist_model:predict', data=data, headers=headers)
predictions = json.loads(json_response.text)['predictions']

print(predictions)

Conclusión

En esta sección, hemos aprendido cómo desplegar modelos de TensorFlow utilizando diferentes técnicas y herramientas. Hemos cubierto el guardado y la carga de modelos, el despliegue con TensorFlow Serving y el despliegue en la nube. Además, hemos realizado un ejercicio práctico para reforzar los conceptos aprendidos. En la siguiente sección, exploraremos cómo monitorear y mantener modelos en producción.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados