As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Conceitos básicos (SDK para Python (Boto3))
<a name="getting-started-python"></a>

Este tutorial mostra como concluir o fluxo de trabalho completo do Amazon Personalize com o SDK para Python (Boto3). 

Depois de concluir este exercício, exclua os recursos que você criou para evitar cobranças desnecessárias. Para obter mais informações, consulte [Requisitos para excluir recursos do Amazon Personalize](deleting-resources.md). 

**Topics**
+ [

## Pré-requisitos
](#gs-sdk-prerequisites)
+ [

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

## Introdução ao uso do Amazon Personalize APIs com notebooks Jupyter (IPython)
](#gs-jupyter-notebook)

## Pré-requisitos
<a name="gs-sdk-prerequisites"></a>

Veja a seguir as etapas obrigatórias para usar os exemplos do Python neste guia:
+ Conclua [Pré-requisitos de conceitos básicos](gs-prerequisites.md) para configurar as permissões necessárias e criar os dados de treinamento. Se estiver usando seus próprios dados de origem, verifique se eles estão formatados de acordo com os requisitos.
+ Configure seu AWS SDK para Python (Boto3) ambiente conforme especificado em[Configurando o AWS SDKs](aws-personalize-set-up-sdks.md).

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

Nas etapas a seguir, você vai verificar seu ambiente e criar clientes do SDK para Python (Boto3) para o Amazon Personalize. Em seguida, importará dados, criará e implantará uma versão da solução com uma campanha e receberá recomendações.

### Etapa 1: verificar seu ambiente Python e criar clientes do boto3
<a name="gs-python-example"></a>

Depois de concluir as etapas obrigatórias, execute o seguinte exemplo de Python para confirmar que seu ambiente está configurado corretamente. Esse código também cria os clientes do boto3 do Amazon Personalize que serão usados neste tutorial. Se o seu ambiente estiver configurado corretamente, uma lista das fórmulas disponíveis será exibida e você poderá executar outros exemplos neste tutorial.

```
import boto3

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

response = personalize.list_recipes()

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

### Etapa 2: Importar dados
<a name="getting-started-python-import-dataset"></a>

Depois de criar seus clientes do boto3 do Amazon Personalize e verificar seu ambiente, importe os dados históricos que você gerou ao concluir [Pré-requisitos de conceitos básicos](gs-prerequisites.md). Para importar os dados históricos para o Amazon Personalize, faça o seguinte:

1. Use o código a seguir para criar um esquema no Amazon Personalize. Substitua `getting-started-schema` por um nome para o esquema. 

   ```
   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. Crie um grupo de conjuntos de dados com o seguinte código. Substitua `dataset group name` por um nome para o grupo de conjuntos de dados.

   ```
   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. Crie um conjunto de dados de interações com itens no novo grupo de conjuntos de dados com o código a seguir. Nomeie o conjunto de dados e informe `schema_arn` e `dataset_group_arn` das etapas anteriores.

   ```
   response = personalize.create_dataset(
       name = 'datase_name',
       schemaArn = 'schema_arn',
       datasetGroupArn = 'dataset_group_arn',
       datasetType = 'Interactions'
   )
   
   dataset_arn = response['datasetArn']
   ```

1. Importe seus dados com um trabalho de importação do conjunto de dados com o código a seguir. O código usa o método describe\$1dataset\$1import\$1job para rastrear o status do trabalho. 

   Envie as seguintes informações como parâmetros: um nome para o trabalho, o `dataset_arn` da etapa anterior, o caminho do bucket do Amazon S3 (`s3://bucket name/folder name/ratings.csv`) onde você salvou os dados de treinamento e o ARN do seu perfil de serviço de IAM. Você criou esse perfil como parte de [Pré-requisitos de conceitos básicos](gs-prerequisites.md). O Amazon Personalize precisa de permissão para acessar o bucket. Consulte [Como conceder permissão ao Amazon Personalize para acessar recursos do 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)
   ```

### Etapa 3: criar uma solução
<a name="getting-started-python-create-solution"></a>

Depois de importar os dados, crie uma solução e uma versão da solução conforme mostrado a seguir. A *solução* inclui as configurações para treinar um modelo, e uma *versão da solução* é um modelo treinado. 

1.  Crie uma nova solução com o código a seguir. Passe o seguinte como parâmetros: o `dataset_group_arn` anterior, um nome para a solução e o ARN para a receita User-Personalization-v 2 ()`arn:aws:personalize:::recipe/aws-user-personalization-v2`. Armazene o ARN da sua nova solução para uso posterior. 

   ```
   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. Crie uma versão da solução com o código a seguir. Passe como parâmetro o `solution_arn` da etapa anterior. Crie uma versão da solução com o código a seguir. Durante o treinamento, o código usa a operação [DescribeSolutionVersion](API_DescribeSolutionVersion.md) para recuperar o status da versão da solução. Quando o treinamento for concluído, o método retornará o ARN da sua nova versão da solução. Armazene-o para uso posterior. 

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

### Etapa 4: criar uma campanha
<a name="getting-started-python-deploy-solution"></a>

Depois de criar sua versão da solução, você poderá implantá-la com uma campanha do Amazon Personalize. Use o código a seguir para criar uma campanha que implanta sua versão da solução. Envie as seguintes informações como parâmetros: `solution_version_arn` e um nome para a campanha. O método retorna o nome do recurso da Amazon (ARN) do novo esquema. Armazene-o para uso posterior.

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

### Etapa 5: Obter recomendações
<a name="getting-started-python-get-recommendations"></a>

Depois de criar uma campanha, você pode usá-la para obter recomendações. O código a seguir mostra como obter recomendações a partir de uma campanha e exibir o ID de cada item recomendado. Envie o ARN da campanha que você criou na etapa anterior. Para ID de usuário, envie o ID de um usuário a partir dos dados de treinamento, como `123`.

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

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

## Introdução ao uso do Amazon Personalize APIs com notebooks Jupyter (IPython)
<a name="gs-jupyter-notebook"></a>

 Para começar a usar o Amazon Personalize com cadernos Jupyter, clone ou baixe uma série de cadernos encontrados na pasta [getting\$1started](https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started) do repositório de [amostras do Amazon Personalize](https://github.com/aws-samples/amazon-personalize-samples). Os cadernos mostram como importar dados de treinamento, criar uma solução e uma campanha e obter recomendações com o Amazon Personalize.

**nota**  
 Antes de começar a usar os cadernos, crie seu ambiente seguindo as etapas em [README.md](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/README.md)