Connexion d'Amazon Redshift et RStudio sur Amazon SageMaker

L'année dernière, nous avons annoncé la disponibilité générale de RStudio sur Amazon SageMaker, le premier environnement de développement intégré (IDE) RStudio Workbench entièrement géré dans le cloud. Vous pouvez lancer rapidement l'IDE RStudio familier et composer les ressources de calcul sous-jacentes sans interrompre votre travail, ce qui facilite la création de solutions d'apprentissage automatique (ML) et d'analyse dans R à grande échelle.

De nombreux utilisateurs de RStudio sur SageMaker utilisent également Redshift d'Amazon, un entrepôt de données massivement parallèle à l'échelle du pétaoctet entièrement géré pour le stockage de données et les charges de travail analytiques. Il permet d'analyser rapidement, simplement et à moindre coût toutes vos données à l'aide du langage SQL standard et de vos outils d'informatique décisionnelle (BI) existants. Les utilisateurs peuvent également interagir avec les données avec ODBC, JDBC ou l'API Amazon Redshift Data.

L'utilisation de RStudio sur SageMaker et Amazon Redshift peut être utile pour effectuer efficacement des analyses sur de grands ensembles de données dans le cloud. Cependant, travailler avec des données dans le cloud peut présenter des défis, tels que la nécessité de supprimer les silos de données organisationnels, de maintenir la sécurité et la conformité, et de réduire la complexité en standardisant les outils. AWS propose des outils tels que RStudio sur SageMaker et Amazon Redshift pour aider à relever ces défis.

Dans cet article de blog, nous vous montrerons comment utiliser ces deux services ensemble pour effectuer efficacement des analyses sur des ensembles de données volumineux dans le cloud tout en relevant les défis mentionnés ci-dessus. Ce blog se concentre sur le langage Rstudio sur Amazon SageMaker, avec des analystes commerciaux, des ingénieurs de données, des scientifiques de données et tous les développeurs qui utilisent le langage R et Amazon Redshift, comme public cible.

Si vous souhaitez utiliser l'expérience SageMaker Studio traditionnelle avec Amazon Redshift, reportez-vous à Utilisation de l'API Amazon Redshift Data pour interagir à partir d'un bloc-notes Amazon SageMaker Jupyter.

Vue d'ensemble de la solution

Dans le blog d'aujourd'hui, nous allons exécuter les étapes suivantes :

1. Clonage de l'exemple de référentiel avec les packages requis.
2. Connexion à Amazon Redshift avec une connexion ODBC sécurisée (ODBC est le protocole préféré pour RStudio).
3. Exécution de requêtes et d'actions d'API SageMaker sur des données dans Amazon Redshift Serverless via RStudio sur SageMaker

Ce processus est décrit dans l'architecture de solutions suivante :

Procédure pas à pas de la solution

Pré-requis

Avant de commencer, assurez-vous que vous disposez de toutes les conditions requises pour configurer RStudio sur Amazon SageMaker et Amazon Redshift Serverless, telles que :

Nous utiliserons une pile CloudFormation pour générer l'infrastructure requise.

Remarque: Si vous avez déjà un domaine RStudio et un cluster Amazon Redshift, vous pouvez ignorer cette étape

Le lancement de cette pile crée les ressources suivantes :

• 3 sous-réseaux privés
• 1 Sous-réseau public
• 1 passerelle NAT
• Passerelle Internet
• Cluster sans serveur Amazon Redshift
• Domaine SageMaker avec RStudio
• Profil utilisateur SageMaker RStudio
• Rôle de service IAM pour l'exécution du domaine SageMaker RStudio
• Rôle de service IAM pour l'exécution du profil utilisateur SageMaker RStudio

Ce modèle est conçu pour fonctionner dans une région (ex. us-east-1, us-west-2) avec trois zones de disponibilité, RStudio sur SageMaker et Amazon Redshift Serverless. Assurez-vous que votre région a accès à ces ressources ou modifiez les modèles en conséquence.

Appuyez sur la touche Lancer la pile bouton pour créer la pile.

1. Sur le Créer une pile page, choisissez Suivant.
2. Sur le Spécifiez les détails de la pile page, indiquez un nom pour votre pile et laissez les options restantes par défaut, puis choisissez Suivant.
3. Sur le Configurer les options de pile page, laissez les options par défaut et appuyez sur Suivant.
4. Sur le Page de révision, Sélectionnez l'

• Je reconnais qu'AWS CloudFormation peut créer des ressources IAM avec des noms personnalisés
• Je reconnais qu'AWS CloudFormation peut nécessiter la capacité suivante: CAPABILITY_AUTO_EXPANDcases à cocher et choisissez Envoyer.

Le modèle générera cinq piles.

Une fois que l'état de la pile est CREATE_COMPLETE, accédez à la console Amazon Redshift Serverless. Il s'agit d'une nouvelle fonctionnalité qui facilite l'exécution d'analyses dans le cloud avec des performances élevées à n'importe quelle échelle. Chargez simplement vos données et commencez à interroger. Il n'est pas nécessaire de configurer et de gérer des clusters.

Notes: Le modèle démontré dans ce blog intégrant Amazon Redshift et RStudio sur Amazon SageMaker sera le même quel que soit le modèle de déploiement d'Amazon Redshift (cluster sans serveur ou traditionnel).

Chargement de données dans Amazon Redshift Serverless

Le script CloudFormation a créé une base de données appelée sagemaker. Remplissons cette base de données avec des tables que l'utilisateur de RStudio pourra interroger. Créez un onglet d'éditeur SQL et assurez-vous que sagemaker la base de données est sélectionnée. Nous utiliserons le données synthétiques sur les transactions par carte de crédit pour créer des tables dans notre base de données. Ces données font partie des exemples d'ensembles de données tabulaires SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Nous allons exécuter la requête suivante dans l'éditeur de requêtes. Cela va générer trois tables, cartes, opérations, ainsi que le utilisateurs.

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;

Vous pouvez vérifier que la requête s'est exécutée avec succès en voyant trois tables dans le volet de gauche de l'éditeur de requête.

Une fois toutes les tables remplies, accédez à SageMaker RStudio et démarrez une nouvelle session avec l'image de base RSession sur une instance ml.m5.xlarge.

Une fois la session lancée, nous exécuterons ce code pour créer une connexion à notre base de données 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)

Pour afficher les tables dans le schéma synthétique, vous devrez accorder l'accès dans Amazon Redshift via l'éditeur de requête.

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

Le RStudio Connexions le volet doit afficher le sagemaker base de données avec schéma synthétique et tableaux cartes, transactions, utilisateurs.

Vous pouvez cliquer sur l'icône de tableau à côté des tableaux pour afficher 1,000 XNUMX enregistrements.

Remarque : Nous avons créé un fichier R Markdown pré-construit avec tous les blocs de code pré-construits qui peuvent être trouvés sur le projet GitHub repo.

Utilisons maintenant le DBI fonction de paquet dbListTables() pour afficher les tables existantes.

dbListTables(con)

Utilisez dbGetQuery() pour transmettre une requête SQL à la base de données.

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

Nous pouvons également utiliser le dbplyr ainsi que le dplyr packages pour exécuter des requêtes dans la base de données. Allons count() combien de transactions sont dans la table des transactions. Mais d'abord, nous devons installer ces packages.

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

Utilisez l'option tbl() fonction tout en spécifiant le schéma.

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

Comptons le nombre de lignes pour chaque table.

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

Nous avons donc 2,000 6,146 utilisateurs ; 24,386,900 XNUMX cartes ; et XNUMX XNUMX XNUMX transactions. Nous pouvons également afficher les tables dans la console.

transactions_tbl

Nous pouvons également voir ce que dplyr les verbes font sous le capot.

show_query(transactions_tbl)

Explorons visuellement le nombre de transactions par année.

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

Nous pouvons également résumer les données de la base de données comme suit :

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

Supposons que nous voulions voir la fraude à l'aide des informations de carte. Nous avons juste besoin de joindre les tables, puis de les regrouper par l'attribut.

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

Préparons maintenant un ensemble de données qui pourrait être utilisé pour l'apprentissage automatique. Filtrons les données de transaction pour inclure uniquement les cartes de crédit Discover tout en ne conservant qu'un sous-ensemble de colonnes.

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)

Et maintenant, faisons un peu de nettoyage en utilisant les transformations suivantes :

• Convertir is_fraud à l'attribut binaire
• Supprimer la chaîne de transaction de use_chip et renommez-le en type
• Combinez l'année, le mois et le jour dans un objet de données
• Supprimer $ du montant et convertir en un type de données numérique

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)

Maintenant que nous avons filtré et nettoyé notre ensemble de données, nous sommes prêts à collecter cet ensemble de données dans la RAM locale.

discover <- collect(discover_tbl)
summary(discover)

Nous avons maintenant un ensemble de données de travail pour commencer à créer des fonctionnalités et à ajuster des modèles. Nous ne couvrirons pas ces étapes dans ce blog, mais si vous souhaitez en savoir plus sur la création de modèles dans RStudio sur SageMaker, reportez-vous à Annonce de RStudio entièrement géré sur Amazon SageMaker pour les scientifiques de données.

Nettoyer

Pour nettoyer toutes les ressources afin d'éviter des coûts récurrents, supprimez le modèle racine CloudFormation. Supprimez également tous les montages EFS créés et tous les compartiments et objets S3 créés.

Conclusion

L'analyse et la modélisation des données peuvent être difficiles lorsque vous travaillez avec de grands ensembles de données dans le cloud. Amazon Redshift est un entrepôt de données populaire qui peut aider les utilisateurs à effectuer ces tâches. RStudio, l'un des environnements de développement intégrés (IDE) les plus largement utilisés pour l'analyse de données, est souvent utilisé avec le langage R. Dans cet article de blog, nous avons montré comment utiliser ensemble Amazon Redshift et RStudio sur SageMaker pour effectuer efficacement des analyses sur des ensembles de données volumineux. En utilisant RStudio sur SageMaker, les utilisateurs peuvent profiter de l'infrastructure entièrement gérée, du contrôle d'accès, de la mise en réseau et des capacités de sécurité de SageMaker, tout en simplifiant l'intégration avec Amazon Redshift. Si vous souhaitez en savoir plus sur l'utilisation de ces deux outils ensemble, consultez nos autres articles de blog et ressources. Vous pouvez également essayer d'utiliser RStudio sur SageMaker et Amazon Redshift pour vous-même et voir comment ils peuvent vous aider dans vos tâches d'analyse et de modélisation de données.

Veuillez ajouter vos commentaires à ce blog ou créer une demande d'extraction sur le GitHub.

À propos des auteurs

Ryan Garner est un Data Scientist avec AWS Professional Services. Il est passionné d'aider les clients AWS à utiliser R pour résoudre leurs problèmes de science des données et d'apprentissage automatique.

Raj Pathak est un architecte de solutions senior et un technologue spécialisé dans les services financiers (assurance, banque, marchés de capitaux) et l'apprentissage automatique. Il est spécialisé dans le traitement du langage naturel (TAL), les grands modèles de langage (LLM) et les projets d'infrastructure et d'exploitation d'apprentissage automatique (MLOps).

Aditi Rajnish est un étudiant de deuxième année en génie logiciel à l'Université de Waterloo. Ses intérêts incluent la vision par ordinateur, le traitement du langage naturel et l'informatique de pointe. Elle est également passionnée par la sensibilisation et le plaidoyer STEM communautaires. Dans ses temps libres, on peut la trouver en train de faire de l'escalade, de jouer du piano ou d'apprendre à préparer le scone parfait.

Saiteja Pudi est un architecte de solutions chez AWS, basé à Dallas, Tx. Il travaille chez AWS depuis plus de 3 ans maintenant, aidant les clients à tirer le véritable potentiel d'AWS en étant leur conseiller de confiance. Il vient d'une formation en développement d'applications, intéressé par la science des données et l'apprentissage automatique.