Serie de desarrollo OpenAI (11): el proceso de aplicación real y el análisis de casos de la función de llamada de función

El texto completo tiene más de 6000 palabras en total y el tiempo de lectura esperado es de entre 15 y 25 minutos | Lleno de productos secos (con casos de código), ¡se recomienda recopilarlos!

El objetivo de este artículo: presentar los parámetros de llamada de función y los métodos de uso del modelo de finalización de chat e implementar completamente un caso de función de llamada de función del modelo de chat.

Dirección de descarga de código

1. Introducción

¿Te imaginas lo poderoso que será si el modelo grande se puede conectar a Internet y tiene la capacidad de datos de un complemento similar a ChatGPT a través de API?

Todos sabemos que la base de conocimiento del modelo grande es a partir de septiembre de 2021, lo que significa que no sabe nada sobre el conocimiento después de esta fecha, aunque se le puede dar cierta capacidad de razonamiento estimulando su capacidad emergente, pero el conocimiento inherente no puede emerger. Por ejemplo, nuestro ChatGLM ligero de modelo grande de código abierto nacional:

Entonces se puede ver que aunque el modelo grande (LLM) es muy capaz y tiene una capacidad emergente muy poderosa, también tiene algunas limitaciones. El problema obvio es que no puede obtener la información y los datos más recientes, y solo puede dar sugerencias textuales . Es imposible resolver directamente algunos problemas , como preguntarle al modelo grande: "¿Cómo está el clima hoy?" Esta escena simple no se puede hacer, por lo que el valor de la aplicación práctica del modelo de lenguaje grande es muy limitado.

Entonces, en abril de 2023, AutoGPT propuso en respuesta a esta situación: **Es necesario darle al modelo de lenguaje grande la capacidad de llamar a API externas. **Por ejemplo, si el modelo GPT se puede utilizar para llamar a la API de Google Mail (API de Gmail), el modelo GPT puede leer correos electrónicos automáticamente y responder automáticamente, etc. En este contexto, OpenAI agregó llamadas a funciones al modelo de finalización de chat más avanzado en la actualización 0613.

No subestimes esta característica, cambia por completo la forma en que los desarrolladores interactúan con los modelos de IA. Esta característica permite a los desarrolladores describir funciones para modelos de IA y luego el modelo puede decidir de manera inteligente generar un objeto JSON que contenga los parámetros para llamar a estas funciones . Antes de que el modelo grande no tenga la capacidad de llamar a funciones (llamada a funciones), el proceso para que los desarrolladores desarrollen aplicaciones de IA basadas en el modelo grande es el siguiente:

La esencia de las llamadas a funciones es la capacidad del modelo de lenguaje grande para llamar a funciones externas, es decir, el modelo de finalización de chat ya no puede responder solo en función de su propio conocimiento de la base de datos, sino que puede montar una biblioteca de funciones adicional y luego buscar la función. biblioteca de acuerdo con las preguntas del usuario, llame a la función externa de acuerdo con las necesidades reales y obtenga el resultado de ejecución de la función, y luego responda según el resultado de ejecución de la función. El proceso básico es el siguiente:

** La comprensión simple es: según el escenario comercial, seleccione automáticamente la función correspondiente y formatee la salida. ** Puede ser una función personalizada simple o una función funcional que encapsula una API de herramienta externa, como una función que puede llamar a Google Mail o una función que puede obtener información meteorológica. Finalmente, mire el cuadro comparativo:

2. El proceso de implementación de la llamada a funciones.

Parece complicado, pero en realidad es muy simple, OpenAI ya lo ha hecho por nosotros: defina la biblioteca de funciones externas con anticipación y establezca los parámetros correspondientes en la función ChatCompletions.create () .

La llamada biblioteca de funciones externas puede entenderse como una función lógica de procesamiento intermedio que debe usarse al desarrollar una determinada aplicación. Por ejemplo, si desea desarrollar un programa de respuesta automática de correo, debe definir:

• función para recibir correo
• función para enviar correo
• …

Cuando el modelo de finalización de chat implementa la función de llamada de función, el modelo grande puede aprovechar al máximo su capacidad de comprensión semántica, analizar la entrada del usuario y luego seleccionar automáticamente la función más adecuada en la biblioteca de funciones para ejecutar y dar la respuesta a la pregunta. Se requiere intervención manual.

