Share via

Werken met de GPT-3.5-Turbo- en GPT-4-modellen

  • Artikel

De GPT-3.5-Turbo- en GPT-4-modellen zijn taalmodellen die zijn geoptimaliseerd voor gespreksinterfaces. De modellen gedragen zich anders dan de oudere GPT-3-modellen. Eerdere modellen waren tekst in en tekst, wat betekent dat ze een prompttekenreeks hebben geaccepteerd en een voltooiing hebben geretourneerd om aan de prompt toe te voegen. De GPT-3.5-Turbo- en GPT-4-modellen zijn echter gespreks- en berichtuitval. De modellen verwachten invoer die is opgemaakt in een specifieke transcriptie-indeling die lijkt op chats. Ze retourneren een voltooiing die een modelgeschreven bericht in de chat vertegenwoordigt. Deze indeling is speciaal ontworpen voor gesprekken met meerdere paden, maar het kan ook goed werken voor niet-chatscenario's.

In dit artikel wordt uitgelegd hoe u aan de slag gaat met de GPT-3.5-Turbo- en GPT-4-modellen. Gebruik de technieken die hier worden beschreven om de beste resultaten te krijgen. Probeer niet op dezelfde manier met de modellen te werken als met de oudere modelreeks, omdat de modellen vaak uitgebreid zijn en minder nuttige antwoorden bieden.

Werken met de GPT-3.5-Turbo- en GPT-4-modellen

In het volgende codefragment ziet u de meest eenvoudige manier om de GPT-3.5-Turbo- en GPT-4-modellen te gebruiken met de API voor chatvoltooiing. Als dit de eerste keer is dat u deze modellen programmatisch gebruikt, raden we u aan om te beginnen met de quickstart GPT-3.5-Turbo en GPT-4.

Notitie

In de Documentatie van Azure OpenAI verwijzen we naar GPT-3.5-Turbo en GPT-35-Turbo door elkaar. De officiële naam van het model op OpenAI is gpt-3.5-turbo. Voor Azure OpenAI is de naam gpt-35-turbovan het onderliggende model vanwege azure-specifieke tekenbeperkingen.

import os
from openai import AzureOpenAI

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

