Crie um modelo de aprendizagem automática no BigQuery ML através do SQL

Este tutorial mostra como criar um modelo de regressão logística através de consultas SQL do BigQuery ML.

O BigQuery ML permite-lhe criar e preparar modelos de aprendizagem automática no BigQuery através de consultas SQL. Isto ajuda a tornar a aprendizagem automática mais acessível, permitindo-lhe usar ferramentas familiares, como o editor de SQL do BigQuery, e também aumenta a velocidade de desenvolvimento, eliminando a necessidade de mover dados para um ambiente de aprendizagem automática separado.

Neste tutorial, vai usar o conjunto de dados de exemplo do Google Analytics para o BigQuery para criar um modelo que preveja se um visitante do Website vai fazer uma transação. Para ver informações sobre o esquema do conjunto de dados do Analytics, consulte o artigo Esquema do BigQuery Export no Centro de Ajuda do Analytics.

Para saber como criar modelos através da Trusted Cloud interface do utilizador da consola, consulte o artigo Trabalhe com modelos através de uma IU. (Pré-visualizar)

Objetivos

Este tutorial mostra como realizar as seguintes tarefas:

Custos

Este tutorial usa componentes faturáveis do Trusted Cloud by S3NS, incluindo o seguinte:

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

Funções necessárias

  • Para criar um modelo e executar a inferência, tem de lhe ser concedidas as seguintes funções:

    • Editor de dados do BigQuery (roles/bigquery.dataEditor)
    • Utilizador do BigQuery (roles/bigquery.user)

Antes de começar

  1. In the Trusted Cloud console, on the project selector page, select or create a Trusted Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Trusted Cloud project.

  3. Make sure that you have the following role or roles on the project: BigQuery Data Editor, BigQuery Job User, Service Usage Admin

    Check for the roles

    1. In the Trusted Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.
    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Trusted Cloud console, go to the IAM page.

      Aceder ao IAM
    2. Selecione o projeto.
    3. Clique em Conceder acesso.
    4. No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o identificador de um utilizador num conjunto de identidades da força de trabalho. Para ver detalhes, consulte Represente utilizadores do pool de força de trabalho em políticas de IAM ou contacte o seu administrador.

    5. Na lista Selecionar uma função, selecione uma função.
    6. Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
    7. Clique em Guardar.
  4. O BigQuery é ativado automaticamente em novos projetos. Para ativar o BigQuery num projeto pré-existente, aceda a

    Enable the BigQuery API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

Crie um conjunto de dados

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

Consola

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda à página do BigQuery

  2. No painel Explorador, clique no nome do projeto.

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

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

    • Para o ID do conjunto de dados, introduza bqml_tutorial.

    • Em Tipo de localização, selecione Várias regiões e, de seguida, selecione EUA (várias regiões nos Estados Unidos).

    • Deixe as restantes predefinições como estão e clique em Criar conjunto de dados.

bq

Para criar um novo conjunto de dados, use o comando bq mk com a flag --location. Para uma lista completa de parâmetros possíveis, consulte a referência do comando bq mk --dataset.

  1. Crie um conjunto de dados com o nome bqml_tutorial com a localização dos dados definida como US e uma descrição de BigQuery ML tutorial dataset:

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

    Em vez de usar a flag --dataset, o comando usa o atalho -d. Se omitir -d e --dataset, o comando cria um conjunto de dados por predefinição.

  2. Confirme que o conjunto de dados foi criado:

    bq ls

API

Chame o método datasets.insert com um recurso de conjunto de dados definido.

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

DataFrames do BigQuery

Antes de experimentar este exemplo, siga as instruções de configuração dos DataFrames do BigQuery no início rápido do BigQuery com os DataFrames do BigQuery. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure o ADC para um ambiente de desenvolvimento local.

import google.cloud.bigquery

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

Crie um modelo de regressão logística

Crie um modelo de regressão logística com o conjunto de dados de exemplo do Analytics para o BigQuery.

SQL

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, execute a seguinte declaraçã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 demora vários minutos a ser concluída. Após a conclusão da primeira iteração, o seu modelo (sample_model) aparece no painel de navegação. Uma vez que a consulta usa uma declaração CREATE MODEL para criar um modelo, não vê os resultados da consulta.

