Data science con R su Google Cloud: analisi esplorativa dei dati

Last reviewed 2024-07-22 UTC

Questo documento mostra come iniziare a utilizzare la data science su larga scala con R su Google Cloud. È destinato a chi ha una certa esperienza con R e con i notebook Jupyter e ha familiarità con SQL.

Questo documento si concentra sull'esecuzione dell'analisi esplorativa dei dati utilizzando istanze Vertex AI Workbench e BigQuery. Puoi trovare il codice di accompagnamento in un notebook Jupyter su GitHub.

Panoramica

R è uno dei linguaggi di programmazione più utilizzati per la modellazione statistica. Ha una community ampia e attiva di data scientist e professionisti del machine learning (ML). Con oltre 20.000 pacchetti nel repository open source del Comprehensive R Archive Network (CRAN), R dispone di strumenti per tutte le applicazioni di analisi statistica dei dati, ML e visualizzazione. R ha registrato una crescita costante negli ultimi due decenni grazie all'espressività della sua sintassi e alla completezza delle sue librerie di dati e ML.

In qualità di data scientist, potresti voler sapere come utilizzare le tue competenze utilizzando R e come sfruttare i vantaggi dei servizi cloud scalabili e completamente gestiti per la data science.

Architettura

In questa procedura dettagliata, utilizzi le istanze Vertex AI Workbench come ambienti di data science per eseguire l'analisi esplorativa dei dati (EDA). In questa procedura dettagliata utilizzi R sui dati estratti da BigQuery, il data warehouse su cloud serverless, a scalabilità elevata ed economico di Google. Dopo aver analizzato ed elaborato i dati, i dati trasformati vengono archiviati in Cloud Storage per ulteriori potenziali attività di ML. Questo flusso è mostrato nel seguente diagramma:

Flusso di dati da BigQuery a Vertex AI Workbench, dove vengono elaborati utilizzando R e i risultati vengono inviati a Cloud Storage per ulteriori analisi.

Dati di esempio

I dati di esempio per questo documento sono il set di dati BigQuery New York City taxi trips. Questo set di dati pubblici include informazioni sui milioni di corse di taxi che si svolgono ogni anno a New York. In questo documento utilizzi i dati del 2022, che si trovano nella tabella bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2022 in BigQuery.

