Conexión de Amazon Redshift y RStudio en Amazon SageMaker

El año pasado, anunciamos la disponibilidad general de RStudio en Amazon SageMaker, el primer entorno de desarrollo integrado (IDE) RStudio Workbench completamente administrado de la industria en la nube. Puede iniciar rápidamente el conocido IDE de RStudio y aumentar y disminuir los recursos informáticos subyacentes sin interrumpir su trabajo, lo que facilita la creación de soluciones de análisis y aprendizaje automático (ML) en R a escala.

Muchos de los usuarios de RStudio en SageMaker también son usuarios de Desplazamiento al rojo de Amazon, un almacén de datos masivamente paralelo, a escala de petabytes y totalmente administrado para el almacenamiento de datos y las cargas de trabajo analíticas. Hace que sea rápido, simple y rentable analizar todos sus datos utilizando SQL estándar y sus herramientas de inteligencia comercial (BI) existentes. Los usuarios también pueden interactuar con los datos con ODBC, JDBC o la API de datos de Amazon Redshift.

El uso de RStudio en SageMaker y Amazon Redshift puede ser útil para realizar análisis de manera eficiente en grandes conjuntos de datos en la nube. Sin embargo, trabajar con datos en la nube puede presentar desafíos, como la necesidad de eliminar los silos de datos organizacionales, mantener la seguridad y el cumplimiento, y reducir la complejidad al estandarizar las herramientas. AWS ofrece herramientas como RStudio en SageMaker y Amazon Redshift para ayudar a enfrentar estos desafíos.

En esta publicación de blog, le mostraremos cómo usar estos dos servicios juntos para realizar análisis de manera eficiente en conjuntos de datos masivos en la nube mientras aborda los desafíos mencionados anteriormente. Este blog se centra en el lenguaje Rstudio en Amazon SageMaker, con analistas de negocios, ingenieros de datos, científicos de datos y todos los desarrolladores que usan R Language y Amazon Redshift, como público objetivo.

Si desea utilizar la experiencia tradicional de SageMaker Studio con Amazon Redshift, consulte Uso de la API de datos de Amazon Redshift para interactuar desde un cuaderno Jupyter de Amazon SageMaker.

Resumen de la solución

En el blog de hoy, ejecutaremos los siguientes pasos:

1. Clonar el repositorio de muestras con los paquetes necesarios.
2. Conexión a Amazon Redshift con una conexión ODBC segura (ODBC es el protocolo preferido para RStudio).
3. Ejecución de consultas y acciones de la API de SageMaker en datos dentro de Amazon Redshift Serverless a través de RStudio en SageMaker

Este proceso se representa en la siguiente arquitectura de soluciones:

Tutorial de la solución

Requisitos previos

Antes de comenzar, asegúrese de tener todos los requisitos para configurar RStudio en Amazon SageMaker y Amazon Redshift Serverless, como:

Usaremos una pila de CloudFormation para generar la infraestructura requerida.

Nota: Si ya tiene un dominio de RStudio y un clúster de Amazon Redshift, puede omitir este paso.

Lanzar esta pila crea los siguientes recursos:

• 3 subredes privadas
• 1 subred pública
• 1 puerta de enlace NAT
• Portal de internet
• Clúster sin servidor de Amazon Redshift
• Dominio de SageMaker con RStudio
• Perfil de usuario de SageMaker RStudio
• Rol de servicio de IAM para la ejecución del dominio de SageMaker RStudio
• Rol de servicio de IAM para la ejecución del perfil de usuario de SageMaker RStudio

Esta plantilla está diseñada para funcionar en una Región (ej. us-east-1, us-west-2) con tres zonas de disponibilidad, RStudio en SageMaker y Amazon Redshift Serverless. Asegúrese de que su región tenga acceso a esos recursos o modifique las plantillas en consecuencia.

Pulse el botón Pila de lanzamiento botón para crear la pila.

1. En Crear pila página, elige Siguiente.
2. En Especificar detalles de la pila página, proporcione un nombre para su pila y deje las opciones restantes como predeterminadas, luego elija Siguiente.
3. En Configurar opciones de pila página, deje las opciones por defecto y presione Siguiente.
4. En Página de revisión, Haga click en el botón