2.1 Cómo construir correctamente la biblioteca de funciones externas

Aunque el modelo Chat Completion tiene capacidades de llamada a funciones (Function Calling), su comprensión de las funciones no es la misma que la de las funciones en los entornos de programación tradicionales . De manera similar al diseño de mensajes efectivos en los diálogos, optimizar el formato y la estructura de las llamadas a funciones puede mejorar significativamente la precisión de la ejecución del modelo. Por lo tanto, especificar el formato de entrada de datos adecuado se convierte en un paso clave. Sólo cuando el formato de datos está diseñado correctamente puede el modelo comprender y realizar tareas con mayor precisión.

En primer lugar, observe el formato entrante de los datos.

2.1.1 Formato de datos de entrada

2.1.1.1 Formato de datos de marco de datos/cadena

En la biblioteca de pandas, las dos estructuras de datos principales son DataFramey Series, y la mayoría de ellas también usan la estructura DataFrame para tareas de procesamiento de datos, por lo que puede crear un ejemplo de datos de DataFrame para probar si el modelo grande puede comprender este formato de datos.

• preparación de datos

# 创建一个稍微复杂的DataFrame，包含多种数据类型
df_complex = pd.DataFrame({
    
    
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000.0, 100000.5, 150000.75],
    'IsMarried': [True, False, True]
})

El resultado es el siguiente:

• verificar

Pase el modelo grande para ver si el modelo puede interpretar los datos.

response = openai.ChatCompletion.create(
  model="gpt-3.5-turbo-16k-0613",
  messages=[
    {
    
    "role": "system", "content": "你是一位优秀的数据分析师，现在有这样一份数据集：'%s'" % df_complex},
    {
    
    "role": "user", "content": "请解释一下这个数据集的分布情况"}
  ]
)

El resultado es el siguiente:

response.choices[0].message['content']

Se puede ver que el modelo puede comprender con precisión la distribución de datos en el formato DataFrame y, además, si desea un formato de datos más general, puede intentar usar .to_string para convertirlo en una cadena y pasarlo. , y podrá obtener la interpretación correcta.

# 转化为字符串类型
df_complex_string = df_complex.to_string()

Formateado de la siguiente manera:

2.1.1.2 Formato de datos JSON

El formato de interacción de datos recomendado oficialmente por OpenAI es: JSON . También se puede ver en los ejemplos anteriores que, aunque el modelo grande puede interpretar correctamente datos de tipo DataFrame/cadena, la legibilidad de los datos no es buena.

Al mismo tiempo, durante las pruebas del programa, también se descubrió que cuando los datos son grandes, es posible que el modelo grande no pueda identificar con precisión los objetos de cadena como tipos de objetos DataFrame. Y JSON como función cruzada

Entonces: un enfoque más general es comunicarse entre funciones y entornos de programación con la ayuda del formato JSON.

JSON (Notación de objetos JavaScript) se utiliza ampliamente en entornos multilingües principalmente porque es simple, flexible y fácil de analizar. Casi todos los lenguajes de programación modernos admiten JSON, lo que lo convierte en un formato de datos verdaderamente multiplataforma y multilenguaje. Su naturaleza liviana y de solo texto también lo hace muy eficiente en transferencias de red.

• preparación de datos

Convertir un DataFrame al formato JSON es muy simple en la biblioteca pandas de Python. Haga esto directamente usando DataFramelos métodos del objeto .to_json

# 将DataFrame转换为JSON格式,orient='split'参数将数据、索引和列分开存储
df_complex_json = df_complex.to_json(orient='split')

print(df_complex_json)

El formato de los datos de salida es el siguiente:

• verificar

response = openai.ChatCompletion.create(
  model="gpt-3.5-turbo-16k-0613",
  messages=[
    {
    
    "role": "system", "content": "你是一位优秀的数据分析师，现在有这样一份数据集：'%s'" % df_complex_json},
    {
    
    "role": "user", "content": "请解释一下这个数据集的分布情况"}
  ]
)

Mire la situación del análisis del modelo:

El modelo normalmente puede identificar el tipo de objeto JSON y, después de muchas pruebas, se descubre que la forma de datos de JSON se puede interpretar con mayor claridad y la legibilidad del objeto JSON en sí es mayor.

2.1.2 Escribir especificaciones de funciones

