Conectando Amazon Redshift e RStudio no Amazon SageMaker

No ano passado, anunciamos a disponibilidade geral de RStudio no Amazon SageMaker, o primeiro ambiente de desenvolvimento integrado (IDE) RStudio Workbench totalmente gerenciado do setor na nuvem. Você pode iniciar rapidamente o familiar RStudio IDE e discar para cima e para baixo os recursos de computação subjacentes sem interromper seu trabalho, facilitando a criação de aprendizado de máquina (ML) e soluções analíticas em R em escala.

Muitos dos usuários do RStudio no SageMaker também são usuários do Amazon RedShift, um data warehouse massivamente paralelo, em escala de petabytes, totalmente gerenciado para armazenamento de dados e cargas de trabalho analíticas. Ele torna rápido, simples e econômico analisar todos os seus dados usando SQL padrão e suas ferramentas de inteligência de negócios (BI) existentes. Os usuários também podem interagir com dados com ODBC, JDBC ou a API de dados do Amazon Redshift.

O uso do RStudio no SageMaker e no Amazon Redshift pode ser útil para realizar análises com eficiência em grandes conjuntos de dados na nuvem. No entanto, trabalhar com dados na nuvem pode apresentar desafios, como a necessidade de remover silos de dados organizacionais, manter a segurança e a conformidade e reduzir a complexidade padronizando as ferramentas. A AWS oferece ferramentas como RStudio no SageMaker e Amazon Redshift para ajudar a enfrentar esses desafios.

Nesta postagem do blog, mostraremos como usar esses dois serviços juntos para realizar análises com eficiência em conjuntos de dados massivos na nuvem enquanto abordamos os desafios mencionados acima. Este blog se concentra no Rstudio na linguagem Amazon SageMaker, com analistas de negócios, engenheiros de dados, cientistas de dados e todos os desenvolvedores que usam a linguagem R e o Amazon Redshift como público-alvo.

Se você quiser usar a experiência tradicional do SageMaker Studio com o Amazon Redshift, consulte Uso da API de dados do Amazon Redshift para interagir a partir de um notebook Jupyter do Amazon SageMaker.

Visão geral da solução

No blog de hoje, estaremos executando as seguintes etapas:

1. Clonando o repositório de amostra com os pacotes necessários.
2. Conectar-se ao Amazon Redshift com uma conexão ODBC segura (ODBC é o protocolo preferido para RStudio).
3. Executar consultas e ações de API do SageMaker em dados no Amazon Redshift Serverless por meio do RStudio no SageMaker

Este processo é representado na seguinte arquitetura de soluções:

Passo a passo da solução

Pré-requisitos

Antes de começar, certifique-se de ter todos os requisitos para configurar o RStudio no Amazon SageMaker e no Amazon Redshift Serverless, como:

Estaremos usando uma pilha CloudFormation para gerar a infraestrutura necessária.

Observação: Se você já possui um domínio RStudio e um cluster Amazon Redshift, pode pular esta etapa

Iniciar esta pilha cria os seguintes recursos:

• 3 sub-redes privadas
• 1 sub-rede pública
• 1 gateway NAT
• Gateway da Internet
• Cluster sem servidor do Amazon Redshift
• Domínio SageMaker com RStudio
• Perfil de usuário do SageMaker RStudio
• Função de serviço IAM para execução de domínio SageMaker RStudio
• Função de serviço IAM para execução de perfil de usuário do SageMaker RStudio

Este modelo foi projetado para funcionar em uma região (ex. us-east-1, us-west-2) com três zonas de disponibilidade, RStudio no SageMaker e Amazon Redshift Serverless. Certifique-se de que sua região tenha acesso a esses recursos ou modifique os modelos de acordo.

Pressione o botão Pilha de Lançamento botão para criar a pilha.

1. No Criar pilha página, escolha Próximo.
2. No Especifique os detalhes da pilha página, forneça um nome para sua pilha e deixe as opções restantes como padrão e escolha Próximo.
3. No Configurar opções de pilha página, deixe as opções como padrão e pressione Próximo.
4. No Página de revisão, Selecione o

• Eu reconheço que o AWS CloudFormation pode criar recursos IAM com nomes personalizados
• Eu reconheço que o AWS CloudFormation pode exigir o seguinte recurso: CAPABILITY_AUTO_EXPANDcaixas de seleção e escolha Submeter.

O modelo irá gerar cinco pilhas.

Uma vez que o status da pilha é CREATE_COMPLETE, navegue até o console do Amazon Redshift Serverless. Esse é um novo recurso que facilita muito a execução de análises na nuvem com alto desempenho em qualquer escala. Basta carregar seus dados e começar a consultar. Não há necessidade de configurar e gerenciar clusters.

Note: O padrão demonstrado neste blog integrando Amazon Redshift e RStudio no Amazon SageMaker será o mesmo, independentemente do padrão de implantação do Amazon Redshift (sem servidor ou cluster tradicional).

Carregando dados no Amazon Redshift Serverless

O script CloudFormation criou um banco de dados chamado sagemaker. Vamos preencher este banco de dados com tabelas para o usuário do RStudio consultar. Crie uma guia do editor SQL e certifique-se de que o sagemaker banco de dados é selecionado. Estaremos usando o dados de transação de cartão de crédito sintético para criar tabelas em nosso banco de dados. Esses dados fazem parte dos conjuntos de dados tabulares de amostra do SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Vamos executar a seguinte consulta no editor de consultas. Isso irá gerar três tabelas, cartões, transações, e usuários.

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;