• Reconozco que AWS CloudFormation podría crear recursos de IAM con nombres personalizados
• Reconozco que AWS CloudFormation puede requerir la siguiente capacidad: CAPABILITY_AUTO_EXPANDcasillas de verificación y elija Enviar.

La plantilla generará cinco pilas.

Una vez que el estado de la pila es CREAR_COMPLETO, vaya a la consola de Amazon Redshift Serverless. Esta es una nueva capacidad que hace que sea muy fácil ejecutar análisis en la nube con alto rendimiento a cualquier escala. Simplemente cargue sus datos y comience a consultar. No es necesario configurar ni administrar clústeres.

Note: El patrón demostrado en este blog que integra Amazon Redshift y RStudio en Amazon SageMaker será el mismo independientemente del patrón de implementación de Amazon Redshift (clúster sin servidor o tradicional).

Carga de datos en Amazon Redshift Serverless

El script de CloudFormation creó una base de datos llamada sagemaker. Completemos esta base de datos con tablas para que el usuario de RStudio las consulte. Cree una pestaña del editor de SQL y asegúrese de que sagemaker se selecciona la base de datos. estaremos usando el datos sintéticos de transacciones de tarjetas de crédito para crear tablas en nuestra base de datos. Estos datos son parte de los conjuntos de datos tabulares de muestra de SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Vamos a ejecutar la siguiente consulta en el editor de consultas. Esto generará tres tablas, tarjetas, transacciones, y usuarios.

CREATE SCHEMA IF NOT EXISTS synthetic;
DROP TABLE IF EXISTS synthetic.transactions;

CREATE TABLE synthetic.transactions(
    user_id INT,
    card_id INT,
    year INT,
    month INT,
    day INT,
    time_stamp TIME,
    amount VARCHAR(100),
    use_chip VARCHAR(100),
    merchant_name VARCHAR(100),
    merchant_city VARCHAR(100),
    merchant_state VARCHAR(100),
    merchant_zip_code VARCHAR(100),
    merchant_category_code INT,
    is_error VARCHAR(100),
    is_fraud VARCHAR(100)
);

COPY synthetic.transactions
FROM 's3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions/credit_card_transactions-ibm_v2.csv'
IAM_ROLE default
REGION 'us-east-1' 
IGNOREHEADER 1 
CSV;

DROP TABLE IF EXISTS synthetic.cards;

CREATE TABLE synthetic.cards(
    user_id INT,
    card_id INT,
    card_brand VARCHAR(100),
    card_type VARCHAR(100),
    card_number VARCHAR(100),
    expire_date VARCHAR(100),
    cvv INT,
    has_chip VARCHAR(100),
    number_cards_issued INT,
    credit_limit VARCHAR(100),
    account_open_date VARCHAR(100),
    year_pin_last_changed VARCHAR(100),
    is_card_on_dark_web VARCHAR(100)
);

COPY synthetic.cards
FROM 's3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions/sd254_cards.csv'
IAM_ROLE default
REGION 'us-east-1' 
IGNOREHEADER 1 
CSV;

DROP TABLE IF EXISTS synthetic.users;

CREATE TABLE synthetic.users(
    name VARCHAR(100),
    current_age INT,
    retirement_age INT,
    birth_year INT,
    birth_month INT,
    gender VARCHAR(100),
    address VARCHAR(100),
    apartment VARCHAR(100),
    city VARCHAR(100),
    state VARCHAR(100),
    zip_code INT,
    lattitude VARCHAR(100),
    longitude VARCHAR(100),
    per_capita_income_zip_code VARCHAR(100),
    yearly_income VARCHAR(100),
    total_debt VARCHAR(100),
    fico_score INT,
    number_credit_cards INT
);

COPY synthetic.users
FROM 's3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions/sd254_users.csv'
IAM_ROLE default
REGION 'us-east-1' 
IGNOREHEADER 1 
CSV;

Puede validar que la consulta se ejecutó correctamente al ver tres tablas en el panel izquierdo del editor de consultas.

Una vez que todas las tablas estén llenas, vaya a SageMaker RStudio e inicie una nueva sesión con la imagen base de RSession en una instancia ml.m5.xlarge.

