Hacer ingeniería de atributos con la cláusula TRANSFORM

En este instructivo, se explica cómo usar la cláusula TRANSFORM de la instrucción CREATE MODEL para realizar ingeniería de atributos al mismo tiempo que creas y entrenas un modelo. Con la cláusula TRANSFORM, puedes especificar una o más funciones de procesamiento previo para transformar los datos de entrada que usas para entrenar el modelo. El preprocesamiento que aplicas al modelo se aplica automáticamente cuando usas el modelo con las funciones ML.EVALUATE y ML.PREDICT.

En este instructivo, se usa el conjunto de datos bigquery-public-data.ml_datasets.penguin público.

Crea un conjunto de datos

Crea un conjunto de datos de BigQuery para almacenar tu modelo de AA.

Console

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a la página de BigQuery

2. En el panel Explorador, haz clic en el nombre de tu proyecto.

3. Haz clic en Ver acciones > Crear conjunto de datos.

4. En la página Crear conjunto de datos, haz lo siguiente:

   • En ID del conjunto de datos, ingresa bqml_tutorial.

   • En Tipo de ubicación, selecciona Multirregión y, luego, EE.UU. (varias regiones en Estados Unidos).

   • Deja la configuración predeterminada restante como está y haz clic en Crear conjunto de datos.

bq

Para crear un conjunto de datos nuevo, usa el comando bq mk con la marca --location. Para obtener una lista completa de los parámetros posibles, consulta la referencia del comando bq mk --dataset.

1. Crea un conjunto de datos llamado bqml_tutorial con la ubicación de los datos establecida en US y una descripción de BigQuery ML tutorial dataset:

   bq --location=US mk -d \
    --description "BigQuery ML tutorial dataset." \
    bqml_tutorial

   En lugar de usar la marca --dataset, el comando usa el acceso directo -d. Si omites -d y --dataset, el comando crea un conjunto de datos de manera predeterminada.

2. Confirma que se haya creado el conjunto de datos:

   bq ls

API

Llama al método datasets.insert con un recurso de conjunto de datos definido.

{
  "datasetReference": {
     "datasetId": "bqml_tutorial"
  }
}

Permite trabajar con BigQuery DataFrames.

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de BigQuery DataFrames.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura ADC para un entorno de desarrollo local.

import google.cloud.bigquery

bqclient = google.cloud.bigquery.Client()
bqclient.create_dataset("bqml_tutorial", exists_ok=True)

Crea el modelo

Crea un modelo de regresión lineal para predecir el peso de los pingüinos y entrénalo con la tabla de muestra penguins.

La cláusula OPTIONS(model_type='linear_reg', input_label_cols=['body_mass_g']) indica que estás creando un modelo de regresión lineal. Un modelo de regresión lineal genera un valor continuo a partir de una combinación lineal de atributos de entrada. La columna body_mass_g es la columna de la etiqueta de entrada. Para los modelos de regresión lineal, la columna de la etiqueta debe tener un valor real (es decir, los valores de la columna deben ser números reales).

La cláusula TRANSFORM de esta consulta utiliza las siguientes columnas de la declaración SELECT:

• body_mass_g: Se usa en el entrenamiento sin ningún cambio.
• culmen_depth_mm: Se usa en el entrenamiento sin ningún cambio.
• flipper_length_mm: Se usa en el entrenamiento sin ningún cambio.
• bucketized_culmen_length: se genera a partir de culmen_length_mm mediante el agrupamiento culmen_length_mm basado en cuantiles con la función analítica ML.QUANTILE_BUCKETIZE().
• culmen_length_mm: Es el valor original de culmen_length_mm, convertido en un valor de STRING y utilizado en el entrenamiento.
• species_sex: generado al cruzar species y sex mediante el uso de la función ML.FEATURE_CROSS.

No es necesario que uses todas las columnas de la tabla de entrenamiento en la cláusula TRANSFORM.

La cláusula WHERE (WHERE body_mass_g IS NOT NULL AND RAND() < 0.2) excluye las filas donde el peso de los pingüinos es NULL y usa la función RAND para dibujar una muestra aleatoria de los datos.

