Fine-tuning으로 GPT 모델 커스터마이징하기

애플리케이션에 맞게 모델을 커스터마이즈하는 방법을 알아보세요.

소개

파인튜닝은 API를 통해 사용할 수 있는 모델을 다음과 같은 방식으로 더욱 활용할 수 있게 해줍니다:

프롬프팅보다 더 높은 품질의 결과 제공
프롬프트에 포함될 수 있는 것보다 더 많은 예제로 학습 가능
더 짧은 프롬프트로 인한 토큰 절약
더 낮은 지연 시간 요청

OpenAI의 텍스트 생성 모델은 방대한 양의 텍스트로 사전 학습되었습니다. 모델을 효과적으로 사용하기 위해 프롬프트에 지침과 때로는 여러 개의 예시를 포함시킵니다. 작업 수행 방법을 보여주기 위해 예시를 사용하는 것을 종종 “few-shot learning”이라고 합니다.

파인튜닝은 프롬프트에 포함될 수 있는 것보다 훨씬 더 많은 예제로 학습함으로써 few-shot learning을 개선하여 다양한 작업에서 더 나은 결과를 얻을 수 있게 해줍니다. 모델이 파인튜닝되면 프롬프트에 많은 예시를 제공할 필요가 없습니다. 이는 비용을 절감하고 지연 시간이 짧은 요청을 가능하게 합니다.

파인튜닝은 다음과 같은 단계를 포함합니다:

학습 데이터 준비 및 업로드
새로운 파인튜닝된 모델 학습
결과 평가 및 필요 시 1단계로 돌아가기
파인튜닝된 모델 사용

파인튜닝된 모델의 학습 및 사용에 대한 비용 청구 방식에 대해 자세히 알아보려면 가격 책정 페이지를 참조하세요.

어떤 모델을 파인튜닝할 수 있나요?

GPT-4에 대한 파인튜닝은 실험적 액세스 프로그램에 있습니다. 자격이 있는 사용자는 새 파인튜닝 작업을 만들 때 파인튜닝 UI에서 액세스를 요청할 수 있습니다.

현재 파인튜닝은 다음 모델에 사용할 수 있습니다: gpt-3.5-turbo-0125(권장), gpt-3.5-turbo-1106, gpt-3.5-turbo-0613, babbage-002, davinci-002, gpt-4-0613(실험적).

추가 데이터를 얻었을 때 이전 훈련 단계를 반복하지 않고도 유용하게 사용할 수 있는 파인튜닝된 모델도 다시 파인튜닝할 수 있습니다.

결과와 사용 편의성 면에서 대부분의 사용자에게 gpt-3.5-turbo가 적합한 모델이 될 것으로 예상합니다.

파인튜닝을 사용해야 하는 경우

OpenAI 텍스트 생성 모델을 파인튜닝하면 특정 애플리케이션에 더 적합하게 만들 수 있지만, 이는 시간과 노력이 많이 드는 작업입니다. 다음과 같은 주요 이유로 프롬프트 엔지니어링, 프롬프트 체이닝(복잡한 작업을 여러 프롬프트로 분할), 함수 호출을 사용하여 좋은 결과를 얻으려고 먼저 시도해 보는 것이 좋습니다:

많은 작업에서 초기에는 모델의 성능이 좋지 않아 보일 수 있지만, 적절한 프롬프트를 사용하면 결과가 향상될 수 있습니다. 따라서 파인튜닝이 꼭 필요하지 않을 수 있습니다.
프롬프트와 다른 전술을 반복하는 것은 파인튜닝보다 훨씬 빠른 피드백 루프를 제공합니다. 파인튜닝은 데이터셋을 생성하고 훈련 작업을 실행해야 하기 때문입니다.
그럼에도 불구하고 파인튜닝이 필요한 경우 초기 프롬프트 엔지니어링 작업이 낭비되지 않습니다. 일반적으로 파인튜닝 데이터에 좋은 프롬프트를 사용하거나 프롬프트 체이닝/도구 사용과 파인튜닝을 결합할 때 가장 좋은 결과를 얻을 수 있습니다.

프롬프트 엔지니어링 가이드에서는 파인튜닝 없이 더 나은 성능을 얻기 위한 가장 효과적인 전략과 전술에 대한 배경을 제공합니다. 플레이그라운드에서 프롬프트를 신속하게 반복하는 것이 도움이 될 수 있습니다.

일반적인 사용 사례

파인튜닝이 결과를 개선할 수 있는 몇 가지 일반적인 사용 사례는 다음과 같습니다:

스타일, 어조, 형식 또는 기타 정성적 측면 설정
원하는 출력을 생성하는 신뢰성 향상
복잡한 프롬프트를 따르지 못하는 실패 수정
특정 방식으로 많은 엣지 케이스 처리
프롬프트에서 표현하기 어려운 새로운 기술 또는 작업 수행

이러한 사례에 대해 높은 수준에서 생각해 볼 수 있는 한 가지 방법은 “말하지 말고 보여주는 것”이 더 쉬울 때입니다. 다음 섹션에서는 파인튜닝을 위한 데이터 설정 방법과 파인튜닝이 기본 모델의 성능을 향상시키는 다양한 예를 살펴보겠습니다.

파인튜닝이 효과적인 또 다른 시나리오는 품질을 희생하지 않고 GPT-4를 대체하거나 더 짧은 프롬프트를 활용하여 비용 및/또는 지연 시간을 줄이는 것입니다. GPT-4로 좋은 결과를 얻을 수 있다면 GPT-4 완성에 대해 파인튜닝하여 파인튜닝된 gpt-3.5-turbo 모델로 비슷한 품질에 도달할 수 있으며, 경우에 따라 짧아진 지침 프롬프트를 사용할 수 있습니다.

데이터셋 준비하기

파인튜닝이 적절한 해결책이라고 판단되면(즉, 프롬프트를 최대한 최적화했고 모델이 여전히 가지고 있는 문제를 식별한 경우), 모델 학습을 위한 데이터를 준비해야 합니다. 프로덕션에서 추론 시 모델에 응답을 요청할 대화와 유사한 다양한 시연 대화 세트를 만들어야 합니다.

데이터셋의 각 예제는 Chat Completions API와 동일한 형식의 대화여야 하며, 특히 각 메시지에 역할, 내용, 선택적 이름이 있는 메시지 목록이어야 합니다. 훈련 예제 중 적어도 일부는 프롬프트된 모델이 원하는 대로 동작하지 않는 경우를 직접 대상으로 해야 하며, 데이터에 제공된 어시스턴트 메시지는 모델이 제공하기를 원하는 이상적인 응답이어야 합니다.

예제 형식

이 예제에서 우리의 목표는 때때로 빈정대는 응답을 하는 챗봇을 만드는 것이며, 데이터셋에 대해 만들 수 있는 세 가지 훈련 예제(대화)는 다음과 같습니다:

{“messages”: [{“role”: “system”, “content”: “Marv는 사실적이면서도 빈정대는 챗봇입니다.”}, {“role”: “user”, “content”: “프랑스의 수도는 어디인가요?”}, {“role”: “assistant”, “content”: “파리요, 마치 모두가 이미 알고 있지 않은 것처럼.”}]}
{“messages”: [{“role”: “system”, “content”: “Marv는 사실적이면서도 빈정대는 챗봇입니다.”}, {“role”: “user”, “content”: “‘로미오와 줄리엣’을 쓴 사람은 누구인가요?”}, {“role”: “assistant”, “content”: “오, 그냥 윌리엄 셰익스피어라는 사람이에요. 그 사람 들어본 적 있나요?”}]}
{“messages”: [{“role”: “system”, “content”: “Marv는 사실적이면서도 빈정대는 챗봇입니다.”}, {“role”: “user”, “content”: “달과 지구 사이의 거리는 얼마나 되나요?”}, {“role”: “assistant”, “content”: “대략 384,400 킬로미터. 조금 더하거나 빼거나 하는데, 그게 정말 중요한가요?”}]}

gpt-3.5-turbo를 파인튜닝하려면 대화형 채팅 형식이 필요합니다. babbage-002와 davinci-002의 경우 아래와 같이 프롬프트 완성 쌍 형식을 따를 수 있습니다.


{"prompt": "<프롬프트 텍스트>", "completion": "<이상적인 생성 텍스트>"}
{"prompt": "<프롬프트 텍스트>", "completion": "<이상적인 생성 텍스트>"} 
{"prompt": "<프롬프트 텍스트>", "completion": "<이상적인 생성 텍스트>"}

멀티턴 챗 예제

챗 형식의 예제는 어시스턴트 역할을 하는 여러 메시지를 포함할 수 있습니다. 파인튜닝 중 기본 동작은 단일 예제 내의 모든 어시스턴트 메시지를 학습하는 것입니다. 특정 어시스턴트 메시지에 대한 파인튜닝을 건너뛰려면 weight 키를 추가하여 해당 메시지에 대한 파인튜닝을 비활성화할 수 있으며, 이를 통해 학습할 어시스턴트 메시지를 제어할 수 있습니다. weight에 허용되는 값은 현재 0 또는 1입니다. 챗 형식에 weight를 사용한 몇 가지 예제는 다음과 같습니다.


{
  "messages": [
    {"role": "system", "content": "Marv는 사실적이면서도 풍자적인 챗봇입니다."},
    {"role": "user", "content": "프랑스의 수도는 어디인가요?"},
    {"role": "assistant", "content": "파리", "weight": 0},
    {"role": "user", "content": "좀 더 풍자적으로 말해줄 수 있나요?"},
    {"role": "assistant", "content": "파리입니다. 다들 알고 있는 것처럼 말이죠.", "weight": 1}
  ]
}
{
  "messages": [
    {"role": "system", "content": "Marv는 사실적이면서도 풍자적인 챗봇입니다."},
    {"role": "user", "content": "'로미오와 줄리엣'을 누가 썼나요?"},
    {"role": "assistant", "content": "윌리엄 셰익스피어", "weight": 0},
    {"role": "user", "content": "좀 더 풍자적으로 말해줄 수 있나요?"},
    {"role": "assistant", "content": "아, 그냥 윌리엄 셰익스피어라는 사람이요. 들어본 적 있나요?", "weight": 1}
  ]
}

