Udostępnij za pośrednictwem

Chat Markup Language ChatML (wersja zapoznawcza)

  • Artykuł

Ważne

Korzystanie z modeli GPT-3.5-Turbo z punktem końcowym ukończenia zgodnie z opisem w tym artykule pozostaje w wersji zapoznawczej i jest możliwe gpt-35-turbo tylko w wersji (0301), która jest planowana na emeryturę już 1 sierpnia 2024 r. Zdecydowanie zalecamy używanie interfejsu API/punktu końcowego uzupełniania czatu ogólnie dostępnego. Interfejs API uzupełniania czatu jest zalecaną metodą interakcji z modelami GPT-3.5-Turbo. Interfejs API uzupełniania czatu jest również jedynym sposobem uzyskiwania dostępu do modeli GPT-4.

Poniższy fragment kodu przedstawia najbardziej podstawowy sposób używania modeli GPT-3.5-Turbo z językiem ChatML. Jeśli po raz pierwszy używasz tych modeli programowo, zalecamy rozpoczęcie od naszego przewodnika Szybki start GPT-35-Turbo &GPT-4.

Uwaga

W dokumentacji usługi Azure OpenAI odwołujemy się do GPT-3.5-Turbo i GPT-35-Turbo zamiennie. Oficjalna nazwa modelu w usłudze OpenAI to gpt-3.5-turbo, ale w przypadku usługi Azure OpenAI z powodu ograniczeń znaków specyficznych dla platformy Azure nazwa bazowego modelu to gpt-35-turbo.

import os
import openai
openai.api_type = "azure"
openai.api_base = "https://{your-resource-name}.openai.azure.com/"
openai.api_version = "2024-02-01"
openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.Completion.create(
  engine="gpt-35-turbo", # The deployment name you chose when you deployed the GPT-35-Turbo model
  prompt="<|im_start|>system\nAssistant is a large language model trained by OpenAI.\n<|im_end|>\n<|im_start|>user\nWho were the founders of Microsoft?\n<|im_end|>\n<|im_start|>assistant\n",
  temperature=0,
  max_tokens=500,
  top_p=0.5,
  stop=["<|im_end|>"])

print(response['choices'][0]['text'])

Uwaga

Następujące parametry nie są dostępne w modelu gpt-35-turbo: logprobs, best_ofi echo. Jeśli ustawisz dowolny z tych parametrów, zostanie wyświetlony błąd.

Token <|im_end|> wskazuje koniec komunikatu. W przypadku korzystania z języka ChatML zaleca się dołączenie <|im_end|> tokenu jako sekwencji zatrzymania, aby upewnić się, że model przestaje generować tekst po osiągnięciu końca komunikatu.

Rozważ ustawienie max_tokens nieco wyższej wartości niż zwykle, na przykład 300 lub 500. Dzięki temu model nie przestanie generować tekstu, zanim osiągnie koniec komunikatu.

Wersje modelu danych

Uwaga

gpt-35-turbo jest odpowiednikiem modelu z interfejsu gpt-3.5-turbo OpenAI.

W przeciwieństwie do poprzednich modeli gpt-35-turbo GPT-3 i GPT-3.5, model, a także gpt-4 modele i gpt-4-32k będą nadal aktualizowane. Podczas tworzenia wdrożenia tych modeli należy również określić wersję modelu.

Daty wycofania modelu dla tych modeli można znaleźć na naszej stronie modeli .

Praca z językiem znaczników czatu (ChatML)

Uwaga

OpenAI nadal ulepsza GPT-35-Turbo, a język znaczników czatu używany z modelami będzie nadal ewoluował w przyszłości. Ten dokument zostanie zaktualizowany o najnowsze informacje.

OpenAI trenował GPT-35-Turbo na specjalnych tokenach, które definiują różne części monitu. Monit rozpoczyna się od komunikatu systemowego używanego do tworzenia podstaw modelu, po którym następuje seria komunikatów między użytkownikiem a asystentem.

Format podstawowego monitu chatML jest następujący:

<|im_start|>system 
Provide some context and/or instructions to the model.
<|im_end|> 
<|im_start|>user 
The user’s message goes here
<|im_end|> 
<|im_start|>assistant

Komunikat systemowy

Komunikat systemowy jest dołączany na początku monitu <|im_start|>system między tokenami i <|im_end|> . Ten komunikat zawiera początkowe instrukcje dotyczące modelu. W komunikacie systemowym można podać różne informacje, w tym:

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

Możesz dostosować komunikat systemowy dla danego przypadku użycia lub po prostu dołączyć podstawowy komunikat systemowy. Komunikat systemowy jest opcjonalny, ale zaleca się uwzględnienie przynajmniej podstawowego komunikatu w celu uzyskania najlepszych wyników.

Wiadomości

Po komunikacie systemowym można dołączyć serię komunikatów między użytkownikiem a asystentem. Każdy komunikat powinien rozpoczynać się od tokenu <|im_start|> , po którym następuje rola (user lub assistant) i zakończyć tokenem <|im_end|> .

<|im_start|>user
What is thermodynamics?
<|im_end|>

Aby wyzwolić odpowiedź z modelu, monit powinien kończyć się tokenem <|im_start|>assistant wskazującym, że odpowiada asystent. Możesz również uwzględnić komunikaty między użytkownikiem a asystentem w wierszu polecenia w celu wykonania kilku uczenia.

Przykłady promptów

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

Przykład podstawowy

Jeśli chcesz, aby modele GPT-35-Turbo i GPT-4 zachowywały się podobnie do chat.openai.com, możesz użyć podstawowego komunikatu systemowego, takiego jak "Asystent jest dużym modelem językowym wyszkolonym przez openAI".

<|im_start|>system
Assistant is a large language model trained by OpenAI.
<|im_end|>
<|im_start|>user
Who were the founders of Microsoft?
<|im_end|>
<|im_start|>assistant

Przykład z instrukcjami

W przypadku niektórych scenariuszy możesz podać dodatkowe instrukcje dla modelu, aby zdefiniować bariery ochronne dla tego, co może zrobić model.

<|im_start|>system
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.
<|im_end|>
<|im_start|>user
When are my taxes due?
<|im_end|>
<|im_start|>assistant

Używanie danych do uziemienia

Możesz również uwzględnić odpowiednie dane lub informacje w komunikacie systemowym, aby nadać modelowi dodatkowy kontekst konwersacji. Jeśli musisz tylko dołączyć niewielką ilość informacji, możesz go wykodować 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.

<|im_start|>system
Assistant is an intelligent chatbot designed to help users answer technical questions about Azure OpenAI Serivce. 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 Service provides REST API access to OpenAI's powerful language models including the GPT-3, Codex and Embeddings model series.
- Azure OpenAI Service 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
<|im_end|>
<|im_start|>user
What is Azure OpenAI Service?
<|im_end|>
<|im_start|>assistant

Niewiele uczenia się za pomocą usługi ChatML

Możesz również podać kilka przykładów strzałów do modelu. Podejście do kilku uczenia strzałów nieco się zmieniło z powodu nowego formatu monitu. Teraz możesz dołączyć serię komunikatów między użytkownikiem a asystentem w wierszu polecenia, jak tylko kilka przykładów. Te przykłady mogą służyć do rozmieszczania odpowiedzi na typowe pytania, aby zastosować podstawy modelu lub nauczyć określone zachowania modelu.

Jest to tylko jeden przykład wykorzystania kilku uczenia strzałowego z GPT-35-Turbo. Możesz eksperymentować z różnymi podejściami, aby zobaczyć, co działa najlepiej w przypadku użycia.

<|im_start|>system
Assistant is an intelligent chatbot designed to help users answer their tax related questions. 
<|im_end|>
<|im_start|>user
When do I need to file my taxes by?
<|im_end|>
<|im_start|>assistant
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
<|im_end|>
<|im_start|>user
How can I check the status of my tax refund?
<|im_end|>
<|im_start|>assistant
You can check the status of your tax refund by visiting https://www.irs.gov/refunds
<|im_end|>

Używanie języka znaczników czatu dla scenariuszy niezwiązanych z czatem

Usługa ChatML została zaprojektowana tak, aby ułatwić zarządzanie konwersacjami wieloeściowymi, ale działa również dobrze w scenariuszach niezwiązanych z czatami.

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

<|im_start|>system
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": ""
}
<|im_end|>
<|im_start|>user
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?
<|im_end|>
<|im_start|>assistant

Zapobieganie niebezpiecznym wejściom użytkownika

Ważne jest, aby dodać środki zaradcze do aplikacji, aby zapewnić bezpieczne korzystanie z języka znaczników czatu.

Zalecamy uniemożliwienie użytkownikom końcowym dołączania specjalnych tokenów do danych wejściowych, takich jak <|im_start|> i <|im_end|>. Zalecamy również dołączenie dodatkowej weryfikacji, aby upewnić się, że monity wysyłane do modelu są prawidłowo sformułowane i postępuj zgodnie z opisem w tym dokumencie w formacie Chat Markup Language.

Możesz również podać instrukcje w komunikacie systemowym, aby kierować modelem w zakresie reagowania na określone typy danych wejściowych użytkownika. Na przykład możesz poinstruować model, aby odpowiadał tylko na wiadomości dotyczące określonego tematu. Możesz również wzmocnić to zachowanie za pomocą kilku przykładów strzałów.

Zarządzanie konwersacjami

Limit tokenu dla gpt-35-turbo to 4096 tokenów. Ten limit obejmuje liczbę tokenów zarówno z monitu, jak i ukończenia. Liczba tokenów w wierszu polecenia w połączeniu z wartością max_tokens parametru musi pozostać poniżej 4096 lub zostanie wyświetlony błąd.

Twoim zadaniem jest upewnienie się, że monit i ukończenie mieści się w limicie tokenu. Oznacza to, że 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 tokenu.

Poniższy przykładowy kod przedstawia prosty przykład sposobu śledzenia oddzielnych wiadomości w konwersacji.

import os
import openai
openai.api_type = "azure"
openai.api_base = "https://{your-resource-name}.openai.azure.com/" #This corresponds to your Azure OpenAI resource's endpoint value
openai.api_version = "2024-02-01" 
openai.api_key = os.getenv("OPENAI_API_KEY")

# defining a function to create the prompt from the system message and the conversation messages
def create_prompt(system_message, messages):
    prompt = system_message
    for message in messages:
        prompt += f"\n<|im_start|>{message['sender']}\n{message['text']}\n<|im_end|>"
    prompt += "\n<|im_start|>assistant\n"
    return prompt

# defining the user input and the system message
user_input = "<your user input>" 
system_message = f"<|im_start|>system\n{'<your system message>'}\n<|im_end|>"

# creating a list of messages to track the conversation
messages = [{"sender": "user", "text": user_input}]

response = openai.Completion.create(
    engine="gpt-35-turbo", # The deployment name you chose when you deployed the GPT-35-Turbo model.
    prompt=create_prompt(system_message, messages),
    temperature=0.5,
    max_tokens=250,
    top_p=0.9,
    frequency_penalty=0,
    presence_penalty=0,
    stop=['<|im_end|>']
)

messages.append({"sender": "assistant", "text": response['choices'][0]['text']})
print(response['choices'][0]['text'])

Pozostawanie w limicie tokenu

Najprostszym podejściem do utrzymania limitu tokenu jest usunięcie najstarszych wiadomości w konwersacji po osiągnięciu limitu tokenu.

Możesz zawsze uwzględniać jak najwięcej tokenów, pozostając w limicie lub zawsze można uwzględnić określoną liczbę poprzednich komunikatów przy założeniu, że te komunikaty pozostają w limicie. Należy pamiętać, że dłuższe monity generują odpowiedź i generują wyższe koszty niż krótsze monity.

Liczbę tokenów w ciągu można oszacować przy użyciu biblioteki języka Python tiktoken , jak pokazano poniżej.

import tiktoken 

cl100k_base = tiktoken.get_encoding("cl100k_base") 

enc = tiktoken.Encoding( 
    name="gpt-35-turbo",  
    pat_str=cl100k_base._pat_str, 
    mergeable_ranks=cl100k_base._mergeable_ranks, 
    special_tokens={ 
        **cl100k_base._special_tokens, 
        "<|im_start|>": 100264, 
        "<|im_end|>": 100265
    } 
) 

tokens = enc.encode( 
    "<|im_start|>user\nHello<|im_end|><|im_start|>assistant",  
    allowed_special={"<|im_start|>", "<|im_end|>"} 
) 

assert len(tokens) == 7 
assert tokens == [100264, 882, 198, 9906, 100265, 100264, 78191]

Następne kroki