Você pode validar se a consulta foi executada com êxito vendo três tabelas no painel esquerdo do editor de consultas.

Depois que todas as tabelas forem preenchidas, navegue até o SageMaker RStudio e inicie uma nova sessão com a imagem base RSession em uma instância ml.m5.xlarge.

Depois que a sessão for iniciada, executaremos esse código para criar uma conexão com nosso banco de dados Amazon Redshift Serverless.

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 visualizar as tabelas no esquema sintético, você precisará conceder acesso no Amazon Redshift por meio do editor de consultas.

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

o RStudio Coneções painel deve mostrar o sagemaker banco de dados com esquema sintético e tabelas de cartões, transações, usuários.

Você pode clicar no ícone de tabela ao lado das tabelas para visualizar 1,000 registros.

Nota: Criamos um arquivo R Markdown pré-construído com todos os blocos de código pré-construídos que podem ser encontrados no projeto GitHub repo.

Agora vamos usar o DBI função de pacote dbListTables() para ver as tabelas existentes.

dbListTables(con)

Use dbGetQuery() para passar uma consulta SQL ao banco de dados.

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

Também podemos usar o dbplyr e dplyr pacotes para executar consultas no banco de dados. vamos count() quantas transações estão na tabela de transações. Mas primeiro, precisamos instalar esses pacotes.

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

Use o tbl() função ao especificar o 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"))

Vamos executar uma contagem do número de linhas para cada tabela.

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

Portanto, temos 2,000 usuários; 6,146 cartões; e 24,386,900 transações. Também podemos visualizar as tabelas no console.

transactions_tbl

Também podemos ver o que dplyr verbos estão fazendo sob o capô.

show_query(transactions_tbl)

Vamos explorar visualmente o número de transações por ano.

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') 

Também podemos resumir os dados no banco de dados da seguinte maneira:

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

Suponha que queremos visualizar a fraude usando as informações do cartão. Só precisamos juntar as tabelas e depois agrupá-las pelo 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)

Agora vamos preparar um conjunto de dados que pode ser usado para aprendizado de máquina. Vamos filtrar os dados da transação para incluir apenas os cartões de crédito do Discover, mantendo apenas um subconjunto de colunas.

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)

E agora vamos fazer uma limpeza usando as seguintes transformações:

• Converter is_fraud para atributo binário
• Remover string de transação de use_chip e renomeie-o para digitar
• Combine ano, mês e dia em um objeto de dados
• Remova $ do valor e converta em um tipo de dados 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)

Agora que filtramos e limpamos nosso conjunto de dados, estamos prontos para coletar esse conjunto de dados na RAM local.

discover <- collect(discover_tbl)
summary(discover)

Agora temos um conjunto de dados de trabalho para começar a criar recursos e modelos de ajuste. Não abordaremos essas etapas neste blog, mas se você quiser saber mais sobre como criar modelos no RStudio no SageMaker, consulte Anunciando o RStudio totalmente gerenciado no Amazon SageMaker for Data Scientists.

Limpar

Para limpar todos os recursos para evitar custos recorrentes, exclua o modelo raiz do CloudFormation. Exclua também todas as montagens EFS criadas e quaisquer objetos e depósitos S3 criados.

Conclusão

A análise e modelagem de dados podem ser desafiadoras ao trabalhar com grandes conjuntos de dados na nuvem. O Amazon Redshift é um data warehouse popular que pode ajudar os usuários a executar essas tarefas. O RStudio, um dos ambientes de desenvolvimento integrado (IDEs) mais usados ​​para análise de dados, é frequentemente usado com a linguagem R. Nesta postagem do blog, mostramos como usar o Amazon Redshift e o RStudio no SageMaker juntos para realizar análises com eficiência em conjuntos de dados massivos. Ao usar o RStudio no SageMaker, os usuários podem aproveitar a infraestrutura totalmente gerenciada, o controle de acesso, a rede e os recursos de segurança do SageMaker, além de simplificar a integração com o Amazon Redshift. Se você quiser saber mais sobre como usar essas duas ferramentas juntas, confira nossos outros posts e recursos do blog. Você também pode tentar usar o RStudio no SageMaker e no Amazon Redshift por conta própria e ver como eles podem ajudá-lo com suas tarefas de análise e modelagem de dados.

Adicione seus comentários a este blog ou crie uma solicitação pull no GitHub.

Sobre os autores

Ryan Garner é Cientista de Dados da AWS Professional Services. Ele é apaixonado por ajudar os clientes da AWS a usar R para resolver seus problemas de Data Science e Machine Learning.

Raj Pathak é Arquiteto de Soluções Sênior e Tecnólogo especializado em Serviços Financeiros (Seguros, Bancos, Mercado de Capitais) e Machine Learning. Ele é especialista em processamento de linguagem natural (NLP), modelos de linguagem grande (LLM) e infraestrutura de aprendizado de máquina e projetos de operações (MLOps).

Aditi Rajnish é um estudante de engenharia de software do segundo ano na Universidade de Waterloo. Seus interesses incluem visão computacional, processamento de linguagem natural e computação de ponta. Ela também é apaixonada por divulgação e defesa STEM baseada na comunidade. Em seu tempo livre, ela pode ser encontrada escalando, tocando piano ou aprendendo a assar o bolinho perfeito.

Saiteja Pudi é Arquiteto de Soluções da AWS, com sede em Dallas, Tx. Ele está na AWS há mais de 3 anos, ajudando os clientes a obter o verdadeiro potencial da AWS sendo seu consultor de confiança. Ele vem de um histórico de desenvolvimento de aplicativos, interessado em Data Science e Machine Learning.