Connessione di Amazon Redshift e RStudio su Amazon SageMaker

L'anno scorso abbiamo annunciato la disponibilità generale di RStudio su Amazon SageMaker, il primo ambiente di sviluppo integrato (IDE) RStudio Workbench completamente gestito nel cloud. Puoi avviare rapidamente il familiare IDE di RStudio e chiamare le risorse di elaborazione sottostanti senza interrompere il tuo lavoro, semplificando la creazione di soluzioni di machine learning (ML) e analisi in R su larga scala.

Molti utenti di RStudio su SageMaker sono anche utenti di Amazon RedShift, un data warehouse massivamente parallelo su scala petabyte completamente gestito per l'archiviazione dei dati e i carichi di lavoro analitici. Rende veloce, semplice e conveniente analizzare tutti i tuoi dati utilizzando SQL standard e gli strumenti di business intelligence (BI) esistenti. Gli utenti possono anche interagire con i dati con ODBC, JDBC o l'API dei dati di Amazon Redshift.

L'uso di RStudio su SageMaker e Amazon Redshift può essere utile per eseguire in modo efficiente analisi su set di dati di grandi dimensioni nel cloud. Tuttavia, lavorare con i dati nel cloud può presentare sfide, come la necessità di rimuovere i silos di dati organizzativi, mantenere la sicurezza e la conformità e ridurre la complessità mediante la standardizzazione degli strumenti. AWS offre strumenti come RStudio su SageMaker e Amazon Redshift per aiutare ad affrontare queste sfide.

In questo post del blog, ti mostreremo come utilizzare entrambi questi servizi insieme per eseguire in modo efficiente analisi su enormi set di dati nel cloud affrontando le sfide sopra menzionate. Questo blog si concentra sul linguaggio Rstudio su Amazon SageMaker, con analisti aziendali, data engineer, data scientist e tutti gli sviluppatori che utilizzano il linguaggio R e Amazon Redshift come pubblico di destinazione.

Se desideri utilizzare l'esperienza tradizionale di SageMaker Studio con Amazon Redshift, fai riferimento a Utilizzo di Amazon Redshift Data API per interagire da un notebook Amazon SageMaker Jupyter.

Panoramica della soluzione

Nel blog di oggi, eseguiremo i seguenti passaggi:

1. Clonazione del repository di esempio con i pacchetti richiesti.
2. Connessione ad Amazon Redshift con una connessione ODBC sicura (ODBC è il protocollo preferito per RStudio).
3. Esecuzione di query e operazioni API SageMaker sui dati all'interno di Amazon Redshift Serverless tramite RStudio su SageMaker

Questo processo è rappresentato nella seguente architettura di soluzioni:

Soluzione dettagliata

Prerequisiti

Prima di iniziare, assicurati di disporre di tutti i requisiti per la configurazione di RStudio su Amazon SageMaker e Amazon Redshift Serverless, ad esempio:

Utilizzeremo uno stack CloudFormation per generare l'infrastruttura richiesta.

Nota: Se disponi già di un dominio RStudio e di un cluster Amazon Redshift, puoi saltare questo passaggio

L'avvio di questo stack crea le seguenti risorse:

• 3 sottoreti private
• 1 sottorete pubblica
• 1 gateway NAT
• Gateway Internet
• Cluster senza server Amazon Redshift
• Dominio SageMaker con RStudio
• Profilo utente di SageMaker RStudio
• Ruolo del servizio IAM per l'esecuzione del dominio SageMaker RStudio
• Ruolo del servizio IAM per l'esecuzione del profilo utente SageMaker RStudio

Questo modello è progettato per funzionare in una regione (ad es. us-east-1, us-west-2) con tre zone di disponibilità, RStudio su SageMaker e Amazon Redshift Serverless. Assicurati che la tua regione abbia accesso a tali risorse o modifica i modelli di conseguenza.

Premere il tasto Avvia Stack pulsante per creare lo stack.

