Verbinden von Amazon Redshift und RStudio auf Amazon SageMaker

Letztes Jahr haben wir die allgemeine Verfügbarkeit von angekündigt RStudio auf Amazon SageMaker, die branchenweit erste vollständig verwaltete integrierte Entwicklungsumgebung (IDE) RStudio Workbench in der Cloud. Sie können die vertraute RStudio-IDE schnell starten und die zugrunde liegenden Rechenressourcen hoch- und herunterwählen, ohne Ihre Arbeit zu unterbrechen, wodurch es einfach wird, Lösungen für maschinelles Lernen (ML) und Analysen in R in großem Maßstab zu erstellen.

Viele der Benutzer von RStudio auf SageMaker sind auch Benutzer von Amazon RedShift, ein vollständig verwaltetes, massiv paralleles Data Warehouse im Petabyte-Bereich für Datenspeicherung und Analyse-Workloads. Es macht es schnell, einfach und kostengünstig, alle Ihre Daten mit Standard-SQL und Ihren vorhandenen Business Intelligence (BI)-Tools zu analysieren. Benutzer können auch mit Daten mit ODBC, JDBC oder der Amazon Redshift Data API interagieren.

Die Verwendung von RStudio auf SageMaker und Amazon Redshift kann hilfreich sein, um Analysen großer Datenmengen in der Cloud effizient durchzuführen. Die Arbeit mit Daten in der Cloud kann jedoch Herausforderungen mit sich bringen, z. B. die Notwendigkeit, organisatorische Datensilos zu entfernen, Sicherheit und Compliance aufrechtzuerhalten und die Komplexität durch Standardisierung von Tools zu reduzieren. AWS bietet Tools wie RStudio auf SageMaker und Amazon Redshift, um diese Herausforderungen zu bewältigen.

In diesem Blog-Beitrag zeigen wir Ihnen, wie Sie diese beiden Dienste zusammen nutzen können, um Analysen auf riesigen Datensätzen in der Cloud effizient durchzuführen und gleichzeitig die oben genannten Herausforderungen zu bewältigen. Dieser Blog konzentriert sich auf das Rstudio in der Amazon SageMaker-Sprache mit Geschäftsanalysten, Dateningenieuren, Datenwissenschaftlern und allen Entwicklern, die die R-Sprache und Amazon Redshift verwenden, als Zielgruppe.

Wenn Sie die herkömmliche SageMaker Studio-Erfahrung mit Amazon Redshift verwenden möchten, finden Sie weitere Informationen unter Verwenden der Amazon Redshift-Daten-API zur Interaktion von einem Amazon SageMaker Jupyter-Notebook aus.

Lösungsüberblick

Im heutigen Blog werden wir die folgenden Schritte ausführen:

1. Klonen des Beispiel-Repositorys mit den erforderlichen Paketen.
2. Verbinden mit Amazon Redshift über eine sichere ODBC-Verbindung (ODBC ist das bevorzugte Protokoll für RStudio).
3. Ausführen von Abfragen und SageMaker-API-Aktionen für Daten in Amazon Redshift Serverless über RStudio auf SageMaker

Dieser Prozess wird in der folgenden Lösungsarchitektur abgebildet:

Lösungsweg

Voraussetzungen:

Bevor Sie beginnen, stellen Sie sicher, dass Sie alle Voraussetzungen für die Einrichtung von RStudio auf Amazon SageMaker und Amazon Redshift Serverless erfüllen, wie z. B.:

Wir werden einen CloudFormation-Stack verwenden, um die erforderliche Infrastruktur zu generieren.

Hinweis: Wenn Sie bereits über eine RStudio-Domäne und einen Amazon Redshift-Cluster verfügen, können Sie diesen Schritt überspringen

Durch das Starten dieses Stapels werden die folgenden Ressourcen erstellt:

• 3 Private Subnetze
• 1 Öffentliches Subnetz
• 1 NAT-Gateway
• Internet-Gateway
• Amazon Redshift Serverless-Cluster
• SageMaker-Domäne mit RStudio
• SageMaker RStudio-Benutzerprofil
• IAM-Dienstrolle für die SageMaker RStudio-Domänenausführung
• IAM-Dienstrolle für die Ausführung von SageMaker RStudio-Benutzerprofilen

Diese Vorlage wurde entwickelt, um in einer Region zu funktionieren (z. us-east-1, us-west-2) mit drei Availability Zones, RStudio auf SageMaker und Amazon Redshift Serverless. Stellen Sie sicher, dass Ihre Region Zugriff auf diese Ressourcen hat, oder ändern Sie die Vorlagen entsprechend.

Drücken Sie auf Stack starten Schaltfläche, um den Stapel zu erstellen.

1. Auf dem Stapel erstellen Seite wählen Weiter.
2. Auf dem Geben Sie die Stapeldetails an Seite, geben Sie einen Namen für Ihren Stack ein und belassen Sie die verbleibenden Optionen als Standard. Wählen Sie dann aus Weiter.
3. Auf dem Konfigurieren Sie die Stapeloptionen Seite, belassen Sie die Optionen als Standard und drücken Sie Weiter.
4. Auf dem BewertungsseiteWählen Sie die

• Ich erkenne an, dass AWS CloudFormation möglicherweise IAM-Ressourcen mit benutzerdefinierten Namen erstellt
• Ich erkenne an, dass AWS CloudFormation möglicherweise die folgenden Funktionen erfordert: CAPABILITY_AUTO_EXPANDKontrollkästchen und wählen Sie aus Absenden.

Die Vorlage generiert fünf Stapel.

Sobald der Stack-Status ist CREATE_COMPLETE, navigieren Sie zur Amazon Redshift Serverless-Konsole. Dies ist eine neue Funktion, die es super einfach macht, Analysen in der Cloud mit hoher Leistung in jeder Größenordnung auszuführen. Laden Sie einfach Ihre Daten und starten Sie die Abfrage. Es müssen keine Cluster eingerichtet und verwaltet werden.

Note: Das in diesem Blog gezeigte Muster zur Integration von Amazon Redshift und RStudio auf Amazon SageMaker ist unabhängig vom Amazon Redshift-Bereitstellungsmuster (serverloser oder herkömmlicher Cluster) gleich.

Laden von Daten in Amazon Redshift Serverless

Das CloudFormation-Skript hat eine Datenbank namens erstellt sagemaker. Lassen Sie uns diese Datenbank mit Tabellen füllen, die der RStudio-Benutzer abfragen kann. Erstellen Sie eine SQL-Editor-Registerkarte und stellen Sie sicher, dass die sagemaker Datenbank ausgewählt. Wir werden die verwenden synthetische Kreditkartentransaktionsdaten um Tabellen in unserer Datenbank zu erstellen. Diese Daten sind Teil der tabellarischen SageMaker-Beispieldatensätze s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Wir werden die folgende Abfrage im Abfrageeditor ausführen. Dadurch werden drei Tabellen generiert, Karten, Transaktionen, und Nutzer.

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;

Sie können überprüfen, ob die Abfrage erfolgreich ausgeführt wurde, indem Sie drei Tabellen im linken Bereich des Abfrage-Editors sehen.

Sobald alle Tabellen gefüllt sind, navigieren Sie zu SageMaker RStudio und starten Sie eine neue Sitzung mit dem RSession-Basisimage auf einer ml.m5.xlarge-Instanz.

Sobald die Sitzung gestartet ist, führen wir diesen Code aus, um eine Verbindung zu unserer Amazon Redshift Serverless-Datenbank herzustellen.

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)

Um die Tabellen im synthetischen Schema anzuzeigen, müssen Sie in Amazon Redshift über den Abfrage-Editor Zugriff gewähren.

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

Das RStudio Verbindungen Bereich sollte die anzeigen sagemaker Datenbank mit synthetischem Schema und Tabellen Karten, Transaktionen, Benutzer.

Sie können auf das Tabellensymbol neben den Tabellen klicken, um 1,000 Datensätze anzuzeigen.

Hinweis: Wir haben eine vorgefertigte R-Markdown-Datei mit allen vorgefertigten Codeblöcken erstellt, die im Projekt zu finden sind GitHub Repo.

Jetzt verwenden wir die DBI Paketfunktion dbListTables() um vorhandene Tabellen anzuzeigen.

dbListTables(con)

Verwenden Sie dbGetQuery(), um eine SQL-Abfrage an die Datenbank zu übergeben.

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

Wir können auch die dbplyr und dplyr Pakete zum Ausführen von Abfragen in der Datenbank. Lasst uns count() wie viele Transaktionen sind in der Transaktionstabelle. Aber zuerst müssen wir diese Pakete installieren.

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

Verwenden Sie das tbl() Funktion beim Angeben des Schemas.

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

Lassen Sie uns die Anzahl der Zeilen für jede Tabelle zählen.

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

Wir haben also 2,000 Benutzer; 6,146 Karten; und 24,386,900 Transaktionen. Wir können die Tabellen auch in der Konsole anzeigen.

transactions_tbl

Wir können auch was anschauen dplyr Verben tun unter der Haube.

show_query(transactions_tbl)

Lassen Sie uns die Anzahl der Transaktionen nach Jahr visuell untersuchen.

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

Wir können Daten in der Datenbank auch wie folgt zusammenfassen:

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

Angenommen, wir möchten Betrug anhand von Karteninformationen anzeigen. Wir müssen nur die Tabellen verbinden und sie dann nach dem Attribut gruppieren.

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

Lassen Sie uns nun einen Datensatz vorbereiten, der für maschinelles Lernen verwendet werden könnte. Lassen Sie uns die Transaktionsdaten so filtern, dass sie nur Discover-Kreditkarten enthalten, während nur eine Teilmenge von Spalten beibehalten wird.

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)

Lassen Sie uns nun mit den folgenden Transformationen etwas aufräumen:

• Konvertieren is_fraud zum binären Attribut
• Transaktionszeichenfolge entfernen aus use_chip und benenne es in Typ um
• Kombinieren Sie Jahr, Monat und Tag zu einem Datenobjekt
• Entfernen Sie $ aus dem Betrag und konvertieren Sie ihn in einen numerischen Datentyp

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)

Nachdem wir unseren Datensatz gefiltert und bereinigt haben, sind wir bereit, diesen Datensatz im lokalen RAM zu sammeln.

discover <- collect(discover_tbl)
summary(discover)

Jetzt haben wir einen funktionierenden Datensatz, um mit der Erstellung von Features und Anpassungsmodellen zu beginnen. Wir werden diese Schritte in diesem Blog nicht behandeln, aber wenn Sie mehr über das Erstellen von Modellen in RStudio auf SageMaker erfahren möchten, beziehen Sie sich auf Ankündigung von vollständig verwaltetem RStudio auf Amazon SageMaker für Data Scientists.

Aufräumen

Löschen Sie die CloudFormation-Stammvorlage, um Ressourcen zu bereinigen und wiederkehrende Kosten zu vermeiden. Löschen Sie auch alle erstellten EFS-Mounts und alle erstellten S3-Buckets und -Objekte.

Zusammenfassung

Die Datenanalyse und -modellierung kann bei der Arbeit mit großen Datensätzen in der Cloud eine Herausforderung darstellen. Amazon Redshift ist ein beliebtes Data Warehouse, das Benutzern bei diesen Aufgaben helfen kann. RStudio, eine der am weitesten verbreiteten integrierten Entwicklungsumgebungen (IDEs) für die Datenanalyse, wird häufig mit der Sprache R verwendet. In diesem Blogbeitrag haben wir gezeigt, wie Sie Amazon Redshift und RStudio auf SageMaker zusammen verwenden können, um Analysen an riesigen Datensätzen effizient durchzuführen. Durch die Verwendung von RStudio auf SageMaker können Benutzer die Vorteile der vollständig verwalteten Infrastruktur, Zugriffskontrolle, Netzwerk- und Sicherheitsfunktionen von SageMaker nutzen und gleichzeitig die Integration mit Amazon Redshift vereinfachen. Wenn Sie mehr über die gemeinsame Verwendung dieser beiden Tools erfahren möchten, sehen Sie sich unsere anderen Blog-Posts und Ressourcen an. Sie können RStudio auch selbst auf SageMaker und Amazon Redshift verwenden und sehen, wie sie Ihnen bei Ihren Datenanalyse- und Modellierungsaufgaben helfen können.

Bitte fügen Sie Ihr Feedback zu diesem Blog hinzu oder erstellen Sie eine Pull-Anforderung auf der GitHub.

Über die Autoren

Ryan Garner ist Data Scientist bei AWS Professional Services. Er hilft AWS-Kunden leidenschaftlich gerne dabei, ihre Probleme mit Data Science und maschinellem Lernen mit R zu lösen.

Raj Pathak ist ein Senior Solutions Architect und Technologe, der sich auf Finanzdienstleistungen (Versicherungen, Banken, Kapitalmärkte) und maschinelles Lernen spezialisiert hat. Er ist spezialisiert auf Natural Language Processing (NLP), Large Language Models (LLM) und Machine Learning Infrastructure and Operations Projects (MLOps).

Aditi Rajnisch ist Student im zweiten Jahr Software Engineering an der University of Waterloo. Ihre Interessen umfassen Computer Vision, Natural Language Processing und Edge Computing. Sie engagiert sich auch leidenschaftlich für Community-basierte MINT-Aufklärung und Interessenvertretung. In ihrer Freizeit findet man sie beim Klettern, Klavierspielen oder lernt, wie man den perfekten Scone backt.

Saiteja Pudi ist Lösungsarchitekt bei AWS mit Sitz in Dallas, Tx. Er ist jetzt seit mehr als 3 Jahren bei AWS und hilft Kunden dabei, das wahre Potenzial von AWS auszuschöpfen, indem er ihr vertrauenswürdiger Berater ist. Er kommt aus der Anwendungsentwicklung und interessiert sich für Data Science und maschinelles Lernen.