Cómo guardar un modelo entrenado en Python

Guardar un modelo entrenado en Python.

Cuando se trabaja en casos de uso de aprendizaje automático (ML) del mundo real, encontrar el mejor algoritmo/modelo no es el final de tus responsabilidades. Es crucial guardar, almacenar y empaquetar estos modelos para su uso futuro y su implementación en producción.

Estas prácticas son necesarias por diversas razones:

  • Respaldo: Un modelo entrenado puede guardarse como respaldo en caso de que los datos originales se dañen o se destruyan.
  • Reusabilidad y reproducibilidad: La construcción de modelos de ML lleva tiempo por naturaleza. Para ahorrar costos y tiempo, es esencial que tu modelo te brinde los mismos resultados cada vez que lo ejecutes. Guardar y almacenar tu modelo de la manera correcta se encarga de esto.
  • Implementación: Cuando se implementa un modelo entrenado en un entorno del mundo real, es necesario empaquetarlo para una implementación fácil. Esto permite que otros sistemas y aplicaciones utilicen el mismo modelo sin mucho problema.

Para reiterar, mientras que guardar y almacenar modelos de ML permite facilitar el intercambio, la reusabilidad y la reproducibilidad; empaquetar los modelos permite una implementación rápida y sin problemas. Estas 3 operaciones trabajan en armonía para simplificar todo el proceso de gestión de modelos.

En este artículo, aprenderás sobre diferentes métodos de guardar, almacenar y empaquetar un modelo de aprendizaje automático entrenado, junto con las ventajas y desventajas de cada método. Pero antes de eso, debes entender la distinción entre estos tres términos.

Guardar vs empaquetar vs almacenar modelos de ML

Aunque todos estos términos parecen similares, no son lo mismo.

Guardar vs Almacenar vs Empaquetar Modelos de ML | Fuente: Autor

Guardar un modelo se refiere al proceso de guardar los parámetros, pesos, etc. del modelo en un archivo. Por lo general, todos los modelos de ML y DL proporcionan algún tipo de método (por ejemplo, model.save()) para guardar los modelos. Pero debes tener en cuenta que guardar es una acción única y solo proporciona un archivo binario del modelo, por lo que aún necesitas código para preparar tu aplicación de ML para producción.

Empaquetar, por otro lado, se refiere al proceso de agrupar o contener los componentes necesarios de un modelo, como el archivo del modelo, las dependencias, los archivos de configuración, etc., en un único paquete desplegable. El objetivo de un paquete es facilitar la distribución e implementación del modelo de ML en un entorno de producción.

Una vez empaquetado, un modelo se puede implementar en diferentes entornos, lo que permite que el modelo se utilice en diversas configuraciones de producción, como aplicaciones web, aplicaciones móviles, etc. Docker es una de las herramientas que te permite hacer esto.

Almacenar el modelo de ML se refiere al proceso de guardar los archivos del modelo entrenado en un almacenamiento centralizado al que se puede acceder en cualquier momento cuando sea necesario. Al almacenar un modelo, normalmente eliges algún tipo de almacenamiento desde donde puedes obtener tu modelo y utilizarlo en cualquier momento. El registro de modelos es una categoría de herramientas que resuelve este problema por ti.

Ahora veamos cómo podemos guardar nuestro modelo.

Cómo guardar un modelo entrenado en Python?

En esta sección, verás diferentes formas de guardar modelos de aprendizaje automático (ML) y aprendizaje profundo (DL). Para comenzar, crearemos un modelo de clasificación simple utilizando el famoso conjunto de datos Iris.

Nota: El enfoque de este artículo no es mostrarte cómo puedes crear el mejor modelo de ML, sino explicar qué tan efectivamente puedes guardar modelos entrenados.

Primero debes cargar las dependencias requeridas y el conjunto de datos Iris de la siguiente manera:

# cargar dependencias
import pandas as pd 

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler 
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix

# cargar el conjunto de datos
url = "iris.data"

# nombres de las columnas a utilizar
nombres = ['largo-sépalo', 'ancho-sépalo', 'largo-pétalo', 'ancho-pétalo', 'Clase']

# leer el conjunto de datos desde la URL
conjunto_datos = pd.read_csv(url, names=nombres) 

# verificar las primeras filas de datos de clasificación de iris
conjunto_datos.head()

A continuación, debes dividir los datos en conjuntos de entrenamiento y prueba y aplicar las etapas de preprocesamiento requeridas, como la estandarización de características.

# separar las características independientes y dependientes
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values 

# Dividir el conjunto de datos en subconjuntos de entrenamiento y prueba aleatorios
X_train, X_test, y_train, y_test = train_test_split(X, 
                                                    y, test_size=0.20) 
# normalización de características
scaler = StandardScaler()
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test) 

Finalmente, necesitas entrenar un modelo de clasificación (puedes elegir cualquiera) en los datos de entrenamiento y verificar su rendimiento en los datos de prueba. 

# entrenar un clasificador KNN
modelo = KNeighborsClassifier(n_neighbors=5)
modelo.fit(X_train, y_train) 

# hacer predicciones en los datos de prueba
y_prediccion = modelo.predict(X_test)

# verificar resultados
print(confusion_matrix(y_test, y_prediccion))
print(classification_report(y_test, y_prediccion)) 

Resultados de clasificación de Iris | Fuente: Autor

Ahora tienes un modelo de aprendizaje automático que deseas guardar para uso futuro. La primera forma de guardar un modelo de aprendizaje automático es utilizando un archivo pickle. 

Guardar un modelo entrenado con pickle

El módulo pickle se puede utilizar para serializar y deserializar objetos de Python. Pickleado es el proceso de convertir una jerarquía de objetos de Python en una secuencia de bytes, mientras que Despickleado es el proceso de convertir una secuencia de bytes (de un archivo binario u otro objeto que parece estar hecho de bytes) de nuevo en una jerarquía de objetos.

Para guardar los modelos de aprendizaje automático utilizados como un archivo pickle, debes usar el módulo Pickle que ya viene con la instalación predeterminada de Python. 

Para guardar tu modelo clasificador de iris, simplemente necesitas decidir un nombre de archivo y guardar tu modelo en un archivo pickle de esta manera:

import pickle

# guardar el modelo de clasificación de iris como un archivo pickle
archivo_modelo_pkl = "modelo_clasificador_iris.pkl"  

with open(archivo_modelo_pkl, 'wb') as archivo:  
    pickle.dump(modelo, archivo)

Como puedes ver, el archivo se abre en modo wb (escritura binaria) para guardar el modelo como bytes. Además, el método dump() almacena el modelo en el archivo pickle dado. 

También puedes cargar este modelo utilizando el método load() del módulo pickle. Ahora necesitas abrir el archivo en modo rb (lectura binaria) para cargar el modelo guardado.

# cargar el modelo desde el archivo pickle
with open(archivo_modelo_pkl, 'rb') as archivo:  
    modelo = pickle.load(archivo)