response = client.chat.completions.create(
    model="gpt-35-turbo", # 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-35-turbo",
  "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.

Notitie

De volgende parameters zijn niet beschikbaar voor de nieuwe GPT-35-Turbo- en GPT-4-modellen: logprobs, best_ofen echo. Als u een van deze parameters instelt, krijgt u een foutmelding.

Elk antwoord bevat finish_reason. De mogelijke waarden voor finish_reason zijn:

  • stop: API heeft volledige modeluitvoer geretourneerd.
  • lengte: Onvolledige modeluitvoer vanwege de max_tokens parameter of de tokenlimiet.
  • content_filter: Weggelaten inhoud vanwege een vlag van onze inhoudsfilters.
  • null: API-antwoord wordt nog steeds uitgevoerd of onvolledig.

Overweeg om een iets hogere waarde in te stellen max_tokens dan normaal, zoals 300 of 500. Een hogere waarde zorgt ervoor dat het model niet stopt met het genereren van tekst voordat het einde van het bericht wordt bereikt.

Versiebeheer model

Notitie

De versie gpt-35-turbo is gelijk aan het gpt-3.5-turbo model van OpenAI.

In tegenstelling tot eerdere GPT-3- en GPT-3.5-modellen, blijven het gpt-35-turbo model en de gpt-4 modellen gpt-4-32k bijgewerkt. Wanneer u een implementatie van deze modellen maakt, moet u ook een modelversie opgeven.

U vindt de buitengebruikstellingsdatums van het model voor deze modellen op de pagina modellen .

Werken met de API voor chatvoltooiing

OpenAI heeft de GPT-35-Turbo- en GPT-4-modellen getraind om invoer te accepteren die is opgemaakt als een gesprek. De berichtenparameter gebruikt een matrix met berichtobjecten met een gesprek georganiseerd op rol. Wanneer u de Python-API gebruikt, wordt er een lijst met woordenlijsten gebruikt.

De indeling van een eenvoudige voltooiing van een chat is:

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

Een gesprek met één voorbeeldantwoord gevolgd door een vraag ziet er als volgt uit:

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

Systeemrol

De systeemrol, ook wel het systeembericht genoemd, wordt aan het begin van de matrix opgenomen. Dit bericht bevat de eerste instructies voor het model. U kunt verschillende informatie opgeven in de systeemrol, zoals:

  • Een korte beschrijving van de assistent.
  • Persoonlijkheidskenmerken van de assistent.
  • Instructies of regels die de assistent moet volgen.
  • Gegevens of informatie die nodig is voor het model, zoals relevante vragen uit een veelgestelde vragen.

U kunt de systeemrol aanpassen voor uw use-case of basisinstructies opnemen. De systeemrol/het bericht is optioneel, maar we raden u aan ten minste een basisrol op te nemen om de beste resultaten te krijgen.

Berichten

Na de systeemrol kunt u een reeks berichten tussen de user en de assistant.

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

Als u een reactie van het model wilt activeren, eindigt u met een gebruikersbericht om aan te geven dat het de beurt is van de assistent om te reageren. U kunt ook een reeks voorbeeldberichten tussen de gebruiker en de assistent opnemen als een manier om weinig-shot learning uit te voeren.

Voorbeelden van berichtprompt

In de volgende sectie ziet u voorbeelden van verschillende stijlen van prompts die u kunt gebruiken met de GPT-35-Turbo- en GPT-4-modellen. Deze voorbeelden zijn slechts een uitgangspunt. U kunt experimenteren met verschillende prompts om het gedrag voor uw eigen use cases aan te passen.

Basisvoorbeeld

Als u wilt dat het GPT-35-Turbo-model zich op dezelfde manier gedraagt als chat.openai.com, kunt u een eenvoudig systeembericht zoals 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?"}

Voorbeeld met instructies

Voor sommige scenario's wilt u mogelijk meer instructies geven aan het model om kaders te definiëren voor wat het model kan doen.

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

Gegevens gebruiken voor aarding

U kunt ook relevante gegevens of informatie opnemen in het systeembericht om het model extra context te geven voor het gesprek. Als u slechts een kleine hoeveelheid informatie wilt opnemen, kunt u deze in het systeembericht hard coden. Als u een grote hoeveelheid gegevens hebt waarvan het model op de hoogte moet zijn, kunt u insluitingen of een product zoals Azure AI Search gebruiken om de meest relevante informatie op het moment van de query op te halen.

{"role": "system", "content": "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."
},
{"role": "user", "content": "What is Azure OpenAI Service?"}

Weinig schots leren met chatvoltooiing

U kunt ook enkele voorbeelden aan het model geven. De benadering voor weinig-shot learning is enigszins gewijzigd vanwege de nieuwe promptindeling. U kunt nu een reeks berichten opnemen tussen de gebruiker en de assistent in de prompt als enkele voorbeelden. Met behulp van deze voorbeelden kunt u antwoorden op veelgestelde vragen zaaien om het model te primen of bepaalde gedragingen aan het model te leren.

In dit voorbeeld ziet u hoe u weinig-shot learning kunt gebruiken met GPT-35-Turbo en GPT-4. U kunt experimenteren met verschillende benaderingen om te zien wat het beste werkt voor uw use-case.

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

Chatvoltooiing gebruiken voor niet-chatscenario's

De CHAT-voltooiings-API is ontworpen om te werken met gesprekken met meerdere paden, maar het werkt ook goed voor niet-chatscenario's.

Voor een scenario voor entiteitextractie kunt u bijvoorbeeld de volgende prompt gebruiken:

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

Een eenvoudige gesprekslus maken

In de voorbeelden tot nu toe ziet u de basismechanica van interactie met de CHAT-voltooiings-API. In dit voorbeeld ziet u hoe u een gesprekslus maakt waarmee de volgende acties worden uitgevoerd:

  • Neemt continu console-invoer en maakt deze correct op als onderdeel van de berichtenlijst als inhoud van de gebruikersrol.
  • Hiermee worden antwoorden uitgevoerd die worden afgedrukt naar de console en opgemaakt en toegevoegd aan de berichtenlijst als assistentrolinhoud.

Telkens wanneer er een nieuwe vraag wordt gesteld, wordt er een lopende transcriptie van het gesprek verzonden, samen met de laatste vraag. Omdat het model geen geheugen heeft, moet u een bijgewerkte transcriptie verzenden met elke nieuwe vraag of verliest het model de context van de vorige vragen en antwoorden.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-02-01",
  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-35-turbo", # model = "deployment_name".
        messages=conversation
    )

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

Wanneer u de voorgaande code uitvoert, krijgt u een leeg consolevenster. Voer uw eerste vraag in het venster in en selecteer vervolgens de Enter sleutel. Nadat het antwoord is geretourneerd, kunt u het proces herhalen en vragen blijven stellen.

Gesprekken beheren

