Condividi tramite

Usare i modelli GPT-3.5-Turbo, GPT-4 e GPT-4o

  • Articolo

I modelli della serie GPT-3.5-Turbo, GPT-4 e GPT-4o sono modelli linguistici ottimizzati per le interfacce conversazionali. I modelli si comportano in modo diverso rispetto ai modelli GPT-3 precedenti. I modelli precedenti erano text-in e text-out, il che significa che accettavano una stringa di richiesta e restituivano un completamento da aggiungere alla richiesta. Tuttavia, i modelli più recenti sono conversation-in e message-out. I modelli prevedono che l'input sia formattato in un formato di trascrizione tipo chat specifico. Restituiscono un completamento che rappresenta un messaggio scritto dal modello nella chat. Questo formato è stato progettato specificamente per le conversazioni a più turni, ma può anche funzionare bene per gli scenari non di chat.

Questo articolo illustra come iniziare a usare i modelli di completamento della chat. Per ottenere i risultati migliori, usare le tecniche descritte qui. Non provare a interagire con i modelli allo stesso modo con la serie di modelli meno recenti perché i modelli sono spesso prolissi e forniscono risposte meno utili.

Usare i modelli di completamento della chat

Il frammento di codice seguente illustra il modo più semplice per interagire con i modelli che usano l'API Completamento chat. Se questa è la prima volta che si usano questi modelli a livello di codice, è consigliabile iniziare con la guida introduttiva al completamento della chat.

Nota

Nella documentazione di Azure OpenAI, si fa riferimento a GPT-3.5-Turbo e GPT-35-Turbo in modo intercambiabile. Il nome ufficiale del modello in OpenAI è gpt-3.5-turbo. Per OpenAI di Azure, a causa di vincoli di caratteri specifici di Azure, il nome del modello sottostante è gpt-35-turbo.

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.

Nota

I parametri seguenti non sono disponibili con i nuovi modelli GPT-35-Turbo e GPT-4: logprobs, best_of e echo. Se si imposta uno di questi parametri, viene visualizzato un errore.

Ogni risposta include finish_reason. I possibili valori per finish_reason sono:

  • stop: l'API ha restituito l'output completo del modello.
  • length: output del modello incompleto a causa del parametro max_tokens o del limite di token.
  • content_filter: omesso contenuto a causa di un flag dai filtri di contenuto.
  • null: la risposta dell'API è ancora in corso o è incompleta.

Prendere in considerazione l'impostazione di max_tokens a un valore leggermente superiore a quello normale, ad esempio 300 o 500. Un valore superiore garantisce che il modello non interrompa la generazione di testo prima che raggiunga la fine del messaggio.

Gestione della versione dei modelli

Nota

La versione gpt-35-turbo equivale al modello di gpt-3.5-turbo da OpenAI.

A differenza dei modelli GPT-3 e GPT-3.5 precedenti, il modello gpt-35-turbo e i modelli gpt-4 e gpt-4-32k continueranno a essere aggiornati. Quando si crea una distribuzione di questi modelli, è necessario specificare anche una versione del modello.

È possibile trovare le date di ritiro del modello per questi modelli nella pagina modelli.

Usare l'API Completamento chat

OpenAI ha eseguito il training dei modelli GPT-35-Turbo e GPT-4 per accettare l'input formattato come conversazione. Il parametro messages accetta una matrice di oggetti messaggio con una conversazione organizzata per ruolo. Quando si usa l'API Python, viene usato un elenco di dizionari.

Il formato di completamento di una chat di base è:

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

Una conversazione con una risposta di esempio seguita da una domanda sarà simile alla seguente:

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

Ruolo del sistema

Il ruolo di sistema, noto anche come messaggio di sistema, è incluso all'inizio della matrice. Questo messaggio fornisce le istruzioni iniziali per il modello. È possibile fornire varie informazioni nel ruolo del sistema, ad esempio:

  • Breve descrizione dell'assistente.
  • Tratti di personalità dell'assistente.
  • Istruzioni o regole che si desidera che l'assistente segua.
  • Dati o informazioni necessari per il modello, ad esempio le domande pertinenti di una domanda frequenti.

