Desde el principio, BigML ha sido consciente de esa necesidad puesto que cada modelo creado en BigML, está inmediatamente disponible para la predicción a través de la API. No obstante, algunos escenarios necesitan que los modelos se distribuyan e implementen en otros lugares. Otra vez, la filosofía del modelo de caja blanca de BigML favorece que todos los modelos (y conjuntos de datos o cualquier otro recurso) creados en la plataforma también se puedan descargar como archivos JSON.
Históricamente, se han brindado herramientas para poder integrar esos modelos en varios entornos de software y hoy presentaremos bigmlflow el “sabor” que puedes añadir a MLFlow para administrar e implementar los modelos de aprendizaje automático de BigML.
BigML
Uso de modelos de Machine Learning en MLFlow requiere construir “sabores” para ellos. Cada “sabor” utiliza bibliotecas que se encargan de los detalles necesarios para serializar y predecir correctamente al utilizar la información del modelo. Para los modelos supervisados de BigML, esto es manejado por bigmlflow.
Instalando bigmlflow es tan fácil como usar el siguiente comando de pip
pip install bigmlflow
y el procedimiento de instalación se encargará de instalar las dependencias, como la versión correcta de MLFlow o los enlaces BigML Python, necesarios para acceder a la API de BigML. Entonces, en una sola línea, está listo para comenzar a trabajar.
Registro de modelos BigML con MLFlow
Para empezar, entremos al ambiente de MLFlow e inicia tu tablero con el siguiente comando
mlflow server --backend-store-uri=sqlite:///mlrunsdb.db \
--default-artifact-root=file:mlruns \
--host localhost \
--port 5000
que utilizará el sistema de archivos para almacenar todos los artefactos relacionados con el modelo, mientras que las entidades de MLFlow se almacenan en tablas SQLite. También estableceremos la variable de entorno necesaria para que MLFlow sepa dónde se manejará el seguimiento.
export MLFLOW_TRACKING_URI=http://localhost:5000
Al escribir esta URL en nuestro navegador, vemos una interfaz limpia que nos espera para crear o registrar nuevos modelos. Como queremos centrarnos en implementar y operar nuestros modelos para garantizar que sean procesables, primero registraremos un modelo BigML existente en la lista de experimentos de MLFlow usando bigmlflow. Esto requiere:
- Descargar el archivo JSON modelo de la API de BigML
- Usar la biblioteca bigmlflow para registrar el modelo
Los repositorios de bigmlflow contienen un directorio ejemplo donde puedes encontrar algunos modelos de BigML. En este ejemplo, usaremos una regresión logística
https://github.com/bigmlcom/bigmlflow/blob/master/examples/bigml_logistic/logistic_regression.json
que se ha construido a partir de datos de pacientes que pueden o no tener diabetes y cuyo objetivo es predecir si un nuevo paciente será diabético (diabetes=Verdadero) o no (diabetes=Falso).
Por supuesto, en su lugar puedes descargar cualquiera de los modelos que crees en BigML. Sin embargo, dado que los recursos son privados, se deben proporcionar tus credenciales para la autenticación. Una vez que los establezcas como variables de entorno el código de descarga equivaldrá a
from bigml.api import BigML api = BigML() api.export("logisticregression/62605ed90c11da5789002caf", "logistic_regression.json")
donde logisticregression/62605ed90c11da5789002caf será el ID del modelo a descargar y la descarga se almacenará en un archivo logistic_regression.json en tu directorio actual.
Ahora nos ayudará registrar ese modelo. Después de eso, podremos cargarlo nuevamente para producir predicciones a partir de él y asignar un punto final que proporcionará una API REST donde podremos enviar las entradas del marco de datos de Panda y recibir las predicciones correspondientes. El código también es bastante simple.
import json import mlflow import bigmlflow MODEL_FILE = "logistic_regression.json" with mlflow.start_run(): with open(MODEL_FILE) as handler: model = json.load(handler) bigmlflow.log_model(model, artifact_path="model", registered_model_name="my_model")
El modelo aparece como registrado en la consola de MLFlow:
Al hacer clic en el enlace del modelo, vemos la información sobre la referencia interna al modelo. En este caso, runs:/6297eabd4c2449f89e40ff503ca0fbf6/model. Imagina que deseas configurar un servicio que predice el uso de ese modelo. Solo necesitas usar el comando mlflow models serve
mlflow models serve --model-uri runs:/6297eabd4c2449f89e40ff503ca0fbf6/model \
-p 1234 --env-manager=local
y un nuevo servicio web estará esperando tus datos de entrada para generar predicciones. Podemos enviarle un par de entradas para probar rápidamente lo que podemos obtener.
$ curl http://localhost:1234/invocations \
-H 'Content-Type: application/json' \
-d '{"columns":["plasma glucose"], "data": [[90], [220]]}'[{"path": ["plasma glucose <= 123"], "confidence": 0.69324, "distribution": [["false", 85], ["true", 24]], "count": 109, "distribution_unit": "categories", "prediction": "false", "next": "bmi", "probability": 0.7781363636363636}, {"path": ["plasma glucose > 123", "plasma glucose > 166"], "confidence": 0.75033, "distribution": [["true", 23], ["false", 2]], "count": 25, "distribution_unit": "categories", "prediction": "true", "next": "bmi", "probability": 0.9001923076923077}]
¡Así que ahí estás! Un modelo de BigML desplegado y listo para realizar predicciones en tu servidor local. Por supuesto, puedes utilizar el resto de opciones que ofrece MLFlow e implementarlo en Google Cloud, AWS ML o la plataforma de tu elección.
Seguimiento de experimentos BigML
Pasamos del último al primero en nuestra explicación de cómo BigML se puede integrar en MLFlow y mostramos el paso final de la solución completa, pero, por supuesto, hay más. Puedes utilizar el seguimiento proporcionado por MLFlow para grabar tus experimentos con BigML también.
Por ejemplo, examinemos la siguiente parte del código proporcionado en nuestro ejemplo de entrenamiento en bigmlflow.
with mlflow.start_run():
model = api.create_model(train, args=model_conf)
print("Creating Model.")
api.ok(model, query_string="limit=-1")
evaluation = api.create_evaluation(model, test)
print("Creating Evaluation")
api.ok(evaluation)
print(
"BigML model: %s\nconf:%s (%s)"
% (
model["object"]["name"],
model["object"]["name_options"],
model["resource"],
)
)
print("accuracy: %s" % evaluation_metric(evaluation,
"accuracy"))
print("precision: %s" % evaluation_metric(evaluation,
"average_precision"))
print("recall: %s" % evaluation_metric(evaluation,
"average_recall"))
mlflow.log_param("args", json.dumps(model_conf))
mlflow.log_metric("accuracy", evaluation_metric(evaluation,
"accuracy"))
mlflow.log_metric(
"precision", evaluation_metric(evaluation,
"average_precision")
)
mlflow.log_metric("recall", evaluation_metric(evaluation,
"average_recall"))
Se crea un modelo en BigML usando API, el mismo objeto de conexión API que mencionamos antes. Cuando finaliza, se evalúa con una retención de prueba creada previamente. Los parámetros de configuración utilizados para crear el modelo, almacenados como model_conf también se registran en la información del experimento de MLFlow, junto con algunas de las métricas de evaluación proporcionadas. Ahora tenemos un nuevo experimento que mostrará estos valores:
Por supuesto, en escenarios realistas hay muchos parámetros que puede cambiar, y las evaluaciones ofrecen muchas métricas y puntos de referencia que también deben ser rastreados.
La buena noticia es que siempre podrás automatizar el registro porque todos los parámetros de configuración y los resultados estarán disponibles en los recursos de BigML tal como los proporciona la API. Como puedes ver, bigmlflow te ayuda a obtener lo mejor de ambas API’s de BigML y MLFlow.
