Crea modelos de aprendizaje automático en BigQuery ML

Crea modelos de aprendizaje automático en BigQuery ML

En este instructivo, se muestra cómo crear un modelo de regresión logística con BigQuery ML en la consola de Google Cloud.

BigQuery ML te permite crear y entrenar modelos de aprendizaje automático en BigQuery mediante consultas de SQL. Esto ayuda a que el aprendizaje automático sea más accesible, ya que te permite usar herramientas conocidas, como el editor de SQL de BigQuery y, también, aumenta la velocidad de desarrollo, ya que quita la necesidad de mover datos a un entorno de aprendizaje automático independiente.

En este instructivo, se usa el ejemplo Conjunto de datos de muestra de Google Analytics para BigQuery a fin de crear un modelo que prediga si un visitante de un sitio web realizará una transacción. Para obtener más información sobre el esquema del conjunto de datos de Analytics, consulta Esquema de BigQuery Export en el Centro de ayuda de Analytics.

Objetivos

En este instructivo, se muestra cómo completar las siguientes tareas:

• Usar la sentencia CREATE MODEL para crear un modelo de regresión logística binaria.
• Usar la función ML.EVALUATE para evaluar el modelo.
• Usar la función ML.PREDICT para hacer predicciones mediante el modelo.

Costos

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

• BigQuery
• BigQuery ML

Para obtener más información sobre los costos de BigQuery, consulta la página Precios de BigQuery.

Para obtener más información sobre los costos de BigQuery ML, consulta los precios de BigQuery ML.

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

6. BigQuery se habilita automáticamente en proyectos nuevos. Para activar BigQuery en un proyecto existente, ve a

   Habilita la API de BigQuery.

   Habilita la API

Crea un conjunto de datos

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

1. En la consola de Google Cloud, ve a la página de 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).

     Los conjuntos de datos públicos se almacenan en la multirregión US. Para que sea más simple, almacena tu conjunto de datos en la misma ubicación.

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

     

Crea un modelo de regresión logística

Crea un modelo de regresión logística con un conjunto de datos de muestra de Analytics para BigQuery.

SQL

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

   Ir a BigQuery

2. En el editor de consultas, ejecuta la siguiente declaración:

   CREATE OR REPLACE MODEL `bqml_tutorial.sample_model`
   OPTIONS(model_type='logistic_reg') AS
   SELECT
   IF(totals.transactions IS NULL, 0, 1) AS label,
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(geoNetwork.country, "") AS country,
   IFNULL(totals.pageviews, 0) AS pageviews
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20160801' AND '20170630'
   

   La consulta tarda varios minutos en completarse. Una vez completada la primera iteración, tu modelo (sample_model) aparece en el panel de navegación. Debido a que en la consulta se usa una sentencia CREATE MODEL para crear un modelo, no se muestran los resultados de la consulta.

Detalles de la consulta

La declaración CREATE MODEL crea el modelo y, luego, lo entrena con los datos recuperados por la declaración SELECT de tu consulta.

La cláusula OPTIONS(model_type='logistic_reg') crea un modelo de regresión logística. Un modelo de regresión logística divide los datos de entrada en dos clases y, luego, calcula la probabilidad de que los datos estén en una de las clases. Lo que intentas detectar, por ejemplo, si un correo electrónico es spam, se representa con un 1 y otros valores se representan con un 0. La probabilidad de que un valor determinado pertenezca a la clase que intentas detectar se indica mediante un valor entre 0 y 1. Por ejemplo, si un correo electrónico recibe una estimación de probabilidad de 0.9, hay una probabilidad del 90% de que el correo electrónico sea spam.

La declaración SELECT de la consulta recupera las siguientes columnas que usa el modelo para predecir la probabilidad de que un cliente complete una transacción:

• totals.transactions: la cantidad total de transacciones de comercio electrónico dentro de la sesión. Si la cantidad de transacciones es NULL, el valor en la columna label se establece en 0. De lo contrario, se establece como 1. Estos valores representan los posibles resultados. Crear un alias con el nombre label es una alternativa a la configuración de la opción input_label_cols= en la declaración CREATE MODEL.
• device.operatingSystem: el sistema operativo del dispositivo del visitante.
• device.isMobile: indica si el dispositivo del visitante es un dispositivo móvil.
• geoNetwork.country: el país de origen de las sesiones, en función de la dirección IP.
• totals.pageviews: la cantidad total de páginas vistas dentro de la sesión.

La cláusula FROM: hace que la consulta entrene el modelo mediante las tablas de muestra bigquery-public-data.google_analytics_sample.ga_sessions. Estas tablas están fragmentadas por fecha, por lo que debes agregarlas mediante un comodín en el nombre de la tabla: google_analytics_sample.ga_sessions_*.

La cláusula WHERE, _TABLE_SUFFIX BETWEEN '20160801' AND '20170630', limita la cantidad de tablas que analiza la consulta. El período analizado es del 1 de agosto de 2016 al 30 de junio de 2017.

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 la autenticación para un entorno de desarrollo local.

from bigframes.ml.linear_model import LogisticRegression
import bigframes.pandas as bpd

# Start by selecting the data you'll use for training. `read_gbq` accepts
# either a SQL query or a table ID. Since this example selects from multiple
# tables via a wildcard, use SQL to define this data. Watch issue
# https://github.com/googleapis/python-bigquery-dataframes/issues/169
# for updates to `read_gbq` to support wildcard tables.

df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20160801"),
        ("_table_suffix", "<=", "20170630"),
    ],
)

# Extract the total number of transactions within
# the Google Analytics session.
#
# Because the totals column is a STRUCT data type, call
# Series.struct.field("transactions") to extract the transactions field.
# See the reference documentation below:
# https://cloud.google.com/python/docs/reference/bigframes/latest/bigframes.operations.structs.StructAccessor#bigframes_operations_structs_StructAccessor_field
transactions = df["totals"].struct.field("transactions")

# The "label" values represent the outcome of the model's
# prediction. In this case, the model predicts if there are any
# ecommerce transactions within the Google Analytics session.
# If the number of transactions is NULL, the value in the label
# column is set to 0. Otherwise, it is set to 1.
label = transactions.notnull().map({True: 1, False: 0}).rename("label")

# Extract the operating system of the visitor's device.
operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")

# Extract whether the visitor's device is a mobile device.
is_mobile = df["device"].struct.field("isMobile")

# Extract the country from which the sessions originated, based on the IP address.
country = df["geoNetwork"].struct.field("country").fillna("")

# Extract the total number of page views within the session.
pageviews = df["totals"].struct.field("pageviews").fillna(0)

# Combine all the feature columns into a single DataFrame
# to use as training data.
features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
    }
)

# Logistic Regression model splits data into two classes, giving the
# a confidence score that the data is in one of the classes.
model = LogisticRegression()
model.fit(features, label)

# The model.fit() call above created a temporary model.
# Use the to_gbq() method to write to a permanent location.
model.to_gbq(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
    replace=True,
)

Consulta las estadísticas de pérdida del modelo

El aprendizaje automático consiste en crear un modelo que pueda usar datos para hacer una predicción. El modelo no es más que una función que toma datos de entrada y realiza cálculos para producir un resultado, es este caso, una predicción.

Los algoritmos de aprendizaje automático toman varios ejemplos en los que ya se conoce la predicción (como los datos históricos de las compras de los usuarios) y ajustan, de forma iterativa, las ponderaciones en el modelo para que sus predicciones coincidan con los valores reales. Para ello, minimiza qué tan equivocado está el modelo con una métrica llamada “pérdida”.

Se espera que para cada iteración, la pérdida debería disminuir, idealmente a cero. Una pérdida de cero significa que el modelo es 100% preciso.