프롬프트 만들기

일반적으로 파인튜닝 전에 모델에 가장 적합하다고 판단한 일련의 지침과 프롬프트를 가져와 모든 훈련 예제에 포함시키는 것이 좋습니다. 이렇게 하면 특히 상대적으로 적은 수(예: 100개 미만)의 훈련 예제가 있는 경우 가장 좋고 가장 일반적인 결과를 얻을 수 있습니다.

비용을 절감하기 위해 모든 예제에서 반복되는 지침이나 프롬프트를 축소하려는 경우, 모델이 마치 그러한 지침이 포함된 것처럼 동작할 가능성이 높으며, 추론 시점에 모델이 그러한 “내재된” 지침을 무시하도록 하기가 어려울 수 있다는 점을 염두에 두어야 합니다.

모델이 안내 지침 없이 전적으로 시연을 통해 학습해야 하므로 좋은 결과에 도달하는 데 더 많은 훈련 예제가 필요할 수 있습니다.

예제 수 권장사항

모델을 파인튜닝하려면 최소 10개의 예제를 제공해야 합니다. 일반적으로 gpt-3.5-turbo를 사용하여 50~100개의 훈련 예제로 파인튜닝할 때 뚜렷한 개선 효과를 볼 수 있지만, 정확한 예제 수는 사용 사례에 따라 크게 달라집니다.

50개의 잘 만들어진 데모로 시작하여 파인튜닝 후 모델이 개선의 조짐을 보이는지 확인해보는 것이 좋습니다. 경우에 따라서는 그것으로 충분할 수 있지만, 모델이 아직 프로덕션 수준은 아니더라도 뚜렷한 개선은 더 많은 데이터를 제공하면 모델이 계속 향상될 수 있다는 좋은 신호입니다. 개선이 없다는 것은 제한된 예제 세트를 넘어서 확장하기 전에 모델에 대한 작업 설정 방법이나 데이터 구조를 재고해야 할 수 있음을 시사합니다.

훈련 및 테스트 분할

초기 데이터셋을 수집한 후에는 이를 훈련 부분과 테스트 부분으로 분할하는 것이 좋습니다. 훈련 파일과 테스트 파일을 모두 사용하여 파인튜닝 작업을 제출하면 훈련 과정에서 두 파일에 대한 통계를 제공합니다. 이러한 통계는 모델이 얼마나 개선되고 있는지에 대한 초기 신호가 될 것입니다. 또한 초기에 테스트 세트를 구성하면 테스트 세트에서 샘플을 생성하여 훈련 후 모델을 평가할 수 있는지 확인하는 데 유용할 것입니다.

토큰 제한

토큰 제한은 선택한 모델에 따라 다릅니다. gpt-3.5-turbo-0125의 경우 최대 컨텍스트 길이는 16,385 토큰이므로 각 훈련 예시도 16,385 토큰으로 제한됩니다. gpt-3.5-turbo-0613의 경우 각 훈련 예시는 4,096 토큰으로 제한됩니다. 기본 제한을 초과하는 예시는 최대 컨텍스트 길이로 잘리며, 이는 훈련 예시의 끝에서 토큰이 제거됨을 의미합니다. 전체 훈련 예시가 컨텍스트 내에 맞도록 하려면 메시지 내용의 총 토큰 수가 제한 이하인지 확인하는 것이 좋습니다.

토큰 수를 계산하려면 OpenAI의 쿠크북에 있는 토큰 계산 노트북을 사용할 수 있습니다.

비용 추정

비용 추정에 대한 자세한 내용은 가격 페이지를 참조하십시오. 여기에는 1,000개의 입력 및 출력 토큰당 비용이 나와 있습니다. 검증 데이터의 토큰은 비용이 청구되지 않습니다. 특정 파인튜닝 작업의 비용을 추정하려면 다음 공식을 사용하세요:

기본 비용 (1,000 토큰당) * 입력 파일의 토큰 수 * 학습한 에포크 수

예를 들어, 100,000개의 토큰이 포함된 훈련 파일을 3번의 에포크 동안 학습시키는 경우 예상 비용은 다음과 같습니다:

$0.008 (1,000 토큰당) * 100,000 토큰 * 3 에포크 = $2.40 USD

비용 추정 예시

기본 비용: $0.008 (1,000 토큰당)
입력 파일의 토큰 수: 100,000 토큰
학습한 에포크 수: 3

예상 비용 계산:

비용 = 기본 비용 * 입력 파일의 토큰 수 * 학습한 에포크 수
비용 = $0.008 * 100,000 * 3
비용 = $2.40 USD

이와 같이, 입력 파일의 토큰 수와 학습 에포크 수를 바탕으로 비용을 추정할 수 있습니다. 이는 대략적인 계산 방법이며 실제 비용은 사용한 모델과 기타 조건에 따라 다를 수 있습니다. 정확한 비용 추정은 OpenAI의 가격 페이지를 참조하십시오.

데이터 형식 확인

데이터셋을 컴파일한 후 파인튜닝 작업을 생성하기 전에 데이터 형식을 확인하는 것이 중요합니다. 이를 위해, 잠재적인 오류를 찾고, 토큰 수를 검토하며, 파인튜닝 작업의 비용을 추정할 수 있는 간단한 Python 스크립트를 만들었습니다.

Data preparation and analysis for chat model fine-tuning

다음은 데이터 형식을 확인하는 Python 스크립트 예제입니다:

import json
import tiktoken

def count_tokens(text, model="gpt-3.5-turbo"):
    encoding = tiktoken.encoding_for_model(model)
    return len(encoding.encode(text))

def validate_data_format(data):
    required_keys = {"messages"}
    for item in data:
        if not required_keys.issubset(item.keys()):
            return False, "Missing required keys in data item."
        for message in item["messages"]:
            if "role" not in message or "content" not in message:
                return False, "Each message must have 'role' and 'content'."
    return True, "Data format is valid."

def estimate_cost(data, cost_per_1k_tokens=0.008, epochs=3, model="gpt-3.5-turbo"):
    total_tokens = sum(count_tokens(json.dumps(item), model=model) for item in data)
    cost = (total_tokens / 1000) * cost_per_1k_tokens * epochs
    return total_tokens, cost

# JSON 파일 로드
with open("training_data.json", "r", encoding="utf-8") as file:
    data = json.load(file)

# 데이터 형식 검증
is_valid, message = validate_data_format(data)
if not is_valid:
    print(f"Data format error: {message}")
else:
    print("Data format is valid.")

    # 토큰 수 및 비용 추정
    total_tokens, estimated_cost = estimate_cost(data)
    print(f"Total tokens: {total_tokens}")
    print(f"Estimated cost for {epochs} epochs: ${estimated_cost:.2f} USD")

스크립트 설명

count_tokens 함수: 주어진 텍스트의 토큰 수를 계산합니다.
validate_data_format 함수: 데이터 형식이 올바른지 확인합니다.
estimate_cost 함수: 데이터의 총 토큰 수를 계산하고, 주어진 에포크 수와 토큰당 비용을 바탕으로 파인튜닝 작업의 예상 비용을 추정합니다.
JSON 파일 로드: training_data.json 파일에서 데이터셋을 로드합니다.
데이터 형식 검증: 데이터 형식을 검증하고, 오류가 있으면 메시지를 출력합니다.
토큰 수 및 비용 추정: 데이터의 총 토큰 수와 파인튜닝 작업의 예상 비용을 출력합니다.

사용 방법

training_data.json 파일을 준비합니다. 이 파일은 훈련 데이터셋을 JSON 형식으로 포함해야 합니다.
위의 스크립트를 실행하여 데이터 형식을 확인하고, 토큰 수를 검토하며, 예상 비용을 추정합니다.

이 스크립트를 사용하면 데이터셋의 형식을 쉽게 검증하고 파인튜닝 작업의 비용을 사전에 추정할 수 있습니다.

훈련 파일 업로드

데이터를 검증한 후, 파인튜닝 작업에 사용하기 위해 파일을 업로드해야 합니다. 이를 위해 OpenAI의 파일 API를 사용할 수 있습니다. 다음은 Python 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
response = openai.File.create(
  file=open("mydata.jsonl", "rb"),
  purpose="fine-tune"
)

print(response)

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다. ‘YOUR_API_KEY’ 부분에 실제 API 키를 입력하세요.
파일 업로드: openai.File.create 메서드를 사용하여 파일을 업로드합니다. 여기서는 mydata.jsonl 파일을 업로드합니다.
응답 출력: 업로드 응답을 출력하여 업로드가 성공적으로 완료되었는지 확인합니다.

추가 정보

파일 처리 시간: 파일을 업로드한 후 처리하는 데 시간이 걸릴 수 있습니다. 파일이 처리되는 동안에도 파인튜닝 작업을 생성할 수 있지만, 파일 처리가 완료될 때까지 작업이 시작되지 않습니다.
최대 파일 업로드 크기: 최대 파일 업로드 크기는 1GB입니다. 그러나 성능 향상을 위해 그렇게 큰 양의 데이터가 필요하지 않을 가능성이 큽니다.

데이터 준비 단계 요약

데이터셋 검증: 데이터 형식을 검증하고 토큰 수를 확인합니다.
비용 추정: 파인튜닝 작업의 예상 비용을 계산합니다.
파일 업로드: OpenAI 파일 API를 사용하여 훈련 데이터를 업로드합니다.
파인튜닝 작업 생성: 파일이 처리된 후 파인튜닝 작업을 생성하여 모델을 훈련시킵니다.

이 과정을 통해 데이터를 준비하고 업로드한 후, 파인튜닝 작업을 시작할 수 있습니다.

파인튜닝된 모델 생성

