Introducción

...

Introducción

Se va a generar un modelo de predicción a partir de datos sobre diabetes, modelo que va a permitir predecir una medida cuantitativa de la progresión de la enfermedad un año después de la línea base. Vamos a utilizar

Para ello se van a utilizar los siguientes módulos de Onesait Platform:

• Entidades: para generar una Entidad histórica donde cargar los datos.

• File Repository sobre MinIO: para guardar el conjunto de datos original. Cargaremos el archivo utilizando el módulo Create Entity in Historical Database

• Notebooks:para tener utilizar un proceso paramétrico para obtener los datos de MinIO, entrenar y generar el modelo, y registrar todo en el módulo de MLFlow.

• Gestor de Modelos (MLFlow) MLFlow: como gestor de modelos para registrar todos los experimentos del cuaderno Notebook, y guardar el modelo y otros archivos para el entrenamiento.

• Módulo Serverless:para crear una función python Python escalable que, usando el modelo generado, pueda predecir la progresión de la enfermedad.

Dataset

La información del conjunto de datos sobre diabetes es la siguiente.

 Se obtuvieron diez variables de base, edad, sexo, índice de masa corporal, presión y seis mediciones de suero sanguíneo para cada uno de los 442 pacientes diabéticos, así como la respuesta de interés, una medida cuantitativa de la progresión de la enfermedad un año después de la línea de base.

Características del dataset:

• Número de instancias: 44

• Número de atributos: Las 10 primeras columnas son valores predictivos numéricos

• Target: La columna 11 es una medida cuantitativa de la progresión de la enfermedad un año después de la línea de base

Información sobre atributos:

• age     age in years

• sex

• bmi     body mass index

• bp      average blood pressure

• s1      tc, total serum cholesterol

• s2      ldl, low-density lipoproteins

• s3      hdl, high-density lipoproteins

• s4      tch, total cholesterol / HDL

• s5      ltg, possibly log of serum triglycerides level

• s6      glu, blood sugar level

...

Datos

Para llevar a cabo este modelo predictivo se van a utilizar datos de diabetes obtenidos de la Universidad de Standford y cedidos por Bradley Efron, Trevor Hastie, Iain Johnstone y Robert Tibshirani. Concretamente, el dataset de datos a utilizar se puede descargar desde este enlace, y tiene el siguiente aspecto:

...

Este conjunto de datos, completamente anonimizado, se compone de diez variables con información de 442 pacientes diabéticos. Dichas variables hacen referencia a:

• AGE: la edad del paciente, en años.

• SEX: el sexo del paciente.

• BMI: el índice de masa corporal.

• BP: la presión sanguínea media.

• S1: tc; colesterol sérico total.

• S2: ldl; lipoproteínas de baja densidad.

• S3: hdl; lipoproteínas de alta densidad.

• S4: tch; colesterol total / HDL.

• S5: ltg; logaritmo del nivel de triglicéridos séricos.

• S6: glu; nivel de glucosa en sangre.

Source URL:

https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html

For more information see:

Bradley Efron, Trevor Hastie, Iain Johnstone and Robert Tibshirani (2004) "Least Angle Regression," Annals of Statistics (with discussion), 407-499.

