Criar modelos de machine learning no BigQuery ML

Este tutorial é uma introdução aos usuários ao BigQuery ML usando o console do Google Cloud.

Com o BigQuery ML, é possível criar e executar modelos de machine learning no BigQuery usando consultas SQL e código Python. O objetivo é democratizar o machine learning, de modo que os especialistas em SQL criem modelos usando as respectivas ferramentas e aumentem a velocidade de desenvolvimento ao eliminar a necessidade de movimentar os dados.

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

Neste tutorial, você usará:

o BigQuery ML para criar um modelo de regressão binária usando a instrução CREATE MODEL;
a função ML.EVALUATE para avaliar o modelo de ML;
a função ML.PREDICT para fazer previsões usando o modelo de ML.

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

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

Criar seu conjunto de dados

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

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

Acesse a página do BigQuery
No painel Explorer, clique no nome do seu projeto.
Clique em Conferir ações > Criar conjunto de dados.
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.

crie um modelo.

Em seguida, você cria um modelo de regressão logística usando o conjunto de dados de amostra do Google Analytics para o BigQuery.

SQL

Com a consulta GoogleSQL padrão a seguir você cria o modelo usado para prever se um visitante do site fará uma transação.

#standardSQL
CREATE 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'

Além de criar o modelo, a execução de uma consulta que contém a instrução CREATE MODEL treina o modelo usando os dados recuperados pela instrução SELECT da consulta.

Detalhes da consulta

A cláusula CREATE MODEL é usada para criar e treinar o modelo chamado bqml_tutorial.sample_model.

A cláusula OPTIONS(model_type='logistic_reg') indica que você está criando um modelo de regressão logística. Um modelo de regressão logística divide os dados de entrada em duas classes e determina a probabilidade de que eles estejam em cada uma dessas classes. Normalmente, aquilo que você está tentando detectar (por exemplo, se um e-mail pode ser classificado como spam) é representado por 1 e todo o resto é representado por 0. Se a saída do modelo de regressão logística for 0,9, há uma probabilidade de 90% da entrada ser aquilo que você quer detectar (o e-mail ser um spam, neste exemplo).

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 — bigquery-public-data.google_analytics_sample.ga_sessions_* — indica que você está consultando o conjunto de dados de amostra do Google Analytics. Esse conjunto de dados está no projeto bigquery-public-data. Você está consultando um grupo de tabelas fragmentadas por data. Isso é representado pelo caractere curinga no 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.

Execute a consulta CREATE MODEL

Para executar a consulta CREATE MODEL para criar e treinar seu modelo:

No console do Google Cloud, clique no botão Escrever nova consulta. Se esse texto não estiver disponível para ser clicado, o Editor de consultas já estará aberto.

Botão Escrever consulta

Insira a seguinte consulta do GoogleSQL na área de texto do Editor de consultas.

#standardSQL
CREATE 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'

Clique em Executar.

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 é possível ver os resultados da consulta.

Observe o modelo enquanto ele está sendo treinado, visualizando a guia Estatísticas do modelo. Assim que a primeira iteração for concluída, a guia será atualizada. As estatísticas continuam sendo atualizadas conforme cada iteração é concluída.

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

Ver estatísticas de treinamento

Para ver os resultados do treinamento de modelo, use a função ML.TRAINING_INFO ou visualize as estatísticas no console do Google Cloud. Neste tutorial, você usa o console do Google Cloud.

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.

Para ver as estatísticas de treinamento do modelo que foram geradas quando você executou a consulta CREATE MODEL:

No painel de navegação do Console do Cloud, na seção Recursos , expanda [PROJECT_ID] > bqml_tutorial e clique em sample_model.
Clique na guia Estatísticas do modelo. Os resultados terão o seguinte formato:

A coluna Perda de dados de treinamento representa a métrica de perda calculada após a iteração especificada no conjunto de dados de treinamento. Você executou uma regressão logística. Portanto, essa coluna é a Log Perda. A coluna Perda de dados de avaliação é a mesma métrica de perda calculada no conjunto de dados de validação, ou seja, dados do treinamento mantidos para validar o modelo.

O BigQuery ML divide automaticamente seus dados de entrada em dois conjuntos, um de treinamento e um de validação, com o objetivo de evitar o sobreajuste do modelo. Isso é necessário para que o algoritmo de treinamento não se adapte demais aos dados conhecidos, evitando que ele generalize esses dados para exemplos novos e ainda inéditos.

Os valores das colunas Perda de dados de treinamento e Perda de dados de avaliação representam valores médios de perda, calculados a partir de todos os exemplos nos seus respectivos conjuntos.

Para ver mais detalhes sobre a função ML.TRAINING_INFO, consulte a referência de sintaxe do BigQuery ML.

Avalie o modelo

Depois de criar o modelo, utilize a função ML.EVALUATE para avaliar o desempenho do classificador. A função ML.EVALUATE avalia os valores previstos em relação aos dados reais. Para calcular métricas específicas de regressão logística, use a função SQL ML.ROC_CURVE ou a função bigframes.ml.metrics.roc_curve do BigQuery DataFrames.

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

SQL

