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.

# Ejemplos de código de inferencia en lotes
<a name="batch-inference-example"></a>

Los ejemplos de código de este capítulo muestran cómo crear un trabajo de inferencia en lotes, ver información sobre el mismo y detenerlo. En este ejemplo se utiliza el formato `InvokeModel` API. Para obtener información sobre el uso del formato de `Converse` API, consulte[Formateo y carga de los datos de la inferencia por lotes](batch-inference-data.md).

Seleccione un idioma para ver un ejemplo de código:

------
#### [ Python ]

Cree un archivo JSONL denominado {{abc.jsonl}} e incluya un objeto JSON para cada registro que contenga al menos el número mínimo de registros (consulte la sección **Número mínimo de registros por lote para el trabajo de inferencia**). {{{Model}}} [Cuotas para Amazon Bedrock](quotas.md) En este ejemplo, utilizará el modelo Anthropic Claude 3 Haiku. En el siguiente ejemplo se muestra el primer JSON de entrada del archivo:

```
{
    "recordId": "CALL0000001", 
    "modelInput": {
        "anthropic_version": "bedrock-2023-05-31", 
        "max_tokens": 1024,
        "messages": [ 
            { 
                "role": "user", 
                "content": [
                    {
                        "type": "text", 
                        "text": "Summarize the following call transcript: ..." 
                    } 
                ]
            }
        ]
    }
}
... 
# Add records until you hit the minimum
```

Cree un bucket de S3 llamado {{amzn-s3-demo-bucket-input}} y cargue el archivo en él. A continuación, cree un bucket de S3 llamado {{amzn-s3-demo-bucket-output}} para escribir sus archivos de salida. Ejecute el siguiente fragmento de código para enviar un trabajo y obtener el resultado {{jobArn}} de la respuesta:

```
import boto3

bedrock = boto3.client(service_name="bedrock")

inputDataConfig=({
    "s3InputDataConfig": {
        "s3Uri": "s3://amzn-s3-demo-bucket-input/abc.jsonl"
    }
})

outputDataConfig=({
    "s3OutputDataConfig": {
        "s3Uri": "s3://amzn-s3-demo-bucket-output/"
    }
})

response=bedrock.create_model_invocation_job(
    roleArn="arn:aws:iam::123456789012:role/MyBatchInferenceRole",
    modelId="anthropic.claude-3-haiku-20240307-v1:0",
    jobName="my-batch-job",
    inputDataConfig=inputDataConfig,
    outputDataConfig=outputDataConfig
)

jobArn = response.get('jobArn')
```

Devuelva la parte `status` del trabajo.

```
bedrock.get_model_invocation_job(jobIdentifier=jobArn)['status']
```

Enumere los trabajos de inferencia por lotes que. {{Failed}}

```
bedrock.list_model_invocation_jobs(
    maxResults=10,
    statusEquals="Failed",
    sortOrder="Descending"
)
```

Detenga el trabajo que inició.

```
bedrock.stop_model_invocation_job(jobIdentifier=jobArn)
```

------
#### [ Java ]

```
package com.amazon.aws.sample.bedrock.inference;

import software.amazon.awssdk.services.bedrock.BedrockClient;
import software.amazon.awssdk.services.bedrock.model.*;

public class BedrockBatchInference {
    private final BedrockClient bedrockClient = BedrockClient.create();

    public void createModelInvokeJobSampleCode() {

        CreateModelInvocationJobResponse response = bedrockClient.createModelInvocationJob(request -> request
                .modelId("anthropic.claude-haiku-4-5-20251001-v1:0")
                .jobName("unique-job-name")
                .roleArn("arn:aws:iam::123456789:role/bedrock-role")
                .clientRequestToken("client-token")
                .inputDataConfig(input -> input
                        .s3InputDataConfig(s3 -> s3
                                .s3Uri("s3://batch-input/abc.jsonl")
                                .s3InputFormat(S3InputFormat.JSONL)))
                .outputDataConfig(output -> output
                        .s3OutputDataConfig(s3 -> s3
                                .s3Uri("s3://batch-output/"))));

        System.out.println(response.jobArn());
    }

    public void getModelInvokeJobSampleCode() {
        GetModelInvocationJobResponse response = bedrockClient.getModelInvocationJob(request -> request
                .jobIdentifier("jobArn"));

        System.out.println(response.status());
    }

    public void listModelInvokeJobSampleCode() {
        ListModelInvocationJobsResponse response = bedrockClient.listModelInvocationJobs(request -> request
                .maxResults(10)
                .nameContains("matching-string"));

        response.invocationJobSummaries().forEach(job ->
                System.out.println(job.jobName() + ": " + job.status()));
    }

    public void stopModelInvokeJobSampleCode() {
        bedrockClient.stopModelInvocationJob(request -> request
                .jobIdentifier("jobArn"));
    }
}
```

------