Cuando entrenas el modelo, BigQuery ML divide los datos de entrada de manera automática en conjuntos de entrenamiento y evaluación para evitar el sobreajuste del modelo. Esto es necesario para que el algoritmo de entrenamiento no se ajuste tanto a los datos de entrenamiento que no pueda generalizarse a ejemplos nuevos.

Usa la consola de Google Cloud para ver cómo cambia la pérdida del modelo durante las iteraciones de entrenamiento del modelo:

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

   Ir a BigQuery

2. En el panel Explorador, expande bqml_tutorial > Modelos y, luego, haz clic en sample_model.

3. Haz clic en la pestaña Entrenamiento y observa el grafo Pérdida. En el gráfico Pérdida, se muestra el cambio en la métrica de pérdida en las iteraciones del conjunto de datos de entrenamiento. Si mantienes el cursor sobre el grafo, puedes ver que hay líneas para la pérdida de entrenamiento y la pérdida de evaluación. Como se realizó una regresión logística, el valor de pérdida de entrenamiento se calcula como pérdida logística mediante los datos de entrenamiento. La pérdida de evaluación es la pérdida de registro calculada en los datos de evaluación. Ambos tipos de pérdida representan los valores de pérdida promedio, promediados en todos los ejemplos en los conjuntos de datos respectivos para cada iteración.

También puedes ver los resultados del entrenamiento de modelos mediante la función ML.TRAINING_INFO.

Evalúa el modelo

Evalúa el rendimiento del modelo con la función ML.EVALUATE. La función ML.EVALUATE evalúa los valores previstos que generó el modelo con los datos reales. Para calcular las métricas específicas de regresión logística, puedes usar la función de SQL ML.ROC_CURVE o la función bigframes.ml.metrics.roc_curve de BigQuery DataFrames.

En este instructivo, se usa un modelo de clasificación binaria que detecta transacciones. Los valores de la columna label son las dos clases que generó el modelo: 0 (sin transacciones) y 1 (transacción realizada).

SQL

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

   Ir a BigQuery

2. En el editor de consultas, ejecuta la siguiente declaración:

   SELECT
   *
   FROM
   ML.EVALUATE(MODEL `bqml_tutorial.sample_model`, (
   SELECT
   IF(totals.transactions IS NULL, 0, 1) AS label,
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(geoNetwork.country, "") AS country,
   IFNULL(totals.pageviews, 0) AS pageviews
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20170701' AND '20170801'))
   

   Los resultados deberían verse así:

     +--------------------+---------------------+---------------------+---------------------+---------------------+--------------------+
     |     precision      |       recall        |      accuracy       |      f1_score       |      log_loss       | roc_auc                   |
     +--------------------+---------------------+---------------------+---------------------+---------------------+--------------------+
     | 0.468503937007874  | 0.11080074487895716 | 0.98534315834767638 | 0.17921686746987953 | 0.04624221101176898    | 0.98174125874125873 |
     +--------------------+---------------------+---------------------+---------------------+---------------------+--------------------+
     

   Debido a que realizaste una regresión logística, los resultados incluyen las siguientes columnas:

   • precision: métrica para modelos de clasificación. La precisión identifica la frecuencia con la que un modelo predijo de manera correcta la clase positiva.

   • recall: métrica para los modelos de clasificación que responde a la siguiente pregunta: de todas las etiquetas positivas posibles, ¿cuántas identificó correctamente el modelo?

   • accuracy: la precisión es la fracción de las predicciones que un modelo de clasificación acertó.

   • f1_score: una medida de la precisión del modelo. La puntuación f1 es el promedio armónico de la precisión y la recuperación. El mejor valor de una puntuación f1 es 1. El peor valor es 0.

   • log_loss: la función de pérdida utilizada en una regresión logística. Esta es la medida de qué tan lejos están las predicciones del modelo de las etiquetas correctas.

   • roc_auc: el área bajo la curva ROC. Esta es la probabilidad de que un clasificador tenga más certeza de que un ejemplo positivo elegido al azar sea realmente positivo en comparación con que un ejemplo negativo elegido al azar sea positivo. Para obtener más información, consulta Clasificación en el Curso intensivo de aprendizaje automático.

Detalles de la consulta

La sentencia SELECT inicial recupera las columnas de su modelo.

La cláusula FROM usa la función ML.EVALUATE en el modelo.

La sentencia SELECT anidada y la cláusula FROM son las mismas que las de la consulta CREATE MODEL.

La cláusula WHERE, _TABLE_SUFFIX BETWEEN '20170701' AND '20170801', limita la cantidad de tablas que analiza la consulta. El período analizado es del 1 de julio de 2017 al 1 de agosto de 2017. Estos son los datos que usas para evaluar el rendimiento predictivo del modelo. Se recolectaron en el mes inmediatamente posterior al período comprendido por los datos de entrenamiento.

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 la autenticación para un entorno de desarrollo local.

import bigframes.pandas as bpd

# Select model you'll use for evaluating. `read_gbq_model` loads model data from a
# BigQuery, but you could also use the `model` object from the previous steps.
model = bpd.read_gbq_model(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
)

# The filters parameter limits the number of tables scanned by the query.
# The date range scanned is July 1, 2017 to August 1, 2017. This is the
# data you're using to evaluate the predictive performance of the model.
# It was collected in the month immediately following the time period
# spanned by the training data.
df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20170701"),
        ("_table_suffix", "<=", "20170801"),
    ],
)

transactions = df["totals"].struct.field("transactions")
label = transactions.notnull().map({True: 1, False: 0}).rename("label")
operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")
is_mobile = df["device"].struct.field("isMobile")
country = df["geoNetwork"].struct.field("country").fillna("")
pageviews = df["totals"].struct.field("pageviews").fillna(0)
features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
    }
)

# Some models include a convenient .score(X, y) method for evaluation with a preset accuracy metric:

# Because you performed a logistic regression, the results include the following columns:

# - precision — A metric for classification models. Precision identifies the frequency with
# which a model was correct when predicting the positive class.

# - recall — A metric for classification models that answers the following question:
# Out of all the possible positive labels, how many did the model correctly identify?

# - accuracy — Accuracy is the fraction of predictions that a classification model got right.

# - f1_score — A measure of the accuracy of the model. The f1 score is the harmonic average of
# the precision and recall. An f1 score's best value is 1. The worst value is 0.

# - log_loss — The loss function used in a logistic regression. This is the measure of how far the
# model's predictions are from the correct labels.

# - roc_auc — The area under the ROC curve. This is the probability that a classifier is more confident that
# a randomly chosen positive example
# is actually positive than that a randomly chosen negative example is positive. For more information,
# see ['Classification']('https://developers.google.com/machine-learning/crash-course/classification/video-lecture')
# in the Machine Learning Crash Course.

model.score(features, label)
#    precision    recall  accuracy  f1_score  log_loss   roc_auc
# 0   0.412621  0.079143  0.985074  0.132812  0.049764  0.974285
# [1 rows x 6 columns]

Usa el modelo para predecir resultados

Usa el modelo para predecir la cantidad de transacciones realizadas por los visitantes del sitio web de cada país.

SQL

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

   Ir a BigQuery

2. En el editor de consultas, ejecuta la siguiente declaración:

   SELECT
   country,
   SUM(predicted_label) as total_predicted_purchases
   FROM
   ML.PREDICT(MODEL `bqml_tutorial.sample_model`, (
   SELECT
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(totals.pageviews, 0) AS pageviews,
   IFNULL(geoNetwork.country, "") AS country
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20170701' AND '20170801'))
   GROUP BY country
   ORDER BY total_predicted_purchases DESC
   LIMIT 10
   

   Los resultados deberían verse así:

   +----------------+---------------------------+
   |    country     | total_predicted_purchases |
   +----------------+---------------------------+
   | United States  |                       220 |
   | Taiwan         |                         8 |
   | Canada         |                         7 |
   | India          |                         2 |
   | Turkey         |                         2 |
   | Japan          |                         2 |
   | Italy          |                         1 |
   | Brazil         |                         1 |
   | Singapore      |                         1 |
   | Australia      |                         1 |
   +----------------+---------------------------+
   

Detalles de la consulta

La sentencia SELECT inicial recupera la columna country y suma la columna predicted_label. La columna predicted_label se genera mediante la función ML.PREDICT. Cuando usas la función ML.PREDICT, el nombre de la columna de resultado del modelo es predicted_<label_column_name>. Para los modelos de regresión lineal, predicted_label es el valor estimado de label. Para los modelos de regresión logística, predicted_label es la etiqueta que describe mejor el valor de datos de entrada dado, ya sea 0 o 1.

La función ML.PREDICT se usa para predecir resultados con tu modelo.

La sentencia SELECT anidada y la cláusula FROM son las mismas que las de la consulta CREATE MODEL.

La cláusula WHERE, _TABLE_SUFFIX BETWEEN '20170701' AND '20170801', limita la cantidad de tablas que analiza la consulta. El período analizado es del 1 de julio de 2017 al 1 de agosto de 2017. Estos son los datos para los que realizas predicciones. Se recolectaron en el mes inmediatamente posterior al período comprendido por los datos de entrenamiento.

Las cláusulas GROUP BY y ORDER BY agrupan los resultados por país y los ordenan por la suma de las compras previstas en orden descendente.

En este caso, la cláusula LIMIT se usa para mostrar solo los 10 primeros resultados.

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 la autenticación para un entorno de desarrollo local.

import bigframes.pandas as bpd

# Select model you'll use for predicting.
# `read_gbq_model` loads model data from
# BigQuery, but you could also use the `model`
# object from the previous steps.
model = bpd.read_gbq_model(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
)

# The filters parameter limits the number of tables scanned by the query.
# The date range scanned is July 1, 2017 to August 1, 2017. This is the
# data you're using to make the prediction.
# It was collected in the month immediately following the time period
# spanned by the training data.
df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20170701"),
        ("_table_suffix", "<=", "20170801"),
    ],
)

operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")
is_mobile = df["device"].struct.field("isMobile")
country = df["geoNetwork"].struct.field("country").fillna("")
pageviews = df["totals"].struct.field("pageviews").fillna(0)
features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
    }
)
# Use Logistic Regression predict method to predict results
# using your model.
# Find more information here in
# [BigFrames](https://cloud.google.com/python/docs/reference/bigframes/latest/bigframes.ml.linear_model.LogisticRegression#bigframes_ml_linear_model_LogisticRegression_predict)

predictions = model.predict(features)

# Call groupby method to group predicted_label by country.
# Call sum method to get the total_predicted_label by country.
total_predicted_purchases = predictions.groupby(["country"])[
    ["predicted_label"]
].sum()

# Call the sort_values method with the parameter
# ascending = False to get the highest values.
# Call head method to limit to the 10 highest values.
total_predicted_purchases.sort_values(ascending=False).head(10)

# country
# United States    220
# Taiwan             8
# Canada             7
# India              2
# Japan              2
# Turkey             2
# Australia          1
# Brazil             1
# Germany            1
# Guyana             1
# Name: predicted_label, dtype: Int64

Prediga compras por usuario

Predice la cantidad de transacciones que realizará cada visitante de un sitio web.

SQL

Esta consulta es idéntica a la consulta de la sección anterior, excepto por la cláusula GROUP BY. Aquí la cláusula GROUP BY, GROUP BY fullVisitorId, se usa para agrupar los resultados por ID de visitante.

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

   Ir a BigQuery

2. En el editor de consultas, ejecuta la siguiente declaración:

   SELECT
   fullVisitorId,
   SUM(predicted_label) as total_predicted_purchases
   FROM
   ML.PREDICT(MODEL `bqml_tutorial.sample_model`, (
   SELECT
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(totals.pageviews, 0) AS pageviews,
   IFNULL(geoNetwork.country, "") AS country,
   fullVisitorId
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20170701' AND '20170801'))
   GROUP BY fullVisitorId
   ORDER BY total_predicted_purchases DESC
   LIMIT 10
   

   Los resultados deberían verse así:

     +---------------------+---------------------------+
     |    fullVisitorId    | total_predicted_purchases |
     +---------------------+---------------------------+
     | 9417857471295131045 |                         4 |
     | 112288330928895942  |                         2 |
     | 2158257269735455737 |                         2 |
     | 489038402765684003  |                         2 |
     | 057693500927581077  |                         2 |
     | 2969418676126258798 |                         2 |
     | 5073919761051630191 |                         2 |
     | 7420300501523012460 |                         2 |
     | 0456807427403774085 |                         2 |
     | 2105122376016897629 |                         2 |
     +---------------------+---------------------------+
     

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 la autenticación para un entorno de desarrollo local.

import bigframes.pandas as bpd

# Select model you'll use for predicting.
# `read_gbq_model` loads model data from
# BigQuery, but you could also use the `model`
# object from the previous steps.
model = bpd.read_gbq_model(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
)

# The filters parameter limits the number of tables scanned by the query.
# The date range scanned is July 1, 2017 to August 1, 2017. This is the
# data you're using to make the prediction.
# It was collected in the month immediately following the time period
# spanned by the training data.
df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20170701"),
        ("_table_suffix", "<=", "20170801"),
    ],
)

operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")
is_mobile = df["device"].struct.field("isMobile")
country = df["geoNetwork"].struct.field("country").fillna("")
pageviews = df["totals"].struct.field("pageviews").fillna(0)
full_visitor_id = df["fullVisitorId"]

features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
        "fullVisitorId": full_visitor_id,
    }
)

predictions = model.predict(features)

# Call groupby method to group predicted_label by visitor.
# Call sum method to get the total_predicted_label by visitor.
total_predicted_purchases = predictions.groupby(["fullVisitorId"])[
    ["predicted_label"]
].sum()

# Call the sort_values method with the parameter
# ascending = False to get the highest values.
# Call head method to limit to the 10 highest values.
total_predicted_purchases.sort_values(ascending=False).head(10)

# fullVisitorId
# 9417857471295131045    4
# 0376394056092189113    2
# 0456807427403774085    2
# 057693500927581077     2
# 112288330928895942     2
# 1280993661204347450    2
# 2105122376016897629    2
# 2158257269735455737    2
# 2969418676126258798    2
# 489038402765684003     2
# Name: predicted_label, dtype: Int64

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

Puedes borrar el proyecto que creaste o conservar el proyecto y borrar el conjunto de datos.

Borra el conjunto de datos

Borrar el proyecto quita todos tus conjuntos de datos y tablas. Si prefieres volver a usar el proyecto, puedes borrar el conjunto de datos que creaste en este instructivo:

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

   Ir a BigQuery

2. En el panel Explorador, selecciona el conjunto de datos bqml_tutorial que creaste.

3. Haz clic en Acciones > Borrar.

4. En el cuadro de diálogo Borrar conjunto de datos, escribe delete para confirmar el comando de eliminación.

5. Haz clic en Borrar.

Borra el proyecto

Para borrar el proyecto, haz lo siguiente:

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

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

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Próximos pasos

• Para obtener más información sobre el aprendizaje automático, consulta el Curso intensivo de aprendizaje automático.
• Para obtener una descripción general de BigQuery ML, consulta Introducción a BigQuery ML.
• Para obtener más información sobre la consola de Google Cloud, consulta Usa la consola de Google Cloud.