(https://web.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf)'

Paso 1: Cargar datos en la plataforma MinIO

Desde el enlace vamos a obtener el archivo de esta fuente https://www4.stat.ncsu.edu/~boos/var.select/diabetes.tab.txt

Vamos a crear una "Entidad en Base de Datos Histórica" a partir de este archivo así que iremos a esta opción:

...

Rellenaremos la información principal

...

Y pulsar en continuar. A continuación, tenemos que rellenar todas las columnas del archivo con el formato de cadena (esto es porque el archivo CSV necesita ser cargado con este tipo de columna)

...

Finalmente pulsamos el botón crear y se creará nuestra nueva entidad:

...

También podemos consultar esta entidad en SQL a través de Presto con el Query Tool

Paso 2: Crear libreta para obtener datos, entrenar y registrar el experimento

En primer lugar, vamos a crear un nuevo notebook, nos dirigimos a la opción Analytics Tools y pulsamos en el botón nuevo notebook (+) le escribimos un nombre

...

También podemos importar este archivo que contiene el cuaderno completo para este ejemplo (sólo tenemos que establecer el parámetro token)

Tenemos algunos párrafos explicativos para el conjunto de datos, pero vamos a la sección de código.

El primer párrafo que vamos a enfocar es el de importación

...

Cargamos muchas librerías y establecemos la url base para el repositorio MinIO. El siguiente párrafo va a ser el párrafo de parámetros con el fin de establecer variables que pueden venir de fuera

...

Para obtener la ruta del archivo podemos ir a la sección My Files:

...

Luego a MinIO

...

Y en la siguiente página podemos obtener la ruta del archivo

...

El token será algún token X-OP-APIKey que pueda acceder al fichero.

A continuación en 3 apartados cargaremos el propio fichero csv y el filepath del apartado anterior, lo leemos como csv con la columna del dataset (necesitamos incluir las columnas en la función read_csv) y mostramos el contenido cargado:

...

Ahora que tenemos nuestro archivo como pandas dataframe podemos dividir los datos en conjuntos de entrenamiento y prueba:

...

Divida también estos conjuntos de datos en conjuntos de datos X e Y para los parámetros de entrada y los resultados esperados:

...

Y ejecute el entrenamiento de ElasticNet con estos datos y obtenga en lr el modelo de salida

...

Por último, evaluamos alguna métrica para el resultado de la predicción:

Paso 3: Registrar los datos de entrenamiento y del modelo en MLFlow

El Notebook Engineestá integrado con el servicio de seguimiento de MLFlow, por lo que lo único que tenemos que hacer en el cuaderno es importar la librería "MLFlow" necesaria y utilizar las funciones de seguimiento de MLFlow. Eso se hará en la sección de librerías de importación

...

Los parámetros de conexión y las variables de entorno ya están hechos, así que ahora podemos registrar los parámetros en MLFlow directamente de esta manera

...

%python

with mlflow.start_run():
    mlflow.set_tag("mlflow.runName", "DiabetesModelGenerator")
    mlflow.log_param("alpha", alpha)
    mlflow.log_param("l1_ratio", l1_ratio)
    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)
    mlflow.log_metric("mae", mae)
    mlflow.sklearn.log_model(lr, "model")
    mlflow.end_run()

Este es el código estándar para el seguimiento de un experimento en MLFlow. Incluimos todo dentro de “with mlflow.start_run()“ para iniciar un nuevo experimento.

Las otras funciones son:

• mlflow.set_tag("mlflow.runName", ...) →(opcional) para establecer un nombre de ejecución del experimento. Si no usamos esto sólo tendremos un id autogenerado, el ID del experimento

• mlflow.log_param(...) → registrar una parámetro de entrada para el experimento

• mlflow.log_metric(...) → registrar una métrica de salida para el experimento

• mlflow.sklearn.log_model(lr, "model") → registra y guarda el modelo entrenado con todos los archivos de metadatos necesarios

Si ejecutamos este párrafo vamos a tener una salida como esta. El proceso de registro ha terminado bien.

...

Si vamos a la interfaz de usuario del Gestor de Modelos en el Control Panel:

...

Podemos ver la ejecución del experimento con todos los parámetros de registro, las métricas y los archivos:

...

Al hacer clic en el experimento, se abre la página de detalles:

...

Y, al final de la página, podemos revisar todos los archivos de este experimento y el propio modelo

...

El run id de la derecha (runs:/859953c3a0dd4596bd15d864e91081ab/model) es importante porque lo vamos a utilizar para publicar el modelo en el siguiente paso. Esta es la referencia que necesitamos para recoger el modelo en el MLFlow y hacer algunas evaluaciones con él.

