Creare un modello di machine learning in BigQuery ML utilizzando SQL

Creare un modello di machine learning in BigQuery ML utilizzando SQL

Questo tutorial mostra come creare un modello di regressione logistica utilizzando query SQL BigQuery ML.

BigQuery ML consente di creare e addestrare modelli di machine learning in BigQuery utilizzando query SQL. Ciò contribuisce a rendere il machine learning più accessibile consentendoti di utilizzare strumenti familiari come l'editor SQL di BigQuery e aumenta anche la velocità di sviluppo eliminando la necessità di spostare i dati in un ambiente di machine learning separato.

In questo tutorial, utilizzi il set di dati di esempio di Google Analytics per BigQuery per creare un modello che prevede se un visitatore del sito web effettuerà una transazione. Per informazioni sullo schema del set di dati Analytics, consulta Schema di BigQuery Export nel Centro assistenza Analytics.

Per scoprire come creare modelli utilizzando l'interfaccia utente della console Google Cloud , consulta Utilizzare i modelli tramite un'interfaccia utente. (Anteprima)

Obiettivi

Questo tutorial mostra come eseguire le seguenti attività:

• Utilizzo dell'istruzione CREATE MODEL per creare un modello di regressione logistica binaria.
• Utilizzando la funzione ML.EVALUATE per valutare il modello.
• Utilizzo della funzione ML.PREDICT per fare previsioni utilizzando il modello.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

• BigQuery
• BigQuery ML

Per ulteriori informazioni sui costi di BigQuery, consulta la pagina Prezzi di BigQuery.

Per ulteriori informazioni sui costi di BigQuery ML, vedi Prezzi di BigQuery ML.

Ruoli obbligatori

• Per creare un modello ed eseguire l'inferenza, devi disporre dei seguenti ruoli:

  • Editor dati BigQuery (roles/bigquery.dataEditor)
  • Utente BigQuery (roles/bigquery.user)

Prima di iniziare

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.
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
Verify that billing is enabled for your Google Cloud project.
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 Google 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 Google Cloud console, go to the IAM page.

   Vai a IAM
2. Seleziona il progetto.
3. Fai clic su Concedi l'accesso.

4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
7. Fai clic su Salva.

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

Verify that billing is enabled for your Google Cloud project.

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 Google 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 Google Cloud console, go to the IAM page.

   Vai a IAM
2. Seleziona il progetto.
3. Fai clic su Concedi l'accesso.

4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
7. Fai clic su Salva.
1. BigQuery viene attivato automaticamente nei nuovi progetti. Per attivare BigQuery in un progetto preesistente, vai a

   Enable the BigQuery API.

   Enable the API

Crea un set di dati

Crea un set di dati BigQuery per archiviare il tuo modello ML.

Console

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai alla pagina BigQuery

2. Nel riquadro Explorer, fai clic sul nome del progetto.

3. Fai clic su Visualizza azioni > Crea set di dati.

   

4. Nella pagina Crea set di dati:

   • In ID set di dati, inserisci bqml_tutorial.

   • Per Tipo di località, seleziona Multi-regione e poi Stati Uniti (più regioni negli Stati Uniti).

   • Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

bq

Per creare un nuovo set di dati, utilizza il comando bq mk con il flag --location. Per un elenco completo dei possibili parametri, consulta la documentazione di riferimento del comando bq mk --dataset.

1. Crea un set di dati denominato bqml_tutorial con la località dei dati impostata su US e una descrizione di BigQuery ML tutorial dataset:

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

   Anziché utilizzare il flag --dataset, il comando utilizza la scorciatoia -d. Se ometti -d e --dataset, il comando crea per impostazione predefinita un dataset.

2. Verifica che il set di dati sia stato creato:

   bq ls

API

Chiama il metodo datasets.insert con una risorsa dataset definita.

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

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

import google.cloud.bigquery

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

Crea un modello di regressione logistica

Crea un modello di regressione logistica utilizzando l'esempio di set di dati di Analytics per BigQuery.

SQL

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, esegui la seguente istruzione:

   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'

   Il completamento della query richiede diversi minuti. Al termine della prima iterazione, il modello (sample_model) viene visualizzato nel pannello di navigazione. Poiché la query utilizza un'istruzione CREATE MODEL per creare un modello, non vengono visualizzati i risultati della query.

Dettagli della query

L'istruzione CREATE MODEL crea il modello e lo addestra utilizzando i dati recuperati dall'istruzione SELECT della query.