Cuando se utiliza la llamada a función para interactuar con el modelo de finalización de chat, cuando se selecciona el formato de datos de entrada clave, la especificación de la escritura de la función es igualmente importante . Al menos debe tener:

1. Borrar nombres de funciones : elija un nombre de función claro y descriptivo.
2. Orden y denominación de los parámetros : los parámetros deben tener un orden lógico y utilizar nombres descriptivos.
3. Descripción detallada de la función : es necesario tener una descripción clara de la función y las variables de parámetros establecidas.

• Paso 1: preparar los datos

Tome este conjunto de datos como ejemplo:

# 示例DataFrame
df_complex = pd.DataFrame({
    
    
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000.0, 100000.5, 150000.75],
    'IsMarried': [True, False, True]
})

# 将DataFrame转换为JSON格式（按'split'方向）
df_complex_json = df_complex.to_json(orient='split')

Mire el formato de los datos de entrada:

• Paso 2: Establecer requisitos

Supongamos que ahora existe ese requisito: deje que el modelo grande calcule la suma de las edades de todas las personas en este conjunto de datos.

• Paso 3: escribe una función para calcular la suma de edades

Una función clara que pueda ser entendida por un modelo grande debería verse así:

def calculate_total_age_from_split_json(input_json):
    """
    从给定的JSON格式字符串（按'split'方向排列）中解析出DataFrame，计算所有人的年龄总和，并以JSON格式返回结果。

    参数:
    input_json (str): 包含个体数据的JSON格式字符串。

    返回:
    str: 所有人的年龄总和，以JSON格式返回。
    """

    # 将JSON字符串转换为DataFrame
    df = pd.read_json(input_json, orient='split')

    # 计算所有人的年龄总和
    total_age = df['Age'].sum()

    # 将结果转换为字符串形式，然后使用json.dumps()转换为JSON格式
    return json.dumps({
    
    "total_age": str(total_age)})

• Paso 4: pruebas funcionales

Cabe señalar que: como se mencionó anteriormente, el formato de datos óptimo recibido por el modelo grande es JSON, por lo tanto, pase un formato JSON para probar si la función se puede calcular normalmente. El código es el siguiente:

# 使用函数计算年龄总和，并以JSON格式输出
result = calculate_total_age_from_split_json(df_complex_json)
print("The JSON output is:", result)

Mira el resultado:

• Paso 5: definir la biblioteca de funciones

Cuando el modelo Chat realmente ejecuta la función de llamada de función, selecciona la función apropiada de una biblioteca de funciones para llamar, por lo que es necesario preparar una biblioteca de funciones. En el caso más simple, una biblioteca de funciones puede contener sólo una función, de la siguiente manera:

function_repository = {
    
    
            "calculate_total_age_from_split_json": calculate_total_age_from_split_json,
        }

El objeto de la biblioteca de funciones debe ser un diccionario, un par clave-valor representa una función, donde Clave es una cadena que representa el nombre de la función y el valor representa la función correspondiente. Entonces, el proceso anterior puede entenderse simplemente como: la llamada biblioteca de funciones externas consiste en utilizar un diccionario grande para almacenar todas las definiciones de funciones necesarias en un escenario de aplicación.

2.2 Cómo utilizar el parámetro funciones para pasar información de funciones externas

Después de escribir la función funcional y el almacén de funciones, lo siguiente que debemos pensar es: ¿ cómo pasar la información relacionada con esta función al modelo de finalización de chat?

La explicación dada en el sitio web oficial de OpenAI es: Utilice el parámetro de funciones de ChatCompletion.create () para pasar la información del contenido de las funciones externas que se pueden llamar al modelo. Los parámetros específicos se explican a continuación :

El parámetro funciones es muy similar al parámetro mensajes y ambos contienen una lista de múltiples diccionarios. Para los mensajes, cada diccionario es un mensaje y para el parámetro funciones, cada diccionario es una función. Cuando el modelo de lenguaje grande (LLM) realmente responde a preguntas, cada función se recupera de acuerdo con la información proporcionada por el parámetro funciones.

Al mismo tiempo, el sitio web oficial de OpenAI estipula claramente que el tipo de resultado devuelto al modelo grande por una función externa que admite la función de llamada de función debe ser un tipo de cadena json.

En otras palabras, se estipula oficialmente que los parámetros aceptados por la función se describen en forma de objetos de esquema JSON . Entonces, primero debemos entender qué es un objeto de esquema JSON.