Una vez que se inicie la sesión, ejecutaremos este código para crear una conexión a nuestra base de datos sin servidor de Amazon Redshift.

library(DBI)
library(reticulate)
boto3 <- import('boto3')
client <- boto3$client('redshift-serverless')
workgroup <- unlist(client$list_workgroups())
namespace <- unlist(client$get_namespace(namespaceName=workgroup$workgroups.namespaceName))
creds <- client$get_credentials(dbName=namespace$namespace.dbName,
                                durationSeconds=3600L,
                                workgroupName=workgroup$workgroups.workgroupName)
con <- dbConnect(odbc::odbc(),
                 Driver='redshift',
                 Server=workgroup$workgroups.endpoint.address,
                 Port='5439',
                 Database=namespace$namespace.dbName,
                 UID=creds$dbUser,
                 PWD=creds$dbPassword)

Para ver las tablas en el esquema sintético, deberá otorgar acceso en Amazon Redshift a través del editor de consultas.

GRANT ALL ON SCHEMA synthetic to "IAMR:SageMakerUserExecutionRole";
GRANT ALL ON ALL TABLES IN SCHEMA synthetic to "IAMR:SageMakerUserExecutionRole";

El RStudio Conexiones El panel debe mostrar el sagemaker base de datos con esquema sintetico y tablas de tarjetas, transacciones, usuarios.

Puede hacer clic en el icono de la tabla junto a las tablas para ver 1,000 registros.

Nota: hemos creado un archivo R Markdown preconstruido con todos los bloques de código preconstruidos que se pueden encontrar en el proyecto Repositorio GitHub.

Ahora usemos el DBI función de paquete dbListTables() para ver las tablas existentes.

dbListTables(con)

Utilice dbGetQuery() para pasar una consulta SQL a la base de datos.

dbGetQuery(con, "select * from synthetic.users limit 100")
dbGetQuery(con, "select * from synthetic.cards limit 100")
dbGetQuery(con, "select * from synthetic.transactions limit 100")

También podemos usar el dbplyr y dplyr paquetes para ejecutar consultas en la base de datos. Vamos count() cuántas transacciones hay en la tabla de transacciones. Pero primero, necesitamos instalar estos paquetes.

install.packages(c("dplyr", "dbplyr", "crayon"))

Ingrese al tbl() función al especificar el esquema.

library(dplyr)
library(dbplyr)

users_tbl <- tbl(con, in_schema("synthetic", "users"))
cards_tbl <- tbl(con, in_schema("synthetic", "cards"))
transactions_tbl <- tbl(con, in_schema("synthetic", "transactions"))

Hagamos un recuento del número de filas de cada tabla.

count(users_tbl)
count(cards_tbl)
count(transactions_tbl)

Así que tenemos 2,000 usuarios; 6,146 tarjetas; y 24,386,900 transacciones. También podemos ver las tablas en la consola.

transactions_tbl

También podemos ver lo que dplyr verbos están haciendo bajo el capó.

show_query(transactions_tbl)

Exploremos visualmente el número de transacciones por año.

transactions_by_year %
  count(year) %>%
  arrange(year) %>%
  collect()

transactions_by_year
install.packages(c('ggplot2', 'vctrs'))
library(ggplot2)
ggplot(transactions_by_year) +
  geom_col(aes(year, as.integer(n))) +
  ylab('transactions') 

También podemos resumir los datos en la base de datos de la siguiente manera:

transactions_tbl %>%
  group_by(is_fraud) %>%
  count()
transactions_tbl %>%
  group_by(merchant_category_code, is_fraud) %>%
  count() %>% 
  arrange(merchant_category_code)

Supongamos que queremos ver el fraude utilizando la información de la tarjeta. Solo necesitamos unir las tablas y luego agruparlas por el atributo.

cards_tbl %>%
  left_join(transactions_tbl, by = c("user_id", "card_id")) %>%
  group_by(card_brand, card_type, is_fraud) %>%
  count() %>% 
  arrange(card_brand)

Ahora preparemos un conjunto de datos que podría usarse para el aprendizaje automático. Filtremos los datos de la transacción para incluir solo las tarjetas de crédito Discover y solo mantengamos un subconjunto de columnas.

