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 (SDK per Python (Boto3))
<a name="getting-started-python"></a>

Questo tutorial mostra come completare il flusso di lavoro di Amazon Personalize dall'inizio alla fine con l'SDK for Python (Boto3). 

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-prerequisites)
+ [

## Tutorial
](#gs-python-custom-tutorial)
+ [

## Come iniziare a usare i notebook Amazon Personalize APIs with Jupyter (IPython)
](#gs-jupyter-notebook)

## Prerequisiti
<a name="gs-sdk-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-custom-tutorial"></a>

Nei passaggi seguenti, verifichi il tuo ambiente e crei client SDK for Python (Boto3) per Amazon Personalize. Quindi importi dati, crei e distribuisci una versione della soluzione con una campagna e ricevi consigli.

### Passaggio 1: verifica il tuo ambiente Python e crea client boto3
<a name="gs-python-example"></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-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 `getting-started-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": "TIMESTAMP",
             "type": "long"
         }
     ],
     "version": "1.0"
   }
   
   create_interactions_schema_response = personalize.create_schema(
       name='getting-started-schema',
       schema=json.dumps(schema)
   )
   
   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')
   dataset_group_arn = response['datasetGroupArn']
   
   description = personalize.describe_dataset_group(datasetGroupArn = dataset_group_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 = 'datase_name',
       schemaArn = 'schema_arn',
       datasetGroupArn = 'dataset_group_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\$1dataset\$1import\$1job 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, 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',
       importMode = 'FULL'
   )
   
   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 3: Creare una soluzione
<a name="getting-started-python-create-solution"></a>

Dopo aver importato i dati, create una soluzione e una versione della soluzione come segue. La *soluzione* contiene le configurazioni per addestrare un modello e una *versione della soluzione* è un modello addestrato. 

1.  Crea una nuova soluzione con il codice seguente. Passate i seguenti parametri come parametri: `dataset_group_arn` da precedente, un nome per la soluzione e l'ARN per la ricetta User-Personalization-v 2 ()`arn:aws:personalize:::recipe/aws-user-personalization-v2`. Memorizza l'ARN della nuova soluzione per un uso successivo. 

   ```
   create_solution_response = personalize.create_solution(
     name='solution name', 
     recipeArn= 'arn:aws:personalize:::recipe/aws-user-personalization-v2', 
     datasetGroupArn = 'dataset group arn'
   )
   solution_arn = create_solution_response['solutionArn']
   print('solution_arn: ', solution_arn)
   ```

1. Crea una versione della soluzione con il codice seguente. Passa come parametro il `solution_arn` passaggio precedente. Il codice seguente crea una versione della soluzione. Durante l'addestramento, il codice utilizza l'[DescribeSolutionVersion](API_DescribeSolutionVersion.md)operazione per recuperare lo stato della versione della soluzione. Al termine della formazione, il metodo restituisce l'ARN della nuova versione della soluzione. Va archiviato per essere utilizzato in un secondo momento. 

   ```
   import time
   import json
   
   create_solution_version_response = personalize.create_solution_version(
       solutionArn = solution_arn
   )
   
   solution_version_arn = create_solution_version_response['solutionVersionArn']
   print(json.dumps(create_solution_version_response, indent=2))
   
   max_time = time.time() + 3*60*60 # 3 hours
   while time.time() < max_time:
       describe_solution_version_response = personalize.describe_solution_version(
           solutionVersionArn = solution_version_arn
       )
       status = describe_solution_version_response["solutionVersion"]["status"]
       print("SolutionVersion: {}".format(status))
       
       if status == "ACTIVE" or status == "CREATE FAILED":
           break
           
       time.sleep(60)
   ```

### Fase 4: creazione di una campagna
<a name="getting-started-python-deploy-solution"></a>

Dopo aver creato la versione della soluzione, distribuiscila con una campagna Amazon Personalize. Usa il codice seguente per creare una campagna che distribuisca la versione della tua soluzione. Passa i seguenti parametri come parametri: il`solution_version_arn`, e un nome per la campagna. Il metodo restituisce l'Amazon Resource Name (ARN) della tua nuova campagna. Va archiviato per essere utilizzato in un secondo momento.

```
response = personalize.create_campaign(
    name = 'campaign name',
    solutionVersionArn = 'solution version arn'
)

arn = response['campaignArn']

description = personalize.describe_campaign(campaignArn = arn)['campaign']
print('Name: ' + description['name'])
print('ARN: ' + description['campaignArn'])
print('Status: ' + description['status'])
```

### Passaggio 5: ottieni consigli
<a name="getting-started-python-get-recommendations"></a>

Dopo aver creato una campagna, puoi utilizzarla per ottenere raccomandazioni. Il codice seguente mostra come ottenere consigli da una campagna e stampare l'ID di ogni articolo consigliato. Passa l'ARN della campagna che hai creato nel passaggio precedente. Per l'ID utente, si passa l'ID di un utente ricavato dai dati di allenamento, ad esempio`123`.

```
response = personalizeRt.get_recommendations(
    campaignArn = 'Campaign ARN',
    userId = '123',
    numResults = 10
)

print("Recommended items")
for item in response['itemList']:
    print (item['itemId'])
```

## Come iniziare a usare i notebook Amazon Personalize APIs with Jupyter (IPython)
<a name="gs-jupyter-notebook"></a>

 [https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started](https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started) I taccuini ti guidano attraverso l'importazione di dati di formazione, la creazione di una soluzione, la creazione di una campagna e l'ottenimento di consigli utilizzando 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)