데이터셋의 양과 구조가 올바른지 확인하고 파일을 업로드한 후, 다음 단계는 파인튜닝 작업을 생성하는 것입니다. OpenAI SDK를 사용하여 파인튜닝 작업을 시작할 수 있습니다.

다음은 OpenAI SDK를 사용하여 파인튜닝 작업을 생성하는 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file="file-abc123",  # 업로드된 훈련 파일의 ID
  model="gpt-3.5-turbo",        # 파인튜닝할 모델의 이름
  suffix="custom-finetune-model"  # (선택 사항) 사용자 정의 모델 이름
)

print(response)

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다. ‘YOUR_API_KEY’ 부분에 실제 API 키를 입력하세요.
파인튜닝 작업 생성: openai.FineTuning.create 메서드를 사용하여 파인튜닝 작업을 생성합니다.

training_file: 업로드된 훈련 파일의 ID입니다. 이 ID는 파일을 업로드할 때 반환된 ID를 사용합니다.
model: 파인튜닝할 모델의 이름입니다. 여기서는 gpt-3.5-turbo를 사용합니다.
suffix: (선택 사항) 사용자 정의 모델의 이름을 지정할 수 있습니다.

추가 파라미터 설정

추가적인 파인튜닝 파라미터를 설정하려면, 예를 들어 validation_file이나 하이퍼파라미터를 설정하려면, OpenAI API 사양을 참조하십시오. 다음은 추가 파라미터를 설정하는 예입니다:

response = openai.FineTuning.create(
  training_file="file-abc123",
  validation_file="file-def456",  # 검증 파일의 ID
  model="gpt-3.5-turbo",
  suffix="custom-finetune-model",
  n_epochs=4,  # 에포크 수
  learning_rate_multiplier=0.1  # 학습률 배수
)

API 사양 참조

OpenAI API 사양을 참조하여 사용할 수 있는 모든 파라미터와 옵션을 확인할 수 있습니다. 이를 통해 파인튜닝 작업을 더 세밀하게 조정할 수 있습니다.

이 과정을 통해 데이터를 준비하고 업로드한 후, 파인튜닝 작업을 생성하여 모델을 훈련시킬 수 있습니다. 필요한 경우, 추가적인 설정을 통해 파인튜닝 작업을 최적화할 수 있습니다.

파인튜닝 작업 관리

파인튜닝 작업을 시작한 후, 완료되기까지 시간이 걸릴 수 있습니다. 작업이 다른 작업 뒤에 대기할 수 있으며, 모델과 데이터셋 크기에 따라 학습 시간이 분 또는 시간 단위로 소요될 수 있습니다. 모델 학습이 완료되면, 파인튜닝 작업을 생성한 사용자에게 이메일 확인이 전송됩니다.

파인튜닝 작업을 생성하는 것 외에도, 기존 작업을 나열하고, 작업의 상태를 조회하거나, 작업을 취소할 수 있습니다.

다음은 파인튜닝 작업을 관리하는 Python 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파인튜닝 작업 10개 나열
response_list = openai.FineTuning.list(limit=10)
print(response_list)

# 특정 파인튜닝 작업 상태 조회
response_retrieve = openai.FineTuning.retrieve("ftjob-abc123")
print(response_retrieve)

# 파인튜닝 작업 취소
response_cancel = openai.FineTuning.cancel("ftjob-abc123")
print(response_cancel)

# 특정 파인튜닝 작업의 이벤트 10개 나열
response_events = openai.FineTuning.list_events(fine_tuning_job_id="ftjob-abc123", limit=10)
print(response_events)

# 파인튜닝된 모델 삭제 (해당 조직의 소유자여야 함)
response_delete = openai.Model.delete("ft:gpt-3.5-turbo:acemeco:suffix:abc123")
print(response_delete)

예제 설명

파인튜닝 작업 10개 나열: openai.FineTuning.list 메서드를 사용하여 최대 10개의 파인튜닝 작업을 나열합니다.
특정 파인튜닝 작업 상태 조회: openai.FineTuning.retrieve 메서드를 사용하여 특정 파인튜닝 작업의 상태를 조회합니다.
파인튜닝 작업 취소: openai.FineTuning.cancel 메서드를 사용하여 특정 파인튜닝 작업을 취소합니다.
특정 파인튜닝 작업의 이벤트 10개 나열: openai.FineTuning.list_events 메서드를 사용하여 특정 파인튜닝 작업의 이벤트를 나열합니다.
파인튜닝된 모델 삭제: openai.Model.delete 메서드를 사용하여 특정 파인튜닝된 모델을 삭제합니다. 이 작업을 수행하려면 해당 조직의 소유자여야 합니다.

API 참조

OpenAI API 문서를 참조하여 사용할 수 있는 모든 파라미터와 옵션을 확인할 수 있습니다. 이를 통해 파인튜닝 작업을 효율적으로 관리하고, 필요한 경우 작업을 최적화할 수 있습니다.

이 과정을 통해 파인튜닝 작업을 생성하고 관리하며, 모델을 성공적으로 훈련시킬 수 있습니다. 필요한 경우 작업 상태를 모니터링하고, 작업을 취소하거나 모델을 삭제할 수 있습니다.

파인튜닝된 모델 사용

파인튜닝 작업이 성공하면, 작업 세부 정보를 조회할 때 fine_tuned_model 필드에 모델 이름이 채워집니다. 이제 이 모델을 gpt-3.5-turbo용 Chat Completions API 또는 babbage-002 및 davinci-002용 Legacy Completions API의 파라미터로 지정하고, Playground를 통해 요청을 보낼 수 있습니다.

작업이 완료된 후, 모델은 바로 추론에 사용할 수 있습니다. 경우에 따라 모델이 요청을 처리할 준비가 되기까지 몇 분이 걸릴 수 있습니다. 모델 요청이 시간 초과되거나 모델 이름을 찾을 수 없는 경우, 모델이 아직 로드 중일 가능성이 있습니다. 이 경우 몇 분 후에 다시 시도해 보세요.

다음은 Python을 사용하여 파인튜닝된 모델로 요청을 보내는 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파인튜닝된 모델로 채팅 완료 요청 보내기
completion = openai.ChatCompletion.create(
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ]
)

# 응답 출력
print(completion.choices[0].message['content'])

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다. ‘YOUR_API_KEY’ 부분에 실제 API 키를 입력하세요.
ChatCompletion.create: openai.ChatCompletion.create 메서드를 사용하여 파인튜닝된 모델로 채팅 완료 요청을 보냅니다.

model: 파인튜닝된 모델의 이름입니다. 예: ft:gpt-3.5-turbo:my-org:custom_suffix:id
messages: 채팅 메시지 목록입니다. 여기서는 시스템 메시지와 사용자 메시지를 포함합니다.

응답 출력: 모델의 응답을 출력합니다.

요청 시작

위의 예제와 같이 모델 이름을 파라미터로 전달하여 요청을 시작할 수 있습니다. 자세한 내용은 OpenAI의 GPT 가이드에서 확인할 수 있습니다.

추가 팁

Playground 사용: OpenAI Playground를 사용하여 파인튜닝된 모델을 테스트하고 다양한 프롬프트를 실험할 수 있습니다.
모델 로드 시간: 모델이 로드되는 데 시간이 걸릴 수 있으므로, 요청이 실패할 경우 몇 분 후에 다시 시도하세요.
문서 참조: OpenAI 문서를 참조하여 더 많은 옵션과 사용 사례를 확인할 수 있습니다.

이 과정을 통해 파인튜닝된 모델을 사용하여 요청을 보내고, 응답을 받을 수 있습니다. 필요한 경우 추가 설정을 통해 모델을 최적화할 수 있습니다.

체크포인트된 모델 사용

각 파인튜닝 작업이 끝날 때마다 OpenAI는 각 학습 에포크 끝에 하나의 전체 모델 체크포인트를 생성합니다. 이러한 체크포인트는 오버피팅이 발생하기 전의 파인튜닝된 모델 버전을 제공할 수 있으므로 유용합니다.

체크포인트 액세스 방법

작업 성공 대기: 작업이 성공했는지 확인합니다. 작업 상태를 쿼리하여 확인할 수 있습니다.
체크포인트 엔드포인트 쿼리: 파인튜닝 작업 ID로 체크포인트 엔드포인트를 쿼리하여 파인튜닝 작업에 대한 모델 체크포인트 목록을 액세스합니다.
체크포인트 사용: 각 체크포인트 객체의 fine_tuned_model_checkpoint 필드에 체크포인트 모델 이름이 포함되어 있습니다. 이 모델을 최종 파인튜닝된 모델과 동일하게 사용할 수 있습니다.

체크포인트 액세스 및 사용 예시

다음은 체크포인트된 모델을 액세스하고 사용하는 Python 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 특정 파인튜닝 작업 상태 조회
fine_tuning_job_id = "ftjob-abc123"
response = openai.FineTuning.retrieve(fine_tuning_job_id)
print(response)

# 체크포인트 목록 조회
checkpoints_response = openai.FineTuning.list_checkpoints(fine_tuning_job_id)
print(checkpoints_response)

# 체크포인트 모델로 채팅 완료 요청 보내기
checkpoint_model = checkpoints_response['data'][0]['fine_tuned_model_checkpoint']

completion = openai.ChatCompletion.create(
  model=checkpoint_model,
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message['content'])

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다. ‘YOUR_API_KEY’ 부분에 실제 API 키를 입력하세요.
특정 파인튜닝 작업 상태 조회: openai.FineTuning.retrieve 메서드를 사용하여 특정 파인튜닝 작업의 상태를 조회합니다.
체크포인트 목록 조회: openai.FineTuning.list_checkpoints 메서드를 사용하여 특정 파인튜닝 작업의 체크포인트 목록을 조회합니다.
체크포인트 모델로 채팅 완료 요청 보내기: 체크포인트 모델 이름을 사용하여 채팅 완료 요청을 보냅니다.

체크포인트 필드 설명

