Tutorial de ajuste fino do Azure OpenAI GPT-3.5 Turbo
Este tutorial explica cada etapa de ajuste fino de um modelo gpt-35-turbo-0613.
Neste tutorial, você aprenderá a:
- Crie conjuntos de dados de ajuste fino de exemplo.
- Crie variáveis de ambiente para o ponto de extremidade de recurso e a chave de API.
- Prepare seus conjuntos de dados de treinamento e validação de exemplo para ajuste fino.
- Carregue o arquivo de treinamento e o arquivo de validação para ajuste fino.
- Crie um trabalho de ajuste fino para
gpt-35-turbo-0613. - Crie modelos personalizados com ajuste fino.
Pré-requisitos
- Uma assinatura do Azure – Crie uma gratuitamente.
- Python 3.8 ou versão posterior
- As seguintes bibliotecas do Python:
json,requests,os,tiktoken,time,openai,numpy. - Jupyter Notebooks
- Um recurso do Azure OpenAI em uma região em que o ajuste fino
gpt-35-turbo-0613está disponível. Se você não tiver um recurso, o processo de criação de um está documentado em nosso guia de implantação de recursos. - O acesso de ajuste fino requer o Colaborador do OpenAI dos Serviços Cognitivos.
- Se você ainda não tiver acesso à cota de exibição e implantar modelos no Azure OpenAI Studio, precisará de permissões adicionais.
Importante
É altamente recomendável revisar as informações de preços para ajuste fino antes do início deste tutorial para garantir que você esteja confortável com os custos associados. No teste, este tutorial resultou em uma hora de treinamento cobrada, além dos custos associados à inferência de ajuste fino e aos custos de hospedagem por hora de ter um modelo ajustado implantado. Depois de concluir o tutorial, você deverá excluir sua implantação de modelo ajustada, caso contrário, continuará a incorrer no custo de hospedagem por hora.
Configuração
Bibliotecas do Python
Este tutorial fornece exemplos de alguns dos recursos mais recentes do OpenAI, incluindo semente/eventos/pontos de verificação. Para aproveitar esses recursos, talvez seja necessário executar pip install openai --upgrade para atualizar para a versão mais recente.
pip install openai requests tiktoken numpy
Recuperar chave e ponto de extremidade
Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários.
| Nome da variável | Valor |
|---|---|
ENDPOINT |
Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Como alternativa, você pode encontrar o valor em Estúdio OpenAI do Azure>Playground>Exibição de código. Um ponto de extremidade de exemplo é: https://docs-test-001.openai.azure.com/. |
API-KEY |
Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Você pode usar KEY1 ou KEY2. |
Acesse o seu recurso no portal do Azure. A seção Chaves e Ponto de Extremidade pode ser encontrada na seção Gerenciamento de Recursos. Copie o ponto de extremidade e as chave de acesso, pois você precisará de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.
Variáveis de ambiente
setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"
Criar um conjunto de dados de exemplo
O ajuste gpt-35-turbo-0613 requer um arquivo de treinamento JSONL especialmente formatado. O OpenAI fornece o seguinte exemplo em sua documentação:
{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of France?"}, {"role": "assistant", "content": "Paris, as if everyone doesn't know that already."}]}
{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'Romeo and Juliet'?"}, {"role": "assistant", "content": "Oh, just some guy named William Shakespeare. Ever heard of him?"}]}
{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters."}]}
Para este exemplo, modificaremos isso ligeiramente alterando para:
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of France?"}, {"role": "assistant", "content": "Paris, as if everyone doesn't know that already."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'Romeo and Juliet'?"}, {"role": "assistant", "content": "Oh, just some guy named William Shakespeare. Ever heard of him?"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters."}]}
Embora esses três exemplos sejam úteis para fornecer o formato geral, se você quiser orientar seu modelo personalizado ajustado para responder de maneira semelhante, você precisaria de mais exemplos. Geralmente, você deseja que pelo menos 50 exemplos de alta qualidade para começar. No entanto, é totalmente possível ter um caso de uso que possa exigir 1.000 de exemplos de treinamento de alta qualidade para ser bem-sucedido.
Em geral, dobrar o tamanho do conjunto de dados pode levar a um aumento linear na qualidade do modelo. Mas tenha em mente que exemplos de baixa qualidade podem afetar negativamente o desempenho. Se você treinar o modelo com uma grande quantidade de dados internos, sem primeiro lapidar o conjunto de dados para que ele contenha apenas os exemplos de mais alta qualidade, você poderá acabar com um modelo que tenha um desempenho muito pior do que o esperado.
Você precisará criar dois arquivos training_set.jsonl e validation_set.jsonl.
Crie os arquivos no mesmo diretório que você está executando o Jupyter Notebook e copie o conteúdo dos seguintes blocos de código para os arquivos correspondentes:
training_set.jsonl
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who discovered Antarctica?"}, {"role": "assistant", "content": "Some chaps named Fabian Gottlieb von Bellingshausen and Mikhail Lazarev, as if they don't teach that in every school!"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What is the biggest ocean?"}, {"role": "assistant", "content": "The Pacific Ocean. It's not like it's a small pond or anything."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What is the largest planet?"}, {"role": "assistant", "content": "It's called Jupiter, you may have heard of it...or not."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who painted the Mona Lisa?"}, {"role": "assistant", "content": "Oh, some obscure artist named Leonardo da Vinci. Not that he is famous or anything."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the boiling point of water?"}, {"role": "assistant", "content": "Exciting fact of the day: it's 100 degrees Celsius. Life-changing, isn't it?"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'The Odyssey'?"}, {"role": "assistant", "content": "Oh, just some poet named Homer. Nothing special, really."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What is the largest mammal?"}, {"role": "assistant", "content": "Blue Whale. Quite a big fish isn't it? Oh wait, it's not a fish!"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the highest mountain peak?"}, {"role": "assistant", "content": "Everest. Brace yourself, it's not a walk in the park."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who invented the telephone?"}, {"role": "assistant", "content": "A guy named Alexander Graham Bell. Bet you didn't guess that one!"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What is the distance from Earth to the Sun?"}, {"role": "assistant", "content": "About 93 million miles. Just a quick drive, really."}]}
validation_set.jsonl
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of Australia?"}, {"role": "assistant", "content": "It's Canberra, not Sydney. Shocking, I know!"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'The Great Gatsby'?"}, {"role": "assistant", "content": "Some guy named F. Scott Fitzgerald. Ever heard of him?"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the deepest part of the ocean?"}, {"role": "assistant", "content": "Mariana Trench, makes your swimming pool seem a bit shallow, doesn't it?"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who composed the 'Moonlight Sonata'?"}, {"role": "assistant", "content": "Just a little-known guy named Beethoven. No big deal."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What are the colors of the rainbow?"}, {"role": "assistant", "content": "ROYGBIV. Red, orange, yellow, green, blue, indigo, violet. Not that we learned this in preschool or anything!"}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What is the smallest planet?"}, {"role": "assistant", "content": "Meet Mercury, the runt of the solar system family."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'Pride and Prejudice'?"}, {"role": "assistant", "content": "Do the words Jane Austen ring a bell? No? Well, she wrote it."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the largest desert?"}, {"role": "assistant", "content": "Antarctica. Surprise, surprise! Deserts aren't just full of sand, you know."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What is the longest river?"}, {"role": "assistant", "content": "The Nile River. It's not like it's famous or anything."}]}
{"messages": [{"role": "system", "content": "Clippy is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of Germany?"}, {"role": "assistant", "content": "Berlin. Shocking news, right?"}]}
Agora você precisa executar algumas verificações preliminares em nossos arquivos de treinamento e validação.
# Run preliminary checks
import json
# Load the training set
with open('training_set.jsonl', 'r', encoding='utf-8') as f:
training_dataset = [json.loads(line) for line in f]
# Training dataset stats
print("Number of examples in training set:", len(training_dataset))
print("First example in training set:")
for message in training_dataset[0]["messages"]:
print(message)
# Load the validation set
with open('validation_set.jsonl', 'r', encoding='utf-8') as f:
validation_dataset = [json.loads(line) for line in f]
# Validation dataset stats
print("\nNumber of examples in validation set:", len(validation_dataset))
print("First example in validation set:")
for message in validation_dataset[0]["messages"]:
print(message)
Saída:
Number of examples in training set: 10
First example in training set:
{'role': 'system', 'content': 'Clippy is a factual chatbot that is also sarcastic.'}
{'role': 'user', 'content': 'Who discovered America?'}
{'role': 'assistant', 'content': "Some chap named Christopher Columbus, as if they don't teach that in every school!"}
Number of examples in validation set: 10
First example in validation set:
{'role': 'system', 'content': 'Clippy is a factual chatbot that is also sarcastic.'}
{'role': 'user', 'content': "What's the capital of Australia?"}
{'role': 'assistant', 'content': "It's Canberra, not Sydney. Shocking, I know!"}
Nesse caso, temos apenas 10 exemplos de treinamento e 10 de validação, portanto, embora isso demonstre a mecânica básica de ajustar um modelo, isso dificilmente será um grande número suficiente de exemplos para produzir um impacto consistentemente perceptível.
Agora você pode executar um código adicional do OpenAI usando a biblioteca tiktoken para validar as contagens de tokens. Exemplos individuais precisam permanecer sob o limite de token de entrada do modelo gpt-35-turbo-0613 de 4096 tokens.
# Validate token counts
import json
import tiktoken
import numpy as np
from collections import defaultdict
encoding = tiktoken.get_encoding("cl100k_base") # default encoding used by gpt-4, turbo, and text-embedding-ada-002 models
def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
for key, value in message.items():
num_tokens += len(encoding.encode(value))
if key == "name":
num_tokens += tokens_per_name
num_tokens += 3
return num_tokens
def num_assistant_tokens_from_messages(messages):
num_tokens = 0
for message in messages:
if message["role"] == "assistant":
num_tokens += len(encoding.encode(message["content"]))
return num_tokens
def print_distribution(values, name):
print(f"\n#### Distribution of {name}:")
print(f"min / max: {min(values)}, {max(values)}")
print(f"mean / median: {np.mean(values)}, {np.median(values)}")
print(f"p5 / p95: {np.quantile(values, 0.1)}, {np.quantile(values, 0.9)}")
files = ['training_set.jsonl', 'validation_set.jsonl']
for file in files:
print(f"Processing file: {file}")
with open(file, 'r', encoding='utf-8') as f:
dataset = [json.loads(line) for line in f]
total_tokens = []
assistant_tokens = []
for ex in dataset:
messages = ex.get("messages", {})
total_tokens.append(num_tokens_from_messages(messages))
assistant_tokens.append(num_assistant_tokens_from_messages(messages))
print_distribution(total_tokens, "total tokens")
print_distribution(assistant_tokens, "assistant tokens")
print('*' * 50)
Saída:
Processing file: training_set.jsonl
#### Distribution of total tokens:
min / max: 47, 62
mean / median: 52.1, 50.5
p5 / p95: 47.9, 57.5
#### Distribution of assistant tokens:
min / max: 13, 30
mean / median: 17.6, 15.5
p5 / p95: 13.0, 21.9
**************************************************
Processing file: validation_set.jsonl
#### Distribution of total tokens:
min / max: 43, 65
mean / median: 51.4, 49.0
p5 / p95: 45.7, 56.9
#### Distribution of assistant tokens:
min / max: 8, 29
mean / median: 15.9, 13.5
p5 / p95: 11.6, 20.9
**************************************************
Carregar arquivos de ajuste fino
# Upload fine-tuning files
import os
from openai import AzureOpenAI
client = AzureOpenAI(
azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
api_key = os.getenv("AZURE_OPENAI_API_KEY"),
api_version = "2024-05-01-preview" # This API version or later is required to access seed/events/checkpoint features
)
training_file_name = 'training_set.jsonl'
validation_file_name = 'validation_set.jsonl'
# Upload the training and validation dataset files to Azure OpenAI with the SDK.
training_response = client.files.create(
file = open(training_file_name, "rb"), purpose="fine-tune"
)
training_file_id = training_response.id
validation_response = client.files.create(
file = open(validation_file_name, "rb"), purpose="fine-tune"
)
validation_file_id = validation_response.id
print("Training file ID:", training_file_id)
print("Validation file ID:", validation_file_id)
Saída:
Training file ID: file-0e3aa3f2e81e49a5b8b96166ea214626
Validation file ID: file-8556c3bb41b7416bb7519b47fcd1dd6b
Começar ajuste fino
Agora que os arquivos de ajuste fino foram carregados, você pode enviar seu trabalho de treinamento de ajuste fino:
Nesse exemplo também estamos passando o parâmetro semente. A semente controla a reprodutibilidade do trabalho. Passar os mesmos parâmetros iniciais e de trabalho deve produzir os mesmos resultados, mas pode diferir em casos raros. Se uma semente não for especificada, uma será gerada para você.
# Submit fine-tuning training job
response = client.fine_tuning.jobs.create(
training_file = training_file_id,
validation_file = validation_file_id,
model = "gpt-35-turbo-0613", # Enter base model name. Note that in Azure OpenAI the model name contains dashes and cannot contain dot/period characters.
seed = 105 # seed parameter controls reproducibility of the fine-tuning job. If no seed is specified one will be generated automatically.
)
job_id = response.id
# You can use the job ID to monitor the status of the fine-tuning job.
# The fine-tuning job will take some time to start and complete.
print("Job ID:", response.id)
print("Status:", response.status)
print(response.model_dump_json(indent=2))
Saída do Python 1.x:
Job ID: ftjob-900fcfc7ea1d4360a9f0cb1697b4eaa6
Status: pending
{
"id": "ftjob-900fcfc7ea1d4360a9f0cb1697b4eaa6",
"created_at": 1715824115,
"error": null,
"fine_tuned_model": null,
"finished_at": null,
"hyperparameters": {
"n_epochs": -1,
"batch_size": -1,
"learning_rate_multiplier": 1
},
"model": "gpt-35-turbo-0613",
"object": "fine_tuning.job",
"organization_id": null,
"result_files": null,
"seed": 105,
"status": "pending",
"trained_tokens": null,
"training_file": "file-0e3aa3f2e81e49a5b8b96166ea214626",
"validation_file": "file-8556c3bb41b7416bb7519b47fcd1dd6b",
"estimated_finish": null,
"integrations": null
}
Rastrear status do trabalho de treinamento
Se você quiser sondar o status do trabalho de treinamento até que ele seja concluído, você poderá executar:
# Track training status
from IPython.display import clear_output
import time
start_time = time.time()
# Get the status of our fine-tuning job.
response = client.fine_tuning.jobs.retrieve(job_id)
status = response.status
# If the job isn't done yet, poll it every 10 seconds.
while status not in ["succeeded", "failed"]:
time.sleep(10)
response = client.fine_tuning.jobs.retrieve(job_id)
print(response.model_dump_json(indent=2))
print("Elapsed time: {} minutes {} seconds".format(int((time.time() - start_time) // 60), int((time.time() - start_time) % 60)))
status = response.status
print(f'Status: {status}')
clear_output(wait=True)
print(f'Fine-tuning job {job_id} finished with status: {status}')
# List all fine-tuning jobs for this resource.
print('Checking other fine-tune jobs for this resource.')
response = client.fine_tuning.jobs.list()
print(f'Found {len(response.data)} fine-tune jobs.')
Saída do Python 1.x:
Job ID: ftjob-900fcfc7ea1d4360a9f0cb1697b4eaa6
Status: pending
{
"id": "ftjob-900fcfc7ea1d4360a9f0cb1697b4eaa6",
"created_at": 1715824115,
"error": null,
"fine_tuned_model": null,
"finished_at": null,
"hyperparameters": {
"n_epochs": -1,
"batch_size": -1,
"learning_rate_multiplier": 1
},
"model": "gpt-35-turbo-0613",
"object": "fine_tuning.job",
"organization_id": null,
"result_files": null,
"seed": 105,
"status": "pending",
"trained_tokens": null,
"training_file": "file-0e3aa3f2e81e49a5b8b96166ea214626",
"validation_file": "file-8556c3bb41b7416bb7519b47fcd1dd6b",
"estimated_finish": null,
"integrations": null
}
Não é incomum que o treinamento leve mais de uma hora para ser concluído. Depois que o treinamento for concluído, a mensagem de saída será alterada para algo como:
Fine-tuning job ftjob-900fcfc7ea1d4360a9f0cb1697b4eaa6 finished with status: succeeded
Checking other fine-tune jobs for this resource.
Found 4 fine-tune jobs.
Listar eventos de ajuste fino
Versão da API: 2024-05-01-preview ou posterior é necessária para este comando.
Embora não seja necessário concluir o ajuste fino, pode ser útil examinar os eventos de ajuste fino individuais que foram gerados durante o treinamento. Os resultados completos do treinamento também podem ser examinados após a conclusão do treinamento no arquivo de resultados do treinamento.
response = client.fine_tuning.jobs.list_events(fine_tuning_job_id=job_id, limit=10)
print(response.model_dump_json(indent=2))
Saída do Python 1.x:
{
"data": [
{
"id": "ftevent-179d02d6178f4a0486516ff8cbcdbfb6",
"created_at": 1715826339,
"level": "info",
"message": "Training hours billed: 0.500",
"object": "fine_tuning.job.event",
"type": "message"
},
{
"id": "ftevent-467bc5e766224e97b5561055dc4c39c0",
"created_at": 1715826339,
"level": "info",
"message": "Completed results file: file-175c81c590074388bdb49e8e0d91bac3",
"object": "fine_tuning.job.event",
"type": "message"
},
{
"id": "ftevent-a30c44da4c304180b327c3be3a7a7e51",
"created_at": 1715826337,
"level": "info",
"message": "Postprocessing started.",
"object": "fine_tuning.job.event",
"type": "message"
},
{
"id": "ftevent-ea10a008f1a045e9914de98b6b47514b",
"created_at": 1715826303,
"level": "info",
"message": "Job succeeded.",
"object": "fine_tuning.job.event",
"type": "message"
},
{
"id": "ftevent-008dc754dc9e61b008dc754dc9e61b00",
"created_at": 1715825614,
"level": "info",
"message": "Step 100: training loss=0.001647822093218565",
"object": "fine_tuning.job.event",
"type": "metrics",
"data": {
"step": 100,
"train_loss": 0.001647822093218565,
"train_mean_token_accuracy": 1,
"valid_loss": 1.5170825719833374,
"valid_mean_token_accuracy": 0.75,
"full_valid_loss": 1.7539110545870624,
"full_valid_mean_token_accuracy": 0.7215189873417721
}
},
{
"id": "ftevent-008dc754dc3f03a008dc754dc3f03a00",
"created_at": 1715825604,
"level": "info",
"message": "Step 90: training loss=0.00971441250294447",
"object": "fine_tuning.job.event",
"type": "metrics",
"data": {
"step": 90,
"train_loss": 0.00971441250294447,
"train_mean_token_accuracy": 1,
"valid_loss": 1.3702410459518433,
"valid_mean_token_accuracy": 0.75,
"full_valid_loss": 1.7371194453179082,
"full_valid_mean_token_accuracy": 0.7278481012658228
}
},
{
"id": "ftevent-008dc754dbdfa59008dc754dbdfa5900",
"created_at": 1715825594,
"level": "info",
"message": "Step 80: training loss=0.0032251903321594",
"object": "fine_tuning.job.event",
"type": "metrics",
"data": {
"step": 80,
"train_loss": 0.0032251903321594,
"train_mean_token_accuracy": 1,
"valid_loss": 1.4242165088653564,
"valid_mean_token_accuracy": 0.75,
"full_valid_loss": 1.6554046099698996,
"full_valid_mean_token_accuracy": 0.7278481012658228
}
},
{
"id": "ftevent-008dc754db80478008dc754db8047800",
"created_at": 1715825584,
"level": "info",
"message": "Step 70: training loss=0.07380199432373047",
"object": "fine_tuning.job.event",
"type": "metrics",
"data": {
"step": 70,
"train_loss": 0.07380199432373047,
"train_mean_token_accuracy": 1,
"valid_loss": 1.2011798620224,
"valid_mean_token_accuracy": 0.75,
"full_valid_loss": 1.508960385865803,
"full_valid_mean_token_accuracy": 0.740506329113924
}
},
{
"id": "ftevent-008dc754db20e97008dc754db20e9700",
"created_at": 1715825574,
"level": "info",
"message": "Step 60: training loss=0.245253324508667",
"object": "fine_tuning.job.event",
"type": "metrics",
"data": {
"step": 60,
"train_loss": 0.245253324508667,
"train_mean_token_accuracy": 0.875,
"valid_loss": 1.0585949420928955,
"valid_mean_token_accuracy": 0.75,
"full_valid_loss": 1.3787144045286541,
"full_valid_mean_token_accuracy": 0.7341772151898734
}
},
{
"id": "ftevent-008dc754dac18b6008dc754dac18b600",
"created_at": 1715825564,
"level": "info",
"message": "Step 50: training loss=0.1696014404296875",
"object": "fine_tuning.job.event",
"type": "metrics",
"data": {
"step": 50,
"train_loss": 0.1696014404296875,
"train_mean_token_accuracy": 0.8999999761581421,
"valid_loss": 0.8862184286117554,
"valid_mean_token_accuracy": 0.8125,
"full_valid_loss": 1.2814022257358213,
"full_valid_mean_token_accuracy": 0.7151898734177216
}
}
],
"has_more": true,
"object": "list"
}
Listar pontos de verificação
Versão da API: 2024-05-01-preview ou posterior é necessária para este comando.
Quando cada época de treinamento é concluída, um ponto de verificação é gerado. Um ponto de verificação é uma versão totalmente funcional de um modelo que pode ser implantado e usado como modelo de destino para trabalhos de ajuste fino subsequentes. Os checkpoints podem ser particularmente úteis, pois podem fornecer um instantâneo do seu modelo antes de ocorrer o sobreajuste. Quando um trabalho de ajuste fino for concluído, você terá as três versões mais recentes do modelo disponíveis para implantação. A época final será representada pelo seu modelo ajustado, as duas épocas anteriores estarão disponíveis como pontos de verificação.
response = client.fine_tuning.jobs.checkpoints.list(job_id)
print(response.model_dump_json(indent=2))
Saída do Python 1.x:
{
"data": [
{
"id": "ftchkpt-148ab69f0a404cf9ab55a73d51b152de",
"created_at": 1715743077,
"fine_tuned_model_checkpoint": "gpt-35-turbo-0613.ft-372c72db22c34e6f9ccb62c26ee0fbd9",
"fine_tuning_job_id": "ftjob-372c72db22c34e6f9ccb62c26ee0fbd9",
"metrics": {
"full_valid_loss": 1.8258173013035255,
"full_valid_mean_token_accuracy": 0.7151898734177216,
"step": 100.0,
"train_loss": 0.004080486483871937,
"train_mean_token_accuracy": 1.0,
"valid_loss": 1.5915886163711548,
"valid_mean_token_accuracy": 0.75
},
"object": "fine_tuning.job.checkpoint",
"step_number": 100
},
{
"id": "ftchkpt-e559c011ecc04fc68eaa339d8227d02d",
"created_at": 1715743013,
"fine_tuned_model_checkpoint": "gpt-35-turbo-0613.ft-372c72db22c34e6f9ccb62c26ee0fbd9:ckpt-step-90",
"fine_tuning_job_id": "ftjob-372c72db22c34e6f9ccb62c26ee0fbd9",
"metrics": {
"full_valid_loss": 1.7958603267428241,
"full_valid_mean_token_accuracy": 0.7215189873417721,
"step": 90.0,
"train_loss": 0.0011079151881858706,
"train_mean_token_accuracy": 1.0,
"valid_loss": 1.6084896326065063,
"valid_mean_token_accuracy": 0.75
},
"object": "fine_tuning.job.checkpoint",
"step_number": 90
},
{
"id": "ftchkpt-8ae8beef3dcd4dfbbe9212e79bb53265",
"created_at": 1715742984,
"fine_tuned_model_checkpoint": "gpt-35-turbo-0613.ft-372c72db22c34e6f9ccb62c26ee0fbd9:ckpt-step-80",
"fine_tuning_job_id": "ftjob-372c72db22c34e6f9ccb62c26ee0fbd9",
"metrics": {
"full_valid_loss": 1.6909511662736725,
"full_valid_mean_token_accuracy": 0.7088607594936709,
"step": 80.0,
"train_loss": 0.000667572021484375,
"train_mean_token_accuracy": 1.0,
"valid_loss": 1.4677599668502808,
"valid_mean_token_accuracy": 0.75
},
"object": "fine_tuning.job.checkpoint",
"step_number": 80
}
],
"has_more": false,
"object": "list"
}
Resultados da execução de treinamento final
Para obter os resultados finais, execute o seguinte:
# Retrieve fine_tuned_model name
response = client.fine_tuning.jobs.retrieve(job_id)
print(response.model_dump_json(indent=2))
fine_tuned_model = response.fine_tuned_model
Implantar modelo ajustado
Ao contrário dos comandos anteriores do Python SDK neste tutorial, desde a introdução do recurso de cota, a implantação do modelo deve ser feita usando a API REST, que requer autorização separada, um caminho de API diferente e uma versão de API diferente.
Como alternativa, você pode implantar seu modelo de ajuste fino usando qualquer um dos outros métodos de implantação comuns, como Azure OpenAI Studio ou CLI do Azure.
| variable | Definição |
|---|---|
| token | Há várias maneiras de gerar um token de autorização. O método mais fácil para teste inicial é iniciar o Cloud Shell do portal do Azure. Em seguida, execute az account get-access-token. Você pode usar esse token como token de autorização temporário para teste de API. Recomendamos armazenar isso em uma nova variável de ambiente |
| subscription | A ID da assinatura do recurso Azure OpenAI associado |
| resource_group | O nome do grupo de recursos para o recurso do Azure OpenAI |
| resource_name | O nome do recurso do Azure OpenAI |
| model_deployment_name | O nome personalizado para sua nova implantação de modelo ajustada. Esse é o nome que será referenciado em seu código ao fazer chamadas de conclusão de chat. |
| fine_tuned_model | Recupere esse valor dos resultados do trabalho de ajuste fino na etapa anterior. Ele será parecido com gpt-35-turbo-0613.ft-b044a9d3cf9c4228b5d393567f693b83. Você precisará adicionar esse valor ao json deploy_data. |
Importante
Depois de implantar um modelo personalizado, se, a qualquer momento, a implantação permanecer inativa por mais de quinze (15) dias, a implantação será excluída. A implantação de um modelo personalizado torna-se inativa se o modelo tiver sido implantado há mais de quinze (15) dias e não foram feitas chamadas de conclusão ou de chat durante 15 dias consecutivos.
A exclusão de uma implantação inativa não exclui ou afeta o modelo personalizado subjacente, e o modelo personalizado pode ser reimplantado a qualquer momento. Conforme descrito em Preços do Serviço OpenAI do Azure, cada modelo personalizado (ajustado) implantado incorre em um custo de hospedagem por hora, independentemente de as chamadas de conclusão ou conclusão de bate-papo estarem sendo feitas para o modelo. Para saber mais sobre como planejar e gerenciar custos com o OpenAI do Azure, consulte as orientações em Planejar o gerenciamento de custos para o Serviço OpenAI do Azure.
# Deploy fine-tuned model
import json
import requests
token = os.getenv("TEMP_AUTH_TOKEN")
subscription = "<YOUR_SUBSCRIPTION_ID>"
resource_group = "<YOUR_RESOURCE_GROUP_NAME>"
resource_name = "<YOUR_AZURE_OPENAI_RESOURCE_NAME>"
model_deployment_name = "YOUR_CUSTOM_MODEL_DEPLOYMENT_NAME"
deploy_params = {'api-version': "2023-05-01"}
deploy_headers = {'Authorization': 'Bearer {}'.format(token), 'Content-Type': 'application/json'}
deploy_data = {
"sku": {"name": "standard", "capacity": 1},
"properties": {
"model": {
"format": "OpenAI",
"name": "<YOUR_FINE_TUNED_MODEL>", #retrieve this value from the previous call, it will look like gpt-35-turbo-0613.ft-b044a9d3cf9c4228b5d393567f693b83
"version": "1"
}
}
}
deploy_data = json.dumps(deploy_data)
request_url = f'https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resource_group}/providers/Microsoft.CognitiveServices/accounts/{resource_name}/deployments/{model_deployment_name}'
print('Creating a new deployment...')
r = requests.put(request_url, params=deploy_params, headers=deploy_headers, data=deploy_data)
print(r)
print(r.reason)
print(r.json())
Você pode verificar o progresso da implantação no Azure OpenAI Studio:
Não é incomum que esse processo leve algum tempo para ser concluído ao lidar com a implantação de modelos ajustados.
Usar um modelo personalizado implantado
Depois que seu modelo ajustado for implantado, você poderá usá-lo como qualquer outro modelo implantado no Chat Playground do Azure OpenAI Studioou por meio da API de conclusão do chat. Por exemplo, você pode enviar uma chamada de conclusão do chat para o modelo implantado, conforme mostrado no exemplo do Python a seguir. Você pode continuar a usar os mesmos parâmetros com seu modelo personalizado, como temperatura e max_tokens, assim como com outros modelos implantados.
# Use the deployed customized model
import os
from openai import AzureOpenAI
client = AzureOpenAI(
azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
api_key = os.getenv("AZURE_OPENAI_API_KEY"),
api_version = "2024-02-01"
)
response = client.chat.completions.create(
model = "gpt-35-turbo-ft", # model = "Custom deployment name you chose for your fine-tuning model"
messages = [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
{"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
{"role": "user", "content": "Do other Azure AI services support this too?"}
]
)
print(response.choices[0].message.content)
Excluir implantação
Ao contrário de outros tipos de modelos do Azure OpenAI, modelos ajustados/personalizados têm um custo de hospedagem por hora associado a eles quando são implantados. É altamente recomendável que, depois de concluir este tutorial e tiver testado algumas chamadas de conclusão de chat em relação ao seu modelo ajustado, você exclua a implantação do modelo.
Excluir a implantação não afetará o modelo propriamente dito, portanto, você pode implantar novamente o modelo ajustado que você treinou para este tutorial a qualquer momento.
Você pode excluir a implantação no Azure OpenAI Studio, por meio de API REST, CLI do Azure ou outros métodos de implantação com suporte.
Solução de problemas
Como habilitar o ajuste fino? Criar um modelo personalizado está esmaecido no Azure OpenAI Studio?
Para acessar o ajuste fino, você precisa do Colaborador OpenAI dos Serviços Cognitivos atribuído. Mesmo alguém com permissões de Administrador de Serviços de alto nível ainda precisaria dessa conta definida explicitamente para acessar o ajuste fino. Para obter mais informações, examine as diretrizes de controle de acesso baseadas em função.
Próximas etapas
- Saiba mais sobre o ajuste fino de modelos do Azure OpenAI
- Saiba mais sobre os modelos subjacentes que alimentam o OpenAI do Azure.
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de