È possibile personalizzare il ruolo di sistema per il caso d'uso o includere istruzioni di base. Il ruolo o il messaggio di sistema è facoltativo, ma è consigliabile includere almeno uno di base per ottenere i risultati migliori.

Messaggi

Dopo il ruolo di sistema, è possibile includere una serie di messaggi tra user e assistant.

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

Per attivare una risposta dal modello, terminare con un messaggio utente per indicare che è il turno dell'assistente per rispondere. È possibile includere anche una serie di messaggi di esempio tra l'utente e l'assistente per eseguire alcuni scatti di apprendimento.

Esempi di prompt dei messaggi

La sezione seguente mostra esempi di diversi stili di richieste che è possibile usare con i modelli GPT-35-Turbo e GPT-4. Questi esempi sono solo un punto di partenza. È possibile sperimentare richieste diverse per personalizzare il comportamento per i propri casi d'uso.

Esempio di base

Se si vuole che il modello GPT-35-Turbo si comporti in modo analogo a chat.openai.com, è possibile usare un messaggio di sistema di base come 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?"}

Esempio con istruzioni

Per alcuni scenari, potrebbe essere necessario fornire altre istruzioni al modello per definire limitazioni per le operazioni che il modello è in grado di eseguire.

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

Usare i dati per il grounding

È anche possibile includere dati o informazioni pertinenti nel messaggio di sistema per fornire al modello un contesto aggiuntivo per la conversazione. Se è necessario includere solo una piccola quantità di informazioni, è possibile impostarla come hardcoded nel messaggio di sistema. Se si dispone di una grande quantità di dati che il modello deve conoscere, è possibile usare incorporamenti o un prodotto come Azure AI Search per recuperare le informazioni più rilevanti in fase di query.

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

Alcuni scatti di apprendimento con il completamento della chat

È anche possibile fornire alcuni esempi di scatti al modello. L'approccio per pochi scatti di apprendimento è cambiato leggermente a causa del nuovo formato di richiesta. Ora è possibile includere una serie di messaggi tra l'utente e l'assistente nella richiesta come esempi di scatti. Usando questi esempi, è possibile eseguire il seeding delle risposte alle domande comuni per prime il modello o insegnare comportamenti specifici al modello.

Questo esempio mostra come usare l'apprendimento con pochi scatti con GPT-35-Turbo e GPT-4. È possibile sperimentare diversi approcci per vedere cosa funziona meglio per il caso d'uso.

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

Usare il completamento della chat per scenari non di chat

L'API Completamento delle chat è progettata per lavorare con conversazioni a più turni, ma funziona bene anche per scenari non di chat.

Ad esempio, per uno scenario di estrazione di entità, è possibile usare il prompt seguente:

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

Creare un ciclo di conversazione di base

Gli esempi finora mostrano i meccanismi di base dell'interazione con l'API di completamento della chat. In questo esempio viene illustrato come creare un ciclo di conversazione che esegua le azioni seguenti:

  • Accetta continuamente l'input della console e lo formatta correttamente come parte dell'elenco di messaggi come contenuto del ruolo utente.
  • Restituisce le risposte stampate nella console e formattate e aggiunte all'elenco dei messaggi come contenuto del ruolo assistente.

Ogni volta che viene posta una nuova domanda, viene inviata una trascrizione in esecuzione della conversazione fino a questo momento insieme alla domanda più recente. Poiché il modello non ha memoria, è necessario inviare una trascrizione aggiornata con ogni nuova domanda o il modello perderà il contesto delle domande e delle risposte precedenti.

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

Quando si esegue il codice precedente, si ottiene una finestra della console vuota. Immettere la prima domanda nella finestra e quindi selezionare la chiave Enter. Una volta restituita la risposta, è possibile ripetere il processo e continuare a porre domande.

Gestire le conversazioni