2.2.1 Objeto de esquema JSON

JSON Schema es un estándar de metadatos para describir el formato y la estructura de los datos JSON. Se utiliza para validar, anotar y manipular documentos JSON. El esquema JSON en sí se expresa en formato JSON, lo que proporciona una forma flexible de verificar la estructura de los datos, incluido el tipo de propiedades del objeto, la longitud de la matriz, el rango de valores de números y cadenas , etc.

En pocas palabras, si tiene un objeto JSON, el esquema JSON se puede utilizar como una "plantilla" o "definición" del objeto para verificar si el objeto JSON se ajusta a reglas y estructuras predeterminadas. Por ejemplo, un ejemplo de esquema JSON tan simple se utiliza para describir la información de una persona:

{
    
    
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    
    
    "Name": {
    
    
      "type": "string"
    },
    "Age": {
    
    
      "type": "integer",
      "minimum": 0
    },
    "Salary": {
    
    
      "type": "number"
    },
    "IsMarried": {
    
    
      "type": "boolean"
    }
  },
  "required": ["Name", "Age"]
}

• $schema: Este es un campo de metadatos del esquema JSON que define la versión de la especificación del esquema JSON utilizada.
• type: Especifica el tipo de datos que debe tener el objeto JSON. En este ejemplo, es uno object.
• properties: Reglas para describir propiedades internas de objetos JSON. Es un objeto donde cada clave es un nombre de propiedad a describir y cada valor es una condición que la propiedad debe satisfacer.
• required: una matriz que enumera los campos que son obligatorios. En este ejemplo, Namey Ageson campos obligatorios.

En pocas palabras: el esquema JSON en sí no contiene la información de contenido específica de un objeto, sino solo la información de formato de un determinado tipo de objeto.

2.2.2 Construir la descripción del esquema JSON de la función externa

Por lo tanto, el primer paso para pasar funciones externas al modelo grande es definir la descripción del esquema JSON correspondiente para cada función funcional escrita. **Para la función calcular_total_age_from_split_json definida para calcular la suma de edades hace un momento, escriba su descripción del esquema JSON de la siguiente manera:

calculate_total_age_from_split_json = {
    
    "name": "calculate_total_age_from_split_json",
                                       "description": "计算年龄总和的函数，从给定的JSON格式字符串（按'split'方向排列）中解析出DataFrame，计算所有人的年龄总和，并以JSON格式返回结果。",
                                       "parameters": {
    
    "type": "object",
                                       "properties": {
    
    "input_json": {
    
    "type": "string",
                                                                     "description": "执行计算年龄总和的数据集"},
                                                   },
                                        "required": ["input_json"],
                                    },
                     }

Este esquema JSON describe calculate_total_age_from_split_jsonla función y sus parámetros en detalle. La siguiente es una explicación detallada de los campos:

La razón por la que debes escribir calcular_total_age_from_split_json[“parámetros”] es que cuando el modelo de Chat está en conversación, la información de datos entrantes y salientes se transmite en un formato de datos similar a JSON.

La descripción oficial de los parámetros de las funciones es: Una lista de funciones para las que el modelo puede generar entradas JSON, que también muestra que el modelo usa el formato JSON para la transmisión de datos. Este formato de entrada y salida debe mantenerse estrictamente.

2.3 Cómo cargar la función de llamada de función

Después de definir el almacén de funciones externas, la función de función y la descripción del objeto del esquema JSON correspondiente a la función de función, el trabajo preparatorio básicamente está completo. A continuación, puede interactuar con los datos del modelo grande, específicamente, agregar dos parámetros adicionales en función de los parámetros del diálogo:

• parámetro de funciones: declarar biblioteca de funciones externa
• Parámetro function_call: controla si se ejecuta la función de llamada de función

Su código es el siguiente:

• Código de llamada de diálogo común

response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-16k-0613",
        messages=messages,
    )

• Aumentar las llamadas a funciones

functions = [calculate_total_age_from_split_json]

response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-16k-0613",
        messages=messages,
        
        # 增加这两行
        functions=functions,
        function_call="auto",  
    )

3. Práctica del proceso de llamada de funciones

** En general, cuando desea que un modelo grande tenga capacidades de llamada de funciones, debe pasar por tres etapas: crear una biblioteca de funciones externa -> usar el parámetro funciones para transferir información de la función -> cargar la función de llamada de funciones. **Si se utiliza como ejemplo el cálculo de la suma de edades mencionado anteriormente, un proceso completo debería ser el siguiente:

