Usa Kubeflow Pipelines para el modelado de propensión en Google Cloud

En este documento, se describe un ejemplo de una canalización implementada en Google Cloud que realiza modelado de propensión. Está dirigido a ingenieros de datos, ingenieros de aprendizaje automático o equipos de ciencia de marketing que crean e implementan modelos de aprendizaje automático. En el documento, se supone que conoces conceptos de aprendizaje automático y que estás familiarizado con Google Cloud, BigQuery, Kubeflow Pipelines, Python y los notebooks de Jupyter. También se supone que conoces Google Analytics 360 y la función de exportación sin procesar en BigQuery.

La canalización con la que trabajas usa los datos de muestra de Google Analytics. La canalización compila varios modelos mediante BigQuery ML y XGBoost, y tú ejecutas la canalización mediante Kubeflow Pipelines en Vertex AI Pipelines. En este documento, se describen los procesos de entrenamiento de los modelos, su evaluación y su implementación. También se describe cómo puedes automatizar todo el proceso.

El código de canalización completo está en un notebook de Jupyter en un repositorio de GitHub.

¿Qué es el modelado de propensión?

El modelado de propensión predice acciones que un consumidor podría realizar. Los ejemplos de modelos de propensión incluyen predecir qué consumidores son más propensos a comprar un producto, registrarse para obtener un servicio o incluso desertar y ya no ser un cliente activo para una marca.

El resultado de un modelo de propensión es una puntuación entre 0 y 1 para cada consumidor, en la que esta puntuación representa la probabilidad de que el consumidor realice esa acción. Uno de los factores clave para impulsar a las organizaciones hacia el modelado de propensión es la necesidad de hacer más con los datos de origen. Para los casos de uso de marketing, los mejores modelos de propensión incluyen señales de fuentes en línea y sin conexión, como las estadísticas de sitio y los datos de CRM.

En esta demostración, se usan datos de muestra de GA360 que están en BigQuery. Para tu caso de uso, te recomendamos considerar señales sin conexión adicionales.

Cómo MLOps simplifica tus canalizaciones de AA

La mayoría de los modelos de AA no se usan en producción. Los resultados del modelo generan estadísticas y, con frecuencia, después de que los equipos de ciencia de datos finalizan un modelo, un equipo de ingeniería de software o ingeniería de AA debe unirlo al código para la producción mediante un framework como Flask o FastAPI. Este proceso a menudo requiere que el modelo se compile en un framework nuevo, lo que significa que se deben volver a transformar los datos. Este trabajo puede tardar semanas o meses y, por lo tanto, muchos modelos no llegan a la producción.

Las operaciones de aprendizaje automático (MLOps) se volvieron importantes para obtener valor de los proyectos de AA, y MLOps ahora es un conjunto de habilidades en constante evolución para las organizaciones de ciencia de datos. Para ayudar a las organizaciones a comprender este valor, Google Cloud publicó una Guía de profesionales para MLOps que proporciona una descripción general de MLOps.

Mediante el uso de los principios de MLOps y Google Cloud, puedes enviar modelos a un extremo mediante un proceso automático que quite gran parte de la complejidad del proceso manual. En las herramientas y el proceso descritos en este documento, se analiza un enfoque para ser propietario de tu canalización de extremo a extremo, lo que te ayuda a poner tus modelos en producción. En el documento de la guía de profesionales que se mencionó antes, se proporciona una solución horizontal y un resumen de lo que se puede hacer con MLOps y Google Cloud.

¿Qué es Kubeflow Pipelines y qué es Vertex AI?

Kubeflow Pipelines es un framework de código abierto que se usa para compilar la canalización.

Cada paso del proceso de Kubeflow Pipelines consta de un contenedor independiente que puede tomar entradas o producir resultados en forma de artefactos. Por ejemplo, si un paso del proceso compila tu conjunto de datos, el resultado es el artefacto de conjunto de datos. Este artefacto de conjunto de datos se puede usar como entrada para el siguiente paso. Debido a que cada componente es un contenedor independiente, debes proporcionar información para cada componente de la canalización, como el nombre de la imagen base y una lista de cualquier dependencia.