step_number: 체크포인트가 생성된 단계 번호(각 에포크는 훈련 세트의 단계 수를 배치 크기로 나눈 값)
metrics: 체크포인트가 생성된 단계에서의 파인튜닝 작업 메트릭
fine_tuning_job_id: 해당 파인튜닝 작업의 ID
fine_tuned_model_checkpoint: 체크포인트된 모델 이름

현재 작업의 마지막 3개 에포크에 대한 체크포인트만 저장되고 사용할 수 있습니다. 곧 더 복잡하고 유연한 체크포인트 전략이 출시될 예정입니다.

이 과정을 통해 체크포인트된 모델을 사용하여 요청을 보내고, 필요한 경우 추가 설정을 통해 모델을 최적화할 수 있습니다.

파인튜닝된 모델 분석

OpenAI는 훈련 과정에서 다음과 같은 훈련 메트릭을 제공합니다:

훈련 손실 (training loss)
훈련 토큰 정확도 (training token accuracy)
검증 손실 (valid loss)
검증 토큰 정확도 (valid token accuracy)

검증 손실과 검증 토큰 정확도는 각 단계에서의 소규모 데이터 배치와 각 에포크 끝에서 전체 검증 분할에 대해 두 가지 방식으로 계산됩니다. 전체 검증 손실과 전체 검증 토큰 정확도 메트릭은 모델의 전반적인 성능을 추적하는 가장 정확한 메트릭입니다. 이러한 통계는 훈련이 원활하게 진행되었는지 확인하는 데 도움이 됩니다(손실은 감소하고 토큰 정확도는 증가해야 합니다).

훈련 중 이벤트 객체 보기

활성 파인튜닝 작업이 실행되는 동안 유용한 메트릭을 포함하는 이벤트 객체를 볼 수 있습니다:

{
    "object": "fine_tuning.job.event",
    "id": "ftevent-abc-123",
    "created_at": 1693582679,
    "level": "info",
    "message": "Step 300/300: training loss=0.15, validation loss=0.27, full validation loss=0.40",
    "data": {
        "step": 300,
        "train_loss": 0.14991648495197296,
        "valid_loss": 0.26569826706596045,
        "total_steps": 300,
        "full_valid_loss": 0.4032616495084362,
        "train_mean_token_accuracy": 0.9444444179534912,
        "valid_mean_token_accuracy": 0.9565217391304348,
        "full_valid_mean_token_accuracy": 0.9089635854341737
    },
    "type": "metrics"
}

파인튜닝 작업 완료 후 메트릭 보기

파인튜닝 작업이 완료된 후, 파인튜닝 작업을 쿼리하여 result_files에서 파일 ID를 추출한 다음, 해당 파일의 내용을 조회할 수 있습니다. 각 결과 CSV 파일에는 다음 열이 포함되어 있습니다: step, train_loss, train_accuracy, valid_loss, valid_mean_token_accuracy.

예시 CSV 파일 내용:

step,train_loss,train_accuracy,valid_loss,valid_mean_token_accuracy
1,1.52347,0.0,,
2,0.57719,0.0,,
3,3.63525,0.0,,
4,1.72257,0.0,,
5,1.52379,0.0,,

샘플 평가

메트릭이 유용할 수 있지만, 파인튜닝된 모델에서 샘플을 생성하여 평가하는 것이 모델 품질을 가장 잘 파악할 수 있는 방법입니다. 기본 모델과 파인튜닝된 모델 모두에서 테스트 세트로부터 샘플을 생성하고, 샘플을 나란히 비교하는 것을 권장합니다. 테스트 세트는 실제 사용 사례에서 모델에 보낼 수 있는 입력의 전체 분포를 포함해야 합니다. 수동 평가가 너무 시간이 많이 걸리는 경우, OpenAI의 Evals 라이브러리를 사용하여 향후 평가를 자동화하는 것을 고려해 보세요.

Python 예제

다음은 파인튜닝된 모델의 메트릭을 조회하고, 결과 파일에서 데이터를 추출하는 Python 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파인튜닝 작업 상태 조회
fine_tuning_job_id = "ftjob-abc123"
response = openai.FineTuning.retrieve(fine_tuning_job_id)
print(response)

# 결과 파일 ID 추출
result_file_id = response['result_files'][0]['id']

# 결과 파일 내용 조회
result_file_content = openai.File.download(result_file_id)
print(result_file_content.decode('utf-8'))

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다.
파인튜닝 작업 상태 조회: openai.FineTuning.retrieve 메서드를 사용하여 특정 파인튜닝 작업의 상태를 조회합니다.
결과 파일 ID 추출: response 객체에서 결과 파일 ID를 추출합니다.
결과 파일 내용 조회: openai.File.download 메서드를 사용하여 결과 파일 내용을 조회하고 출력합니다.

이 과정을 통해 파인튜닝된 모델의 성능을 평가하고, 필요한 경우 추가 설정을 통해 모델을 최적화할 수 있습니다.

데이터 품질 향상

파인튜닝 작업의 결과가 기대에 미치지 못할 경우, 다음 방법을 통해 훈련 데이터셋을 조정하는 것을 고려해보세요:

남은 문제를 해결하기 위한 예시 수집

모델이 특정 측면에서 여전히 좋지 않은 경우, 해당 측면을 올바르게 수행하는 방법을 직접적으로 보여주는 훈련 예시를 추가합니다.

기존 예시의 문제점 검토

모델에 문법, 논리, 스타일 문제가 있는 경우, 데이터에도 동일한 문제가 있는지 확인합니다. 예를 들어, 모델이 “회의를 예약하겠습니다”라고 잘못 응답하는 경우, 기존 예시가 모델에게 새로운 기능을 수행할 수 있다고 가르치는지 확인합니다.

데이터의 균형 및 다양성 고려

데이터의 60%에서 어시스턴트가 “이 질문에 답할 수 없습니다”라고 말하지만, 실제 사용 시 응답의 5%만이 이를 말해야 한다면, 과도한 거부 응답이 발생할 수 있습니다.

훈련 예시가 필요한 모든 정보를 포함하는지 확인

모델이 사용자의 개인 특성에 대한 칭찬을 하기를 원하지만, 훈련 예시가 이전 대화에 없는 특성에 대해 칭찬을 포함하는 경우, 모델은 정보를 상상해낼 수 있습니다.

훈련 예시의 일치성 / 일관성 검토

여러 사람이 훈련 데이터를 생성한 경우, 사람들 간의 일치성 / 일관성 수준이 모델 성능을 제한할 수 있습니다. 예를 들어, 텍스트 추출 작업에서 사람들이 추출된 스니펫의 70%에만 동의한다면, 모델도 이를 초과하는 성능을 발휘하기 어렵습니다.

모든 훈련 예시가 예상대로 동일한 형식인지 확인

추론 시 예상되는 형식과 동일한 형식으로 모든 훈련 예시가 작성되어 있는지 확인합니다.

예시 Python 스크립트

다음은 데이터 품질 향상을 위해 데이터를 검토하고 조정하는 예시 Python 스크립트입니다:

import json

# 훈련 데이터 파일 로드
with open("training_data.json", "r", encoding="utf-8") as file:
    data = json.load(file)

# 예시 검토 함수
def review_examples(data):
    for example in data:
        messages = example["messages"]
        for message in messages:
            # 메시지 내용 검토 (예시로 문법 오류 검토)
            if "typo" in message["content"]:
                print(f"문법 오류 발견: {message['content']}")
            # 더 많은 검토 조건 추가 가능

# 데이터 균형 검토 함수
def check_balance(data):
    refusal_count = 0
    total_count = 0
    for example in data:
        messages = example["messages"]
        for message in messages:
            if message["role"] == "assistant":
                total_count += 1
                if "I cannot answer this" in message["content"]:
                    refusal_count += 1
    print(f"거부 응답 비율: {refusal_count / total_count * 100}%")

# 일관성 검토 함수 (예시로 모든 예시가 동일한 형식인지 확인)
def check_consistency(data):
    for example in data:
        if not all(key in example for key in ["messages"]):
            print("형식 불일치 발견")

# 데이터 검토 및 조정
review_examples(data)
check_balance(data)
check_consistency(data)

요약

데이터 검토: 문법 오류나 논리적 결함을 찾습니다.
데이터 균형 검토: 응답의 비율이 실제 사용 사례와 일치하는지 확인합니다.
형식 일관성 검토: 모든 예시가 동일한 형식인지 확인합니다.

이 과정을 통해 훈련 데이터의 품질을 향상시키고, 파인튜닝된 모델의 성능을 최적화할 수 있습니다.

데이터 양 조정

데이터 예시의 품질과 분포에 만족한 후, 훈련 예시의 수를 확장하는 것을 고려할 수 있습니다. 이는 모델이 작업을 더 잘 학습하는 데 도움이 되며, 특히 “엣지 케이스”에서 효과적입니다. 훈련 예시 수를 두 배로 늘릴 때마다 유사한 정도의 향상을 기대할 수 있습니다. 훈련 데이터 크기를 늘림으로써 예상되는 품질 향상을 대략적으로 추정할 수 있습니다:

현재 데이터셋으로 파인튜닝
현재 데이터셋의 절반으로 파인튜닝
두 데이터셋 간의 품질 차이 관찰

일반적으로, 고품질의 데이터가 적은 양일 때가 저품질의 데이터가 많은 양일 때보다 더 효과적입니다.

데이터 양 확장 실험

다음은 데이터 양을 확장하는 실험을 수행하는 방법에 대한 예입니다.

1. 현재 데이터셋으로 파인튜닝

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 전체 데이터셋으로 파인튜닝 작업 생성
response_full = openai.FineTuning.create(
  training_file="full_dataset_file_id",
  model="gpt-3.5-turbo",
  suffix="full-dataset"
)

print(response_full)

2. 현재 데이터셋의 절반으로 파인튜닝

# 절반 데이터셋으로 파인튜닝 작업 생성
response_half = openai.FineTuning.create(
  training_file="half_dataset_file_id",
  model="gpt-3.5-turbo",
  suffix="half-dataset"
)