La clausola OPTIONS(model_type='logistic_reg') crea un modello di regressione logistica. Un modello di regressione logistica divide i dati di input in due classi, quindi stima la probabilità che i dati appartengano a una delle classi. Ciò che stai cercando di rilevare, ad esempio se un'email è spam, è rappresentato da 1 e gli altri valori sono rappresentati da 0. La probabilità che un determinato valore appartenga alla classe che stai cercando di rilevare è indicata da un valore compreso tra 0 e 1. Ad esempio, se un'email riceve una stima di probabilità pari a 0,9, significa che c'è una probabilità del 90% che l'email sia spam.

L'istruzione SELECT di questa query recupera le seguenti colonne utilizzate dal modello per prevedere la probabilità che un cliente completi una transazione:

• totals.transactions: il numero totale di transazioni e-commerce durante la sessione. Se il numero di transazioni è NULL, il valore nella colonna label è impostato su 0. In caso contrario, viene impostato su 1. Questi valori rappresentano i possibili risultati. La creazione di un alias denominato label è un'alternativa all'impostazione dell'opzione input_label_cols= nell'istruzione CREATE MODEL.
• device.operatingSystem: il sistema operativo del dispositivo del visitatore.
• device.isMobile: indica se il dispositivo del visitatore è un dispositivo mobile.
• geoNetwork.country: il paese da cui hanno origine le sessioni, in base all'indirizzo IP.
• totals.pageviews: il numero totale di visualizzazioni di pagina all'interno della sessione.

La clausola FROM fa sì che la query addestri il modello utilizzando le tabelle di esempio bigquery-public-data.google_analytics_sample.ga_sessions. Queste tabelle sono suddivise in partizioni per data, quindi le aggreghi utilizzando un carattere jolly nel nome della tabella: google_analytics_sample.ga_sessions_*.

La clausola WHERE — _TABLE_SUFFIX BETWEEN '20160801' AND '20170630' — limita il numero di tabelle analizzate dalla query. L'intervallo di date scansionato va dal 1° agosto 2016 al 30 giugno 2017.

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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

Visualizzare le statistiche sulla perdita del modello

Il machine learning consiste nel creare un modello che possa utilizzare i dati per fare una previsione. Il modello è essenzialmente una funzione che accetta input e applica calcoli agli input per produrre un output, ovvero una previsione.

Gli algoritmi di machine learning funzionano prendendo diversi esempi in cui la previsione è già nota (come i dati storici degli acquisti degli utenti) e regolando in modo iterativo vari pesi nel modello in modo che le previsioni del modello corrispondano ai valori reali. Per farlo, riduce al minimo l'errore del modello utilizzando una metrica chiamata perdita.

L'aspettativa è che per ogni iterazione la perdita diminuisca, idealmente fino a zero. Una perdita pari a zero indica che il modello è preciso al 100%.

Durante l'addestramento del modello, BigQuery ML suddivide automaticamente i dati di input in set di addestramento e valutazione per evitare l'overfitting del modello. Ciò è necessario affinché l'algoritmo di addestramento non si adatti ai dati di addestramento in modo così preciso da non poter generalizzare nuovi esempi.

Utilizza la console Google Cloud per vedere come cambia la perdita del modello nel corso delle iterazioni di addestramento:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro Explorer, espandi bqml_tutorial > Modelli e poi fai clic su sample_model.

3. Fai clic sulla scheda Addestramento e guarda il grafico Perdita. Il grafico Perdita mostra la variazione della metrica di perdita nel corso delle iterazioni sul set di dati di addestramento. Se tieni il cursore sopra il grafico, puoi vedere che ci sono linee per Perdita di addestramento e Perdita di valutazione. Poiché hai eseguito una regressione logistica, il valore della perdita di addestramento viene calcolato come perdita logaritmica, utilizzando i dati di addestramento. La perdita di valutazione è la perdita logaritmica calcolata sui dati di valutazione. Entrambi i tipi di perdita rappresentano i valori medi di perdita, calcolati su tutti gli esempi nei rispettivi set di dati per ogni iterazione.

Puoi anche visualizzare i risultati dell'addestramento del modello utilizzando la funzione ML.TRAINING_INFO.

Valuta il modello

Valuta le prestazioni del modello utilizzando la funzione ML.EVALUATE. La funzione ML.EVALUATE valuta i valori previsti generati dal modello rispetto ai dati effettivi. Per calcolare metriche specifiche per la regressione logistica, puoi utilizzare la funzione SQL ML.ROC_CURVE o la funzione BigQuery DataFrames bigframes.ml.metrics.roc_curve.

In questo tutorial utilizzi un modello di classificazione binaria che rileva le transazioni. I valori nella colonna label sono le due classi generate dal modello: 0 (nessuna transazione) e 1 (transazione effettuata).