Las canalizaciones de Vertex AI te permiten ejecutar canalizaciones que se compilaron mediante Kubeflow Pipelines o TensorFlow Extended (TFX). Sin Vertex AI, la ejecución de cualquiera de estos frameworks de código abierto a gran escala requiere que configures y mantengas tus propios clústeres de Kubernetes. Vertex AI Pipelines aborda este desafío. Debido a que es un servicio administrado, aumenta o reduce verticalmente la escala según sea necesario, y no requiere mantenimiento continuo.

El proceso de compilación de la canalización

En el ejemplo descrito en este documento, se usa un notebook de Jupyter para crear los componentes de canalización y compilarlos, ejecutarlos y automatizarlos. Como se mencionó antes, el notebook está en un repositorio de GitHub.

Puedes ejecutar el código del notebook con Vertex AI Workbench, que controla la autenticación por ti. Vertex AI Workbench te permite trabajar con notebooks para crear máquinas, compilar notebooks y conectarte a Git. (Vertex AI Workbench incluye muchas características más, pero no se tratan en este documento).

Cuando finaliza la ejecución de la canalización, se genera un diagrama similar al siguiente en Vertex AI Pipelines:

Un grafo acíclico dirigido que muestra los componentes que ejecuta la canalización.

En el diagrama anterior, se muestra un grafo acíclico dirigido (DAG). La compilación y revisión del DAG es un paso central para comprender tus datos o tu canalización de AA. Los atributos clave de los DAG son que los componentes fluyen en una sola dirección (en este caso, de arriba abajo) y que no ocurre un ciclo, es decir, un componente superior no depende de su componente secundario. Algunos componentes pueden ocurrir en paralelo, mientras que otros tienen dependencias y, por lo tanto, ocurren en serie.

La casilla de verificación verde en cada componente indica que el código se ejecutó correctamente. Si se produjeron errores, verás un signo de exclamación rojo. Puedes hacer clic en cada componente del diagrama para ver más detalles del trabajo.

El diagrama de DAG se incluye en esta sección del documento como un modelo para cada componente que compila la canalización. En la siguiente lista, se proporciona una descripción de cada componente.

La canalización completa realiza los siguientes pasos, como se muestra en el diagrama de DAG:

  1. create-input-view: Este componente crea una vista de BigQuery. El componente copia SQL de un bucket de Cloud Storage y completa los valores de parámetros que proporcionas. Esta vista de BigQuery es el conjunto de datos de entrada que se usa para todos los modelos más adelante en la canalización.
  2. build-bqml-logistic: La canalización usa BigQuery ML para crear un modelo de regresión logística. Cuando se completa este componente, se puede ver un modelo nuevo en la consola de BigQuery. Puedes usar este objeto de modelo para ver el rendimiento del modelo y, luego, compilar predicciones.
  3. evaluate-bqml-logistic: La canalización usa este componente a fin de crear una curva de precisión/recuperación (logistic_data_path en el diagrama de DAG) para la regresión logística. Este artefacto se almacena en un bucket de Cloud Storage.
  4. build-bqml-xgboost: Este componente crea un modelo XGBoost mediante BigQuery ML. Cuando se completa este componente, puedes ver un objeto de modelo nuevo (system.Model) en la consola de BigQuery. Puedes usar este objeto para ver el rendimiento del modelo y, luego, compilar predicciones.
  5. evaluate-bqml-xgboost: Este componente crea una curva de precisión/recuperación llamada xgboost_data_path para el modelo XGBoost. Este artefacto se almacena en un bucket de Cloud Storage.
  6. build-xgb-xgboost: La canalización crea un modelo de XGBoost. Este componente usa Python en lugar de BigQuery ML, de modo que puedas ver diferentes enfoques para crear el modelo. Cuando este componente se completa, almacena un objeto de modelo y las métricas de rendimiento en un bucket de Cloud Storage.
  7. deploy-xgb: Este componente implementa el modelo XGBoost. Crea un extremo que permite predicciones en línea o por lotes. Puedes explorar el extremo en la pestaña Modelos en la página de la consola de Vertex AI. El extremo realiza un ajuste de escala automático para coincidir con el tráfico.
  8. build-bqml-automl: La canalización crea un modelo de AutoML mediante BigQuery ML. Cuando se completa este componente, se puede ver un objeto de modelo nuevo en la consola de BigQuery. Puedes usar este objeto para ver el rendimiento del modelo y, luego, compilar predicciones.
  9. evaluate-bqml-automl: La canalización crea una curva de precisión/recuperación para el modelo de AutoML. El artefacto se almacena en un bucket de Cloud Storage.

Ten en cuenta que el proceso no envía los modelos de BigQuery ML a un extremo. Esto se debe a que puedes generar predicciones directamente a partir del objeto de modelo que está en BigQuery. A medida que decidas entre usar BigQuery ML y usar otras bibliotecas para tu solución, considera cómo se deben generar las predicciones. Si una predicción por lotes diaria satisface tus necesidades, mantenerse en el entorno de BigQuery puede simplificar tu flujo de trabajo. Sin embargo, si necesitas predicciones en tiempo real o si tu situación necesita una función que esté en otra biblioteca, sigue los pasos de este documento para enviar tu modelo guardado a un extremo.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

  4. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  5. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

El notebook de Jupyter para esta situación

Las tareas para crear y compilar la canalización se compilan en un notebook de Jupyter que se encuentra en un repositorio de GitHub.

Para realizar las tareas, obtén el notebook y, luego, ejecuta las celdas de código en el notebook en orden. En el flujo descrito en este documento, se supone que ejecutas los notebooks en Vertex AI Workbench.

Abre el entorno de Vertex AI Workbench

Para comenzar, debes clonar el repositorio de GitHub en un entorno de Vertex AI Workbench.

  1. En la consola, selecciona el proyecto en el que deseas crear el notebook.
  2. Ve a la página Entrenamiento de Vertex AI Workbench.

    Ve a la página Vertex AI Workbench.

  3. En la pestaña Notebooks administrados por el usuario, haz clic en  Nuevo notebook .

  4. En la lista de tipos de notebooks, elige un notebook de Python 3.

  5. En el cuadro de diálogo Nuevo notebook, haz clic en Opciones avanzadas y, luego, en Tipo de máquina, selecciona el tipo de máquina que deseas usar. Si no estás seguro, elige n1-standard-1 (1 CPU virtual, 3.75 GB de RAM).

  6. Haga clic en Crear.

    El entorno del notebook toma unos minutos en crearse.

  7. Cuando el notebook se haya creado, selecciona el notebook y haz clic en Abrir Jupyterlab.

    El entorno de JupyterLab se abrirá en tu navegador.

  8. Para iniciar una pestaña de la terminal, selecciona Archivo > Nuevo > Launcher.

  9. Haz clic en el ícono de Terminal en la pestaña Launcher.

  10. En la terminal, clona el repositorio de GitHub mlops-on-gcp:

    git clone https://github.com/GoogleCloudPlatform/cloud-for-marketing/
    

    Cuando el comando finalice, verás la carpeta cloud-for-marketing en el navegador de archivos.

Configura los parámetros de los notebooks

Antes de ejecutar el notebook, debes configurarlo. El notebook requiere un bucket de Cloud Storage para almacenar artefactos de canalización, por lo que primero debes crear ese bucket.

  1. Crea un bucket de Cloud Storage en el que el notebook pueda almacenar artefactos de canalización. El nombre del bucket debe ser único a nivel global.
  2. En la carpeta cloud-for-marketing/marketing-analytics/predicting/kfp_pipeline/, abre el notebook Propensity_Pipeline.ipynb.
  3. En el notebook, establece el valor de la variable PROJECT_ID como el ID del proyecto de Cloud en el que deseas ejecutar la canalización.
  4. Establece el valor de la variable BUCKET_NAME en el nombre del bucket que acabas de crear.

En el resto de este documento, se describen los fragmentos de código que son importantes para comprender cómo funciona la canalización. Para ver la implementación completa, consulta el repositorio de GitHub.

Compila la vista de BigQuery

El primer paso de la canalización genera los datos de entrada, que se usarán para compilar cada modelo. Este componente de Kubeflow Pipelines genera una vista de BigQuery. Para simplificar el proceso de creación de la vista, un SQL ya se generó y se guardó en un archivo de texto en GitHub.

El código de cada componente comienza con decorar (modificar una clase o función superior mediante atributos) la clase de componente de Kubeflow Pipelines. Luego, el código define la función create_input_view, que es un paso en la canalización.