1. Sulla Crea stack pagina, scegli Avanti.
2. Sulla Specifica i dettagli dello stack page, fornisci un nome per il tuo stack e lascia le opzioni rimanenti come predefinite, quindi scegli Avanti.
3. Sulla Configura le opzioni di stack pagina, lasciare le opzioni come predefinite e premere Avanti.
4. Sulla Pagina di revisione, Selezionare il

• Riconosco che AWS CloudFormation potrebbe creare risorse IAM con nomi personalizzati
• Riconosco che AWS CloudFormation potrebbe richiedere la seguente funzionalità: CAPABILITY_AUTO_EXPANDcaselle di controllo e scegliere Invio.

Il modello genererà cinque pile.

Una volta che lo stato dello stack è CREATE_COMPLETE, vai alla console Amazon Redshift Serverless. Questa è una nuova funzionalità che semplifica l'esecuzione di analisi nel cloud con prestazioni elevate su qualsiasi scala. Basta caricare i tuoi dati e iniziare a interrogare. Non è necessario configurare e gestire i cluster.

Note:: Il modello illustrato in questo blog che integra Amazon Redshift e RStudio su Amazon SageMaker sarà lo stesso indipendentemente dal modello di distribuzione di Amazon Redshift (cluster senza server o tradizionale).

Caricamento dei dati in Amazon Redshift Serverless

Lo script CloudFormation ha creato un database chiamato sagemaker. Popoliamo questo database con le tabelle che l'utente di RStudio può interrogare. Crea una scheda dell'editor SQL e assicurati che il file sagemaker database è selezionato. Useremo il dati sintetici sulle transazioni con carta di credito per creare tabelle nel nostro database. Questi dati fanno parte dei set di dati tabulari di esempio SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Eseguiremo la seguente query nell'editor di query. Questo genererà tre tabelle, carte, transazioni, ed utenti.

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;

Puoi verificare che la query sia stata eseguita correttamente visualizzando tre tabelle nel riquadro a sinistra dell'editor di query.

Una volta popolate tutte le tabelle, passa a SageMaker RStudio e avvia una nuova sessione con l'immagine di base RSession su un'istanza ml.m5.xlarge.

Una volta avviata la sessione, eseguiremo questo codice per creare una connessione al nostro database 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)

Per visualizzare le tabelle nello schema sintetico, dovrai concedere l'accesso in Amazon Redshift tramite l'editor di query.

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

Lo Studio R Connessioni riquadro dovrebbe mostrare il sagemaker database con schema sintetico e tabelle schede, transazioni, utenti.

È possibile fare clic sull'icona della tabella accanto alle tabelle per visualizzare 1,000 record.

Nota: abbiamo creato un file R Markdown predefinito con tutti i blocchi di codice predefiniti che possono essere trovati nel progetto Repository GitHub.

Ora usiamo il DBI funzione pacchetto dbListTables() per visualizzare le tabelle esistenti.

dbListTables(con)

Utilizzare dbGetQuery() per passare una query SQL al database.

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

Possiamo anche usare il dbplyr ed dplyr pacchetti per eseguire query nel database. Andiamo count() quante transazioni ci sono nella tabella delle transazioni. Ma prima, dobbiamo installare questi pacchetti.

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

Usa il tbl() durante la specifica dello schema.

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

Eseguiamo un conteggio del numero di righe per ogni tabella.

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

Quindi abbiamo 2,000 utenti; 6,146 carte; e 24,386,900 transazioni. Possiamo anche visualizzare le tabelle nella console.

transactions_tbl

Possiamo anche vedere cosa dplyr i verbi stanno facendo sotto il cofano.

show_query(transactions_tbl)

Esploriamo visivamente il numero di transazioni per anno.

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

Possiamo anche riassumere i dati nel database come segue:

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

Supponiamo di voler visualizzare le frodi utilizzando i dati della carta. Dobbiamo solo unire le tabelle e quindi raggrupparle in base all'attributo.

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