A consulta usada para avaliar o modelo é esta:

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

Detalhes da consulta

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

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

A cláusula FROM e a instrução SELECT aninhada desta consulta são as mesmas da 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.

Execute a consulta ML.EVALUATE

Para executar a consulta ML.EVALUATE que avalia o modelo:

No console do Google Cloud, clique no botão Escrever nova consulta.

Insira a seguinte consulta do GoogleSQL na área de texto do Editor de consultas.

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

Clique em Executar.
Após concluir a consulta, clique na guia Resultados abaixo da área de texto da consulta. Os resultados terão o seguinte formato:
```
+--------------------+---------------------+--------------------+--------------------+---------------------+----------+
|     precision      |       recall        |      accuracy      |      f1_score      |      log_loss       | roc_auc  |
+--------------------+---------------------+--------------------+--------------------+---------------------+----------+
| 0.4451901565995526 | 0.08879964301651048 | 0.9716829479411401 | 0.1480654761904762 | 0.07921781778780206 | 0.970706 |
+--------------------+---------------------+--------------------+--------------------+---------------------+----------+
```
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: 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: precisão é a fração das previsões corretas de um modelo de classificação.
- f1_score: 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: área sob a curva de característica de operação do receptor(ROC, na sigla em inglês).. É 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.

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]

use seu modelo para prever resultados

Agora seu modelo foi avaliado, a próxima etapa é usá-lo para prever um resultado. Use seu modelo para prever o número de transações feitas pelos visitantes do site em cada país.

SQL

A consulta usada para prever o resultado é a seguinte:

#standardSQL
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

Detalhes da consulta

A principal instrução SELECT recupera a coluna country e soma a coluna predicted_label. Essa coluna é 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 mais provável, que, nesse caso, é 0 ou 1.

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

A cláusula FROM e a instrução SELECT aninhada desta consulta são as mesmas da 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.

Executar a consulta `ML.PREDICT`

Veja como executar a consulta que usa o modelo para prever um resultado:

No console do Google Cloud, clique no botão Escrever nova consulta.

Insira a seguinte consulta do GoogleSQL na área de texto do Editor de consultas.

#standardSQL
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

Clique em Executar.
Após concluir a consulta, clique na guia Resultados abaixo da área de texto da consulta. Os resultados terão a seguinte aparência:

+----------------+---------------------------+
|    country     | total_predicted_purchases |
+----------------+---------------------------+
| United States  |                       209 |
| Taiwan         |                         6 |
| Canada         |                         4 |
| Turkey         |                         2 |
| India          |                         2 |
| Japan          |                         2 |
| Indonesia      |                         1 |
| United Kingdom |                         1 |
| Guyana         |                         1 |
+----------------+---------------------------+

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

No próximo exemplo, você tentará prever o número de transações que os visitantes do site farão.

SQL

Essa consulta é idêntica à anterior, exceto pela cláusula GROUP BY. Aqui, a cláusula GROUP BY — GROUP BY fullVisitorId — é usada para agrupar os resultados por código de visitante.

Para executar a consulta, faça o seguinte:

No console do Google Cloud, clique no botão Escrever nova consulta.

Insira a seguinte consulta do GoogleSQL na área de texto do Editor de consultas.

#standardSQL
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

Clique em Executar.

Após concluir a consulta, clique na guia Resultados abaixo da área de texto da consulta. Os resultados terão a seguinte aparência:

+---------------------+---------------------------+
|    fullVisitorId    | total_predicted_purchases |
+---------------------+---------------------------+
| 9417857471295131045 |                         4 |
| 2158257269735455737 |                         3 |
| 5073919761051630191 |                         3 |
| 7104098063250586249 |                         2 |
| 4668039979320382648 |                         2 |
| 1280993661204347450 |                         2 |
| 7701613595320832147 |                         2 |
| 0376394056092189113 |                         2 |
| 9097465012770697796 |                         2 |
| 4419259211147428491 |                         2 |
+---------------------+---------------------------+

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.

exclua o projeto que você criou; ou
Mantenha o projeto e exclua o conjunto de dados.

Excluir o conjunto de dados

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

Se necessário, abra a página do BigQuery no console do Google Cloud.

Acesse a página do BigQuery
Na navegação, selecione o conjunto de dados bqml_tutorial criado.
Clique em Excluir conjunto de dados no lado direito da janela. Essa ação exclui o conjunto, a tabela e todos os dados.
Na caixa de diálogo Excluir conjunto de dados, confirme o comando de exclusão digitando o nome do seu conjunto de dados (bqml_tutorial) e clique em Excluir.

Excluir 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.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

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.

Criar modelos de machine learning no BigQuery ML

Objetivos

Custos

Antes de começar

Criar seu conjunto de dados

crie um modelo.

SQL

BigQuery DataFrames

Ver estatísticas de treinamento

Avalie o modelo

SQL

BigQuery DataFrames

use seu modelo para prever resultados

SQL

Executar a consulta ML.PREDICT

BigQuery DataFrames

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

SQL

BigQuery DataFrames

Limpar

Excluir o conjunto de dados

Excluir o projeto

A seguir

Executar a consulta `ML.PREDICT`