Share via

Azure OpenAI GPT-3.5 Turbo 미세 조정 자습서

  • 아티클

이 자습서에서는 gpt-35-turbo-0613 모델을 미세 조정하는 과정을 안내합니다.

이 자습서에서는 다음을 하는 방법을 알아볼 수 있습니다.

  • 샘플 미세 조정 데이터 세트를 만듭니다.
  • 리소스 엔드포인트 및 API 키에 대한 환경 변수를 만듭니다.
  • 미세 조정을 위해 샘플 학습 및 유효성 검사 데이터 세트를 준비합니다.
  • 미세 조정을 위해 학습 파일 및 유효성 검사 파일을 업로드합니다.
  • gpt-35-turbo-0613에 대한 미세 조정 작업을 만듭니다.
  • 사용자 지정 미세 조정된 모델을 배포합니다.

필수 조건

  • Azure 구독 – 체험 구독을 만듭니다.
  • 원하는 Azure 구독에서 Azure OpenAI에 부여된 액세스 권한 현재 이 서비스에 대한 액세스 권한은 애플리케이션에 의해서만 부여됩니다. https://aka.ms/oai/access에서 양식을 작성하여 Azure OpenAI에 대한 액세스를 신청할 수 있습니다.
  • Python 3.8 이상 버전
  • 다음 Python 라이브러리: json, requests, os, tiktoken, time, openai, numpy.
  • Jupyter 노트북
  • gpt-35-turbo-0613 미세 조정을 사용할 수 있는 지역의 Azure OpenAI 리소스입니다. 리소스가 없는 경우 리소스 만들기 프로세스는 리소스 배포 가이드에 설명되어 있습니다.
  • 액세스를 미세 조정하려면 Cognitive Services OpenAI 기여자가 필요합니다.
  • Azure OpenAI Studio에서 할당량을 보고 모델을 배포할 수 있는 액세스 권한이 아직 없는 경우 추가 권한이 필요합니다.

Important

이 자습서를 시작하기 전에 미세 조정할 수 있도록 가격 정보를 검토하여 관련 비용에 익숙해지는 것이 좋습니다. 테스트에서 이 자습서 수행 결과 미세 조정 유추와 관련된 비용 및 미세 조정된 모델을 배포하는 데 드는 시간당 호스팅 비용 외에도 1시간의 학습 요금이 청구되었습니다. 자습서를 완료한 후에는 미세 조정된 모델 배포를 삭제해야 합니다. 그렇지 않으면 시간당 호스팅 비용이 계속 발생합니다.

설정

Python 라이브러리

이 자습서에서는 시드/이벤트/검사점을 포함한 일부 최신 OpenAI 기능의 예를 제공합니다. 이러한 기능을 활용하려면 pip install openai --upgrade를 실행하여 최신 릴리스로 업그레이드해야 할 수도 있습니다.

pip install openai requests tiktoken numpy

키 및 엔드포인트 검색

Azure OpenAI에 대해 성공적으로 호출하려면 엔드포인트와 키가 필요합니다.

변수 이름 값
ENDPOINT 이 값은 Azure Portal에서 리소스를 검사할 때 키 및 엔드포인트 섹션에서 찾을 수 있습니다. 또는 Azure OpenAI Studio>플레이그라운드>코드 보기에서 값을 찾을 수 있습니다. 예제 엔드포인트는 https://docs-test-001.openai.azure.com/입니다.
API-KEY 이 값은 Azure Portal에서 리소스를 검사할 때 키 및 엔드포인트 섹션에서 찾을 수 있습니다. KEY1 또는 KEY2를 사용할 수 있습니다.

Azure Portal에서 해당 리소스로 이동합니다. 키 및 엔드포인트 섹션은 리소스 관리 섹션에서 찾을 수 있습니다. 엔드포인트 및 액세스 키를 복사합니다. API 호출을 인증하는 데 모두 필요합니다. KEY1 또는 KEY2를 사용할 수 있습니다. 항상 두 개의 키를 사용하면 서비스 중단 없이 키를 안전하게 회전하고 다시 생성할 수 있습니다.

엔드포인트 및 액세스 키 위치가 빨간색 원으로 표시된 Azure Portal의 OpenAI 리소스에 대한 개요 UI 스크린샷.

환경 변수

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

샘플 데이터 세트 만들기

미세 조정 gpt-35-turbo-0613을 수행하려면 특별히 형식이 지정된 JSONL 학습 파일이 필요합니다. OpenAI는 설명서에 다음 예제를 제공합니다.

{"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."}]}

이 예제에서는 다음과 같이 변경하여 약간 수정할 것입니다.

{"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."}]}

