Creare un modello K-means per raggruppare il set di dati sui noleggi di biciclette di Londra

---

BigQuery ML supporta l'apprendimento non supervisionato . Puoi applicare K-means per raggruppare i dati in cluster. A differenza del machine learning supervisionato, che riguarda l'analisi predittiva, l'apprendimento non supervisionato riguarda Analytics. Si tratta di comprendere i tuoi dati in modo da poter rendere i prendono le loro decisioni.

In questo tutorial, utilizzerai un modello K-means in BigQuery ML per per creare cluster di dati Set di dati pubblico London Weekly Noleggias. Dati di Londra Noleggio biciclette contiene il numero di persone che hanno assunto il programma di affitti del ciclo di Santander a Londra nel 2011 a oggi. I dati includono i timestamp di partenza e di arrivo, i nomi delle stazioni e della corsa.

Le query in questo tutorial utilizzano Funzioni geografiche disponibili nell'analisi geospaziale. Per ulteriori informazioni sull'analisi geospaziale, vedi Introduzione all'analisi geospaziale.

Obiettivi

In questo tutorial:

• Creare un modello di clustering K-means.
• Prendi decisioni basate sui dati in base alla visualizzazione di BigQuery ML tra i cluster.

Costi

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

• BigQuery
• BigQuery ML

Per informazioni sui costi di BigQuery, consulta Prezzi di BigQuery.

Per informazioni sui costi di BigQuery ML, consulta Prezzi di BigQuery ML.

Prima di iniziare

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

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

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

   Go to project selector

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

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

   Go to project selector

5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

6. BigQuery viene abilitato automaticamente nei nuovi progetti. Per attivare BigQuery in un progetto preesistente, vai a

   Attiva l'API BigQuery.

   Abilita l'API

Introduzione

I dati possono contenere raggruppamenti naturali o cluster di dati e potresti identificare questi raggruppamenti in modo descrittivo per fare in modo che prendono le loro decisioni. Ad esempio, se sei un rivenditore, potresti voler identificare raggruppamenti naturali di clienti che hanno abitudini d'acquisto o località simili. Questo processo è noto come segmentazione dei clienti.

I dati utilizzati per la segmentazione dei clienti potrebbero includere il negozio alla quale visitato, quali articoli hanno comprato e quanto hanno pagato. Creeresti un modello per cercare di capire in che modo questi gruppi di clienti tipo di poter progettare elementi che risultino interessanti per i membri del gruppo.

Potresti anche trovare gruppi di prodotti tra gli articoli acquistati. In questo caso, raggruppa gli articoli in base a chi li ha acquistati, a quando sono stati acquistati, dove sono stati acquistati e altre caratteristiche simili. Creeresti un modello per determinare le caratteristiche di un gruppo di prodotti, prendere decisioni consapevoli, ad esempio come migliorare il cross-sell.

In questo tutorial utilizzerai BigQuery ML per creare k-means che esegue il clustering Dati sui noleggi biciclette di Londra basati su attributi delle stazioni di noleggio biciclette.

Per creare un modello K-means, segui questi passaggi.

• Passaggio 1: crea un set di dati per archiviare il modello

  Il primo passaggio consiste nel creare un set di dati in cui archiviare il modello.

  .
  Nota: Poiché il set di dati Londra Noleggio biciclette è archiviato in EU località multiregionale, il set di dati deve trovarsi anche in EU.

• Passaggio due: esamina i dati di addestramento

  Il passaggio successivo è esaminare i dati che utilizzi per addestrare il modello di clustering eseguendo una query sulla tabella london_bicycles. Poiché K-means è un supervisionato, l'addestramento del modello non richiede etichette è necessario suddividerli in dati di addestramento e dati di valutazione.

  .

• Passaggio 3. Crea un modello K-means.

  Il terzo passaggio consiste nel creare il modello K-means. Quando crei il modello, di clustering è station_name e i dati vengono raggruppati in base Attributo stazione, ad esempio la distanza della stazione dal centro città.

• Passaggio quattro: usa la funzione ML.PREDICT per prevedere il cluster di una stazione.

  Successivamente, utilizzerai la funzione ML.PREDICT per prevedere il cluster per un un determinato insieme di stazioni. Prevedi i cluster per tutti i nomi delle stazioni che contengono la stringa Kennington.

• Passaggio 5: usa il modello per prendere decisioni basate sui dati.

  L'ultimo passaggio consiste nell'utilizzare il modello per prendere decisioni basate sui dati. Ad esempio: sulla base dei risultati del modello, è possibile determinare quali stazioni trarrebbero vantaggio dalla capacità aggiuntiva.

  .

Passaggio 1: crea il set di dati

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

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

   Vai alla pagina di BigQuery

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

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

   

4. Nella pagina Crea set di dati, segui questi passaggi:

   • In ID set di dati, inserisci bqml_tutorial.

   • In Tipo di località, seleziona Più regioni, quindi seleziona UE (più regioni nell'Unione Europea).

     Il set di dati pubblico di London Noleggio biciclette è archiviato nel EU più regioni. Il set di dati deve trovarsi nella stessa località.

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

     

Passaggio 2: esamina i dati di addestramento

Esamina quindi i dati utilizzati per addestrare il modello K-means. In questo tutorial, raggruppi le stazioni di noleggio in base ai seguenti attributi:

• Durata dei noleggi
• Numero di viaggi al giorno
• Distanza dal centro città

SQL

La seguente query GoogleSQL viene utilizzata esaminare i dati utilizzati per addestrare il modello K-means.

#standardSQL
WITH
hs AS (
SELECT
  h.start_station_name AS station_name,
  IF
  (EXTRACT(DAYOFWEEK
    FROM
      h.start_date) = 1
    OR EXTRACT(DAYOFWEEK
    FROM
      h.start_date) = 7,
    "weekend",
    "weekday") AS isweekday,
  h.duration,
  ST_DISTANCE(ST_GEOGPOINT(s.longitude,
      s.latitude),
    ST_GEOGPOINT(-0.1,
      51.5))/1000 AS distance_from_city_center
FROM
  `bigquery-public-data.london_bicycles.cycle_hire` AS h
JOIN
  `bigquery-public-data.london_bicycles.cycle_stations` AS s
ON
  h.start_station_id = s.id
WHERE
  h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
  AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
stationstats AS (
SELECT
  station_name,
  isweekday,
  AVG(duration) AS duration,
  COUNT(duration) AS num_trips,
  MAX(distance_from_city_center) AS distance_from_city_center
FROM
  hs
GROUP BY
  station_name, isweekday )
SELECT
*
FROM
stationstats
ORDER BY
distance_from_city_center ASC

Dettagli query

Questa query estrae i dati sulle assunzioni del ciclo, tra cui start_station_name, e duration e lo unisce alle informazioni della stazione, tra cui distance-from-city-center. Quindi, calcola gli attributi dalla stazione di stationstats, inclusa la durata media delle corse e il numero di corse e passa per l'attributo della stazione distance_from_city_center.

Questa query utilizza il parametro Clausola WITH per definire le sottoquery. La query utilizza anche gli attributi ST_DISTANCE e ST_GEOGPOINT funzioni di analisi geospaziale. Per ulteriori informazioni su queste funzioni, consulta Area geografica . Per ulteriori informazioni informazioni sull'analisi geospaziale, consulta Introduzione alle analisi geospaziali.

Esegui la query

La seguente query compila i dati di addestramento e viene utilizzata anche nel CREATE MODEL più avanti in questo tutorial.

Per eseguire la query:

1. Vai alla pagina BigQuery.

Vai a BigQuery

1. Nel riquadro dell'editor, esegui la seguente istruzione SQL:

   
   WITH
     hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF
       (EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 1
         OR EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 7,
         "weekend",
         "weekday") AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude,
           s.latitude),
         ST_GEOGPOINT(-0.1,
           51.5))/1000 AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
     ON
       h.start_station_id = s.id
     WHERE
       h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
     stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday )
   SELECT
     *
   FROM
     stationstats
   ORDER BY
     distance_from_city_center ASC
   
   

