Conectarea Amazon Redshift și RStudio pe Amazon SageMaker

Anul trecut, am anunțat disponibilitatea generală a RStudio pe Amazon SageMaker, primul mediu de dezvoltare integrat (IDE) RStudio Workbench complet gestionat în cloud. Puteți lansa rapid IDE-ul familiar RStudio și puteți apela în sus și în jos resursele de calcul subiacente, fără a vă întrerupe munca, facilitând construirea de soluții de învățare automată (ML) și de analiză în R la scară.

Mulți dintre utilizatorii RStudio pe SageMaker sunt, de asemenea, utilizatori Amazon RedShift, un depozit de date complet gestionat, la scară petabyte, masiv paralel, pentru stocarea datelor și sarcinile de lucru analitice. Vă face rapid, simplu și rentabil analizarea tuturor datelor utilizând SQL standard și instrumentele existente de business intelligence (BI). De asemenea, utilizatorii pot interacționa cu datele cu ODBC, JDBC sau Amazon Redshift Data API.

Utilizarea RStudio pe SageMaker și Amazon Redshift poate fi utilă pentru efectuarea eficientă a analizei pe seturi mari de date din cloud. Cu toate acestea, lucrul cu date în cloud poate prezenta provocări, cum ar fi nevoia de a elimina silozurile de date organizaționale, de a menține securitatea și conformitatea și de a reduce complexitatea prin standardizarea instrumentelor. AWS oferă instrumente precum RStudio pe SageMaker și Amazon Redshift pentru a ajuta la abordarea acestor provocări.

În această postare pe blog, vă vom arăta cum să utilizați ambele aceste servicii împreună pentru a efectua eficient analize pe seturi masive de date din cloud, abordând în același timp provocările menționate mai sus. Acest blog se concentrează pe limbajul Rstudio pe Amazon SageMaker, cu analiști de afaceri, ingineri de date, oameni de știință de date și toți dezvoltatorii care folosesc limbajul R și Amazon Redshift, ca public țintă.

Dacă doriți să utilizați experiența tradițională SageMaker Studio cu Amazon Redshift, consultați Utilizarea Amazon Redshift Data API pentru a interacționa de pe un notebook Amazon SageMaker Jupyter.

Prezentare generală a soluțiilor

În blogul de astăzi, vom executa următorii pași:

1. Clonarea depozitului de mostre cu pachetele necesare.
2. Conectarea la Amazon Redshift cu o conexiune ODBC sigură (ODBC este protocolul preferat pentru RStudio).
3. Rularea de interogări și acțiuni API SageMaker asupra datelor din Amazon Redshift Serverless prin RStudio pe SageMaker

Acest proces este descris în următoarea arhitectură de soluții:

Rezolvare soluție

Cerințe preliminare

Înainte de a începe, asigurați-vă că aveți toate cerințele pentru configurarea RStudio pe Amazon SageMaker și Amazon Redshift Serverless, cum ar fi:

Vom folosi o stivă CloudFormation pentru a genera infrastructura necesară.

Notă: Dacă aveți deja un domeniu RStudio și un cluster Amazon Redshift, puteți sări peste acest pas

Lansarea acestei stive creează următoarele resurse:

• 3 subrețele private
• 1 subrețea publică
• 1 gateway NAT
• Gateway Internet
• Cluster fără server Amazon Redshift
• Domeniul SageMaker cu RStudio
• Profil de utilizator SageMaker RStudio
• Rol de serviciu IAM pentru execuția domeniului SageMaker RStudio
• Rol de serviciu IAM pentru execuția profilului de utilizator SageMaker RStudio

Acest șablon este conceput pentru a funcționa într-o regiune (ex. us-east-1, us-west-2) cu trei zone de disponibilitate, RStudio pe SageMaker și Amazon Redshift Serverless. Asigurați-vă că regiunea dvs. are acces la aceste resurse sau modificați șabloanele în consecință.

Apăsaţi Lansați Stack butonul pentru a crea stiva.

1. Pe Creați stivă pagina, alege Pagina Următoare →.
2. Pe Specificați detaliile stivei pagina, furnizați un nume pentru stiva dvs. și lăsați opțiunile rămase ca implicite, apoi alegeți Pagina Următoare →.
3. Pe Configurați opțiunile stivei pagina, lăsați opțiunile implicite și apăsați Pagina Următoare →.
4. Pe Pagina de revizuire, Selectați

• Recunosc că AWS CloudFormation ar putea crea resurse IAM cu nume personalizate
• Recunosc că AWS CloudFormation ar putea necesita următoarea capacitate: CAPABILITY_AUTO_EXPANDcasete de selectare și alegeți Trimite mesaj.

Șablonul va genera cinci stive.

Odată ce starea stivei este CREATE_COMPLETE, navigați la consola Amazon Redshift Serverless. Aceasta este o nouă capacitate care face foarte ușor să rulați analize în cloud cu performanțe ridicate la orice scară. Încărcați-vă datele și începeți să interogați. Nu este nevoie să configurați și să gestionați clustere.

notițe: Modelul demonstrat în acest blog care integrează Amazon Redshift și RStudio pe Amazon SageMaker va fi același, indiferent de modelul de implementare Amazon Redshift (cluster fără server sau tradițional).

Se încarcă date în Amazon Redshift Serverless

Scriptul CloudFormation a creat o bază de date numită sagemaker. Să completăm această bază de date cu tabele pe care utilizatorul RStudio să le interogheze. Creați o filă editor SQL și asigurați-vă că sagemaker baza de date este selectată. Vom folosi date sintetice ale tranzacțiilor cu cardul de credit pentru a crea tabele în baza noastră de date. Aceste date fac parte din exemplele de seturi de date tabelare SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Vom executa următoarea interogare în editorul de interogări. Aceasta va genera trei tabele, carduri, tranzacții, și utilizatorii.

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;

Puteți valida dacă interogarea a rulat cu succes, văzând trei tabele în panoul din stânga al editorului de interogări.

Odată ce toate tabelele sunt populate, navigați la SageMaker RStudio și începeți o nouă sesiune cu imaginea de bază RSession pe o instanță ml.m5.xlarge.

Odată ce sesiunea este lansată, vom rula acest cod pentru a crea o conexiune la baza noastră de date 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)

Pentru a vizualiza tabelele din schema sintetică, va trebui să acordați acces în Amazon Redshift prin intermediul editorului de interogări.

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

RStudio Conexiuni panoul ar trebui să arate sagemaker baza de date cu schema sintetica si tabele carduri, tranzactii, utilizatori.

Puteți face clic pe pictograma tabel de lângă tabele pentru a vizualiza 1,000 de înregistrări.

Notă: Am creat un fișier R Markdown pre-construit cu toate blocurile de cod pre-construite care pot fi găsite la proiect GitHub repo.

Acum să folosim DBI functia pachetului dbListTables() pentru a vizualiza tabelele existente.

dbListTables(con)

Utilizați dbGetQuery() pentru a transmite o interogare SQL la baza de date.

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

Putem folosi și dbplyr și dplyr pachete pentru a executa interogări în baza de date. hai sa count() câte tranzacții sunt în tabelul de tranzacții. Dar mai întâi trebuie să instalăm aceste pachete.

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

Folosește tbl() funcția în timp ce specificați 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"))

Să rulăm o numărătoare a numărului de rânduri pentru fiecare tabel.

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

Deci avem 2,000 de utilizatori; 6,146 de cărți; și 24,386,900 de tranzacții. Putem vizualiza și tabelele din consolă.

transactions_tbl

Putem vedea și ce dplyr verbele fac sub capotă.

show_query(transactions_tbl)

Să explorăm vizual numărul de tranzacții pe an.

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

De asemenea, putem rezuma datele din baza de date după cum urmează:

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

