Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Obtención de segmentos de usuario con un trabajo de segmentos por lotes
<a name="creating-batch-seg-job"></a>

 Si utilizó una receta USER\$1SEGMENTATION, puede crear trabajos de segmentos por lotes para obtener segmentos de usuarios con la versión de su solución. Cada segmento de usuario se ordena en orden descendente en función de la probabilidad de que cada usuario interactúe con los elementos de su inventario. Según la receta, los datos de entrada deben ser una lista de elementos ([Receta Item-Affinity](item-affinity-recipe.md)) o atributos de elementos ([Receta Item-Attribute-Affinity](item-attribute-affinity-recipe.md)) en formato JSON. Puede crear un trabajo de segmento por lotes con la consola Amazon Personalize, el AWS Command Line Interface (AWS CLI) o AWS SDKs. 

 Cuando crea un trabajo de segmento por lotes, especifica las rutas de Amazon S3 a sus ubicaciones de entrada y salida. Amazon S3 se basa en prefijos. Si proporciona un prefijo para la ubicación de los datos de entrada, Amazon Personalize utilizará todos los archivos que coincidan con ese prefijo como datos de entrada. Por ejemplo, si proporciona `s3://amzn-s3-demo-bucket/folderName` y su bucket también tiene una carpeta con una ruta de `s3://amzn-s3-demo-bucket/folderName_test`, Amazon Personalize utiliza todos los archivos de ambas carpetas como datos de entrada. Para usar solo los archivos de una carpeta específica como datos de entrada, finalice la ruta de Amazon S3 con un delimitador de prefijo, como `/`: `s3://amzn-s3-demo-bucket/folderName/` Para obtener más información sobre cómo Amazon S3 organiza los objetos, consulte [Organizar, enumerar y trabajar con sus objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/organizing-objects.html). 

