Tilslutning af Amazon Redshift og RStudio på Amazon SageMaker

Sidste år annoncerede vi den generelle tilgængelighed af RStudio på Amazon SageMaker, branchens første fuldt administrerede RStudio Workbench integrerede udviklingsmiljø (IDE) i skyen. Du kan hurtigt starte den velkendte RStudio IDE og ringe op og ned for de underliggende computerressourcer uden at afbryde dit arbejde, hvilket gør det nemt at bygge maskinlæring (ML) og analyseløsninger i R i skala.

Mange af RStudio på SageMaker brugere er også brugere af Amazon rødforskydning, et fuldt administreret, petabyte-skala, massivt parallelt datavarehus til datalagring og analytiske arbejdsbelastninger. Det gør det hurtigt, enkelt og omkostningseffektivt at analysere alle dine data ved hjælp af standard SQL og dine eksisterende Business Intelligence (BI) værktøjer. Brugere kan også interagere med data med ODBC, JDBC eller Amazon Redshift Data API.

Brugen af ​​RStudio på SageMaker og Amazon Redshift kan være nyttig til effektivt at udføre analyser på store datasæt i skyen. Arbejdet med data i skyen kan dog give udfordringer, såsom behovet for at fjerne organisatoriske datasiloer, opretholde sikkerhed og compliance og reducere kompleksiteten ved at standardisere værktøjer. AWS tilbyder værktøjer såsom RStudio på SageMaker og Amazon Redshift til at hjælpe med at tackle disse udfordringer.

I dette blogindlæg vil vi vise dig, hvordan du bruger begge disse tjenester sammen til effektivt at udføre analyser på massive datasæt i skyen, mens vi løser de ovenfor nævnte udfordringer. Denne blog fokuserer på Rstudio på Amazon SageMaker-sproget med forretningsanalytikere, dataingeniører, dataforskere og alle udviklere, der bruger R Language og Amazon Redshift, som målgruppe.

Hvis du gerne vil bruge den traditionelle SageMaker Studio-oplevelse med Amazon Redshift, så se Brug af Amazon Redshift Data API til at interagere fra en Amazon SageMaker Jupyter-notebook.

Løsningsoversigt

I bloggen i dag vil vi udføre følgende trin:

1. Kloning af prøvelageret med de nødvendige pakker.
2. Opretter forbindelse til Amazon Redshift med en sikker ODBC-forbindelse (ODBC er den foretrukne protokol til RStudio).
3. Kørsel af forespørgsler og SageMaker API-handlinger på data i Amazon Redshift Serverless gennem RStudio på SageMaker

Denne proces er afbildet i følgende løsningsarkitektur:

Gennemgang af løsning

Forudsætninger

Før du går i gang, skal du sikre dig, at du har alle krav til opsætning af RStudio på Amazon SageMaker og Amazon Redshift Serverless, såsom:

Vi vil bruge en CloudFormation-stak til at generere den nødvendige infrastruktur.

Bemærk: Hvis du allerede har et RStudio-domæne og Amazon Redshift-klynge, kan du springe dette trin over

Ved at starte denne stak oprettes følgende ressourcer:

• 3 Private undernet
• 1 Offentligt undernet
• 1 NAT-gateway
• Internet-gateway
• Amazon Redshift Serverløs klynge
• SageMaker domæne med RStudio
• SageMaker RStudio brugerprofil
• IAM-servicerolle for SageMaker RStudio-domænekørsel
• IAM-servicerolle for udførelse af SageMaker RStudio-brugerprofil

Denne skabelon er designet til at fungere i en region (f. us-east-1, us-west-2) med tre tilgængelighedszoner, RStudio på SageMaker og Amazon Redshift Serverless. Sørg for, at din region har adgang til disse ressourcer, eller modificer skabelonerne i overensstemmelse hermed.

Tryk Start Stack knappen for at oprette stakken.

1. På Opret stak side, vælg Næste.
2. På Angiv stakdetaljer side, angiv et navn til din stak og lad de resterende muligheder være standard, og vælg derefter Næste.
3. På Konfigurer stakindstillinger side, lad indstillingerne være standard og tryk på Næste.
4. På Review side, Skal du vælge

• Jeg anerkender, at AWS CloudFormation kan skabe IAM-ressourcer med brugerdefinerede navne
• Jeg anerkender, at AWS CloudFormation muligvis kræver følgende kapacitet: CAPABILITY_AUTO_EXPANDafkrydsningsfelter og vælg Indsend.

Skabelonen genererer fem stakke.

Når stak status er CREATE_COMPLETE, naviger til Amazon Redshift Serverless-konsollen. Dette er en ny funktion, der gør det super nemt at køre analyser i skyen med høj ydeevne i enhver skala. Bare indlæs dine data og begynd at forespørge. Der er ingen grund til at opsætte og administrere klynger.

Bemærk: Mønsteret, der vises i denne blog, der integrerer Amazon Redshift og RStudio på Amazon SageMaker, vil være det samme uanset Amazon Redshift-implementeringsmønster (serverløs eller traditionel klynge).

Indlæser data i Amazon Redshift Serverless

CloudFormation-scriptet oprettede en database kaldet sagemaker. Lad os udfylde denne database med tabeller, som RStudio-brugeren kan forespørge på. Opret en SQL-editor-fane, og vær sikker på, at sagemaker database er valgt. Vi vil bruge syntetiske kreditkorttransaktionsdata at oprette tabeller i vores database. Disse data er en del af SageMaker eksempeltabeldatasæt s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Vi skal udføre følgende forespørgsel i forespørgselseditoren. Dette vil generere tre tabeller, kort, transaktioner, , brugere.

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 forespørgslen kørte med succes, ved at se tre tabeller i venstre rude i forespørgselseditoren.

Når alle tabellerne er udfyldt, skal du navigere til SageMaker RStudio og starte en ny session med RSession-basebillede på en ml.m5.xlarge-instans.

Når sessionen er startet, kører vi denne kode for at oprette en forbindelse til vores 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 at se tabellerne i det syntetiske skema skal du give adgang i Amazon Redshift via forespørgselseditoren.

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

RStudio Tilslutninger ruden skal vise sagemaker database med skema syntetiske og tabeller kort, transaktioner, brugere.

Du kan klikke på tabelikonet ved siden af ​​tabellerne for at se 1,000 poster.

Bemærk: Vi har oprettet en forudbygget R Markdown-fil med alle de forudbyggede kodeblokke, der kan findes på projektet GitHub repo.

Lad os nu bruge DBI pakkefunktion dbListTables() for at se eksisterende tabeller.

dbListTables(con)

Brug dbGetQuery() til at sende en SQL-forespørgsel 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å bruge dbplyr , dplyr pakker til at udføre forespørgsler i databasen. Lad os count() hvor mange transaktioner der er i transaktionstabellen. Men først skal vi installere disse pakker.

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

Brug tbl() funktion, mens du angiver skemaet.

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

Lad os køre en optælling af antallet af rækker for hver tabel.

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

Så vi har 2,000 brugere; 6,146 kort; og 24,386,900 transaktioner. Vi kan også se bordene i konsollen.

transactions_tbl

Vi kan også se hvad dplyr verber gør under hætten.

show_query(transactions_tbl)

Lad os visuelt udforske antallet af transaktioner efter å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å opsummere 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)

Antag, at vi ønsker at se svindel ved hjælp af kortoplysninger. Vi skal blot slutte os til tabellerne og derefter gruppere dem efter attributten.

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

Lad os nu forberede et datasæt, der kan bruges til maskinlæring. Lad os filtrere transaktionsdataene til kun at inkludere Discover-kreditkort, mens vi kun beholder et undersæt af 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 lad os nu gøre noget rent ved hjælp af følgende transformationer:

• Konverter is_fraud til binær attribut
• Fjern transaktionsstreng fra use_chip og omdøb den til type
• Kombiner år, måned og dag til et dataobjekt
• Fjern $ fra beløb 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)

Nu hvor vi har filtreret og renset vores datasæt, er vi klar til at samle dette datasæt i lokal RAM.

discover <- collect(discover_tbl)
summary(discover)

Nu har vi et fungerende datasæt til at begynde at skabe funktioner og tilpasse modeller. Vi vil ikke dække disse trin i denne blog, men hvis du vil lære mere om at bygge modeller i RStudio på SageMaker, henvises til Annoncerer fuldt administreret RStudio på Amazon SageMaker for dataforskere.

Ryd op

For at rydde op i ressourcer for at undgå at pådrage sig tilbagevendende omkostninger, skal du slette rodskabelonen CloudFormation. Slet også alle oprettede EFS-monteringer og alle oprettede S3-bøtter og objekter.

Konklusion

Dataanalyse og modellering kan være udfordrende, når du arbejder med store datasæt i skyen. Amazon Redshift er et populært datavarehus, der kan hjælpe brugere med at udføre disse opgaver. RStudio, et af de mest udbredte integrerede udviklingsmiljøer (IDE'er) til dataanalyse, bruges ofte sammen med R-sprog. I dette blogindlæg viste vi, hvordan man bruger Amazon Redshift og RStudio på SageMaker sammen til effektivt at udføre analyser på massive datasæt. Ved at bruge RStudio på SageMaker kan brugerne drage fordel af den fuldt administrerede infrastruktur, adgangskontrol, netværk og sikkerhedsfunktioner i SageMaker, samtidig med at integrationen med Amazon Redshift forenkles. Hvis du gerne vil lære mere om at bruge disse to værktøjer sammen, så tjek vores andre blogindlæg og ressourcer. Du kan også prøve at bruge RStudio på SageMaker og Amazon Redshift for dig selv og se, hvordan de kan hjælpe dig med dine dataanalyse- og modelleringsopgaver.

Tilføj venligst din feedback til denne blog, eller opret en pull-anmodning på GitHub.

Om forfatterne

Ryan Garner er dataforsker med AWS Professional Services. Han brænder for at hjælpe AWS-kunder med at bruge R til at løse deres problemer med datavidenskab og maskinlæring.

Raj Pathak er en senior løsningsarkitekt og -teknolog med speciale i finansielle tjenesteydelser (forsikring, bank, kapitalmarkeder) og maskinlæring. Han har specialiseret sig i Natural Language Processing (NLP), Large Language Models (LLM) og Machine Learning infrastruktur og driftsprojekter (MLOps).

Aditi Rajnish er en andenårig softwareingeniørstuderende ved University of Waterloo. Hendes interesser omfatter computersyn, naturlig sprogbehandling og edge computing. Hun brænder også for samfundsbaseret STEM-opsøgende og fortalervirksomhed. I sin fritid kan hun blive fundet ved at klatre, spille klaver eller lære at bage den perfekte scones.

Saiteja Pudi er Solutions Architect hos AWS, baseret i Dallas, Tx. Han har været hos AWS i mere end 3 år nu og har hjulpet kunder med at udlede det sande potentiale i AWS ved at være deres betroede rådgiver. Han kommer fra en applikationsudviklingsbaggrund, interesseret i Data Science og Machine Learning.