Saídas previstas Copiar página
Reduza a latência para respostas de modelos em que grande parte da
resposta é conhecida com antecedência.
Saídas Previstas permitem que você acelere as respostas da API de Conclusões de Chat quando
muitos dos tokens de saída são conhecidos com antecedência. Isso é mais comum quando você
está regenerando um arquivo de texto ou código com pequenas modificações. Você pode fornecer
sua previsão usando o prediction parâmetro de solicitação em Conclusões de Chat .
As Saídas Previstas estão disponíveis hoje usando os modelos mais recentes gpt-4o e gpt-4o-mini .
Continue lendo para aprender como usar Saídas Previstas para reduzir a latência em seus
aplicativos.
Exemplo de refatoração de código
Saídas Preditas são particularmente úteis para regenerar documentos de texto e arquivos de código
com pequenas modificações. Digamos que você queira que o modelo GPT-4o refatore um pedaço
de código TypeScript e converta a username propriedade da User classe para ser email :
1 class User {
2 firstName: string = "";
3 lastName: string = "";
4 username: string = "";
5 }
6
7 export default User;
A maior parte do arquivo permanecerá inalterada, exceto a linha 4 acima. Se você usar o texto atual
do arquivo de código como sua previsão, poderá regenerar o arquivo inteiro com latência menor.
Essas economias de tempo aumentam rapidamente para arquivos maiores.
Abaixo está um exemplo de uso do prediction parâmetro em nossos SDKs para prever que a saída
final do modelo será muito semelhante ao nosso arquivo de código original, que usamos como texto
de previsão.
Refatorar uma classe TypeScript com uma saída prevista Javascript-escritor
1 import OpenAI from "openai";
2
3 const code = `
4 class User {
5 firstName: string = "";
6 lastName: string = "";
7 username: string = "";
8 }
9
10 export default User;
11 `.trim();
12
13 const openai = new OpenAI();
14
15 const refactorPrompt = `
16 Replace the "username" property with an "email" property. Respond only
17 with code, and with no markdown formatting.
18 `;
19
20 const completion = await [Link]({
21 model: "gpt-4o",
22 messages: [
23 {
24 role: "user",
25 content: refactorPrompt
26 },
27 {
28 role: "user",
29 content: code
30 }
31 ],
32 store: true,
33 prediction: {
34 type: "content",
35 content: code
36 }
37 });
38
39 // Inspect returned data
40 [Link](completion);
41 [Link]([Link][0].[Link]);
Além do código refatorado, a resposta do modelo conterá dados semelhantes a estes:
1 {
2 id: 'chatcmpl-xxx',
3 object: '[Link]',
4 created: 1730918466,
5 model: 'gpt-4o-2024-08-06',
6 choices: [ /* ...actual text response here... */],
7 usage: {
8 prompt_tokens: 81,
9 completion_tokens: 39,
10 total_tokens: 120,
11 prompt_tokens_details: { cached_tokens: 0, audio_tokens: 0 },
12 completion_tokens_details: {
13 reasoning_tokens: 0,
14 audio_tokens: 0,
15 accepted_prediction_tokens: 18,
16 rejected_prediction_tokens: 10
17 }
18 },
19 system_fingerprint: 'fp_159d8341cc'
20 }
Note tanto o accepted_prediction_tokens e rejected_prediction_tokens no usage objeto. Neste exemplo,
18 tokens da predição foram usados para acelerar a resposta, enquanto 10 foram rejeitados.
Observe que quaisquer tokens rejeitados ainda serão cobrados como outros tokens de conclusão gerados
pela API, portanto, as Saídas Previstas podem introduzir custos mais altos para suas solicitações.
Exemplo de streaming
Os ganhos de latência de Predicted Outputs são ainda maiores quando você usa streaming para
respostas de API. Aqui está um exemplo do mesmo caso de uso de refatoração de código, mas
usando streaming nos OpenAI SDKs.
Saídas previstas com streaming Javascript-escritor
1 import OpenAI from "openai";
2
3 const code = `
4 class User {
5 firstName: string = "";
6 lastName: string = "";
7 username: string = "";
8 }
9
10 export default User;
11 `.trim();
12
13 const openai = new OpenAI();
14
15 const refactorPrompt = `
16 Replace the "username" property with an "email" property. Respond only
17 with code, and with no markdown formatting.
18 `;
19
20 const completion = await [Link]({
21 model: "gpt-4o",
22 messages: [
23 {
24 role: "user",
25 content: refactorPrompt
26 },
27 {
28 role: "user",
29 content: code
30 }
31 ],
32 store: true,
33 prediction: {
34 type: "content",
35 content: code
36 },
37 stream: true
38 });
39
40 // Inspect returned data
41 for await (const chunk of stream) {
42 [Link]([Link][0]?.delta?.content || "");
43 }
Posição do texto previsto na resposta
Ao fornecer texto de previsão, sua previsão pode aparecer em qualquer lugar dentro da resposta
gerada e ainda fornecer redução de latência para a resposta. Digamos que seu texto previsto seja o
servidor Hono simples mostrado abaixo:
1 import { serveStatic } from "@hono/node-server/serve-static";
2 import { serve } from "@hono/node-server";
3 import { Hono } from "hono";
4
5 const app = new Hono();
6
7 [Link]("/api", (c) => {
8 return [Link]("Hello Hono!");
9 });
10
11 // You will need to build the client code first `pnpm run ui:build`
12 [Link](
13 "/*",
14 serveStatic({
15 rewriteRequestPath: (path) => `./dist${path}`,
16 })
17 );
18
19 const port = 3000;
20 [Link](`Server is running on port ${port}`);
21
22 serve({
23 fetch: [Link],
24 port,
25 });
Você pode solicitar ao modelo que regenere o arquivo com um prompt como:
1 Add a get route to this application that responds with
2 the text "hello world". Generate the entire application
3 file again with this route added, and with no other
4 markdown formatting.
A resposta ao prompt pode ser algo como isto:
1 import { serveStatic } from "@hono/node-server/serve-static";
2 import { serve } from "@hono/node-server";
3 import { Hono } from "hono";
4
5 const app = new Hono();
6
7 [Link]("/api", (c) => {
8 return [Link]("Hello Hono!");
9 });
10
11 [Link]("/hello", (c) => {
12 return [Link]("hello world");
13 });
14
15 // You will need to build the client code first `pnpm run ui:build`
16 [Link](
17 "/*",
18 serveStatic({
19 rewriteRequestPath: (path) => `./dist${path}`,
20 })
21 );
22
23 const port = 3000;
24 [Link](`Server is running on port ${port}`);
25
26 serve({
27 fetch: [Link],
28 port,
29 });
Você ainda verá tokens de previsão aceitos na resposta, mesmo que o texto de previsão tenha
aparecido antes e depois do novo conteúdo adicionado à resposta:
1 {
2 id: 'chatcmpl-xxx',
3 object: '[Link]',
4 created: 1731014771,
5 model: 'gpt-4o-2024-08-06',
6 choices: [ /* completion here... */],
7 usage: {
8 prompt_tokens: 203,
9 completion_tokens: 159,
10 total_tokens: 362,
11 prompt_tokens_details: { cached_tokens: 0, audio_tokens: 0 },
12 completion_tokens_details: {
13 reasoning_tokens: 0,
14 audio_tokens: 0,
15 accepted_prediction_tokens: 60,
16 rejected_prediction_tokens: 0
17 }
18 },
19 system_fingerprint: 'fp_9ee9e968ea'
20 }
Desta vez, não houve tokens de predição rejeitados, porque todo o conteúdo do arquivo que
previmos foi usado na resposta final. Legal! 🔥
Limitações
Ao usar Saídas Previstas, você deve considerar os seguintes fatores e limitações.
As saídas previstas são suportadas apenas com os modelos das séries GPT-4o e GPT-4o-mini.
Ao fornecer uma previsão, quaisquer tokens fornecidos que não façam parte da conclusão final
ainda serão cobrados nas taxas de token de conclusão. Veja a rejected_prediction_tokens
propriedade do usage objeto para ver quantos tokens não são usados na resposta final.
Os seguintes parâmetros de API não são suportados ao usar Saídas Previstas:
n : valores maiores que 1 não são suportados
logprobs : não suportado
presence_penalty : valores maiores que 0 não são suportados
frequency_penalty : valores maiores que 0 não são suportados
audio : As saídas previstas não são compatíveis com entradas e saídas de áudio
modalities : Somente text modalidades são suportadas
max_completion_tokens : não suportado
tools : A chamada de função não é suportada atualmente com saídas previstas