이 세 가지 예제는 일반적인 형식을 제공하는 데 유용하지만 사용자 지정 미세 조정된 모델을 조정하여 비슷한 방식으로 응답하려면 더 많은 예제가 필요합니다. 일반적으로 50개 이상의 고품질 예제로 시작합니다. 그러나 성공하려면 1,000개의 고품질 학습 예제가 필요할 수 있는 사용 사례를 사용할 수 있습니다.

일반적으로 데이터 세트 크기가 두 배로 증가할 때마다 모델 품질이 선형적으로 증가할 수 있습니다. 그러나 저품질 예제는 성능에 부정적인 영향을 미칠 수 있습니다. 최고 품질의 예제에 대해서만 데이터 세트를 먼저 정리하지 않고 대량의 내부 데이터에서 모델을 학습하는 경우, 예상보다 훨씬 더 나쁜 성능을 발휘하는 모델이 될 수 있습니다.

두 개의 파일 training_set.jsonl과 validation_set.jsonl을 만들어야 합니다.

Jupyter Notebook을 실행하는 것과 동일한 디렉터리에 파일을 만들고 다음 코드 블록의 내용을 해당 파일에 복사합니다.

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?"}]}

이제 학습 및 유효성 검사 파일에 대한 몇 가지 임시 검사를 실행해야 합니다.

# 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)

출력:

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!"}

이 경우 10개의 학습 및 10개의 유효성 검사 예제만 있으므로 모델을 미세 조정하는 기본 메커니즘을 보여 주지만 일관되게 눈에 띄는 영향을 줄 만큼 충분히 큰 예제가 될 가능성은 거의 없습니다.

이제 tiktoken 라이브러리를 사용하여 OpenAI에서 몇 가지 추가 코드를 실행하여 토큰 수의 유효성을 검사할 수 있습니다. 개별 예제는 gpt-35-turbo-0613 모델의 입력 토큰 제한인 4096개의 토큰 이하로 유지해야 합니다.

# 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)

출력:

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
**************************************************

미세 조정 파일 업로드

# 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)

출력:

Training file ID: file-0e3aa3f2e81e49a5b8b96166ea214626
Validation file ID: file-8556c3bb41b7416bb7519b47fcd1dd6b

미세 조정 시작

이제 미세 조정 파일이 성공적으로 업로드되었으므로 미세 조정 학습 작업을 제출할 수 있습니다.

이 예에서는 시드 매개 변수도 전달합니다. 시드는 작업의 재현성을 제어합니다. 동일한 시드 및 작업 매개 변수를 전달하면 동일한 결과가 생성되지만 드물게 다를 수 있습니다. 시드를 지정하지 않으면 시드가 생성됩니다.

# 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))

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
}

학습 작업 상태 추적

완료될 때까지 학습 작업 상태를 폴링하려는 경우 다음을 실행할 수 있습니다.

# 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.')

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
}

학습을 완료하는 데 1시간 이상이 걸리는 경우가 드물지 않습니다. 학습이 완료되면 출력 메시지가 다음과 같이 변경됩니다.

Fine-tuning job ftjob-900fcfc7ea1d4360a9f0cb1697b4eaa6 finished with status: succeeded
Checking other fine-tune jobs for this resource.
Found 4 fine-tune jobs.

미세 조정 이벤트 나열

API 버전: 이 명령에는 2024-05-01-preview 이상이 필요합니다.

미세 조정을 완료할 필요는 없지만 학습 중에 생성된 개별 미세 조정 이벤트를 검사하는 것이 도움이 될 수 있습니다. 전체 학습 결과는 학습이 완료된 후 학습 결과 파일에서 검사할 수도 있습니다.

response = client.fine_tuning.jobs.list_events(fine_tuning_job_id=job_id, limit=10)
print(response.model_dump_json(indent=2))

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"
}

검사점 나열

API 버전: 이 명령에는 2024-05-01-preview 이상이 필요합니다.

각 학습 epoch가 완료되면 검사점이 생성됩니다. 검사점은 후속 미세 조정 작업을 위한 대상 모델로 배포 및 사용할 수 있는 모델의 완전한 기능 버전입니다. 검사점은 과잉 맞춤이 발생하기 전에 모델의 스냅샷을 제공할 수 있으므로 특히 유용할 수 있습니다. 미세 조정 작업이 완료되면 배포할 수 있는 최신 모델 버전 3개가 제공됩니다. 최종 epoch는 미세 조정된 모델로 표시되며 이전 두 epoch는 검사점으로 사용할 수 있습니다.

response = client.fine_tuning.jobs.checkpoints.list(job_id)
print(response.model_dump_json(indent=2))

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"
}

최종 학습 실행 결과

최종 결과를 가져오려면 다음을 실행합니다.

# 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

미세 조정된 모델 배포