Ora prepariamo un set di dati che potrebbe essere utilizzato per l'apprendimento automatico. Filtriamo i dati della transazione per includere solo le carte di credito Discover mantenendo solo un sottoinsieme di colonne.

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 ora facciamo un po' di pulizia usando le seguenti trasformazioni:

• convertire is_fraud all'attributo binario
• Rimuovi la stringa di transazione da use_chip e rinominarlo in type
• Combina anno, mese e giorno in un oggetto dati
• Rimuovi $ dall'importo e converti in un tipo di dati numerico

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)

Ora che abbiamo filtrato e ripulito il nostro set di dati, siamo pronti per raccogliere questo set di dati nella RAM locale.

discover <- collect(discover_tbl)
summary(discover)

Ora disponiamo di un set di dati funzionante per iniziare a creare funzionalità e modelli di adattamento. Non tratteremo questi passaggi in questo blog, ma se vuoi saperne di più sulla creazione di modelli in RStudio su SageMaker, fai riferimento a Annuncio di RStudio completamente gestito su Amazon SageMaker per i data scientist.

Pulire

Per ripulire qualsiasi risorsa ed evitare di incorrere in costi ricorrenti, eliminare il modello CloudFormation root. Elimina anche tutti i montaggi EFS creati e tutti gli oggetti e i bucket S3 creati.

Conclusione

L'analisi e la modellazione dei dati possono essere impegnative quando si lavora con set di dati di grandi dimensioni nel cloud. Amazon Redshift è un popolare data warehouse che può aiutare gli utenti a svolgere queste attività. RStudio, uno degli ambienti di sviluppo integrato (IDE) più utilizzati per l'analisi dei dati, viene spesso utilizzato con il linguaggio R. In questo post del blog, abbiamo mostrato come utilizzare insieme Amazon Redshift e RStudio su SageMaker per eseguire in modo efficiente analisi su enormi set di dati. Utilizzando RStudio su SageMaker, gli utenti possono sfruttare l'infrastruttura completamente gestita, il controllo degli accessi, il networking e le funzionalità di sicurezza di SageMaker, semplificando al contempo l'integrazione con Amazon Redshift. Se desideri saperne di più sull'utilizzo di questi due strumenti insieme, dai un'occhiata agli altri post e risorse del nostro blog. Puoi anche provare a utilizzare RStudio su SageMaker e Amazon Redshift per te stesso e vedere come possono aiutarti con le attività di analisi e modellazione dei dati.

Aggiungi il tuo feedback a questo blog o crea una richiesta pull sul GitHub.

Informazioni sugli autori

Ryan Garner è un Data Scientist con AWS Professional Services. È appassionato di aiutare i clienti AWS a utilizzare R per risolvere i loro problemi di data science e machine learning.

Raja Pathak è un Senior Solutions Architect e Tecnologo specializzato in Servizi Finanziari (Assicurazioni, Banche, Capital Markets) e Machine Learning. È specializzato in Natural Language Processing (NLP), Large Language Models (LLM) e progetti di infrastrutture e operazioni di Machine Learning (MLOps).

Aditi Rajnish è uno studente di ingegneria del software del secondo anno presso l'Università di Waterloo. I suoi interessi includono la visione artificiale, l'elaborazione del linguaggio naturale e l'edge computing. È anche appassionata di sensibilizzazione e difesa delle STEM basate sulla comunità. Nel suo tempo libero, può essere trovata ad arrampicarsi su roccia, suonare il piano o imparare a preparare la focaccina perfetta.

Saiteja Pudi è un Solutions Architect presso AWS, con sede a Dallas, Tx. Collabora con AWS da più di 3 anni, aiutando i clienti a trarre il vero potenziale di AWS essendo il loro consulente di fiducia. Proviene da un background di sviluppo di applicazioni, interessato a Data Science e Machine Learning.