Ciência de dados com R no Google Cloud: análise de dados exploratória

Last reviewed 2024-07-22 UTC

Este documento mostra como começar a usar a ciência de dados em escala com o R no Google Cloud. Ele é destinado a quem tem alguma experiência com notebooks do R e do Jupyter e que se sente confortável com o SQL.

Este documento se concentra na análise de dados exploratória usando instâncias do Vertex AI Workbench e o BigQuery. Encontre o código em um notebook do Jupyter (link em inglês) no GitHub.

Visão geral

R é uma das linguagens de programação mais usadas para modelagem estatística. Ela tem uma comunidade grande e ativa de cientistas de dados e profissionais de machine learning (ML, na sigla em inglês). Com mais de 20.000 pacotes no repositório de código aberto da rede de arquivamento abrangente do R (CRAN, na sigla em inglês), o R tem ferramentas para todos os aplicativos de análise de dados estatísticos, ML e visualização. A R tem crescido constante nas últimas duas décadas devido à expressividade da sintaxe e à amplitude de dados e bibliotecas de ML.

Como cientista de dados, é possível usar o conjunto de habilidades que você tem com a R e também aproveitar as vantagens dos serviços em nuvem totalmente gerenciados e escalonáveis para ciência de dados.

Arquitetura

Neste tutorial, você vai usar instâncias do Vertex AI Workbench como ambientes de ciência de dados para realizar a análise exploratória de dados (EDA). Use R em dados extraídos neste tutorial do BigQuery, o armazenamento de dados em nuvem sem servidor, altamente escalonável e econômico do Google. Depois de analisar e processar os dados, os dados transformados são armazenados no Cloud Storage para outras possíveis tarefas de ML. Esse fluxo é mostrado no diagrama a seguir:

Fluxo de dados do BigQuery para o Vertex AI Workbench, em que eles são processados usando R e os resultados são enviados ao Cloud Storage para mais análises.

Dados de exemplo

Os dados de exemplo deste documento são o conjunto de dados de viagens de táxi da cidade de Nova York no BigQuery. Esse conjunto de dados públicos inclui informações sobre os milhões de viagens de táxi que acontecem em Nova York a cada ano. Neste documento, você usa os dados de 2022, que estão na tabela bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2022 no BigQuery.

Este documento se concentra na EDA e na visualização usando a R e o BigQuery. As etapas deste documento configuram você para uma meta de ML de prever o valor da tarifa do táxi (o valor antes de impostos, taxas e outros extras) com base em vários fatores sobre a viagem. A criação de modelos não é abordada neste documento.

Vertex AI Workbench

O Vertex AI Workbench é um serviço que oferece um ambiente integrado do JupyterLab (em inglês), com os seguintes recursos:

  • Implantação com um clique É possível usar um único clique para iniciar uma instância do JupyterLab pré-configurada com os frameworks de machine learning e ciência de dados mais recentes.
  • Escalonamento por demanda. Comece com uma configuração de máquina pequena (por exemplo, 4 vCPUs e 16 GB de RAM, como neste documento). Quando seus dados ficarem muito grandes para uma máquina, você poderá escalonar adicionando CPUs, RAM e GPUs.
  • Google Cloud integração. As instâncias do Vertex AI Workbench são integradas a Google Cloud serviços como o BigQuery. Essa integração facilita o processamento da ingestão de dados para o pré-processamento e a exploração.
  • Cobrança por utilização. Não há taxa mínima nem compromissos imediatos. Para mais informações, consulte Preços do Vertex AI Workbench. Você também paga pelos recursos Google Cloud usados nos notebooks, como o BigQuery e o Cloud Storage.

Os notebooks de instância do Vertex AI Workbench são executados em Deep Learning VM Images. Este documento oferece suporte à criação de uma instância do Vertex AI Workbench que tenha o R 4.3.

Trabalhar com o BigQuery usando R

O BigQuery não requer gerenciamento de infraestrutura. Portanto, você pode se concentrar na descoberta de insights significativos. Você pode analisar grandes quantidades de dados em escala e preparar conjuntos de dados para ML usando os recursos analíticos avançados do BigQuery.

Para consultar dados do BigQuery usando R, use a bigrquery, uma biblioteca de código aberto da R. No pacote bigrquery, são fornecidos os seguintes níveis de abstração sobre o BigQuery:

  • A API de nível inferior fornece wrappers finos sobre a API REST do BigQuery.
  • A interface DBI envolve a API de nível inferior e torna o trabalho com o BigQuery semelhante a qualquer outro sistema de banco de dados. Essa é a camada mais conveniente, se você quiser executar consultas SQL no BigQuery ou fazer upload de menos de 100 MB.
  • A interface dbplyr permite tratar tabelas do BigQuery como frames de dados na memória. Essa é a camada mais conveniente se você não quiser gravar SQL, mas quiser que o dbplyr grave para você.

