Cómo configurar openai para devolver datos, mantener la salida de transmisión y cargar en segmentos
Puede usar el parámetro de transmisión de la API de OpenAI para lograr una salida de transmisión y puede usar el parámetro max_tokens para controlar la longitud de cada dato devuelto. El siguiente es un código de muestra para demostrar cómo usar la API de OpenAI para lograr una salida de transmisión y cargar en partes:
python
import openai
# 连接 OpenAI API openai.api_key = "YOUR_API_KEY"
# 设置 OpenAI API 参数
model_engine = "davinci"
# 模型引擎
prompt = "你好，我需要帮助进行自然语言处理任务。" # 请求语句
temperature = 0.5 # 温度参数
max_tokens = 100 # 每次最大输出长度 # 获取 OpenAI 返回数据
completions = openai.Completion.create( engine=model_engine, prompt=prompt, temperature=temperature, max_tokens=max_tokens, n=1, stream=True ) # 分段获取数据
for i, text in enumerate(iter(completions.choices), start=1):
print(f"============== 第 {
i} 段输出 ==============")
print(text.text)
En este ejemplo, streamconfiguramos el parámetro en True, de modo que la API de OpenAI transmitirá los datos a la persona que llama en tiempo real y devolverá un objeto generador ( iter(completions.choices)) que nos permite obtener los datos pieza por pieza e imprimirlos. Al mismo tiempo, usamos max_tokensparámetros para controlar la longitud de los datos devueltos cada vez, lo que también puede evitar de manera efectiva el problema de memoria insuficiente causado por datos devueltos demasiado largos. Tenga en cuenta que aquí YOUR_API_KEYdebe reemplazarse con la clave API que solicitó en OpenAI. [Tiempo de solicitud: 14 segundos]
openai devuelve el flujo, ya sea UDP o TCP, y recibe el código de datos del flujo DEMO
La API OpenAI GPT-3 devuelve un flujo HTTPS utilizando el protocolo TCP.
Si necesita procesar el flujo de datos devuelto por la API OpenAI GPT-3, puede usar la biblioteca de solicitudes en Python para procesarlo.
El siguiente es un código de muestra que puede recibir y procesar el flujo de datos devuelto por la API OpenAI GPT-3:
python
import requests
def process_stream(stream):
for line in stream.iter_lines():
if line: # 处理返回的数据
print(line.decode('utf-8')) # 发起 API 请求并处理返回的数据流
response = requests.post(url, headers=headers, data=data, stream=True)
process_stream(response.iter_lines())
En el código anterior, usamos requests.postel método para realizar una stream=Truesolicitud POST con el parámetro y guardar la respuesta en responsela variable . A continuación, llamamos process_streama la función para procesar el flujo de datos devuelto por la API. En process_streamla función , usamos iter_linesel iterador para procesar el flujo de datos línea por línea y convertir cada línea en una cadena codificada en UTF-8. En este ejemplo simple, solo imprimimos los datos en la consola, pero puede escribir la lógica correspondiente para procesar los datos de acuerdo con las necesidades reales.
El ejemplo de código PHP para recibir datos de transmisión es el siguiente:
php
<?php $ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'STREAM_URL');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_WRITEFUNCTION, function($curl, $data)
{
// 处理获得的数据
echo $data;
return strlen($data); });
curl_exec($ch);
curl_close($ch); ?>
Entre ellos, STREAM_URLrepresenta la dirección URL de transmisión de OpenAI. Este código escribirá datos de forma incremental en la pantalla.
En consecuencia, el ejemplo de código Java para recibir datos de transmisión es el siguiente:
java
import java.net.*;
import java.io.*;
public class StreamReceiver {
public static void main(String[] args) throws Exception
{
URL streamURL = new URL("STREAM_URL");
try (
BufferedReader reader = new BufferedReader( new InputStreamReader(streamURL.openStream())))
{
String line;
while ((line = reader.readLine()) != null)
{
// 处理获得的数据 System.out.println(line);
}
}
}
}
De manera similar, STREAM_URLrepresenta la dirección URL de transmisión de OpenAI. Este código enviará los datos paso a paso a la interfaz de línea de comandos
Ejemplo de código PHP:
<?php // 请求OpenAI接口获取stream数据，并转发到H5页面端
$openAIUrl = 'https://api.openai.com/v1/engines/davinci-codex/completions'; $headers = array( 'Content-Type: application/json', 'Authorization: Bearer <YOUR_API_KEY>' );
$data = array( 'prompt' => 'Hello, world!', 'max_tokens' => 5, 'temperature' => 0.7 );
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $openAIUrl);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
$output = fopen('php://output', 'w');
curl_setopt($ch, CURLOPT_WRITEFUNCTION, function ($ch, $chunk) use ($output) {
fwrite($output, $chunk);
return strlen($chunk); });
curl_exec($ch);
fclose($output); // 将stream数据转发给H5页面端
header('Content-Type: text/event-stream');
header('Cache-Control: no-cache');
header('Connection: keep-alive');
header('Access-Control-Allow-Origin: *');
fpassthru($output);
Ejemplo de código Java:
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(asyncSupported = true, urlPatterns = {
"/stream"})
public class StreamServlet extends HttpServlet
{
private static final ExecutorService executor = Executors.newCachedThreadPool();
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 创建异步上下文
AsyncContext asyncContext = request.startAsync(); // 提交任务到线程池
executor.submit(() -> {
try {
// 请求OpenAI接口获取stream数据
URL url = new URL("https://api.openai.com/v1/engines/davinci-codex/completions");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", "application/json");
conn.setRequestProperty("Authorization", "Bearer <YOUR_API_KEY>"); conn.setDoOutput(true);
OutputStream out = conn.getOutputStream();
out.write("{\"prompt\": \"Hello, world!\", \"max_tokens\": 5, \"temperature\": 0.7}".getBytes());
out.flush();
out.close();
InputStream in = conn.getInputStream();
response.setContentType("text/event-stream");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Connection", "keep-alive");
response.setHeader("Access-Control-Allow-Origin", "*");
byte[] buffer = new byte[1024];
int count;
while ((count = in.read(buffer)) != -1) {
// 将stream数据转发给H5页面端
OutputStream outputStream = asyncContext.getResponse().getOutputStream();
String data = new String(buffer, 0, count);
outputStream.write(("data: " + data + "\n\n").getBytes());
outputStream.flush(); } in.close(); }
catch (IOException e) {
e.printStackTrace(); }
finally {
asyncContext.complete(); } }); } }
Ejemplo de código Python:
import requests from flask
import Flask, Response app = Flask(__name__) @app.route('/stream')
def stream(): # 请求OpenAI接口获取stream数据
url = 'https://api.openai.com/v1/engines/davinci-codex/completions'
headers = {
'Content-Type': 'application/json', 'Authorization': 'Bearer <YOUR_API_KEY>' }
data = {
'prompt': 'Hello, world!', 'max_tokens': 5, 'temperature': 0.7 } res = requests.post(url, headers=headers, json=data, stream=True)
# 将stream数据转发给H5页面端
def generate():
for chunk in res.iter_content(chunk_size=1024):
if chunk: yield 'data: ' + chunk.decode() + '\n\n'
return Response(generate(), mimetype='text/event-stream', headers={
'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Access-Control-Allow-Origin': '*' })
if __name__ == '__main__':
app.run()
Nota: El código anterior es solo para referencia, y la implementación específica debe modificarse adecuadamente de acuerdo con sus propias necesidades comerciales.
Cómo habilitar Html front-end para mostrar el formato mardown
Para mostrar el formato de Markdown en el front-end HTML, puede usar una biblioteca o herramienta llamada analizador de Markdown. Aquí hay un ejemplo simple:
1. Primero, importe una biblioteca de analizador Markdown, como por ejemplo, marcado.js, a través de CDN o descárguelo a una carpeta local.
html <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
- Agregue una etiqueta de área de texto en la página para ingresar texto en formato Markdown y agregue una etiqueta div para mostrar el contenido HTML analizado.
javascripthtml <textarea id="mdInput"></textarea> <div id="htmlOutput"></div>
- Obtenga el valor del área de texto en JavaScript, páselo al analizador Markdown e inserte el código HTML de salida en el div.
javascript
var markdown = document.getElementById('mdInput').value;
var html = marked(markdown);
document.getElementById('htmlOutput').innerHTML = html;
De esta manera, el texto en formato Markdown se puede mostrar en el navegador.
Similar al sitio web de ChatGPT, la tecnología de procesamiento de flujo (Stream) en Node.js se utiliza para convertir la salida en formato de descuento.
La transmisión es una técnica útil cuando se trabaja con grandes cantidades de datos, lo que permite que los datos se procesen en fragmentos sin esperar a que se cargue todo el conjunto de datos. En el sitio web de ChatGPT, se puede usar un método similar al siguiente código para convertir el flujo de salida al formato de descuento:
javascript
const markdown = require('markdown').markdown;
const stream = require('stream');
const outputStream = new stream.Writable({
write(chunk, encoding, callback) {
const text = chunk.toString();
const markdownText = markdown.toHTML(text);
process.stdout.write(markdownText);
callback(); },
});
// Stream output to markdown formatter
originalOutputStream.pipe(outputStream);
En este ejemplo de código, markdownla biblioteca se usa para convertir el texto sin formato de entrada al formato Markdown. Un Writableflujo de escritura para recibir resultados, convertirlos al formato Markdown y enviarlos al flujo de salida estándar ( process.stdout.write()). Finalmente, originalOutputStreamconecte el flujo de salida original ( ) al nuevo flujo grabable ( outputStream), y canalice la salida a la salida estándar a través de ese flujo. Este es solo un ejemplo simple, en realidad, el sitio web de ChatGPT puede usar técnicas más complejas para transmitir y convertir la salida al formato Markdown.