También podemos registrar el con el fin de etiquetarlo, versionarlo y tenerlo fuera del experimento, podemos hacerlo con el código o podemos utilizar el botón de registro en el lado derecho:

...

Y si vamos a la pestaña modelo podemos verlo y trabajar con él

Paso 4: Crear una función Serverless en Python que evalúe los datos contra el modelo MLFlow

Con el modelo generado anteriormente vamos a crear una función Python que, con una entrada simple o múltiple, pueda obtener una predicción usando el modelo.

El primer paso es ir al menú Serverless Applications

...

A continuación vamos a crear (con el botón +) una nueva aplicación y vamos a rellenar todas las entradas necesarias

...

Podemos crear un nuevo repositorio o utilizar uno existente. En cualquier caso, vamos a tener una nueva aplicación como esta:

...

Luego podemos ir al botón "Ver" y luego a la pestaña de funciones

...

El siguiente paso es crear o utilizar una función serverless existente, hacemos clic en "Create Function" y vamos a crear tres archivos.

En primer lugar, seleccionamos Además, se cuenta con una medida cuantitativa de la progresión de la enfermedad un año después de la línea de base, denominada como «Y».

Ejecución del demostrador

A continuación se explican los diferentes pasos a llevar a cabo.

Paso 1.- Crear la Entidad

Una vez que se tienen los datos de diabetes descargados en el local, el primer paso consistirá en crear una Entidad para almacenarlos en Onesait Platform y poder trabajar con ellos.

En este caso, se va a crear una Entidad en una base de datos histórica. Para ello, se navegará desde Control Panel al menú de Conceptos principales > Mis Entidades.

Image Added

Se mostrará entonces el listado de Entidades del usuario. Se pulsará en el botón de «+» para crear una nueva Entidad.

...

De entre las distintas opciones, se seleccionará la de «Creación Entidad en BD Histórica»:

...

Se cuenta con dos opciones de Entidad histórica. De ambas, se seleccionará la primera opción, la de «Creación Entidad en BD Histórica»:

...

Seguidamente se mostrará el asistente de creación de la Entidad en donde, al igual que en el resto de Entidades, se tendrá que introducir una información básica:

...

• Identificación: el nombre único con el que identificar a la Entidad. En este caso se introducirá «diabetes_raw».

• Meta-Información: etiquetas con las que caracterizar la Entidad, que servirán para su filtrado a la hora de hacer búsquedas. Se pueden añadir algunas etiquetas referidas al tema, como pueden ser «diabetes», «dataset» o «ml».

• Descripción: texto descriptivo extendido de la Entidad, como su uso, propiedades, características, etc. Por simplificar, se añadirá «Dataset de valores de diabetes».

Además, contamos con dos opciones de caracterización de la Entidad:

• Entidad activa: para que la Entidad funcione o se encuentre bloqueada.

• Entidad pública: si se quiere que la Entidad sea pública, o si se quiere privada.

Una vez definida la información general y las opciones de la Entidad, pulsaremos en el botón de «Continuar» para acceder a la definición del esquema de la Entidad.

...

A continuación, se tendrá que crear los campos correspondientes a la cabecera de la tabla. Todos estos campos serán de tipo «string», y no será necesario indicar la descripción del campo.

...

Una vez creados los campos, se procederá a indicar las opciones del archivo original de los datos. Aquí se indicarán las siguientes opciones:

...

• Formato: el formato del archivo de datos. En este caso se trata de un archivo separado por comas (CSV).

• Carácter de escape: ninguno.

• Carácter de citación: ninguno.

• Carácter de separación: en este caso, los datos están separados por tabulaciones, por lo que se añadirá «|» para indicar este tipo de carácter.

Seguidamente están las opciones de particiones, pero no aplican para este tutorial, por lo que se omiten.

Por último se tendrá que actualizar la consulta SQL de la Entidad. Para ello se pulsará en el botón de «Actualizar SQL», y al momento se mostrará la nueva consulta SQL:

...