Este documento usa a API de baixo nível do bigrquery, sem a necessidade de DBI ou dbplyr.

Objetivos

  • Crie uma instância do Vertex AI Workbench com suporte para R.
  • Consulte e analise dados do BigQuery usando a biblioteca R do bigrquery.
  • Preparar e armazenar dados para ML no Cloud Storage.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

  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. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Compute Engine API.

    Enable the API

    5.

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

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Compute Engine API.

    Enable the API

    8.

crie uma instância do Vertex AI Workbench

A primeira etapa é criar uma instância do Vertex AI Workbench que possa ser usada neste tutorial.

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

    Acessar o Workbench

  2. Na guia Instâncias, clique em Criar nova.

  3. Na janela Nova instância, clique em Criar. Para este tutorial, mantenha todos os valores padrão.

    A instância do Vertex AI Workbench pode levar de 2 a 3 minutos para iniciar. Quando estiver pronta, a instância será listada automaticamente no painel Instâncias de notebook, e um link Abrir JupyterLab será exibido ao lado do nome da instância. Se o link para abrir o JupyterLab não aparecer na lista após alguns minutos, atualize a página.

Abrir o JupyterLab e instalar o R

Para concluir o tutorial no notebook, você precisa abrir o ambiente do JupyterLab, instalar o R, clonar o repositório do GitHub vertex-ai-samples e abrir o notebook.

  1. Na lista de instâncias, clique em Abrir o JupyterLab. Isso abre o ambiente JupyterLab em outra guia do navegador.

  2. No ambiente do JupyterLab, clique em  New Launcher e, na guia Launcher, clique em Terminal.

  3. No painel do terminal, instale o R:

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

    Durante a instalação, sempre que você for solicitado a continuar, digite y. A instalação pode levar alguns minutos para ser concluída. Quando a instalação for concluída, a saída será semelhante a esta:

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

    Em que INSTANCE_NUMBER é o número exclusivo atribuído à sua instância do Vertex AI Workbench.

  4. Depois que os comandos terminarem de ser executados no terminal, atualize a página do navegador e abra a tela de início clicando em  Nova tela de início.

    A guia "Launcher" mostra opções para iniciar o R em um notebook ou no console e criar um arquivo R.

  5. Clique na guia Terminal e clone o repositório do GitHub vertex-ai-samples:

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

    Quando o comando for concluído, você verá a pasta vertex-ai-samples no painel do navegador de arquivos do ambiente do JupyterLab.

  6. No navegador de arquivos, abra vertex-ai-samples>notebooks >community>exploratory_data_analysis. O notebook eda_with_r_and_bigquery.ipynb vai aparecer.

Abrir o notebook e configurar o R

  1. No navegador de arquivos, abra o notebook eda_with_r_and_bigquery.ipynb.

    Este notebook aborda a análise de dados exploratória com R e o BigQuery. No restante deste documento, você vai trabalhar no notebook e executar o código que aparece no notebook do Jupyter.

  2. Confira a versão do R que o notebook está usando:

    version

    O campo version.string na saída vai mostrar R version 4.3.2, que você instalou na seção anterior.

  3. Verifique e instale os pacotes R necessários, se eles ainda não estiverem disponíveis na sessão atual:

    # 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. Carregue os pacotes necessários:

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

  5. Autentique bigrquery usando a autenticação fora da banda:

    bq_auth(use_oob = True)

  6. Defina o nome do projeto que você quer usar para este notebook substituindo [YOUR-PROJECT-ID] por um nome:

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

  7. Defina o nome do bucket do Cloud Storage em que os dados de saída serão armazenados substituindo [YOUR-BUCKET-NAME] por um nome globalmente exclusivo:

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

  8. Defina a altura e a largura padrão para os gráficos que serão gerados mais tarde no notebook:

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

Consultar dados do BigQuery

Nesta seção do notebook, você vai ler os resultados da execução de uma instrução SQL do BigQuery em R e analisar os dados de forma preliminar.

  1. Crie uma instrução SQL do BigQuery que extraia alguns possíveis indicadores e a variável de previsão de destino para uma amostra de viagens. A consulta a seguir filtra alguns valores outliers ou sem sentido nos campos que estão sendo lidos para análise.

    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