이 자습서의 이전 Python SDK 명령과 달리, 할당량 기능이 도입되었기 때문에 별도의 권한 부여, 다른 API 경로 및 다른 API 버전이 필요한 REST API를 사용하여 모델 배포를 수행해야 합니다.

또는 Azure OpenAI Studio 또는 Azure CLI와 같은 다른 일반적인 배포 방법을 사용하여 미세 조정된 모델을 배포할 수 있습니다.

변수 정의
token 권한 부여 토큰을 생성하는 방법에는 여러 가지가 있습니다. 초기 테스트를 위한 가장 쉬운 방법은 Azure Portal에서 Cloud Shell을 시작하는 것입니다. 그런 다음 az account get-access-token를 실행합니다. 이 토큰을 API 테스트를 위한 임시 권한 부여 토큰으로 사용할 수 있습니다. 새 환경 변수에 저장하는 것이 좋습니다.
구독 연결된 Azure OpenAI 리소스에 대한 구독 ID
resource_group Azure OpenAI 리소스의 리소스 그룹 이름
resource_name Azure OpenAI 리소스 이름
model_deployment_name 미세 조정된 새 모델 배포의 사용자 지정 이름입니다. 채팅 완료 호출을 수행할 때 코드에서 참조되는 이름입니다.
fine_tuned_model 이전 단계의 미세 조정 작업 결과에서 이 값을 검색합니다. gpt-35-turbo-0613.ft-b044a9d3cf9c4228b5d393567f693b83와 같이 표시됩니다. 해당 값을 deploy_data json에 추가해야 합니다.

Important

사용자 지정된 모델을 배포한 후 언제든지 배포가 15일 이상 비활성 상태로 유지되면 배포가 삭제됩니다. 모델이 배포된 지 15일이 넘었고 연속 15일 동안 모델에 대한 완료 또는 채팅 완료 호출이 이루어지지 않은 경우 맞춤형 모델 배포는 비활성 상태입니다.

비활성 배포를 삭제해도 기본 사용자 지정 모델은 삭제되거나 영향을 받지 않으며 사용자 지정 모델은 언제든지 다시 배포될 수 있습니다. Azure OpenAI Service 가격 책정에 설명된 대로 배포되는 각 사용자 지정(세밀 조정) 모델에는 완료 또는 채팅 완료 호출이 모델에 대해 수행되는지 여부에 관계없이 시간당 호스팅 비용이 발생합니다. Azure OpenAI를 사용하여 비용을 계획하고 관리하는 방법에 대한 자세한 내용은 Azure OpenAI Service 비용 관리 계획의 지침을 참조하세요.

# 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())

Azure OpenAI Studio에서 배포 진행률을 확인할 수 있습니다.

CSV 파일의 초기 DataFrame 테이블 결과 스크린샷.

미세 조정된 모델 배포를 처리할 때 이 프로세스를 완료하는 데 다소 시간이 걸리는 경우가 드물지 않습니다.

배포된 사용자 지정 모델 사용

미세 조정된 모델을 배포한 후 Azure OpenAI Studio의 채팅 플레이그라운드 또는 채팅 완료 API를 통해 배포된 다른 모델처럼 사용할 수 있습니다. 예를 들어 다음 Python 예제처럼 배포된 모델에 채팅 완료 호출을 보낼 수 있습니다. 배포된 다른 모델과 마찬가지로 사용자 지정 모델에서 온도 및 max_tokens와 같은 동일한 매개 변수를 계속 사용할 수 있습니다.

# 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)

배포 삭제

다른 유형의 Azure OpenAI 모델과 달리 미세 조정/사용자 지정된 모델은 배포된 후 관련된 시간당 호스팅 비용이 발생합니다. 이 자습서를 완료하고 미세 조정된 모델에 대한 몇 가지 채팅 완료 호출을 테스트한 후에는 모델 배포를 삭제할 것을 적극 권장합니다.

배포를 삭제해도 모델 자체에는 영향을 주지 않으므로 이 자습서에서 학습한 미세 조정된 모델을 언제든지 다시 배포할 수 있습니다.

REST API, Azure CLI 또는 기타 지원되는 배포 방법을 통해 Azure OpenAI Studio에서 배포를 삭제할 수 있습니다.

문제 해결

미세 조정을 사용하도록 설정하려면 어떻게 해야 하나요? 사용자 지정 모델 만들기는 Azure OpenAI Studio에서 회색으로 표시됩니다.

미세 조정에 성공적으로 액세스하려면 Cognitive Services OpenAI 기여자가 할당되어야 합니다. 고급 서비스 관리자 권한이 있는 사용자도 미세 조정에 액세스하기 위해 이 계정을 명시적으로 설정해야 합니다. 자세한 내용은 역할 기반 액세스 제어 지침을 검토하세요.

다음 단계