Detalhes da consulta

A declaração CREATE MODEL cria o modelo e, em seguida, prepara o modelo com os dados obtidos pela declaração SELECT da sua consulta.

A cláusula OPTIONS(model_type='logistic_reg') cria um modelo de regressão logística. Um modelo de regressão logística divide os dados de entrada em duas classes e, em seguida, estima a probabilidade de os dados estarem numa das classes. O que está a tentar detetar, como se um email é spam, é representado por 1 e os outros valores são representados por 0. A probabilidade de um determinado valor pertencer à classe que está a tentar detetar é indicada por um valor entre 0 e 1. Por exemplo, se um email receber uma estimativa de probabilidade de 0,9, existe uma probabilidade de 90% de o email ser spam.

A declaração SELECT desta consulta obtém as seguintes colunas 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 é definido como 0. Caso contrário, é definido como 1. Estes valores representam os resultados possíveis. A criação de um alias com o nome label é uma alternativa à definição da opção input_label_cols= na declaração CREATE MODEL.
  • device.operatingSystem: o sistema operativo 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áginas na sessão.

A cláusula FROM faz com que a consulta prepare o modelo usando as tabelas de amostra bigquery-public-data.google_analytics_sample.ga_sessions. Estas tabelas são divididas por data, pelo que as agrega usando um caráter universal 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 analisadas pela consulta. O intervalo de datas analisado é de 1 de agosto de 2016 a 30 de junho de 2017.

DataFrames do BigQuery

Antes de experimentar este exemplo, siga as instruções de configuração dos DataFrames do BigQuery no início rápido do BigQuery com os DataFrames do BigQuery. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure o ADC 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,
)

Veja as estatísticas de perda do modelo

A aprendizagem automática consiste em criar um modelo que possa usar dados para fazer uma previsão. O modelo é essencialmente uma função que recebe entradas e aplica cálculos às entradas para produzir uma saída, ou seja, uma previsão.

Os algoritmos de aprendizagem automática funcionam através da análise de vários exemplos em que a previsão já é conhecida (como os dados do histórico de compras dos utilizadores) e do ajuste iterativo de vários pesos no modelo para que as previsões do modelo correspondam aos valores reais. O modelo faz isto minimizando o quão errado está através de uma métrica denominada perda.

A expetativa é que, para cada iteração, a perda diminua, idealmente, para zero. Uma perda de zero significa que o modelo é 100% preciso.

Ao preparar o modelo, o BigQuery ML divide automaticamente os dados de entrada em conjuntos de preparação e avaliação, para evitar o sobreajuste do modelo. Isto é necessário para que o algoritmo de preparação não se ajuste demasiado aos dados de preparação, de modo que não consiga generalizar para novos exemplos.

Use a Trusted Cloud consola para ver como a perda do modelo muda ao longo das iterações de preparação do modelo:

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

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

  3. Clique no separador Formação e consulte o gráfico Perda. O gráfico de Perda mostra a alteração na métrica de perda ao longo das iterações no conjunto de dados de treino. Se passar o cursor do rato sobre o gráfico, pode ver que existem linhas para Perda de treino e Perda de avaliação. Uma vez que fez uma regressão logística, o valor da perda de formação é calculado como perda logarítmica, usando os dados de formação. A perda de avaliação é a perda logarítmica calculada nos dados de avaliação. Ambos os tipos de perda representam valores de perda médios, calculados para todos os exemplos nos respetivos conjuntos de dados para cada iteração.

Também pode ver os resultados da preparação do modelo através da função ML.TRAINING_INFO.

Avalie o modelo

Avalie o desempenho do modelo através da função ML.EVALUATE. A função ML.EVALUATE avalia os valores previstos gerados pelo modelo em comparação com os dados reais. Para calcular métricas específicas da regressão logística, pode usar a função SQL ML.ROC_CURVE ou a função bigframes.ml.metrics.roc_curve BigQuery DataFrames.

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

