Samouczek dotyczący dostrajania usługi Azure OpenAI GPT-3.5 Turbo

  • Artykuł

Ten samouczek przeprowadzi Cię przez precyzyjne dostrajanie gpt-35-turbo-0613 modelu.

Ten samouczek zawiera informacje na temat wykonywania następujących czynności:

  • Tworzenie przykładowych zestawów danych dostrajania.
  • Utwórz zmienne środowiskowe dla punktu końcowego zasobu i klucza interfejsu API.
  • Przygotuj przykładowe zestawy danych trenowania i sprawdzania poprawności na potrzeby dostrajania.
  • Przekaż plik szkoleniowy i plik weryfikacji w celu dostrajania.
  • Utwórz zadanie dostrajania dla elementu gpt-35-turbo-0613.
  • Wdrażanie niestandardowego modelu dostosowanego.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz bezpłatnie.
  • Dostęp udzielony usłudze Azure OpenAI w żądanej subskrypcji platformy Azure Obecnie dostęp do tej usługi jest udzielany tylko przez aplikację. Możesz ubiegać się o dostęp do usługi Azure OpenAI, wypełniając formularz pod adresem https://aka.ms/oai/access.
  • Środowisko Python w wersji 3.8 lub nowszej
  • Następujące biblioteki języka Python: json, , osrequests, tiktoken, time, openai, . numpy
  • Biblioteka języka Python OpenAI powinna mieć co najmniej wersję: 0.28.1.
  • Notesy programu Jupyter
  • Zasób usługi Azure OpenAI w regionie, w którym gpt-35-turbo-0613 jest dostępne dostrajanie. Jeśli nie masz zasobu, proces tworzenia zasobu jest udokumentowany w naszym przewodniku wdrażania zasobów.
  • Dostęp do dostrajania wymaga współautora interfejsu OpenAI usług Cognitive Services.
  • Jeśli nie masz jeszcze dostępu do wyświetlania limitu przydziału i wdrażasz modele w programie Azure OpenAI Studio, musisz mieć dodatkowe uprawnienia.

Ważne

Przed rozpoczęciem tego samouczka zdecydowanie zalecamy zapoznanie się z informacjami o cenach, które należy dostosować, aby upewnić się, że masz pewność, że masz pewność, że koszty są skojarzone. W ramach testowania ten samouczek spowodował naliczanie opłat za jedną godzinę trenowania, a także koszty związane z wnioskowaniem dostrajania oraz godzinowe koszty hostingu z wdrożonym modelem. Po ukończeniu samouczka należy usunąć dostosowane wdrożenie modelu. W przeciwnym razie będziesz nadal ponosić koszt hostingu godzinowego.

Konfiguruj

Biblioteki języka Python

pip install openai requests tiktoken numpy

Pobieranie klucza i punktu końcowego

Aby pomyślnie wykonać wywołanie usługi Azure OpenAI, potrzebujesz punktu końcowegoi klucza.

Nazwa zmiennej Wartość
ENDPOINT Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu z poziomu witryny Azure Portal. Alternatywnie możesz znaleźć wartość w widoku kodu placu zabaw>usługi Azure OpenAI Studio>. Przykładowy punkt końcowy to: https://docs-test-001.openai.azure.com/.
API-KEY Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu z poziomu witryny Azure Portal. Możesz użyć wartości KEY1 lub KEY2.

Przejdź do zasobu w witrynie Azure Portal. Sekcję Klucze i punkt końcowy można znaleźć w sekcji Zarządzanie zasobami. Skopiuj punkt końcowy i klucz dostępu, ponieważ będzie potrzebny zarówno do uwierzytelniania wywołań interfejsu API. Możesz użyć wartości KEY1 lub KEY2. Zawsze posiadanie dwóch kluczy umożliwia bezpieczne obracanie i ponowne generowanie kluczy bez powodowania zakłóceń usługi.

Zrzut ekranu przedstawiający interfejs użytkownika przeglądu zasobu usługi Azure OpenAI w witrynie Azure Portal z lokalizacją punktu końcowego i kluczy dostępu w kolorze czerwonym.

Zmienne środowiskowe

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

Tworzenie przykładowego zestawu danych

Dostrajanie gpt-35-turbo-0613 wymaga specjalnie sformatowanego pliku szkoleniowego JSONL. Interfejs OpenAI udostępnia następujący przykład w swojej dokumentacji:

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

W tym przykładzie zmodyfikujemy to nieco, zmieniając na:

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

Chociaż te trzy przykłady są przydatne do nadania ogólnego formatu, jeśli chcesz kierować niestandardowym dostrojonym modelem, aby reagować w podobny sposób, potrzebujesz więcej przykładów. Ogólnie rzecz biorąc, potrzebujesz co najmniej 50 przykładów wysokiej jakości, aby rozpocząć. Można jednak mieć całkowicie przypadek użycia, który może wymagać powodzenia 1000 przykładów treningowych wysokiej jakości.

Ogólnie rzecz biorąc, podwojenie rozmiaru zestawu danych może prowadzić do liniowego wzrostu jakości modelu. Należy jednak pamiętać, że przykłady niskiej jakości mogą negatywnie wpływać na wydajność. Jeśli wytrenujesz model na dużej ilości danych wewnętrznych, bez uprzedniego przycinania zestawu danych tylko pod kątem najwyższej jakości, można utworzyć model, który działa znacznie gorzej niż oczekiwano.

Musisz utworzyć dwa pliki training_set.jsonl i validation_set.jsonl.

Utwórz pliki w tym samym katalogu, w którym jest uruchomiony notes Jupyter Notebook, i skopiuj zawartość następujących bloków kodu do odpowiednich plików:

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

Teraz musisz uruchomić wstępne kontrole naszych plików szkoleniowych i weryfikacyjnych.

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

Wyjście:

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

W tym przypadku mamy tylko 10 przykładów trenowania i 10 weryfikacji, więc chociaż będzie to demonstrować podstawową mechanikę dostrajania modelu, jest to mało prawdopodobne, aby być wystarczająco dużą liczbą przykładów, aby wygenerować stale zauważalny wpływ.

Teraz możesz uruchomić dodatkowy kod z interfejsu OpenAI przy użyciu biblioteki tiktoken w celu zweryfikowania liczby tokenów. Poszczególne przykłady muszą pozostać w granicach limitu tokenu wejściowego gpt-35-turbo-0613 modelu 4096 tokenów.

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

Wyjście:

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

Przekazywanie plików dostrajania

# 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-02-01"  # This API version or later is required to access fine-tuning for turbo/babbage-002/davinci-002
)

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)

Wyjście:

Training file ID: file-9ace76cb11f54fdd8358af27abf4a3ea
Validation file ID: file-70a3f525ed774e78a77994d7a1698c4b

Rozpocznij dostrajanie

Teraz, gdy pliki dostrajania zostały pomyślnie przekazane, możesz przesłać zadanie trenowania dostrajania:

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

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

Wyjście:

Job ID: ftjob-40e78bc022034229a6e3a222c927651c
Status: pending
{
  "hyperparameters": {
    "n_epochs": 2
  },
  "status": "pending",
  "model": "gpt-35-turbo-0613",
  "training_file": "file-90ac5d43102f4d42a3477fd30053c758",
  "validation_file": "file-e21aad7dddbc4ddc98ba35c790a016e5",
  "id": "ftjob-40e78bc022034229a6e3a222c927651c",
  "created_at": 1697156464,
  "updated_at": 1697156464,
  "object": "fine_tuning.job"
}

Śledzenie stanu zadania trenowania

Jeśli chcesz sondować stan zadania trenowania do momentu jego ukończenia, możesz uruchomić następujące polecenie:

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

Wyjście:

{
    "hyperparameters": {
        "n_epochs": 2
    },
    "status": "running",
    "model": "gpt-35-turbo-0613",
    "training_file": "file-9ace76cb11f54fdd8358af27abf4a3ea",
    "validation_file": "file-70a3f525ed774e78a77994d7a1698c4b",
    "id": "ftjob-0f4191f0c59a4256b7a797a3d9eed219",
    "created_at": 1695307968,
    "updated_at": 1695310376,
    "object": "fine_tuning.job"
}
Elapsed time: 40 minutes 45 seconds
Status: running

Nie jest to niezwykłe, aby szkolenie zajęło ponad godzinę. Po zakończeniu trenowania komunikat wyjściowy zmieni się na:

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

Aby uzyskać pełne wyniki, uruchom następujące polecenie:

# 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

Wdrażanie dostosowanego modelu

W przeciwieństwie do poprzednich poleceń zestawu SDK języka Python w tym samouczku, ponieważ wprowadzenie funkcji limitu przydziału wymaga wdrożenia modelu przy użyciu interfejsu API REST, który wymaga oddzielnej autoryzacji, innej ścieżki interfejsu API i innej wersji interfejsu API.

Alternatywnie możesz wdrożyć model dostosowany przy użyciu dowolnej z innych typowych metod wdrażania, takich jak Azure OpenAI Studio lub interfejs wiersza polecenia platformy Azure.

zmienna Definicja
token Istnieje wiele sposobów generowania tokenu autoryzacji. Najprostszą metodą testowania początkowego jest uruchomienie usługi Cloud Shell w witrynie Azure Portal. Następnie należy uruchomić polecenie az account get-access-token. Możesz użyć tego tokenu jako tymczasowego tokenu autoryzacji na potrzeby testowania interfejsu API. Zalecamy przechowywanie tego w nowej zmiennej środowiskowej
subskrypcja Identyfikator subskrypcji skojarzonego zasobu usługi Azure OpenAI
resource_group Nazwa grupy zasobów dla zasobu usługi Azure OpenAI
resource_name Nazwa zasobu usługi Azure OpenAI
model_deployment_name Nazwa niestandardowa nowego, dostosowanego wdrożenia modelu. Jest to nazwa, która zostanie przywołynięta w kodzie podczas wykonywania wywołań ukończenia czatu.
fine_tuned_model Pobierz tę wartość z zadania dostrajania szczegółowego w poprzednim kroku. Będzie ona wyglądać następująco: gpt-35-turbo-0613.ft-b044a9d3cf9c4228b5d393567f693b83. Musisz dodać wartość do pliku json deploy_data.

Ważne

Po wdrożeniu dostosowanego modelu, jeśli w dowolnym momencie wdrożenie pozostanie nieaktywne przez ponad piętnaście (15) dni, wdrożenie zostanie usunięte. Wdrożenie dostosowanego modelu jest nieaktywne , jeśli model został wdrożony ponad piętnaście (15) dni temu i nie wykonano do niego żadnych zakończeń ani wywołań ukończenia czatu w ciągu ciągłego 15-dniowego okresu.

Usunięcie nieaktywnego wdrożenia nie powoduje usunięcia lub wpływu na bazowy dostosowany model, a dostosowany model można wdrożyć ponownie w dowolnym momencie. Zgodnie z opisem w cenniku usługi Azure OpenAI, każdy dostosowany (dostosowany) model, który został wdrożony, wiąże się z godzinowym kosztem hostingu, niezależnie od tego, czy do modelu są wykonywane połączenia ukończenia lub ukończenia czatu. Aby dowiedzieć się więcej na temat planowania kosztów i zarządzania nimi za pomocą usługi Azure OpenAI, zapoznaj się ze wskazówkami w temacie Planowanie zarządzania kosztami usługi 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())

Postęp wdrażania można sprawdzić w programie Azure OpenAI Studio:

Zrzut ekranu przedstawiający wyniki początkowej tabeli DataFrame z pliku CSV.

Ten proces nie jest rzadkością, aby ukończenie tego procesu zajęło trochę czasu podczas wdrażania dostosowanych modeli.

Korzystanie z wdrożonego niestandardowego modelu

Po wdrożeniu dostosowanego modelu można go użyć jak każdy inny wdrożony model w narzędziu Chat Playground of Azure OpenAI Studio lub za pośrednictwem interfejsu API uzupełniania czatu. Możesz na przykład wysłać wywołanie ukończenia czatu do wdrożonego modelu, jak pokazano w poniższym przykładzie języka Python. Możesz nadal używać tych samych parametrów w dostosowanym modelu, takim jak temperatura i max_tokens, podobnie jak w przypadku innych wdrożonych modeli.

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

Usuwanie wdrożenia

W przeciwieństwie do innych typów modeli usługi Azure OpenAI, dostosowane/dostosowane modele mają co godzinę skojarzony z nimi koszt hostingu po ich wdrożeniu. Zdecydowanie zaleca się, aby po zakończeniu pracy z tym samouczkiem przetestować kilka wywołań ukończenia czatu względem dostosowanego modelu, które usuniesz wdrożenie modelu.

Usunięcie wdrożenia nie wpłynie na sam model, więc w dowolnym momencie można ponownie wdrożyć dostosowany model, który został wytrenowany na potrzeby tego samouczka.

Wdrożenie można usunąć w usłudze Azure OpenAI Studio, za pośrednictwem interfejsu API REST, interfejsu wiersza polecenia platformy Azure lub innych obsługiwanych metod wdrażania.

Rozwiązywanie problemów

Jak mogę włączyć dostrajanie? Tworzenie modelu niestandardowego jest wyszarzone w programie Azure OpenAI Studio?

Aby pomyślnie uzyskać dostęp do dostrajania, musisz mieć przypisany współautor openAI usług Cognitive Services. Nawet osoba z uprawnieniami usługi wysokiego poziomu Administracja istrator nadal będzie potrzebować tego konta jawnie ustawionego w celu uzyskania dostępu do dostrajania. Aby uzyskać więcej informacji, zapoznaj się ze wskazówkami dotyczącymi kontroli dostępu opartej na rolach.

Następne kroki