2. Una volta completata la query, fai clic sulla scheda Risultati sotto il testo della query. geografica specifica. La scheda Risultati mostra le colonne per cui hai eseguito query e che vengono utilizzate per addestrare il tuo modello: station_name, duration, num_trips, distance_from_city_center. I risultati dovrebbero essere simili ai seguenti.

DataFrame BigQuery

Prima di provare questo esempio, segui i DataFrame di BigQuery nella guida rapida di BigQuery utilizzando BigQuery DataFrames. Per ulteriori informazioni, consulta Documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Impostare l'autenticazione per un ambiente di sviluppo locale.

import datetime

import pandas as pd

import bigframes
import bigframes.pandas as bpd

bigframes.options.bigquery.project = your_gcp_project_id
# Compute in the EU multi-region to query the London bicycles dataset.
bigframes.options.bigquery.location = "EU"

# Extract the information you'll need to train the k-means model in this
# tutorial. Use the read_gbq function to represent cycle hires
# data as a DataFrame.
h = bpd.read_gbq(
    "bigquery-public-data.london_bicycles.cycle_hire",
    col_order=["start_station_name", "start_station_id", "start_date", "duration"],
).rename(
    columns={
        "start_station_name": "station_name",
        "start_station_id": "station_id",
    }
)

s = bpd.read_gbq(
    # Use ST_GEOPOINT and ST_DISTANCE to analyze geographical
    # data. These functions determine spatial relationships between
    # geographical features.
    """
    SELECT
    id,
    ST_DISTANCE(
        ST_GEOGPOINT(s.longitude, s.latitude),
        ST_GEOGPOINT(-0.1, 51.5)
    ) / 1000 AS distance_from_city_center
    FROM
    `bigquery-public-data.london_bicycles.cycle_stations` s
    """
)

# Define Python datetime objects in the UTC timezone for range comparison,
# because BigQuery stores timestamp data in the UTC timezone.
sample_time = datetime.datetime(2015, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
sample_time2 = datetime.datetime(2016, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)

h = h.loc[(h["start_date"] >= sample_time) & (h["start_date"] <= sample_time2)]

# Replace each day-of-the-week number with the corresponding "weekday" or
# "weekend" label by using the Series.map method.
h = h.assign(
    isweekday=h.start_date.dt.dayofweek.map(
        {
            0: "weekday",
            1: "weekday",
            2: "weekday",
            3: "weekday",
            4: "weekday",
            5: "weekend",
            6: "weekend",
        }
    )
)

# Supplement each trip in "h" with the station distance information from
# "s" by merging the two DataFrames by station ID.
merged_df = h.merge(
    right=s,
    how="inner",
    left_on="station_id",
    right_on="id",
)

# Engineer features to cluster the stations. For each station, find the
# average trip duration, number of trips, and distance from city center.
stationstats = merged_df.groupby(["station_name", "isweekday"]).agg(
    {"duration": ["mean", "count"], "distance_from_city_center": "max"}
)
stationstats.columns = pd.Index(
    ["duration", "num_trips", "distance_from_city_center"]
)
stationstats = stationstats.sort_values(
    by="distance_from_city_center", ascending=True
).reset_index()

# Expected output results: >>> stationstats.head(3)
# station_name	isweekday duration  num_trips	distance_from_city_center
# Borough Road...	weekday	    1110	    5749	    0.12624
# Borough Road...	weekend	    2125	    1774	    0.12624
# Webber Street...	weekday	    795	        6517	    0.164021
#   3 rows × 5 columns

Passaggio 3. Crea un modello K-means

Ora che hai esaminato i dati di addestramento, il passaggio successivo è creare Modello K-means utilizzando i dati.

SQL

Puoi creare e addestrare un modello K-means utilizzando CREATE MODEL con l'opzione model_type=kmeans.

Dettagli query

L'istruzione CREATE MODEL specifica il numero di cluster da utilizzare: quattro. Nell'istruzione SELECT, la clausola EXCEPT esclude station_name colonna perché station_name non è una funzionalità. La query crea una riga univoca per Station_name, e solo le caratteristiche sono menzionate nell'istruzione SELECT.

Se ometti l'opzione num_clusters, BigQuery ML sceglie una valore predefinito ragionevole in base al numero totale di righe nei dati di addestramento. Tu potresti anche eseguire l'ottimizzazione degli iperparametri per trovare un buon numero. Per determinare un ottimale di cluster, eseguirai la query CREATE MODEL per valori di num_clusters, trova la misura dell'errore e scegli il punto in cui la misura di errore è al suo valore minimo. Puoi ottenere la misura dell'errore Selezionando il modello e facendo clic sulla scheda Valutazione. Questa scheda mostra l'indice di Davies-Bouldin.

Esegui la query

La seguente query aggiunge un'istruzione CREATE MODEL alla query utilizzata esaminare i dati di addestramento e rimuovere anche i campi id al loro interno.

Per eseguire la query e creare un modello K-means:

1. Vai alla pagina BigQuery.

Vai a BigQuery

1. Nel riquadro dell'editor, esegui la seguente istruzione SQL:

   
   CREATE OR REPLACE MODEL `bqml_tutorial.london_station_clusters`
     OPTIONS(model_type='kmeans', num_clusters=4) AS
   WITH
     hs AS (
     SELECT
       h.start_station_name AS station_name,
     IF
       (EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 1
         OR EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 7,
         "weekend",
         "weekday") AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude,
           s.latitude),
         ST_GEOGPOINT(-0.1,
           51.5))/1000 AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
     ON
       h.start_station_id = s.id
     WHERE
       h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
     stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday)
   SELECT
     * EXCEPT(station_name, isweekday)
   FROM
     stationstats
    
   