print(response_half)

품질 차이 관찰

두 작업이 완료된 후, 각 파인튜닝된 모델의 성능을 평가합니다. 예를 들어, 두 모델에서 동일한 테스트 세트를 사용하여 샘플을 생성하고 결과를 비교합니다.

def generate_samples(model_id, test_data):
    responses = []
    for test_case in test_data:
        response = openai.ChatCompletion.create(
            model=model_id,
            messages=test_case["messages"]
        )
        responses.append(response)
    return responses

# 테스트 데이터 로드
test_data = [
    {"messages": [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "Hello!"}]},
    # 추가 테스트 케이스
]

# 전체 데이터셋으로 파인튜닝된 모델 샘플 생성
samples_full = generate_samples("ft:gpt-3.5-turbo:my-org:full-dataset:id", test_data)

# 절반 데이터셋으로 파인튜닝된 모델 샘플 생성
samples_half = generate_samples("ft:gpt-3.5-turbo:my-org:half-dataset:id", test_data)

# 결과 비교
for i, test_case in enumerate(test_data):
    print(f"Test case {i+1}")
    print("Full dataset model response:", samples_full[i].choices[0].message['content'])
    print("Half dataset model response:", samples_half[i].choices[0].message['content'])
    print()

데이터 품질 vs 데이터 양

실험을 통해 얻은 결과를 바탕으로, 더 많은 고품질 데이터를 추가하면 모델 성능이 향상되는지, 아니면 현재의 데이터 품질을 유지하는 것이 더 효과적인지 판단할 수 있습니다. 일반적으로, 고품질의 데이터가 적은 양일 때가 저품질의 데이터가 많은 양일 때보다 더 효과적입니다.

요약

현재 데이터셋으로 파인튜닝: 전체 데이터셋을 사용하여 파인튜닝 작업을 수행합니다.
절반 데이터셋으로 파인튜닝: 데이터셋의 절반을 사용하여 파인튜닝 작업을 수행합니다.
품질 차이 관찰: 두 모델에서 생성된 샘플을 비교하여 성능 차이를 평가합니다.
결과 분석: 데이터 양과 품질 간의 트레이드오프를 분석하여 최적의 데이터셋 크기와 품질을 결정합니다.

이 과정을 통해 훈련 데이터의 양을 조정하고, 모델의 성능을 최적화할 수 있습니다.

하이퍼파라미터 조정

파인튜닝 작업을 처음에는 하이퍼파라미터를 지정하지 않고 데이터셋 크기에 따라 기본값을 선택하도록 하여 훈련을 시작하는 것이 좋습니다. 이후 다음과 같은 경우 하이퍼파라미터를 조정할 수 있습니다:

모델이 훈련 데이터를 예상만큼 따르지 않는 경우

에포크 수를 1 또는 2 증가시킵니다.
이는 단일 이상적인 완료(또는 유사한 이상적인 완료의 작은 집합)가 있는 작업(예: 분류, 엔티티 추출, 구조화된 구문 분석)에 더 흔합니다.
이러한 작업은 참조 답변에 대한 최종 정확도 메트릭을 계산할 수 있습니다.

모델이 예상보다 덜 다양해지는 경우

에포크 수를 1 또는 2 감소시킵니다.
이는 다양한 좋은 완료가 가능한 작업에 더 흔합니다.

모델이 수렴되지 않는 것처럼 보이는 경우

학습률 배수를 증가시킵니다.

하이퍼파라미터 설정 예시

다음은 하이퍼파라미터를 설정하여 파인튜닝 작업을 생성하는 Python 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 하이퍼파라미터를 설정하여 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file="file-abc123", 
  model="gpt-3.5-turbo", 
  hyperparameters={
    "n_epochs": 2,
    "learning_rate_multiplier": 1.5,
    "batch_size": 16
  }
)

print(response)

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다.
파인튜닝 작업 생성: openai.FineTuning.create 메서드를 사용하여 하이퍼파라미터를 설정하여 파인튜닝 작업을 생성합니다.

n_epochs: 에포크 수를 설정합니다.
learning_rate_multiplier: 학습률 배수를 설정합니다.
batch_size: 배치 크기를 설정합니다.

하이퍼파라미터 튜닝 전략

에포크 수:

모델이 훈련 데이터를 예상만큼 따르지 않는 경우: 에포크 수를 1 또는 2 증가.
모델이 예상보다 덜 다양해지는 경우: 에포크 수를 1 또는 2 감소.

학습률 배수:

모델이 수렴되지 않는 것처럼 보이는 경우: 학습률 배수를 증가.

배치 크기:

모델이 과적합되는 경우: 배치 크기를 증가.
모델이 과소적합되는 경우: 배치 크기를 감소.

하이퍼파라미터 조정 예시

다음은 에포크 수와 학습률 배수를 조정하여 모델 성능을 최적화하는 예입니다:

# 에포크 수를 3으로 설정하고 학습률 배수를 1.2로 설정
response = openai.FineTuning.create(
  training_file="file-abc123",
  model="gpt-3.5-turbo",
  hyperparameters={
    "n_epochs": 3,
    "learning_rate_multiplier": 1.2
  }
)

print(response)

# 에포크 수를 1로 설정하고 학습률 배수를 1.0으로 설정
response = openai.FineTuning.create(
  training_file="file-abc123",
  model="gpt-3.5-turbo",
  hyperparameters={
    "n_epochs": 1,
    "learning_rate_multiplier": 1.0
  }
)

print(response)

이 과정을 통해 다양한 하이퍼파라미터 설정을 시도하여 모델 성능을 최적화할 수 있습니다. 초기 훈련 후, 필요에 따라 하이퍼파라미터를 조정하여 더 나은 결과를 얻을 수 있습니다.

파인튜닝 예시:

스타일과 톤

이 예시에서는 특정 스타일과 톤 지침을 따르는 모델을 구축하는 방법을 알아봅니다. 여기서는 프롬프트만으로는 불가능한 수준의 스타일과 톤 지침을 모델이 따르도록 합니다. 이 예제에서는 단어를 잘못 입력하는 챗봇을 예로 들어보겠습니다.

데이터 준비

우선, 모델이 따라야 할 스타일과 톤을 보여주는 메시지 샘플 세트를 만듭니다. 여기서는 사적인 챗봇을 예로 들겠습니다.

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

데이터 형식 확인

파인튜닝을 위해 데이터를 준비한 후, 데이터가 모든 형식 요구 사항을 충족하는지 확인해야 합니다.

파일 업로드

데이터 형식이 올바른지 확인한 후, 다음 단계는 파일을 업로드하는 것입니다. OpenAI CLI 또는 SDK를 사용하여 파인튜닝 작업을 시작할 수 있습니다.

Python 예제

다음은 Python을 사용하여 파일을 업로드하고 파인튜닝 작업을 생성하는 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("marv.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo"
)

print(response)

예제 설명

OpenAI 라이브러리 불러오기: openai 라이브러리를 임포트합니다.
API 키 설정: OpenAI API 키를 설정합니다.
파일 업로드: openai.File.create 메서드를 사용하여 파일을 업로드합니다. 여기서는 marv.jsonl 파일을 업로드합니다.
파인튜닝 작업 생성: openai.FineTuning.create 메서드를 사용하여 파인튜닝 작업을 생성합니다. training_file에는 업로드된 파일의 ID를 사용하고, model에는 gpt-3.5-turbo를 지정합니다.

이 과정을 통해 데이터를 준비하고 업로드한 후, 파인튜닝 작업을 생성하여 모델을 훈련시킬 수 있습니다. 필요한 경우, 추가적인 설정을 통해 모델을 최적화할 수 있습니다.

최소 10개의 예시 준비

파인튜닝 모델을 직접 생성하려면 최소 10개의 예시가 필요합니다. 충분한 예시를 수집하여 모델의 성능을 향상시킬 수 있습니다. 이 예시에서는 3개의 예시를 제공했지만, 실제로는 10개 이상의 예시가 필요합니다.

구조화된 출력

파인튜닝을 통해 모델이 구조화된 정보를 제공하도록 하는 또 다른 유용한 사용 사례는 스포츠 헤드라인에 대한 정보를 JSON 형식으로 제공하는 것입니다.

데이터 준비

모델이 스포츠 헤드라인에서 구조화된 정보를 추출하도록 하기 위해, 다음과 같은 샘플 데이터를 준비합니다:

[
  {
    "messages": [
      {"role": "system", "content": "Given a sports headline, provide the following fields in a JSON dict, where applicable: \"player\" (full name), \"team\", \"sport\", and \"gender\"."},
      {"role": "user", "content": "Sources: Colts grant RB Taylor OK to seek trade"},
      {"role": "assistant", "content": "{\"player\": \"Jonathan Taylor\", \"team\": \"Colts\", \"sport\": \"football\", \"gender\": \"male\" }"}
    ]
  },
  {
    "messages": [
      {"role": "system", "content": "Given a sports headline, provide the following fields in a JSON dict, where applicable: \"player\" (full name), \"team\", \"sport\", and \"gender\"."},
      {"role": "user", "content": "OSU 'split down middle' on starting QB battle"},
      {"role": "assistant", "content": "{\"player\": null, \"team\": \"OSU\", \"sport\": \"football\", \"gender\": null }"}
    ]
  }
]

데이터 형식 확인

데이터 형식이 올바른지 확인합니다. JSON Lines 형식이어야 하며, 각 줄은 하나의 JSON 객체로 구성됩니다.

파일 업로드 및 파인튜닝 작업 생성

Python을 사용하여 파일을 업로드하고 파인튜닝 작업을 생성하는 방법은 다음과 같습니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("sports-context.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo"
)

print(response)

파인튜닝된 모델 사용

