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

# Ottenere segmenti di utenti con un processo di segmentazione in batch
<a name="creating-batch-seg-job"></a>

 Se hai utilizzato una ricetta USER\$1SEGMENTATION, puoi creare processi di segmentazione in batch per ottenere segmenti di utenti con la tua versione della soluzione. Ogni segmento di utenti è ordinato in ordine decrescente in base alla probabilità che ogni utente interagisca con gli articoli del tuo inventario. A seconda della ricetta, i dati di input devono essere un elenco di elementi ([Ricetta Item-Affinity](item-affinity-recipe.md)) o attributi degli articoli ([Item-Attribute-Affinity ricetta](item-attribute-affinity-recipe.md)) in formato JSON. Puoi creare un processo di segmentazione in batch con la console Amazon Personalize, il AWS Command Line Interface (AWS CLI) o. AWS SDKs 

 Quando crei un processo di segmentazione in batch, specifichi i percorsi di Amazon S3 verso le posizioni di input e output. Amazon S3 è basato su prefissi. Se fornisci un prefisso per la posizione dei dati di input, Amazon Personalize utilizza tutti i file che corrispondono a quel prefisso come dati di input. Ad esempio, se fornisci `s3://amzn-s3-demo-bucket/folderName` e il tuo bucket ha anche una cartella con un percorso di`s3://amzn-s3-demo-bucket/folderName_test`, Amazon Personalize utilizza tutti i file in entrambe le cartelle come dati di input. [Per utilizzare solo i file all'interno di una cartella specifica come dati di input, termina il percorso di Amazon S3 con un delimitatore di prefisso, ad esempio`/`: `s3://amzn-s3-demo-bucket/folderName/` Per ulteriori informazioni su come Amazon S3 organizza gli oggetti, consulta Organizzazione, elenco e utilizzo degli oggetti.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/organizing-objects.html) 

**Topics**
+ [Creazione di un processo di segmentazione in batch (console)](#batch-segment-console)
+ [Creazione di un processo di segmentazione in batch ()AWS CLI](#batch-segment-cli)
+ [Creazione di un processo di segmentazione in batch ()AWS SDKs](#batch-segment-sdk)

## Creazione di un processo di segmentazione in batch (console)
<a name="batch-segment-console"></a>

 Dopo aver completato[Preparazione dei dati di input per i consigli sui batch](batch-data-upload.md), sei pronto per creare un processo di segmentazione in batch. Questa procedura presuppone che siano già state create una soluzione e una versione della soluzione (modello addestrato) con una ricetta USER\$1SEGEMENTATION.

**Per iniziare, crea un processo di segmentazione in batch (console)**

1. Apri la console Amazon Personalize a [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e accedi al tuo account.

1. Nella pagina del gruppo **Datasets, scegli il tuo gruppo** di set di dati.

1. Scegli processi di **segmentazione in batch** nel riquadro di navigazione, quindi scegli **Crea processo di segmento in batch**.

1. Nei **dettagli del processo di segmentazione** in **batch, per Nome del processo di segmentazione** in batch, specifica un nome per il processo di segmentazione in batch.

1. Per **Soluzione**, scegli la soluzione, quindi scegli l'**ID della versione della soluzione** che desideri utilizzare per generare i consigli. Puoi creare lavori di segmentazione in batch solo se hai utilizzato una ricetta USER\$1SEGEMENTATION. 

1. Per **Numero di utenti**, specifica facoltativamente il numero di utenti che Amazon Personalize genera per ogni segmento di utenti. Il valore predefinito è 25. Il massimo è 5 milioni.

1.  Per la **fonte di input**, specifica il percorso Amazon S3 del tuo file di input o usa **Browse S3** per scegliere il tuo bucket Amazon S3.

   Usa la seguente sintassi: **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json**

    I dati di input devono essere nel formato corretto per la ricetta utilizzata dalla soluzione. Per esempi di dati di input, vedere[Esempi JSON di input e output di processi di segmentazione in batch](prepare-input-data-user-segment.md#batch-segment-job-json-examples). 

1. Per **Output destination**, specifica il percorso verso la tua posizione di output o usa **Browse S3** per scegliere il tuo bucket Amazon S3. Ti consigliamo di utilizzare una posizione diversa per i dati di output (una cartella o un altro bucket Amazon S3).

    Usa la seguente sintassi: **s3://amzn-s3-demo-bucket/<output folder name>/** 

1. Per il **ruolo IAM**, scegli una delle seguenti opzioni:
   +  Scegli **Crea e usa un nuovo ruolo di servizio** e inserisci il **nome del ruolo di servizio** per creare un nuovo ruolo, oppure
   +  Se hai già creato un ruolo con le autorizzazioni corrette, scegli **Usa un ruolo di servizio esistente e scegli il ruolo** IAM. 

    Il ruolo che utilizzi deve disporre dell'accesso in lettura e scrittura rispettivamente ai bucket Amazon S3 di input e output.

1.  Per la **configurazione del filtro**, scegli facoltativamente un filtro per applicare un filtro ai segmenti di utenti. Se il filtro utilizza parametri segnaposto, assicurati che i valori dei parametri siano inclusi nel codice JSON di input. Per ulteriori informazioni, consulta [Fornire valori di filtro nel codice JSON di input](filter-batch.md#providing-filter-values). 

1. Per i **tag, aggiungi** facoltativamente qualsiasi tag. Per ulteriori informazioni sull'etichettatura delle risorse Amazon Personalize, consulta. [Etichettare le risorse di Amazon Personalize](tagging-resources.md)

1.  Scegli **Crea un processo di segmentazione in batch**. La creazione del processo del segmento **Batch inizia e viene visualizzata la pagina Lavori del segmento** **Batch con la sezione Dettagli del processo del segmento Batch**.

1.  Quando lo stato del processo di segmento batch diventa **Attivo**, puoi recuperare l'output del lavoro dal bucket di output designato di Amazon S3. Il nome del file di output sarà nel formato `input-name.out`. 

## Creazione di un processo di segmentazione in batch ()AWS CLI
<a name="batch-segment-cli"></a>

Dopo aver completato[Preparazione dei dati di input per i consigli sui batch](batch-data-upload.md), siete pronti per creare un processo di segmentazione in batch utilizzando il `create-batch-segment-job` codice seguente. Specificate un nome di lavoro, sostituitelo `Solution version ARN` con l'Amazon Resource Name (ARN) della versione della soluzione e sostituitelo `IAM service role ARN` con l'ARN del ruolo di servizio IAM che avete creato per Amazon Personalize durante la configurazione. Questo ruolo deve avere accesso in lettura e scrittura rispettivamente ai bucket Amazon S3 di input e output. Per `num-results` specificare il numero di utenti che desideri che Amazon Personalize preveda per ogni riga di dati di input. Il valore predefinito è 25. Il massimo è 5 milioni. Facoltativamente, fornisci un file `filter-arn` per filtrare i segmenti di utenti. Se il filtro utilizza parametri segnaposto, assicurati che i valori dei parametri siano inclusi nel codice JSON di input. Per ulteriori informazioni, consulta [Filtraggio dei consigli sui batch e dei segmenti di utenti (risorse personalizzate)](filter-batch.md). 

Sostituisci `S3 input path` e `S3 output path` con il percorso Amazon S3 verso i file di input e le posizioni di output. Ti consigliamo di utilizzare una posizione diversa per i dati di output (una cartella o un altro bucket Amazon S3). Usa la seguente sintassi per le posizioni di input e output: and. **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json** **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"
}
```

## Creazione di un processo di segmentazione in batch ()AWS SDKs
<a name="batch-segment-sdk"></a>

Dopo aver completato[Preparazione dei dati di input per i consigli sui batch](batch-data-upload.md), è possibile creare un processo di segmentazione in batch con l'`CreateBatchSegmentJob`operazione. Il codice seguente mostra come creare un processo di segmentazione in batch. Assegna un nome al lavoro, specifica l'Amazon Resource Name (ARN) della versione della soluzione da utilizzare, specifica l'ARN per il tuo ruolo Amazon Personalize IAM e specifica il percorso Amazon S3 verso i file di input e le posizioni di output. Il tuo ruolo di servizio IAM deve avere accesso in lettura e scrittura rispettivamente ai bucket Amazon S3 di input e output. 

Ti consigliamo di utilizzare una posizione diversa per i dati di output (una cartella o un altro bucket Amazon S3). Usa la seguente sintassi per le posizioni di input e output: and. **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json** **s3://amzn-s3-demo-bucket/<output folder name>/** 

 Per`numResults`, specifica il numero di utenti che desideri che Amazon Personalize preveda per ogni riga di dati di input. Il valore predefinito è 25. Il massimo è 5 milioni. Facoltativamente, fornisci un file `filterArn` per filtrare i segmenti di utenti. Se il filtro utilizza parametri segnaposto, assicurati che i valori dei parametri siano inclusi nel codice JSON di input. Per ulteriori informazioni, consulta [Filtraggio dei consigli sui batch e dei segmenti di utenti (risorse personalizzate)](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();
```

------

L'elaborazione dell'attività batch potrebbe richiedere del tempo per il completamento. È possibile controllare lo stato di un'attività richiamando [DescribeBatchSegmentJob](API_DescribeBatchSegmentJob.md) e passando `batchSegmentJobArn` come parametro di input. Puoi anche elencare tutti i lavori di segmentazione in batch di Amazon Personalize nel tuo AWS ambiente chiamando. [ListBatchSegmentJobs](API_ListBatchSegmentJobs.md)