Amazon Redshifti ja RStudio ühendamine Amazon SageMakeris

Eelmisel aastal teatasime üldisest saadavusest RStudio Amazon SageMakeris, valdkonna esimene täielikult hallatav RStudio Workbenchi integreeritud arenduskeskkond (IDE) pilves. Saate kiiresti käivitada tuttava RStudio IDE ja valida selle aluseks olevaid arvutusressursse üles ja alla ilma oma tööd katkestamata, muutes masinõppe (ML) ja analüütikalahenduste loomise R-vormingus lihtsaks.

Paljud SageMakeri RStudio kasutajad on ka kasutajad Amazoni punane nihe, täielikult hallatav, petabaitide mastaabis, massiliselt paralleelne andmeladu andmete salvestamiseks ja analüütiliseks töökoormuseks. See muudab kõigi andmete analüüsimise standardse SQL-i ja olemasolevate ärianalüüsi (BI) tööriistade abil kiireks, lihtsaks ja kulutõhusaks. Kasutajad saavad andmetega suhelda ka ODBC, JDBC või Amazon Redshift Data API abil.

RStudio kasutamine SageMakeris ja Amazon Redshiftis võib olla abiks pilves olevate suurte andmekogumite tõhusaks analüüsimiseks. Pilves andmetega töötamine võib aga tekitada väljakutseid, näiteks vajadus eemaldada organisatsiooni andmehoidlad, säilitada turvalisus ja vastavus ning vähendada keerukust tööriistade standardimise kaudu. AWS pakub nende väljakutsetega toimetulemiseks selliseid tööriistu nagu RStudio saidil SageMaker ja Amazon Redshift.

Selles ajaveebipostituses näitame teile, kuidas neid mõlemaid teenuseid koos kasutada, et tõhusalt analüüsida pilves olevaid tohutuid andmekogumeid, lahendades samal ajal ülalmainitud väljakutseid. See ajaveeb keskendub Amazon SageMakeri keele Rstudiole, mille sihtrühmaks on ärianalüütikud, andmeinsenerid, andmeteadlased ja kõik arendajad, kes kasutavad R-keelt ja Amazon Redshiftit.

Kui soovite kasutada traditsioonilist SageMaker Studio kogemust Amazon Redshiftiga, vaadake Amazon Redshift Data API kasutamine Amazon SageMaker Jupyteri sülearvutiga suhtlemiseks.

Lahenduse ülevaade

Tänases ajaveebis teostame järgmisi samme:

1. Proovihoidla kloonimine vajalike pakettidega.
2. Ühenduse loomine Amazon Redshiftiga turvalise ODBC-ühendusega (ODBC on RStudio eelistatud protokoll).
3. Päringute ja SageMaker API toimingute käitamine andmetel Amazon Redshift Serverlessis SageMakeri RStudio kaudu

Seda protsessi on kujutatud järgmises lahenduste arhitektuuris:

Lahenduse ülevaade

Eeldused

Enne alustamist veenduge, et teil on kõik nõuded RStudio seadistamiseks Amazon SageMakeris ja Amazon Redshift Serverlessis, näiteks:

Kasutame vajaliku infrastruktuuri loomiseks CloudFormationi pinu.

Märge: Kui teil on juba RStudio domeen ja Amazon Redshifti klaster, võite selle sammu vahele jätta

Selle virna käivitamine loob järgmised ressursid:

• 3 Privaatsed alamvõrgud
• 1 Avalik alamvõrk
• 1 NAT-lüüs
• Interneti-lüüs
• Amazon Redshift serverita klaster
• SageMakeri domeen RStudioga
• SageMaker RStudio kasutajaprofiil
• IAM-teenuse roll SageMaker RStudio domeeni täitmiseks
• IAM-i teenuseroll SageMaker RStudio kasutajaprofiili täitmiseks

See mall on loodud töötama piirkonnas (nt. us-east-1, us-west-2), millel on kolm saadavustsooni, RStudio SageMakeris ja Amazon Redshift Serverless. Veenduge, et teie piirkonnal oleks juurdepääs neile ressurssidele, või muutke malle vastavalt.

Vajutage Käivitage Stack nuppu virna loomiseks.

1. Kohta Loo virn lehel, valige järgmine.
2. Kohta Määrake virna üksikasjad lehele, andke oma virnale nimi ja jätke ülejäänud valikud vaikevalikuks, seejärel valige järgmine.
3. Kohta Konfigureerige virna valikud lehele, jätke valikud vaikeväärtusteks ja vajutage järgmine.
4. Kohta Ülevaate lehtValige

• Tunnistan, et AWS CloudFormation võib luua kohandatud nimedega IAM-i ressursse
• Tunnistan, et AWS CloudFormation võib vajada järgmist võimalust: CAPABILITY_AUTO_EXPANDmärkeruudud ja valige LIITU.

Mall loob viis virna.

Kui virna staatus on CREATE_COMPLETE, navigeerige Amazon Redshift Serverless konsooli. See on uus võimalus, mis muudab analüütika käitamise pilves ülilihtsaks suure jõudlusega mis tahes skaalal. Lihtsalt laadige oma andmed ja alustage päringuid. Klastreid pole vaja seadistada ja hallata.

märkused: Selles ajaveebis näidatud muster, mis ühendab Amazon SageMakeris Amazon Redshift ja RStudio, on sama, olenemata Amazon Redshifti juurutusmustrist (serverita või traditsiooniline klaster).

Andmete laadimine Amazon Redshift Serverlessis

CloudFormationi skript lõi andmebaasi nimega sagemaker. Täidame selle andmebaasi tabelitega, mida RStudio kasutaja saab päringuid teha. Looge SQL-i redaktori vahekaart ja veenduge, et sagemaker andmebaas on valitud. Me hakkame kasutama sünteetilise krediitkaardi tehingute andmed et luua tabeleid meie andmebaasis. Need andmed on osa SageMakeri tabelinäidistest s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Me täidame päringuredaktoris järgmise päringu. See loob kolm tabelit, kaardid, tehingud, ja Kasutajad.

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;

Saate kontrollida päringu edukat käitamist, kui näete päringuredaktori vasakpoolses paanis kolme tabelit.

Kui kõik tabelid on täidetud, liikuge saidile SageMaker RStudio ja alustage uut seanssi RSessioni baaspildiga ml.m5.xlarge eksemplaris.

Kui seanss on käivitatud, käivitame selle koodi, et luua ühendus meie Amazon Redshift Serverless andmebaasiga.

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)

Sünteetilises skeemis olevate tabelite vaatamiseks peate päringuredaktori kaudu andma juurdepääsu rakendusele Amazon Redshift.

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

RStudio Side paan peaks näitama sagemaker andmebaas sünteetilise skeemiga ja tabelitega kaardid, tehingud, kasutajad.

1,000 kirje vaatamiseks võite klõpsata tabeli ikoonil tabelite kõrval.

Märkus: oleme loonud eelehitatud R Markdown faili kõigi eelehitatud koodiplokkidega, mis projekti juurest leiate GitHub repo.

Nüüd kasutame DBI paketi funktsioon dbListTables() olemasolevate tabelite vaatamiseks.

dbListTables(con)

SQL-päringu edastamiseks andmebaasi kasutage käsku dbGetQuery().

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

Saame kasutada ka dbplyr ja dplyr paketid päringute täitmiseks andmebaasis. Lähme count() mitu tehingut on tehingute tabelis. Kuid kõigepealt peame need paketid installima.

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

Kasuta tbl() skeemi määramisel.

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

Loendame iga tabeli ridade arvu.

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

Seega on meil 2,000 kasutajat; 6,146 kaarti; ja 24,386,900 XNUMX XNUMX tehingut. Tabeleid saame vaadata ka konsoolist.

transactions_tbl

Saame ka vaadata, mida dplyr verbid teevad kapoti all.

show_query(transactions_tbl)

Uurime visuaalselt tehingute arvu aastate lõikes.

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

Samuti saame andmebaasis olevad andmed kokku võtta järgmiselt:

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

Oletame, et tahame kaarditeavet kasutades vaadata pettusi. Peame tabelid lihtsalt ühendama ja seejärel atribuudi järgi rühmitama.

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

Nüüd valmistame ette andmestiku, mida saaks kasutada masinõppeks. Filtreerime tehinguandmeid nii, et need hõlmaksid lihtsalt Discoveri krediitkaarte, jättes alles vaid veergude alamhulga.

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)

Ja nüüd puhastame, kasutades järgmisi teisendusi:

• Muutma is_fraud binaarsele atribuudile
• Eemaldage tehingustring use_chip ja nimetage see tippimiseks ümber
• Ühendage aasta, kuu ja päev andmeobjektiks
• Eemaldage summast $ ja teisendage numbriliseks andmetüübiks

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üüd, kui oleme oma andmestiku filtreerinud ja puhastanud, oleme valmis koguma selle andmestiku kohalikku RAM-i.

discover <- collect(discover_tbl)
summary(discover)

Nüüd on meil toimiv andmestik, et alustada funktsioonide ja mudelite sobitamisega. Me ei käsitle neid samme selles ajaveebis, kuid kui soovite SageMakeris RStudio mudelite ehitamise kohta lisateavet, vaadake Täielikult hallatava RStudio väljakuulutamine andmeteadlaste jaoks mõeldud Amazon SageMakeris.

Korista ära

Ressursside puhastamiseks, et vältida korduvaid kulusid, kustutage CloudFormationi juurmall. Kustutage ka kõik loodud EFS-i kinnitused ja kõik loodud S3-salved ja objektid.

Järeldus

Andmete analüüs ja modelleerimine võivad pilves suurte andmekogumitega töötamisel olla keerulised. Amazon Redshift on populaarne andmeladu, mis aitab kasutajatel neid ülesandeid täita. R-keelega kasutatakse sageli RStudiot, mis on üks enim kasutatavaid integreeritud arenduskeskkondi (IDE) andmete analüüsimiseks. Selles ajaveebi postituses näitasime, kuidas kasutada Amazon Redshifti ja RStudiot SageMakeris koos, et massiivseid andmekogumeid tõhusalt analüüsida. Kasutades RStudiot SageMakeris, saavad kasutajad ära kasutada SageMakeri täielikult hallatavat infrastruktuuri, juurdepääsukontrolli, võrgundus- ja turbevõimalusi, lihtsustades samal ajal integreerimist Amazon Redshiftiga. Kui soovite nende kahe tööriista koos kasutamise kohta lisateavet, vaadake meie teisi ajaveebi postitusi ja ressursse. Võite ka ise proovida RStudio kasutamist SageMakeris ja Amazon Redshiftis ning näha, kuidas need saavad teid andmete analüüsi- ja modelleerimisülesannete täitmisel aidata.

Palun lisage oma tagasiside sellele blogile või looge tõmbetaotlus GitHub.

Autoritest

Ryan Garner on AWS-i professionaalsete teenustega andmeteadlane. Ta soovib kirglikult aidata AWS-i klientidel kasutada R-i oma andmeteaduse ja masinõppe probleemide lahendamiseks.

Raj Pathak on vanemlahenduste arhitekt ja tehnoloog, kes on spetsialiseerunud finantsteenustele (kindlustus, pangandus, kapitaliturud) ja masinõppele. Ta on spetsialiseerunud loomuliku keele töötlemisele (NLP), suurtele keelemudelitele (LLM) ning masinõppe infrastruktuuri ja operatsiooniprojektidele (MLOps).

Aditi Rajnish on Waterloo ülikooli teise aasta tarkvaratehnika üliõpilane. Tema huvide hulka kuuluvad arvutinägemine, loomuliku keele töötlemine ja äärearvutus. Ta on kirglik ka kogukonnapõhise STEM-i teavitamise ja propageerimise vastu. Vabal ajal võib teda leida kaljuronimisest, klaverit mängimast või ideaalse skooni küpsetamise õppimisest.

Saiteja Pudi on lahenduste arhitekt AWSis, mis asub Dallases, Texases. Ta on olnud AWS-is juba üle 3 aasta, aidates klientidel saada AWS-i tõelist potentsiaali, olles nende usaldusväärne nõustaja. Ta on pärit rakenduste arendamise taustast, olles huvitatud andmeteadusest ja masinõppest.