A continuación, se generará el esquema de la Entidad pulsando en el botón de «Generar esquema»:

...

Hecho esto, se terminará pulsando en el botón de «Crear», situado en la parte superior derecha de la pantalla, para crear la nueva Entidad.

...

Tras pulsar el botón de crear, aparecerá un aviso indicando si se quiere añadir datos a la Entidad. Esto se realizará en el siguiente paso, por lo que se puede omitir.

...

Creada la Entidad, se regresará al listado de Entidades del usuario, en donde se podrá comprobar que aparece correctamente.

...

Paso 2.- Cargar los datos en MinIO

Aunque en el paso anterior era posible cargar los datos directamente, se quiere mostrar cómo subir el archivo de datos a un bucket de MinIO.

Para ello, desde Control Panel se navegará a Conceptos principales > Mis Ficheros.

...

De entre las diversas opciones disponibles, se escogerá la de «MinIO».

...

Se mostrará entonces el navegador de contenidos del Bucket de MinIO.

...

Además, en la parte inferior se visualizarán los archivos, propios y compartidos por otros usuarios, disponibles.

...

Se puede subir un archivo tanto usando el Bucket superior como desde el listado de archivos disponibles. Como la segunda opción es similar a otros recursos de la Plataforma, como las Entidades, se usará la primera opción para mostrar su funcionamiento.

Para ello, desde el navegador de contenidos, se pulsará en la carpeta de «datalake» y se navegará hasta el destino donde se quiera subir el archivo. Por ejemplo: «analyticsbucket/datalake/diabetes_raw».

...

Una vez en la ruta seleccionada, se pulsará en el botón de «Upload» y se seleccionará la opción de «Upload File» para subir el archivo desde el local:

...

Hecho esto, el archivo CSV con los datos de diabetes aparecerá en el listado del Bucket:

...

Puesto que más adelante se va a necesitar, es recomendable apuntar la ruta del archivo subido. Esto se puede ver en el listado de archivos inferior, que para este caso sería «analyticsbucket/datalake/diabetes_raw/select_diabetes.tab_20230927170218.csv».

...

Paso 3.- Crear el Notebook

Para crear un nuevo Notebook, desde Control Panel se navegará hasta el menú de Procesamiento > Mis Notebooks.

...

Se mostrará entonces el listado de Notebooks del usuario, así como aquellos públicos. Se pulsará en el botón de «+» para crear un nuevo Notebook.

...

Aparecerá entonces una ventana pidiendo que se introduzca el nombre del Notebook a crear. Aquí se indicará el nombre que interese, que para este ejemplo será «notebook_diabetes».

...

Una vez creado el Notebook, se procederá a configuración.

Paso 4.- Configurar el Notebook

El Notebook se compondrá se varios párrafos, cada uno de ellos orientado a definir una tarea.

En un primer párrafo se van a importar las librerías que se van a necesitar para llevar a cabo el experimento, así como definir el entorno de trabajo como variable global.

4.1.- Cargar la tabla de datos

We import request for doing rest calls and set global path vars

%python
import warnings
import requests
import io
import pandas as pd
import numpy as np
import mlflow
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import ElasticNet
from sklearn.linear_model import lasso_path, enet_path

# Set here the URL of the Platform instance
environment = "https://lab.onesaitplatform.com"

baseurl = environment + "/controlpanel/api/objectstorage"

Para este tutorial se hará uso de CloudLab, la instancia de experimentación de Onesait Platform.

...

Seguidamente, en un nuevo párrafo, se definirán los parámetros de entrada que se ejecutarán como proceso en el Notebook.

Set input params if we want to execute this notebook as process

%python
token = z.input("token")
filepath = z.input("filepath")
alpha_str = z.input("alpha")
l1_ratio_str = z.input("l1_ratio")
alpha = float(alpha_str)
l1_ratio = float(l1_ratio_str)

Algunos de estos parámetros (lo que presentan un z.input()) serán campos a introducir por el usuario que lleve a cabo el experimento, siendo:

...

• Token: el token personal del usuario que lleva a cabo el experimento, y que puede encontrarse en el menú contextual anejo al nombre de usuario.

...

• FilePath: la localización del archivo de datos que se ha cargado en MinIO, y que se comentó que era interesante apuntar. Como recordatorio, sería: «analyticsbucket/datalake/diabetes_raw/select_diabetes.tab_20230927170218.csv»

• Alpha y l1_ratio: dos parámetros del experimento, que se mantendrán con el valor de «0.05».

A continuación se recuperará el archivo de datos de diabetes desde MinIO. Para ello se generará el siguiente párrafo:

Get file from MinIO

%python
response = requests.get(url = baseurl + "?filePath=" + filepath, params = {}, headers= {"X-OP-APIKey":token})
stream=response.content

Si existe algún problema con el token de usuario, mostrando el valor de la variable «stream» mostrará el error correspondiente.

...

Si no hay problemas con el token, se continuará creando un nuevo párrafo en el que se definirá la cabecera de la tabla, así como se creará la tabla en el Notebook.

We set the column for the dataset and read the content as csv

%python
colnames=['age', 'sex','bmi','bp','s1','s2','s3','s4','s5','s6', 'progression']
data = pd.read_csv(io.StringIO(stream.decode('utf-8')), sep="\t", header=0, names=colnames )

Para comprobar que la tabla se ha generado correctamente, se puede mostrar la tabla con el siguiente párrafo:

Show the file loaded as dataframe

%python
data

La salida debería mostrar la tabla:

...

Si la tabla no llegase a cargar correctamente, se mostrará un mensaje que indica «Empty DataFrame»:

...

4.2.- Preparar los datos para el entrenamiento

Una vez que la tabla está cargada y los datos se muestran correctamente, seguidamente se va a preparar los datasets de entrenamiento y pruebas.

Para ello, se preparará un nuevo párrafo en el que se desactivarán los avisos, se generará una nueva semilla aleatoria, y se separará el dataset en dos grupos de datos: uno de entrenamiento, que contendrá el 75% de los datos, y otro de prueba, que contará con el 25% de datos restantes.

Split the data in train a test

%python
warnings.filterwarnings("ignore")
np.random.seed(40)

# Split the data into training and test sets. (0.75, 0.25) split.
train, test = train_test_split(data)

Para comprobar los datasets de entrenamiento y prueba, se pueden generar dos nuevos párrafos con el siguiente código:

Show train set

%python
train

Que mostrará:

...

Show test set

%python
test

Que en este caso mostrará:

...

Con esto se comprueba que los datasets ya están preparados. Sin embargo, hay un campo que no hace falta, y es el de «progression», ya que esta columna predicha es una medida cuantitativa de la progresión de la enfermedad un año después del inicio.

Por tanto, se va a quitar dicha columna de los datasets de entrenamiento y prueba mediante el siguiente párrafo:

Split for target column

%python
train_x = train.drop(["progression"], axis=1)
test_x = test.drop(["progression"], axis=1)
train_y = train[["progression"]]
test_y = test[["progression"]]

Para comprobar cómo quedan los datasets, se podrá mostrar los datos se manera similar a cómo se hizo previamente con estos párrafos:

Show train_x

%python
train_x

...

Show train_y

%python
train_y

...

Show test_x

%python
test_x

...

Show test_y

%python
test_y

...

Una vez que se ha comprobado que los datos son correctos, se procederá a realizar el entrenamiento con ElasticNet:

Run train with input params

%python
# Run ElasticNet
lr = ElasticNet(alpha=alpha, l1_ratio=l1_ratio, random_state=42)
lr.fit(train_x, train_y)
predicted_qualities = lr.predict(test_x)

Este párrafo no devolverá ninguna información, por lo que habrá que crear otro párrafo con la evaluación de las métricas para mostrar los resultados del modelo de entrenamiento:

