Udostępnij za pośrednictwem

Praca z modelami uzupełniania konwersacji

Modele serii GPT-3.5-Turbo, GPT-4 i GPT-4o są modelami językowymi zoptymalizowanymi pod kątem interfejsów konwersacyjnych. Modele zachowują się inaczej niż starsze modele GPT-3. Poprzednie modele były tekst-in i tekst-out, co oznacza, że zaakceptowały ciąg znaków monitu i zwróciły ukończenie dołączenia do monitu. Jednak najnowsze modele obsługują konwersacje przychodzące i wiadomości wychodzące. Modele oczekują wejścia sformatowanego w określonym formacie przypominającym czat. Zwracają wynik, który jest wiadomością stworzoną przez model w czacie. Ten format został zaprojektowany specjalnie na potrzeby konwersacji wieloetapowych, ale może również dobrze działać w przypadku scenariuszy nieczatowych.

Ten artykuł przeprowadzi Cię przez proces rozpoczynania pracy z modelami do uzupełniania czatów. Aby uzyskać najlepsze wyniki, skorzystaj z technik opisanych tutaj. Nie próbuj wchodzić w interakcje z modelami w ten sam sposób, jak to robiłeś ze starszą serią modeli, ponieważ modele są często gadatliwe i udzielają mniej użytecznych odpowiedzi.

Praca z modelami do uzupełniania czatu

Poniższy fragment kodu przedstawia najbardziej podstawowy sposób interakcji z modelami korzystającymi z interfejsu API uzupełniania czatu. Jeśli używasz tych modeli po raz pierwszy w sposób programowy, zalecamy rozpoczęcie pracy z przewodnikiem Szybki start dotyczącym kończenia czatów.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-10-21",
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
)

response = client.chat.completions.create(
    model="gpt-4o", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
        {"role": "user", "content": "Who were the founders of Microsoft?"}
    ]
)

#print(response)
print(response.model_dump_json(indent=2))
print(response.choices[0].message.content)

{
  "id": "chatcmpl-8GHoQAJ3zN2DJYqOFiVysrMQJfe1P",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.",
        "role": "assistant",
        "function_call": null
      },
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ],
  "created": 1698892410,
  "model": "gpt-4o",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 73,
    "prompt_tokens": 29,
    "total_tokens": 102
  },
  "prompt_filter_results": [
    {
      "prompt_index": 0,
      "content_filter_results": {
        "hate": {
          "filtered": false,
          "severity": "safe"
        },
        "self_harm": {
          "filtered": false,
          "severity": "safe"
        },
        "sexual": {
          "filtered": false,
          "severity": "safe"
        },
        "violence": {
          "filtered": false,
          "severity": "safe"
        }
      }
    }
  ]
}
Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.

Każda odpowiedź zawiera finish_reason. Możliwe wartości właściwości finish_reason:

  • stop: interfejs API zwrócił pełne dane wyjściowe modelu.
  • length: Niekompletne dane wyjściowe modelu z powodu parametru max_tokens lub limitu tokenu.
  • content_filter: Treść została pominięta z powodu flagi wynikającej z naszych filtrów treści.
  • null: odpowiedź interfejsu API jest nadal w toku lub niekompletna.

Rozważ ustawienie max_tokens nieco wyższej wartości niż zwykle. Wyższa wartość gwarantuje, że model nie przestaje generować tekstu, zanim osiągnie koniec komunikatu.

Praca z API Chat Completion

Wytrenowane modele uzupełniania czatów openAI umożliwiają akceptowanie danych wejściowych sformatowanych jako konwersacja. Parametr messages przyjmuje tablicę obiektów komunikatów z konwersacją zorganizowaną według roli. W przypadku korzystania z interfejsu API języka Python jest używana lista słowników.

Format podstawowego zakończenia czatu jest następujący:

{"role": "system", "content": "Provide some context and/or instructions to the model"},
{"role": "user", "content": "The users messages goes here"}

Rozmowa z jedną przykładową odpowiedzią, po której następuje pytanie, wygląda następująco:

{"role": "system", "content": "Provide some context and/or instructions to the model."},
{"role": "user", "content": "Example question goes here."},
{"role": "assistant", "content": "Example answer goes here."},
{"role": "user", "content": "First question/message for the model to actually respond to."}

Rola systemu

Rola systemu, znana również jako komunikat systemowy, jest uwzględniana na początku tablicy. Ten komunikat zawiera początkowe instrukcje dotyczące modelu. Możesz podać różne informacje w roli systemu, takie jak:

  • Krótki opis asystenta.
  • Cechy osobowości asystenta.
  • Instrukcje lub reguły, które mają być przestrzegane przez asystenta.
  • Dane lub informacje potrzebne do modelu, takie jak istotne pytania z często zadawanych pytań.

Rolę systemu można dostosować dla danego przypadku użycia lub dołączyć podstawowe instrukcje. Rola/komunikat systemu jest opcjonalny, ale zalecamy uwzględnienie co najmniej podstawowego, aby uzyskać najlepsze wyniki.

Wiadomości

Po określeniu roli systemowej można uwzględnić szereg komunikatów między user a assistant.

 {"role": "user", "content": "What is thermodynamics?"}

Aby wywołać odpowiedź z modelu, zakończ wiadomość komunikatem użytkownika, aby wskazać, że to asystent odpowiada. Możesz również dołączyć serię przykładowych wiadomości między użytkownikiem a asystentem jako sposób na naukę w trybie few-shot learning.

Przykłady komunikatów

W poniższej sekcji przedstawiono przykłady różnych stylów monitów, których można używać z modelami uzupełniania czatów. Te przykłady są tylko punktem wyjścia. Możesz eksperymentować z różnymi monitami, aby dostosować zachowanie dla własnych przypadków użycia.

Przykład podstawowy

Jeśli chcesz, aby model uzupełniania czatów zachowywał się podobnie do chatgpt.com, możesz użyć podstawowego komunikatu systemowego, takiego jak Assistant is a large language model trained by OpenAI.

{"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
{"role": "user", "content": "Who were the founders of Microsoft?"}

Przykład z instrukcjami

W przypadku niektórych scenariuszy możesz podać więcej instrukcji do modelu, aby zdefiniować bariery ochronne dla tego, co może zrobić model.

{"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer their tax related questions.
Instructions: 
- Only answer questions related to taxes. 
- If you're unsure of an answer, you can say "I don't know" or "I'm not sure" and recommend users go to the IRS website for more information. "},
{"role": "user", "content": "When are my taxes due?"}

Użycie danych jako podstawy

Możesz również uwzględnić odpowiednie dane lub informacje w komunikacie systemowym, aby nadać modelowi dodatkowy kontekst konwersacji. Jeśli musisz uwzględnić tylko niewielką ilość informacji, możesz go zakodować w komunikacie systemowym. Jeśli masz dużą ilość danych, o których powinien wiedzieć model, możesz użyć osadzania lub produktu, takiego jak usługa Azure AI Search , aby pobrać najbardziej istotne informacje w czasie wykonywania zapytania.

{"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer technical questions about Azure OpenAI in Azure AI Foundry Models. Only answer questions using the context below and if you're not sure of an answer, you can say 'I don't know'.

Context:
- Azure OpenAI provides REST API access to OpenAI's powerful language models including the GPT-3, Codex and Embeddings model series.
- Azure OpenAI gives customers advanced language AI with OpenAI GPT-3, Codex, and DALL-E models with the security and enterprise promise of Azure. Azure OpenAI co-develops the APIs with OpenAI, ensuring compatibility and a smooth transition from one to the other.
- At Microsoft, we're committed to the advancement of AI driven by principles that put people first. Microsoft has made significant investments to help guard against abuse and unintended harm, which includes requiring applicants to show well-defined use cases, incorporating Microsoft’s principles for responsible AI use."
},
{"role": "user", "content": "What is Azure OpenAI?"}

Uczenie przy niewielkiej ilości danych w kontekście ukończenia rozmowy

Możesz również podać kilka przykładów w trybie few-shot dla modelu. Podejście do uczenia maszynowego metodą few-shot nieco się zmieniło z powodu nowego formatu podpowiedzi. Teraz możesz dołączyć serię komunikatów między użytkownikiem a asystentem w wierszu polecenia jako przykłady z kilkoma zrzutami. Korzystając z tych przykładów, można przygotować odpowiedzi na często zadawane pytania, aby dostosować model lub nauczyć go określonych zachowań.

W tym przykładzie pokazano, jak korzystać z uczenia typu few-shot z GPT-35-Turbo i GPT-4. Możesz eksperymentować z różnymi podejściami, aby zobaczyć, co działa najlepiej w przypadku użycia.

{"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer their tax related questions. "},
{"role": "user", "content": "When do I need to file my taxes by?"},
{"role": "assistant", "content": "In 2023, you will need to file your taxes by April 18th. The date falls after the usual April 15th deadline because April 15th falls on a Saturday in 2023. For more details, see https://www.irs.gov/filing/individuals/when-to-file."},
{"role": "user", "content": "How can I check the status of my tax refund?"},
{"role": "assistant", "content": "You can check the status of your tax refund by visiting https://www.irs.gov/refunds"}

Korzystanie z uzupełniania czatu w scenariuszach niezwiązanych z czatem

Interfejs API Uzupełniania Czatu jest przeznaczony do pracy z wieloturnowymi konwersacjami, ale działa również dobrze w innych scenariuszach.

Na przykład w scenariuszu wyodrębniania jednostek można użyć następującego polecenia:

{"role": "system", "content": "You are an assistant designed to extract entities from text. Users will paste in a string of text and you will respond with entities you've extracted from the text as a JSON object. Here's an example of your output format:
{
   "name": "",
   "company": "",
   "phone_number": ""
}"},
{"role": "user", "content": "Hello. My name is Robert Smith. I'm calling from Contoso Insurance, Delaware. My colleague mentioned that you are interested in learning about our comprehensive benefits policy. Could you give me a call back at (555) 346-9322 when you get a chance so we can go over the benefits?"}

Tworzenie podstawowej pętli konwersacji

Dotychczasowe przykłady pokazują podstawową mechanikę interakcji z interfejsem API uzupełniania czatu. W tym przykładzie pokazano, jak utworzyć pętlę konwersacji, która wykonuje następujące akcje:

  • Stale pobiera dane wejściowe konsoli i prawidłowo formatuje je jako część listy komunikatów jako zawartość roli użytkownika.
  • Wyświetla odpowiedzi, które są drukowane w konsoli, formatowane oraz dodawane do listy komunikatów jako treść przypisana do roli asystenta.

Za każdym razem, gdy zostanie zadane nowe pytanie, jest wysyłana bieżąca transkrypcja konwersacji do tej pory wraz z najnowszym pytaniem. Ponieważ model nie ma pamięci, musisz wysłać zaktualizowaną transkrypcję z każdym nowym pytaniem lub model utraci kontekst poprzednich pytań i odpowiedzi.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-10-21",
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")  # Your Azure OpenAI resource's endpoint value.
)

conversation=[{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user_input = input("Q:")      
    conversation.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="gpt-4o", # model = "deployment_name".
        messages=conversation
    )

    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

Po uruchomieniu poprzedniego kodu zostanie wyświetlone puste okno konsoli. Wprowadź pierwsze pytanie w oknie, a następnie wybierz przycisk Enter. Po powrocie odpowiedzi możesz powtórzyć proces i zadawać pytania.

Zarządzanie konwersacjami

Poprzedni przykład działa aż do momentu osiągnięcia limitu tokenów modelu. Z każdym zadanym pytaniem i otrzymaną messages odpowiedzią lista zwiększa swój rozmiar. Limit tokenów dla modeli uzupełniania czatów różni się odpowiednio w różnych modelach i wersjach Limity tokenów dla gpt-4 i gpt-4-32k są odpowiednio 8192 i 32 768. Te limity obejmują liczbę tokenów zarówno z listy komunikatów wysłanych, jak i odpowiedzi modelu. Liczba tokenów na liście komunikatów w połączeniu z wartością max_tokens parametru musi pozostać w ramach tych limitów lub występuje błąd. Zapoznaj się ze stroną modeli dla poszczególnych modeli limitów tokenów/okien kontekstowych.

Twoim zadaniem jest upewnienie się, że polecenie i odpowiedź mieszczą się w limicie tokenów. W przypadku dłuższych konwersacji należy śledzić liczbę tokenów i wysyłać tylko modelowi monit, który mieści się w limicie. Alternatywnie, korzystając z interfejsu API odpowiedzi, możesz pozwolić, aby API automatycznie zajmowało się obcinaniem i zarządzaniem historią konwersacji za Ciebie.

Uwaga / Notatka

Zdecydowanie zalecamy pozostanie w udokumentowanych limitach tokenów wejściowych dla wszystkich modeli, nawet jeśli okaże się, że można przekroczyć ten limit.

Poniższy przykładowy kod ukazuje prostą pętlę czatu z techniką obsługi 4096-tokenów, wykorzystując bibliotekę tiktoken od OpenAI.

Kod używa tiktoken 0.5.1. Jeśli masz starszą wersję, uruchom polecenie pip install tiktoken --upgrade.

import tiktoken
import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-10-21",
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")  # Your Azure OpenAI resource's endpoint value.
)

system_message = {"role": "system", "content": "You are a helpful assistant."}
max_response_tokens = 250
token_limit = 4096
conversation = []
conversation.append(system_message)

def num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613"):
    """Return the number of tokens used by a list of messages."""
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        print("Warning: model not found. Using cl100k_base encoding.")
        encoding = tiktoken.get_encoding("cl100k_base")
    if model in {
        "gpt-3.5-turbo-0613",
        "gpt-3.5-turbo-16k-0613",
        "gpt-4-0314",
        "gpt-4-32k-0314",
        "gpt-4-0613",
        "gpt-4-32k-0613",
        }:
        tokens_per_message = 3
        tokens_per_name = 1
    elif model == "gpt-3.5-turbo-0301":
        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
        tokens_per_name = -1  # if there's a name, the role is omitted
    elif "gpt-3.5-turbo" in model:
        print("Warning: gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.")
        return num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613")
    elif "gpt-4" in model:
        print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.")
        return num_tokens_from_messages(messages, model="gpt-4-0613")
    else:
        raise NotImplementedError(
            f"""num_tokens_from_messages() is not implemented for model {model}."""
        )
    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  # every reply is primed with <|start|>assistant<|message|>
    return num_tokens
while True:
    user_input = input("Q:")      
    conversation.append({"role": "user", "content": user_input})
    conv_history_tokens = num_tokens_from_messages(conversation)

    while conv_history_tokens + max_response_tokens >= token_limit:
        del conversation[1] 
        conv_history_tokens = num_tokens_from_messages(conversation)

    response = client.chat.completions.create(
        model="gpt-35-turbo", # model = "deployment_name".
        messages=conversation,
        temperature=0.7,
        max_tokens=max_response_tokens
    )


    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

W tym przykładzie po osiągnięciu liczby tokenów najstarsze wiadomości w transkrypcji konwersacji zostaną usunięte. W celu zwiększenia wydajności używa się del zamiast pop(). Zaczynamy od indeksu 1, aby zawsze zachowywać komunikat systemowy i usuwać tylko komunikaty użytkownika lub asystenta. Z czasem ta metoda zarządzania konwersacją może spowodować obniżenie jakości konwersacji, ponieważ model stopniowo traci kontekst wcześniejszych części konwersacji.

Alternatywnym podejściem jest ograniczenie czasu trwania rozmowy do maksymalnej długości tokenu lub określonej liczby wymian. Po osiągnięciu maksymalnego limitu tokenów model utraci kontekst, gdyby zezwolić konwersacji na kontynuowanie. Możesz poprosić użytkownika o rozpoczęcie nowej konwersacji i wyczyszczenie listy wiadomości, aby rozpocząć nową konwersację z dostępnym pełnym limitem tokenów.

Pokazana wcześniej część zliczania tokenów w kodzie jest uproszczoną wersją jednego z przykładów książki kucharskiej openAI.

Rozwiązywanie problemów

Nie używaj składni ChatML ani specjalnych tokenów z punktem końcowym uzupełniania czatu

Niektórzy klienci próbują użyć składni ChatML starszej generacji z punktami końcowymi dla uzupełniania czatu oraz nowszymi modelami. ChatML to funkcja w wersji zapoznawczej, która pracowała tylko z starszym punktem końcowym uzupełniania z modelem gpt-35-turbo wersji 0301. Ten model jest przewidziany do wycofania. Jeśli spróbujesz użyć składni ChatML z nowszymi modelami i punktem końcowym ukończenia czatu, może to spowodować błędy i nieoczekiwane zachowanie odpowiedzi modelu. Nie zalecamy tego użycia. Ten sam problem może wystąpić podczas korzystania z typowych tokenów specjalnych.

Kod błędu Komunikat o błędzie Rozwiązanie
400 400 — "Nie można wygenerować danych wyjściowych ze względu na specjalne tokeny w danych wejściowych". Monit zawiera specjalne tokeny lub starsze tokeny ChatML, które nie są rozpoznawane lub obsługiwane przez model/punkt końcowy. Upewnij się, że tablica monitów/komunikatów nie zawiera żadnych starszych tokenów ChatML/tokenów specjalnych. W przypadku uaktualniania ze starszego modelu wyklucz wszystkie tokeny specjalne przed przesłaniem żądania interfejsu API do modelu.

Nie można utworzyć ukończenia, ponieważ model wygenerował nieprawidłowe dane wyjściowe Unicode

Kod błędu Komunikat o błędzie Rozwiązanie
500 500 — InternalServerError: Kod błędu: 500 — {'error': {'message': "Nie można utworzyć ukończenia, ponieważ model wygenerował nieprawidłowe dane wyjściowe Unicode}}. Możesz zminimalizować występowanie tych błędów, zmniejszając temperaturę monitów do mniej niż 1 i upewniając się, że używasz klienta z logiką ponawiania prób. Ponowne wysyłanie żądania często prowadzi do pomyślnej odpowiedzi.

Dalsze kroki