SQL

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, esegui la seguente istruzione:

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

   I risultati dovrebbero essere simili ai seguenti:

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

   Poiché hai eseguito una regressione logistica, i risultati includono le seguenti colonne:

   • precision: una metrica per i modelli di classificazione. La precisione identifica la frequenza con cui un modello ha previsto correttamente la classe positiva.

   • recall: una metrica per i modelli di classificazione che risponde alla seguente domanda: tra tutte le etichette positive possibili, quante sono state identificate correttamente dal modello?

   • accuracy: l'accuratezza è la frazione di previsioni che un modello di classificazione ha indovinato.

   • f1_score: una misura dell'accuratezza del modello. Il punteggio F1 è la media armonica di precisione e richiamo. Il valore migliore di un punteggio F1 è 1. Il valore peggiore è 0.

   • log_loss: la funzione di perdita utilizzata in una regressione logistica. Questa è la misura della distanza delle previsioni del modello dalle etichette corrette.

   • roc_auc: l'area sotto la curva ROC. Questa è la probabilità che un classificatore sia più sicuro che un esempio positivo scelto a caso sia effettivamente positivo rispetto a un esempio negativo scelto a caso. Per saperne di più, consulta Classificazione in Machine Learning Crash Course.

Dettagli della query

L'istruzione SELECT iniziale recupera le colonne dal modello.

La clausola FROM utilizza la funzione ML.EVALUATE rispetto al tuo modello.

L'istruzione SELECT e la clausola FROM nidificate sono le stesse della query CREATE MODEL.

La clausola WHERE — _TABLE_SUFFIX BETWEEN '20170701' AND '20170801' — limita il numero di tabelle analizzate dalla query. L'intervallo di date scansionato è dal 1° luglio 2017 al 1° agosto 2017. Questi sono i dati che utilizzi per valutare il rendimento predittivo del modello. È stato raccolto nel mese immediatamente successivo al periodo di tempo coperto dai dati di addestramento.

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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]

Utilizzare il modello per prevedere i risultati

Utilizza il modello per prevedere il numero di transazioni effettuate dai visitatori del sito web di ogni paese.

SQL

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, esegui la seguente istruzione:

   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

   I risultati dovrebbero essere simili ai seguenti:

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

Dettagli della query

L'istruzione SELECT iniziale recupera la colonna country e somma la colonna predicted_label. La colonna predicted_label viene generata dalla funzione ML.PREDICT. Quando utilizzi la funzione ML.PREDICT, il nome della colonna di output per il modello è predicted_<label_column_name>. Per i modelli di regressione lineare, predicted_label è il valore stimato di label. Per i modelli di regressione logistica, predicted_label è l'etichetta che descrive meglio il valore dei dati di input specificato, ovvero 0 o 1.

La funzione ML.PREDICT viene utilizzata per prevedere i risultati utilizzando il modello.

L'istruzione SELECT e la clausola FROM nidificate sono le stesse della query CREATE MODEL.

La clausola WHERE — _TABLE_SUFFIX BETWEEN '20170701' AND '20170801' — limita il numero di tabelle analizzate dalla query. L'intervallo di date scansionato è dal 1° luglio 2017 al 1° agosto 2017. Questi sono i dati per cui stai facendo previsioni. Sono stati raccolti nel mese immediatamente successivo al periodo di tempo coperto dai dati di addestramento.

Le clausole GROUP BY e ORDER BY raggruppano i risultati per paese e li ordinano in base alla somma degli acquisti previsti in ordine decrescente.

La clausola LIMIT viene utilizzata qui per visualizzare solo i primi 10 risultati.

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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

Prevedi gli acquisti per utente

Prevedi il numero di transazioni che effettuerà ogni visitatore del sito web.

SQL

Questa query è identica a quella della sezione precedente, ad eccezione della clausola GROUP BY. Qui la clausola GROUP BY, GROUP BY fullVisitorId, viene utilizzata per raggruppare i risultati per ID visitatore.

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, esegui la seguente istruzione:

   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

   I risultati dovrebbero essere simili ai seguenti:

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

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

Puoi eliminare il progetto che hai creato o mantenerlo ed eliminare il set di dati.

Eliminazione del set di dati

L'eliminazione del progetto rimuove tutti i set di dati e tutte le tabelle nel progetto. Se preferisci riutilizzare il progetto, puoi eliminare il set di dati creato in questo tutorial:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro Explorer, seleziona il set di dati bqml_tutorial che hai creato.

3. Fai clic su Azioni > Elimina.

4. Nella finestra di dialogo Elimina set di dati, conferma il comando di eliminazione digitando delete.

5. Fai clic su Elimina.

Elimina il progetto

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini, elimini anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

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.

Passaggi successivi

• Per saperne di più sul machine learning, consulta Machine Learning Crash Course.
• Per una panoramica di BigQuery ML, consulta Introduzione a BigQuery ML.
• Per scoprire di più sulla console Google Cloud , consulta Utilizzo della console Google Cloud .