"

    A coluna key é um identificador de linha gerado com base nos valores concatenados das colunas trip_distance e fare_amount.

  2. Execute a consulta e extraia os mesmos dados como um tibble na memória, que é semelhante a um frame de dados.

    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. Veja os resultados recuperados:

    head(taxi_trip_data)

    O resultado é uma tabela semelhante à imagem abaixo:

    As seis primeiras linhas dos dados da viagem de táxi.

    Os resultados mostram estas colunas de dados de viagem:

    • Número inteiro trip_time_minutes
    • Número inteiro passenger_count
    • trip_distance_miles duplo
    • rate_code caractere
    • rate_type caractere
    • fare_amount duplo
    • key caractere

  4. Veja o número de linhas e tipos de dados de cada coluna:

    str(taxi_trip_data)

    A saída será assim:

    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. Veja um resumo dos dados recuperados:

    summary(taxi_trip_data)

    O resultado será assim:

    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

Visualizar dados usando ggplot2

Nesta seção do notebook, você vai usar a biblioteca ggplot2 em R para estudar algumas das variáveis do conjunto de dados de exemplo.

  1. Exiba a distribuição dos valores fare_amount usando um histograma:

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

    O gráfico resultante é semelhante ao da imagem a seguir:

    Um gráfico que mostra a distribuição dos valores das tarifas com picos nos valores 20 e 52.

  2. Exiba o relacionamento entre trip_distance e fare_amount usando um gráfico de dispersão:

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

    O gráfico resultante é semelhante ao da imagem a seguir:

    Um gráfico de dispersão da relação entre a distância da viagem e o valor da tarifa, com uma linha de suavização de regressão linear.

Processar os dados no BigQuery a partir do R

Ao trabalhar com grandes conjuntos de dados, recomendamos que você faça o maior número de análises possíveis (agregação, filtragem, mesclagem, computação de colunas etc.) no BigQuery e recupere os resultados. Executar essas tarefas em R é menos eficiente. O uso do BigQuery para análise aproveita a escalonabilidade e o desempenho do BigQuery, além de garantir que os resultados retornados possam caber na memória no R.

  1. No notebook, crie uma função que encontre o número de viagens e o valor médio da tarifa para cada valor da coluna escolhida:

    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. Invocar a função usando a coluna trip_time_minutes, que é definida usando a funcionalidade de carimbo de data/hora no 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()

    O notebook mostra dois gráficos. O primeiro gráfico mostra o número de viagens por duração em minutos. O segundo gráfico mostra a quantidade média de tarifas das viagens por tempo de viagem.

    A saída do primeiro comando ggplot é a seguinte, mostrando o número de viagens por duração (em minutos):

    Uma curva mostra que o número de viagens em minutos é maior entre 0 e 10 minutos e cai drasticamente à medida que o tempo de viagem se aproxima de 25 minutos.

    A saída do segundo comando ggplot é a seguinte, mostrando o valor médio da tarifa das viagens por tempo de viagem:

    Uma curva mostra que o valor médio da tarifa aumenta de forma constante de 0 a 50 minutos e depois aumenta a uma taxa mais lenta de 50 a 125 minutos.

    Para conferir mais exemplos de visualização com outros campos nos dados, consulte o notebook.

Salvar dados como arquivos CSV no Cloud Storage

A próxima tarefa é salvar dados extraídos do BigQuery como arquivos CSV no Cloud Storage para usá-los em outras tarefas de ML.

  1. No notebook, carregue dados de treinamento e avaliação do BigQuery em 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. Verifique o número de observações em cada conjunto de dados:

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

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

    Aproximadamente 75% do total de instâncias precisa estar em treinamento, com aproximadamente 25% das instâncias restantes em avaliação.

  3. Grave os dados em um arquivo CSV local:

    # 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. Faça upload dos arquivos CSV para o Cloud Storage unindo comandos gsutil que são transmitidos para o 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)

    Também é possível fazer upload de arquivos CSV para o Cloud Storage usando a biblioteca googleCloudStorageR, que invoca a API JSON do Cloud Storage.

Também é possível usar o bigrquery para gravar dados do R no BigQuery. A gravação no BigQuery geralmente é feita depois de concluir algum pré-processamento ou gerar resultados para serem usados em uma análise mais detalhada.

Limpar

Remova os recursos usados neste documento para evitar cobranças na sua conta Google Cloud .

Excluir o projeto

A maneira mais fácil de evitar cobranças é excluir o projeto criado. Se você planeja explorar várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

  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.

A seguir

  • Saiba mais sobre como usar os dados do BigQuery nos seus notebooks R na documentação do bigrquery.
  • Conheça as práticas recomendadas para engenharia de ML em Regras de ML.
  • Para ter uma visão geral dos princípios e recomendações de arquitetura específicos para cargas de trabalho de IA e ML em Google Cloud, consulte a perspectiva de IA e ML no Framework de arquitetura.
  • Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.

Colaboradores

Autor: Alok Pattani | Mediador de desenvolvedores

Outros colaboradores: