Amazon Redshift en RStudio verbinden op Amazon SageMaker

Vorig jaar kondigden we de algemene beschikbaarheid aan van RStudio op Amazon SageMaker, de eerste volledig beheerde RStudio Workbench geïntegreerde ontwikkelomgeving (IDE) in de cloud. U kunt snel de bekende RStudio IDE starten en de onderliggende rekenresources op- en afbellen zonder uw werk te onderbreken, waardoor het eenvoudig wordt om machine learning (ML) en analyseoplossingen in R op schaal te bouwen.

Veel van de gebruikers van RStudio op SageMaker zijn ook gebruikers van Amazon roodverschuiving, een volledig beheerd, massaal parallel datawarehouse op petabyte-schaal voor dataopslag en analytische workloads. Het maakt het snel, eenvoudig en kosteneffectief om al uw gegevens te analyseren met behulp van standaard SQL en uw bestaande BI-tools (Business Intelligence). Gebruikers kunnen ook communiceren met gegevens met ODBC, JDBC of de Amazon Redshift Data API.

Het gebruik van RStudio op SageMaker en Amazon Redshift kan nuttig zijn voor het efficiënt uitvoeren van analyses op grote datasets in de cloud. Het werken met gegevens in de cloud kan echter uitdagingen met zich meebrengen, zoals de noodzaak om organisatorische gegevenssilo's te verwijderen, de beveiliging en naleving te behouden en de complexiteit te verminderen door tooling te standaardiseren. AWS biedt tools zoals RStudio op SageMaker en Amazon Redshift om deze uitdagingen het hoofd te bieden.

In deze blogpost laten we u zien hoe u beide services samen kunt gebruiken om efficiënt analyses uit te voeren op enorme datasets in de cloud en tegelijkertijd de bovengenoemde uitdagingen aan te gaan. Deze blog richt zich op de Rstudio op Amazon SageMaker-taal, met bedrijfsanalisten, data-engineers, datawetenschappers en alle ontwikkelaars die de R-taal en Amazon Redshift gebruiken als doelgroep.

Als u de traditionele SageMaker Studio-ervaring met Amazon Redshift wilt gebruiken, raadpleegt u De Amazon Redshift Data API gebruiken om te communiceren vanuit een Amazon SageMaker Jupyter-notebook.

Overzicht oplossingen

In de blog van vandaag gaan we de volgende stappen uitvoeren:

1. De voorbeeldrepository klonen met de vereiste pakketten.
2. Verbinding maken met Amazon Redshift met een beveiligde ODBC-verbinding (ODBC is het voorkeursprotocol voor RStudio).
3. Query's en SageMaker API-acties uitvoeren op gegevens binnen Amazon Redshift Serverless via RStudio op SageMaker

Dit proces wordt weergegeven in de volgende oplossingsarchitectuur:

Oplossingsoverzicht

Voorwaarden

Voordat u aan de slag gaat, moet u ervoor zorgen dat u over alle vereisten beschikt voor het instellen van RStudio op Amazon SageMaker en Amazon Redshift Serverless, zoals:

We zullen een CloudFormation-stack gebruiken om de vereiste infrastructuur te genereren.

Opmerking: Als je al een RStudio-domein en Amazon Redshift-cluster hebt, kun je deze stap overslaan

Door deze stapel te starten, worden de volgende bronnen gemaakt:

• 3 privé-subnetten
• 1 openbaar subnet
• 1 NAT-gateway
• Internetgateway
• Amazon Redshift Serverloze cluster
• SageMaker-domein met RStudio
• SageMaker RStudio-gebruikersprofiel
• IAM-servicerol voor SageMaker RStudio-domeinuitvoering
• IAM-servicerol voor uitvoering van SageMaker RStudio-gebruikersprofielen

Deze sjabloon is ontworpen om te werken in een regio (bijv. us-east-1, us-west-2) met drie beschikbaarheidszones, RStudio op SageMaker en Amazon Redshift Serverless. Zorg ervoor dat uw regio toegang heeft tot die bronnen, of pas de sjablonen dienovereenkomstig aan.

Druk op de Start Stack knop om de stapel te maken.

1. Op de Maak een stapel pagina, kies Volgende.
2. Op de Geef stapeldetails op pagina, geef een naam op voor uw stapel en laat de resterende opties als standaard staan, en kies vervolgens Volgende.
3. Op de Configureer stapelopties pagina, laat de opties op standaard staan ​​en druk op Volgende.
4. Op de Beoordelingspagina, Selecteert u de

• Ik erken dat AWS CloudFormation IAM-bronnen met aangepaste namen kan maken
• Ik erken dat AWS CloudFormation mogelijk de volgende mogelijkheid vereist: CAPABILITY_AUTO_EXPANDselectievakjes en kies Verzenden.

De sjabloon genereert vijf stapels.

Zodra de stapelstatus is CREATE_COMPLETE, navigeer naar de Amazon Redshift Serverless-console. Dit is een nieuwe mogelijkheid die het supergemakkelijk maakt om analyses in de cloud uit te voeren met hoge prestaties op elke schaal. Laad gewoon uw gegevens en begin met zoeken. Het opzetten en beheren van clusters is niet nodig.

Note: Het patroon dat in deze blog wordt gedemonstreerd door Amazon Redshift en RStudio op Amazon SageMaker te integreren, zal hetzelfde zijn, ongeacht het implementatiepatroon van Amazon Redshift (serverloos of traditioneel cluster).

Gegevens laden in Amazon Redshift serverloos

Het CloudFormation-script heeft een database gemaakt met de naam sagemaker. Laten we deze database vullen met tabellen die de RStudio-gebruiker kan opvragen. Maak een SQL-editor-tabblad en zorg ervoor dat het sagemaker databank is geselecteerd. We zullen gebruik maken van de synthetische creditcardtransactiegegevens om tabellen in onze database te maken. Deze gegevens maken deel uit van de SageMaker-voorbeeldgegevenssets in tabelvorm s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

We gaan de volgende query uitvoeren in de query-editor. Dit genereert drie tabellen, kaarten, transacties, en gebruikers.

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;

U kunt valideren dat de query met succes is uitgevoerd door drie tabellen in het linkerdeelvenster van de query-editor te zien.

Zodra alle tabellen zijn gevuld, navigeert u naar SageMaker RStudio en start u een nieuwe sessie met RSession-basisimage op een ml.m5.xlarge-instantie.

Zodra de sessie is gestart, voeren we deze code uit om een ​​verbinding tot stand te brengen met onze 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)

Om de tabellen in het synthetische schema te bekijken, moet u toegang verlenen in Amazon Redshift via de query-editor.

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

De RStudio aansluitingen het deelvenster zou de sagemaker database met synthetisch schema en tabellenkaarten, transacties, gebruikers.

U kunt op het tabelpictogram naast de tabellen klikken om 1,000 records te bekijken.

Opmerking: we hebben een vooraf gebouwd R Markdown-bestand gemaakt met alle vooraf gebouwde codeblokken die te vinden zijn in het project GitHub repo.

Laten we nu de . gebruiken DBI pakket functie: dbListTables() om bestaande tabellen te bekijken.

dbListTables(con)

Gebruik dbGetQuery() om een ​​SQL-query door te geven aan de 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")

We kunnen ook de dbplyr en dplyr pakketten om query's in de database uit te voeren. Laten we count() hoeveel transacties er in de transactietabel staan. Maar eerst moeten we deze pakketten installeren.

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

Gebruik de tbl() functie terwijl u het schema opgeeft.

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

Laten we het aantal rijen voor elke tabel tellen.

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

We hebben dus 2,000 gebruikers; 6,146 kaarten; en 24,386,900 transacties. We kunnen ook de tabellen in de console bekijken.

transactions_tbl

We kunnen ook bekijken wat dplyr werkwoorden doen onder de motorkap.

show_query(transactions_tbl)

Laten we het aantal transacties per jaar visueel verkennen.

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

We kunnen de gegevens in de database ook als volgt samenvatten:

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

Stel dat we fraude willen bekijken aan de hand van kaartgegevens. We hoeven alleen maar de tabellen samen te voegen en ze vervolgens te groeperen op attribuut.

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

Laten we nu een dataset voorbereiden die kan worden gebruikt voor machine learning. Laten we de transactiegegevens filteren om alleen Discover-creditcards op te nemen en slechts een subset van kolommen te behouden.

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)

En laten we nu wat opschonen met behulp van de volgende transformaties:

• Converteren is_fraud naar binair attribuut
• Transactietekenreeks verwijderen uit use_chip en hernoem het naar type
• Combineer jaar, maand en dag in een gegevensobject
• Verwijder $ uit bedrag en converteer naar een numeriek gegevenstype

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 we onze dataset hebben gefilterd en opgeschoond, zijn we klaar om deze dataset in lokaal RAM te verzamelen.

discover <- collect(discover_tbl)
summary(discover)

Nu hebben we een werkende dataset om te beginnen met het maken van functies en passende modellen. We zullen deze stappen niet in deze blog behandelen, maar als u meer wilt weten over het bouwen van modellen in RStudio op SageMaker, raadpleeg dan Aankondiging van volledig beheerde RStudio op Amazon SageMaker voor gegevenswetenschappers.

Opruimen

Verwijder de root CloudFormation-sjabloon om resources op te schonen om terugkerende kosten te voorkomen. Verwijder ook alle gemaakte EFS-koppelingen en alle gemaakte S3-buckets en -objecten.

Conclusie

Data-analyse en -modellering kan een uitdaging zijn bij het werken met grote datasets in de cloud. Amazon Redshift is een populair datawarehouse dat gebruikers kan helpen bij het uitvoeren van deze taken. RStudio, een van de meest gebruikte geïntegreerde ontwikkelomgevingen (IDE's) voor data-analyse, wordt vaak gebruikt met R-taal. In deze blogpost hebben we laten zien hoe je Amazon Redshift en RStudio op SageMaker samen kunt gebruiken om efficiënt analyses uit te voeren op enorme datasets. Door RStudio op SageMaker te gebruiken, kunnen gebruikers profiteren van de volledig beheerde infrastructuur, toegangscontrole, netwerk- en beveiligingsmogelijkheden van SageMaker, terwijl ze ook de integratie met Amazon Redshift vereenvoudigen. Als je meer wilt weten over het samen gebruiken van deze twee tools, bekijk dan onze andere blogposts en bronnen. U kunt ook zelf RStudio op SageMaker en Amazon Redshift proberen en zien hoe zij u kunnen helpen met uw gegevensanalyse en modelleringstaken.

Voeg alstublieft uw feedback toe aan deze blog, of maak een pull request op de GitHub.

Over de auteurs

Ryan Garner is een datawetenschapper bij AWS Professional Services. Hij is gepassioneerd om AWS-klanten te helpen R te gebruiken om hun Data Science- en Machine Learning-problemen op te lossen.

Raj Pathak is een Senior Solutions Architect en technoloog, gespecialiseerd in financiële diensten (verzekeringen, banken, kapitaalmarkten) en machine learning. Hij is gespecialiseerd in Natural Language Processing (NLP), Large Language Models (LLM) en Machine Learning Infrastructure and Operations Projects (MLOps).

Aditi Rajnish is een tweedejaars student software engineering aan de Universiteit van Waterloo. Haar interesses omvatten computervisie, natuurlijke taalverwerking en edge computing. Ze is ook gepassioneerd door community-based STEM-outreach en belangenbehartiging. In haar vrije tijd kan ze rotsklimmen, piano spelen of leren hoe ze de perfecte scone moet bakken.

Saiteja Pudi is een Solutions Architect bij AWS, gevestigd in Dallas, Tx. Hij werkt nu al meer dan 3 jaar bij AWS en helpt klanten het ware potentieel van AWS te benutten door hun vertrouwde adviseur te zijn. Hij heeft een achtergrond in applicatieontwikkeling en is geïnteresseerd in datawetenschap en machine learning.