La función requiere varias entradas. Algunos de estos valores están hard-coded en el código, como la fecha de inicio y de finalización. Cuando automatizas tu canalización, puedes modificar el código para usar valores adecuados (por ejemplo, con la función CURRENT_DATE para una fecha). También puedes actualizar el componente para que tome estos valores como parámetros en lugar de mantenerlos hard-coded. También debes cambiar el valor de ga_data_ref al nombre de tu tabla de GA360 y establecer el valor de la variable conversion como tu conversión. (En este ejemplo, se usan los datos de muestra públicos de GA360)

En la siguiente lista, se muestra el código del componente create-input-view.

@component(
   # this component builds a BigQuery view, which will be the underlying source for model
   packages_to_install=["google-cloud-bigquery", "google-cloud-storage"],
   base_image="python:3.9",
   output_component_file="output_component/create_input_view.yaml",
)
def create_input_view(view_name: str,
                     data_set_id: str,
                     project_id: str,
                     bucket_name: str,
                     blob_path: str

):
   from google.cloud import bigquery
   from google.cloud import storage
   client = bigquery.Client(project=project_id)
   dataset = client.dataset(data_set_id)
   table_ref = dataset.table(view_name)
   ga_data_ref = 'bigquery-public-data.google_analytics_sample.ga_sessions_*'
   conversion = "hits.page.pageTitle like '%Shopping Cart%'"
   start_date = '20170101'
   end_date = '20170131'

def get_sql(bucket_name, blob_path):
       from google.cloud import storage
       storage_client = storage.Client()
       bucket = storage_client.get_bucket(bucket_name)
       blob = bucket.get_blob(blob_path)
       content = blob.download_as_string()
       return content
def if_tbl_exists(client, table_ref):

...

   else:
       content = get_sql()
       content = str(content, 'utf-8')
       create_base_feature_set_query = content.
                                   format(start_date = start_date,
                                   end_date = end_date,
                                   ga_data_ref = ga_data_ref,
                                   conversion = conversion)
shared_dataset_ref = client.dataset(data_set_id)
base_feature_set_view_ref = shared_dataset_ref.table(view_name)
base_feature_set_view = bigquery.Table(base_feature_set_view_ref)
base_feature_set_view.view_query = create_base_feature_set_query.format(project_id)
base_feature_set_view = client.create_table(base_feature_set_view)

Compila el modelo de BigQuery ML

Después de crear la vista, ejecuta el componente llamado build_bqml_logistic para compilar un modelo de BigQuery ML. Este bloque del notebook es un componente central. Mediante la vista de entrenamiento que creaste en el primer bloque, el notebook compila un modelo de BigQuery ML. En este ejemplo, el notebook usa la regresión logística.

Para obtener información sobre los tipos de modelo y los hiperparámetros disponibles, consulta la documentación de referencia de BigQuery ML.

En la siguiente lista, se muestra el código de este componente.

@component(
   # this component builds a logistic regression with BigQuery ML
   packages_to_install=["google-cloud-bigquery"],
   base_image="python:3.9",
   output_component_file="output_component/create_bqml_model_logistic.yaml"
)
def build_bqml_logistic(project_id: str,
                       data_set_id: str,
                       model_name: str,
                       training_view: str
):
   from google.cloud import bigquery
   client = bigquery.Client(project=project_id)
   model_name = f"{project_id}.{data_set_id}.{model_name}"
   training_set = f"{project_id}.{data_set_id}.{training_view}"
   build_model_query_bqml_logistic = '''
   CREATE OR REPLACE MODEL `{model_name}`
   OPTIONS(model_type='logistic_reg'
   , INPUT_LABEL_COLS = ['label']
   , L1_REG = 1
   , DATA_SPLIT_METHOD = 'RANDOM'
   , DATA_SPLIT_EVAL_FRACTION = 0.20
   ) AS
       SELECT * EXCEPT (fullVisitorId, label),
       CASE WHEN label is null then 0 ELSE label end as label
   FROM `{training_set}`
   '''.format(model_name = model_name, training_set = training_set)
job_config = bigquery.QueryJobConfig()
client.query(build_model_query_bqml_logistic, job_config=job_config)

Usa XGBoost en lugar de BigQuery ML