# evaluar el modelo 
y_prediccion = modelo.predict(X_test)

# verificar resultados
print(classification_report(y_test, y_prediccion)) 

Una vez cargado, puedes usar este modelo para hacer predicciones. 

Resultado de clasificación de Iris | Fuente: Autor

Pros del enfoque pickle de Python 

  • 1
    Pickle se presenta como el módulo estándar en Python, lo que facilita su uso para guardar y restaurar modelos de aprendizaje automático.
  • 2
    Los archivos pickle pueden manejar la mayoría de los objetos de Python, incluidos los objetos personalizados, lo que los convierte en una forma versátil de guardar modelos.
  • 3
    Para modelos pequeños, el enfoque pickle es bastante rápido y eficiente. 
  • 4
    Cuando se despickea un modelo de aprendizaje automático, se restaura a su estado anterior, incluidas las variables o configuraciones. Esto hace que los archivos pickle de Python sean una de las mejores alternativas para guardar modelos de aprendizaje automático. 

Contras del enfoque pickle de Python

  • 1
    Si despickeas datos no confiables, el pickleado puede representar una amenaza de seguridad. Despickear un objeto puede ejecutar código malicioso, por lo que es crucial despickear solo información de fuentes confiables.
  • 2
    El uso de objetos pickle puede estar limitado en algunas circunstancias, ya que no se pueden transferir entre diferentes versiones de Python o sistemas operativos.
  • 3
    Para modelos con una gran huella de memoria, el pickleado puede resultar en la creación de archivos enormes, lo que puede ser problemático.
  • 4
    El pickleado puede dificultar el seguimiento de los cambios en un modelo a lo largo del tiempo, especialmente si el modelo se actualiza con frecuencia y no es factible crear múltiples archivos pickle para diferentes versiones de los modelos que pruebes. 

Pickle es más adecuado para modelos de tamaño pequeño y también tiene algunos problemas de seguridad, estas razones son suficientes para buscar otra alternativa para guardar los modelos de ML. A continuación, discutiremos Joblib para guardar y cargar modelos de ML.

Nota: En las secciones próximas verás el mismo modelo de clasificación de iris que se guarda utilizando diferentes técnicas.

Guardar modelo entrenado con Joblib

Joblib es un conjunto de herramientas (normalmente parte del ecosistema de Scipy) que proporciona tuberías ligeras en Python. Se centra principalmente en el almacenamiento en caché en disco, la memorización y la computación en paralelo, y se utiliza para guardar y cargar objetos de Python. Joblib ha sido específicamente optimizado para matrices NumPy para hacerlo rápido y confiable para modelos de ML que tienen muchos parámetros.

Para guardar modelos grandes con Joblib, necesitas usar el módulo Python Joblib que viene preinstalado con Python.

import joblib 

# guardar modelo con joblib
filename = 'joblib_model.sav'
joblib.dump(model, filename)

Para guardar el modelo, necesitas definir un nombre de archivo con una extensión ‘.sav’ o ‘.pkl’ y llamar al método dump() de Joblib.

Similar a pickle, Joblib proporciona el método load() para cargar el modelo de ML guardado.

# cargar modelo con joblib
loaded_model = joblib.load(filename)

# evaluar modelo
y_predict = model.predict(X_test)

# verificar resultados
print(classification_report(y_test, y_predict)) 

Después de cargar el modelo con Joblib, puedes usarlo en los datos para hacer predicciones.

Resultados de clasificación de iris | Fuente: Autor

Pros de guardar modelos de ML con Joblib

  • 1
    El rendimiento rápido y efectivo es un componente clave de Joblib, especialmente para modelos con requisitos de memoria sustanciales.
  • 2
    El proceso de serialización y deserialización se puede paralelizar a través de Joblib, lo que puede mejorar el rendimiento en máquinas de varios núcleos.
  • 3
    Para modelos que demandan mucha memoria, Joblib utiliza un formato de archivo mapeado en memoria para reducir la utilización de memoria.
  • 4
    Joblib ofrece varias características de seguridad, como una lista blanca de funciones seguras que se pueden utilizar durante la deserialización, para ayudar a protegerse contra datos no confiables.

Contras de guardar modelos de ML con Joblib

  • 1
    Joblib está optimizado para matrices numpy y puede no funcionar tan bien con otros tipos de objetos.
  • 2
    Joblib ofrece menos flexibilidad que Pickle porque hay menos opciones disponibles para configurar el proceso de serialización.
  • 3
    En comparación con Pickle, Joblib es menos conocido, lo que puede dificultar la búsqueda de ayuda y documentación al respecto.

Aunque Joblib resuelve los principales problemas que enfrenta pickle, tiene algunos problemas propios. A continuación, verás cómo puedes guardar y restaurar los modelos manualmente utilizando JSON.

Guardar modelo entrenado con JSON

Cuando deseas tener control total sobre el procedimiento de guardar y restaurar tu modelo de ML, JSON entra en juego. A diferencia de los otros dos métodos, este método no guarda directamente el modelo de ML en un archivo; en su lugar, necesitas definir explícitamente los diferentes parámetros de tu modelo para guardarlos.

Para usar este método, necesitas usar el módulo Python json que nuevamente viene junto con la instalación predeterminada de Python. Usar el método JSON requiere un esfuerzo adicional para escribir todos los parámetros que contiene un modelo de ML. Para guardar el modelo usando JSON, creemos una función como esta:

import json 

# crear función de guardado en json
def save_json(model, filepath, X_train, y_train): 
    saved_model = {}
    saved_model["algorithm"] = model.get_params()['algorithm'],
    saved_model["max_iter"] = model.get_params()['leaf_size'],
    saved_model["solver"] = model.get_params()['metric'],
    saved_model["metric_params"] = model.get_params()['metric_params'],
    saved_model["n_jobs"] = model.get_params()['n_jobs'],
    saved_model["n_neighbors"] = model.get_params()['n_neighbors'],
    saved_model["p"] = model.get_params()['p'],
    saved_model["weights"] = model.get_params()['weights'],
    saved_model["X_train"] = X_train.tolist() if X_train is not None else "None",
    saved_model["y_train"] = y_train.tolist() if y_train is not None else "None"
    
    json_txt = json.dumps(saved_model, indent=4)
    with open(filepath, "w") as file: 
        file.write(json_txt)

# guardar el modelo de clasificación de iris en un archivo json
file_path = 'json_model.json'
save_json(model, file_path, X_train, y_train)

Observa cómo necesitas definir cada parámetro del modelo y los datos para almacenarlo en JSON. Diferentes modelos tienen diferentes métodos para verificar los detalles del parámetro. Por ejemplo, el método get_params() para KNeighboursClassifier devuelve la lista de todos los hiperparámetros en el modelo. Necesitas guardar todos estos hiperparámetros y los valores de los datos en un diccionario que luego se guarda en un archivo con la extensión ‘.json’.

