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.

Obtener segmentos de usuarios con un trabajo de segmento por lotes

Si utilizó una SEGMENTATION receta USER _, 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) o atributos de los elementos (Receta Item-Attribute-Affinity) en JSON formato. 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.

Creación de un trabajo de segmento por lotes (consola)

Cuando haya completado Preparación de los datos de entrada para las recomendaciones por lotes, 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 SEGEMENTATION receta USER _.

Creación de un trabajo de segmento por lotes (AWS CLI)

Cuando haya completado Preparación de los datos de entrada para las recomendaciones por lotes, estará listo para crear un trabajo de segmento por lotes con el siguiente código create-batch-segment-job. Especifique un nombre de trabajo, Solution version ARN sustitúyalo por el nombre del recurso de Amazon (ARN) de la versión de la IAM service role ARN solución y sustitúyalo por el ARN del rol de IAM servicio 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 la entradaJSON. Para obtener más información, consulte Filtrado de las recomendaciones por lotes y segmentos de usuarios (recursos personalizados).

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)

Cuando haya completado Preparación de los datos de entrada para las recomendaciones por lotes, 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 del recurso de Amazon (ARN) de la versión de la solución que va a utilizar, especifique el ARN de su IAM función Amazon Personalize y especifique la ruta de Amazon S3 a las ubicaciones de los archivos de entrada y salida. Su rol IAM de servicio debe tener acceso de lectura y escritura a los buckets de entrada y salida de Amazon S3, 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 la entrada. JSON Para obtener más información, consulte Filtrado de las recomendaciones por lotes y segmentos de usuarios (recursos personalizados).

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: {         /* required */
    s3DataSource: {   /* required */
      path: 'INPUT_PATH', /* required */
      // kmsKeyArn: 'INPUT_KMS_KEY_ARN' /* optional */'
    }
  },
  jobOutput: {         /* required */
    s3DataDestination: {   /* required */
      path: 'OUTPUT_PATH', /* required */
      // kmsKeyArn: 'OUTPUT_KMS_KEY_ARN' /* optional */'
    }
  },
  roleArn: 'ROLE_ARN', /* required */
  solutionVersionArn: 'SOLUTION_VERSION_ARN', /* required */
  numResults: 20 /* optional */
};

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 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 llamandoListBatchSegmentJobs.