Łączenie Amazon Redshift i RStudio na Amazon SageMaker

W zeszłym roku ogłosiliśmy powszechną dostępność RStudio na Amazon SageMaker, pierwsze w branży w pełni zarządzane zintegrowane środowisko programistyczne (IDE) RStudio Workbench w chmurze. Możesz szybko uruchomić znane środowisko IDE RStudio i przełączać w górę i w dół bazowe zasoby obliczeniowe bez przerywania pracy, co ułatwia tworzenie rozwiązań uczenia maszynowego (ML) i analiz w R na dużą skalę.

Wielu użytkowników RStudio w SageMaker jest również użytkownikami Amazonka Przesunięcie ku czerwieni, w pełni zarządzany, masowo równoległy magazyn danych w skali petabajtów do przechowywania danych i obciążeń analitycznych. Sprawia, że ​​analiza wszystkich danych jest szybka, prosta i ekonomiczna przy użyciu standardowego języka SQL i istniejących narzędzi analizy biznesowej (BI). Użytkownicy mogą również wchodzić w interakcje z danymi za pomocą ODBC, JDBC lub Amazon Redshift Data API.

Wykorzystanie RStudio na SageMaker i Amazon Redshift może być pomocne w efektywnym przeprowadzaniu analiz na dużych zbiorach danych w chmurze. Jednak praca z danymi w chmurze może wiązać się z wyzwaniami, takimi jak konieczność usunięcia organizacyjnych silosów danych, utrzymania bezpieczeństwa i zgodności oraz zmniejszenia złożoności poprzez standaryzację narzędzi. AWS oferuje narzędzia, takie jak RStudio w SageMaker i Amazon Redshift, które pomagają stawić czoła tym wyzwaniom.

W tym poście na blogu pokażemy, jak korzystać z obu tych usług razem, aby skutecznie przeprowadzać analizy ogromnych zbiorów danych w chmurze, jednocześnie rozwiązując wspomniane wyżej wyzwania. Ten blog koncentruje się na Rstudio w języku Amazon SageMaker, z analitykami biznesowymi, inżynierami danych, naukowcami danych i wszystkimi programistami, którzy używają języka R i Amazon Redshift jako odbiorców docelowych.

Jeśli chcesz korzystać z tradycyjnego doświadczenia SageMaker Studio z Amazon Redshift, zobacz Korzystanie z interfejsu Amazon Redshift Data API do interakcji z notebooka Amazon SageMaker Jupyter.

Omówienie rozwiązania

Na dzisiejszym blogu wykonamy następujące kroki:

1. Klonowanie przykładowego repozytorium z wymaganymi pakietami.
2. Łączenie z Amazon Redshift za pomocą bezpiecznego połączenia ODBC (ODBC jest preferowanym protokołem dla RStudio).
3. Uruchamianie zapytań i akcji API SageMaker na danych w Amazon Redshift Serverless poprzez RStudio na SageMaker

Proces ten jest przedstawiony w następującej architekturze rozwiązań:

Przewodnik po rozwiązaniu

Wymagania wstępne

Zanim zaczniesz, upewnij się, że spełniasz wszystkie wymagania dotyczące konfigurowania RStudio na Amazon SageMaker i Amazon Redshift Serverless, takie jak:

Będziemy używać stosu CloudFormation do generowania wymaganej infrastruktury.

Uwaga: Jeśli masz już domenę RStudio i klaster Amazon Redshift, możesz pominąć ten krok

Uruchomienie tego stosu tworzy następujące zasoby:

• 3 prywatne podsieci
• 1 podsieć publiczna
• 1 brama NAT
• Brama internetowa
• Bezserwerowy klaster Amazon Redshift
• Domena SageMaker z RStudio
• Profil użytkownika SageMaker RStudio
• Rola usługi IAM dla wykonania domeny SageMaker RStudio
• Rola usługi IAM dla wykonania profilu użytkownika SageMaker RStudio

Ten szablon jest przeznaczony do pracy w regionie (np. us-east-1, us-west-2) z trzema strefami dostępności, RStudio w SageMaker i Amazon Redshift Serverless. Upewnij się, że Twój region ma dostęp do tych zasobów lub odpowiednio zmodyfikuj szablony.

Naciśnij Uruchom stos przycisk, aby utworzyć stos.

1. Na Utwórz stos wybierz stronę Następna.
2. Na Określ szczegóły stosu stronę, podaj nazwę swojego stosu i pozostaw pozostałe opcje jako domyślne, a następnie wybierz Następna.
3. Na Skonfiguruj opcje stosu stronę, pozostaw opcje jako domyślne i naciśnij Następna.
4. Na Strona recenzjiWybierz

• Potwierdzam, że AWS CloudFormation może tworzyć zasoby IAM o niestandardowych nazwach
• Przyjmuję do wiadomości, że AWS CloudFormation może wymagać następującej możliwości: CAPABILITY_AUTO_EXPANDpola wyboru i wybierz Prześlij.

Szablon wygeneruje pięć stosów.

Gdy stan stosu jest CREATE_COMPLETE, przejdź do konsoli Amazon Redshift Serverless. Jest to nowa funkcja, która bardzo ułatwia przeprowadzanie analiz w chmurze z wysoką wydajnością w dowolnej skali. Po prostu załaduj swoje dane i zacznij wysyłać zapytania. Nie ma potrzeby konfigurowania klastrów i zarządzania nimi.

Note: Wzorzec pokazany na tym blogu integrujący Amazon Redshift i RStudio w Amazon SageMaker będzie taki sam niezależnie od wzorca wdrażania Amazon Redshift (klaster bezserwerowy lub tradycyjny).

Ładowanie danych w Amazon Redshift Serverless

Skrypt CloudFormation utworzył bazę danych o nazwie sagemaker. Wypełnijmy tę bazę danych tabelami, aby użytkownik RStudio mógł wykonać zapytanie. Utwórz kartę edytora SQL i upewnij się, że sagemaker wybrana jest baza danych. Będziemy korzystać z syntetyczne dane transakcji kartą kredytową do tworzenia tabel w naszej bazie danych. Te dane są częścią przykładowych tabelarycznych zestawów danych SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Zamierzamy wykonać następujące zapytanie w edytorze zapytań. Spowoduje to wygenerowanie trzech tabel, karty, transakcje, i Użytkownicy.

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;

Możesz sprawdzić, czy zapytanie zostało wykonane pomyślnie, wyświetlając trzy tabele w lewym okienku edytora zapytań.

Po wypełnieniu wszystkich tabel przejdź do SageMaker RStudio i rozpocznij nową sesję z obrazem podstawowym RSession na instancji ml.m5.xlarge.

Po uruchomieniu sesji uruchomimy ten kod, aby utworzyć połączenie z naszą bazą danych Amazon Redshift Serverless.

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)

Aby wyświetlić tabele w schemacie syntetycznym, musisz przyznać dostęp w Amazon Redshift za pośrednictwem edytora zapytań.

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

RSstudio połączenia okienko powinno pokazywać sagemaker baza danych ze schematami syntetycznymi i tabelami kart, transakcji, użytkowników.

Możesz kliknąć ikonę tabeli obok tabel, aby wyświetlić 1,000 rekordów.

Uwaga: Stworzyliśmy gotowy plik R Markdown ze wszystkimi gotowymi blokami kodu, które można znaleźć w projekcie GitHub repo.

Teraz użyjmy DBI funkcja pakietu dbListTables() aby wyświetlić istniejące tabele.

dbListTables(con)

Użyj dbGetQuery(), aby przekazać zapytanie SQL do bazy danych.

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

Możemy również użyć dbplyr i dplyr pakiety do wykonywania zapytań w bazie danych. załóżmy count() ile transakcji znajduje się w tabeli transakcji. Ale najpierw musimy zainstalować te pakiety.

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

Użyj tbl() funkcji podczas określania schematu.

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

Policzmy liczbę wierszy dla każdej tabeli.

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

Mamy więc 2,000 użytkowników; 6,146 kart; i 24,386,900 XNUMX XNUMX transakcji. Możemy również przeglądać tabele w konsoli.

transactions_tbl

Możemy również zobaczyć, co dplyr czasowniki robią pod maską.

show_query(transactions_tbl)

Przyjrzyjmy się wizualnie liczbie transakcji według roku.

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

Możemy również podsumować dane w bazie danych w następujący sposób:

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

Załóżmy, że chcemy zobaczyć oszustwo przy użyciu informacji o karcie. Musimy tylko połączyć tabele, a następnie pogrupować je według atrybutu.

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

Teraz przygotujmy zestaw danych, którego można użyć do uczenia maszynowego. Przefiltrujmy dane transakcji tak, aby obejmowały tylko karty kredytowe Discover, zachowując tylko podzbiór kolumn.

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)

A teraz zróbmy trochę porządków, używając następujących przekształceń:

• konwertować is_fraud do atrybutu binarnego
• Usuń ciąg transakcji z use_chip i zmień jego nazwę na typ
• Połącz rok, miesiąc i dzień w obiekt danych
• Usuń $ z kwoty i przekonwertuj na numeryczny typ danych

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)

Teraz, gdy przefiltrowaliśmy i wyczyściliśmy nasz zestaw danych, jesteśmy gotowi do zebrania tego zestawu danych w lokalnej pamięci RAM.

discover <- collect(discover_tbl)
summary(discover)

Teraz mamy działający zestaw danych, aby rozpocząć tworzenie funkcji i modeli dopasowywania. Nie będziemy omawiać tych kroków na tym blogu, ale jeśli chcesz dowiedzieć się więcej o budowaniu modeli w RStudio w SageMaker, zajrzyj do Zapowiedź w pełni zarządzanego RStudio w Amazon SageMaker dla naukowców zajmujących się danymi.

Oczyszczanie

Aby wyczyścić wszelkie zasoby i uniknąć powtarzających się kosztów, usuń główny szablon CloudFormation. Usuń również wszystkie utworzone mocowania EFS oraz utworzone zasobniki i obiekty S3.

Wnioski

Analiza i modelowanie danych może stanowić wyzwanie podczas pracy z dużymi zbiorami danych w chmurze. Amazon Redshift to popularna hurtownia danych, która może pomóc użytkownikom w wykonywaniu tych zadań. RStudio, jedno z najczęściej używanych zintegrowanych środowisk programistycznych (IDE) do analizy danych, jest często używane z językiem R. W tym poście na blogu pokazaliśmy, jak wspólnie korzystać z Amazon Redshift i RStudio w SageMaker, aby skutecznie przeprowadzać analizy na ogromnych zbiorach danych. Korzystając z RStudio w SageMaker, użytkownicy mogą korzystać z w pełni zarządzanej infrastruktury, kontroli dostępu, sieci i możliwości bezpieczeństwa SageMaker, jednocześnie upraszczając integrację z Amazon Redshift. Jeśli chcesz dowiedzieć się więcej o korzystaniu z tych dwóch narzędzi razem, sprawdź nasze inne wpisy na blogu i zasoby. Możesz także spróbować użyć RStudio na SageMaker i Amazon Redshift dla siebie i zobaczyć, jak mogą ci pomóc w zadaniach związanych z analizą danych i modelowaniem.

Dodaj swoją opinię do tego bloga lub utwórz żądanie ściągnięcia na stronie GitHub.

O autorach

Ryana Garnera jest Data Scientist w AWS Professional Services. Pasjonuje się pomaganiem klientom AWS w używaniu R do rozwiązywania problemów związanych z nauką o danych i uczeniem maszynowym.

Raj Pathak jest Starszym Architektem Rozwiązań i Technologiem specjalizującym się w usługach finansowych (ubezpieczenia, bankowość, rynki kapitałowe) oraz uczeniu maszynowym. Specjalizuje się w przetwarzaniu języka naturalnego (NLP), dużych modelach językowych (LLM) oraz projektach infrastrukturalnych i operacyjnych uczenia maszynowego (MLOps).

Aditi Rajnish jest studentem drugiego roku inżynierii oprogramowania na University of Waterloo. Jej zainteresowania obejmują wizję komputerową, przetwarzanie języka naturalnego i przetwarzanie brzegowe. Jest także pasjonatem działań społecznych i rzecznictwa STEM. W wolnym czasie można ją spotkać na wspinaczce skałkowej, grze na pianinie lub uczeniu się, jak upiec idealne bułeczki.

Saiteja Pudi jest architektem rozwiązań w firmie AWS z siedzibą w Dallas w Teksasie. Jest z AWS od ponad 3 lat, pomagając klientom czerpać prawdziwy potencjał AWS, będąc ich zaufanym doradcą. Wywodzi się ze środowiska programistycznego, interesuje się nauką o danych i uczeniem maszynowym.