Para leer este archivo JSON, solo necesitas abrirlo y acceder a los parámetros de la siguiente manera:

# crear función de carga de json
def load_json(filepath):
    with open(filepath, "r") as file:
        saved_model = json.load(file)

    return saved_model

# cargar configuraciones del modelo
saved_model = load_json('json_model.json')
saved_model

En el código anterior, se crea una función load_json() que abre el archivo JSON en modo de lectura y devuelve todos los parámetros y datos como un diccionario.

Modelo cargado desde JSON | Fuente: Autor

Desafortunadamente, no puedes utilizar el modelo guardado directamente con JSON, necesitas leer estos parámetros y datos para volver a entrenar el modelo por ti mismo.

Pros de guardar modelos de ML con JSON

  • 1
    Los modelos que necesitan intercambiarse entre varios sistemas pueden hacerlo utilizando JSON, que es un formato portátil que puede ser leído por una amplia variedad de lenguajes de programación y plataformas.
  • 2
    JSON es un formato basado en texto que es fácil de leer y entender, lo que lo convierte en una buena opción para modelos que deben ser inspeccionados o editados por humanos.
  • 3
    En comparación con Pickle o Joblib, JSON es un formato ligero que crea archivos más pequeños, lo cual puede ser crucial para modelos que deben transferirse a través de Internet.
  • 4
    A diferencia de pickle, que ejecuta código durante la deserialización, JSON es un formato seguro que minimiza las amenazas de seguridad.

Contras de guardar modelos de ML con JSON

  • 1
    Debido a que JSON solo admite un pequeño número de tipos de datos, puede no ser compatible con modelos de aprendizaje automático sofisticados que emplean tipos de datos únicos.
  • 2
    En particular, para modelos grandes, la serialización y deserialización de JSON puede ser más lenta que otros formatos.
  • 3
    En comparación con otros formatos alternativos, JSON ofrece menos flexibilidad y puede requerir más esfuerzo para adaptar el procedimiento de serialización.
  • 4
    JSON es un formato con pérdida que puede no preservar toda la información del modelo original, lo cual puede ser un problema para modelos que requieren una replicación exacta.

Para asegurar la seguridad y los beneficios de JSON/pickle, puedes guardar tu modelo en una base de datos dedicada. A continuación, verás cómo puedes guardar un modelo de ML en una base de datos.

Guardar modelo de aprendizaje profundo con TensorFlow Keras

TensorFlow es un framework popular para entrenar modelos basados en aprendizaje profundo, y Keras es un envoltorio para TensorFlow. Se utiliza un diseño de red neuronal con numerosas capas y un conjunto de datos etiquetados para entrenar modelos de aprendizaje profundo. Estos modelos tienen dos componentes principales, Pesos y Arquitectura de la red, que necesitas guardar para restaurarlos para su uso futuro. Por lo general, hay dos formas de guardar modelos de aprendizaje profundo:

  1. Guardar la arquitectura del modelo en un archivo JSON o YAML y los pesos en un archivo HDF5.
  2. Guardar tanto el modelo como la arquitectura en un archivo HDF5, protobuf o tflite.

Puedes elegir cualquiera de estas formas para hacerlo, pero el método más utilizado es guardar los pesos del modelo y la arquitectura juntos en un archivo HDF5.

Para guardar un modelo de aprendizaje profundo en TensorFlow Keras, puedes utilizar el método save() del objeto Model de Keras. Este método guarda todo el modelo, incluyendo la arquitectura del modelo, el optimizador y los pesos, en un formato que se puede cargar más tarde para hacer predicciones.

Aquí tienes un ejemplo de código que muestra cómo guardar un modelo de DL basado en TensorFlow Keras:

# importar dependencias de tensorflow
from tensorflow.keras.models import Sequential, model_from_json
from tensorflow.keras.layers import Dense