• Paso 1: preparar los datos

# 示例DataFrame
df_complex = pd.DataFrame({
    
    
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000.0, 100000.5, 150000.75],
    'IsMarried': [True, False, True]
})

# 将DataFrame转换为JSON格式（按'split'方向）
df_complex_json = df_complex.to_json(orient='split')

• Paso 2: Establecer requisitos

Deje que el modelo grande calcule la suma de las edades de todas las personas en este conjunto de datos.

• Paso 3: escribe una función para calcular la suma de edades

def calculate_total_age_from_split_json(input_json):
    """
    从给定的JSON格式字符串（按'split'方向排列）中解析出DataFrame，计算所有人的年龄总和，并以JSON格式返回结果。

    参数:
    input_json (str): 包含个体数据的JSON格式字符串。

    返回:
    str: 所有人的年龄总和，以JSON格式返回。
    """

    # 将JSON字符串转换为DataFrame
    df = pd.read_json(input_json, orient='split')

    # 计算所有人的年龄总和
    total_age = df['Age'].sum()

    # 将结果转换为字符串形式，然后使用json.dumps()转换为JSON格式
    return json.dumps({
    
    "total_age": str(total_age)})

• Paso 4: pruebas funcionales

# 使用函数计算年龄总和，并以JSON格式输出
result = calculate_total_age_from_split_json(df_complex_json)
print("The JSON output is:", result)

• Paso 5: definir la biblioteca de funciones

function_repository = {
    
    
            "calculate_total_age_from_split_json": calculate_total_age_from_split_json,
        }

• Paso 6: crear el esquema JSON de la función funcional

calculate_total_age_from_split_json = {
    
    "name": "calculate_total_age_from_split_json",
                      "description": "计算年龄总和的函数，从给定的JSON格式字符串（按'split'方向排列）中解析出DataFrame，计算所有人的年龄总和，并以JSON格式返回结果。",
                      "parameters": {
    
    "type": "object",
                                     "properties": {
    
    "input_json": {
    
    "type": "string",
                                                             "description": "执行计算年龄总和的数据集"},
                                                   },
                                     "required": ["input_json"],
                                    },
                     }

• Paso 7: crea una lista de funciones

Similar al parámetro de mensajes del modelo de entrada es una lista que contiene múltiples mensajes, las funciones del modelo de entrada también son una lista que contiene múltiples descripciones de funciones, pero en este momento solo hay una función, por lo que solo hay un diccionario en las funciones. lista, el código es el siguiente:

functions = [calculate_total_age_from_split_json]

Mira el resultado:

• Paso 8: crear mensajes

messages=[
    {
    
    "role": "system", "content": "你是一位优秀的数据分析师, 现在有这样一个数据集input_json：%s，数据集以JSON形式呈现" % df_complex_json},
    {
    
    "role": "user", "content": "请在数据集input_json上执行计算所有人年龄总和函数"}
]

• Paso 9: Pase el modelo, deje que seleccione automáticamente la función y complete el cálculo.

response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-16k-0613",
        messages=messages,
        functions=functions,
        function_call="auto",  
    )

Mire los resultados del cálculo del modelo grande:

Después de agregar el parámetro de función de llamada a función, la devolución de datos sufrirá los siguientes cambios:

• El contenido del mensaje devuelto pasará a ser nulo.
• Se agrega un diccionario "function_call", que contiene dos pares clave-valor. El par clave-valor cuya clave es "nombre" indica el nombre de la función que debe llamarse para completar el diálogo, es decir, calcular_total_age_from_split_json. El par de valores cuya clave es "argumentos" indica los parámetros que deben pasarse a la función.

Entonces ** si el resultado devuelto del modelo grande contiene la palabra clave function_call, significa que este mensaje del asistente necesita llamar a una función externa. ** Toca la pizarra, debes entender: este mensaje sigue siendo el mensaje del asistente, pero este mensaje no contiene contenido, pero contiene la palabra clave function_call, que también es una palabra clave alternativa que se puede incluir en el parámetro uno de mensajes. de .

Hay dos informaciones principales en la llamada a función:

• nombre de la función
• argumentos

Es necesario preservar estos dos datos básicos .

• Paso 10: guarde la información clave durante la interacción

# 保存交互过程中的函数名称
function_name = response["choices"][0]["message"]["function_call"]["name"]

# 加载交互过程中的参数
function_args = json.loads(response["choices"][0]["message"]["function_call"]["arguments"])

La información guardada es la siguiente:

La razón de esto es: en primer lugar, nuestro escenario de demanda debería ser así: para el conjunto de datos df_complex_json, use la función calcular_total_age_from_split_json para calcular la suma de las edades de todas las personas.

Para un modelo grande, el proceso de cálculo de la función externa se ejecuta localmente, por lo que significa que debe completar el cálculo de la función localmente de acuerdo con la función y los parámetros de función devueltos por el modelo, y luego guardar el proceso de cálculo y los resultados como un mensaje y agregarlo a los mensajes, y llamar al modelo de finalización de chat para analizar el resultado del cálculo de la función por segunda vez y finalmente generar la respuesta a la pregunta del usuario de acuerdo con el resultado del cálculo de la función.

• Paso 11: guarde el objeto de función

# 保存具体的函数对象
local_fuction_call = function_repository[function_name]

Mire la salida de local_fuction_call:

• Paso 12: Complete el cálculo del modelo

Pase directamente el objeto function_args a local_fuction_call para transferir todos los parámetros a la vez, el código es el siguiente:

final_response = local_fuction_call(**function_args)

Mire el resultado final del cálculo:

A través de los 12 procesos anteriores, el modelo puede completar con éxito el cálculo llamando a funciones externas.

• Paso final: agregar mensajes al proceso de compilación

Como se mencionó anteriormente, aquí se reitera que el proceso del modelo grande que llama a funciones externas para cálculo, razonamiento y otras capacidades debe ser: de acuerdo con la función y los parámetros de función devueltos por el modelo, el cálculo de la función se completa localmente y luego El proceso de cálculo y los resultados se guardan como El mensaje se agrega a los mensajes, y el resultado del cálculo de la función de análisis del modelo de finalización de chat se llama por segunda vez y, finalmente, la respuesta a la pregunta del usuario se genera de acuerdo con el resultado del cálculo de la función.

Entonces, basándonos en este proceso, podemos transformar el programa de esta manera:

1. Agregar el primer resultado devuelto del modelo en mensajes.

# 追加第一次模型返回结果消息
messages.append(response["choices"][0]["message"])

2. Agregue el segundo resultado de retorno del modelo en los mensajes, es decir, el resultado del cálculo de la función externa.

# 追加function计算结果，注意：function message必须要输入关键词name
messages.append({
    
    "role": "function", "name": function_name, "content": final_response,})

Entonces el contenido del mensaje en este momento debería ser el siguiente:

3. Pregunta nuevamente al modelo de finalización de chat

En este punto, ya no es necesario preguntarle repetidamente al modelo, simplemente pase los mensajes preparados al modelo de Chat, el código es el siguiente:

last_response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-16k-0613",
            messages=messages,)

Mire el resultado final:

El modelo finalmente respondió correctamente. Por lo tanto, la llamada a función requiere dos llamadas al modelo de finalización de chat y un cálculo de función local para ejecutar todo el proceso correctamente. Su diagrama de flujo general es el siguiente:

4. Resumen

Este artículo brinda los antecedentes de la función de llamada de función en el modelo de finalización de chat y luego explica en detalle el proceso de implementación de la llamada de función. Esto incluye cómo construir la biblioteca de funciones externas de Chat, incluida la entrada de formato de cadena, formulario Json y formulario de función, y también explica cómo definir funciones, incluidos objetos JSON y esquema JSON y descripciones de esquema Json para crear funciones externas. Finalmente, se presenta en detalle la implementación de la llamada a función y se resume todo el proceso, proporcionando una comprensión y orientación integrales y profundas para la aplicación de la llamada a función.

Finalmente, ¡gracias por leer este artículo! Si sientes que has ganado algo, no olvides darle me gusta, marcarlo y seguirme, esta es la motivación para mi creación continua. Si tiene alguna pregunta o sugerencia, puede dejar un mensaje en el área de comentarios, haré todo lo posible para responder y aceptar sus comentarios. Si hay un tema en particular que le gustaría conocer, hágamelo saber y estaré encantado de escribir un artículo al respecto. ¡Gracias por su apoyo y esperamos crecer con usted!