Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Commencer à utiliser un groupe de jeux de données de domaine (SDK pour Python (Boto3))
<a name="getting-started-domain-python"></a>

Ce didacticiel explique comment utiliser le SDK pour Python (Boto3) afin de créer un groupe de jeux de données de domaine pour le domaine VIDEO\_ON\_DEMAND. Dans ce didacticiel, vous allez créer un outil de recommandation pour le cas *d'utilisation qui vous convient* le mieux.

Lorsque vous avez terminé l'exercice de mise en route, pour éviter d'encourir des frais inutiles, supprimez les ressources que vous avez créées. Pour de plus amples informations, veuillez consulter [Conditions requises pour supprimer des ressources Amazon Personalize](deleting-resources.md). 

**Topics**
+ [Conditions préalables](#gs-sdk-domain-prerequisites)
+ [didacticiel](#gs-python-tutorial)
+ [Commencer à utiliser les blocs-notes Amazon Personalize APIs avec Jupyter (iPython)](#gs-jupyter-domain-notebook)

## Conditions préalables
<a name="gs-sdk-domain-prerequisites"></a>

Les étapes suivantes sont prérequises pour l'utilisation des exemples Python de ce guide :
+ Complétez le [Conditions préalables pour démarrer](gs-prerequisites.md) pour configurer les autorisations requises et créer les données d'entraînement. Si vous utilisez vos propres données sources, assurez-vous qu'elles sont formatées conformément aux prérequis.
+ Configurez votre AWS SDK pour Python (Boto3) environnement comme indiqué dans[Configuration du AWS SDKs](aws-personalize-set-up-sdks.md).

## didacticiel
<a name="gs-python-tutorial"></a>

Au cours des étapes suivantes, vous allez vérifier votre environnement et créer un SDK pour les clients Python (Boto3) pour Amazon Personalize. Ensuite, vous importez des données, vous créez un outil de recommandation pour le *cas d'utilisation qui vous convient* le mieux et vous obtenez des recommandations.

### Étape 1 : Vérifiez votre environnement Python et créez des clients boto3
<a name="gs-python-domain-verify-environment"></a>

Une fois que vous avez effectué les prérequis, exécutez l'exemple Python suivant pour vérifier que votre environnement a été configuré correctement. Ce code crée également les clients Amazon Personalize boto3 que vous utilisez dans ce didacticiel. Si votre environnement est correctement configuré, une liste des recettes disponibles s'affiche et vous pouvez exécuter les autres exemples de ce didacticiel.

```
import boto3

personalizeRt = boto3.client('personalize-runtime')
personalize = boto3.client('personalize')

response = personalize.list_recipes()

for recipe in response['recipes']:
    print (recipe)
```

### Étape 2 : Importer des données
<a name="getting-started-python-domain-import-dataset"></a>

Après avoir créé les clients Amazon Personalize boto3 et vérifié votre environnement, importez les données historiques que vous avez créées lorsque vous avez terminé le. [Conditions préalables pour démarrer](gs-prerequisites.md) Pour importer des données historiques dans Amazon Personalize, procédez comme suit :

1. Utilisez le code suivant pour créer un schéma dans Amazon Personalize. Remplacez `gs-domain-interactions-schema` par un nom pour le schéma. 

   ```
   import json
   schema = {
     "type": "record",
     "name": "Interactions",
     "namespace": "com.amazonaws.personalize.schema",
     "fields": [
         {
             "name": "USER_ID",
             "type": "string"
         },
         {
             "name": "ITEM_ID",
             "type": "string"
         },
         {
             "name": "EVENT_TYPE",
             "type": "string"
         },
         {
             "name": "TIMESTAMP",
             "type": "long"
         }
     ],
     "version": "1.0"
   }
   
   create_interactions_schema_response = personalize.create_schema(
       name='{{gs-domain-interactions-schema}}',
       schema=json.dumps(schema),
       domain='VIDEO_ON_DEMAND'
   )
   
   interactions_schema_arn = create_interactions_schema_response['schemaArn']
   print(json.dumps(create_interactions_schema_response, indent=2))
   ```

1. Créez un fichier groupe d'ensembles de données avec le code suivant. Remplacez `dataset group name` par le nom du groupe de jeux de données.

   ```
   response = personalize.create_dataset_group(
     name = '{{dataset group name}}',
     domain = 'VIDEO_ON_DEMAND'
   )
   dsg_arn = response['datasetGroupArn']
   
   description = personalize.describe_dataset_group(datasetGroupArn = dsg_arn)['datasetGroup']
   
   print('Name: ' + description['name'])
   print('ARN: ' + description['datasetGroupArn'])
   print('Status: ' + description['status'])
   ```

1. Créez un jeu de données d'interactions entre articles dans votre nouveau groupe de jeux de données à l'aide du code suivant. Donnez un nom à l'ensemble de données `schema_arn` et indiquez le et `dataset_group_arn` des étapes précédentes.

   ```
   response = personalize.create_dataset(
       name = '{{interactions-dataset-name}}',
       schemaArn = interactions_schema_arn,
       datasetGroupArn = dsg_arn,
       datasetType = 'INTERACTIONS'
   )
   
   dataset_arn = response['datasetArn']
   ```

1. Importez vos données à l'aide d'une tâche d'importation de jeux de données avec le code suivant. Le code utilise la méthode describe\_dataset\_import\_job pour suivre l'état de la tâche. 

   Transmettez les paramètres suivants : le nom de la tâche, celui `dataset_arn` de l'étape précédente, le chemin du compartiment Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) dans lequel vous avez stocké les données de formation et l'ARN de votre rôle de service IAM. Vous avez créé ce rôle dans le cadre du[Conditions préalables pour démarrer](gs-prerequisites.md). Amazon Personalize a besoin d'une autorisation pour accéder au compartiment. Pour plus d'informations sur l'octroi d'accès, consultez[Permettre à Amazon Personalize d'accéder aux ressources Amazon S3](granting-personalize-s3-access.md). 

   ```
   import time
   response = personalize.create_dataset_import_job(
       jobName = '{{JobName}}',
       datasetArn = '{{dataset_arn}}',
       dataSource = {'dataLocation':'s3://{{amzn-s3-demo-bucket}}/{{filename}}.csv'},
       roleArn = '{{role_arn}}'
   )
   
   dataset_interactions_import_job_arn = response['datasetImportJobArn']
   
   description = personalize.describe_dataset_import_job(
       datasetImportJobArn = dataset_interactions_import_job_arn)['datasetImportJob']
   
   print('Name: ' + description['jobName'])
   print('ARN: ' + description['datasetImportJobArn'])
   print('Status: ' + description['status'])
   
   max_time = time.time() + 3*60*60 # 3 hours
   while time.time() < max_time:
       describe_dataset_import_job_response = personalize.describe_dataset_import_job(
           datasetImportJobArn = dataset_interactions_import_job_arn
       )
       status = describe_dataset_import_job_response["datasetImportJob"]['status']
       print("Interactions DatasetImportJob: {}".format(status))
       
       if status == "ACTIVE" or status == "CREATE FAILED":
           break
           
       time.sleep(60)
   ```

### Étape 4 : créer un recommandeur
<a name="domain-gs-py-create-recommender"></a>

Une fois votre tâche d'importation de jeu de données terminée, vous êtes prêt à créer un recommandateur. Utilisez le code suivant pour créer un recommendeur. Transmettez les paramètres suivants : le nom du recommandeur, le nom de ressource Amazon (ARN) de votre groupe de données et l'ARN `arn:aws:personalize:::recipe/aws-vod-top-picks` de la recette. Le code utilise la méthode describe\_recommender pour suivre l'état du recommandeur.

```
import time
create_recommender_response = personalize.create_recommender(
  name = 'gs-python-top-picks',
  recipeArn = 'arn:aws:personalize:::recipe/aws-vod-top-picks',
  datasetGroupArn = dsg_arn     
)
recommender_arn = create_recommender_response['recommenderArn']

print('Recommender ARN:' + recommender_arn)
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:

    version_response = personalize.describe_recommender(
        recommenderArn = recommender_arn
    )
    status = version_response["recommender"]["status"]

    if status == "ACTIVE":
        print("Creation succeeded for {}".format(recommender_arn))
        
    elif status == "CREATE FAILED":
        print("Creation failed for {}".format(recommender_arn))

    if status == "ACTIVE":
        break
    else:
        print("Recommender creation is still in progress")
        
    time.sleep(60)
```

### Étape 5 : Obtenir des recommandations
<a name="domain-gs-py-get-recommendations"></a>

Après avoir créé un recommandeur, vous pouvez l'utiliser pour obtenir des recommandations avec le code suivant. Transmettez comme paramètres le Amazon Resource Name (ARN) du recommandeur que vous avez créé à l'étape précédente, ainsi qu'un ID utilisateur (par exemple,`123`). La méthode imprime la liste des éléments recommandés. 

```
response = personalizeRt.get_recommendations(
    recommenderArn = "arn:aws:personalize:us-west-2:014025156336:recommender/gs-python-top-picks-89",
    userId = '123'
)
print("Recommended items")
for item in response['itemList']:
    print (item['itemId'])
```

## Commencer à utiliser les blocs-notes Amazon Personalize APIs avec Jupyter (iPython)
<a name="gs-jupyter-domain-notebook"></a>

 [Pour commencer à créer des groupes de jeux de données de domaines avec les blocs-notes Jupyter, clonez ou téléchargez une série de blocs-notes situés dans le dossier [notebooks\_managed\_domains du référentiel](https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started/notebooks_managed_domains) d'échantillons Amazon Personalize.](https://github.com/aws-samples/amazon-personalize-samples) Les carnets de notes vous expliquent comment importer des données de formation, créer un outil de recommandation et obtenir des recommandations avec Amazon Personalize.

**Note**  
 [Avant de commencer avec les blocs-notes, assurez-vous de créer votre environnement en suivant les étapes du fichier README.md](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/README.md)