Questo documento si concentra sull'EDA e sulla visualizzazione utilizzando R e BigQuery. I passaggi descritti in questo documento ti consentono di configurare un obiettivo di ML per prevedere l'importo della tariffa del taxi (l'importo al lordo di tasse, commissioni e altri extra), in base a una serie di fattori relativi al viaggio. La creazione effettiva del modello non è trattata in questo documento.

Vertex AI Workbench

Vertex AI Workbench è un servizio che offre un ambiente JupyterLab integrato con le seguenti funzionalità:

  • Deployment con un solo clic. Puoi utilizzare un solo clic per avviare un'istanza JupyterLab preconfigurata con i più recenti framework di machine learning e data science.
  • Scalabilità on demand. Puoi iniziare con una configurazione della macchina di piccole dimensioni (ad esempio, 4 vCPU e 16 GB di RAM, come in questo documento) e, quando i dati diventano troppo grandi per una macchina, puoi fare lo scale up aggiungendo CPU, RAM e GPU.
  • Google Cloud integrazione. Le istanze di Vertex AI Workbench sono integrate con servizi come BigQuery. Google Cloud Questa integrazione semplifica il passaggio dall'importazione dei dati alla pre-elaborazione e all'esplorazione.
  • Prezzi a consumo. Non sono previste tariffe minime o impegni iniziali. Per informazioni, consulta i prezzi di Vertex AI Workbench. Paghi anche per le risorse Google Cloud che utilizzi all'interno dei notebook (come BigQuery e Cloud Storage).

I notebook dell'istanza Vertex AI Workbench vengono eseguiti su Deep Learning VM Image. Questo documento supporta la creazione di un'istanza di Vertex AI Workbench con R 4.3.

Utilizzare BigQuery con R

BigQuery non richiede la gestione dell'infrastruttura, quindi puoi concentrarti sulla scoperta di informazioni significative. Puoi analizzare grandi quantità di dati su larga scala e preparare set di dati per il machine learning utilizzando le ricche funzionalità di analisi SQL di BigQuery.

Per eseguire query sui dati BigQuery utilizzando R, puoi utilizzare bigrquery, una libreria R open source. Il pacchetto bigrquery fornisce i seguenti livelli di astrazione su BigQuery:

  • L'API di basso livello fornisce wrapper sottili sull'API REST BigQuery sottostante.
  • L'interfaccia DBI racchiude l'API di basso livello e rende l'utilizzo di BigQuery simile a quello di qualsiasi altro sistema di database. Questo è il livello più comodo se vuoi eseguire query SQL in BigQuery o caricare meno di 100 MB.
  • L'interfaccia dbplyr consente di trattare le tabelle BigQuery come frame di dati in memoria. Questo è il livello più comodo se non vuoi scrivere codice SQL, ma vuoi che lo scriva dbplyr per te.

Questo documento utilizza l'API di basso livello di bigrquery, senza richiedere DBI o dbplyr.

Obiettivi

  • Crea un'istanza di Vertex AI Workbench che supporti R.
  • Esegui query e analizza i dati da BigQuery utilizzando la libreria R bigrquery.
  • Prepara e archivia i dati per il machine learning in Cloud Storage.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

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

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

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Compute Engine API.

    Enable the API

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

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Compute Engine API.

    Enable the API

    8.

    crea un'istanza di Vertex AI Workbench

    Il primo passaggio consiste nel creare un'istanza di Vertex AI Workbench che puoi utilizzare per questa procedura dettagliata.

    1. Nella console Google Cloud vai alla pagina Workbench.

      Vai a Workbench

    2. Nella scheda Istanze, fai clic su Crea nuova.

    3. Nella finestra Nuova istanza, fai clic su Crea. Per questa procedura dettagliata, mantieni tutti i valori predefiniti.

      L'avvio dell'istanza Vertex AI Workbench può richiedere 2-3 minuti. Quando è pronta, l'istanza viene elencata automaticamente nel riquadro Istanze notebook e accanto al nome dell'istanza è presente un link Apri JupyterLab. Se il link per aprire JupyterLab non viene visualizzato nell'elenco dopo alcuni minuti, aggiorna la pagina.

    Apri JupyterLab e installa R

    Per completare la procedura dettagliata nel blocco note, devi aprire l'ambiente JupyterLab, installare R, clonare il repository GitHub vertex-ai-samples e poi aprire il blocco note.

    1. Nell'elenco delle istanze, fai clic su Apri JupyterLab. Si apre l'ambiente JupyterLab in un'altra scheda del browser.

    2. Nell'ambiente JupyterLab, fai clic su  Nuovo Avvio app e poi nella scheda Avvio app, fai clic su Terminale.

    3. Nel riquadro del terminale, installa R:

      conda create -n r
conda activate r
conda install -c r r-essentials r-base=4.3.2

      Durante l'installazione, ogni volta che ti viene chiesto di continuare, digita y. Il completamento dell'installazione potrebbe richiedere alcuni minuti. Al termine dell'installazione, l'output è simile al seguente:

      done
Executing transaction: done
® jupyter@instance-INSTANCE_NUMBER:~$

      dove INSTANCE_NUMBER è il numero univoco assegnato alla tua istanza di Vertex AI Workbench.

    4. Al termine dell'esecuzione dei comandi nel terminale, aggiorna la pagina del browser e apri Avvio app facendo clic su  Nuovo Avvio app.

      La scheda Launcher mostra le opzioni per avviare R in un notebook o nella console e per creare un file R.

    5. Fai clic sulla scheda Terminale, quindi clona il repository GitHub vertex-ai-samples:

      git clone https://github.com/GoogleCloudPlatform/vertex-ai-samples.git

      Al termine del comando, vedrai la cartella vertex-ai-samples nel riquadro del browser dei file dell'ambiente JupyterLab.

    6. Nel browser di file, apri vertex-ai-samples>notebooks >community>exploratory_data_analysis. Viene visualizzato il notebook eda_with_r_and_bigquery.ipynb.

    Apri il notebook e configura R

    1. Nel browser di file, apri il blocco note eda_with_r_and_bigquery.ipynb.

      Questo notebook illustra l'analisi esplorativa dei dati con R e BigQuery. Nel resto di questo documento, lavorerai nel notebook ed eseguirai il codice che vedi all'interno del notebook Jupyter.

    2. Controlla la versione di R utilizzata dal blocco note:

      version

      Il campo version.string nell'output deve mostrare R version 4.3.2, che hai installato nella sezione precedente.

    3. Controlla e installa i pacchetti R necessari se non sono già disponibili nella sessione corrente:

      # List the necessary packages
needed_packages <- c("dplyr", "ggplot2", "bigrquery")

# Check if packages are installed
installed_packages <- .packages(all.available = TRUE)
missing_packages <- needed_packages[!(needed_packages %in% installed_packages)]

# If any packages are missing, install them
if (length(missing_packages) > 0) {
  install.packages(missing_packages)
}

    4. Carica i pacchetti richiesti:

      # Load the required packages
lapply(needed_packages, library, character.only = TRUE)

    5. Autentica bigrquery utilizzando l'autenticazione out-of-band:

      bq_auth(use_oob = True)

    6. Imposta il nome del progetto che vuoi utilizzare per questo blocco note sostituendo [YOUR-PROJECT-ID] con un nome:

      # Set the project ID
PROJECT_ID <- "[YOUR-PROJECT-ID]"

    7. Imposta il nome del bucket Cloud Storage in cui archiviare i dati di output sostituendo [YOUR-BUCKET-NAME] con un nome univoco a livello globale:

      BUCKET_NAME <- "[YOUR-BUCKET-NAME]"

    8. Imposta l'altezza e la larghezza predefinite per i grafici che verranno generati in un secondo momento nel notebook:

      options(repr.plot.height = 9, repr.plot.width = 16)

    Esegui query sui dati da BigQuery

    In questa sezione del blocco note, leggi i risultati dell'esecuzione di un'istruzione SQL di BigQuery in R e dai un'occhiata preliminare ai dati.

    1. Crea un'istruzione SQL BigQuery che estrae alcuni possibili predittori e la variabile di previsione target per un campione di viaggi. La seguente query filtra alcuni valori anomali o privi di significato nei campi che vengono letti per l'analisi.

      sql_query_template <- "
    SELECT
      TIMESTAMP_DIFF(dropoff_datetime, pickup_datetime, MINUTE) AS trip_time_minutes,

      passenger_count,

      ROUND(trip_distance, 1) AS trip_distance_miles,

      rate_code,
      /* Mapping from rate code to type from description column in BigQuery table schema */
      (CASE
        WHEN rate_code = '1.0'
          THEN 'Standard rate'
        WHEN rate_code = '2.0'
          THEN 'JFK'
        WHEN rate_code = '3.0'
          THEN 'Newark'
        WHEN rate_code = '4.0'
          THEN 'Nassau or Westchester'
        WHEN rate_code = '5.0'
          THEN 'Negotiated fare'
        WHEN rate_code = '6.0'
          THEN 'Group ride'
        /* Several NULL AND some '99.0' values go here */
        ELSE 'Unknown'
        END)
        AS rate_type,

      fare_amount,

      CAST(ABS(FARM_FINGERPRINT(
        CONCAT(
          CAST(trip_distance AS STRING),
          CAST(fare_amount AS STRING)
          )
        ))
        AS STRING)
        AS key

    FROM
      `bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2022`

    /* Filter out some outlier or hard to understand values */
    WHERE
      (TIMESTAMP_DIFF(dropoff_datetime, pickup_datetime, MINUTE)
        BETWEEN 0.01 AND 120)
      AND
      (passenger_count BETWEEN 1 AND 10)
      AND
      (trip_distance BETWEEN 0.01 AND 100)
      AND
      (fare_amount BETWEEN 0.01 AND 250)

    LIMIT %s
"

      La colonna key è un identificatore di riga generato in base ai valori concatenati delle colonne trip_distance e fare_amount.

    2. Esegui la query e recupera gli stessi dati di una tibble in memoria, che è simile a un frame di dati.

      sample_size <- 10000

sql_query <- sprintf(sql_query_template, sample_size)

taxi_trip_data <- bq_table_download(
    bq_project_query(
        PROJECT_ID,
        query = sql_query
    )
)

    3. Visualizza i risultati recuperati:

      head(taxi_trip_data)

      L'output è una tabella simile alla seguente immagine:

      Le prime sei righe dei dati sui viaggi in taxi.

      I risultati mostrano le seguenti colonne di dati di viaggio:

      • trip_time_minutes numero intero
      • passenger_count numero intero
      • trip_distance_miles: doppio
      • rate_code carattere
      • rate_type carattere
      • fare_amount: doppio
      • key carattere

    4. Visualizza il numero di righe e i tipi di dati di ogni colonna:

      str(taxi_trip_data)

      L'output è simile al seguente:

      tibble [10,000 x 7] (S3: tbl_df/tbl/data.frame)
$ trip_time_minutes  : int [1:10000] 52 19 2 7 14 16 1 2 2 6 ...
$ passenger_count    : int [1:10000] 1 1 1 1 1 1 1 1 3 1 ...
$ trip_distance_miles: num [1:10000] 31.3 8.9 0.4 0.9 2 0.6 1.7 0.4 0.5 0.2 ...
$ rate_code          : chr [1:10000] "5.0" "5.0" "5.0" "5.0" ...
$ rate_type          : chr [1:10000] "Negotiated fare" "Negotiated fare" "Negotiated fare" "Negotiated fare" ...
$ fare_amount        : num [1:10000] 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 ...
$ key                : chr [1:10000] "1221969315200336084" 5007772749405424948" "3727452358632142755" "77714841168471205370" ...

    5. Visualizza un riepilogo dei dati recuperati:

      summary(taxi_trip_data)

      L'output è simile al seguente:

      trip_time_minutes passenger_count trip_distance_miles  rate_code
Min.   :  1.00    Min.   :1.000   Min.   : 0.000      Length:10000
1st Qu.: 20.00    1st Qu.:1.000   1st Qu.: 3.700      Class :character
Median : 24.00    Median :1.000   Median : 4.800      Mode  :character
Mean   : 30.32    Mean   :1.465   Mean   : 9.639
3rd Qu.: 39.00    3rd Qu.:2.000   3rd Qu.:17.600
Max.   :120.00    Max.   :9.000   Max.   :43.700
rate_type          fare_amount         key
Length:10000       Min.   :  0.01   Length:10000
Class :character   1st Qu.: 16.50   Class :character
Mode  :character   Median : 16.50   Mode  :character
                  Mean   : 31.22
                  3rd Qu.: 52.00
                  Max.   :182.50

    Visualizzare i dati utilizzando ggplot2

    In questa sezione del blocco note, utilizzi la libreria ggplot2 in R per studiare alcune delle variabili del set di dati di esempio.

    1. Visualizza la distribuzione dei valori fare_amount utilizzando un istogramma:

      ggplot(
    data = taxi_trip_data,
    aes(x = fare_amount)
    ) +
geom_histogram(bins = 100)

      Il grafico risultante è simile a quello nell'immagine seguente:

      Un grafico che mostra la distribuzione degli importi delle tariffe con picchi ai valori 20 e 52.

    2. Mostra la relazione tra trip_distance e fare_amount utilizzando un grafico a dispersione:

      ggplot(
    data = taxi_trip_data,
    aes(x = trip_distance_miles, y = fare_amount)
    ) +
geom_point() +
geom_smooth(method = "lm")

      Il grafico risultante è simile a quello nell'immagine seguente:

      Un grafico a dispersione della relazione tra la distanza della corsa e l&#39;importo della tariffa, con una linea di smoothing della regressione lineare.

    Elabora i dati in BigQuery da R

    Quando lavori con set di dati di grandi dimensioni, ti consigliamo di eseguire la maggior parte dell'analisi possibile (aggregazione, filtraggio, unione, calcolo delle colonne e così via) in BigQuery e poi recuperare i risultati. L'esecuzione di queste attività in R è meno efficiente. L'utilizzo di BigQuery per l'analisi sfrutta la scalabilità e le prestazioni di BigQuery e garantisce che i risultati restituiti possano essere memorizzati in R.

    1. Nel notebook, crea una funzione che trovi il numero di viaggi e l'importo medio della tariffa per ogni valore della colonna scelta:

      get_distinct_value_aggregates <- function(column) {
    query <- paste0(
        'SELECT ',
          column,
          ',
          COUNT(1) AS num_trips,
          AVG(fare_amount) AS avg_fare_amount

        FROM
          `bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2022`

        WHERE
          (TIMESTAMP_DIFF(dropoff_datetime, pickup_datetime, MINUTE)
            BETWEEN 0.01 AND 120)
          AND
          (passenger_count BETWEEN 1 AND 10)
          AND
          (trip_distance BETWEEN 0.01 AND 100)
          AND
          (fare_amount BETWEEN 0.01 AND 250)

        GROUP BY 1
        '
        )

    bq_table_download(
        bq_project_query(
            PROJECT_ID,
            query = query
        )
    )
}

    2. Richiama la funzione utilizzando la colonna trip_time_minutes definita utilizzando la funzionalità timestamp in BigQuery:

      df <- get_distinct_value_aggregates(
  'TIMESTAMP_DIFF(dropoff_datetime, pickup_datetime, MINUTE) AS trip_time_minutes')

ggplot(
    data = df,
    aes(x = trip_time_minutes, y = num_trips)
    ) +
geom_line()

ggplot(
    data = df,
    aes(x = trip_time_minutes, y = avg_fare_amount)
    ) +
geom_line()

      Il notebook mostra due grafici. Il primo grafico mostra il numero di viaggi in base alla durata del viaggio in minuti. Il secondo grafico mostra l'importo medio della tariffa dei viaggi in base alla durata del viaggio.

      L'output del primo comando ggplot è il seguente, che mostra il numero di viaggi in base alla durata del viaggio (in minuti):

      Una curva mostra che il numero di viaggi in minuti è più alto a 0-10 minuti e diminuisce bruscamente man mano che la durata del viaggio si avvicina a 25 minuti.

      L'output del secondo comando ggplot è il seguente, che mostra l'importo medio della tariffa dei viaggi in base alla durata del viaggio:

      Una curva mostra che l&#39;importo medio della tariffa aumenta costantemente da 0 minuti a 50 minuti, per poi aumentare a un ritmo più lento da 50 minuti a 125 minuti.

      Per visualizzare altri esempi di visualizzazione con altri campi nei dati, consulta il notebook.

    Salva i dati come file CSV in Cloud Storage

    L'attività successiva consiste nel salvare i dati estratti da BigQuery come file CSV in Cloud Storage in modo da poterli utilizzare per ulteriori attività di ML.

    1. Nel notebook, carica i dati di addestramento e valutazione da BigQuery in R:

      # Prepare training and evaluation data from BigQuery
sample_size <- 10000

sql_query <- sprintf(sql_query_template, sample_size)

# Split data into 75% training, 25% evaluation
train_query <- paste('SELECT * FROM (', sql_query,
  ') WHERE MOD(CAST(key AS INT64), 100) <= 75')
eval_query <- paste('SELECT * FROM (', sql_query,
  ') WHERE MOD(CAST(key AS INT64), 100) > 75')

# Load training data to data frame
train_data <- bq_table_download(
    bq_project_query(
        PROJECT_ID,
        query = train_query
    )
)

# Load evaluation data to data frame
eval_data <- bq_table_download(
    bq_project_query(
        PROJECT_ID,
        query = eval_query
    )
)

    2. Controlla il numero di osservazioni in ogni set di dati:

      print(paste0("Training instances count: ", nrow(train_data)))

print(paste0("Evaluation instances count: ", nrow(eval_data)))

      Circa il 75% delle istanze totali deve essere utilizzato per l'addestramento, mentre circa il 25% delle istanze rimanenti deve essere utilizzato per la valutazione.

    3. Scrivi i dati in un file CSV locale:

      # Write data frames to local CSV files, with headers
dir.create(file.path('data'), showWarnings = FALSE)

write.table(train_data, "data/train_data.csv",
  row.names = FALSE, col.names = TRUE, sep = ",")

write.table(eval_data, "data/eval_data.csv",
  row.names = FALSE, col.names = TRUE, sep = ",")

    4. Carica i file CSV su Cloud Storage eseguendo il wrapping dei comandi gsutil passati al sistema:

      # Upload CSV data to Cloud Storage by passing gsutil commands to system
gcs_url <- paste0("gs://", BUCKET_NAME, "/")

command <- paste("gsutil mb", gcs_url)

system(command)

gcs_data_dir <- paste0("gs://", BUCKET_NAME, "/data")

command <- paste("gsutil cp data/*_data.csv", gcs_data_dir)

system(command)

command <- paste("gsutil ls -l", gcs_data_dir)

system(command, intern = TRUE)

      Puoi anche caricare file CSV in Cloud Storage utilizzando la libreria googleCloudStorageR, che richiama l'API Cloud Storage JSON.

    Puoi anche utilizzare bigrquery per scrivere i dati da R in BigQuery. La scrittura in BigQuery viene in genere eseguita dopo aver completato un pre-elaborazione o generato risultati da utilizzare per ulteriori analisi.

    Esegui la pulizia

    Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo documento, devi rimuoverle.

    Elimina il progetto

    Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato. Se intendi esplorare più architetture, tutorial o guide rapide, il riutilizzo dei progetti ti aiuta a non 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

    • Scopri di più su come utilizzare i dati BigQuery nei notebook R nella documentazione di bigrquery.
    • Scopri le best practice per l'ingegneria ML in Rules of ML.
    • Per una panoramica dei principi e dei consigli architetturali specifici per i workload di AI e ML in Google Cloud, consulta la prospettiva AI e ML nel framework Well-Architected.
    • Per ulteriori architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.

    Collaboratori

    Autore: Alok Pattani | Developer Advocate

    Altri collaboratori: