Koble til Amazon Redshift og RStudio på Amazon SageMaker

I fjor kunngjorde vi generell tilgjengelighet av RStudio på Amazon SageMaker, bransjens første fullt administrerte RStudio Workbench integrerte utviklingsmiljø (IDE) i skyen. Du kan raskt starte den velkjente RStudio IDE og ringe opp og ned de underliggende dataressursene uten å avbryte arbeidet ditt, noe som gjør det enkelt å bygge maskinlæring (ML) og analyseløsninger i R i stor skala.

Mange av RStudio på SageMaker brukere er også brukere av Amazon RedShift, et fullstendig administrert, petabyte-skala, massivt parallelt datavarehus for datalagring og analytiske arbeidsbelastninger. Det gjør det raskt, enkelt og kostnadseffektivt å analysere alle dataene dine ved hjelp av standard SQL og dine eksisterende BI-verktøy (business intelligence). Brukere kan også samhandle med data med ODBC, JDBC eller Amazon Redshift Data API.

Bruken av RStudio på SageMaker og Amazon Redshift kan være nyttig for å effektivt utføre analyser på store datasett i skyen. Arbeid med data i skyen kan imidlertid by på utfordringer, som behovet for å fjerne organisasjonsdatasiloer, opprettholde sikkerhet og samsvar og redusere kompleksiteten ved å standardisere verktøy. AWS tilbyr verktøy som RStudio på SageMaker og Amazon Redshift for å hjelpe til med å takle disse utfordringene.

I dette blogginnlegget vil vi vise deg hvordan du bruker begge disse tjenestene sammen for å effektivt utføre analyser på massive datasett i skyen samtidig som vi tar tak i utfordringene nevnt ovenfor. Denne bloggen fokuserer på Rstudio på Amazon SageMaker-språket, med forretningsanalytikere, dataingeniører, dataforskere og alle utviklere som bruker R Language og Amazon Redshift, som målgruppe.

Hvis du vil bruke den tradisjonelle SageMaker Studio-opplevelsen med Amazon Redshift, se Bruke Amazon Redshift Data API til å samhandle fra en Amazon SageMaker Jupyter-notisbok.

Løsningsoversikt

I bloggen i dag vil vi utføre følgende trinn:

1. Kloning av prøvelageret med de nødvendige pakkene.
2. Koble til Amazon Redshift med en sikker ODBC-tilkobling (ODBC er den foretrukne protokollen for RStudio).
3. Kjøre spørringer og SageMaker API-handlinger på data i Amazon Redshift Serverless gjennom RStudio på SageMaker

Denne prosessen er avbildet i følgende løsningsarkitektur:

Gjennomgang av løsningen

Forutsetninger

Før du begynner, sørg for at du har alle krav for å sette opp RStudio på Amazon SageMaker og Amazon Redshift Serverless, for eksempel:

Vi vil bruke en CloudFormation-stack for å generere den nødvendige infrastrukturen.

OBS: Hvis du allerede har et RStudio-domene og Amazon Redshift-klynge, kan du hoppe over dette trinnet

Å starte denne stabelen skaper følgende ressurser:

• 3 Private undernett
• 1 Offentlig subnett
• 1 NAT-gateway
• Internett-gateway
• Amazon Redshift Serverløs klynge
• SageMaker-domene med RStudio
• SageMaker RStudio brukerprofil
• IAM-tjenesterolle for SageMaker RStudio-domeneutførelse
• IAM-tjenesterolle for utføring av SageMaker RStudio brukerprofil

Denne malen er laget for å fungere i en region (f.eks. us-east-1, us-west-2) med tre tilgjengelighetssoner, RStudio på SageMaker og Amazon Redshift Serverless. Sørg for at din region har tilgang til disse ressursene, eller modifiser malene deretter.

Trykk på Start Stack knappen for å lage stabelen.

1. På Lag stabel side, velg neste.
2. På Spesifiser stakkdetaljer side, oppgi et navn for stabelen din og la de gjenværende alternativene være standard, og velg deretter neste.
3. På Konfigurer stakkalternativer side, la alternativene være standard og trykk neste.
4. På Review-siden, Velg

• Jeg erkjenner at AWS CloudFormation kan lage IAM-ressurser med tilpassede navn
• Jeg erkjenner at AWS CloudFormation kan kreve følgende funksjon: CAPABILITY_AUTO_EXPANDavmerkingsbokser og velg Send.

Malen vil generere fem stabler.

Når stabelstatusen er CREATE_COMPLETE, naviger til Amazon Redshift Serverless-konsollen. Dette er en ny funksjon som gjør det superenkelt å kjøre analyser i skyen med høy ytelse i alle skalaer. Bare last inn dataene dine og begynn å spørre. Det er ikke nødvendig å sette opp og administrere klynger.

Merknader: Mønsteret demonstrert i denne bloggen som integrerer Amazon Redshift og RStudio på Amazon SageMaker vil være det samme uavhengig av Amazon Redshift-distribusjonsmønster (serverløs eller tradisjonell klynge).

Laster data i Amazon Redshift Serverless

CloudFormation-skriptet opprettet en database kalt sagemaker. La oss fylle denne databasen med tabeller som RStudio-brukeren kan spørre etter. Opprett en SQL-redigeringsfane og vær sikker på at sagemaker databasen er valgt. Vi vil bruke syntetiske kredittkorttransaksjonsdata å lage tabeller i vår database. Disse dataene er en del av SageMaker eksempeltabelldatasett s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Vi skal utføre følgende spørring i spørringsredigeringsprogrammet. Dette vil generere tre tabeller, kort, transaksjoner, og Brukere.

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;

Du kan validere at spørringen kjørte ved å se tre tabeller i venstre rute i spørringsredigeringsprogrammet.

Når alle tabellene er fylt ut, naviger til SageMaker RStudio og start en ny økt med RSession-grunnbilde på en ml.m5.xlarge-forekomst.

Når økten er lansert, kjører vi denne koden for å opprette en tilkobling til vår Amazon Redshift Serverless-database.

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)

For å se tabellene i det syntetiske skjemaet, må du gi tilgang i Amazon Redshift via spørringsredigeringsprogrammet.

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

RStudio Tilkoblinger ruten skal vise sagemaker database med skjema syntetiske og tabeller kort, transaksjoner, brukere.

Du kan klikke på tabellikonet ved siden av tabellene for å se 1,000 poster.

Merk: Vi har laget en forhåndsbygd R Markdown-fil med alle kodeblokkene forhåndsbygde som kan finnes på prosjektet GitHub repo.

La oss nå bruke DBI pakkefunksjon dbListTables() for å se eksisterende tabeller.

dbListTables(con)

Bruk dbGetQuery() for å sende en SQL-spørring til databasen.

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

Vi kan også bruke dbplyr og dplyr pakker for å utføre spørringer i databasen. La oss count() hvor mange transaksjoner er i transaksjonstabellen. Men først må vi installere disse pakkene.

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

Bruke tbl() funksjon mens du spesifiserer skjemaet.

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

La oss kjøre en telling av antall rader for hver tabell.

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

Så vi har 2,000 brukere; 6,146 kort; og 24,386,900 XNUMX XNUMX transaksjoner. Vi kan også se tabellene i konsollen.

transactions_tbl

Vi kan også se hva dplyr verb gjør under panseret.

show_query(transactions_tbl)

La oss visuelt utforske antall transaksjoner etter år.

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

Vi kan også oppsummere data i databasen som følger:

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

Anta at vi ønsker å se svindel ved å bruke kortinformasjon. Vi trenger bare å slå sammen tabellene og deretter gruppere dem etter attributtet.

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

La oss nå utarbeide et datasett som kan brukes til maskinlæring. La oss filtrere transaksjonsdataene til bare å inkludere Discover-kredittkort mens vi bare beholder et undersett av kolonner.

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)

Og la oss nå gjøre litt rengjøring ved å bruke følgende transformasjoner:

• Konverter is_fraud til binært attributt
• Fjern transaksjonsstreng fra use_chip og gi det nytt navn til type
• Kombiner år, måned og dag til et dataobjekt
• Fjern $ fra beløpet og konverter til en numerisk datatype

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)

Nå som vi har filtrert og renset datasettet vårt, er vi klare til å samle dette datasettet inn i lokal RAM.

discover <- collect(discover_tbl)
summary(discover)

Nå har vi et fungerende datasett for å begynne å lage funksjoner og tilpasse modeller. Vi vil ikke dekke disse trinnene i denne bloggen, men hvis du vil lære mer om å bygge modeller i RStudio på SageMaker, se Kunngjør Fullt administrert RStudio på Amazon SageMaker for dataforskere.

Opprydding

For å rydde opp i ressurser for å unngå å pådra seg gjentakende kostnader, slett root CloudFormation-malen. Slett også alle opprettede EFS-fester og eventuelle S3-bøtter og objekter som er opprettet.

konklusjonen

Dataanalyse og modellering kan være utfordrende når du arbeider med store datasett i skyen. Amazon Redshift er et populært datavarehus som kan hjelpe brukere med å utføre disse oppgavene. RStudio, et av de mest brukte integrerte utviklingsmiljøene (IDE) for dataanalyse, brukes ofte med R-språk. I dette blogginnlegget viste vi hvordan du bruker Amazon Redshift og RStudio på SageMaker sammen for å effektivt utføre analyser på massive datasett. Ved å bruke RStudio på SageMaker kan brukere dra nytte av den fullstendig administrerte infrastrukturen, tilgangskontrollen, nettverks- og sikkerhetsfunksjonene til SageMaker, samtidig som de forenkler integrasjonen med Amazon Redshift. Hvis du vil lære mer om hvordan du bruker disse to verktøyene sammen, kan du sjekke ut våre andre blogginnlegg og ressurser. Du kan også prøve å bruke RStudio på SageMaker og Amazon Redshift for deg selv og se hvordan de kan hjelpe deg med dataanalyse og modelleringsoppgaver.

Legg til tilbakemelding på denne bloggen, eller opprett en pull-forespørsel på GitHub.

Om forfatterne

Ryan Garner er en dataforsker med AWS Professional Services. Han er lidenskapelig opptatt av å hjelpe AWS-kunder med å bruke R til å løse sine problemer med datavitenskap og maskinlæring.

Raj Pathak er en senior løsningsarkitekt og -teknolog som spesialiserer seg på finansielle tjenester (forsikring, bank, kapitalmarked) og maskinlæring. Han spesialiserer seg på Natural Language Processing (NLP), Large Language Models (LLM) og Machine Learning infrastruktur og driftsprosjekter (MLOps).

Aditi Rajnish er en andreårs programvareingeniørstudent ved University of Waterloo. Hennes interesser inkluderer datasyn, naturlig språkbehandling og edge computing. Hun er også lidenskapelig opptatt av samfunnsbasert STEM-oppsøking og talsmann. På fritiden kan hun bli funnet i fjellklatring, spille piano eller lære å bake den perfekte scones.

Saiteja Pudi er en løsningsarkitekt ved AWS, basert i Dallas, Tx. Han har vært hos AWS i mer enn 3 år nå, og har hjulpet kunder med å utlede det sanne potensialet til AWS ved å være deres pålitelige rådgiver. Han kommer fra applikasjonsutviklingsbakgrunn, interessert i datavitenskap og maskinlæring.