El componente ilustrado en la sección anterior usa BigQuery ML. En la siguiente sección de los notebooks, se muestra cómo usar XGBoost en Python directamente en lugar de usar BigQuery ML.

Ejecuta el componente llamado build_bqml_xgboost para compilar el componente y ejecutar un modelo de clasificación estándar de XGBoost con una búsqueda de cuadrícula. Luego, el código guarda el modelo como un artefacto en el bucket de Cloud Storage que creaste. La función admite parámetros adicionales (metrics y model) para los artefactos de salida. Kubeflow Pipelines requiere estos parámetros.

@component(
   # this component builds an xgboost classifier with xgboost
   packages_to_install=["google-cloud-bigquery", "xgboost", "pandas", "sklearn", "joblib", "pyarrow"],
   base_image="python:3.9",
   output_component_file="output_component/create_xgb_model_xgboost.yaml"
)
def build_xgb_xgboost(project_id: str,
                     data_set_id: str,
                     training_view: str,
                     metrics: Output[Metrics],
                     model: Output[Model]
):

...

  data_set = f"{project_id}.{data_set_id}.{training_view}"
  build_df_for_xgboost = '''
                         SELECT * FROM `{data_set}`
                         '''.format(data_set = data_set)

...

  xgb_model = XGBClassifier(n_estimators=50,
                            objective='binary:hinge',
                            silent=True,
                            nthread=1,
                           eval_metric="auc")
   random_search = RandomizedSearchCV(xgb_model,
                                     param_distributions=params,
                                     n_iter=param_comb,
                                     scoring='precision',
                                     n_jobs=4,
                                     cv=skf.split(X_train,y_train),
                                     verbose=3,
                                     random_state=1001 )
  random_search.fit(X_train, y_train)
  xgb_model_best = random_search.best_estimator_
  predictions = xgb_model_best.predict(X_test)
  score = accuracy_score(y_test, predictions)
  auc = roc_auc_score(y_test, predictions)
  precision_recall = precision_recall_curve(y_test, predictions)

  metrics.log_metric("accuracy",(score * 100.0))
  metrics.log_metric("framework", "xgboost")
  metrics.log_metric("dataset_size", len(df))
  metrics.log_metric("AUC", auc)

  dump(xgb_model_best, model.path + ".joblib")

Compila un extremo

Ejecuta el componente llamado deploy_xgb para compilar un extremo mediante el modelo XGBoost de la sección anterior. El componente toma el artefacto del modelo XGBoost anterior, compila un contenedor y, luego, implementa el extremo, mientras proporciona la URL del extremo como un artefacto para que puedas verlo. Cuando se completa este paso, se crea un extremo de Vertex AI, y puedes verlo en la página de la consola de Vertex AI.

@component(
   # Deploys xgboost model
   packages_to_install=["google-cloud-aiplatform", "joblib", "sklearn", "xgboost"],
   base_image="python:3.9",
   output_component_file="output_component/xgboost_deploy_component.yaml",
)
def deploy_xgb(
   model: Input[Model],
   project_id: str,
   vertex_endpoint: Output[Artifact],
   vertex_model: Output[Model]
):
   from google.cloud import aiplatform
   aiplatform.init(project=project_id)
   deployed_model = aiplatform.Model.upload(
       display_name="tai-propensity-test-pipeline",
       artifact_uri = model.uri.replace("model", ""),
       serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/xgboost-cpu.1-4:latest"
   )
   endpoint = deployed_model.deploy(machine_type="n1-standard-4")
# Save data to the output params
   vertex_endpoint.uri = endpoint.resource_name
   vertex_model.uri = deployed_model.resource_name

Define la canalización

Para definir la canalización, debes definir cada operación en función de los componentes que creaste antes. Luego, puedes especificar el orden de los elementos de la canalización si no se los llama de forma explícita en el componente.

Por ejemplo, el siguiente código en el notebook define una canalización. En este caso, el código requiere que el componente build_bqml_logistic_op se ejecute después del componente create_input_view_op.

