Ciencia de datos con R en Google Cloud: Análisis exploratorio de datos

Last reviewed 2024-07-22 UTC

En este documento, se muestra cómo comenzar a usar la ciencia de datos a gran escala con R enGoogle Cloud. Esto está dirigido a aquellos usuarios que tengan experiencia con R y con notebooks de Jupyter, que se sientan cómodos con SQL.

En este documento, nos enfocamos en realizar análisis de datos exploratorios mediante instancias de Vertex AI Workbench y BigQuery. Puedes encontrar el código complementario en un notebook de Jupyter en GitHub.

R es uno de los lenguajes de programación que más se usan para el modelado estadístico. Tiene una gran comunidad activa de científicos de datos y profesionales del aprendizaje automático (AA). Con más de 20,000 paquetes en el repositorio de código abierto de la Red integral de archivos R (CRAN), R tiene herramientas para todas las aplicaciones de análisis de datos estadísticos, AA y visualización. R experimentó un crecimiento continuo en las últimas dos décadas debido a la expresividad de su sintaxis y a través de la amplitud de sus datos y las bibliotecas del AA.

Como científico de datos, es posible que desees saber cómo puedes usar tu conjunto de habilidades mediante R y cómo también puedes aprovechar las ventajas de los servicios de nube completamente administrados y escalables para la ciencia de datos.

Arquitectura

En esta explicación, usarás instancias de Vertex AI Workbench como los entornos de ciencia de datos para realizar análisis de datos exploratorio (EDA). Usa R en los datos que extraigas en esta explicación de BigQuery, el almacén de datos en la nube sin servidores, altamente escalable y rentable de Google. Después de analizar y procesar los datos, los datos transformados se almacenan en Cloud Storage para otras tareas potenciales de AA. Este flujo se muestra en el siguiente diagrama:

Flujo de datos de BigQuery a Vertex AI Workbench, donde se procesa mediante R y los resultados se envían a Cloud Storage para su análisis posterior.

Datos de ejemplo

Los datos de ejemplo de este documento son el conjunto de datos de viajes en taxi de la ciudad de Nueva York de BigQuery. Este conjunto de datos públicos incluye información sobre los millones de viajes en taxi que se realizan en la ciudad de Nueva York cada año. En este documento, usarás los datos de 2022, que se encuentran en la tabla bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2022 de BigQuery.

En este documento, nos enfocamos en el EDA y en la visualización mediante R y BigQuery. Los pasos que se indican en este documento te preparan para un objetivo de la IA de predecir el importe de la tarifa de taxi (el importe antes de los impuestos, las tarifas y otros extras), según varios factores sobre el viaje. La creación real del modelo no se trata en este documento.

Vertex AI Workbench

Vertex AI Workbench es un servicio que ofrece un entorno integrado de JupyterLab, con las siguientes características:

  • Implementación con un solo clic Puedes usar un solo clic para iniciar una instancia de JupyterLab preconfigurada con los últimos frameworks de aprendizaje automático y ciencia de datos.
  • Escala según la demanda Puedes comenzar con una configuración de máquina pequeña (por ejemplo, 4 CPU virtuales y 16 GB de RAM, como en este documento) y, cuando tus datos se vuelvan demasiado grandes para una máquina, puedes escalarlos si agregas CPU, RAM y GPU.
  • Integración deGoogle Cloud . Las instancias de Vertex AI Workbench están integradas con servicios de Google Cloud , como BigQuery. Esta integración facilita el paso de la transferencia de datos al preprocesamiento y la exploración.
  • Precios de pago por uso No hay tarifas mínimas ni compromisos anticipados. Para obtener información, consulta los precios de Vertex AI Workbench. También pagas por los Google Cloud recursos que usas en los notebooks (como BigQuery y Cloud Storage).

Los notebooks de instancias de Vertex AI Workbench se ejecutan en imágenes de VM de aprendizaje profundo. En este documento, se admite la creación de una instancia de Vertex AI Workbench que tenga R 4.3.

Trabaja con BigQuery mediante R

BigQuery no requiere administración de infraestructura, por lo que puedes enfocarte en descubrir estadísticas significativas. Puedes analizar grandes cantidades de datos a gran escala y preparar conjuntos de datos para el AA con las capacidades analíticas enriquecidas del SQL de BigQuery.

Para consultar datos de BigQuery con R, puedes usar bigrquery, una biblioteca R de código abierto. El paquete de bigrquery proporciona los siguientes niveles de abstracción, además de BigQuery:

  • La API de bajo nivel proporciona wrappers delgados a través de la API de REST de BigQuery subyacente.
  • La interfaz de DBI une la API de bajo nivel y hace que trabajar con BigQuery sea similar a trabajar con cualquier otro sistema de base de datos. Esta es la capa más conveniente si deseas ejecutar consultas de SQL en BigQuery o subir menos de 100 MB.
  • La interfaz de dbplyr te permite tratar las tablas de BigQuery, como los marcos de datos en la memoria. Esta es la capa más conveniente si no quieres escribir SQL, sino que prefieres que dbplyr lo haga por ti.