Metrics Evaluation

%python
# Evaluate metrics
def eval_metrics(actual, pred):
    rmse = np.sqrt(mean_squared_error(actual, pred))
    mae = mean_absolute_error(actual, pred)
    r2 = r2_score(actual, pred)
    return rmse, mae, r2
(rmse, mae, r2) = eval_metrics(test_y, predicted_qualities)
# Print out ElasticNet model metrics
print("Elasticnet model (alpha=%f, l1_ratio=%f):" % (alpha, l1_ratio))
print("  RMSE: %s" % rmse)
print("  MAE: %s" % mae)
print("  R2: %s" % r2)

Al ejecutarlo, debería de salir los siguientes resultados:

...

Se considera que, para este experimento, estos resultados son correctos, por lo que únicamente faltará registrar el experimento en la interfaz del componente MLFlow.

Paso 5.- Registrar los datos de entrenamiento y del modelo en MLFlow

Para registrar el experimento en el módulo de MLFlow, se creará un nuevo párrafo con el siguiente código:

%python
with mlflow.start_run():
    mlflow.set_tag("mlflow.runName", "DiabetesModelGenerator")
    mlflow.log_param("alpha", alpha)
    mlflow.log_param("l1_ratio", l1_ratio)
    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)
    mlflow.log_metric("mae", mae)
    mlflow.sklearn.log_model(sk_model=lr, artifact_path="model")
    mlflow.end_run()

Del código anterior, es interesante hacer referencia a la línea de

mlflow.sklearn.log_model(sk_model=lr, artifact_path="model")

Con este comando, se va a registrar y guardar el modelo entrenado, con todos los archivos de metadatos necesarios.

Si todo va correctamente, el resultado será como el siguiente:

...

Si se navega hasta el gestor de modelos, se podrá ver la ejecución del experimento, con todos los parámetros de registro, las métricas y los archivos. Para ello, se navegará al menú de Procesamiento > MLOps:

...

Accediendo, se mostrará entonces el resumen de los modelos ejecutados

...

Al hacer clic en el experimento, se abre la página de detalles:

...

Y, al final de la página, se va a poder revisar todos los archivos de este experimento y el propio modelo:

...

El identificador (ID) del experimento de la derecha (runs:/859953c3a0dd4596bd15d864e91081ab/model) es importante porque se va a utilizar para publicar el modelo en el siguiente paso. Ésta es la referencia que se necesita para recoger el modelo en el MLFlow y hacer algunas evaluaciones con él.

También se puede registrar con el fin de etiquetarlo, versionarlo y tenerlo fuera del experimento. Se va a poder hacer con el código o se puede utilizar el botón de registro en el lado derecho:

...

Una vez registrado, aparecerá un aviso en la parte derecha indicando que se ha registro el experimento correctamente.

...

Navegando a la pestaña del modelo, se podrá verlo y trabajar con él.

Paso 7.- Crear una función serverless en Python que evalúe los datos contra el modelo MLFlow

Con el modelo generado anteriormente, se va a crear una función de Python que, con una entrada simple o múltiple, pueda obtener una predicción usando el modelo.

Para ello, se navegará hasta el menú de Lógica > Mis Funciones.

...

Esto mostrará el listado de aplicaciones serverless disponibles para el usuario. Se creará una nueva aplicación pulsando en el botón «+» situado en la parte superior derecha.

...

Aparecerá entonces el asistente de creación de la aplicación. En caso de no contar con un repositorio GIT en el que trabajar, habrá que crear uno nuevo rellenando la siguiente información:

...

• Nombre: el identificador único de la aplicación serverless.

• URL del servidor de GIT: dirección donde se encuentra el repositorio de GIT.

• Usuario del GIT: el usuario con permisos en el repositorio.

• Token privado: credencial de acceso al repositorio

• Nombre del grupo de GIT: propiedad que sólo aplica a GitLab.

• Rama GIT de trabajo: rama en la que trabajar en el repositorio.

