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á.
# Ajuste modelos de peso aberto usando -compatible OpenAI APIs
O Amazon Bedrock fornece endpoints de API OpenAI compatíveis para ajustar os modelos básicos. Esses endpoints permitem que você use ferramentas familiares para criar, monitorar OpenAI SDKs e gerenciar trabalhos de ajuste fino com os modelos Amazon Bedrock. Esta página destaca o uso deles APIs para o ajuste fino do reforço.
## Capacidades gerais
+ **Carregar arquivos de treinamento** — Use a API Files para carregar e gerenciar dados de treinamento para trabalhos de ajuste fino
+ **Crie tarefas de ajuste fino — Comece a ajustar tarefas** com dados de treinamento personalizados e funções de recompensa
+ **Listar e recuperar trabalhos** — Visualize todos os trabalhos de ajuste fino e obtenha informações detalhadas sobre trabalhos específicos
+ **Monitore eventos de trabalho** — acompanhe o progresso do ajuste fino por meio de registros de eventos detalhados
+ **Pontos de verificação de acesso — Recupere pontos** de verificação do modelo intermediário criados durante o treinamento
+ **Inferência imediata — Após a conclusão do ajuste fino, use o modelo ajustado resultante para inferência** sob demanda por meio do OpenAI compatível com o Amazon Bedrock (API de respostas/preenchimentos de bate-papo) sem etapas adicionais de implantação APIs
+ **Fácil migração** — Compatível com as bases de código OpenAI SDK existentes
## Fluxo de trabalho de reforço e ajuste fino para modelos de peso aberto
Antes de fazer o ajuste fino, certifique-se de ter os pré-requisitos, pois o Amazon Bedrock precisa de permissões específicas para criar e gerenciar o processo de ajuste fino. Para obter informações abrangentes sobre segurança e permissões, consulte[Acesso e segurança para modelos de peso aberto](rft-open-weight-access-security.md).
Execute o ajuste fino do reforço para modelos de peso aberto em 5 etapas:
1. **Carregar conjunto de dados de treinamento** — Use a API de arquivos para fazer upload de solicitações no formato necessário (por exemplo, JSONL) com o objetivo de “ajuste fino” como reforço e ajuste fino do conjunto de dados de treinamento. Para obter mais informações, consulte [Prepare dados para modelos de peso aberto](rft-prepare-data-open-weight.md).
1. **Configurar a função de recompensa** — defina um avaliador para pontuar as respostas do modelo com base na exatidão, estrutura, tom ou outros objetivos usando as funções Lambda. Para obter mais informações, consulte [Configurando funções de recompensa para modelos de peso aberto](reward-functions-open-weight.md).
1. **Crie um trabalho de ajuste fino — Inicie o trabalho** de ajuste fino de reforço usando a API OpenAI compatível especificando o modelo básico, o conjunto de dados, a função de recompensa e outras configurações opcionais, como hiperparâmetros. Para obter mais informações, consulte [Crie um trabalho de ajuste fino](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job).
1. **Monitore o progresso do treinamento** — Acompanhe o status do trabalho, os eventos e as métricas de treinamento usando os trabalhos de ajuste fino. APIs Para obter mais informações, consulte [Listar eventos de ajuste fino](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Acesse os pontos de verificação do modelo intermediário para avaliar o desempenho em diferentes estágios de treinamento, consulte[Listar pontos de verificação de ajuste fino](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints).
1. **Execute inferência** — Use o ID do modelo ajustado diretamente para inferência por meio de respostas ou conclusões de bate-papo compatíveis com o Amazon Bedrock. OpenAI APIs Para obter mais informações, consulte [Execute inferência com um modelo ajustado](fine-tuning-openai-job-create.md#fine-tuning-openai-inference).
## Regiões e endpoints compatíveis
A tabela a seguir mostra os modelos básicos e as regiões que oferecem suporte a ajustes APIs finos OpenAI compatíveis:
**Modelos e regiões OpenAI compatíveis para ajustes finos compatíveis APIs**
| Fornecedor | Modelo | ID do modelo | Nome da região | Região | Endpoint |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | Oeste dos EUA (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
| Qwen | Qwen3 32B | qwen.qwen3-32b | Oeste dos EUA (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
# Acesso e segurança para modelos de peso aberto
Antes de começar o ajuste fino de reforço (RFT), certifique-se de entender que tipo de acesso o Amazon Bedrock precisa para operações específicas de RFT. O RFT requer permissões adicionais além do ajuste fino padrão devido aos seus recursos de execução da função de recompensa.
## Pré-requisitos
Antes de usar o ajuste fino OpenAI compatível com o Amazon Bedrock APIs, certifique-se de ter o seguinte:
1. Uma AWS conta com permissões apropriadas para acessar o Amazon Bedrock
1. **Autenticação** — Você pode se autenticar usando:
+ Chave de API Amazon Bedrock (necessária para o OpenAI SDK e disponível para solicitações HTTP)
+ AWS credenciais (com suporte para solicitações HTTP)
**nota**
[Se você estiver usando chaves de API de curto e longo prazo do Amazon Bedrock, certifique-se de que sua função tenha acesso às seguintes permissões de política do IAM: e Role. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions)
1. **OpenAISDK (opcional)** — Instale o SDK do OpenAI Python se estiver usando solicitações baseadas em SDK.
1. **Variáveis de ambiente** — Defina as seguintes variáveis de ambiente:
+ `OPENAI_API_KEY`— Defina sua chave de API Amazon Bedrock
+ `OPENAI_BASE_URL`— Defina como o endpoint Amazon Bedrock da sua região (por exemplo,) `https://bedrock-mantle.us-west-2.api.aws/v1`
Para obter mais informações, consulte [API de respostas](bedrock-mantle.md#bedrock-mantle-responses).
1. **Dados de treinamento** formatados como arquivos JSONL com a finalidade. `fine-tune` Para obter mais informações, consulte [Prepare dados para modelos de peso aberto](rft-prepare-data-open-weight.md).
## Permissões do Lambda para funções de recompensa
Você deve adicionar permissões de invocação do Lambda. Veja a seguir um exemplo de política que você pode usar:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
Você também pode usar modelos hospedados pelo Amazon Bedrock como juízes para configurar funções de recompensa. Você precisará adicionar permissões específicas para invocar modelos básicos na função de execução do Lambda. Em sua função lambda, você pode configurar essas políticas gerenciadas LLMs para avaliação. Consulte [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html).
Veja a seguir um exemplo para invocar os modelos da fundação Amazon Bedrock como juiz usando a API Invoke:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
# Prepare dados para modelos de peso aberto
Ao ajustar modelos de peso aberto com ajuste fino de reforço usando compatibilidade com OpenAI, forneça dados de treinamento trazendo seus próprios APIs prompts no formato JSONL com essa finalidade. `fine-tune`
## Formato e requisitos dos dados de treinamento
Os dados de treinamento devem seguir o formato de conclusão de bate-papo do OpenAI com exemplos de 100 a 20 mil. Cada exemplo de treinamento contém:
+ `messages`: nesse campo, inclua a função de usuário, sistema ou assistente contendo o prompt de entrada fornecido ao modelo.
+ `reference_answer`: nesse campo, ele deve conter o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade.
+ [Opcional] Você pode adicionar campos usados pelo avaliador Lambda para avaliação.
**Requisitos:**
+ Formato JSONL com prompts no formato de conclusão de chat OpenAI (um prompt por linha)
+ O objetivo deve ser definido como `fine-tune`
+ Um mínimo de 100 registros no conjunto de dados de treinamento
+ O Amazon Bedrock valida automaticamente o formato do conjunto de dados de treinamento
------
#### [ Example: General question-answering ]
```
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
role": "user",
"content": "What is machine learning?"}
],
"reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed."
}
```
------
#### [ Example: Math problem ]
```
{
"id": "sample-001",
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
------
## API de arquivos
Você pode usar a API de arquivos compatível com OpenAI para carregar seus dados de treinamento para trabalhos de ajuste fino. Os arquivos são armazenados com segurança no Amazon Bedrock e usados na criação de trabalhos de ajuste fino. Para obter detalhes completos da API, consulte a [documentação de OpenAI Arquivos](https://platform.openai.com/docs/api-reference/files).
### Carregar arquivo de treinamento
Para fazer o upload de um arquivo de treinamento, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Upload training file
with open(TRAINING_FILE_PATH, 'rb') as f:
file_response = client.files.create(
file=f,
purpose='fine-tune'
)
# Store file ID for next steps
training_file_id = file_response.id
print(f"✅ Training file uploaded successfully: {training_file_id}")
```
------
#### [ HTTP request ]
Faça uma solicitação POST para`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-F purpose="fine-tune" \
-F file="@training_data.jsonl"
```
------
### Recuperar detalhes do arquivo
Para recuperar detalhes sobre um arquivo específico, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Retrieve file details
file_details = client.files.retrieve(training_file_id)
# Print raw response
print(json.dumps(file_details.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Faça uma solicitação GET para`/v1/files/{file_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Listar arquivos
Para listar os arquivos enviados, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List files
files_response = client.files.list(purpose='fine-tune')
# Print raw response
print(json.dumps(files_response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Faça uma solicitação GET para`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Excluir arquivo
Para excluir um arquivo, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Delete file
delete_response = client.files.delete(training_file_id)
```
------
#### [ HTTP request ]
Faça uma solicitação DELETE para`/v1/files/{file_id}`:
```
curl -X DELETE https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Características dos dados de treinamento efetivos
Dados efetivos de treinamento de RFT requerem três características principais:
+ **Clareza e consistência** — use instruções claras e inequívocas com formatação consistente. Evite rótulos contraditórios, instruções ambíguas ou respostas de referência conflitantes que enganem o treinamento.
+ **Diversidade** — inclua formatos de entrada variados, casos extremos e níveis de dificuldade que refletem os padrões de uso da produção em diferentes tipos e cenários de usuários.
+ **Funções de recompensa eficientes** — Crie funções que sejam executadas rapidamente (segundos, não minutos), que se paralelizem e retornem pontuações consistentes para um treinamento econômico. AWS Lambda
## Propriedades adicionais
O formato de dados RFT oferece suporte a campos personalizados além dos requisitos principais do esquema (`messages`e`reference_answer`). Essa flexibilidade permite que você adicione quaisquer dados adicionais que sua função de recompensa precise para uma avaliação adequada.
**nota**
Você não precisa configurar isso em sua receita. O formato de dados suporta inerentemente campos adicionais. Basta incluí-los em seus dados de treinamento JSON e eles serão passados para sua função de recompensa em `metadata` campo.
**Propriedades adicionais comuns**
+ `task_id`— Identificador exclusivo para rastreamento
+ `difficulty_level`— Indicador de complexidade do problema
+ `domain`— Área temática ou categoria
+ `expected_reasoning_steps`— Número de etapas na solução
Esses campos adicionais são passados para sua função de recompensa durante a avaliação, permitindo uma lógica de pontuação sofisticada adaptada ao seu caso de uso específico.
**Exemplos com propriedades adicionais**
------
#### [ Chemistry problem ]
```
{
"id": "chem-001",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
}
],
"reference_answer": {
"donor_bond_counts": 2,
"acceptor_bond_counts": 4
}
}
```
O `reference_answer` campo contém o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade.
------
#### [ Math problem with metadata ]
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
------
# Configurando funções de recompensa para modelos de peso aberto
As funções de recompensa avaliam a qualidade da resposta e fornecem sinais de feedback para o treinamento do modelo. Você pode configurar funções de recompensa usando funções personalizadas do Lambda. Escolha a abordagem que corresponda aos requisitos da sua tarefa.
## Funções personalizadas do Lambda para avaliação de recompensas
Você pode configurar funções de recompensa usando funções personalizadas do Lambda. Em sua função Lambda, você tem flexibilidade na forma como implementa a lógica de avaliação:
+ **Tarefas objetivas** — Para tarefas objetivas, como geração de código ou raciocínio matemático, use avaliadores baseados em regras verificáveis que verifiquem a exatidão em relação a padrões ou casos de teste conhecidos.
+ Tarefas **subjetivas — Para tarefas** subjetivas, como acompanhamento de instruções ou interações com chatbots, chame os modelos da Amazon Bedrock Foundation como juízes em sua função Lambda para avaliar a qualidade da resposta com base em seus critérios.
Sua função Lambda pode implementar lógica complexa, integrar componentes externos APIs, realizar cálculos em várias etapas ou combinar vários critérios de avaliação, dependendo dos requisitos de sua tarefa.
**nota**
Ao usar funções personalizadas do Lambda:
Aumente o tempo limite do Lambda do padrão de 3 segundos para o máximo 15 minutos para avaliações complexas.
A função de execução do Lambda precisa de permissões para invocar a função Lambda, conforme descrito em. [Permissões do Lambda para funções de recompensa](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions)
## Detalhes da implementação da função Lambda
Ao implementar funções personalizadas de recompensa do Lambda, sua função deve aceitar e retornar dados no formato a seguir.
------
#### [ Input structure ]
```
[{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
"metadata": {
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_key": "sample-001"
}
}]
```
------
#### [ Output structure ]
```
[{
"id": "123",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "accuracy",
"value": 0.9,
"type": "Reward"
},
{
"name": "policy_compliance",
"value": 0.8,
"type": "Metric"
}
]
}]
```
------
**Diretrizes de design**
+ **Classifique as respostas** — Dê à melhor resposta uma pontuação claramente mais alta
+ **Use verificações consistentes** — Avalie a conclusão da tarefa, a aderência ao formato, a segurança e a duração razoável
+ **Mantenha o escalonamento estável** — mantenha as pontuações normalizadas e não exploráveis
# Crie e gerencie trabalhos de ajuste fino para modelos de peso aberto usando o OpenAI APIs
O trabalho de ajuste fino compatível com OpenAI APIs permite que você crie, monitore e gerencie trabalhos de ajuste fino. Esta página destaca o uso deles APIs para o ajuste fino do reforço. Para obter detalhes completos da API, consulte a documentação [OpenAIde ajuste fino](https://platform.openai.com/docs/api-reference/fine-tuning).
## Crie um trabalho de ajuste fino
Cria um trabalho de ajuste fino que inicia o processo de criação de um novo modelo a partir de um determinado conjunto de dados. Para obter detalhes completos da API, consulte a documentação sobre como [OpenAIcriar trabalhos de ajuste fino](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create).
### Exemplos
Para criar um trabalho de ajuste fino com o método RFT, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Create fine-tuning job with RFT method
job_response = client.fine_tuning.jobs.create(
model=MODEL_ID,
training_file=training_file_id,
# Suffix field is not supported so commenting for now.
# suffix="rft-example", # Optional: suffix for fine-tuned model name
extra_body={
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": "arn:aws:lambda:us-west-2:123456789012:function:my-reward-function" # Replace with your Lambda ARN
}
},
"hyperparameters": {
"n_epochs": 1, # Number of training epochs
"batch_size": 4, # Batch size
"learning_rate_multiplier": 1.0 # Learning rate multiplier
}
}
}
}
)
# Store job ID for next steps
job_id = job_response.id
print({job_id})
```
------
#### [ HTTP request ]
Faça uma solicitação POST para`/v1/fine_tuning/jobs`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"training_file": "file-abc123",
"model": "gpt-4o-mini",
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": "arn:aws:lambda:us-west-2:123456789012:function:my-grader"
}
},
"hyperparameters": {
"n_epochs": 1,
"batch_size": 4,
"learning_rate_multiplier": 1.0
}
}
}
}'
```
------
## Listar eventos de ajuste fino
Lista eventos para um trabalho de ajuste fino. Eventos de ajuste fino fornecem informações detalhadas sobre o progresso do seu trabalho, incluindo métricas de treinamento, criação de pontos de verificação e mensagens de erro. Para obter detalhes completos da API, consulte a documentação da [OpenAILista de eventos de ajuste fino](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events).
### Exemplos
Para listar eventos de ajuste fino, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List fine-tuning events
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id="ftjob-abc123",
limit=50
)
for event in events.data:
print(f"[{event.created_at}] {event.level}: {event.message}")
if event.data:
print(f" Metrics: {event.data}")
```
------
#### [ HTTP request ]
Faça uma solicitação GET para`/v1/fine_tuning/jobs/{fine_tuning_job_id}/events`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=50
```
------
Os eventos incluem informações como:
+ Mensagens iniciadas e concluídas do treinamento
+ Notificações de criação de pontos de verificação
+ Métricas de treinamento (perda, precisão) em cada etapa
+ Mensagens de erro se o trabalho falhar
Para paginar todos os eventos, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Paginate through all events
all_events = []
after = None
while True:
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id="ftjob-abc123",
limit=100,
after=after
)
all_events.extend(events.data)
if not events.has_more:
break
after = events.data[-1].id
```
------
#### [ HTTP request ]
Faça várias solicitações GET com o `after` parâmetro:
```
# First request
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100
# Subsequent requests with 'after' parameter
curl "https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100&after=ft-event-abc123"
```
------
## Recupere o trabalho de ajuste fino
Obtenha informações detalhadas sobre um trabalho de ajuste fino. Para obter detalhes completos da API, consulte a documentação do trabalho de [ajuste fino do OpenAI Retrieve](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve).
### Exemplos
Para recuperar detalhes específicos do trabalho, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Retrieve specific job details
job_details = client.fine_tuning.jobs.retrieve(job_id)
# Print raw response
print(json.dumps(job_details.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Faça uma solicitação GET para`/v1/fine_tuning/jobs/{fine_tuning_job_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Listar trabalhos de ajuste fino
Lista os trabalhos de ajuste fino da sua organização com suporte à paginação. Para obter detalhes completos da API, consulte a documentação da [OpenAILista de trabalhos de ajuste fino](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list).
### Exemplos
Para listar trabalhos de ajuste fino com limite e paginação, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List fine-tuning jobs with limit and pagination
response = client.fine_tuning.jobs.list(
limit=20 # Maximum number of jobs to return
)
# Print raw response
print(json.dumps(response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Faça uma solicitação GET para`/v1/fine_tuning/jobs`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs?limit=20 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Cancelar o trabalho de ajuste fino
Cancela um trabalho de ajuste fino que está em andamento. Depois de cancelado, o trabalho não pode ser retomado. Para obter detalhes completos da API, consulte a documentação do [trabalho de ajuste fino do OpenAI Cancelamento](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel).
### Exemplos
Para cancelar um trabalho de ajuste fino, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Cancel fine-tuning job
cancel_response = client.fine_tuning.jobs.cancel("ftjob-abc123")
print(f"Job ID: {cancel_response.id}")
print(f"Status: {cancel_response.status}") # Should be "cancelled"
```
------
#### [ HTTP request ]
Faça uma solicitação POST para`/v1/fine_tuning/jobs/{fine_tuning_job_id}/cancel`:
```
curl -X POST https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/cancel \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Listar pontos de verificação de ajuste fino
Lista os pontos de verificação para um trabalho de ajuste fino. Os pontos de verificação são instantâneos de modelos intermediários criados durante o ajuste fino que podem ser usados para inferência para avaliar o desempenho em diferentes estágios de treinamento. Para obter mais informações, consulte a documentação de [OpenAIList fine-tuning checkpoints](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list).
### Exemplos
Para listar os pontos de verificação de um trabalho de ajuste fino, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List checkpoints for a fine-tuning job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id="ftjob-abc123",
limit=10
)
for checkpoint in checkpoints.data:
print(f"Checkpoint ID: {checkpoint.id}")
print(f"Step: {checkpoint.step_number}")
print(f"Model: {checkpoint.fine_tuned_model_checkpoint}")
print(f"Metrics: {checkpoint.metrics}")
print("---")
```
------
#### [ HTTP request ]
Faça uma solicitação GET para`/v1/fine_tuning/jobs/{fine_tuning_job_id}/checkpoints`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/checkpoints?limit=10
```
------
Cada ponto de verificação inclui:
+ **ID do ponto de verificação** — Identificador exclusivo do ponto de verificação
+ **Número da etapa** — Etapa de treinamento na qual o ponto de verificação foi criado
+ **Ponto de verificação do** modelo — identificador do modelo que pode ser usado para inferência
+ **Métricas** — perda de validação e precisão neste ponto de verificação
Para usar um modelo de ponto de verificação para inferência, escolha a guia do seu método preferido e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Test inference with a checkpoint
response = client.chat.completions.create(
model=checkpoint.fine_tuned_model_checkpoint,
messages=[{"role": "user", "content": "What is AI?"}],
max_tokens=100
)
print(response.choices[0].message.content)
```
------
#### [ HTTP request ]
Faça uma solicitação POST para`/v1/chat/completions`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom:7p4lURel:ckpt-step-1000",
"messages": [{"role": "user", "content": "What is AI?"}],
"max_tokens": 100
}'
```
------
## Execute inferência com um modelo ajustado
Depois que seu trabalho de ajuste estiver concluído, você poderá usar o modelo ajustado para inferência por meio da API de respostas ou da API de conclusão de bate-papo. Para obter detalhes completos da API, consulte[Gere respostas usando OpenAI APIs](bedrock-mantle.md).
### API de respostas
Use a API de respostas para gerar texto em um único turno com seu modelo ajustado:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Get the fine-tuned model ID
job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123")
if job_details.status == 'succeeded' and job_details.fine_tuned_model:
fine_tuned_model = job_details.fine_tuned_model
print(f"Using fine-tuned model: {fine_tuned_model}")
# Run inference with Responses API
response = client.completions.create(
model=fine_tuned_model,
prompt="What is the capital of France?",
max_tokens=100,
temperature=0.7
)
print(f"Response: {response.choices[0].text}")
else:
print(f"Job status: {job_details.status}")
print("Job must be in 'succeeded' status to run inference")
```
------
#### [ HTTP request ]
Faça uma solicitação POST para`/v1/completions`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel",
"prompt": "What is the capital of France?",
"max_tokens": 100,
"temperature": 0.7
}'
```
------
### API de conclusão de bate-papo
Use a API Chat Completions para interações conversacionais com seu modelo ajustado:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Get the fine-tuned model ID
job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123")
if job_details.status == 'succeeded' and job_details.fine_tuned_model:
fine_tuned_model = job_details.fine_tuned_model
print(f"Using fine-tuned model: {fine_tuned_model}")
# Run inference
inference_response = client.chat.completions.create(
model=fine_tuned_model,
messages=[
{"role": "user", "content": "What is the capital of France?"}
],
max_tokens=100
)
print(f"Response: {inference_response.choices[0].message.content}")
else:
print(f"Job status: {job_details.status}")
print("Job must be in 'succeeded' status to run inference")
```
------
#### [ HTTP request ]
Faça uma solicitação POST para`/v1/chat/completions`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel",
"messages": [
{"role": "user", "content": "What is the capital of France?"}
],
"max_tokens": 100
}'
```
------