# definir la arquitectura del modelo
model = Sequential()
model.add(Dense(12, input_dim=4, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

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

# Ajustar el modelo
model.fit(X_train, y_train, epochs=150, batch_size=10, verbose=0)

# guardar el modelo y su arquitectura
model.save('model.h5')

Esto es todo, solo necesitas definir la arquitectura del modelo, entrenar los modelos con la configuración adecuada y finalmente guardarlo usando el método save().

Cargar los modelos guardados con Keras es tan fácil como leer un archivo en Python. Solo necesitas llamar al método load_model() proporcionando la ruta del archivo del modelo y tu modelo se cargará.

# definir dependencia
from tensorflow.keras.models import load_model

# cargar modelo
modelo = load_model('modelo.h5')

# verificar información del modelo
modelo.summary()

Tu modelo ahora está cargado y listo para usar.

Modelo cargado de TensorFlow | Fuente: Autor

Pros de guardar modelos con TensorFlow Keras

  • 1
    Guardar y cargar modelos en TensorFlow Keras es muy sencillo utilizando las funciones save() y load_model(). Esto facilita guardar y compartir modelos con otras personas o implementarlos en producción.
  • 2
    Toda la arquitectura del modelo, el optimizador y los pesos se guardan en un solo archivo al guardar un modelo de Keras. Sin necesidad de preocuparse por cargar la arquitectura y los pesos por separado, es sencillo cargar el modelo y generar predicciones.
  • 3
    TensorFlow Keras admite varios formatos de archivo para guardar modelos, incluyendo el formato HDF5 (.h5), el formato TensorFlow SavedModel (.pb) y el formato TensorFlow Lite (.tflite). Esto te brinda flexibilidad para elegir el formato que mejor se adapte a tus necesidades.

Contras de guardar modelos con TensorFlow Keras

  • 1
    Al guardar un modelo de Keras, el archivo resultante puede ser bastante grande, especialmente si tienes un gran número de capas o parámetros. Esto puede dificultar compartir o implementar el modelo, especialmente en situaciones donde el ancho de banda o el espacio de almacenamiento son limitados.
  • 2
    Los modelos guardados con una versión de TensorFlow Keras podrían no funcionar con otra. Si intentas cargar un modelo que fue guardado con una versión diferente de Keras o TensorFlow, esto puede resultar en problemas.
  • 3
    Aunque es sencillo guardar un modelo de Keras, solo puedes utilizar las características que Keras ofrece para almacenar modelos. Es posible que se requiera un marco o estrategia diferente si necesitas más flexibilidad en la forma en que se guardan o cargan los modelos.

Hay otro marco ampliamente utilizado llamado Pytorch para entrenar modelos basados en DL. Veamos cómo puedes guardar modelos de aprendizaje profundo basados en Pytorch con Python.

Guardar un modelo de aprendizaje profundo con Pytorch

Desarrollado por Facebook, Pytorch es uno de los marcos más utilizados para desarrollar soluciones basadas en DL. Proporciona un gráfico computacional dinámico, que te permite modificar tu modelo sobre la marcha, lo que lo hace ideal para investigación y experimentación. Utiliza los formatos de archivo ‘.pt’ y ‘.pth’ para guardar la arquitectura y los pesos del modelo.

Para guardar un modelo de aprendizaje profundo en PyTorch, puedes utilizar el método save() del objeto torch.nn.Module de PyTorch. Este método guarda el modelo completo, incluyendo la arquitectura del modelo y los pesos, en un formato que se puede cargar más tarde para hacer predicciones.

Aquí tienes un ejemplo de código que muestra cómo guardar un modelo de PyTorch:

# importar dependencias
import torch
import torch.nn as nn
import numpy as np

# convertir matrices de datos numpy a tensores
X_train = torch.FloatTensor(X_train)
X_test = torch.FloatTensor(X_test)
y_train = torch.LongTensor(y_train)
y_test = torch.LongTensor(y_test)

# definir arquitectura del modelo
class ModeloClasificacionRedNeuronal(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(ModeloClasificacionRedNeuronal, self).__init__()
        self.input_layer = nn.Linear(input_dim, 128)
        self.hidden_layer1 = nn.Linear(128, 64)
        self.output_layer = nn.Linear(64, output_dim)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        out = self.relu(self.input_layer(x))
        out = self.relu(self.hidden_layer1(out))
        out = self.output_layer(out)
        return out

# definir dimensiones de entrada y salida
input_dim = 4
output_dim = 3
modelo = ModeloClasificacionRedNeuronal(input_dim, output_dim)

# crear nuestro optimizador y objeto de función de pérdida
learning_rate = 0.01
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(modelo.parameters(), lr=learning_rate)

# definir pasos de entrenamiento
def entrenar_red_neuronal(modelo, optimizer, criterion, X_train, y_train, X_test, y_test, num_epochs, train_losses, test_losses):
    for epoch in range(num_epochs):
        # eliminar los gradientes del paso anterior loss.backward()
        optimizer.zero_grad()
        
        # alimentación hacia adelante
        output_train = modelo(X_train)

        # calcular la pérdida
        loss_train = criterion(output_train, y_train)

        # propagación hacia atrás: calcular los gradientes
        loss_train.backward()

        # actualizar los pesos
        optimizer.step()
        
        output_test = modelo(X_test)
        loss_test = criterion(output_test, y_test)

        train_losses[epoch] = loss_train.item()
        test_losses[epoch] = loss_test.item()

        if (epoch + 1) % 50 == 0:
            print(f"Epoch {epoch+1}/{num_epochs}, Pérdida de entrenamiento: {loss_train.item():.4f}, Pérdida de prueba: {loss_test.item():.4f}")

# entrenar modelo
num_epochs = 1000
train_losses = np.zeros(num_epochs)
test_losses = np.zeros(num_epochs)
entrenar_red_neuronal(modelo, optimizer, criterion, X_train, y_train, X_test, y_test, num_epochs, train_losses, test_losses)

# guardar modelo
torch.save(modelo, 'modelo_pytorch.pt')

A diferencia de Tensorflow, Pytorch te permite tener más control sobre el entrenamiento del modelo, como se ve en el código anterior. Después de entrenar el modelo, puedes guardar los pesos y su arquitectura utilizando el método save().

Para cargar el modelo guardado con Pytorch, se requiere el uso del método load().

# cargar modelo
modelo = torch.load('modelo_pytorch.pt')
# verificar resumen del modelo
modelo.eval()

Modelo cargado de Pytorch | Fuente: Autor

Pros de guardar modelos con Pytorch

  • 1
    El grafo computacional utilizado por PyTorch es dinámico, lo que significa que se construye a medida que se ejecuta el programa. Esto permite una mayor flexibilidad para modificar el modelo durante el entrenamiento o la inferencia.
  • 2
    Para modelos dinámicos, como aquellos con entradas o salidas de longitud variable, que son frecuentes en el procesamiento del lenguaje natural (NLP) y la visión por computadora, PyTorch ofrece un mejor soporte.
  • 3
    Dado que PyTorch está escrito en Python y funciona bien con otras bibliotecas de Python como NumPy y pandas, es sencillo manipular los datos tanto antes como después del entrenamiento.

Contras de guardar modelos con Pytorch

  • 1
    Aunque PyTorch proporciona una API accesible, puede haber una curva de aprendizaje pronunciada para los recién llegados al aprendizaje profundo o la programación en Python.
  • 2
    Dado que PyTorch es principalmente un marco para la investigación, es posible que no tenga tantas herramientas para implementaciones en producción como otros marcos de aprendizaje profundo como TensorFlow o Keras.

Esto no es todo, también puedes utilizar plataformas de registro de modelos para guardar modelos basados en DL, especialmente aquellos con un tamaño grande. Esto facilita su implementación y mantenimiento sin requerir esfuerzo adicional de los desarrolladores.

Puedes encontrar el conjunto de datos y el código utilizados en este artículo aquí.

¿Cómo empaquetar modelos de ML?

Un modelo de ML está típicamente optimizado para el rendimiento en el conjunto de datos de entrenamiento y el entorno específico en el que se entrena. Sin embargo, cuando se trata de implementar los modelos en diferentes entornos, como un entorno de producción, puede haber varios desafíos.

Estos desafíos incluyen, pero no se limitan a, diferencias en hardware, software y entradas de datos. Empaquetar el modelo facilita abordar estos problemas, ya que permite exportar o serializar el modelo en un formato estándar que se puede cargar y utilizar en varios entornos.

Actualmente, existen varias opciones disponibles para el empaquetado. Al empaquetar el modelo en un formato estándar como PMML (Predictive Model Markup Language), ONNX, formato TensorFlow SavedModel, etc., se vuelve más fácil compartir y colaborar en un modelo sin preocuparse por las diferentes bibliotecas y herramientas utilizadas por diferentes equipos. Ahora, veamos algunos ejemplos de cómo empaquetar un modelo de ML con diferentes frameworks en Python.

Nota: Para esta sección también verás el mismo ejemplo de clasificación de iris.

Empaquetar modelos con PMML

Utilizando la biblioteca PMML en Python, puedes exportar tus modelos de aprendizaje automático al formato PMML y luego implementarlo como un servicio web, un sistema de procesamiento por lotes o una plataforma de integración de datos. Esto puede facilitar compartir y colaborar en modelos de aprendizaje automático, así como implementarlos en varios entornos de producción.

Para empaquetar un modelo de ML utilizando PMML, puedes utilizar diferentes módulos como sklearn2pmml, jpmml-sklearn, jpmml-tensorflow, etc.

Nota: Para usar PMML, debes tener Java Runtime instalado en tu sistema.

Aquí tienes un ejemplo de fragmento de código que te permite empaquetar el modelo clasificador de iris entrenado utilizando PMML.

from sklearn2pmml import PMMLPipeline, sklearn2pmml
# empaquetar modelo clasificador de iris con PMML
sklearn2pmml(PMMLPipeline([("estimador",
                        	modelo)]),
         	"modelo_iris.pmml",
         	con_repr=True)

En el código anterior, simplemente necesitas crear un objeto de tubería PMML pasando tu objeto de modelo. Luego, necesitas guardar el objeto PMML utilizando el método sklearn2pmml(). Eso es todo, ahora puedes utilizar este archivo “modelo_iris.pmml” en diferentes entornos.

Pros de usar PMML

  • 1
    Dado que PMML es un formato independiente de la plataforma, los modelos PMML se pueden integrar con numerosas plataformas de procesamiento de datos y utilizar en una variedad de situaciones de producción.
  • 2
    PMML puede reducir el encierro del proveedor ya que permite a los usuarios exportar e importar modelos de diferentes plataformas de aprendizaje automático.
  • 3
    Los modelos PMML se pueden implementar fácilmente en entornos de producción, ya que se pueden integrar con diversas plataformas y sistemas de procesamiento de datos.

Contras de usar PMML

  • 1
    Algunos modelos y algoritmos de aprendizaje automático pueden no poder exportarse en formato PMML debido al soporte limitado.
  • 2
    PMML es un formato basado en XML que puede ser verboso e inflexible, lo que puede dificultar la modificación o actualización de los modelos después de haber sido exportados en formato PMML.
  • 3
    Puede ser difícil crear modelos PMML, especialmente para modelos complicados con varias características e interacciones.

Empaquetando modelos con ONNX

Desarrollado por Microsoft y Facebook, ONNX (Open Neural Network Exchange) es un formato abierto para representar modelos de aprendizaje automático. Permite la interoperabilidad entre diferentes marcos y herramientas de aprendizaje profundo.

Los modelos ONNX se pueden implementar eficientemente en una variedad de plataformas, incluyendo dispositivos móviles, dispositivos de borde y la nube. Admite una variedad de tiempos de ejecución, incluyendo Caffe2, TensorFlow, PyTorch y MXNet, lo que le permite implementar sus modelos en diferentes dispositivos y plataformas con un esfuerzo mínimo.

Para guardar el modelo usando ONNX, es necesario tener los paquetes onnx y onnxruntime descargados en su sistema.

A continuación se muestra un ejemplo de cómo puede convertir el modelo de ML existente al formato ONNX.

# cargar dependencias
import onnxmltools
import onnxruntime

# Convertir el modelo KNeighborsClassifier al formato ONNX
onnx_model = onnxmltools.convert_sklearn(model)

# Guardar el modelo ONNX en un archivo
onnx_file = "iris_knn.onnx"
onnxmltools.utils.save_model(onnx_model, onnx_file)

Sólo necesita importar los módulos requeridos y utilizar el método convert_sklearn() para convertir el modelo de sklearn al modelo ONNX. Una vez que se haya realizado la conversión, utilizando el método save_model(), puede almacenar el modelo ONNX en un archivo con la extensión “.onnx”. Aunque aquí se muestra un ejemplo de un modelo de ML, ONNX se utiliza principalmente para modelos de DL.

También puede cargar este modelo utilizando el módulo ONNX Runtime.

# Cargar el modelo ONNX en ONNX Runtime
sess = onnxruntime.InferenceSession(onnx_file)

# Evaluar el modelo en algunos datos de prueba
input_data = {"X": X_test[:10].astype('float32')}
output = sess.run(None, input_data)

Necesita crear una sesión utilizando el método InferenceSession() para cargar el modelo ONNX desde un archivo y luego utilizar el método sess.run() para realizar predicciones a partir del modelo.

Pros de usar ONNX

  • 1
    Con poco esfuerzo, los modelos ONNX se pueden implementar fácilmente en varias plataformas, incluyendo dispositivos móviles y la nube. Gracias al soporte de ONNX para una amplia gama de tiempos de ejecución, es sencillo implementar modelos en diferentes plataformas de hardware y software.
  • 2
    Los modelos ONNX están optimizados para el rendimiento, lo que significa que pueden ejecutarse más rápido y consumir menos recursos que los modelos en otros formatos.

Contras de usar ONNX

  • 1
    ONNX está diseñado principalmente para modelos de aprendizaje profundo y puede no ser adecuado para otros tipos de modelos de aprendizaje automático.
  • 2
    Los modelos ONNX pueden no ser compatibles con todas las versiones de diferentes marcos de aprendizaje profundo, lo que puede requerir un esfuerzo adicional para garantizar la compatibilidad.

Empaquetando modelos con Tensorflow SavedModel

El formato SavedModel de Tensorflow le permite guardar y cargar fácilmente sus modelos de aprendizaje profundo, y garantiza la compatibilidad con otras herramientas y plataformas de Tensorflow. Además, proporciona una forma eficiente y simplificada de implementar nuestros modelos en entornos de producción.

SavedModel admite una amplia gama de escenarios de implementación, incluyendo el servicio de modelos con Tensorflow Serving, la implementación de modelos en dispositivos móviles con Tensorflow Lite y la exportación de modelos a otras bibliotecas de ML como ONNX.

Proporciona una forma simple y eficiente de guardar y cargar modelos de Tensorflow. La API es fácil de usar y está bien documentada, y el formato está diseñado para ser eficiente y escalable.

Nota: Puede utilizar el mismo modelo de TensorFlow entrenado en la sección anterior.

Para guardar el modelo en el formato SavedModel, puede utilizar las siguientes líneas de código:

import tensorflow as tf

# utilizando el formato SavedModel para guardar el modelo
tf.saved_model.save(model, "mi_modelo")

También puede cargar el modelo con el método load().

# Cargar el modelo
modelo_cargado = tf.saved_model.load("mi_modelo")

Ventajas de utilizar Tensorflow SavedModel

  • 1
    SavedModel es independiente de la plataforma y compatible con diferentes versiones, lo que facilita compartir e implementar modelos en diferentes plataformas y versiones de TensorFlow.
  • 2
    SavedModel admite una variedad de escenarios de implementación, incluyendo la exportación de modelos a otras bibliotecas de ML como ONNX, el servicio de modelos con TensorFlow Serving y la distribución de modelos en dispositivos móviles utilizando TensorFlow Lite.
  • 3
    SavedModel está optimizado para entrenamiento e inferencia, con soporte para entrenamiento distribuido y la capacidad de utilizar GPUs y TPUs para acelerar el entrenamiento.

Inconvenientes de utilizar Tensorflow SavedModel

  • 1
    Los archivos SavedModel pueden ser grandes, especialmente para modelos complejos, lo que puede dificultar su almacenamiento y transferencia.
  • 2
    Dado que SavedModel es exclusivo de TensorFlow, su compatibilidad con otras bibliotecas y herramientas de ML puede estar limitada.
  • 3
    El modelo guardado es un archivo binario que puede ser difícil de inspeccionar, lo que dificulta comprender los detalles de la arquitectura y operación del modelo.

Ahora que has visto varias formas de empaquetar modelos de ML y DL, también debes tener en cuenta que existen varias herramientas disponibles que proporcionan infraestructura para empaquetar, implementar y servir estos modelos. Dos de las más populares son BentoML y MLFlow.

BentoML

BentoML es un marco flexible para construir y implementar servicios de aprendizaje automático listos para producción. Permite a los científicos de datos empaquetar sus modelos entrenados, sus dependencias y el código de infraestructura necesario para servir el modelo en un paquete reutilizable llamado “Bento”.

BentoML admite varios marcos de aprendizaje automático y plataformas de implementación y proporciona una API unificada para gestionar el ciclo de vida del modelo. Una vez que un modelo se empaqueta como un Bento, se puede implementar en diversas plataformas de servicios como AWS Lambda, Kubernetes o Docker. BentoML también ofrece un servidor de API que se puede utilizar para servir el modelo a través de una API REST. Puedes obtener más información al respecto aquí.

MLFlow

MLFlow es una plataforma de código abierto para gestionar el ciclo de vida completo del aprendizaje automático. Proporciona un conjunto completo de herramientas para realizar un seguimiento de experimentos, empaquetar código y dependencias, e implementar modelos.

MLFlow permite a los científicos de datos empaquetar fácilmente sus modelos en un formato estándar que se puede implementar en diversas plataformas como AWS SageMaker, Azure ML y Google Cloud AI Platform. La plataforma también proporciona un registro de modelos para gestionar las versiones del modelo y realizar un seguimiento de su rendimiento a lo largo del tiempo. Además, MLFlow ofrece una API REST para servir modelos, que se puede integrar fácilmente en aplicaciones web u otros servicios.

¿Cómo almacenar modelos de ML?

Ahora que conocemos la forma de guardar modelos, veamos cómo podemos almacenarlos para facilitar su recuperación rápida y sencilla.

Almacenar modelos de ML en una base de datos

También tienes la opción de guardar tus modelos de ML en bases de datos relacionales como PostgreSQL, MySQL, Oracle SQL, etc., o en bases de datos NoSQL como MongoDB, Cassandra, etc. La elección de la base de datos depende totalmente de factores como el tipo y el volumen de datos que se almacenan, los requisitos de rendimiento y escalabilidad, y las necesidades específicas de la aplicación.

PostgreSQL es una opción popular cuando se trabaja en modelos de ML que brindan soporte para almacenar y manipular datos estructurados. Almacenar modelos de ML en PostgreSQL ofrece una forma fácil de realizar un seguimiento de las diferentes versiones de un modelo y gestionarlos en un lugar centralizado.

Además, permite compartir fácilmente los modelos entre un equipo u organización. Sin embargo, es importante tener en cuenta que almacenar modelos grandes en una base de datos puede aumentar el tamaño de la base de datos y los tiempos de consulta, por lo que es importante considerar la capacidad de almacenamiento y el rendimiento de la base de datos al almacenar modelos en PostgreSQL.

Para guardar un modelo de ML en una base de datos como PostgreSQL, primero necesitas convertir el modelo entrenado en un formato serializado, como una secuencia de bytes (objeto pickle) o JSON.

import pickle

# serializar el modelo
model_bytes = pickle.dumps(model)

Luego, abre una conexión a la base de datos y crea una tabla o colección para almacenar el modelo serializado. Para esto, necesitas usar la biblioteca psycopg2 de Python, que te permite conectarte a la base de datos de PostgreSQL. Puedes descargar esta biblioteca con la ayuda del instalador de paquetes de Python.

$ pip install psycopg2-binary

Luego, necesitas establecer una conexión a la base de datos para almacenar el modelo de ML de la siguiente manera:

import psycopg2

# establecer la conexión a la base de datos
conn = psycopg2.connect(
  database="nombre-base-datos", user=nombre-usuario, password='tu-contraseña', host='127.0.0.1', port='5432'
)

Para realizar cualquier operación en la base de datos, necesitas crear un objeto cursor que te ayudará a ejecutar consultas en tu programa de Python.

# crear un cursor
cur = conn.cursor()

Con la ayuda de este cursor, ahora puedes ejecutar la consulta CREATE TABLE para crear una nueva tabla.

cur.execute("CREATE TABLE models (id INT PRIMARY KEY NOT NULL, name CHAR(50), model BYTEA)")

Nota: Asegúrate de que el tipo de objeto del modelo sea BYTEA.

Finalmente, puedes almacenar el modelo y otra información de metadatos usando el comando INSERT INTO.

# insertar el modelo serializado en la base de datos
cur.execute("INSERT INTO models (id, name, model) VALUES (%s, %s, %s)", (1, 'clasificador-iris', model_bytes))
conn.commit()

# cerrar la conexión de la base de datos
cur.close()
conn.close()

Una vez que todas las operaciones estén hechas, cierra el cursor y la conexión a la base de datos.

Finalmente, para leer el modelo de la base de datos, puedes usar el comando SELECT filtrando el modelo por nombre o id.

import psycopg2
import pickle

# conectar a la base de datos
conn = psycopg2.connect(
  database="nombre-base-datos", user=nombre-usuario, password='tu-contraseña', host='127.0.0.1', port='5432'
)

# recuperar el modelo serializado de la base de datos
cur = conn.cursor()
cur.execute("SELECT model FROM models WHERE name = %s", ('clasificador-iris',))
model_bytes = cur.fetchone()[0]

# deserializar el modelo
model = pickle.loads(model_bytes)

# cerrar la conexión de la base de datos
cur.close()
conn.close()

Una vez que el modelo se carga desde la base de datos, puedes usarlo para hacer predicciones de la siguiente manera:

# probar el modelo cargado
y_predict = model.predict(X_test)

# verificar resultados
print(classification_report(y_test, y_predict)) 

Esto es todo, tienes el modelo almacenado y cargado desde la base de datos.

Pros de almacenar modelos de ML en una base de datos

  • 1
    Almacenar modelos de ML en una base de datos proporciona una ubicación de almacenamiento centralizada que puede ser fácilmente accedida por múltiples aplicaciones y usuarios.
  • 2
    Dado que la mayoría de las organizaciones ya tienen bases de datos en su lugar, integrar modelos de ML en la infraestructura existente se vuelve más fácil.
  • 3
    Las bases de datos están optimizadas para la recuperación de datos, lo que significa que la recuperación de los modelos de ML es más rápida y eficiente.
  • 4
    Las bases de datos están diseñadas para proporcionar características de seguridad sólidas como autenticación, autorización y cifrado. Esto asegura que los modelos de ML almacenados estén seguros.

Contras de almacenar modelos de ML en una base de datos

  • 1
    Las bases de datos están diseñadas para almacenar datos estructurados y no están optimizadas para almacenar datos no estructurados como modelos de ML. Como resultado, puede haber limitaciones en cuanto al tamaño del modelo, formatos de archivo y otros aspectos de los modelos de ML que no pueden ser acomodados por las bases de datos.
  • 2
    Almacenar modelos de ML en una base de datos puede ser complejo y requiere experiencia tanto en administración de bases de datos como en aprendizaje automático.
  • 3
     Si los modelos de ML son grandes, almacenarlos en una base de datos puede generar problemas de escalabilidad. Además, la recuperación de modelos grandes puede afectar el rendimiento de la base de datos.

Mientras que pickle, joblib y JSON son formas comunes de guardar modelos de aprendizaje automático, tienen limitaciones cuando se trata de versionar, compartir y gestionar modelos de aprendizaje automático. Aquí es donde los registros de modelos de ML vienen al rescate y resuelven todos los problemas que enfrentan las alternativas.

A continuación, verás cómo guardar modelos de ML en el registro de modelos puede ayudarte a lograr la reproducibilidad y la reutilización.

Almacenando modelos de ML en el registro de modelos

  • Un registro de modelos es un repositorio central que puede almacenar, versionar y gestionar modelos de aprendizaje automático.
  • Típicamente incluye características como versionado de modelos, control de metadatos, comparación de ejecuciones de modelos, etc.
  • Cuando trabajas en proyectos de ML o DL, puedes guardar y recuperar los modelos y sus metadatos del registro de modelos en cualquier momento que desees.
  • Por encima de todo, los registros de modelos permiten una alta colaboración entre los miembros del equipo.

Consulta este artículo para obtener más información sobre el registro de modelos.

Existen diversas opciones para el registro de modelos, por ejemplo, neptune.ai, Mlflow, Kubeflow, etc. Aunque todas estas plataformas tienen algunas características únicas por sí mismas, es más prudente elegir un registro que pueda brindarte un amplio conjunto de características.

En este ejemplo, utilizaré Neptune. Tiene una funcionalidad de registro de modelos desarrollada para organizar, almacenar y gestionar modelos de aprendizaje automático. Es una excelente opción para científicos de datos e ingenieros de ML que necesitan gestionar sus modelos entrenados, porque les proporciona características de colaboración, una interfaz fácil de usar y capacidades de versionado de modelos.

Puedes configurar una cuenta gratuita aquí o obtener más información sobre la herramienta aquí.

Registrar un modelo en el registro de Neptune

Una vez que hayas creado una cuenta gratuita, puedes hacer clic en el botón Nuevo Proyecto para iniciar un nuevo proyecto.

Crear un nuevo proyecto en Neptune | Fuente: Autor

Una vez que se haya completado la creación del proyecto, verás una página con diferentes configuraciones para guardar el modelo. Con Neptune, puedes trabajar con diferentes marcos como Scikit-Learn, Keras, Tensorflow, Pytorch y más.

Para almacenar modelos en el registro de modelos de Neptune, necesitas instalar la biblioteca:

$ pip install neptune

Nota: Asegúrate de haber guardado tu modelo entrenado en un archivo utilizando el módulo pickle o joblib para almacenarlo en el registro de modelos.

Una vez instalada la dependencia, debes importarla en tu programa e inicializar el modelo de Neptune proporcionándole un nombre, una clave única (en mayúsculas) y tus credenciales de Neptune. Puedes encontrar toda esta información en la pestaña de metadatos del modelo de un proyecto de Neptune.

import neptune

# inicializar modelo
model = neptune.init_model(
name="Modelo de predicción",
key="IRMOD", # debe ser diferente para tu proyecto
project="nombre-de-usuario/nombre-del-proyecto",
api_token="tu-clave-de-api", # tus credenciales
)

En el código anterior, se importa la dependencia de Neptune y se inicializa un modelo (que deseas almacenar y rastrear con el registro de modelos de Neptune) con las credenciales de Neptune. Luego, debes asignar los metadatos del modelo de clasificación al objeto de modelo de Neptune.

# asignar metadatos del modelo de clasificación al objeto de modelo
model_info = {"size_limit": 7.09, "size_units": "KB"}
model["model"] = model_info

Finalmente, puedes subir el modelo al registro de modelos de Neptune utilizando el método upload() de esta manera:

# subir el modelo al registro
model["model/signature"].upload("iris_classifier_model.pkl")

Además, puedes rastrear la versión del conjunto de datos utilizando el método track_files() proporcionado por neptune.

# rastrear la versión del conjunto de datos
model["data/train_and_test"].track_files("iris.data")

# detener la sesión
model.stop()

Esto es todo, tu modelo y el conjunto de datos ahora están guardados en el registro. Además, no olvides cerrar la sesión con el método stop().

Comprobar modelo almacenado en Neptune | Fuente: Autor

Versión de un modelo

Cuando trabajas en un proyecto de aprendizaje automático del mundo real, es posible que pruebes muchos modelos y combinaciones de parámetros e hiperparámetros. Si no haces un seguimiento de estos datos, es posible que no sepas todas las cosas que has probado y que haya posibles retrabajos.

Aquí es donde el registro de modelos de Neptune te ayuda, ya que puedes registrar diferentes versiones de un modelo con solo unas pocas líneas de código. Para comenzar, debes inicializar un objeto ModelVersion de la siguiente manera:

# inicializar el ModelVersion
import neptune
model_version = neptune.init_model_version(
model="IR-IRMOD", # debe ser diferente para tu proyecto
project="nombredeusuario/nombredelproyecto",
api_token="tu-clave-de-api", # tus credenciales
)

Luego puedes optar por guardar el modelo y otros detalles de metadatos en cada versión del modelo que vas a registrar en el registro de Neptune.

# parámetros del modelo
parameters = {
"algorithm": clf_model.get_params()['algorithm'],
"max_iter": clf_model.get_params()['leaf_size'],
"solver": clf_model.get_params()['metric'],
"metric_params": clf_model.get_params()['metric_params'],
"n_jobs": clf_model.get_params()['n_jobs'],
"n_neighbors": clf_model.get_params()['n_neighbors'],
"p": clf_model.get_params()['p'],
"weights": clf_model.get_params()['weights'],
}

# registrar parámetros del modelo y otros metadatos
model_version["model/binary"].upload("iris_classifier_model.pkl")
model_version["model/parameters"] = parameters
model_version["data/dataset"].track_files("iris.data")
model_version["validation/acc"] = 0.93

# detener sesión
model_version.stop()

Una vez hecho esto, puedes detener la sesión con el método stop().

Vista de las versiones del modelo en la aplicación de Neptune | Fuente: neptune.ai

Consultar modelo y metadatos desde el registro

Finalmente, necesitas acceder a este modelo guardado y a los metadatos cuando sea necesario. Puedes cargar cualquier versión específica del modelo que hayas guardado en el registro. Para ello, debes inicializar un objeto ModelVersion proporcionándole el id de la versión del modelo.

import neptune
import pickle

# especificar id de la versión del modelo
version_id = 'IR-IRMOD-1' # debe ser diferente para tu proyecto

# inicializar ejecución
model_version = neptune.init_model_version(
with_id=version_id,
project="nombredeusuario/nombre-del-proyecto",
api_token="tu-clave-de-api", # tus credenciales
)

Una vez hecho esto, puedes acceder a diferentes objetos del modelo como el modelo, los metadatos, el conjunto de datos, etc. que hayas registrado. Para empezar, descarguemos el modelo del registro y lo guardemos localmente para probar su rendimiento en datos de prueba.

# guardar el modelo del registro en local
if model_version.exists("model/binary"):
model_version["model/binary"].download(f"model/{version_id}_model.pkl")

# cargar el modelo desde el archivo pickle guardado
with open(f"model/{version_id}_model.pkl", 'rb') as file: 
clf_model_2 = pickle.load(file)

# evaluar el modelo
y_predict = clf_model_2.predict(X_test)

También puedes verificar la información de metadatos del modelo que has guardado en Neptune.

Comprobación de la información de metadatos del modelo guardada en Neptune | Fuente: Autor

Para descargar estos metadatos localmente, puedes usar el siguiente código:

# verificar metadatos
model_version["model/parameters"].fetch()

Eso es todo, ahora sabes cómo almacenar y cargar modelos específicos desde el registro de modelos de Neptune.

Puedes obtener más información sobre el registro de modelos de Neptune aquí.

Ventajas de almacenar modelos con un registro de modelos

  • 1
    Un lugar centralizado para gestionar, almacenar y controlar versiones de modelos de aprendizaje automático.
  • 2
    Los registros de modelos suelen incluir metadatos sobre los modelos, como su versión, métricas de rendimiento, etc., lo que facilita el seguimiento de los cambios y la comprensión del pasado del modelo.
  • 3
    Los registros de modelos permiten a los miembros del equipo colaborar en modelos y compartir su trabajo fácilmente.
  • 4
    Algunos registros de modelos ofrecen opciones de implementación automatizada, lo que puede simplificar el proceso de implementación de modelos en entornos de producción.
  • 5
    Los registros de modelos suelen ofrecer funciones de seguridad, como control de acceso, cifrado y autenticación, asegurando que los modelos se mantengan seguros y solo sean accesibles para usuarios autorizados.

Desventajas de almacenar modelos con un registro de modelos

  • 1
    Algunos registros de modelos requieren una suscripción de pago, lo que aumenta el costo de los programas de aprendizaje automático.
  • 2
    Los registros de modelos suelen tener una curva de aprendizaje, y puede llevar tiempo familiarizarse con su funcionalidad y características.
  • 3
    El uso de un registro de modelos puede requerir la integración con otras herramientas y sistemas, lo que puede crear dependencias adicionales.

Ahora has visto diferentes formas de guardar un modelo de ML (siendo el registro de modelos el más óptimo), es hora de ver algunas formas de guardar los modelos basados en Aprendizaje Profundo (DL).

Mejores prácticas

En esta sección, verás algunas de las mejores prácticas para guardar los modelos de ML y DL.

  • Asegurar las versiones de las bibliotecas: El uso de diferentes versiones de bibliotecas para guardar y cargar los modelos puede generar problemas de compatibilidad, ya que puede haber cambios estructurales con la actualización de la biblioteca. Debes asegurarte de que las versiones de las bibliotecas al cargar los modelos de aprendizaje automático sean las mismas que las versiones de las bibliotecas utilizadas para guardar el modelo.
  • Asegurar las versiones de Python: Es una buena práctica utilizar la misma versión de Python en todas las etapas del desarrollo de tu pipeline de ML. A veces, los cambios en la versión de Python pueden generar problemas de ejecución, por ejemplo, TensorflowV1 es compatible hasta Python 3.7, y si intentas usarlo con versiones posteriores, te encontrarás con errores.
  • Guardar tanto la arquitectura del modelo como los pesos: En el caso de los modelos basados en DL, si solo guardas los pesos del modelo pero no la arquitectura, no podrás reconstruir el modelo. Guardar la arquitectura del modelo junto con los pesos entrenados garantiza que el modelo se pueda reconstruir completamente y utilizar más adelante.
  • Documentar el modelo: Se debe documentar el objetivo, las entradas, las salidas y el rendimiento anticipado del modelo. Esto puede ayudar a otros a comprender las capacidades y limitaciones del modelo.
  • Utilizar un registro de modelos: Utilizar un registro de modelos como neptune.ai para hacer un seguimiento de los modelos, sus versiones y metadatos, y colaborar con los miembros del equipo.
  • Mantener el modelo guardado seguro: Mantener el modelo guardado seguro mediante su cifrado o almacenamiento en un lugar seguro, especialmente si contiene datos sensibles.

Conclusiones

En conclusión, guardar modelos de aprendizaje automático es un paso importante en el proceso de desarrollo, ya que te permite reutilizar y compartir tus modelos con otros. Hay varias formas de guardar modelos de aprendizaje automático, cada una con sus propias ventajas y desventajas. Algunos métodos populares incluyen el uso de pickle, Joblib, JSON, TensorFlow save y PyTorch save.

Es importante elegir el formato de archivo adecuado para tu caso de uso específico y seguir las mejores prácticas para guardar y documentar modelos, como el control de versiones, garantizar las versiones de lenguaje y biblioteca, y probar el modelo guardado. Siguiendo las prácticas discutidas en este artículo, puedes asegurarte de que tus modelos de aprendizaje automático se guarden correctamente, sean fáciles de reutilizar e implementar, y se puedan compartir de manera efectiva con otros.

Referencias

  1. https://machinelearningmastery.com/save-load-machine-learning-models-python-scikit-learn/  
  2. https://www.tensorflow.org/tutorials/keras/save_and_load 
  3. https://pytorch.org/tutorials/beginner/saving_loading_models.html 
  4. https://www.kaggle.com/code/prmohanty/python-how-to-save-and-load-ml-models

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Inteligencia Artificial

Investigadores de KAIST presentan FaceCLIPNeRF un canal de manipulación impulsado por texto de una cara en 3D utilizando NeRF deformable

Un componente crucial de las mejoras en el contenido digital humano en 3D es la capacidad de manipular fácilmente la ...

Inteligencia Artificial

Google Research explora ¿Puede la retroalimentación de IA reemplazar la entrada humana para un aprendizaje por refuerzo efectivo en modelos de lenguaje grandes?

La retroalimentación humana es esencial para mejorar y optimizar los modelos de aprendizaje automático. En los último...

Aprendizaje Automático

De Sonido a Vista Conoce AudioToken para la Síntesis de Audio a Imagen.

Los modelos generativos neuronales han transformado la forma en que consumimos contenido digital, revolucionando vari...