Una vez rellena la información, se pulsará en el botón de «Crear» situado en la parte superior derecha de la pantalla para terminar la creación de la aplicación, y se regresará al listado de aplicaciones disponibles, donde ya aparecerá la que se acaba de crear.

...

Seguidamente, se pulsará en el botón de «Ver» para visualizar el modelo, y se navegará a la pestaña de «Funciones»:

...

El siguiente paso será crear o utilizar una función serverless existente. Se pulsará en el botón de «Create Function», y se crearán tres archivos.

En primer lugar, selecciona la rama principal en el lado derecho:

...

Luego vamos vas a crear (aquí o en el repositorio git Git con un editor externo) los 3 tres archivos:

requirements.txt → librerías que necesita nuestro tu modelo para ejecutarse. En este caso vamos , vas a tener estos:

...

fdk
protobuf==3.20.*
numpy==1.23.4
mlflow==1.19.0
mlflow-onesaitplatform-plugin==0.2.11
scikit-learn

...

Es importante el triggers.source config para tener el endpoint para esta función, el nombre y el tiempo de ejecución.

func.py →el contenido de la función de evaluación en sí. Tenemos Tienes que cargar las bibliotecas para evaluar el modelo, MLFlow y fdk para el punto final.

También utilizamos utilizarás una variable de entorno para la entrada paramétrica del host, experimento y token.

...

import io
import json
import logging
import os
os.environ["HOME"] = "/tmp"
import random
import mlflow

from fdk import response

host = os.environ['HOST']
token = os.environ['TOKEN']
experimentid = os.environ['EXPERIMENTID']

tracking_uri = "https://" + host + "/controlpanel/modelsmanager"
model_uri = "onesait-platform://" + token +  "@" + host + "/0/" + experimentid + "/artifacts/model"
global pyfunc_predictor

mlflow.set_tracking_uri(tracking_uri)
pyfunc_predictor = mlflow.pyfunc.load_model(model_uri=model_uri)
logging.getLogger().info("Diabetes Progression Predictor ready")

def handler(ctx, data: io.BytesIO = None):
    try:
        logging.getLogger().info("Try")
        answer = []
        json_obj = json.loads(data.getvalue())
        logging.getLogger().info("json_obj")
        logging.getLogger().info(str(json_obj))
        if isinstance(json_obj, list):
            logging.getLogger().info("isinstance")
            answer = []
            values = []
            inputvector = []
            for input in json_obj:
                logging.getLogger().info("for")
                logging.getLogger().info("input: " + str(input))
                inputvector = [ input['age'], input['sex'], input['bmi'], input['bp'], input['s1'], input['s2'], input['s3'], input['s4'], input['s5'], input['s6']]
                values.append(inputvector)
                
            predict = pyfunc_predictor.predict(values)
            answer = predict.tolist()
            logging.getLogger().info("prediction")
        else:
            answer = "input object is not an array of objects:" + str(json_obj)
            logging.getLogger().error('error isinstance(json_obj, list):' + isinstance(json_obj, list))
            raise Exception(answer)
    except (Exception, ValueError) as ex:

        logging.getLogger().error('error parsing json payload: ' + str(ex))

    logging.getLogger().info("Inside Python ML function")
    return response.Response(
        ctx, response_data=json.dumps(answer),
        headers={"Content-Type": "application/json"}
    )

Podemos Puedes guardar todo y desplegar nuestra tu función con el botón Rocket:

...

El último paso es poner las variables de entorno para el modelo con el botón:

...

Paso

...

8.- Evaluación del modelo

Ahora podemos puedes probar el modelo con la API Rest REST con postman Postman por ejemplo enviando un array de json JSON con la entrada:

...

O podemos puedes crear un evaluador de modelo en el Dashboard Engine que utilice este punto final con alguna entrada proporcionada:

...

O podemos puedes evaluar este modelo en un flujo de datos en batch o en streaming en el DataFlow con el componente evaluador correspondiente:

...