En este documento, se usa la API de bajo nivel de bigrquery, sin necesidad de DBI o dbplyr.

Objetivos

  • Crea una instancia de Vertex AI Workbench que sea compatible con R.
  • Consultar y analizar datos de BigQuery con la biblioteca R de bigrquery
  • Preparar y almacenar datos para el AA en Cloud Storage.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

  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

Crea una instancia de Vertex AI Workbench

El primer paso es crear una instancia de Vertex AI Workbench que puedas usar para esta explicación.

  1. En la consola de Google Cloud, ve a la página Workbench.

    Ir a Workbench

  2. En la pestaña Instancias, haz clic en Crear nueva.

  3. En la ventana Nueva instancia, haz clic en Crear. Para esta explicación, mantén todos los valores predeterminados.

    La instancia de Vertex AI Workbench puede tardar entre 2 y 3 minutos en iniciarse. Cuando esté lista, la instancia aparecerá automáticamente en el panel Instancias de notebook, y aparecerá un vínculo Abrir JupyterLab junto al nombre de la instancia. Si el vínculo para abrir JupyterLab no aparece en la lista después de unos minutos, actualiza la página.

Abre JupyterLab e instala R

Para completar la explicación en el notebook, debes abrir el entorno de JupyterLab, instalar R, clonar el repositorio de GitHub vertex-ai-samples y, luego, abrir el notebook.

  1. En la lista de instancias, haz clic en Abrir Jupyterlab. Esto abrirá el entorno de JupyterLab en otra pestaña del navegador.

  2. En el entorno de JupyterLab, haz clic en  New Launcher y, luego, en la pestaña Launcher, haz clic en Terminal.

  3. En el panel de la terminal, instala R:

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

    Durante la instalación, cada vez que se te solicite continuar, escribe y. La instalación puede tardar unos minutos en completarse. Cuando se completa la instalación, el resultado es similar al siguiente:

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

    Donde INSTANCE_NUMBER es el número único asignado a tu instancia de Vertex AI Workbench.

  4. Una vez que los comandos terminen de ejecutarse en la terminal, actualiza la página del navegador y, luego, abre el selector haciendo clic en  Nuevo selector.

    En la pestaña Launcher, se muestran opciones para iniciar R en un notebook o en la consola, y para crear un archivo R.

  5. Haz clic en la pestaña Terminal y, luego, clona el repositorio de GitHub vertex-ai-samples:

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

    Cuando el comando finalice, verás la carpeta vertex-ai-samples en el panel del navegador de archivos del entorno de JupyterLab.

  6. En el navegador de archivos, abre vertex-ai-samples>notebooks >community>exploratory_data_analysis. Verás el notebook eda_with_r_and_bigquery.ipynb.

Abre el notebook y configura R

  1. En el navegador de archivos, abre el notebook eda_with_r_and_bigquery.ipynb.

    En este notebook, se explica el análisis de datos exploratorios con R y BigQuery. En el resto de este documento, trabajarás en el notebook y ejecutarás el código que ves dentro del notebook de Jupyter.

  2. Verifica la versión de R que usa el notebook:

    version
    

    El campo version.string en el resultado debería mostrar R version 4.3.2, que instalaste en la sección anterior.

  3. Busca y, luego, instala los paquetes de R necesarios si aún no están disponibles en la sesión actual:

    # 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. Carga los paquetes necesarios:

    # Load the required packages
    lapply(needed_packages, library, character.only = TRUE)
    
  5. Autentica bigrquery mediante la autenticación fuera de banda:

    bq_auth(use_oob = True)
    
  6. Para establecer el nombre del proyecto que deseas usar para este notebook, reemplaza [YOUR-PROJECT-ID] por un nombre:

    # Set the project ID
    PROJECT_ID <- "[YOUR-PROJECT-ID]"
    
  7. Para establecer el nombre del bucket de Cloud Storage en el que se almacenarán los datos de salida, reemplaza [YOUR-BUCKET-NAME] por un nombre único a nivel global:

    BUCKET_NAME <- "[YOUR-BUCKET-NAME]"
    
  8. Establece la altura y el ancho predeterminados para los gráficos que se generarán más adelante en el notebook:

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

Consulta datos de BigQuery

