Criar modelos de machine learning no BigQuery ML

Criar modelos de machine learning no BigQuery ML

Neste tutorial, mostramos como criar um modelo de regressão logística usando BigQuery ML no console do Google Cloud.

O BigQuery ML permite criar e treinar modelos de machine learning em o BigQuery usando consultas SQL. Isso ajuda a tornar o machine learning acessível porque permite usar ferramentas conhecidas, como o BigQuery SQL Editor e também aumenta a velocidade de desenvolvimento, eliminando a necessidade de mover os dados em um ambiente de machine learning separado.

Neste tutorial, você usa o conjunto de dados de amostra do Google Analytics para BigQuery e cria um modelo que prevê se um visitante do site fará uma transação. Para informações sobre o esquema do conjunto de dados do Analytics, veja o esquema do BigQuery Export na Central de Ajuda do Google Analytics.

Objetivos

Este tutorial mostra como fazer as seguintes tarefas:

• Usar o Instrução CREATE MODEL para criar um modelo de regressão logística binária.
• Use a função ML.EVALUATE para avaliar o modelo.
• Usar o Função ML.PREDICT para fazer previsões usando o modelo.

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

• BigQuery
• BigQuery ML

Para mais informações sobre os custos do BigQuery, consulte a página de preços do BigQuery.

Para mais informações sobre os custos do BigQuery ML, consulte os preços do BigQuery ML.

Antes de começar

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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. Make sure that billing is enabled for your Google Cloud project.

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. Make sure that billing is enabled for your Google Cloud project.

6. O BigQuery é ativado automaticamente em novos projetos. Para ativar o BigQuery em um projeto preexistente, acesse

   Enable the BigQuery API.

   Enable the API

Criar um conjunto de dados

Crie um conjunto de dados do BigQuery para armazenar o modelo de ML:

1. No console do Google Cloud, acesse a página do BigQuery.

   Acesse a página do BigQuery

2. No painel Explorer, clique no nome do seu projeto.

3. Clique em Conferir ações > Criar conjunto de dados.

   

4. Na página Criar conjunto de dados, faça o seguinte:

   • Para o código do conjunto de dados, insira bqml_tutorial.

   • Em Tipo de local, selecione Multirregião e EUA (várias regiões nos Estados Unidos).

     Os conjuntos de dados públicos são armazenados na multirregião US. Para simplificar, armazene seus conjuntos de dados no mesmo local.

   • Mantenha as configurações padrão restantes e clique em Criar conjunto de dados.

     

Criar um modelo de regressão logística

Criar um modelo de regressão logística usando a amostra do Google Analytics no BigQuery.

SQL

1. No Console do Google Cloud, acesse a página BigQuery.

   Acessar o BigQuery

2. No editor de consultas, execute a seguinte instrução:

   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'
   

   A consulta leva alguns minutos para ser concluída. Depois que a primeira iteração for concluída, seu modelo (sample_model) aparecerá no painel de navegação. Como a consulta usa uma instrução CREATE MODEL para criar um modelo, não é necessário ver os resultados da consulta.

Detalhes da consulta

A instrução CREATE MODEL cria o modelo e depois o treina usando os dados recuperados pela instrução SELECT da consulta.

A cláusula OPTIONS(model_type='logistic_reg') cria uma classe logística de regressão. Um de regressão logística divide os dados de entrada em duas classes e, estima a probabilidade de que os dados estejam em uma das classes. O que você é tentando detectar, por exemplo, se um e-mail é spam, é representada por 1 e outros valores são representados por 0. A probabilidade de um determinado valor pertencer a para a classe que você está tentando detectar é indicada por um valor entre 0 e 1. Por exemplo, se um e-mail recebe uma estimativa de probabilidade de 0,9, há uma probabilidade de 90% de que o e-mail seja spam.

A instrução SELECT dessa consulta recupera as colunas abaixo, que são usadas pelo modelo para prever a probabilidade de um cliente concluir uma transação:

• totals.transactions: o número total de transações de comércio eletrônico na sessão. Se o número de transações for NULL, o valor na coluna label será definido como 0. Caso contrário, será definido como 1. Esses valores representam os resultados possíveis. Criar um alias denominado label é uma alternativa à configuração da opção input_label_cols= na instrução CREATE MODEL;
• device.operatingSystem: o sistema operacional do dispositivo do visitante;
• device.isMobile: indica se o dispositivo do visitante é um dispositivo móvel;
• geoNetwork.country: o país de origem das sessões com base no endereço IP.
• totals.pageviews: o número total de visualizações de página na sessão.

A cláusula FROM: faz com que a consulta treine o modelo usando a bigquery-public-data.google_analytics_sample.ga_sessions tabelas de exemplo. Essas tabelas são fragmentadas por data, então você as agrega usando um caractere curinga no o nome da tabela: google_analytics_sample.ga_sessions_*.

A cláusula WHERE — _TABLE_SUFFIX BETWEEN '20160801' AND '20170630' — limita o número de tabelas verificadas pela consulta. O período verificado vai de 1º de agosto de 2016 até 30 de junho de 2017.

BigQuery DataFrames

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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,
)

Visualizar as estatísticas de perda do modelo

O machine learning pode ser definido como criar um modelo capaz de utilizar dados para fazer previsões. O modelo é basicamente uma função que recebe entradas e aplica cálculos a estas entradas para produzir um resultado: uma previsão.

Os algoritmos de aprendizado de máquina funcionam utilizando diversos exemplos em que a previsão já é conhecida (como o histórico de compras de usuários) e ajustando iterativamente vários pesos no modelo de modo que as previsões correspondam aos valores reais. Isso é feito ao minimizar as possibilidades de erro do modelo por meio de uma métrica denominada perda.

A expectativa é que a perda seja reduzida a cada iteração, idealmente até chegar a zero. Uma perda zero significa que o modelo é 100% exato.

Ao treinar o modelo, o BigQuery ML divide automaticamente as inserir dados no conjuntos de treinamento e avaliação, para evitar o overfitting o modelo. Isso é necessário para que o algoritmo de treinamento não se encaixe tão perto dos dados de treinamento que não consegue generalizar para novos exemplos.

Use o console do Google Cloud para conferir como a perda do modelo muda iterações de treinamento do modelo:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No painel Explorador, expanda bqml_tutorial > Models e Depois clique em sample_model.

3. Clique na guia Treinamento e olhe para o gráfico Perda. O gráfico de perda gráfico mostra a mudança na métrica de perda ao longo das iterações no conjunto de dados de treinamento. Se você segurar o cursor sobre o gráfico, vai notar que há linhas para Perda de treinamento e Perda de avaliação. Como você uma regressão logística, o valor da perda de treinamento é calculado como log Perda, usando os dados de treinamento. A perda de avaliação é a log Perda calculada dados de avaliação de recursos. Os dois tipos de perda representam valores médios de perda, em todos os exemplos nos respectivos conjuntos de dados de cada iteração.

Também é possível ver os resultados do treinamento de modelo usando o Função ML.TRAINING_INFO.

Avaliar o modelo

Avalie o desempenho do modelo usando a função ML.EVALUATE. A função ML.EVALUATE avalia os valores previstos gerados pelo modelo em relação aos dados reais. Para calcular a regressão logística específica você pode usar o Função SQL ML.ROC_CURVE ou o bigframes.ml.metrics.roc_curve Função DataFrames do BigQuery.

Neste tutorial, você está usando um modelo de classificação binária que detecta transações. Os valores na coluna label são as duas classes gerados pelo modelo: 0 (sem transações) e 1 (transação feita).

SQL

1. No Console do Google Cloud, acesse a página BigQuery.

   Acessar o BigQuery

2. No editor de consultas, execute a seguinte instrução:

   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'))
   

   Os resultados vão ter a aparência abaixo:

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

   Como você executou uma regressão logística, os resultados incluem as seguintes colunas:

   • precision: métrica para modelos de classificação. A precisão identifica a frequência de acerto de um modelo ao prever a classe positiva.

   • recall: uma métrica para modelos de classificação que responde à seguinte pergunta: De todos os rótulos positivos possíveis, quantos identificaram o modelo corretamente?

   • accuracy: a precisão é a fração das previsões corretas de um modelo de classificação.

   • f1_score: a medida da precisão do modelo. A pontuação f1 é a média harmônica da precisão e do recall. O melhor valor de uma pontuação f1 é 1. O pior valor é 0.

   • log_loss: a função de perda usada em uma regressão logística. É a medida de quanto as predições do modelo se distanciam dos rótulos corretos.

   • roc_auc: a área sob a curva de característica de operação do receptor ROC. É a probabilidade de um classificador ter mais certeza de que um exemplo positivo aleatório seja de fato positivo do que um exemplo negativo aleatório seja positivo. Para mais informações, consulte Classificação no Curso intensivo de machine learning.

Detalhes da consulta

A instrução SELECT inicial recupera as colunas do modelo.

A cláusula FROM usa a função ML.EVALUATE no modelo.

A instrução SELECT aninhada e a cláusula FROM são as mesmas que na consulta CREATE MODEL.

A cláusula WHERE — _TABLE_SUFFIX BETWEEN '20170701' AND '20170801' — limita o número de tabelas verificadas pela consulta. O período verificado vai de 1º de julho de 2017 a 1º de agosto de 2017. Esses são os dados usados para avaliar o desempenho preditivo do modelo. Os dados foram coletados no mês imediatamente posterior ao período abrangido pelos dados de treinamento.

BigQuery DataFrames

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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]

Usar o modelo para prever resultados

Use o modelo para prever o número de transações feitas pelos visitantes do site de cada país.

SQL

1. No Console do Google Cloud, acesse a página BigQuery.

   Acessar o BigQuery

2. No editor de consultas, execute a seguinte instrução:

   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
   

   Os resultados vão ter a aparência abaixo:

   +----------------+---------------------------+
   |    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 |
   +----------------+---------------------------+
   

Detalhes da consulta

A instrução SELECT inicial recupera a coluna country e soma os predicted_label. Essa coluna predicted_label é gerada pela função ML.PREDICT. Ao usar a função ML.PREDICT, o nome da coluna de saída para o modelo é predicted_<label_column_name>. Para modelos de regressão linear, predicted_label é o valor estimado de label. Para modelos de regressão logística, predicted_label é o rótulo que melhor descreve o valor dos dados de entrada fornecido, 0 ou 1.

A função ML.PREDICT é usada para prever resultados usando o modelo.

A instrução SELECT aninhada e a cláusula FROM são as mesmas que na consulta CREATE MODEL.

A cláusula WHERE — _TABLE_SUFFIX BETWEEN '20170701' AND '20170801' — limita o número de tabelas verificadas pela consulta. O período verificado vai de 1º de julho de 2017 a 1º de agosto de 2017. Você está fazendo predições para esses dados. Os dados foram coletados no mês imediatamente posterior ao período abrangido pelos dados de treinamento.

As cláusulas GROUP BY e ORDER BY agrupam os resultados por país e os ordenam pela soma das compras previstas em ordem decrescente.

A cláusula LIMIT é usada aqui para exibir apenas os 10 melhores resultados.

BigQuery DataFrames

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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

Faça predições de compras por usuário

Preveja o número de transações que cada visitante do site vai fazer.

SQL

Esta consulta é idêntica à consulta da seção anterior, exceto pelo cláusula GROUP BY. Aqui, a cláusula GROUP BY — GROUP BY fullVisitorId — é usada para agrupar os resultados por código de visitante.

1. No Console do Google Cloud, acesse a página BigQuery.

   Acessar o BigQuery

2. No editor de consultas, execute a seguinte instrução:

   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
   

   Os resultados vão ter a aparência abaixo:

     +---------------------+---------------------------+
     |    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 testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

Você pode excluir o projeto criado ou mantê-lo e excluir o no conjunto de dados.

Excluir o conjunto de dados

A exclusão do seu projeto vai remover todos os conjuntos de dados e tabelas no projeto. Caso prefira reutilizá-lo, exclua o conjunto de dados criado neste tutorial:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No painel Explorador, selecione o conjunto de dados bqml_tutorial criado.

3. Clique em . Ações > Excluir.

4. Na caixa de diálogo Excluir conjunto de dados, confirme o comando de exclusão digitando delete.

5. Clique em Excluir.

Exclua o projeto

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

A seguir

• Para saber mais sobre machine learning, consulte o Curso intensivo de machine learning.
• Para uma visão geral do BigQuery ML, consulte Introdução ao BigQuery ML.
• Para saber mais, consulte Como usar o console do Google Cloud.