Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Guida introduttiva a un gruppo di set di dati di dominio (SDK for Python (Boto3))
<a name="getting-started-domain-python"></a>

Questo tutorial mostra come utilizzare l'SDK for Python (Boto3) per creare un gruppo di set di dati di dominio per il dominio VIDEO\_ON\_DEMAND. *In questo tutorial, crei un programma di raccomandazione per il caso d'uso Top picks for you.*

Al termine dell'esercizio introduttivo, per evitare di incorrere in addebiti inutili, elimina le risorse che hai creato. Per ulteriori informazioni, consulta [Requisiti per l'eliminazione delle risorse Amazon Personalize](deleting-resources.md). 

**Topics**
+ [Prerequisiti](#gs-sdk-domain-prerequisites)
+ [Tutorial](#gs-python-tutorial)
+ [Guida introduttiva all'utilizzo dei notebook Amazon Personalize APIs with Jupyter (IPython)](#gs-jupyter-domain-notebook)

## Prerequisiti
<a name="gs-sdk-domain-prerequisites"></a>

Di seguito sono elencate alcune fasi preliminari per utilizzare gli esempi di Python in questa guida.
+ Completa il [Prerequisiti per iniziare](gs-prerequisites.md) modulo per configurare le autorizzazioni richieste e creare i dati di allenamento. Se utilizzi i tuoi dati di origine, assicurati che i dati siano formattati come nei prerequisiti.
+ Configura il tuo AWS SDK per Python (Boto3) ambiente come specificato in. [Configurazione del AWS SDKs](aws-personalize-set-up-sdks.md)

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

Nei passaggi seguenti, verifichi il tuo ambiente e crei client SDK for Python (Boto3) per Amazon Personalize. Quindi importi i dati, crei un programma di raccomandazione per lo use case *Top pick for you* e ricevi consigli.

### Passaggio 1: verifica il tuo ambiente Python e crea client boto3
<a name="gs-python-domain-verify-environment"></a>

Dopo aver completato i prerequisiti, esegui il seguente esempio Python per confermare che l'ambiente sia configurato correttamente. Questo codice crea anche i client Amazon Personalize boto3 che usi in questo tutorial. Se il tuo ambiente è configurato correttamente, viene visualizzato un elenco delle ricette disponibili e puoi eseguire gli altri esempi in questo tutorial.

```
import boto3

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

response = personalize.list_recipes()

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

### Fase 2: Importazione dei dati
<a name="getting-started-python-domain-import-dataset"></a>

Dopo aver creato i client Amazon Personalize boto3 e verificato il tuo ambiente, importa i dati storici che hai creato quando hai completato il. [Prerequisiti per iniziare](gs-prerequisites.md) Per importare dati storici in Amazon Personalize, procedi come segue:

1. Utilizza il codice seguente per creare uno schema in Amazon Personalize. Sostituisci `gs-domain-interactions-schema` con un nome per lo schema. 

   ```
   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. Creare un gruppo di set di dati con il seguente codice. Sostituire `dataset group name` con un nome per il gruppo di set di dati.

   ```
   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. Crea un set di dati sulle interazioni tra elementi nel tuo nuovo gruppo di set di dati con il codice seguente. Assegna un nome al set di dati e fornisci il risultato dei `schema_arn` passaggi `dataset_group_arn` precedenti.

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

1. Importa i tuoi dati con un processo di importazione del set di dati con il codice seguente. Il codice utilizza il metodo describe\_dataset\_import\_job per tenere traccia dello stato del lavoro. 

   Passa i seguenti parametri come parametri: un nome per il lavoro, il `dataset_arn` percorso del passaggio precedente, il bucket path di Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) in cui hai archiviato i dati di addestramento e l'ARN del tuo ruolo di servizio IAM. Hai creato questo ruolo come parte di. [Prerequisiti per iniziare](gs-prerequisites.md) Amazon Personalize necessita dell'autorizzazione per accedere al bucket. Per informazioni sulla concessione dell'accesso, consulta. [Offrire ad Amazon Personalize l'accesso alle risorse di 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)
   ```

### Fase 4: Creare un programma di raccomandazione
<a name="domain-gs-py-create-recommender"></a>

Una volta completato il processo di importazione del set di dati, sei pronto per creare un programma di raccomandazione. Utilizzate il codice seguente per creare un programma di raccomandazione. Passa i seguenti parametri come parametri: un nome per il programma di raccomandazione, l'Amazon Resource Name (ARN) del tuo gruppo di set di dati e `arn:aws:personalize:::recipe/aws-vod-top-picks` l'ARN per la ricetta. Il codice utilizza il metodo describe\_recommendender per tenere traccia dello stato del programma di raccomandazione.

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

### Passaggio 5: Ottieni consigli
<a name="domain-gs-py-get-recommendations"></a>

Dopo aver creato un programma di raccomandazione, lo usi per ottenere consigli con il codice seguente. Passa come parametri l'Amazon Resource Name (ARN) del programma di raccomandazione che hai creato nel passaggio precedente e un ID utente (ad esempio,). `123` Il metodo stampa l'elenco degli elementi consigliati. 

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

## Guida introduttiva all'utilizzo dei notebook Amazon Personalize APIs with Jupyter (IPython)
<a name="gs-jupyter-domain-notebook"></a>

 [https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started/notebooks_managed_domains](https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started/notebooks_managed_domains) I taccuini ti guidano nell'importazione dei dati di allenamento, nella creazione di un programma di raccomandazione e nella ricezione di consigli con Amazon Personalize.

**Nota**  
 [Prima di iniziare con i notebook, assicurati di creare il tuo ambiente seguendo i passaggi del file README.md](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/README.md)