discover_tbl %
  filter(card_brand == 'Discover', card_type == 'Credit') %>%
  left_join(transactions_tbl, by = c("user_id", "card_id")) %>%
  select(user_id, is_fraud, merchant_category_code, use_chip, year, month, day, time_stamp, amount)

Y ahora hagamos un poco de limpieza usando las siguientes transformaciones:

• Convertir is_fraud al atributo binario
• Eliminar cadena de transacción de use_chip y cambiarle el nombre a tipo
• Combinar año, mes y día en un objeto de datos
• Eliminar $ de la cantidad y convertir a un tipo de datos numérico

discover_tbl %
  mutate(is_fraud = ifelse(is_fraud == 'Yes', 1, 0),
         type = str_remove(use_chip, 'Transaction'),
         type = str_trim(type),
         type = tolower(type),
         date = paste(year, month, day, sep = '-'),
         date = as.Date(date),
         amount = str_remove(amount, '[$]'),
         amount = as.numeric(amount)) %>%
  select(-use_chip, -year, -month, -day)

Ahora que hemos filtrado y limpiado nuestro conjunto de datos, estamos listos para recopilar este conjunto de datos en la memoria RAM local.

discover <- collect(discover_tbl)
summary(discover)

Ahora tenemos un conjunto de datos de trabajo para comenzar a crear características y modelos de ajuste. No cubriremos esos pasos en este blog, pero si desea obtener más información sobre la creación de modelos en RStudio en SageMaker, consulte Anuncio de RStudio completamente administrado en Amazon SageMaker para científicos de datos.

Limpiar

Para limpiar los recursos y evitar incurrir en costos recurrentes, elimine la plantilla raíz de CloudFormation. Elimine también todos los montajes de EFS creados y todos los depósitos y objetos de S3 creados.

Conclusión

El análisis y el modelado de datos pueden ser un desafío cuando se trabaja con grandes conjuntos de datos en la nube. Amazon Redshift es un almacén de datos popular que puede ayudar a los usuarios a realizar estas tareas. RStudio, uno de los entornos de desarrollo integrado (IDE) más utilizados para el análisis de datos, se utiliza a menudo con el lenguaje R. En esta publicación de blog, mostramos cómo usar Amazon Redshift y RStudio en SageMaker juntos para realizar análisis de manera eficiente en conjuntos de datos masivos. Al usar RStudio en SageMaker, los usuarios pueden aprovechar las capacidades de infraestructura, control de acceso, redes y seguridad completamente administradas de SageMaker, al mismo tiempo que simplifican la integración con Amazon Redshift. Si desea obtener más información sobre el uso de estas dos herramientas juntas, consulte nuestras otras publicaciones y recursos del blog. También puede intentar usar RStudio en SageMaker y Amazon Redshift y ver cómo pueden ayudarlo con sus tareas de modelado y análisis de datos.

Agregue sus comentarios a este blog o cree una solicitud de extracción en el GitHub.

Acerca de los autores

ryan garner es un científico de datos con los servicios profesionales de AWS. Le apasiona ayudar a los clientes de AWS a utilizar R para resolver sus problemas de ciencia de datos y aprendizaje automático.

Raj Pathak es Arquitecto de Soluciones Senior y Tecnólogo especializado en Servicios Financieros (Seguros, Banca, Mercados de Capitales) y Aprendizaje Automático. Se especializa en procesamiento de lenguaje natural (NLP), modelos de lenguaje grande (LLM) y proyectos de infraestructura y operaciones de aprendizaje automático (MLOps).

aditi rajnish es un estudiante de ingeniería de software de segundo año en la Universidad de Waterloo. Sus intereses incluyen la visión artificial, el procesamiento del lenguaje natural y la computación perimetral. También le apasiona el alcance y la defensa de STEM basados ​​en la comunidad. En su tiempo libre, se la puede encontrar escalando rocas, tocando el piano o aprendiendo a hornear el bollo perfecto.

Saiteja Pudi es arquitecto de soluciones en AWS, con sede en Dallas, Tx. Ha estado con AWS durante más de 3 años, ayudando a los clientes a obtener el verdadero potencial de AWS siendo su asesor de confianza. Viene de un fondo de desarrollo de aplicaciones, interesado en ciencia de datos y aprendizaje automático.