2. Nel pannello di navigazione, nella sezione Risorse, espandi il nome del tuo progetto, fai clic su bqml_tutorial, quindi su london_station_clusters.

3. Fai clic sulla scheda Schema. Lo schema del modello elenca i quattro attributi delle stazioni usato da BigQuery ML per eseguire il clustering. Lo schema deve avere come mostrato di seguito.

1. Fai clic sulla scheda Valutazione. Questa scheda mostra le visualizzazioni di cluster identificati dal modello K-means. Nella sezione Caratteristiche numeriche, barra mostrano fino a 10 dei più importanti valori delle caratteristiche numeriche per per ciascun centroide. Puoi selezionare le funzionalità da visualizzare dal menu a discesa o dal menu Fogli Google.

DataFrame BigQuery

Prima di provare questo esempio, segui i DataFrame di BigQuery nella guida rapida di BigQuery utilizzando BigQuery DataFrames. Per ulteriori informazioni, consulta Documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Impostare l'autenticazione per un ambiente di sviluppo locale.

from bigframes.ml.cluster import KMeans

# To determine an optimal number of clusters, construct and fit several
# K-Means objects with different values of num_clusters, find the error
# measure, and pick the point at which the error measure is at its minimum
# value.
cluster_model = KMeans(n_clusters=4)
cluster_model.fit(stationstats)
cluster_model.to_gbq(
    your_model_id,  # For example: "bqml_tutorial.london_station_clusters"
    replace=True,
)

Passaggio 4: usa la funzione ML.PREDICT per prevedere il cluster di una stazione

Per identificare il cluster a cui appartiene una particolare stazione, utilizza la ML.PREDICT Funzione SQL oppure la funzione DataFrames BigQuery di predict

SQL

Dettagli query

Questa query utilizza la classe REGEXP_CONTAINS per trovare tutte le voci della colonna station_name contenenti la funzione la stringa "Kennington". La funzione ML.PREDICT utilizza questi valori per prevedere quali cluster contengono queste stazioni.

Esegui la query

La seguente query prevede il cluster di ogni stazione che la stringa "Kennington" nel nome.