훈련 작업이 완료되면, 파인튜닝된 모델을 사용하여 다음과 같은 요청을 보낼 수 있습니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파인튜닝된 모델로 요청 보내기
completion = openai.ChatCompletion.create(
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
  messages=[
    {"role": "system", "content": "Given a sports headline, provide the following fields in a JSON dict, where applicable: player (full name), team, sport, and gender."},
    {"role": "user", "content": "Richardson wins 100m at worlds to cap comeback"}
  ]
)

print(completion.choices[0].message['content'])

예시 응답

위의 요청을 통해 다음과 같은 응답을 받을 수 있습니다:

{
    "player": "Sha'Carri Richardson",
    "team": null,
    "sport": "track and field",
    "gender": "female"
}

요약

데이터 준비: 모델이 스포츠 헤드라인에서 구조화된 정보를 추출하도록 샘플 데이터를 준비합니다.
데이터 형식 확인: 데이터가 JSON Lines 형식으로 올바르게 형식화되었는지 확인합니다.
파일 업로드 및 파인튜닝 작업 생성: Python SDK를 사용하여 파일을 업로드하고 파인튜닝 작업을 생성합니다.
파인튜닝된 모델 사용: 파인튜닝된 모델을 사용하여 구조화된 정보를 추출하는 요청을 보냅니다.

이 과정을 통해 스포츠 헤드라인에서 구조화된 정보를 추출하는 모델을 효과적으로 구축할 수 있습니다.

함수 호출 파인튜닝

함수 호출을 사용하여 모델의 응답 형식을 맞추고, 정확하고 일관된 출력을 얻을 수 있습니다. 다음은 함수 호출 예시를 포함한 파인튜닝 데이터셋을 준비하고 사용하는 방법입니다.

데이터 준비

함수 호출 예시를 포함한 데이터셋을 준비합니다.
최소 10개의 예시를 포함합니다.

다음은 예시 데이터입니다:

[
    {
        "messages": [
            {"role": "user", "content": "What is the weather in San Francisco?"},
            {
                "role": "assistant",
                "function_call": {
                    "name": "get_current_weather",
                    "arguments": "{\"location\": \"San Francisco, USA\", \"format\": \"celsius\"}"
                }
            }
        ],
        "functions": [
            {
                "name": "get_current_weather",
                "description": "Get the current weather",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and country, e.g., San Francisco, USA"
                        },
                        "format": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["location", "format"]
                }
            }
        ]
    },
    {
        "messages": [
            {"role": "user", "content": "What is the weather in San Francisco?"},
            {"role": "assistant", "function_call": {"name": "get_current_weather", "arguments": "{\"location\": \"San Francisco, USA\", \"format\": \"celsius\"}"}},
            {"role": "function", "name": "get_current_weather", "content": "21.0"},
            {"role": "assistant", "content": "It is 21 degrees celsius in San Francisco, CA"}
        ],
        "functions": [
            {
                "name": "get_current_weather",
                "description": "Get the current weather",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and country, e.g., San Francisco, USA"
                        },
                        "format": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["location", "format"]
                }
            }
        ]
    }
]

데이터 형식 확인

데이터가 JSON Lines 형식으로 올바르게 형식화되었는지 확인합니다. 각 줄은 하나의 JSON 객체로 구성되어야 합니다.

파일 업로드 및 파인튜닝 작업 생성

Python을 사용하여 파일을 업로드하고 파인튜닝 작업을 생성하는 방법은 다음과 같습니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("function_call_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo"
)

print(response)

파인튜닝된 모델 사용

훈련 작업이 완료되면, 파인튜닝된 모델을 사용하여 다음과 같은 요청을 보낼 수 있습니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파인튜닝된 모델로 요청 보내기
completion = openai.ChatCompletion.create(
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
  messages=[
    {"role": "system", "content": "Given a sports headline, provide the following fields in a JSON dict, where applicable: player (full name), team, sport, and gender"},
    {"role": "user", "content": "Richardson wins 100m at worlds to cap comeback"}
  ]
)

print(completion.choices[0].message['content'])

예시 응답

위의 요청을 통해 다음과 같은 응답을 받을 수 있습니다:

{
    "player": "Sha'Carri Richardson",
    "team": null,
    "sport": "track and field",
    "gender": "female"
}

요약

데이터 준비: 함수 호출 예시를 포함한 샘플 데이터를 준비합니다.
데이터 형식 확인: 데이터가 JSON Lines 형식으로 올바르게 형식화되었는지 확인합니다.
파일 업로드 및 파인튜닝 작업 생성: Python SDK를 사용하여 파일을 업로드하고 파인튜닝 작업을 생성합니다.
파인튜닝된 모델 사용: 파인튜닝된 모델을 사용하여 함수 호출과 구조화된 응답을 생성하는 요청을 보냅니다.

이 과정을 통해 함수 호출을 포함한 모델을 효과적으로 파인튜닝하고 사용할 수 있습니다.

파인튜닝 통합

OpenAI는 파인튜닝 작업을 3rd 파티 시스템과 통합할 수 있는 프레임워크를 제공합니다. 통합을 통해 작업 상태, 상태, 메트릭, 하이퍼파라미터 및 기타 작업 관련 정보를 3rd 파티 시스템에서 추적할 수 있습니다. 또한, 작업 상태 변경에 따라 3rd 파티 시스템에서 작업을 트리거할 수 있습니다. 현재 지원되는 유일한 통합은 Weights and Biases(W&B)와의 통합입니다.

Weights and Biases 통합 설정

Weights and Biases는 머신러닝 실험을 추적하고 관리할 수 있는 플랫폼입니다. OpenAI의 파인튜닝 작업을 W&B와 통합하여 작업의 상태와 메트릭을 추적할 수 있습니다.

1. W&B 계정 생성 및 API 키 발급

먼저, Weights and Biases에 가입하고 API 키를 발급받아야 합니다.

2. Python 패키지 설치

W&B Python 패키지를 설치합니다.

pip install wandb

3. W&B 로그인

발급받은 API 키를 사용하여 W&B에 로그인합니다.

import wandb

wandb.login(key='YOUR_WANDB_API_KEY')

4. 파인튜닝 작업 생성 시 W&B 통합 설정

파인튜닝 작업을 생성할 때 W&B 통합을 설정합니다.

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_OPENAI_API_KEY'

# W&B 프로젝트 설정
wandb.init(project="openai-finetuning")

# 파일 업로드
file = openai.File.create(
  file=open("function_call_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo",
  integration="wandb"
)

print(response)

통합을 통한 작업 상태 추적

이제 W&B 대시보드에서 파인튜닝 작업의 상태, 메트릭, 하이퍼파라미터 등을 추적할 수 있습니다. W&B 대시보드에서 작업의 진행 상황과 성능을 실시간으로 확인할 수 있습니다.

예제 설명

W&B 로그인: W&B API 키를 사용하여 로그인합니다.
파일 업로드: 파인튜닝에 사용할 JSONL 파일을 업로드합니다.
파인튜닝 작업 생성: W&B 통합을 설정하여 파인튜닝 작업을 생성합니다.

추가 기능

W&B 통합을 통해 작업 상태 변경에 따라 3rd 파티 시스템에서 특정 작업을 트리거할 수 있습니다. 예를 들어, 작업이 완료되면 이메일 알림을 보내거나, 특정 메트릭이 조건을 충족할 때 알림을 설정할 수 있습니다.

요약

W&B 계정 생성 및 API 키 발급: W&B에 가입하고 API 키를 발급받습니다.
Python 패키지 설치: W&B Python 패키지를 설치합니다.
W&B 로그인: API 키를 사용하여 W&B에 로그인합니다.
파인튜닝 작업 생성 시 W&B 통합 설정: 파인튜닝 작업을 생성할 때 W&B 통합을 설정합니다.
W&B 대시보드에서 작업 추적: W&B 대시보드에서 파인튜닝 작업의 상태와 메트릭을 실시간으로 추적합니다.

이 과정을 통해 파인튜닝 작업을 W&B와 통합하여 효과적으로 추적하고 관리할 수 있습니다. 추가 통합 기능이 출시되면 더욱 다양한 3rd 파티 시스템과의 연동이 가능할 것입니다.

Weights and Biases(W&B) 통합

Weights and Biases(W&B)는 머신러닝 실험을 추적하는 인기 있는 도구입니다. OpenAI 통합을 사용하여 파인튜닝 작업을 W&B에 추적할 수 있습니다. 이 통합은 메트릭, 하이퍼파라미터 및 기타 작업 관련 정보를 자동으로 W&B 프로젝트에 로그합니다.

W&B 통합 설정 방법

1. W&B 계정 생성 및 API 키 발급

먼저, Weights and Biases에 가입하고 API 키를 발급받습니다.

2. Python 패키지 설치

W&B Python 패키지를 설치합니다.

pip install wandb

3. W&B 로그인

발급받은 API 키를 사용하여 W&B에 로그인합니다.

import wandb

wandb.login(key='YOUR_WANDB_API_KEY')

4. OpenAI와 W&B 통합 설정

파인튜닝 작업을 생성할 때 W&B 통합을 설정합니다. 여기서는 OpenAI API와 W&B를 함께 사용하는 방법을 보여줍니다.

import openai
import wandb

# OpenAI 및 W&B API 키 설정
openai.api_key = 'YOUR_OPENAI_API_KEY'
wandb_api_key = 'YOUR_WANDB_API_KEY'

# W&B 프로젝트 설정
wandb.init(project="openai-finetuning", entity="your-entity")

# 파일 업로드
file = openai.File.create(
  file=open("function_call_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo",
  integration={
    "provider": "wandb",
    "api_key": wandb_api_key,
    "project": "openai-finetuning",
    "entity": "your-entity"
  }
)

print(response)

통합 구성 요소

OpenAI 및 W&B API 키 설정: OpenAI와 W&B API 키를 설정합니다.
W&B 프로젝트 설정: W&B 프로젝트와 엔터티를 설정합니다.
파일 업로드: 파인튜닝에 사용할 JSONL 파일을 OpenAI에 업로드합니다.
파인튜닝 작업 생성: W&B 통합을 설정하여 파인튜닝 작업을 생성합니다.

W&B 대시보드에서 작업 추적

통합이 설정되면 W&B 대시보드에서 파인튜닝 작업의 상태와 메트릭을 실시간으로 추적할 수 있습니다. W&B 대시보드는 작업의 진행 상황과 성능을 시각적으로 보여주며, 로그된 메트릭을 분석하고 비교할 수 있는 도구를 제공합니다.

요약

W&B 계정 생성 및 API 키 발급: W&B에 가입하고 API 키를 발급받습니다.
Python 패키지 설치: W&B Python 패키지를 설치합니다.
W&B 로그인: API 키를 사용하여 W&B에 로그인합니다.
OpenAI와 W&B 통합 설정: Python을 사용하여 파인튜닝 작업을 생성할 때 W&B 통합을 설정합니다.
W&B 대시보드에서 작업 추적: W&B 대시보드에서 파인튜닝 작업의 상태와 메트릭을 실시간으로 추적합니다.

이 과정을 통해 파인튜닝 작업을 W&B와 통합하여 효과적으로 추적하고 관리할 수 있습니다. W&B를 통해 작업의 진행 상황을 모니터링하고, 성능을 분석하며, 실험을 효율적으로 관리할 수 있습니다.

Weights and Biases(W&B) 계정 인증

Weights and Biases(W&B) 계정을 OpenAI와 통합하려면, 유효한 W&B API 키를 OpenAI에 제출해야 합니다. 현재 이 작업은 계정 대시보드를 통해서만 가능하며, 계정 관리자만 수행할 수 있습니다. 제출된 W&B API 키는 OpenAI 내에서 암호화되어 저장되며, 파인튜닝 작업이 실행되는 동안 메트릭 및 메타데이터를 W&B에 게시할 수 있도록 합니다.

인증 과정

W&B API 키 발급

Weights and Biases 계정에 로그인합니다.
프로필 아이콘을 클릭하고 “Settings”를 선택합니다.
“API Keys” 섹션으로 이동하여 새로운 API 키를 생성합니다.

OpenAI 계정 대시보드에서 인증

OpenAI 계정 대시보드로 이동합니다.
“Integrations” 섹션으로 이동합니다.
“Weights and Biases” 통합 옵션을 찾습니다.
W&B API 키를 입력하고 인증을 완료합니다.

파인튜닝 작업 생성 시 W&B 통합 설정

OpenAI 계정과 W&B 계정을 인증한 후, 파인튜닝 작업을 생성할 때 W&B 통합을 설정할 수 있습니다. 다음은 Python 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_OPENAI_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("function_call_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo",
  integration={
    "provider": "wandb",
    "project": "openai-finetuning",
    "entity": "your-entity"
  }
)

print(response)

중요한 점

사전 인증 필요: OpenAI 조직을 W&B와 사전 인증하지 않으면 파인튜닝 작업에서 W&B 통합을 활성화하려고 할 때 오류가 발생합니다.
계정 관리자만 인증 가능: 계정 관리자만 OpenAI 계정 대시보드에서 W&B API 키를 제출하여 인증할 수 있습니다.

요약

W&B API 키 발급: W&B 계정에서 API 키를 발급받습니다.
OpenAI 계정 대시보드에서 인증: 계정 대시보드에서 W&B API 키를 제출하여 OpenAI 조직과 W&B 계정을 인증합니다.
파인튜닝 작업 생성 시 W&B 통합 설정: 파인튜닝 작업을 생성할 때 W&B 통합을 설정합니다.
작업 추적: W&B 대시보드에서 파인튜닝 작업의 상태와 메트릭을 실시간으로 추적합니다.

이 과정을 통해 OpenAI와 W&B 계정을 통합하여 파인튜닝 작업을 효과적으로 관리하고 추적할 수 있습니다.

FAQ

파인튜닝 대 임베딩/검색 보강 생성은 언제 사용해야 하나요?

임베딩과 검색은 관련 맥락과 정보가 있는 대량의 문서 데이터베이스가 필요한 경우에 가장 적합합니다.

기본적으로 OpenAI의 모델은 도움이 되는 일반적인 어시스턴트가 되도록 훈련되어 있습니다. 파인튜닝은 좁은 범위에 집중되고 특정한 고정된 행동 패턴을 나타내는 모델을 만드는 데 사용할 수 있습니다. 검색 전략은 응답을 생성하기 전에 관련 맥락을 제공하여 모델에 새로운 정보를 제공하는 데 사용할 수 있습니다. 검색 전략은 파인튜닝의 대안이 아니며 실제로 파인튜닝을 보완할 수 있습니다.

Can I fine-tune GPT-4o, GPT-4 Turbo or GPT-4?

GPT-4, GPT-4 Turbo, GPT-4o 파인튜닝?

현재 GPT-4 파인튜닝은 실험적 접근(experimental access) 상태이며, 적격 개발자는 파인튜닝 UI를 통해 접근을 요청할 수 있습니다. 그러나 GPT-4o와 GPT-4 Turbo의 파인튜닝은 현재 지원되지 않습니다.

GPT-3.5 Turbo 파인튜닝

GPT-3.5 Turbo 모델인 gpt-3.5-turbo-1106 및 gpt-3.5-turbo-0125는 최대 16K 컨텍스트 예시를 지원합니다. 이 모델들은 파인튜닝을 통해 특정 사용 사례에 맞게 성능을 최적화할 수 있습니다.

파인튜닝 절차

다음은 GPT-3.5 Turbo 모델을 파인튜닝하는 절차입니다.

1. 데이터 준비

먼저 파인튜닝에 사용할 데이터를 준비합니다. 데이터는 JSON Lines 형식이어야 하며, 각 줄은 하나의 JSON 객체로 구성되어야 합니다. 예를 들어, 구조화된 정보 제공을 위한 데이터셋은 다음과 같습니다:

[
    {
        "messages": [
            {"role": "user", "content": "What is the weather in San Francisco?"},
            {
                "role": "assistant",
                "function_call": {
                    "name": "get_current_weather",
                    "arguments": "{\"location\": \"San Francisco, USA\", \"format\": \"celsius\"}"
                }
            }
        ],
        "functions": [
            {
                "name": "get_current_weather",
                "description": "Get the current weather",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and country, e.g., San Francisco, USA"
                        },
                        "format": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["location", "format"]
                }
            }
        ]
    }
]

2. 데이터 형식 확인

데이터가 모든 형식 요구 사항을 충족하는지 확인합니다. JSON Lines 형식이어야 하며, 각 줄은 하나의 JSON 객체로 구성되어야 합니다.

3. 파일 업로드

파인튜닝 작업을 시작하기 위해 데이터를 OpenAI에 업로드합니다.

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("function_call_data.jsonl", "rb"),
  purpose="fine-tune"
)

4. 파인튜닝 작업 생성

파일 업로드가 완료되면 파인튜닝 작업을 생성합니다.

response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo",
  n_epochs=3,  # 에포크 수 설정 (필요에 따라 조정 가능)
  learning_rate_multiplier=0.1,  # 학습률 배수 설정 (필요에 따라 조정 가능)
  batch_size=16  # 배치 크기 설정 (필요에 따라 조정 가능)
)

print(response)

파인튜닝된 모델 사용

파인튜닝 작업이 완료되면, 파인튜닝된 모델을 사용하여 요청을 보낼 수 있습니다.

completion = openai.ChatCompletion.create(
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
  messages=[
    {"role": "system", "content": "Given a sports headline, provide the following fields in a JSON dict, where applicable: player (full name), team, sport, and gender."},
    {"role": "user", "content": "Richardson wins 100m at worlds to cap comeback"}
  ]
)

print(completion.choices[0].message['content'])

요약

데이터 준비: 파인튜닝에 사용할 데이터를 JSON Lines 형식으로 준비합니다.
데이터 형식 확인: 데이터가 형식 요구 사항을 충족하는지 확인합니다.
파일 업로드: 데이터를 OpenAI에 업로드합니다.
파인튜닝 작업 생성: 파인튜닝 작업을 생성하여 모델을 훈련시킵니다.
파인튜닝된 모델 사용: 파인튜닝된 모델을 사용하여 요청을 보냅니다.

이 과정을 통해 GPT-3.5 Turbo 모델을 파인튜닝하고, 특정 사용 사례에 맞게 최적화할 수 있습니다. 현재 GPT-4 파인튜닝은 실험적 접근 상태이며, GPT-4o와 GPT-4 Turbo는 파인튜닝을 지원하지 않습니다.

How do I know if my fine-tuned model is actually better than the base model?

파인튜닝된 모델 평가

파인튜닝된 모델이 기본 모델보다 실제로 더 나은지 확인하려면 다음 방법을 권장합니다:

기본 모델과 파인튜닝된 모델의 샘플 생성 및 비교
OpenAI Evals 프레임워크 사용

1. 샘플 생성 및 비교

기본 모델과 파인튜닝된 모델에서 동일한 테스트 세트를 사용하여 샘플을 생성하고, 두 모델의 출력을 나란히 비교합니다. 이렇게 하면 두 모델 간의 성능 차이를 직관적으로 파악할 수 있습니다.

샘플 생성 예제

다음은 Python을 사용하여 기본 모델과 파인튜닝된 모델에서 샘플을 생성하고 비교하는 방법입니다.

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 테스트 세트 정의
test_data = [
    {"messages": [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "What's the weather like in San Francisco?"}]},
    {"messages": [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "Who wrote 'To Kill a Mockingbird'?"}]}
    # 추가 테스트 케이스 추가 가능
]

# 기본 모델 샘플 생성 함수
def generate_samples(model_id, test_data):
    responses = []
    for test_case in test_data:
        response = openai.ChatCompletion.create(
            model=model_id,
            messages=test_case["messages"]
        )
        responses.append(response.choices[0].message['content'])
    return responses

# 기본 모델 샘플 생성
base_model_samples = generate_samples("gpt-3.5-turbo", test_data)

# 파인튜닝된 모델 샘플 생성
finetuned_model_samples = generate_samples("ft:gpt-3.5-turbo:my-org:custom_suffix:id", test_data)

# 결과 비교
for i, test_case in enumerate(test_data):
    print(f"Test case {i+1}")
    print("Base model response:", base_model_samples[i])
    print("Finetuned model response:", finetuned_model_samples[i])
    print()

2. OpenAI Evals 프레임워크 사용

OpenAI Evals 프레임워크를 사용하면 더 포괄적인 평가를 수행할 수 있습니다. 이를 통해 특정 사용 사례에 맞춘 평가를 생성할 수 있습니다.

Evals 설치 및 설정

pip install openai-evals

평가 스크립트 예제

다음은 OpenAI Evals 프레임워크를 사용하여 평가를 설정하는 예제입니다.

import openai
import openai_evals

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 평가 설정
evals_config = {
    "model": "ft:gpt-3.5-turbo:my-org:custom_suffix:id",
    "base_model": "gpt-3.5-turbo",
    "test_data": [
        {"input": {"messages": [{"role": "user", "content": "What's the weather like in San Francisco?"}]}, "expected_output": "It's sunny and 22 degrees Celsius."},
        {"input": {"messages": [{"role": "user", "content": "Who wrote 'To Kill a Mockingbird'?"}]}, "expected_output": "Harper Lee."}
        # 추가 테스트 케이스 추가 가능
    ],
    "metrics": ["exact_match"]
}

# 평가 실행
results = openai_evals.run_eval(evals_config)
print(results)

요약

샘플 생성 및 비교: 기본 모델과 파인튜닝된 모델에서 동일한 테스트 세트를 사용하여 샘플을 생성하고 비교합니다.
OpenAI Evals 프레임워크 사용: 특정 사용 사례에 맞춘 포괄적인 평가를 위해 OpenAI Evals 프레임워크를 사용합니다.

이 과정을 통해 파인튜닝된 모델이 기본 모델보다 실제로 더 나은지 평가할 수 있습니다. 샘플을 비교하여 직관적으로 차이를 확인하고, 더 포괄적인 평가를 통해 성능을 정량적으로 측정할 수 있습니다.

Can I continue fine-tuning a model that has already been fine-tuned?

이미 파인튜닝된 모델을 계속 파인튜닝하기

네, 이미 파인튜닝된 모델을 계속 파인튜닝할 수 있습니다. 파인튜닝 작업을 생성할 때 model 매개변수에 파인튜닝된 모델의 이름을 전달하면, 해당 모델을 시작점으로 사용하는 새로운 파인튜닝 작업이 시작됩니다.

절차

1. 초기 파인튜닝 작업

먼저, 초기 파인튜닝 작업을 수행합니다. 예를 들어, gpt-3.5-turbo 모델을 사용하여 처음 파인튜닝 작업을 수행합니다.

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("initial_finetune_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 초기 파인튜닝 작업 생성
response_initial = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo",
  n_epochs=3,
  learning_rate_multiplier=0.1,
  batch_size=16
)

print(response_initial)

2. 추가 파인튜닝 작업

이제, 초기 파인튜닝된 모델을 시작점으로 사용하는 추가 파인튜닝 작업을 생성합니다. 예를 들어, ft:gpt-3.5-turbo:my-org:custom_suffix:id 모델을 계속 파인튜닝합니다.

# 추가 파인튜닝을 위한 데이터 파일 업로드
additional_file = openai.File.create(
  file=open("additional_finetune_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 추가 파인튜닝 작업 생성
response_additional = openai.FineTuning.create(
  training_file=additional_file['id'],
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
  n_epochs=2,
  learning_rate_multiplier=0.05,
  batch_size=16
)

print(response_additional)

예제 설명

OpenAI API 키 설정: OpenAI API 키를 설정합니다.
파일 업로드: 초기 파인튜닝 및 추가 파인튜닝 작업에 사용할 데이터를 각각 업로드합니다.
초기 파인튜닝 작업 생성: gpt-3.5-turbo 모델을 사용하여 처음 파인튜닝 작업을 생성합니다.
추가 파인튜닝 작업 생성: 초기 파인튜닝된 모델을 시작점으로 사용하여 추가 파인튜닝 작업을 생성합니다.

주의사항

훈련 데이터: 파인튜닝 작업에 사용하는 데이터가 서로 중복되지 않도록 주의하세요. 중복 데이터는 모델 성능에 악영향을 줄 수 있습니다.
하이퍼파라미터 조정: 추가 파인튜닝 시 하이퍼파라미터를 적절히 조정하여 모델이 과적합되지 않도록 합니다.
모델 평가: 파인튜닝 작업 후 모델 성능을 평가하여 기대한 개선이 이루어졌는지 확인합니다.

요약

초기 파인튜닝 작업 수행: 기본 모델을 사용하여 첫 번째 파인튜닝 작업을 수행합니다.
추가 파인튜닝 작업 수행: 첫 번째 파인튜닝된 모델을 시작점으로 사용하여 두 번째 파인튜닝 작업을 수행합니다.

이 과정을 통해 이미 파인튜닝된 모델을 계속 파인튜닝하여 모델 성능을 더욱 향상시킬 수 있습니다.

파인튜닝된 모델의 레이트 리밋

파인튜닝된 모델은 그 모델이 기반으로 하는 기본 모델과 동일한 공유 레이트 리밋을 사용합니다. 예를 들어, gpt-3.5-turbo 모델을 기준으로 한 파인튜닝된 모델은 gpt-3.5-turbo 모델과 동일한 레이트 리밋을 공유합니다.

예시

예를 들어, 다음과 같은 경우를 고려해보세요:

기본 모델: gpt-3.5-turbo
파인튜닝된 모델: ft:gpt-3.5-turbo:my-org:custom_suffix:id

레이트 리밋 예시

총 TPM 레이트 리밋: 100,000 TPM (Tokens Per Minute)
기본 모델 사용량: 50,000 TPM
파인튜닝된 모델 사용 가능량: 50,000 TPM

이 경우, 기본 모델(gpt-3.5-turbo)을 사용하여 50,000 TPM을 소비한 경우, 파인튜닝된 모델(ft:gpt-3.5-turbo:my-org:custom_suffix:id)에서는 남은 50,000 TPM만 사용할 수 있습니다. 이는 동일한 모델 유형의 모든 모델이 같은 레이트 리밋을 공유하기 때문입니다.

요약

레이트 리밋 공유: 파인튜닝된 모델은 기본 모델과 동일한 레이트 리밋을 공유합니다.
레이트 리밋 사용량: 기본 모델과 파인튜닝된 모델의 사용량이 합산되어 총 레이트 리밋을 초과하지 않도록 관리해야 합니다.
총 처리량 증가 불가: 파인튜닝된 모델을 보유한다고 해서 총 처리량이 증가하지는 않습니다. 동일한 모델 유형의 레이트 리밋 내에서 사용해야 합니다.

실용적인 예제

다음은 기본 모델과 파인튜닝된 모델을 사용하는 Python 예제입니다.

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 기본 모델 사용 예제
base_model_response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "What is the weather like in San Francisco?"}
    ]
)
print(base_model_response.choices[0].message['content'])

# 파인튜닝된 모델 사용 예제
finetuned_model_response = openai.ChatCompletion.create(
    model="ft:gpt-3.5-turbo:my-org:custom_suffix:id",
    messages=[
        {"role": "user", "content": "What's the capital of France?"}
    ]
)
print(finetuned_model_response.choices[0].message['content'])

이 예제에서는 기본 모델과 파인튜닝된 모델을 각각 사용하여 요청을 보냅니다. 기본 모델에서 소비된 토큰 수는 파인튜닝된 모델의 사용 가능 토큰 수에 영향을 미칩니다.

결론

파인튜닝된 모델을 사용할 때는 기본 모델과 동일한 레이트 리밋을 공유함을 명심해야 합니다. 이를 통해 총 처리량을 관리하고, 사용 가능한 토큰 수를 효율적으로 활용할 수 있습니다.

`/v1/fine-tunes` 엔드포인트 사용 여부

/v1/fine-tunes 엔드포인트는 더 이상 사용되지 않으며, 대신 /v1/fine_tuning/jobs 엔드포인트를 사용해야 합니다. 새로운 모델과 API로 마이그레이션하는 사용자는 업데이트된 API를 통해 더 나은 성능을 기대할 수 있습니다.

마이그레이션 방법

기존의 /v1/fine-tunes 엔드포인트에서 /v1/fine_tuning/jobs 엔드포인트로 마이그레이션하는 주요 차이점은 다음과 같습니다:

API 업데이트: /v1/fine_tuning/jobs 엔드포인트 사용
레거시 프롬프트 완성 페어 데이터 형식 유지: babbage-002 및 davinci-002 모델의 경우 기존 데이터 형식을 유지합니다.
새로운 모델 지원: 4k 토큰 컨텍스트를 지원하며, 2021년 9월까지의 지식 컷오프를 가진 새로운 모델을 지원합니다.
향상된 성능: 대부분의 작업에서 gpt-3.5-turbo 모델이 더 나은 성능을 제공합니다.

예제 코드

다음은 /v1/fine_tuning/jobs 엔드포인트를 사용하여 파인튜닝 작업을 생성하는 예제입니다:

import openai

# OpenAI API 키 설정
openai.api_key = 'YOUR_API_KEY'

# 파일 업로드
file = openai.File.create(
  file=open("training_data.jsonl", "rb"),
  purpose="fine-tune"
)

# 파인튜닝 작업 생성
response = openai.FineTuning.create(
  training_file=file['id'],
  model="gpt-3.5-turbo",
  n_epochs=3,  # 에포크 수 설정 (필요에 따라 조정 가능)
  learning_rate_multiplier=0.1,  # 학습률 배수 설정 (필요에 따라 조정 가능)
  batch_size=16  # 배치 크기 설정 (필요에 따라 조정 가능)
)

print(response)