**Topics**
+ [Creación de un trabajo de segmento por lotes (consola)](#batch-segment-console)
+ [Creación de un trabajo de segmento por lotes (AWS CLI)](#batch-segment-cli)
+ [Creación de un trabajo de segmento por lotes (AWS SDKs)](#batch-segment-sdk)

## Creación de un trabajo de segmento por lotes (consola)
<a name="batch-segment-console"></a>

 Cuando haya completado [Preparación de los datos de entrada para las recomendaciones por lotes](batch-data-upload.md), estará listo para crear un trabajo de segmento por lotes. Este procedimiento supone que ya ha creado una solución y una versión de la solución (modelo entrenado) con una receta USER\$1SEGEMENTATION.

**Para obtener un trabajo de segmento por lotes (consola)**

1. Abre la consola Amazon Personalize en [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e inicia sesión en tu cuenta.

1. En la página **Grupo de conjuntos de datos**, elija su grupo de conjuntos de datos.

1. Elija **trabajos de inferencia por lotes** en el panel de navegación y, a continuación, **Crear trabajo de inferencia por lotes**.

1. En **Detalles del trabajo de segmento por lotes**, para **Nombre del trabajo de segmento por lotes**, especifique un nombre para su trabajo de segmento por lotes.

1. En **Solución**, elija la solución y, a continuación, elija el **ID de versión de la solución** que desee utilizar para generar las recomendaciones. Puede crear trabajos de segmentos por lotes solo si utilizó una receta USER\$1SEGEMENTATION. 

1. En **Número de usuarios**, si lo desea, especifique el número de usuarios que Amazon Personalize genera para cada segmento de usuarios. El valor predeterminado es 25. El máximo es de 5 millones.

1.  En **Origen de entrada**, especifique la ruta de Amazon S3 al archivo de entrada o utilice **Examinar S3** para elegir su bucket de Amazon S3.

   Utilice la siguiente sintaxis: **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json**

    Los datos de entrada deben tener el formato correcto para la receta que utiliza su solución. Para ver ejemplos de datos de entrada, consulte [Ejemplos de JSON de entrada y salida de trabajos de segmentos por lotes](prepare-input-data-user-segment.md#batch-segment-job-json-examples). 

1. En **Destino de salida**, especifique la ruta a su ubicación de salida o utilice **Examinar S3** para elegir su bucket de Amazon S3. Recomendamos que utilice una ubicación diferente para sus datos de salida (ya sea una carpeta o un bucket de Amazon S3 diferente).

    Utilice la siguiente sintaxis: **s3://amzn-s3-demo-bucket/<output folder name>/** 

1. En **Rol de IAM**, elija una de las opciones siguientes:
   +  Elija **Crear y usar un nuevo rol de servicio** e introduzca el **Nombre del rol de servicio** para crear un nuevo rol, o
   +  Si ya ha creado un rol con los permisos correctos, elija **Usar un rol de servicio existente** y elija el rol de IAM. 

    El rol que utilice debe tener acceso de lectura y escritura a sus buckets de entrada y salida de Amazon S3, respectivamente.

1.  Para **Configuración de filtro**, elija opcionalmente un filtro para aplicar un filtro a los segmentos de usuarios. Si el filtro utiliza parámetros de marcador de posición, asegúrese de que los valores de los parámetros estén incluidos en el JSON de entrada. Para obtener más información, consulte [Proporcionar valores de filtro en su JSON de entrada](filter-batch.md#providing-filter-values). 

1. Para **Etiquetas**, si lo desea, añada cualquier etiqueta. Para obtener más información acerca del etiquetado de recursos de Amazon Personalize, consulte [Etiquetado de recursos de Amazon Personalize](tagging-resources.md).

1.  Seleccione **Crear trabajo de segmento por lotes**. Se inicia la creación del trabajo de segmentos por lotes y aparece la página **Trabajos de inferencia por lotes** con la sección **Detalles del trabajo de inferencia por lotes** visible.

1.  Cuando el estado del trabajo de segmentos por lotes cambia a **Activo**, puede recuperar la salida del trabajo en el bucket de Amazon S3 de salida designado. El nombre del archivo de salida tendrá el formato `input-name.out`. 

## Creación de un trabajo de segmento por lotes (AWS CLI)
<a name="batch-segment-cli"></a>

Cuando haya completado [Preparación de los datos de entrada para las recomendaciones por lotes](batch-data-upload.md), estará listo para crear un trabajo de segmento por lotes con el siguiente código `create-batch-segment-job`. Especifique un nombre de trabajo, sustituya `Solution version ARN` por el nombre de recurso de Amazon (ARN) de la versión de su solución, y sustituya el `IAM service role ARN` por el ARN del rol de servicio de IAM que creó para Amazon Personalize durante la configuración. Este rol debe tener acceso de lectura y escritura a sus buckets de entrada y salida de Amazon S3, respectivamente. Para `num-results`, especifique el número de usuarios que desea que Amazon Personalize prediga para cada línea de datos de entrada. El valor predeterminado es 25. El máximo es de 5 millones. Si lo desea, proporcione un `filter-arn` para filtrar segmentos de usuarios. Si el filtro utiliza parámetros de marcador de posición, asegúrese de que los valores de los parámetros estén incluidos en el JSON de entrada. Para obtener más información, consulte [Filtrado de las recomendaciones por lotes y segmentos de usuarios (recursos personalizados)](filter-batch.md). 

Sustituya `S3 input path` y `S3 output path` por la ruta de Amazon S3 al archivo de entrada y a las ubicaciones de salida. Recomendamos que utilice una ubicación diferente para sus datos de salida (ya sea una carpeta o un bucket de Amazon S3 diferente). Utilice la siguiente sintaxis para las ubicaciones de entrada y salida: **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json** y **s3://amzn-s3-demo-bucket/<output folder name>/**. 

```
aws personalize create-batch-segment-job \
                --job-name Job name \
                --solution-version-arn Solution version ARN \
                --num-results The number of predicted users \
                --filter-arn Filter ARN \
                --job-input s3DataSource={path=s3://S3 input path} \
                --job-output s3DataDestination={path=s3://S3 output path} \
                --role-arn IAM service role ARN
{
   "batchSegmentJobArn": "arn:aws:personalize:us-west-2:acct-id:batch-segment-job/batchSegmentJobName"
}
```

## Creación de un trabajo de segmento por lotes (AWS SDKs)
<a name="batch-segment-sdk"></a>

Cuando haya completado [Preparación de los datos de entrada para las recomendaciones por lotes](batch-data-upload.md), estará listo para crear un trabajo de segmento por lotes con la operación `CreateBatchSegmentJob`. En el siguiente código se muestra cómo crear un trabajo de segmento por lotes. Asigne un nombre al trabajo, especifique el nombre de recurso de Amazon (ARN) de la versión de la solución que se utilizará, especifique el ARN para su rol de IAM de Amazon Personalize y especifique la ruta de Amazon S3 a sus ubicaciones de salida y archivo de entrada. Su rol de servicio de IAM debe tener acceso de lectura y escritura a los buckets de Amazon S3 de entrada y salida, respectivamente. 

Recomendamos que utilice una ubicación diferente para sus datos de salida (ya sea una carpeta o un bucket de Amazon S3 diferente). Utilice la siguiente sintaxis para las ubicaciones de entrada y salida: **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json** y **s3://amzn-s3-demo-bucket/<output folder name>/**. 

 Para `numResults`, especifique el número de usuarios que desea que Amazon Personalize prediga para cada línea de datos de entrada. El valor predeterminado es 25. El máximo es de 5 millones. Si lo desea, proporcione un `filterArn` para filtrar segmentos de usuarios. Si el filtro utiliza parámetros de marcador de posición, asegúrese de que los valores de los parámetros estén incluidos en el JSON de entrada. Para obtener más información, consulte [Filtrado de las recomendaciones por lotes y segmentos de usuarios (recursos personalizados)](filter-batch.md). 

------
#### [ SDK for Python (Boto3) ]

```
import boto3

personalize_rec = boto3.client(service_name='personalize')

personalize_rec.create_batch_segment_job (
    solutionVersionArn = "Solution version ARN",
    jobName = "Job name",
    numResults = 25,
    filterArn = "Filter ARN",
    roleArn = "IAM service role ARN",
    jobInput = 
       {"s3DataSource": {"path": "s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json"}},
    jobOutput = 
       {"s3DataDestination": {"path": "s3://amzn-s3-demo-bucket/<output folder name>/"}}
)
```

------
#### [ SDK for Java 2.x ]

```
public static String createBatchSegmentJob(PersonalizeClient personalizeClient,
                                                        String solutionVersionArn,
                                                        String jobName,
                                                        String filterArn,
                                                        int numResults,
                                                        String s3InputDataSourcePath,
                                                        String s3DataDestinationPath,
                                                        String roleArn,
                                                        String explorationWeight,
                                                        String explorationItemAgeCutOff) {

  long waitInMilliseconds = 60 * 1000;
  String status;
  String batchSegmentJobArn;

  try {
      // Set up data input and output parameters.
      S3DataConfig inputSource = S3DataConfig.builder()
              .path(s3InputDataSourcePath)
              .build();
      S3DataConfig outputDestination = S3DataConfig.builder()
              .path(s3DataDestinationPath)
              .build();

      BatchSegmentJobInput jobInput = BatchSegmentJobInput.builder()
              .s3DataSource(inputSource)
              .build();
      BatchSegmentJobOutput jobOutputLocation = BatchSegmentJobOutput.builder()
              .s3DataDestination(outputDestination)
              .build();


      CreateBatchSegmentJobRequest createBatchSegmentJobRequest = CreateBatchSegmentJobRequest.builder()
              .solutionVersionArn(solutionVersionArn)
              .filterArn(filterArn)
              .jobInput(jobInput)
              .jobOutput(jobOutputLocation)
              .jobName(jobName)
              .numResults(numResults)
              .roleArn(roleArn)
              .build();

      batchSegmentJobArn = personalizeClient.createBatchSegmentJob(createBatchSegmentJobRequest)
              .batchSegmentJobArn();
      DescribeBatchSegmentJobRequest describeBatchSegmentJobRequest = DescribeBatchSegmentJobRequest.builder()
              .batchSegmentJobArn(batchSegmentJobArn)
              .build();

      long maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;

      // wait until the batch segment job is complete.
      while (Instant.now().getEpochSecond() < maxTime) {

          BatchSegmentJob batchSegmentJob = personalizeClient
                  .describeBatchSegmentJob(describeBatchSegmentJobRequest)
                  .batchSegmentJob();

          status = batchSegmentJob.status();
          System.out.println("batch segment job status: " + status);

          if (status.equals("ACTIVE") || status.equals("CREATE FAILED")) {
              break;
          }
          try {
              Thread.sleep(waitInMilliseconds);
          } catch (InterruptedException e) {
              System.out.println(e.getMessage());
          }
      }
      return batchSegmentJobArn;

  } catch (PersonalizeException e) {
      System.out.println(e.awsErrorDetails().errorMessage());
  }
  return "";
}
```

------
#### [ SDK for JavaScript v3 ]

```
// Get service clients module and commands using ES6 syntax.
import { CreateBatchSegmentJobCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";

// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});

// Set the batch segment job's parameters.

export const createBatchSegmentJobParam = {
  jobName: "NAME",
  jobInput: {
    s3DataSource: {
      path: "INPUT_PATH",
    },
  },
  jobOutput: {
    s3DataDestination: {
      path: "OUTPUT_PATH",
    },
  },
  roleArn: "ROLE_ARN",
  solutionVersionArn: "SOLUTION_VERSION_ARN",
  numResults: 20,
};

export const run = async () => {
  try {
    const response = await personalizeClient.send(
      new CreateBatchSegmentJobCommand(createBatchSegmentJobParam),
    );
    console.log("Success", response);
    return response; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------

El procesamiento del trabajo por lotes puede tardar un tiempo en completarse. Puede comprobar el estado de un trabajo llamando a [DescribeBatchSegmentJob](API_DescribeBatchSegmentJob.md) y pasando un `batchSegmentJobArn` como el parámetro de entrada. También puede publicar todos los trabajos del segmento por lotes de Amazon Personalize de su AWS entorno llamando al teléfono[ListBatchSegmentJobs](API_ListBatchSegmentJobs.md).