Per eseguire la query ML.PREDICT:

1. Vai alla pagina BigQuery.

Vai a BigQuery

1. Nel riquadro dell'editor, esegui la seguente istruzione SQL:

   
   WITH
     hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF
       (EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 1
         OR EXTRACT(DAYOFWEEK
         FROM
           h.start_date) = 7,
         "weekend",
         "weekday") AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude,
           s.latitude),
         ST_GEOGPOINT(-0.1,
           51.5))/1000 AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
     ON
       h.start_station_id = s.id
     WHERE
       h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
     stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday )
   SELECT
     * EXCEPT(nearest_centroids_distance)
   FROM
     ML.PREDICT( MODEL `bqml_tutorial.london_station_clusters`,
       (
       SELECT
         *
       FROM
         stationstats
       WHERE
         REGEXP_CONTAINS(station_name, 'Kennington')))
   
   

2. Una volta completata la query, fai clic sulla scheda Risultati sotto il testo della query. geografica specifica. I risultati dovrebbero essere simili ai seguenti.

   

DataFrame BigQuery

Prima di provare questo esempio, segui i DataFrame di BigQuery nella guida rapida di BigQuery utilizzando BigQuery DataFrames. Per ulteriori informazioni, consulta Documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Impostare l'autenticazione per un ambiente di sviluppo locale.

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

# Use 'contains' function to filter by stations containing the string
# "Kennington".
stationstats = stationstats.loc[
    stationstats["station_name"].str.contains("Kennington")
]

result = cluster_model.predict(stationstats)

# Expected output results:   >>>results.peek(3)
# CENTROID...	NEAREST...	station_name  isweekday	 duration num_trips dist...
# 	1	[{'CENTROID_ID'...	Borough...	  weekday	  1110	    5749	0.13
# 	2	[{'CENTROID_ID'...	Borough...	  weekend	  2125      1774	0.13
# 	1	[{'CENTROID_ID'...	Webber...	  weekday	  795	    6517	0.16
#   3 rows × 7 columns

Passaggio 5: usa il modello per prendere decisioni basate sui dati

I risultati della valutazione possono aiutarti a interpretare i diversi cluster. Nella Nell'esempio seguente, il centroide 3 mostra una stazione trafficata e vicina al centro città. Il Centroid 2 mostra la seconda stazione della città, meno affollata e utilizzati per noleggi di durata maggiore. Il Centroid 1 mostra una stazione della città meno trafficata, con noleggi di durata più breve. Centroid 4 che mostra una stazione di periferia con corse più lunghi.

In base a questi risultati, puoi utilizzare questi dati per prendere decisioni più consapevoli. Ad esempio:

• Supponiamo di dover sperimentare un nuovo tipo di blocco. Quale cluster stazioni di noleggio dovresti scegliere come soggetto per questo esperimento? Le stazioni di 1, 2 o 4 sembrano scelte logiche perché non sono le stazioni più trafficate.

• Supponiamo di voler mettere in magazzino alcune stazioni di biciclette da corsa. Quali stazioni dovresti scegliere? Il centroide 4 è il gruppo di stazioni distanti dal in centro città e i loro viaggi sono i più lunghi. Questi sono probabili candidati per in bici da corsa.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

• Puoi eliminare il progetto che hai creato.
• In alternativa, puoi mantenere il progetto ed eliminare il set di dati.

Elimina il set di dati

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

1. Se necessario, apri la pagina BigQuery nel nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Nel menu di navigazione, fai clic sul set di dati bqml_tutorial che hai creato.

3. Fai clic su Elimina set di dati sul lato destro della finestra. Questa azione elimina il set di dati e il modello.

4. Nella finestra di dialogo Elimina set di dati, digita per confermare il comando di eliminazione il nome del set di dati (bqml_tutorial), quindi 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à in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro 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. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

• Per una panoramica di BigQuery ML, consulta Introduzione a BigQuery ML.
• Per informazioni sulla creazione di modelli, consulta CREATE MODEL pagina sulla sintassi.