Het vorige voorbeeld wordt uitgevoerd totdat u de tokenlimiet van het model hebt bereikt. Bij elke vraag die wordt gesteld en het antwoord is ontvangen, wordt de messages lijst groter. De tokenlimiet voor gpt-35-turbo is 4.096 tokens. De tokenlimieten voor gpt-4 respectievelijk gpt-4-32k 8.192 en 32.768. Deze limieten omvatten het aantal tokens van zowel de verzonden berichtenlijst als het modelantwoord. Het aantal tokens in de berichtenlijst in combinatie met de waarde van de max_tokens parameter moet onder deze limieten blijven of u ontvangt een foutmelding.

Het is uw verantwoordelijkheid om ervoor te zorgen dat de prompt en voltooiing binnen de tokenlimiet vallen. Voor langere gesprekken moet u het aantal tokens bijhouden en alleen het model een prompt verzenden die binnen de limiet valt.

Notitie

We raden u ten zeerste aan binnen de gedocumenteerde limiet voor invoertoken te blijven voor alle modellen, zelfs als u ontdekt dat u die limiet kunt overschrijden.

In het volgende codevoorbeeld ziet u een eenvoudig voorbeeld van een chatlus met een techniek voor het verwerken van een telling van 4096 token met behulp van de tiktokenbibliotheek van OpenAI.

De code maakt gebruik van tiktoken 0.5.1. Als u een oudere versie hebt, voert u deze uit 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-02-01",
  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")

In dit voorbeeld worden de oudste berichten in het gesprektranscriptie verwijderd nadat het aantal tokens is bereikt. Voor efficiëntie wordt del gebruikt in plaats van pop(). We beginnen bij index 1 om het systeembericht altijd te behouden en alleen gebruikers- of assistentberichten te verwijderen. Door deze methode voor het beheren van het gesprek kan de gesprekskwaliteit na verloop van tijd afnemen, omdat het model geleidelijk de context van de eerdere gedeelten van het gesprek verliest.

Een alternatieve methode is om de gespreksduur te beperken tot de maximale tokenlengte of een bepaald aantal beurten. Nadat de maximale tokenlimiet is bereikt, verliest het model context als u het gesprek toestaat door te gaan. U kunt de gebruiker vragen een nieuw gesprek te starten en de berichtenlijst te wissen om een nieuw gesprek te starten met de volledige tokenlimiet die beschikbaar is.

Het tokentellinggedeelte van de code dat eerder is gedemonstreerd, is een vereenvoudigde versie van een van de kookboekvoorbeelden van OpenAI.

Probleemoplossing

Hier volgt een tip voor het oplossen van problemen.

Gebruik geen ChatML-syntaxis of speciale tokens met het eindpunt voor voltooiing van de chat

Sommige klanten proberen de verouderde ChatML-syntaxis te gebruiken met de eindpunten voor chatvoltooiing en nieuwere modellen. ChatML was een preview-functie die alleen werkte met het verouderde voltooiingseindpunt met het gpt-35-turbo versie 0301-model. Dit model is bedoeld voor buitengebruikstelling. Als u de ChatML-syntaxis probeert te gebruiken met nieuwere modellen en het eindpunt voor voltooiing van de chat, kan dit leiden tot fouten en onverwacht gedrag van het modelantwoord. Dit gebruik wordt niet aanbevolen. Dit probleem kan zich voordoen bij het gebruik van algemene speciale tokens.

Foutcode Foutbericht Oplossing
400 400 - 'Kan geen uitvoer genereren vanwege speciale tokens in de invoer'. Uw prompt bevat speciale tokens of verouderde ChatML-tokens die niet worden herkend of ondersteund door het model/eindpunt. Zorg ervoor dat uw prompt-/berichtenmatrix geen verouderde ChatML-tokens/speciale tokens bevat. Als u een upgrade uitvoert van een verouderd model, sluit u alle speciale tokens uit voordat u een API-aanvraag naar het model verzendt.

Kan voltooiing niet maken omdat het model ongeldige Unicode-uitvoer heeft gegenereerd

Foutcode Foutbericht Tijdelijke oplossing
500 500 - InternalServerError: Foutcode: 500 - {'error': {'message': 'Kan voltooiing niet maken omdat het model ongeldige Unicode-uitvoer heeft gegenereerd}}. U kunt het voorkomen van deze fouten minimaliseren door de temperatuur van uw prompts te verlagen naar minder dan 1 en ervoor te zorgen dat u een client gebruikt met logica voor opnieuw proberen. Het opnieuw voltooien van de aanvraag resulteert vaak in een geslaagd antwoord.

Volgende stappen