L'esempio precedente viene eseguito fino a raggiungere il limite di token del modello. A ogni domanda posta e a ogni risposta ricevuta, l'elenco messages aumenta di dimensioni. Il limite di token per gpt-35-turbo è 4.096 token. I limiti dei token per gpt-4 e gpt-4-32k sono rispettivamente 8.192 e 32.768. Questi limiti includono il conteggio dei token dell'elenco di messaggi inviato e della risposta del modello. Il numero di token nell'elenco di messaggi combinato con il valore del parametro max_tokens deve rimanere al di sotto di questi limiti o si riceve un errore.

È responsabilità dell'utente assicurarsi che la richiesta e il completamento siano compresi nel limite di token. Per conversazioni più lunghe, è necessario tenere traccia del conteggio dei token e inviare al modello solo un prompt che rientri nel limite.

Nota

È consigliabile rimanere entro il limite di token di input documentato per tutti i modelli, anche se si scopre che è possibile superare tale limite.

L'esempio di codice seguente illustra un semplice esempio di ciclo di chat con una tecnica per gestire un conteggio dei token 4.096 usando la libreria tiktoken di OpenAI.

Il codice usa il tiktoken 0.5.1. Se si dispone di una versione precedente, eseguire 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 questo esempio, dopo il raggiungimento del numero di token, i messaggi meno recenti nella trascrizione della conversazione vengono rimossi. Per garantire l'efficienza, del viene usato al posto di pop(). Si inizia con l'indice 1 per mantenere sempre il messaggio di sistema e rimuovere solo i messaggi utente o assistente. Nel tempo, questo metodo di gestione della conversazione può causare un degrado della qualità della conversazione poiché il modello perde gradualmente il contesto delle parti precedenti della conversazione.

Un approccio alternativo consiste nel limitare la durata della conversazione alla lunghezza massima del token o a un numero specifico di turni. Dopo aver raggiunto il limite massimo di token, il modello perde il contesto se si vuole consentire la continuazione della conversazione. È possibile richiedere all'utente di iniziare una nuova conversazione e cancellare l'elenco dei messaggi per avviare una nuova conversazione con il limite di token completo disponibile.

La parte del conteggio dei token del codice illustrata in precedenza è una versione semplificata di uno degli esempi di cookbook di OpenAI.

Risoluzione dei problemi

Ecco un suggerimento per la risoluzione dei problemi.

Non usare la sintassi chatML o i token speciali con l'endpoint di completamento della chat

Alcuni clienti tentano di usare la sintassi chatML di legacy con gli endpoint di completamento della chat e i modelli più recenti. ChatML era una funzionalità di anteprima che funzionava solo con l'endpoint di completamenti di legacy con il modello 0301 versione gpt-35-turbo. Questo modello è previsto per il ritiro. Se si tenta di usare la sintassi ChatML con modelli più recenti e l'endpoint di completamento della chat, può generare errori e comportamenti imprevisti della risposta del modello. Non è consigliabile usarlo. Questo stesso problema può verificarsi quando si usano token speciali comuni.

Codice di errore Messaggio di errore Soluzione
400 400 - "Impossibile generare l'output a causa di token speciali nell'input". Il prompt contiene token speciali o token ChatML di legacy non riconosciuti o supportati dal modello/endpoint. Assicurarsi che la matrice richiesta/messaggi non contenga token ChatML di legacy/token speciali. Se si esegue l'aggiornamento da un modello di legacy, escludere tutti i token speciali prima di inviare una richiesta API al modello.

Impossibile creare il completamento perché l'output Unicode generato dal modello non è valido

Codice di errore Messaggio di errore Soluzione alternativa
500 500 - InternalServerError: Codice errore: 500 - {'error': {'message': ‘Impossibile creare il completamento perché l'output Unicode generato dal modello non è valido}}. È possibile ridurre al minimo l'occorrenza di questi errori riducendo la temperatura dei prompt a meno di 1 e assicurandosi di usare un client con logica di ripetizione dei tentativi. La ripetizione della richiesta comporta spesso una risposta con esito positivo.

Passaggi successivi