Ansluter Amazon Redshift och RStudio på Amazon SageMaker

Förra året tillkännagav vi den allmänna tillgängligheten av RStudio på Amazon SageMaker, branschens första fullt hanterade RStudio Workbench integrerade utvecklingsmiljö (IDE) i molnet. Du kan snabbt starta den välbekanta RStudio IDE och ringa upp och ner de underliggande beräkningsresurserna utan att avbryta ditt arbete, vilket gör det enkelt att bygga maskininlärning (ML) och analyslösningar i R i skala.

Många av RStudio på SageMaker användare är också användare av Amazon RedShift, ett helt hanterat, petabyte-skala, massivt parallellt datalager för datalagring och analytiska arbetsbelastningar. Det gör det snabbt, enkelt och kostnadseffektivt att analysera all din data med standard SQL och dina befintliga Business Intelligence (BI)-verktyg. Användare kan också interagera med data med ODBC, JDBC eller Amazon Redshift Data API.

Användningen av RStudio på SageMaker och Amazon Redshift kan vara till hjälp för att effektivt utföra analyser av stora datamängder i molnet. Att arbeta med data i molnet kan dock innebära utmaningar, såsom behovet av att ta bort organisatoriska datasilos, upprätthålla säkerhet och efterlevnad och minska komplexiteten genom att standardisera verktyg. AWS erbjuder verktyg som RStudio på SageMaker och Amazon Redshift för att hjälpa till att hantera dessa utmaningar.

I det här blogginlägget kommer vi att visa dig hur du använder båda dessa tjänster tillsammans för att effektivt utföra analyser av massiva datamängder i molnet samtidigt som vi tar itu med utmaningarna som nämns ovan. Den här bloggen fokuserar på Rstudio på Amazon SageMaker-språket, med affärsanalytiker, dataingenjörer, datavetare och alla utvecklare som använder R Language och Amazon Redshift som målgrupp.

Om du vill använda den traditionella SageMaker Studio-upplevelsen med Amazon Redshift, se Använda Amazon Redshift Data API för att interagera från en Amazon SageMaker Jupyter-anteckningsbok.

Lösningsöversikt

I bloggen idag kommer vi att utföra följande steg:

1. Kloning av provförrådet med de nödvändiga paketen.
2. Ansluter till Amazon Redshift med en säker ODBC-anslutning (ODBC är det föredragna protokollet för RStudio).
3. Köra frågor och SageMaker API-åtgärder på data inom Amazon Redshift Serverless via RStudio på SageMaker

Denna process avbildas i följande lösningsarkitektur:

Lösning genomgång

Förutsättningar

Innan du börjar, se till att du har alla krav för att ställa in RStudio på Amazon SageMaker och Amazon Redshift Serverless, som:

Vi kommer att använda en CloudFormation-stack för att skapa den nödvändiga infrastrukturen.

Notera: Om du redan har en RStudio-domän och Amazon Redshift-kluster kan du hoppa över det här steget

När du startar denna stack skapas följande resurser:

• 3 Privata undernät
• 1 Offentligt undernät
• 1 NAT-gateway
• Internet-gateway
• Amazon Redshift Serverless kluster
• SageMaker-domän med RStudio
• SageMaker RStudio användarprofil
• IAM-tjänstroll för SageMaker RStudio-domänexekvering
• IAM-tjänstroll för utförande av SageMaker RStudio användarprofil

Den här mallen är utformad för att fungera i en region (t.ex. us-east-1, us-west-2) med tre tillgänglighetszoner, RStudio på SageMaker och Amazon Redshift Serverless. Se till att din region har tillgång till dessa resurser, eller ändra mallarna i enlighet med detta.

Tryck Starta stack knappen för att skapa stacken.

1. På Skapa stack sida, välj Nästa.
2. På Ange stapeldetaljer sida, ange ett namn för din stack och lämna de återstående alternativen som standard, välj sedan Nästa.
3. På Konfigurera stackalternativ sida, lämna alternativen som standard och tryck Nästa.
4. På Granskningssida, Välj

• Jag erkänner att AWS CloudFormation kan skapa IAM-resurser med anpassade namn
• Jag erkänner att AWS CloudFormation kan kräva följande funktioner: CAPABILITY_AUTO_EXPANDkryssrutor och välj Skicka.

Mallen kommer att generera fem stackar.

När stackstatusen är CREATE_COMPLETE, navigera till Amazon Redshift Serverless-konsolen. Detta är en ny funktion som gör det superenkelt att köra analyser i molnet med hög prestanda i alla skala. Ladda bara din data och börja fråga. Det finns inget behov av att konfigurera och hantera kluster.

Anmärkningar: Mönstret som visas i den här bloggen som integrerar Amazon Redshift och RStudio på Amazon SageMaker kommer att vara detsamma oavsett Amazon Redshift-distributionsmönster (serverlöst eller traditionellt kluster).

Laddar data i Amazon Redshift Serverless

CloudFormation-skriptet skapade en databas som heter sagemaker. Låt oss fylla denna databas med tabeller för RStudio-användaren att fråga. Skapa en SQL-redigeringsflik och se till att sagemaker databas är vald. Vi kommer att använda syntetiska kreditkortstransaktionsdata att skapa tabeller i vår databas. Denna data är en del av SageMakers exempel på tabelluppsättningar s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Vi kommer att köra följande fråga i frågeredigeraren. Detta kommer att generera tre tabeller, kort, transaktioner, och användare.

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 verifiera att frågan kördes framgångsrikt genom att se tre tabeller i den vänstra rutan i frågeredigeraren.

När alla tabeller är ifyllda, navigera till SageMaker RStudio och starta en ny session med RSession-basbild på en ml.m5.xlarge-instans.

När sessionen har startat kommer vi att köra den här koden för att skapa en anslutning till vår Amazon Redshift Serverless-databas.

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)

För att se tabellerna i det syntetiska schemat måste du ge åtkomst i Amazon Redshift via frågeredigeraren.

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

RStudio Anslutningar rutan ska visa sagemaker databas med schema syntetiska och tabeller kort, transaktioner, användare.

Du kan klicka på tabellikonen bredvid tabellerna för att se 1,000 XNUMX poster.

Obs: Vi har skapat en förbyggd R Markdown-fil med alla kodblock förbyggda som kan hittas i projektet GitHub repo.

Låt oss nu använda DBI paketfunktion dbListTables() för att se befintliga tabeller.

dbListTables(con)

Använd dbGetQuery() för att skicka en SQL-fråga till 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 också använda dbplyr och dplyr paket för att köra frågor i databasen. Låt oss count() hur många transaktioner som finns i transaktionstabellen. Men först måste vi installera dessa paket.

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

Använd tbl() funktion medan du anger schemat.

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

Låt oss köra en räkning av antalet rader för varje tabell.

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

Så vi har 2,000 6,146 användare; 24,386,900 XNUMX kort; och XNUMX XNUMX XNUMX transaktioner. Vi kan också se tabellerna i konsolen.

transactions_tbl

Vi kan också se vad dplyr verb gör under huven.

show_query(transactions_tbl)

Låt oss visuellt utforska antalet transaktioner per å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 också sammanfatta data i databasen enligt följande:

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

Anta att vi vill se bedrägerier med kortinformation. Vi behöver bara sammanfoga tabellerna och sedan gruppera dem efter attributet.

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

Låt oss nu förbereda en datauppsättning som kan användas för maskininlärning. Låt oss filtrera transaktionsdata för att bara inkludera Discover-kreditkort samtidigt som vi bara behåller en undergrupp av kolumner.

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)

Och låt oss nu göra lite rengöring med följande transformationer:

• Konvertera is_fraud till binärt attribut
• Ta bort transaktionssträng från use_chip och byt namn på den till typ
• Kombinera år, månad och dag till ett dataobjekt
• Ta bort $ från beloppet och konvertera till en numerisk datatyp

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 när vi har filtrerat och rengjort vår datauppsättning är vi redo att samla in denna datauppsättning i lokalt RAM.

discover <- collect(discover_tbl)
summary(discover)

Nu har vi ett fungerande dataset för att börja skapa funktioner och anpassa modeller. Vi kommer inte att ta upp de stegen i den här bloggen, men om du vill lära dig mer om att bygga modeller i RStudio på SageMaker, hänvisa till Tillkännager Fullt Managed RStudio på Amazon SageMaker för dataforskare.

Städa

För att rensa upp eventuella resurser för att undvika återkommande kostnader, ta bort rotmallen CloudFormation. Ta också bort alla EFS-fästen som skapats och alla S3-hinkar och skapade objekt.

Slutsats

Dataanalys och modellering kan vara utmanande när man arbetar med stora datamängder i molnet. Amazon Redshift är ett populärt datalager som kan hjälpa användare att utföra dessa uppgifter. RStudio, en av de mest använda integrerade utvecklingsmiljöerna (IDE) för dataanalys, används ofta med R-språk. I det här blogginlägget visade vi hur man använder Amazon Redshift och RStudio på SageMaker tillsammans för att effektivt utföra analyser på massiva datamängder. Genom att använda RStudio på SageMaker kan användare dra fördel av SageMakers fullt hanterade infrastruktur, åtkomstkontroll, nätverk och säkerhetsfunktioner, samtidigt som de förenklar integrationen med Amazon Redshift. Om du vill lära dig mer om hur du använder dessa två verktyg tillsammans, kolla in våra andra blogginlägg och resurser. Du kan också prova att använda RStudio på SageMaker och Amazon Redshift själv och se hur de kan hjälpa dig med dina dataanalys- och modelleringsuppgifter.

Vänligen lägg till din feedback till den här bloggen, eller skapa en pull-förfrågan på GitHub.

Om författarna

Ryan Garner är en dataforskare med AWS Professional Services. Han brinner för att hjälpa AWS-kunder att använda R för att lösa sina problem med datavetenskap och maskininlärning.

Raj Pathak är en senior lösningsarkitekt och tekniker specialiserad på finansiella tjänster (försäkring, bank, kapitalmarknader) och maskininlärning. Han är specialiserad på Natural Language Processing (NLP), Large Language Models (LLM) och Machine Learning infrastruktur och driftsprojekt (MLOps).

Aditi Rajnish är en andraårig programvaruingenjörsstudent vid University of Waterloo. Hennes intressen inkluderar datorseende, naturlig språkbehandling och edge computing. Hon brinner också för samhällsbaserad STEM-uppsökande och opinionsbildning. På fritiden kan hon hittas på att klättra, spela piano eller lära sig att baka den perfekta scones.

Saiteja Pudi är en lösningsarkitekt på AWS, baserad i Dallas, Tx. Han har arbetat med AWS i mer än 3 år nu och hjälpt kunder att ta del av AWS verkliga potential genom att vara deras pålitliga rådgivare. Han kommer från en applikationsutvecklingsbakgrund, intresserad av datavetenskap och maskininlärning.