En esta sección del notebook, leerás los resultados de la ejecución de una instrucción de SQL de BigQuery en R y una vista preliminar de los datos.

  1. Crea una instrucción de SQL de BigQuery que extraiga algunos posibles predictores y la variable de predicción de destino para una muestra de viajes. La siguiente consulta filtra algunos valores atípicos o sin sentido en los campos que se leen para el análisis.

    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 columna key es un identificador de fila generado que se basa en los valores concatenados de las columnas trip_distance y fare_amount.

  2. Ejecuta la consulta y recupera los mismos datos como un tibble en la memoria, que es como un marco de datos.

    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. Visualiza los resultados recuperados:

    head(taxi_trip_data)
    

    El resultado es una tabla similar a la siguiente imagen:

    Las primeras seis filas de los datos de viajes en taxi

    Los resultados muestran las siguientes columnas de datos de viaje:

    • Número entero trip_time_minutes
    • Número entero passenger_count
    • trip_distance_miles doble
    • rate_code carácter
    • rate_type carácter
    • fare_amount doble
    • key carácter
  4. Observa la cantidad de filas y tipos de datos de cada columna:

    str(taxi_trip_data)
    

    La salida es similar a esta:

    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. Visualiza un resumen de los datos recuperados:

    summary(taxi_trip_data)
    

    El resultado es similar a este:

    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
    

Visualiza datos con ggplot2

En esta sección del notebook, usarás la biblioteca ggplot2 en R para estudiar algunas de las variables del conjunto de datos de ejemplo.

  1. Muestra la distribución de los valores de fare_amount mediante un histograma:

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

    El gráfico resultante es similar al de la siguiente imagen:

    Un gráfico que muestra la distribución de los importes de las tarifas con aumentos repentinos en los valores de 20 y 52.

  2. Muestra la relación entre trip_distance y fare_amount mediante un gráfico de dispersión:

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

    El gráfico resultante es similar al de la siguiente imagen:

    Un diagrama de dispersión de la relación entre la distancia del viaje y el importe de la tarifa, con una línea de suavización de regresión lineal.

Procesa los datos en BigQuery desde R

Cuando trabajas con grandes conjuntos de datos, te recomendamos que realices la mayor cantidad de análisis posible (agregación, filtrado, unión, columnas de procesamiento, etc.) en BigQuery y, luego, recuperes los resultados. Es menos eficiente realizar estas tareas en R. Usar BigQuery para el análisis aprovecha la escalabilidad y el rendimiento de BigQuery, y se asegura de que los resultados que se muestren puedan ajustarse a la memoria en R.

  1. En el notebook, crea una función que encuentre la cantidad de viajes y el importe promedio de la tarifa para cada valor de la columna elegida:

    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. Invoca la función con la columna trip_time_minutes que se define con la función de marca de tiempo en 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()
    

    El notebook muestra dos gráficos. En el primer gráfico, se muestra la cantidad de viajes según la duración en minutos. En el segundo gráfico, se muestra el importe promedio de la tarifa de los viajes por hora de viaje.

    El resultado del primer comando ggplot es el siguiente, que muestra la cantidad de viajes por duración (en minutos):

    Una curva muestra que la cantidad de viajes en minutos es más alta entre 0 y 10 minutos, y disminuye bruscamente a medida que el tiempo del viaje se acerca a los 25 minutos.

    El resultado del segundo comando ggplot es el siguiente, que muestra el importe promedio de la tarifa de los viajes por hora de viaje:

    Una curva muestra que el importe promedio de la tarifa aumenta de forma constante de 0 a 50 minutos y, luego, aumenta a un ritmo más lento de 50 a 125 minutos.

    Si deseas ver más ejemplos de visualización con otros campos en los datos, consulta el notebook.

Guarda datos como archivos CSV en Cloud Storage

La siguiente tarea es guardar los datos extraídos de BigQuery como archivos CSV en Cloud Storage para que puedas usarlos en más tareas del AA.

  1. En el notebook, carga los datos de entrenamiento y de evaluación de BigQuery en 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. Verifica la cantidad de observaciones en cada conjunto de datos:

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

    Alrededor del 75% del total de instancias debe estar en entrenamiento, y aproximadamente el 25% de las instancias restantes en evaluación.

  3. Escribe los datos en un archivo 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. Sube los archivos CSV a Cloud Storage mediante la unión de los comandos gsutil que se pasan 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)
    

    También puedes subir archivos CSV a Cloud Storage con la biblioteca googleCloudStorageR, que invoca la API de JSON de Cloud Storage.

También puedes usar bigrquery para volver a escribir datos de R en BigQuery. Por lo general, la escritura en BigQuery se realiza después de completar algún procesamiento previo o generar resultados que se usarán para un análisis más detallado.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que se usaron en este documento, debes quitarlos.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste. Si planeas explorar varias arquitecturas, instructivos o guías de inicio rápido, la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

  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.

¿Qué sigue?

  • Obtén más información para usar los datos de BigQuery en tus notebooks de R en la documentación de bigrquery.
  • Obtén información sobre las recomendaciones para la ingeniería del AA en las reglas del AA..
  • Para obtener una descripción general de los principios y las recomendaciones arquitectónicos específicos de las cargas de trabajo de IA y AA en Google Cloud, consulta la perspectiva de IA y AA en el Framework de arquitectura.
  • Para obtener más información sobre las arquitecturas de referencia, los diagramas y las prácticas recomendadas, explora Cloud Architecture Center.

Colaboradores

Autor: Alok Pattani | Developer Advocate

Otros colaboradores: