Suivez vos expériences ML de bout en bout avec Data Version Control et Amazon SageMaker Experiments

Les data scientists travaillent souvent à comprendre les effets de diverses stratégies de prétraitement des données et d'ingénierie des fonctionnalités en combinaison avec différentes architectures de modèles et hyperparamètres. Cela nécessite de couvrir de grands espaces de paramètres de manière itérative, et il peut être fastidieux de suivre les configurations et les résultats précédemment exécutés tout en gardant les expériences reproductibles.

Cet article vous explique comment suivre vos expériences sur le code, les données, les artefacts et les métriques en utilisant Expériences Amazon SageMaker en conjonction avec Contrôle de version des données (DVC). Nous montrons comment vous pouvez utiliser DVC côte à côte avec Amazon Sage Maker emplois de transformation et de formation. Nous formons différents modèles CatBoost sur l'ensemble de données sur le logement californien à partir du Dépôt StatLib, et modifiez les stratégies d'exclusion tout en gardant une trace de la version des données avec DVC. Dans chaque expérience individuelle, nous suivons les artefacts d'entrée et de sortie, le code et les métriques à l'aide des expériences SageMaker.

Expériences SageMaker

SageMaker Experiments est un service AWS permettant de suivre les expériences d'apprentissage automatique (ML). Le SageMaker expérimente le SDK Python est une interface de haut niveau pour ce service qui vous aide à suivre les informations sur les expériences à l'aide de Python.

L'objectif de SageMaker Experiments est de simplifier au maximum la création d'expériences, de les remplir d'essais, d'ajouter des informations de suivi et de lignage et d'exécuter des analyses sur les essais et les expériences.

Lorsque nous discutons des expériences SageMaker, nous faisons référence aux concepts suivants :

• Expérience – Une collection d’essais connexes. Vous ajoutez des essais à une expérience que vous souhaitez comparer entre eux.
• Procès – Une description d’un workflow ML en plusieurs étapes. Chaque étape du flux de travail est décrite par un composant d'essai.
• Composant d'essai – Une description d'une seule étape d'un flux de travail ML, telle que le nettoyage des données, l'extraction de fonctionnalités, la formation de modèle ou l'évaluation de modèle.
• Traqueur – Un gestionnaire de contexte Python pour enregistrer des informations sur un seul composant d'essai (par exemple, des paramètres, des métriques ou des artefacts).

Contrôle de la version des données

Data Version Control (DVC) est un nouveau type de logiciel de gestion des versions, des flux de travail et des expériences de données qui s'appuie sur Git (bien qu'il puisse fonctionner de manière autonome). DVC réduit l'écart entre les outils d'ingénierie établis et les besoins en science des données, vous permettant ainsi de tirer parti de nouveaux Caractéristiques tout en réutilisant les compétences et l'intuition existantes.

Le partage et la collaboration d'expériences en science des données peuvent être effectués via un flux Git régulier (validations, branchement, marquage, demandes d'extraction) de la même manière qu'il fonctionne pour les ingénieurs logiciels. Avec Git et DVC, les équipes de science des données et de ML peuvent versionner les expériences, gérer de grands ensembles de données et rendre les projets reproductibles.

DVC présente les fonctionnalités suivantes :

• DVC est un faim, Open source ligne de commande outil.
• DVC fonctionne sur les référentiels Git et possède une interface de ligne de commande et un flux similaires à ceux de Git. DVC peut également fonctionner de manière autonome, mais sans versioning capacités.
• La gestion des versions des données est activée en remplaçant les fichiers volumineux, les répertoires d'ensembles de données, les modèles ML, etc. par de petits fichiers. métafichiers (facile à gérer avec Git). Ces espaces réservés pointent vers les données originales, qui sont découplées de la gestion du code source.
• Vous pouvez utiliser le stockage sur site ou dans le cloud pour stocker les données du projet séparément de sa base de code. C'est ainsi que les data scientists peuvent transférer de grands ensembles de données ou partager un modèle entraîné par GPU avec d'autres.
• DVC rend les projets de science des données reproductibles en créant des pipelines en utilisant des graphiques de dépendances implicites et en codifiant les données et les artefacts impliqués.
• DVC est indépendant de la plate-forme. Il fonctionne sur tous les principaux systèmes d'exploitation (Linux, macOS et Windows) et fonctionne indépendamment des langages de programmation (Python, R, Julia, scripts shell, etc.) ou des bibliothèques ML (Keras, TensorFlow, PyTorch, Scipy et plus) utilisé dans le projet.
• DVC est rapide à installer et ne nécessite pas d'infrastructure particulière, ni ne dépend d'API ou de services externes. C'est un outil CLI autonome.

Expériences SageMaker et exemple DVC

Exemple GitHub montre comment utiliser DVC dans l'environnement SageMaker. En particulier, nous examinons comment créer une image personnalisée avec les bibliothèques DVC installées par défaut pour fournir un environnement de développement cohérent à vos data scientists dans Amazon SageMakerStudio, et comment exécuter DVC avec l'infrastructure gérée par SageMaker pour le traitement et la formation. De plus, nous montrons comment enrichir les informations de suivi de SageMaker avec les informations de versionnage des données de DVC et les visualiser dans la console Studio.

Le diagramme suivant illustre l'architecture et le flux de travail de la solution.

Créez une image Studio personnalisée avec DVC déjà installé

Dans ce nouvel article concernant notre nouveau projet GitHub référentiel, nous expliquons comment créer une image personnalisée pour Studio sur laquelle DVC est déjà installé. L'avantage de créer une image et de la rendre disponible à tous les utilisateurs de Studio est que cela crée un environnement cohérent pour les utilisateurs de Studio, qu'ils peuvent également exécuter localement. Bien que l'échantillon soit basé sur AWSCloud9, vous pouvez également créer le conteneur sur votre ordinateur local à condition que Docker soit installé et exécuté. Cet exemple est basé sur les éléments suivants Dockerfile ainsi que environnement.yml. L'image Docker résultante est stockée dans Registre des conteneurs élastiques Amazon (Amazon EMR) dans votre compte AWS. Voir le code suivant :

# Login to ECR
aws --region ${REGION} ecr get-login-password | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Create the ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom

# Build the image - it might take a few minutes to complete this step
docker build . -t ${IMAGE_NAME} -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

# Push the image to ECR
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

Vous pouvez maintenant créer un nouveau domaine Studio or mettre à jour un domaine Studio existant qui a accès à l’image Docker nouvellement créée.

Nous utilisons Kit de développement AWS Cloud (AWS CDK) pour créer les ressources suivantes via AWS CloudFormation:

• Un rôle d'exécution SageMaker avec les autorisations appropriées sur votre domaine Studio nouveau ou existant
• Une image SageMaker et une version de l'image SageMaker à partir de l'image Docker conda-env-dvc-kernel que nous avons créé plus tôt
• An AppImageConfig qui spécifie comment la passerelle du noyau doit être configurée
• Un utilisateur de Studio (data-scientist-dvc) avec le rôle d'exécution SageMaker correct et l'image Studio personnalisée disponible

Pour des instructions détaillées, reportez-vous à Associer une image personnalisée à SageMaker Studio.

Exécuter le laboratoire

Pour exécuter l'atelier, procédez comme suit :

1. Dans le domaine Studio, lancez Studio pour le data-scientist-dvc utilisateur.
2. Choisissez l'icône Git, puis choisissez Cloner un référentiel.
   
3. Saisissez l'URL du référentiel (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) et choisissez Cloner.
4. Dans le navigateur de fichiers, choisissez le amazon-sagemaker-experiments-dvc-demo dépôt.
5. Ouvrez le dvc_sagemaker_script_mode.ipynb carnet.
6. Pour Image personnalisée, choisissez l'image conda-env-dvc-kernel.
7. Selectionnez Sélectionnez.
   

Configurer DVC pour la gestion des versions des données

Nous créons un sous-répertoire où nous préparons les données : sagemaker-dvc-sample. Dans ce sous-répertoire, nous initialisons un nouveau référentiel Git et définissons la télécommande sur un référentiel que nous créons dans Code AWSCommit. L'objectif est de disposer des configurations et des fichiers DVC pour le suivi des données versionnés dans ce référentiel. Cependant, Git offre des fonctionnalités natives pour gérer les sous-projets via, par exemple, les sous-modules git et les sous-arbres git, et vous pouvez étendre cet exemple pour utiliser l'un des outils susmentionnés qui correspondent le mieux à votre flux de travail.

Le principal avantage de l'utilisation de CodeCommit avec SageMaker dans notre cas est son intégration avec Gestion des identités et des accès AWS (IAM) pour l'authentification et l'autorisation, ce qui signifie que nous pouvons utiliser les rôles IAM pour envoyer et extraire des données sans avoir besoin de récupérer les informations d'identification (ou les clés SSH). La définition des autorisations appropriées sur le rôle d'exécution SageMaker permet également au bloc-notes Studio et à la tâche de formation et de traitement SageMaker d'interagir en toute sécurité avec CodeCommit.

Bien que vous puissiez remplacer CodeCommit par n'importe quel autre service de contrôle de code source, tel que GitHub, Gitlab ou Bitbucket, vous devez réfléchir à la manière de gérer les informations d'identification de votre système. Une possibilité consiste à stocker ces informations d'identification sur AWS Secrets Manager et récupérez-les au moment de l'exécution à partir du bloc-notes Studio ainsi que des tâches de traitement et de formation SageMaker.

Traiter et former avec DVC et SageMaker

Dans cette section, nous explorons deux approches différentes pour résoudre notre problème et comment nous pouvons suivre les deux tests à l'aide des expériences SageMaker selon l'architecture conceptuelle de haut niveau que nous vous avons montrée précédemment.

Mettre en place une expérience SageMaker

Pour suivre ce test dans SageMaker, nous devons créer une expérience. Il faut également définir l'essai dans l'expérience. Par souci de simplicité, nous ne considérons qu'un seul essai pour l'expérience, mais vous pouvez avoir n'importe quel nombre d'essais au sein d'une expérience, par exemple si vous souhaitez tester différents algorithmes.

Nous créons une expérience nommée DEMO-sagemaker-experiments-dvc avec deux essais, dvc-trial-single-file ainsi que dvc-trial-multi-files, chacun représentant une version différente de l'ensemble de données.

Créons le DEMO-sagemaker-experiments-dvc expérience:

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent
from smexperiments.tracker import Tracker

experiment_name = 'DEMO-sagemaker-experiments-dvc'

# create the experiment if it doesn't exist
try:
    my_experiment = Experiment.load(experiment_name=experiment_name)
    print("existing experiment loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_experiment = Experiment.create(
            experiment_name = experiment_name,
            description = "How to integrate DVC"
        )
        print("new experiment created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Test 1 : Générer des fichiers uniques pour la formation et la validation

Dans cette section, nous créons un script de traitement qui récupère les données brutes directement depuis Service de stockage simple Amazon (Amazon S3) en entrée ; le traite pour créer les ensembles de données d'entraînement, de validation et de test ; et stocke les résultats sur Amazon S3 à l'aide de DVC. De plus, nous montrons comment vous pouvez suivre les artefacts de sortie générés par DVC avec SageMaker lors de l'exécution de tâches de traitement et de formation et via les expériences SageMaker.

Tout d'abord, nous créons le dvc-trial-single-file essai et ajoutez-le au DEMO-sagemaker-experiments-dvc expérience. Ce faisant, nous gardons tous les composants d’essai liés à ce test organisés de manière significative.

first_trial_name = "dvc-trial-single-file"

try:
    my_first_trial = Trial.load(trial_name=first_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_first_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=first_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Utilisez DVC dans une tâche de traitement SageMaker pour créer la version de fichier unique

Dans cette section, nous créons un script de traitement qui obtient les données brutes directement d'Amazon S3 en entrée à l'aide de la capacité de chargement de données gérées de SageMaker ; le traite pour créer les ensembles de données d'entraînement, de validation et de test ; et stocke les résultats sur Amazon S3 à l'aide de DVC. Il est très important de comprendre que lorsque nous utilisons DVC pour stocker des données sur Amazon S3 (ou extraire des données d'Amazon S3), nous perdons les capacités de chargement de données gérées par SageMaker, ce qui peut potentiellement avoir un impact sur les performances et les coûts de nos tâches de traitement et de formation. , en particulier lorsque vous travaillez avec de très grands ensembles de données. Pour plus d'informations sur les différentes fonctionnalités du mode de saisie natif de SageMaker, reportez-vous à Accéder aux données de formation.

Enfin, nous unifions les capacités de suivi DVC avec les capacités de suivi de SageMaker lors de l'exécution de tâches de traitement via SageMaker Experiments.

Le script de traitement attend l'adresse du référentiel Git et la branche que nous souhaitons créer pour stocker les métadonnées DVC transmises via les variables d'environnement. Les ensembles de données eux-mêmes sont stockés dans Amazon S3 par DVC. Bien que les variables environnementales soient automatiquement suivies dans SageMaker Experiments et visibles dans les paramètres des composants d'essai, nous souhaiterons peut-être enrichir les composants d'essai avec des informations supplémentaires, qui deviennent ensuite disponibles pour visualisation dans l'interface utilisateur de Studio à l'aide d'un objet de suivi. Dans notre cas, les paramètres des composants d'essai sont les suivants :

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Le script de prétraitement clone le référentiel Git ; génère les ensembles de données d'entraînement, de validation et de test ; et le synchronise à l'aide de DVC. Comme mentionné précédemment, lors de l'utilisation de DVC, nous ne pouvons pas profiter des capacités natives de chargement de données de SageMaker. Outre les pertes de performances que nous pourrions subir sur de grands ensembles de données, nous perdons également les capacités de suivi automatique des artefacts de sortie. Cependant, grâce au tracker et à l'API Python DVC, nous pouvons compenser ces lacunes, récupérer ces informations au moment de l'exécution et les stocker dans le composant d'essai avec peu d'effort. La valeur ajoutée de cette opération est d'avoir une vue unique des artefacts d'entrée et de sortie qui appartiennent à ce travail de traitement spécifique.

Le script Python de prétraitement complet est disponible dans le GitHub repo.

with Tracker.load() as tracker:
    tracker.log_parameters({"data_commit_hash": commit_hash})
    for file_type in file_types:
        path = dvc.api.get_url(
            f"{data_path}/{file_type}/california_{file_type}.csv",
            repo=dvc_repo_url,
            rev=dvc_branch
        )
        tracker.log_output(name=f"california_{file_type}",value=path)

SageMaker nous donne la possibilité d'exécuter notre script de traitement sur des images de conteneurs gérées par AWS et optimisées pour fonctionner sur l'infrastructure AWS. Si notre script nécessite des dépendances supplémentaires, nous pouvons fournir un requirements.txt déposer. Lorsque nous démarrons le travail de traitement, SageMaker utilise pip-install pour installer toutes les bibliothèques dont nous avons besoin (par exemple, les bibliothèques liées à DVC). Si vous avez besoin d'un contrôle plus strict de toutes les bibliothèques installées sur les conteneurs, vous pouvez apporter votre propre conteneur dans SageMaker, par exemple pour traitement et de la formation.

Nous avons désormais tous les ingrédients pour exécuter notre travail de traitement SageMaker :

• Un script de traitement pouvant traiter plusieurs arguments (--train-test-split-ratio) et deux variables environnementales (DVC_REPO_URL ainsi que DVC_BRANCH)
• A requiremets.txt filet
• Un dépôt Git (dans CodeCommit)
• Une expérience et un essai SageMaker

from sagemaker.processing import FrameworkProcessor, ProcessingInput
from sagemaker.sklearn.estimator import SKLearn

dvc_repo_url = "codecommit::{}://sagemaker-dvc-sample".format(region)
dvc_branch = my_first_trial.trial_name

script_processor = FrameworkProcessor(
    estimator_cls=SKLearn,
    framework_version='0.23-1',
    instance_count=1,
    instance_type='ml.m5.xlarge',
    env={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    },
    role=role
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Nous exécutons ensuite le travail de traitement avec le preprocessing-experiment.py scénario, experiment_config, dvc_repo_urlet dvc_branch nous avons défini plus tôt.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.2"]
)

Le travail de traitement prend environ 5 minutes. Vous pouvez désormais afficher les détails de l'essai pour l'ensemble de données à fichier unique.

La capture d'écran suivante montre où vous pouvez trouver les informations stockées dans Studio. Notez les valeurs de dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URLet data_commit_hash sur le Paramètres languette.

Notez également les détails d'entrée et de sortie sur le Artefacts languette.

Créez un estimateur et ajustez le modèle avec une version de données à fichier unique

Pour utiliser l'intégration DVC dans une tâche de formation SageMaker, nous passons un dvc_repo_url ainsi que dvc_branch comme variables d'environnement lorsque vous créez l'objet Estimator.

Nous nous entraînons sur dvc-trial-single-file branchez d'abord.

Lors de l'extraction de données avec DVC, nous utilisons la structure d'ensemble de données suivante :

dataset
    |-- train
    |   |-- california_train.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation.csv

Nous créons maintenant un estimateur Scikit-learn en utilisant le Kit de développement logiciel (SDK) SageMaker Python. Cela nous permet de préciser les éléments suivants :

• Le chemin d'accès au fichier source Python, qui doit être exécuté comme point d'entrée à la formation.
• Le rôle IAM qui contrôle les autorisations d'accès aux données Amazon S3 et CodeCommit et l'exécution des fonctions SageMaker.
• Une liste de dictionnaires qui définissent les métriques utilisées pour évaluer les tâches de formation.
• Le nombre et le type d'instances de formation. Nous utilisons une instance ml.m5.large.
• Hyperparamètres utilisés pour la formation.
• Variables d'environnement à utiliser pendant le travail de formation. Nous utilisons DVC_REPO_URL, DVC_BRANCHet USER.

metric_definitions = [{'Name': 'median-AE', 'Regex': "AE-at-50th-percentile: ([0-9.]+).*$"}]

hyperparameters={ 
        "learning_rate" : 1,
        "depth": 6
    }
estimator = SKLearn(
    entry_point='train.py',
    source_dir='source_dir',
    role=role,
    metric_definitions=metric_definitions,
    hyperparameters=hyperparameters,
    instance_count=1,
    instance_type='ml.m5.large',
    framework_version='0.23-1',
    base_job_name='training-with-dvc-data',
    environment={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    }
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Nous appelons la méthode fit de l'estimateur avec le experimental_config que nous avons défini précédemment pour démarrer la formation.

%%time
estimator.fit(experiment_config=experiment_config)

Le travail de formation prend environ 5 minutes. Les journaux affichent ces lignes, indiquant les fichiers extraits par DVC :

Running dvc pull command
A       train/california_train.csv
A       test/california_test.csv
A       validation/california_validation.csv
3 files added and 3 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train.csv']
Found validation files: ['/opt/ml/input/data/dataset/train/california_train.csv']

Test 2 : Générer plusieurs fichiers pour la formation et la validation

Nous créons un nouveau dvc-trial-multi-files essai et ajoutez-le au courant DEMO-sagemaker-experiments-dvc expérience.

second_trial_name = "dvc-trial-multi-files"
try:
    my_second_trial = Trial.load(trial_name=second_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_second_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=second_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Contrairement au premier script de traitement, nous créons maintenant plusieurs fichiers à partir de l'ensemble de données d'origine pour la formation et la validation et stockons les métadonnées DVC dans une branche différente.

Vous pouvez explorer le deuxième script Python de prétraitement sur GitHub.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment-multifiles.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.1"]
)

Le travail de traitement prend environ 5 minutes. Vous pouvez désormais afficher les détails de l'essai pour l'ensemble de données multi-fichiers.

Les captures d'écran suivantes montrent où vous pouvez trouver les informations stockées dans SageMaker Experiments dans le Composants d'essai dans l'interface utilisateur de Studio. Notez les valeurs de dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URLet data_commit_hash sur le Paramètres languette.

Vous pouvez également consulter les détails d'entrée et de sortie sur le Artefacts languette.

Nous nous entraînons maintenant sur le dvc-trial-multi-files bifurquer. Lors de l'extraction de données avec DVC, nous utilisons la structure d'ensemble de données suivante :

dataset
    |-- train
    |   |-- california_train_1.csv
    |   |-- california_train_2.csv
    |   |-- california_train_3.csv
    |   |-- california_train_4.csv
    |   |-- california_train_5.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation_1.csv
    |   |-- california_validation_2.csv
    |   |-- california_validation_3.csv

Comme nous l'avons fait auparavant, nous créons un nouvel estimateur Scikit-learn avec le nom de l'essai dvc-trial-multi-files et commencer le travail de formation.

%%time

estimator.fit(experiment_config=experiment_config)

Le travail de formation prend environ 5 minutes. Sur les journaux de tâches de formation envoyés au bloc-notes, vous pouvez voir ces lignes, indiquant les fichiers extraits par DVC :

Running dvc pull command
A       validation/california_validation_2.csv
A       validation/california_validation_1.csv
A       validation/california_validation_3.csv
A       train/california_train_4.csv
A       train/california_train_5.csv
A       train/california_train_2.csv
A       train/california_train_3.csv
A       train/california_train_1.csv
A       test/california_test.csv
9 files added and 9 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train_2.csv', '/opt/ml/input/data/dataset/train/california_train_5.csv', '/opt/ml/input/data/dataset/train/california_train_4.csv', '/opt/ml/input/data/dataset/train/california_train_1.csv', '/opt/ml/input/data/dataset/train/california_train_3.csv']
Found validation files: ['/opt/ml/input/data/dataset/validation/california_validation_2.csv', '/opt/ml/input/data/dataset/validation/california_validation_1.csv', '/opt/ml/input/data/dataset/validation/california_validation_3.csv']

Hébergez votre modèle dans SageMaker

Après avoir entraîné votre modèle ML, vous pouvez le déployer à l'aide de SageMaker. Pour déployer un point de terminaison persistant en temps réel qui effectue une prédiction à la fois, nous utilisons Services d'hébergement en temps réel SageMaker.

from sagemaker.serializers import CSVSerializer

predictor = estimator.deploy(1, "ml.t2.medium", serializer=CSVSerializer())

Tout d’abord, nous obtenons le dernier ensemble de données de test localement sur le bloc-notes de développement dans Studio. A cet effet, nous pouvons utiliser dvc.api.read() pour charger les données brutes stockées dans Amazon S3 par la tâche de traitement SageMaker.

import io
import dvc.api

raw = dvc.api.read(
    "dataset/test/california_test.csv",
    repo=dvc_repo_url,
    rev=dvc_branch
)

Ensuite, nous préparons les données à l'aide de Pandas, chargeons un fichier CSV de test et appelons predictor.predict pour appeler le point de terminaison SageMaker créé précédemment, avec des données, et obtenir des prédictions.

test = pd.read_csv(io.StringIO(raw), sep=",", header=None)
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0:1].values

predicted = predictor.predict(X_test)
for i in range(len(predicted)-1):
    print(f"predicted: {predicted[i]}, actual: {y_test[i][0]}")

Supprimer le point de terminaison

Vous devez supprimer les points de terminaison lorsqu'ils ne sont plus utilisés, car ils sont facturés en fonction de la durée de déploiement (pour plus d'informations, voir Tarification d'Amazon SageMaker). Assurez-vous de supprimer le point de terminaison pour éviter des coûts inattendus.

predictor.delete_endpoint()

Nettoyer

Avant de supprimer toutes les ressources que vous avez créées, assurez-vous que toutes les applications sont supprimées du data-scientist-dvc utilisateur, y compris toutes les applications KernelGateway, ainsi que l'application JupiterServer par défaut.

Vous pouvez ensuite détruire la pile AWS CDK en exécutant la commande suivante :

cdk destroy

Si vous avez utilisé un domaine existant, exécutez également les commandes suivantes :

# inject your DOMAIN_ID into the configuration file
sed -i 's/<your-sagemaker-studio-domain-id>/'"$DOMAIN_ID"'/' ../update-domain-no-custom-images.json
# update the sagemaker studio domain
aws --region ${REGION} sagemaker update-domain --cli-input-json file://../update-domain-no-custom-images.json

Conclusion

Dans cet article, vous avez expliqué comment suivre vos expériences à travers le code, les données, les artefacts et les métriques en utilisant SageMaker Experiments et les tâches de traitement et de formation SageMaker en conjonction avec DVC. Nous avons créé une image Docker contenant DVC, qui était requise pour Studio en tant que bloc-notes de développement, et avons montré comment utiliser les tâches de traitement et de formation avec DVC. Nous avons préparé deux versions des données et utilisé DVC pour les gérer avec Git. Ensuite, vous avez utilisé SageMaker Experiments pour suivre le traitement et la formation avec les deux versions des données afin d'avoir une vue unifiée des paramètres, des artefacts et des métriques dans une seule interface. Enfin, vous avez déployé le modèle sur un point de terminaison SageMaker et utilisé un ensemble de données de test de la deuxième version de l'ensemble de données pour appeler le point de terminaison SageMaker et obtenir des prédictions.

À l'étape suivante, vous pouvez étendre le bloc-notes existant, introduire votre propre stratégie d'ingénierie des fonctionnalités et utiliser DVC et SageMaker pour exécuter vos expériences. Allons construire !

Pour en savoir plus, consultez les ressources suivantes :

À propos des auteurs

Paul DiFrancesco est architecte de solutions chez AWS. Il a de l'expérience dans les télécommunications et le génie logiciel. Il est passionné par l'apprentissage automatique et se concentre actuellement sur l'utilisation de son expérience pour aider les clients à atteindre leurs objectifs sur AWS, en particulier dans les discussions autour des MLOps. En dehors du travail, il aime jouer au football et lire.

Eitan Sela est un architecte de solutions spécialiste de l'apprentissage automatique chez Amazon Web Services. Il travaille avec les clients d'AWS pour fournir des conseils et une assistance technique, en les aidant à créer et à exploiter des solutions d'apprentissage automatique sur AWS. Dans ses temps libres, Eitan aime faire du jogging et lire les derniers articles sur l'apprentissage automatique.