Usare i modelli GPT-3.5-Turbo e GPT-4
I modelli GPT-3.5-Turbo e GPT-4 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 al prompt. Tuttavia, i modelli GPT-3.5-Turbo e GPT-4 sono di conversazione e messaggi. I modelli prevedono che l'input sia formattato in un formato di trascrizione simile a 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 GPT-3.5-Turbo e GPT-4. 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 verbosi e forniscono risposte meno utili.
Usare i modelli GPT-3.5-Turbo e GPT-4
Il frammento di codice seguente illustra il modo più semplice per usare i modelli GPT-3.5-Turbo e GPT-4 con l'API Di completamento chat. Se questa è la prima volta che si usano questi modelli a livello di codice, è consigliabile iniziare con la guida introduttiva GPT-3.5-Turbo e GPT-4.
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 Azure OpenAI, 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
max_tokensparametro o del limite di token. - content_filter: omesso contenuto a causa di un flag dai filtri di contenuto.
- null: risposta API ancora in corso o incompleta.
Prendere in considerazione l'impostazione max_tokens di un valore leggermente superiore al 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 gpt-3.5-turbo modello da OpenAI.
A differenza dei modelli GPT-3 e GPT-3.5 precedenti, il gpt-35-turbo modello e i gpt-4 modelli 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 dei 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. È anche possibile includere una serie di messaggi di esempio tra l'utente e l'assistente come modo per eseguire l'apprendimento con pochi scatti.
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 simile a chat.openai.com, è possibile usare un messaggio di sistema di base, ad esempio 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, è possibile fornire altre istruzioni al modello per definire protezioni 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 Ricerca di intelligenza artificiale di Azure 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?"}
Apprendimento con pochi scatti con il completamento della chat
È anche possibile fornire alcuni esempi al modello. L'approccio per l'apprendimento con pochi scatti è leggermente cambiato a causa del nuovo formato di richiesta. È ora possibile includere una serie di messaggi tra l'utente e l'assistente nel prompt come esempi di pochi 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 chat è progettata per funzionare con conversazioni a più turni, ma funziona anche bene per gli 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 Enter chiave. Dopo aver restituito 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 del 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 max_tokens parametro 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 numero di token e inviare solo al modello un prompt che rientra 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 la gestione di un numero di token di 4.096 token usando la libreria tiktoken di OpenAI.
Il codice usa tiktoken 0.5.1. Se si ha 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 l'efficienza, del viene usato invece di pop(). Si inizia con l'indice 1 per mantenere sempre il messaggio di sistema e rimuovere solo i messaggi utente o assistente. Nel corso del 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 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 legacy con il gpt-35-turbo modello versione 0301. 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 legacy non riconosciuti o supportati dal modello/endpoint. Assicurarsi che la matrice prompt/messages non contenga token ChatML legacy/token speciali. Se si esegue l'aggiornamento da un modello 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': 'Failed to create completion as the model generated invalid Unicode output}}. | È 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
- Altre informazioni su Azure OpenAI.
- Introduzione al modello GPT-35-Turbo con la guida introduttiva GPT-35-Turbo.
- Per altri esempi, vedere il repository GitHub degli esempi di Azure OpenAI.