@dsl.pipeline(
   # Default pipeline root. You can override it when submitting the pipeline.
   pipeline_root=PIPELINE_ROOT,
   # A name for the pipeline.
   name="pipeline-test",
   description='Propensity BigQuery ML Test'
)
def pipeline():

   create_input_view_op = create_input_view(
                          view_name = VIEW_NAME,
                          data_set_id = DATA_SET_ID,
                          project_id = PROJECT_ID,
                          bucket_name = BUCKET_NAME,
                          blob_path = BLOB_PATH
                                            )
    build_bqml_logistic_op = build_bqml_logistic(
                        project_id = PROJECT_ID,
                        data_set_id = DATA_SET_ID,
                        model_name = 'bqml_logistic_model',
                        training_view = VIEW_NAME
                                                  )

 # several components have been deleted for brevity

   build_bqml_logistic_op.after(create_input_view_op)
   build_bqml_xgboost_op.after(create_input_view_op)
   build_bqml_automl_op.after(create_input_view_op)
   build_xgb_xgboost_op.after(create_input_view_op)

   evaluate_bqml_logistic_op.after(build_bqml_logistic_op)
   evaluate_bqml_xgboost_op.after(build_bqml_xgboost_op)
   evaluate_bqml_automl_op.after(build_bqml_automl_op)

Compila y ejecuta la canalización

Ahora puedes compilar y ejecutar la canalización.

Con el siguiente código del notebook, se establece el valor enable_caching como verdadero para habilitar el almacenamiento en caché. Cuando el almacenamiento en caché está habilitado, las ejecuciones anteriores en las que un componente se completó de forma correcta no se volverán a ejecutar. Esta marca es útil, en especial, cuando estás probando la canalización, porque cuando el almacenamiento en caché está habilitado, la ejecución se completa más rápido y usa menos recursos.

compiler.Compiler().compile(
   pipeline_func=pipeline, package_path="pipeline.json"
)
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
run = pipeline_jobs.PipelineJob(
   display_name="test-pipeine",
   template_path="pipeline.json",

   job_id="test-{0}".format(TIMESTAMP),
   enable_caching=True
)
run.run()

Automatiza la canalización

En esta etapa, lanzaste la primera canalización. Puedes consultar la página Vertex AI Pipelines en la consola para ver el estado de este trabajo. Puedes observar cómo se compila y ejecuta cada contenedor. También puedes realizar un seguimiento de los errores de componentes específicos en esta sección si haces clic en cada uno.

Para programar la canalización, debes compilar una función de Cloud Functions y usar un programador que sea similar a un trabajo cron.

El código de la última sección del notebook programa la canalización para que se ejecute una vez al día, como se muestra en el siguiente fragmento de código:

from kfp.v2.google.client import AIPlatformClient
api_client = AIPlatformClient(project_id=PROJECT_ID,
                            region='us-central1'
                            )
api_client.create_schedule_from_job_spec(
   job_spec_path='pipeline.json',
   schedule='0 * * * *',
   enable_caching=False
)

Usa la canalización finalizada en producción

La canalización completada realizó las siguientes tareas:

  • Creó un conjunto de datos de entrada.
  • Entrenó varios modelos mediante BigQuery ML y XGBoost de Python.
  • Analizó los resultados del modelo.
  • Implementó el modelo XGBoost.

También automatizaste la canalización con Cloud Functions y Cloud Scheduler para que se ejecuten a diario.

La canalización que se define en el notebook se creó para ilustrar las formas de crear varios modelos. No ejecutarías la canalización como está compilada actualmente en una situación de producción. Sin embargo, puedes usar esta canalización como guía y modificar los componentes para que se adapten a tus necesidades. Por ejemplo, puedes editar el proceso de creación de atributos para aprovechar tus datos, modificar los períodos y, quizás, compilar modelos alternativos. También debes elegir el modelo entre los que se ilustran que se adapte mejor a tus requisitos de producción.

Cuando la canalización esté lista para la producción, puedes implementar tareas adicionales. Por ejemplo, puedes implementar un modelo de campeón y retador, en el que se crea un modelo nuevo cada día y el modelo nuevo (el retador) y el existente (el campeón) se puntúan sobre los datos nuevos. El modelo nuevo se pone en producción solo si su rendimiento es mejor que el del modelo actual. Para supervisar el progreso del sistema, también puedes mantener un registro del rendimiento del modelo de cada día y visualizar las tendencias de rendimiento.

¿Qué sigue?