Să presupunem că vrem să vedem frauda folosind informațiile cardului. Trebuie doar să unim tabelele și apoi să le grupăm după atribut.

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

Acum să pregătim un set de date care ar putea fi folosit pentru învățarea automată. Să filtrăm datele tranzacției pentru a include doar cardurile de credit Discover, păstrând în același timp doar un subset de coloane.

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)

Și acum să facem niște curățări folosind următoarele transformări:

• Converti is_fraud la atributul binar
• Eliminați șirul tranzacției din use_chip și redenumiți-l pentru a tasta
• Combinați anul, luna și ziua într-un obiect de date
• Eliminați $ din sumă și convertiți într-un tip de date numerice

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)

Acum că ne-am filtrat și curățat setul de date, suntem gata să colectăm acest set de date în memoria RAM locală.

discover <- collect(discover_tbl)
summary(discover)

Acum avem un set de date de lucru pentru a începe să creăm caracteristici și modele de potrivire. Nu vom acoperi acești pași în acest blog, dar dacă doriți să aflați mai multe despre construirea modelelor în RStudio pe SageMaker, consultați Anunțăm RStudio complet gestionat pe Amazon SageMaker pentru cercetătorii de date.

A curăța

Pentru a curăța orice resurse pentru a evita costurile recurente, ștergeți șablonul CloudFormation rădăcină. De asemenea, ștergeți toate monturile EFS create și orice găleți și obiecte S3 create.

Concluzie

Analiza și modelarea datelor pot fi o provocare atunci când lucrați cu seturi mari de date în cloud. Amazon Redshift este un depozit de date popular care poate ajuta utilizatorii să îndeplinească aceste sarcini. RStudio, unul dintre cele mai utilizate medii de dezvoltare integrate (IDE) pentru analiza datelor, este adesea folosit cu limbajul R. În această postare de blog, am arătat cum să folosiți împreună Amazon Redshift și RStudio pe SageMaker pentru a efectua eficient analize pe seturi de date masive. Folosind RStudio pe SageMaker, utilizatorii pot profita de infrastructura complet gestionată, controlul accesului, rețelele și capacitățile de securitate ale SageMaker, simplificând în același timp integrarea cu Amazon Redshift. Dacă doriți să aflați mai multe despre utilizarea acestor două instrumente împreună, consultați celelalte postări și resurse de pe blog. De asemenea, puteți încerca să utilizați RStudio pe SageMaker și Amazon Redshift și să vedeți cum vă pot ajuta cu analiza datelor și sarcinile de modelare.

Vă rugăm să adăugați feedback-ul dvs. la acest blog sau să creați o cerere de extragere pe GitHub.

Despre Autori

Ryan Garner este un Data Scientist cu AWS Professional Services. Este pasionat să îi ajute pe clienții AWS să folosească R pentru a-și rezolva problemele Data Science și Machine Learning.

Raj Pathak este un arhitect senior de soluții și tehnolog specializat în servicii financiare (asigurări, banci, piețe de capital) și învățare automată. Este specializat în procesarea limbajului natural (NLP), modele de limbaj mari (LLM) și proiecte de infrastructură și operațiuni de învățare automată (MLOps).

Aditi Rajnish este student în anul II la inginerie software la Universitatea din Waterloo. Interesele ei includ viziunea computerizată, procesarea limbajului natural și edge computing. Ea este, de asemenea, pasionată de sensibilizarea și advocacy STEM la nivel comunitar. În timpul liber, ea poate fi găsită cățărând pe stâncă, cântând la pian sau învățând cum să coace scone-ul perfect.

Saiteja Pudi este arhitect de soluții la AWS, cu sediul în Dallas, Texas. El lucrează la AWS de mai bine de 3 ani, ajutând clienții să obțină adevăratul potențial al AWS, fiind consilierul lor de încredere. El provine dintr-un mediu de dezvoltare de aplicații, interesat de Data Science și Machine Learning.