Saltar al contenido
Home » Blog » 4 formas de guardar un modelo listo para un entorno real

4 formas de guardar un modelo listo para un entorno real

    Guardar modelos

    Siempre que hablamos de machine learning se muestra el método para encontrar un algoritmo capaz de conseguir unos resultados esperados: clasificación, detección de anomalías, pronósticos, etc. Pero una vez que conseguimos los resultados nos podemos dar cuenta que es muy costoso también poner ese modelo en producción, es decir, ponerlo a funcionar en un entorno real.

    Lo más importante es saber como guardar un modelo y luego volver a cargarlo. Esto depende un poco de con qué hayáis hecho el modelo ya que varía si lo haceis con Scikit-Learn, tensorflow, pytorch o, si estáis haciendo aprendizaje reforzado, stable baselines 3(aunque hay más yo aquí me centraré en estos que son las principales librerías para hacer ML).

    En este artículo vamos a ver el código necesario para realizar el guardado y carga en cada una de estas librerías, y que será el primer paso para poner nuestro modelo a funcionar en un entorno que no requiera de nuestra interacción.

    Scikit-Learn

    Si estamos realizando Machine Learning utilizando las funcionalidades que nos aporta la librería Scikit-Learn (una de las mejores para clasificación, regresión y clustering, entre otras) es muy sencillo guardar los datos de nuestro modelo.

    Para ello utilizaremos la librería Pickle, una librería que implementa una serie de funcionalidades para la serialización y des-serialización de objetos en Python. La forma de guardar un modelo con esta librería es:

    import pickle
    pickle.dump(model, open('trading_model.p', 'wb'))
    

    La extensión no tiene por que ser esa pero yo la uso así para saber que se trata de un fichero guardado con Pickle y cuando vea este fichero en el futuro, de un vistazo, ya pueda saber cómo ha sido guardado y cómo tengo que volver a cargarlo.

    Para cargar los datos sería:

    import pickle
    loaded_model = pickle.load(open('trading_model.p', 'rb'))
    

    Aunque el formato Pickle es muy sencillo, como Scikit-Learn utiliza conceptos sencillo sin hiperparámetros que regular, es posible guardarlo en este formato sin necesitar otros datos.

    Tensorflow

    Una vez creado el modelo la forma de guardar los modelos de tensorflow es con HDF5. Aunque también se puede guardar en otros formatos como JSON, actualmente se está imponiendo la forma de guardar los modelos mediante este formato, ya que mejora en muchos aspectos a las anteriores formas de guardar los modelos. En JSON por ejemplo se guarda por un lado el modelo y por otro los pesos de los hiperparámetros del modelo. No es que sea mucho más complicado, pero es un paso a más a tener en cuenta.

    Con lo cual es mucho más sencillo guardar un modelo y usarlo más tarde utilizando este formato.

    La forma de guardar un modelo que ya ha sido entrenado es:

    # Venimos de un model.fit() ejecutado correctamente
    model.save('trading_model.h5')
    

    Y para cargarlo posteriormente:

    from keras.models import load_model
    model = load_model("trading_model.h5")
    

    Al contrario que sucedía en Scikit-Learn, el guardado de un modelo en tensorflow sí que necesita de no solo la forma de la red neuronal, sino también de otros muchos parámetros como:

    • Pesos
    • Arquitectura
    • Detalles de compilación del modelo (pérdidas y métricas)
    • Estado del optimizador del modelo

    Pero al realizar el guardado con HDFS5 esto viene todo incluido, lo que facilita mucho la tarea.

    Pytorch

    Aunque los modelos desde pytorch también se pueden guardar con el formato pickle, esta librería también trae su propio sistema de guardar modelos (que de hecho utilizan “pickle.dump()” y “pickle.load()”). La forma de guardar un modelo con esta librería es la siguiente:

    torch.save(model, "trading_model.pt")
    

    Al igual que sucede con Tensorflow, con esta forma no solo guardamos los datos del propio algoritmo sino también los pesos, arquitectura y otros detalles que necesita la librería para una correcta carga.

    model = torch.load("trading_model.pt")
    

    Una vez que ya tenemos la variable “model” ya podemos trabajar con el modelo tal y como lo hubiéramos hecho en el propio proyecto en el cual se guardó.

    Stable Baselines 3

    Si estamos haciendo modelos de aprendizaje reforzado ya nos tendremos que tirar por esta librería, que ya hemos visto en otras entradas. La forma de guardar un modelo con esta librería también es muy sencilla:

    model_PPO.save("trading_model_ppo.sb3")
    

    Para cargar el modelo en este caso se complica un poco más ya que hay que saber el algoritmo con el que se ha generado el modelo anterior (de hay que yo ponga un “_ppo” para reconocer que este modelo se ha hecho con el algortimo de Proximal Policy Optimization).

    Así que para cargar el modelo anteriormente generado con este algoritmo tendremos que importar el algoritmo y luego hacer un “.load”:

    from stable_baselines3 import PPO
    loaded_model = PPO.load("trading_model_ppo.sb3")
    

    Una vez cargado el modelo con el algoritmo correspondiente ya podemos empezar a trabajar de forma normal.

    Conceptos importantes para guardar un modelo

    Conceptos importantes para guardar un modelo

    No todo es tan sencillo como parece, hacerlo como se ve en muchos tutoriales por internet esta chupado, porque es el mismo código en donde se hace el “save” y el “load” del modelo, pero al hacer el guardado en un entorno y cargarlo en otro pueden surgir problemas.

    Hay que tener en cuenta que los datos que tiene que recibir el nuevo algoritmo tienen que tener el exactamente el mismo forma que con los que se ha realizado el guardado. Si varía algo en la estructura de los datos el modelo puede no funcionar o mostrar unos resultados completamente distintos a los que esperábamos.

    Otro detalle importante es que las versiones con las que estemos trabajando sean las idénticas. Me he encontrado muchos errores que eran debidos a un cambio en la versión, no solo de la librería con la que estemos trabajando, sino con la versión de Python con la que estamos haciendo nuestro código.

    Conclusiones

    Guardar un modelo y volver a cargarlo con los datos de nuestros algoritmos es uno de esos detalles que son cruciales pero poca gente tiene en cuenta, ya que no forma parte de, lo que llamaré, la parte divertida de hacer Machine Learning.

    Este problema surge cuando quieres realmente pasar a la acción con tu código y es ahí donde empiezan los dolores de cabeza.

    Tener claro cual es la librería que utilizamos, la versión de python que tenemos y como son los datos que estamos entregando al modelo son las partes que hay que tener muy claras a la hora de pasar un modelo a real. Tres pasos importantes que, si uno sale mal, puede que nuestro algoritmo no funcione como esperábamos.

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *