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 do grupo de conjuntos de dados de domínio (SDK para JavaScript v3)
Este tutorial mostra como usar o AWS SDK para JavaScript v3 para criar um grupo de conjuntos de dados de domínio para o domínio VIDEO\$1ON\$1DEMAND. Neste tutorial, você cria um recomendador para o caso de uso *principais opções para você*.
Para ver o código usado neste tutorial no GitHub, consulte [Exemplos de código do Amazon Personalize para o SDK para JavaScript v3](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/personalize) no repositório *Exemplos de código do SDK AWS*.
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-js-sdk-domain-prerequisites)
+ [Tutorial](#domain-gs-js-domain-tutorial)
## Pré-requisitos
Este tutorial tem os seguintes pré-requisitos:
+ Conclua os [Pré-requisitos de conceitos básicos](gs-prerequisites.md) para configurar as permissões necessárias e criar os dados de treinamento. Se você também tiver concluído [Conceitos básicos do grupo de conjuntos de dados de domínio (console)](getting-started-console-domain.md), poderá reutilizar os mesmos dados de origem. Se estiver usando seus próprios dados de origem, verifique se eles estão formatados de acordo com os requisitos.
+ Configure as credenciais do SDK for JavaScript e AWS conforme especificado no procedimento [Configurar o SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html) no *Guia do desenvolvedor do AWS SDK para JavaScript*.
## Tutorial
Nas etapas a seguir, você instalará as dependências necessárias. Em seguida, você vai criar um grupo de conjuntos de dados, importar dados, criar um recomendador para o caso de uso *Principais opções para você* e receber recomendações.
Se você usar o Node.js, poderá executar cada amostra de código salvando-a como um arquivo JavaScript e depois executando `node `.
### Etapa 1: Instalar as dependências do Amazon Personalize
Depois de concluir as etapas obrigatórias, instale as seguintes dependências do Amazon Personalize:
+ @aws-sdk/client-personalize
+ @aws-sdk/client-personalize-runtime
+ @aws-sdk/client-personalize-events (opcional para este tutorial, mas obrigatório se você quiser [registrar eventos](recording-events.md) depois de criar seu recomendador)
Confira a seguir um exemplo de um arquivo `package.json` que você pode usar. Para instalar as dependências com o Node.js, navegue até a pasta onde você salvou o arquivo `package.json` e execute `npm install`.
```
{
"name": "personalize-js-project",
"version": "1.0.0",
"description": "personalize operations",
"type": "module",
"author": "Author Name ",
"license": "ISC",
"dependencies": {
"@aws-sdk/client-personalize": "^3.350.0",
"@aws-sdk/client-personalize-events": "^3.350.0",
"@aws-sdk/client-personalize-runtime": "^3.350.0",
"fs": "^0.0.1-security"
},
"compilerOptions": {
"resolveJsonModule": true,
"esModuleInterop": true
}
}
```
### Etapa 2: Criar clientes do Amazon Personalize
Depois de instalar as dependências, crie seus clientes do Amazon Personalize. Neste tutorial, as amostras de código pressupõem que você cria os clientes em um arquivo chamado `personalizeClients.js` armazenado em um diretório de nome `libs`.
Este é um exemplo de um arquivo `personalizeClient.js`.
```
import { PersonalizeClient } from "@aws-sdk/client-personalize";
import { PersonalizeRuntimeClient } from "@aws-sdk/client-personalize-runtime";
import { PersonalizeEventsClient } from "@aws-sdk/client-personalize-events";
// Set your AWS region.
const REGION = "region"; //e.g. "us-east-1"
const personalizeClient = new PersonalizeClient({ region: REGION});
const personalizeEventsClient = new PersonalizeEventsClient({ region: REGION});
const personalizeRuntimeClient = new PersonalizeRuntimeClient({ region: REGION});
export { personalizeClient, personalizeEventsClient, personalizeRuntimeClient };
```
### Etapa 3: Importar dados
Depois de criar seus clientes do Amazon Personalize, importe os dados históricos que você gerou ao concluir os [Pré-requisitos de conceitos básicos](gs-prerequisites.md). Para importar os dados históricos para o Amazon Personalize, faça o seguinte:
1. Salve o esquema Avro a seguir como um arquivo JSON no seu diretório de trabalho. Esse esquema corresponde às colunas no arquivo CSV que você criou ao concluir o [Como criar dados de treinamento (grupo de conjuntos de dados de domínio)](gs-prerequisites.md#gs-data-prep-domain).
```
{
"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"
}
```
1. Crie um esquema de domínio no Amazon Personalize com o código `createDomainSchema.js` a seguir. Substitua `SCHEMA_PATH` pelo caminho para o arquivo schema.json que você acabou de criar. Atualize o `createSchemaParam` para especificar um nome para o esquema e `domain` para especificar o `VIDEO_ON_DEMAND`.
```
// Get service clients module and commands using ES6 syntax.
import { CreateSchemaCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});
import fs from "node:fs";
const schemaFilePath = "SCHEMA_PATH";
let mySchema = "";
try {
mySchema = fs.readFileSync(schemaFilePath).toString();
} catch (err) {
mySchema = "TEST"; // for unit tests.
}
// Set the domain schema parameters.
export const createDomainSchemaParam = {
name: "NAME" /* required */,
schema: mySchema /* required */,
domain:
"DOMAIN" /* required for a domain dataset group, specify ECOMMERCE or VIDEO_ON_DEMAND */,
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateSchemaCommand(createDomainSchemaParam),
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
1. Crie um grupo de conjunto de dados de domínio no Amazon Personalize com o código `createDomainDatasetGroup.js` a seguir. Atualize `domainDatasetGroupParams` para especificar um nome para o grupo de conjunto de dados e especifique `VIDEO_ON_DEMAND` para `domain`.
```
// Get service clients module and commands using ES6 syntax.
import { CreateDatasetGroupCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});
// Set the domain dataset group parameters.
export const domainDatasetGroupParams = {
name: "NAME" /* required */,
domain:
"DOMAIN" /* required for a domain dsg, specify ECOMMERCE or VIDEO_ON_DEMAND */,
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateDatasetGroupCommand(domainDatasetGroupParams),
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
1. Crie um conjunto de dados de interações com itens no Amazon Personalize com o código `createDataset.js` a seguir. Atualize `createDatasetParam` para especificar o nome do recurso da Amazon (ARN) do grupo de conjuntos de dados e do esquema que você acabou de criar e nomear o conjunto de dados. Além disso, especifique `Interactions` para `datasetType`.
```
// Get service clients module and commands using ES6 syntax.
import { CreateDatasetCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});
// Set the dataset's parameters.
export const createDatasetParam = {
datasetGroupArn: "DATASET_GROUP_ARN" /* required */,
datasetType: "DATASET_TYPE" /* required */,
name: "NAME" /* required */,
schemaArn: "SCHEMA_ARN" /* required */,
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateDatasetCommand(createDatasetParam),
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
1. Importe seus dados com o código `createDatasetImportJob.js` a seguir. Atualize `datasetImportJobParam` para especificar o seguinte:
+ Especifique um nome para o trabalho e especifique o ARN do seu conjunto de dados de interações.
+ Para `dataLocation`, especifique o caminho do bucket do Amazon S3 (`s3://https://amzn-s3-demo-bucket.s3.region-code.amazonaws.com/folder name/ratings.csv`) onde você salvou os dados de treinamento.
+ Para `roleArn`, especifique o nome do recurso da Amazon para seu perfil de serviço do Amazon Personalize. Você criou esse perfil como parte de [Pré-requisitos de conceitos básicos](gs-prerequisites.md).
```
// Get service clients module and commands using ES6 syntax.
import { CreateDatasetImportJobCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});
// Set the dataset import job parameters.
export const datasetImportJobParam = {
datasetArn: "DATASET_ARN" /* required */,
dataSource: {
/* required */
dataLocation: "S3_PATH",
},
jobName: "NAME" /* required */,
roleArn: "ROLE_ARN" /* required */,
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateDatasetImportJobCommand(datasetImportJobParam),
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
### Etapa 4: Criar um recomendador
Depois que o trabalho de importação do conjunto de dados for concluído, você poderá criar um recomendador. Use o código `createRecommender.js` a seguir para obter uma recomendação. Atualize `createRecommenderParam` com o seguinte: especifique um nome para o recomendador, defina o ARN do seu grupo de conjuntos de dados e especifique `arn:aws:personalize:::recipe/aws-vod-top-picks` para `recipeArn`.
```
// Get service clients module and commands using ES6 syntax.
import { CreateRecommenderCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});
// Set the recommender's parameters.
export const createRecommenderParam = {
name: "NAME" /* required */,
recipeArn: "RECIPE_ARN" /* required */,
datasetGroupArn: "DATASET_GROUP_ARN" /* required */,
};
export const run = async () => {
try {
const response = await personalizeClient.send(
new CreateRecommenderCommand(createRecommenderParam),
);
console.log("Success", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
### Etapa 5: Obter recomendações
Depois de criar um recomendador, você poderá usá-lo para receber recomendações. Use o código `getRecommendations.js` a seguir para obter recomendações para um usuário. Atualize `getRecommendationsParam` para especificar o ARN do recomendador criado na etapa anterior e defina um ID de usuário (por exemplo, `123`).
```
// Get service clients module and commands using ES6 syntax.
import { GetRecommendationsCommand } from "@aws-sdk/client-personalize-runtime";
import { personalizeRuntimeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeRuntimeClient = new PersonalizeRuntimeClient({ region: "REGION"});
// Set the recommendation request parameters.
export const getRecommendationsParam = {
recommenderArn: "RECOMMENDER_ARN" /* required */,
userId: "USER_ID" /* required */,
numResults: 15 /* optional */,
};
export const run = async () => {
try {
const response = await personalizeRuntimeClient.send(
new GetRecommendationsCommand(getRecommendationsParam),
);
console.log("Success!", response);
return response; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```