Traitement parallèle des données avec 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.

Avec un volume de données sans cesse croissant généré, les ensembles de données utilisés pour le ML et l'analyse statistique se développent en tandem. Cela entraîne les défis de l'augmentation du temps de développement et de la gestion de l'infrastructure de calcul. Pour résoudre ces défis, les scientifiques des données ont cherché à mettre en œuvre des techniques de traitement parallèle des données. Traitement parallèle des données, ou parallélisation des données, prend de grands ensembles de données existants et les distribue sur plusieurs processeurs ou nœuds pour opérer simultanément sur les données. Cela peut permettre un temps de traitement plus rapide d'ensembles de données plus volumineux, ainsi qu'une utilisation optimisée sur le calcul. Cela peut aider les praticiens du ML à créer des modèles réutilisables pour la génération d'ensembles de données, et également à réduire la charge et les coûts de l'infrastructure de calcul.

Vue d'ensemble de la solution

Dans Amazon Sage Maker, de nombreux clients utilisent Traitement SageMaker pour aider à mettre en œuvre le traitement parallèle des données. Avec SageMaker Processing, vous pouvez utiliser une expérience simplifiée et gérée sur SageMaker pour exécuter vos charges de travail de traitement de données, telles que l'ingénierie des fonctionnalités, la validation des données, l'évaluation et l'interprétation des modèles. Cela présente de nombreux avantages, car il n'y a pas d'infrastructure de longue durée à gérer : les instances de traitement s'arrêtent lorsque les tâches sont terminées, les environnements peuvent être standardisés via des conteneurs, les données à l'intérieur Service de stockage simple Amazon (Amazon S3) est distribué de manière native sur plusieurs instances et les paramètres d'infrastructure sont flexibles en termes de mémoire, de calcul et de stockage.

SageMaker Processing propose des options de distribution des données. Pour le traitement parallèle des données, vous devez utiliser le Option ShardedByS3Key pour le S3DataDistributionType. Lorsque ce paramètre est sélectionné, SageMaker Processing prend les n instances et distribuer des objets 1/n objets de la source de données d'entrée dans les instances. Par exemple, si deux instances sont fournies avec quatre objets de données, chaque instance reçoit deux objets.

SageMaker Processing nécessite trois composants pour exécuter les tâches de traitement :

• Une image de conteneur contenant votre code et vos dépendances pour exécuter vos charges de travail de traitement de données
• Un chemin vers une source de données d'entrée dans Amazon S3
• Un chemin vers une source de données de sortie dans Amazon S3

Le processus est décrit dans le schéma suivant.

Dans cet article, nous vous montrons comment utiliser RStudio sur SageMaker pour s'interfacer avec une série de tâches de traitement SageMaker afin de créer un pipeline de traitement de données parallèle à l'aide du Langage de programmation R.

La solution comprend les étapes suivantes:

1. Configurez le projet RStudio.
2. Générez et enregistrez l'image du conteneur de traitement.
3. Exécutez le pipeline de traitement en deux étapes :
   1. La première étape prend plusieurs fichiers de données et les traite à travers une série de tâches de traitement.
   2. La deuxième étape concatène les fichiers de sortie et les divise en ensembles de données d'apprentissage, de test et de validation.

Pré-requis

Remplissez les conditions préalables suivantes :

1. Configurez le RStudio sur SageMaker Workbench. Pour plus d'informations, reportez-vous à Annonce de RStudio entièrement géré sur Amazon SageMaker pour les scientifiques de données.
2. Créez un utilisateur avec RStudio sur SageMaker avec les autorisations d'accès appropriées.

Configurer le projet RStudio

Pour configurer le projet RStudio, procédez comme suit :

1. Naviguez vers votre Amazon SageMakerStudio panneau de contrôle sur la console SageMaker.
2. Lancez votre application dans l'environnement RStudio.
   
3. Démarrez une nouvelle session RStudio.
4. Pour Nom de la séance, entrez un nom.
5. Pour Type d'instance et les Image(s), utilisez les paramètres par défaut.
6. Selectionnez Démarrer la session.
   
7. Naviguez dans la session.
8. Selectionnez Nouveau projet, Contrôle de version, et alors Sélectionnez Git.
9. Pour URL du référentiel, Entrer https://github.com/aws-samples/aws-parallel-data-processing-r.git
10. Laissez les options restantes par défaut et choisissez Créer un projet.
    

Vous pouvez accéder au aws-parallel-data-processing-R répertoire sur le Fichiers onglet pour afficher le référentiel. Le référentiel contient les fichiers suivants :

• Container_Build.rmd
• /dataset
  • bank-additional-full-data1.csv
  • bank-additional-full-data2.csv
  • bank-additional-full-data3.csv
  • bank-additional-full-data4.csv
• /docker
• Dockerfile-Processing
• Parallel_Data_Processing.rmd
• /preprocessing
  • filter.R
  • process.R

Construire le conteneur

Dans cette étape, nous construisons notre image de conteneur de traitement et la poussons vers Registre des conteneurs élastiques Amazon (Amazon ECR). Effectuez les étapes suivantes :

1. Accédez à la Container_Build.rmd fichier.
2. Installez l' CLI de génération d'images SageMaker Studio en exécutant la cellule suivante. Assurez-vous de disposer des autorisations requises avant de terminer cette étape. Il s'agit d'une CLI conçue pour envoyer et enregistrer des images de conteneur dans Studio.

   pip install sagemaker-studio-image-build

3. Exécutez la cellule suivante pour créer et enregistrer notre conteneur de traitement :

   /home/sagemaker-user/.local/bin/sm-docker build . --file ./docker/Dockerfile-Processing --repository sagemaker-rstudio-parallel-processing:1.0

Une fois la tâche exécutée avec succès, vous recevez un résultat semblable à celui-ci :

Image URI: <Account_Number>.dkr.ecr.<Region>.amazonaws.com/sagemaker-rstudio- parallel-processing:1.0

Exécuter le pipeline de traitement

Après avoir créé le conteneur, accédez au Parallel_Data_Processing.rmd dossier. Ce fichier contient une série d'étapes qui nous aident à créer notre pipeline de traitement de données parallèle à l'aide de SageMaker Processing. Le diagramme suivant décrit les étapes du pipeline que nous effectuons.

Commencez par exécuter l'étape d'importation du package. Importez les packages RStudio requis avec le SDK SageMaker :

suppressWarnings(library(dplyr))
suppressWarnings(library(reticulate))
suppressWarnings(library(readr))
path_to_python <- system(‘which python’, intern = TRUE)

use_python(path_to_python)
sagemaker <- import('sagemaker')

Configurez maintenant votre rôle d'exécution SageMaker et les détails de l'environnement :

role = sagemaker$get_execution_role()
session = sagemaker$Session()
bucket = session$default_bucket()
account_id <- session$account_id()
region <- session$boto_region_name
local_path <- dirname(rstudioapi::getSourceEditorContext()$path)

Initialisez le conteneur que nous avons créé et enregistré à l'étape précédente :

container_uri <- paste(account_id, "dkr.ecr", region, "amazonaws.com/sagemaker-rstudio-parallel-processing:1.0", sep=".")
print(container_uri)

À partir de là, nous plongeons plus en détail dans chacune des étapes de traitement.

Charger le jeu de données

Pour notre exemple, nous utilisons le Ensemble de données de marketing bancaire de l'UCI. Nous avons déjà divisé le jeu de données en plusieurs fichiers plus petits. Exécutez le code suivant pour importer les fichiers sur Amazon S3 :

local_dataset_path <- paste0(local_path,"/dataset/")

dataset_files <- list.files(path=local_dataset_path, pattern=".csv$", full.names=TRUE)
for (file in dataset_files){
  session$upload_data(file, bucket=bucket, key_prefix="sagemaker-rstudio-example/split")
}

input_s3_split_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/split")

Une fois les fichiers téléchargés, passez à l'étape suivante.

Effectuer un traitement parallèle des données

Dans cette étape, nous prenons les fichiers de données et effectuons l'ingénierie des fonctionnalités pour filtrer certaines colonnes. Ce travail est réparti sur une série d'instances de traitement (pour notre exemple, nous en utilisons deux).

Nous utilisons les filter.R fichier pour traiter les données, et configurez le travail comme suit :

filter_processor <- sagemaker$processing$ScriptProcessor(command=list("Rscript"),
                                                        image_uri=container_uri,
                                                        role=role,
                                                        instance_count=2L,
                                                        instance_type="ml.m5.large")

output_s3_filter_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/filtered")
s3_filter_input <- sagemaker$processing$ProcessingInput(source=input_s3_split_location,
                                                        destination="/opt/ml/processing/input",
                                                        s3_data_distribution_type="ShardedByS3Key",
                                                        s3_data_type="S3Prefix")
s3_filter_output <- sagemaker$processing$ProcessingOutput(output_name="bank-additional-full-filtered",
                                                         destination=output_s3_filter_location,
                                                         source="/opt/ml/processing/output")

filtering_step <- sagemaker$workflow$steps$ProcessingStep(name="FilterProcessingStep",
                                                      code=paste0(local_path, "/preprocessing/filter.R"),
                                                      processor=filter_processor,
                                                      inputs=list(s3_filter_input),
                                                      outputs=list(s3_filter_output))

Comme mentionné précédemment, lors de l'exécution d'une tâche de traitement de données parallèle, vous devez ajuster le paramètre d'entrée en fonction de la façon dont les données seront partitionnées et du type de données. Par conséquent, nous fournissons la méthode de partitionnement par S3Prefix:

s3_data_distribution_type="ShardedByS3Key",
                                                      s3_data_type="S3Prefix")

Une fois ces paramètres insérés, SageMaker Processing répartit équitablement les données sur le nombre d'instances sélectionnées.

Ajustez les paramètres selon vos besoins, puis exécutez la cellule pour instancier la tâche.

Générer des ensembles de données de formation, de test et de validation

Dans cette étape, nous prenons les fichiers de données traités, les combinons et les divisons en ensembles de données de test, d'entraînement et de validation. Cela nous permet d'utiliser les données pour construire notre modèle.

Nous utilisons les process.R fichier pour traiter les données, et configurez le travail comme suit :

script_processor <- sagemaker$processing$ScriptProcessor(command=list("Rscript"),
                                                         image_uri=container_uri,
                                                         role=role,
                                                         instance_count=1L,
                                                         instance_type="ml.m5.large")

output_s3_processed_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/processed")
s3_processed_input <- sagemaker$processing$ProcessingInput(source=output_s3_filter_location,
                                                         destination="/opt/ml/processing/input",
                                                         s3_data_type="S3Prefix")
s3_processed_output <- sagemaker$processing$ProcessingOutput(output_name="bank-additional-full-processed",
                                                         destination=output_s3_processed_location,
                                                         source="/opt/ml/processing/output")

processing_step <- sagemaker$workflow$steps$ProcessingStep(name="ProcessingStep",
                                                      code=paste0(local_path, "/preprocessing/process.R"),
                                                      processor=script_processor,
                                                      inputs=list(s3_processed_input),
                                                      outputs=list(s3_processed_output),
                                                      depends_on=list(filtering_step))

Ajustez les paramètres si nécessaire, puis exécutez la cellule pour instancier la tâche.

Exécutez le pipeline

Une fois toutes les étapes instanciées, démarrez le pipeline de traitement pour exécuter chaque étape en exécutant la cellule suivante :

pipeline = sagemaker$workflow$pipeline$Pipeline(
  name="BankAdditionalPipelineUsingR",
  steps=list(filtering_step, processing_step)
)

upserted <- pipeline$upsert(role_arn=role)
execution <- pipeline$start()

execution$describe()
execution$wait()

La durée de chacune de ces tâches varie en fonction de la taille et du nombre d'instances sélectionnés.

Accédez à la console SageMaker pour voir toutes vos tâches de traitement.

Nous commençons par le travail de filtrage, comme illustré dans la capture d'écran suivante.

Une fois cette opération terminée, le pipeline passe au travail de traitement des données.

Lorsque les deux tâches sont terminées, accédez à votre compartiment S3. Regardez dans le sagemaker-rstudio-example dossier, sous processed. Vous pouvez voir les fichiers des ensembles de données d'entraînement, de test et de validation.

Conclusion

Avec une quantité croissante de données qui seront nécessaires pour construire des modèles de plus en plus sophistiqués, nous devons changer notre approche de la façon dont nous traitons les données. Le traitement parallèle des données est une méthode efficace pour accélérer la génération d'ensembles de données et, s'il est associé à des environnements et des outils cloud modernes tels que RStudio sur SageMaker et SageMaker Processing, il peut supprimer une grande partie du poids indifférencié de la gestion de l'infrastructure, de la génération de code passe-partout et de la gestion de l'environnement. Dans cet article, nous avons expliqué comment implémenter le traitement parallèle des données dans RStudio sur SageMaker. Nous vous encourageons à l'essayer en clonant le référentiel GitHub, et si vous avez des suggestions sur la façon d'améliorer l'expérience, veuillez soumettre un problème ou une demande d'extraction.

Pour en savoir plus sur les fonctionnalités et les services utilisés dans cette solution, reportez-vous à RStudio sur Amazon SageMaker et les Traitement d'Amazon SageMaker.

À propos des auteurs

Raj Pathak est un architecte de solutions et un conseiller technique auprès de clients Fortune 50 et de taille moyenne FSI (banques, assurances, marchés des capitaux) au Canada et aux États-Unis. Raj se spécialise dans l'apprentissage automatique avec des applications dans l'extraction de documents, la transformation du centre de contact et la vision par ordinateur.

Jake Wen est un architecte de solutions chez AWS avec une passion pour la formation ML et le traitement du langage naturel. Jake aide les clients des petites et moyennes entreprises en matière de conception et de leadership éclairé pour créer et déployer des applications à grande échelle. En dehors du travail, il aime faire de la randonnée.

Aditi Rajnish est un étudiant de première 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.

Sean Morgan est un architecte de solutions AI/ML chez AWS. Il a de l'expérience dans les domaines des semi-conducteurs et de la recherche universitaire, et utilise son expérience pour aider les clients à atteindre leurs objectifs sur AWS. Pendant son temps libre, Sean est un contributeur et un mainteneur open source actif, et est le responsable du groupe d'intérêt spécial pour les modules complémentaires TensorFlow.

Paul Wu est un architecte de solutions travaillant dans l'activité Greenfield d'AWS au Texas. Ses domaines d'expertise incluent les conteneurs et les migrations.