SQL

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, execute a seguinte declaraçã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 devem ter o seguinte aspeto:

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

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

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

    • recall: uma métrica para modelos de classificação que responde à seguinte pergunta: de todas as etiquetas positivas possíveis, quantas o modelo identificou corretamente?

    • accuracy: A precisão é a fração de previsões em que um modelo de classificação acertou.

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

    • log_loss: a função de perda usada numa regressão logística. Esta é a medida da distância entre as previsões do modelo e as etiquetas corretas.

    • roc_auc: a área abaixo da curva ROC. Esta é a probabilidade de um classificador ter mais confiança de que um exemplo positivo escolhido aleatoriamente é realmente positivo do que um exemplo negativo escolhido aleatoriamente é positivo. Para mais informações, consulte a secção Classificação no Curso intensivo de aprendizagem automática.

Detalhes da consulta

A declaração SELECT inicial obtém as colunas do seu modelo.

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

A declaração SELECT aninhada e a cláusula FROM são iguais às da consulta CREATE MODEL.

A cláusula WHERE_TABLE_SUFFIX BETWEEN '20170701' AND '20170801' — limita o número de tabelas analisadas pela consulta. O intervalo de datas analisado é de 1 de julho de 2017 a 1 de agosto de 2017. Estes são os dados que está a usar para avaliar o desempenho preditivo do modelo. Foi recolhido no mês imediatamente a seguir ao período abrangido pelos dados de preparação.

DataFrames do BigQuery

Antes de experimentar este exemplo, siga as instruções de configuração dos DataFrames do BigQuery no início rápido do BigQuery com os DataFrames do BigQuery. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure o ADC 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 o modelo para prever resultados

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

SQL

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, execute a seguinte declaraçã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 devem ter o seguinte aspeto:

    +----------------+---------------------------+
    |    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 declaração SELECT inicial obtém a coluna country e soma a coluna predicted_label. A coluna predicted_label é gerada pela função ML.PREDICT. Quando usa 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 é a etiqueta que melhor descreve o valor de dados de entrada fornecido, 0 ou 1.

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

A declaração SELECT aninhada e a cláusula FROM são iguais às da consulta CREATE MODEL.

A cláusula WHERE_TABLE_SUFFIX BETWEEN '20170701' AND '20170801' — limita o número de tabelas analisadas pela consulta. O intervalo de datas analisado é de 1 de julho de 2017 a 1 de agosto de 2017. Estes são os dados para os quais está a fazer previsões. Foram recolhidos no mês imediatamente a seguir ao período abrangido pelos dados de preparação.

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

A cláusula LIMIT é usada aqui para apresentar apenas os 10 principais resultados.

DataFrames do BigQuery

Antes de experimentar este exemplo, siga as instruções de configuração dos DataFrames do BigQuery no início rápido do BigQuery com os DataFrames do BigQuery. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure o ADC 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

Preveja as compras por utilizador

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

SQL

Esta consulta é idêntica à consulta na secção anterior, exceto pela cláusula GROUP BY. Aqui, a cláusula GROUP BYGROUP BY fullVisitorId — é usada para agrupar os resultados por ID do visitante.

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, execute a seguinte declaraçã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 devem ter o seguinte aspeto:

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

DataFrames do BigQuery

Antes de experimentar este exemplo, siga as instruções de configuração dos DataFrames do BigQuery no início rápido do BigQuery com os DataFrames do BigQuery. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure o ADC 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 incorrer em cobranças na sua Trusted Cloud conta pelos recursos usados nesta página, siga estes passos.

Pode eliminar o projeto que criou ou manter o projeto e eliminar o conjunto de dados.

Elimine o conjunto de dados

A eliminação do projeto remove todos os conjuntos de dados e todas as tabelas no projeto. Se preferir reutilizar o projeto, pode eliminar o conjunto de dados que criou neste tutorial:

  1. Na Trusted Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

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

  3. Clique em Ações > Eliminar.

  4. Na caixa de diálogo Eliminar conjunto de dados, confirme o comando de eliminação escrevendo delete.

  5. Clique em Eliminar.

Elimine o projeto

Para eliminar o projeto:

  1. In the Trusted 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.

O que se segue?