Sigue estos pasos para crear el modelo:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

   CREATE OR REPLACE MODEL `bqml_tutorial.penguin_transform`
     TRANSFORM(
       body_mass_g,
       culmen_depth_mm,
       flipper_length_mm,
       ML.QUANTILE_BUCKETIZE(culmen_length_mm, 10) OVER () AS bucketized_culmen_length,
       CAST(culmen_length_mm AS string) AS culmen_length_mm,
       ML.FEATURE_CROSS(STRUCT(species, sex)) AS species_sex)
     OPTIONS (
       model_type = 'linear_reg',
       input_label_cols = ['body_mass_g'])
   AS
   SELECT
     *
   FROM
     `bigquery-public-data.ml_datasets.penguins`
   WHERE
     body_mass_g IS NOT NULL
     AND RAND() < 0.2;

   La consulta tarda unos 15 minutos en completarse, después de lo cual el modelo penguin_transform aparece en el panel Explorador. Debido a que en la consulta se usa una declaración CREATE MODEL para crear un modelo, no se muestran los resultados.

Evalúa el modelo

Evalúa el rendimiento del modelo con la función ML.EVALUATE. La función ML.EVALUATE evalúa los pesos de pingüinos predichos que devuelve el modelo en comparación con los pesos reales de los pingüinos de los datos de entrenamiento.

La declaración SELECT anidada de esta consulta y la cláusula FROM son las mismas que las de la consulta CREATE MODEL. Debido a que usaste la cláusula TRANSFORM cuando creaste el modelo, no es necesario que especifiques las columnas y las transformaciones de nuevo en la función ML.EVALUATE. La función los recupera automáticamente del modelo.

Sigue estos pasos para evaluar el modelo:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

   SELECT
     *
   FROM
     ML.EVALUATE(
       MODEL `bqml_tutorial.penguin_transform`,
       (
         SELECT
           *
         FROM
           `bigquery-public-data.ml_datasets.penguins`
         WHERE
           body_mass_g IS NOT NULL
       ));

   Los resultados debería ser similar al siguiente:

   +---------------------+--------------------+------------------------+-----------------------+--------------------+--------------------+
   | mean_absolute_error | mean_squared_error | mean_squared_log_error | median_absolute_error |      r2_score      | explained_variance |
   +---------------------+--------------------+------------------------+-----------------------+--------------------+--------------------+
   |   64.21134350607677 | 13016.433317859564 |   7.140935762696211E-4 |     15.31788461553515 | 0.9813042531507734 | 0.9813186268757634 |
   +---------------------+--------------------+------------------------+-----------------------+--------------------+--------------------+
   

   Una métrica importante en los resultados de la evaluación es la puntuación R². La puntuación R² es una medida estadística que determina si las predicciones de regresión lineal se aproximan a los datos reales. Un valor de 0 indica que el modelo no explica nada de la variabilidad de los datos de respuesta alrededor de la media. Un valor de 1 indica que el modelo explica toda la variabilidad de los datos de respuesta alrededor de la media.

   Para obtener más información sobre el resultado de la función ML.EVALUATE, consulta Salida.

   También puedes llamar a ML.EVALUATE sin proporcionar los datos de entrada. Usará las métricas de evaluación calculadas durante el entrenamiento.

Usa el modelo para predecir el peso de un pingüino

Usa el modelo con la función ML.PREDICT para predecir el peso de los pingüinos machos.

La función ML.PREDICT genera el valor previsto en la columna predicted_label_column_name, que, en este caso, es predicted_body_mass_g.

Cuando usas la función ML.PREDICT, no tienes que pasar todas las columnas que se usan en el entrenamiento de modelos. Solo se requieren las columnas que usaste en la cláusula TRANSFORM. De manera similar a ML.EVALUATE, la función ML.PREDICT recupera automáticamente las columnas y las transformaciones TRANSFORM del modelo.

Sigue estos pasos para obtener predicciones del modelo:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

   SELECT
     predicted_body_mass_g
   FROM
     ML.PREDICT(
       MODEL `bqml_tutorial.penguin_transform`,
       (
         SELECT
           *
         FROM
           `bigquery-public-data.ml_datasets.penguins`
         WHERE
           sex = 'MALE'
       ));

   Los resultados debería ser similar al siguiente:

   +-----------------------+
   | predicted_body_mass_g |
   +-----------------------+
   |    2810.2868541725757 |
   +-----------------------+
   |    3813.6574220842676 |
   +-----------------------+
   |     4098.844698262214 |
   +-----------------------+
   |     4256.587135004173 |
   +-----------------------+
   |     3008.393497302691 |
   +-----------------------+
   |     ...               |
   +-----------------------+