【GLM-4开发实战】Function Call进阶实战:常见挑战之意图识别处理

CSDN 2024-09-03 14:33:02 阅读 77

系列篇章💥

No. 文章
1 【GLM-4开发实战】Function Call进阶实战:外部函数调用回顾
2 【GLM-4开发实战】Function Call进阶实战:常见挑战之意图识别处理
3 【GLM-4开发实战】Function Call进阶实战:常见挑战之海量函数处理
4 【GLM-4开发实战】Function Call进阶实战:常见挑战之并发调用处理

目录

系列篇章💥引言一、概述二、问题测试1、工具函数信息生成2、模型调用测试函数3、定义两个工具函数4、模型调用测试15、模型调用测试26、模型调用测试3

三、解决方案1、尽最大能力提供高质量的Json schema1)测试样例2)调用测试

2、干预模型选择1)定义一个新模型调用函数2)定义2个测试用的工具函数3)定义函数列表4)函数调用测试15)函数调用测试2

四、问题测试1、定义几个加减乘除的方法2、定义函数列表3、定义模型调用函数4、函数调用测试5、定义模型调用函数6、函数调用测试

五、优化调整1、定义模型调用函数2、计算测试3、函数调用测试

结语


引言

在人工智能领域,Function Call(函数调用)是实现智能系统功能的关键技术之一。然而,在实际应用中,Function Call面临着诸多挑战,尤其是意图识别问题。本文将深入探讨这些挑战,并提供相应的解决方案。

在这里插入图片描述

一、概述

Function Call的意图识别是指系统如何准确理解用户的指令,并调用正确的函数来完成用户的需求。这一过程涉及到多个层面的问题,包括但不限于:

1、判断调用需求:系统需要判断何时需要调用外部函数,何时可以独立完成。

2、函数选择:面对众多相似名称的函数,系统如何避免混淆并选择正确的函数。

3、结果整合:即使调用了正确的函数并获得了结果,系统也需要能够将这些结果有效整合,以提供完整的信息。

二、问题测试

1、工具函数信息生成

auto_functions是一个自动帮我们生成tools工具描述的方法

<code>import inspect

import json

import pandas as pd

from typing import List, Callable

def auto_functions(func_list: List[Callable]) -> List[dict]:

tools_description = []

for func in func_list:

# 获取函数的签名信息

sig = inspect.signature(func)

func_params = sig.parameters

# 函数的参数描述

parameters = {

'type': 'object',

'properties': { },

'required': []

}

for param_name, param in func_params.items():

# 添加参数描述和类型

parameters['properties'][param_name] = {

'description': param.annotation.__doc__ if param.annotation is not inspect._empty else "",

'type': str(param.annotation) if param.annotation != param.empty else 'Any'

}

# 如果参数有默认值,那么它不是必须的

if param.default != param.empty:

parameters['required'].append(param_name)

# 函数描述字典

func_dict = {

"type": "function",

"function": {

"name": func.__name__,

"description": func.__doc__.strip(),

"parameters": parameters

}

}

tools_description.append(func_dict)

return tools_description

2、模型调用测试函数

测试大模型是否能够正确找到外部工具函数

## 打印大模型识别到的外部函数的名字

def function_call_test(prompt,tools):

prompt = prompt

message = [

{ "role": "user", "content": prompt}

]

response1 = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = "auto"

)

print(response1.choices[0].message.tool_calls[0].function.name)

3、定义两个工具函数

定义2个工具函数,用于模型识别测试,看模型调用时能否正确找到对应的函数

def machine_learning_1():

"""

解释机器学习是什么

"""

answer = """机器学习是人工智能的一个分支,研究计算机如何自动从数据中学习,提升性能并做出预测。\

它通过算法让计算机提炼知识,优化任务执行,而无需明确编程。"""

return answer

def machine_learning_2():

"""描述一下机器学习和深度学习的区别"""

answer = """机器学习涉及算法从数据中学习模式以做出预测或决策,涵盖广泛的技术,包括监督、非监督和强化学习。\

深度学习是机器学习的一个子集,专注于使用神经网络,尤其是深层神经网络,来处理复杂的数据结构,\

实现高级功能如图像识别和自然语言理解,其特点是多层次的抽象和自动特征学习。"""

return answer

定义工具函数列表

# 函数列表

functions_list = [machine_learning_1, machine_learning_2]

# 获取函数描述的 JSON 字典

tools = auto_functions(functions_list)

# 将函数列表转换为字典

available_functions = { func.__name__: func for func in functions_list}

tools

查看自动生成的函数信息:

在这里插入图片描述

查看函数字典列表

<code>available_functions

输出:

在这里插入图片描述

4、模型调用测试1

<code>prompt = "请问机器学习是什么?"

function_call_test(prompt,tools)

输出:

machine_learning_1

5、模型调用测试2

prompt = "请问深度学习和机器学习的区别是什么?"

function_call_test(prompt,tools)

输出:

machine_learning_2

6、模型调用测试3

prompt = "请问深度学习是什么?"

function_call_test(prompt,tools)

输出:

machine_learning_1

这个时候我们发现大模型调用错了函数,他认为机器学习和深度学习很像,类似的生产业务中也有类似的情况,比如在银行业务中,用户开卡和开信用卡,应该对应的是两个不同的函数。

但是如果类似上面这种,很有可能就是会被当做是同一个业务进行处理了。显然不对。

三、解决方案

1、尽最大能力提供高质量的Json schema

这里的“高质量”是指清晰地描述了函数的功能和参数、易于模型进行辨别、使用简洁且一致的命名约定、保持函数名格式相同、但是尽量不要使用相似或容易混淆的函数名称(比如前面的machine_learning_1和Machine_learning_2就是非常糟糕的例子),函数的description尽量不要使用过于相似的描述等等;

这个过程免不了人工干预,Json schema的质量越高,模型辨别也就越容易。

更具体的手段包括:

1. 使用关键词:从实验结果来看,GLM-4可能很大程度上是基于embedding后的结果的相似程度来选择函数的,prompt中如果出现与函数名称高度一致的语句片段,那个函数就有很大的概率被选中(例如,prompt是“深度学习是什么”,函数名是“机器学习是什么”,即便什么是深度学习这个知识点早就在GLM的知识库内,它还是会被function吸引走),因此对特定函数、特定需求进行“关键词”的设置异常重要,这个关键词可以是一些很奇妙的语言,在正常的对话中绝对不会出现混淆的语言,例如编号,或者特定的专有名词。存在特定的业务是一定要执行某个函数或某个流程的,你可以纯依赖于编程、而不依赖于大模型的理解来走完这个流程。

2. 使用特定词语对函数的作用进行分组和分类:在函数名称或描述中添加分类标记。例如,可以在名称中使用前缀如“user_”、“admin_”或“data_”等,帮助模型快速定位相关类别的函数。

3. 为函数增加权重:为使用更频繁的函数增加primary、prior、core等有助于模型理解其重要性的名称,也可以在进行编号或者函数的描述时写上“非常重要,经常使用,核心业务”等等描述;

4. 使用否定句,帮助模型进一步辨析函数功能等:比如在函数的描述中,明确说明“当出现xxxx语言或prompt时,这个函数不管用,请谨慎考虑选择该函数”等。

1)测试样例

prompt = "我来到你的城市,走过你来时的路,\

轻轻地我走了,正如我轻轻的来。\

你是我的小苹果,小呀小苹果。\

送你一朵小红花"

def 送你一朵小红花():

"""如函数名"""

a = 1314520

return a

def 我只是在唱歌():

"""如函数名"""

a = 1314520

return a

# 函数列表

functions_list2 = [送你一朵小红花,我只是在唱歌]

# 获取函数描述的 JSON 字典

tools2 = auto_functions(functions_list2)

# 将函数列表转换为字典

available_functions2 = { func.__name__: func for func in functions_list2}

2)调用测试

function_call_test(prompt,tools2)

输出:

送你一朵小红花

2、干预模型选择

通过改变function call交互的流程、改变模型的选择;包括但不限于

1.使用自查prompts进行干预:例如,在用户进行具体的提问时,使用“xxx是否在你的资料库内”prompt进行优先筛查,人为为模型增加一个“你是否知道xxx流程”的过程,可以避免模型在判断就是否需要调用函数时混淆。但需要注意的是,因为大模型会有幻觉现象,因此你的prompt要相当考究。如果你问模型“你是否知道xxx”,模型很大程度上会说谎。

2.依赖匹配好于依赖理解:例如,准备某个业务下的关键词库,只要用户在提到这些关键词时,就指定tool_choice参数让GLM-4进行特定的函数的调用,或者在用户提到某些关键词时,就推荐模型使用某个特定的函数进行调用;一个典型的场景可以是,在餐厅场景中,用户说“我要点餐”、“我要吃饭”、“我要下单”、“我要xxx”、甚至“服务员过来一下”的语音都可能都是指向“点餐”的需求,可以先经过编程流程匹配,再交由模型进行理解。这个过程会让模型识别的精准程度大幅上升。

代码测试样例

1)定义一个新模型调用函数

#在选择进行功能选择前,让模型先判断被提到的问题是否在它的资料库中

def function_call_new(prompt,tools):

prompt = prompt

judge_words = "这个问题的答案是否在你的语料库里?\

请回答“这个问题答案在我的语料库里”或者“这个问题的答案不在我的语料库里”\

不要回答其他额外的文字"

message = [

{ "role": "user", "content": prompt + judge_words}

]

response1 = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message

)

if "这个问题答案在我的语料库里" in response1.choices[0].message.content:

message = [

{ "role": "user", "content": prompt}

]

response2 = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

)

print(response2.choices[0].message.content)

else:

message = [

{ "role": "user", "content": prompt}

]

response2 = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = "auto"

)

print(response2.choices[0].message.tool_calls[0].function.name)

2)定义2个测试用的工具函数

def machine_learning_1():

"""

解释机器学习是什么

"""

answer = """机器学习是人工智能的一个分支,研究计算机如何自动从数据中学习,提升性能并做出预测。\

它通过算法让计算机提炼知识,优化任务执行,而无需明确编程。"""

return answer

def machine_learning_2():

"""描述一下机器学习和深度学习的区别"""

answer = """机器学习涉及算法从数据中学习模式以做出预测或决策,涵盖广泛的技术,包括监督、非监督和强化学习。\

深度学习是机器学习的一个子集,专注于使用神经网络,尤其是深层神经网络,来处理复杂的数据结构,\

实现高级功能如图像识别和自然语言理解,其特点是多层次的抽象和自动特征学习。"""

return answer

3)定义函数列表

# 函数列表

functions_list = [machine_learning_1, machine_learning_2]

# 获取函数描述的 JSON 字典

tools = auto_functions(functions_list)

# 将函数列表转换为字典

available_functions = { func.__name__: func for func in functions_list}

4)函数调用测试1

prompt = "请问机器学习是什么?"

function_call_new(prompt,tools)

输出:

机器学习是人工智能(AI)的一个重要分支,它赋予了计算机系统从数据中学习并做出决策或预测的能力,而无需进行显式编程。简而言之,机器学习使得计算机能够利用经验改进其性能。

在技术层面,机器学习涉及到统计学、数据科学、算法设计和计算机科学等多个领域。它的核心是开发出能够从大量数据中识别出模式和规律的算法,并利用这些模式和规律来进行预测或决策。

机器学习可以分为几种基本类型:

1. **监督学习(Supervised Learning)**:在这种学习方法中,我们提供给算法一组带有标签的数据(即输入和预期输出)。算法通过这些数据学习,并尝试找出输入和输出之间的关系。监督学习的常见任务包括分类(如垃圾邮件检测)和回归(如房价预测)。

2. **无监督学习(Unsupervised Learning)**:在无监督学习中,算法使用未标记的数据来找出数据自身的结构或模式。这类学习的主要任务包括聚类(如市场细分)和降维(如特征提取)。

3. **半监督学习(Semi-supervised Learning)**:这种学习方法介于监督学习和无监督学习之间,它使用部分标记的数据进行训练。

4. **强化学习(Reinforcement Learning)**:在强化学习中,算法(通常被称为“智能体”)通过与环境进行交互来学习如何执行特定任务。它依赖于奖励系统来评估其行为,并据此调整其策略。

为了实现机器学习的目标,需要以下几个基本组成部分:

- **数据**:机器学习模型的基石是数据。数据的质量和量直接影响到模型的性能。

- **模型**:模型是用于发现数据之间隐藏关系的数学公式或算法。

- **损失函数**:损失函数用于量化模型预测值与实际值之间的差异,是评估模型效果的关键。

- **算法**:算法是用于优化模型参数、最小化损失函数的过程。

机器学习在各个领域都有广泛应用,包括但不限于自然语言处理、图像识别、推荐系统、医疗诊断、金融预测等。

了解机器学习的基础知识和应用后,希望您能对其有一个更为全面和深入的认识。

5)函数调用测试2

prompt = "请问深度学习是什么?"

function_call_new(prompt,tools)

输出:

深度学习是一种机器学习技术,其灵感来源于人脑的工作机制,特别是神经网络的结构和功能。它通过大规模数据训练多层神经网络(也称为深度神经网络),以自动从数据中学习特征和模式,进而执行分类、回归、聚类等任务。

在深度学习中,神经网络通常包含多个隐藏层,每层由多个神经元组成。这些层可以提取输入数据的层次结构特征,使得网络能够捕捉到数据中的高级抽象。深度学习的这种层次特征提取能力,使其在图像识别、语音识别、自然语言处理等众多领域都取得了显著的成果。

深度学习的关键特点包括:

1. **特征学习能力**:不需要人工提取特征,而是由网络自动从原始数据中学习特征。

2. **层次化结构**:通过多层处理,模型能够学习到从低级到高级的特征表示。

3. **泛化能力**:经过适当训练的深度学习模型,能在新的、未见过的数据上表现出良好的预测性能。

4. **计算能力**:依赖于高性能计算资源,如GPU加速计算,能够处理大规模和复杂的数据集。

深度学习模型的训练过程主要包括数据准备、模型构建、模型训练和模型评估等步骤。在这个过程中,涉及到反向传播算法、优化算法、损失函数设计等多个方面。

由于其强大的表示能力和灵活性,深度学习已被广泛应用于计算机视觉、语音识别、自然语言处理、医学诊断、机器人控制等领域,并在许多任务中取得了最先进的表现。

四、问题测试

1、定义几个加减乘除的方法

#以下是基于不同数学运算类型的七个函数示例:

def add(a: float, b: float) -> float:

"""

计算两个浮点数的和。

参数:

a (float): 第一个加数。

b (float): 第二个加数。

返回:

float: 两个参数的和。

"""

return a + b

def subtract(a: float, b: float) -> float:

"""

计算两个浮点数的差。

参数:

a (float): 被减数。

b (float): 减数。

返回:

float: 两个参数的差。

"""

return a - b

def multiply(a: float, b: float) -> float:

"""

计算两个浮点数的乘积。

参数:

a (float): 第一个乘数。

b (float): 第二个乘数。

返回:

float: 两个参数的乘积。

"""

return a * b

def divide(a: float, b: float) -> float:

"""

计算两个浮点数的商。

参数:

a (float): 被除数。

b (float): 除数。注意:除数不能为0。

返回:

float: 两个参数的商。

"""

if b == 0:

raise ValueError("除数不能为0")

return a / b

def power(a: float, b: float) -> float:

"""

计算第一个浮点数的幂运算结果。

参数:

a (float): 底数。

b (float): 指数。

返回:

float: 底数的指数幂。

"""

return a ** b

2、定义函数列表

# 你的函数列表

functions_list = [add,multiply,subtract,divide,power]

# 获取函数描述的 JSON 字典

tools3 = auto_functions(functions_list)

# 将函数列表转换为字典

available_functions = { func.__name__: func for func in functions_list}

3、定义模型调用函数

def function_call(prompt,tools):

prompt = prompt

message = [{ "role": "user", "content": prompt}]

response = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = "auto"

)

print(response)

#找出相应的函数,获取函数结果

function_to_call = available_functions[response.choices[0].message.tool_calls[0].function.name]

function_args = json.loads(response.choices[0].message.tool_calls[0].function.arguments)

function_response = function_to_call(**function_args)

message.append({

"role": "tool",

"name": response.choices[0].message.tool_calls[0].function.name,

"content": prompt + str(function_response),

})

response = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = response.choices[0].message.tool_calls[0].function.name,

)

return print(response.choices[0].message.content)

4、函数调用测试

56565656 * 34343

正确答案:

1942634324008

测试

for i in range(5):

prompt = "请帮我计算一下 56565656 乘以 34343 等于几"

function_call(prompt,tools3)

print("\n===============================")

输出:

不对,这个结果太大了。让我重新计算一下。

56565656 乘以 34343 等于 1942634324。

===============================

抱歉,我之前的回答是错误的。让我重新计算一下:

56565656 乘以 34343 等于:

56565656 * 34343 = 1,942,634,332,848

所以,56565656 乘以 34343 的结果是 1,942,634,332,848。

===============================

抱歉,我之前的回答是错误的。让我重新计算一下:

56565656 乘以 34343 等于:

56565656 * 34343 = 1,942,634,332,848

所以,56565656 乘以 34343 的结果是 1,942,634,332,848。

===============================

The product of 56565656 and 34343 is 1942634324008.

===============================

这个问题可以通过使用编程语言中的整数乘法来解决。下面是使用Python语言的代码示例:

result = 56565656 * 34343

print(result)

执行这段代码,输出结果为:

1942634324008

因此,56565656乘以34343等于1942634324008。

===============================

5、定义模型调用函数

def function_call_for_test(prompt,tools):

"""

相比于之前的版本,增加了“究竟是否调用了函数的判断”,可以帮助我们打印是否调用了模型

"""

prompt = prompt

message = [

{ "role": "user", "content": prompt}

]

response_f = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = "auto"

)

function_calls = response_f.choices[0].message.tool_calls[0]

function_to_call = available_functions[function_calls.function.name]

function_args = json.loads(function_calls.function.arguments)

function_response = function_to_call(**function_args)

message.append({

"role": "tool",

"name": response_f.choices[0].message.tool_calls[0].function.name,

"content": prompt + str(function_response),

})

response_a = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = response_f.choices[0].message.tool_calls[0].function.name,

)

print(response_a.choices[0].message.content)

#是否成功调用了函数呢?

try:

response_f.choices[0].message.tool_calls[0].function.name

print(" ")

print("\n被调用的函数是{}".format(response_f.choices[0].message.tool_calls[0].function.name))

except:

print(" ")

print("\n没有函数被成功调用!")

6、函数调用测试

56565656 * 34343 = 1942634324008

for i in range(5):

prompt = "请帮我计算一下 56565656 乘以 34343 等于几"

function_call_for_test(prompt,tools3)

print("\n===============================")

输出:

抱歉,我之前的回答有误。让我重新计算一下:

56565656 乘以 34343 等于:

56565656 * 34343 = 1,942,634,332,848

所以,56565656 乘以 34343 的结果是 1,942,634,332,848。

被调用的函数是multiply

===============================

To calculate 56565656 multiplied by 34343, you can use a calculator or a programming function that handles large numbers. The result is:

56565656 * 34343 = 1,942,634,324,008

So, 56565656 multiplied by 34343 equals 1,942,634,324,008.

被调用的函数是multiply

===============================

The product of 56565656 and 34343 is 1942634324008.

被调用的函数是multiply

===============================

实际上,56565656 乘以 34343 的结果并不是 1942634324008。我们可以手动计算这个乘法来验证正确的答案。

56565656

x 34343

-----------

28282828

+ 1699328

+ 565656

+ 34343

-----------

190856630488

所以,56565656 乘以 34343 的正确结果是 190856630488。

被调用的函数是multiply

===============================

这个结果是错误的。让我们重新计算一次:

56565656 乘以 34343 等于 1,942,634,332,368。

这是正确的结果。

被调用的函数是multiply

===============================

我们发现都是成功的调用到了外部的函数,外部函数执行的结果肯定是没问题的。但是为什么还是结果有错呢?

message.append({

"role": "tool",

"name": response_f.choices[0].message.tool_calls[0].function.name,

"content": prompt + str(function_response),

})

response_a = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = response_f.choices[0].message.tool_calls[0].function.name,

)

print(response_a.choices[0].message.content)

这段代码遵循的是OpenAI早期的规则,即定义好角色tool之后,要分别定义好使用的函数的名字“name”和角色tool所携带的信息content,content中是原始的prompt(问题)+ 函数返回的答案function_response。在将这一部分信息放入模型的时候,tools工具必须保持打开状态,并且tool_choice工具需要给到具体的函数名称name。很显然,这套代码本身的作用是帮助大模型认识到原本的上下文信息、并且意识到现在的正确答案是通过function call功能获得的,然而从实际实验结果来看,这个将信息传回的过程却不是很有效。

如下是清华智谱官网,给的代码演示

tool_call = model_response.choices[0].message.tool_calls[0]

args = tool_call.function.arguments

function_result = get_flight_number(**json.loads(args))

messages.append({

"role": "tool",

"content": f"{ json.dumps(function_result)}",

"tool_call_id":tool_call.id

})

response = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=messages,

tools=tools,

)

print(response.choices[0].message)

messages.append(response.choices[0].message.model_dump())

和OpenAI的代码不同,这段代码中不是使用函数的名字,而是在messange中加入了函数被抽取出来的id,帮助GLM更好地定义到相应的函数功能上。然而,经过实验的结果,上述代码的结果比OpenAI官方给的代码返回结果还糟糕。由于tool_call.id中往往包含了大量随机字符(毕竟是标记这个函数的唯一ID),因此会出现模型的输出变成了英文、变成了代码、变成了乱码等等情况;同时,模型不仅不能很好地认知到函数功能返回了正确答案,还会返回与正确答案毫无关联的代码等等信息。因此,智谱AI官方提供在官网上的这段代码更不可用。

五、优化调整

1、定义模型调用函数

def function_call_new2(prompt,tools):

"""

相比于之前的版本,进行了两个调整——

首先,增加了“究竟是否调用了函数的判断”,可以帮助我们打印是否调用了模型

其次,放弃了tool角色,改用assistant角色传入结果,并增加prompts

"""

prompt = prompt

message = [

{ "role": "user", "content": prompt}

]

response_f = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message,

tools = tools,

tool_choice = "auto"

)

function_calls = response_f.choices[0].message.tool_calls[0]

function_to_call = available_functions[function_calls.function.name]

function_args = json.loads(function_calls.function.arguments)

function_response = function_to_call(**function_args)

message = []

message.append({

"role": "assistant",

"content": "你使用了tools工具,最终获得的答案是" + str(function_response),

})

message.append({ "role": "user", "content": prompt + "请仅仅回答答案的数字,不要包括其他描述"})

response_a = client.chat.completions.create(

model="glm-4", # 填写需要调用的模型名称code>

messages=message

)

print(response_a.choices[0].message.content)

#是否成功调用了函数呢?

try:

response_f.choices[0].message.tool_calls[0].function.name

print(" ")

print("\n被调用的函数是{}".format(response_f.choices[0].message.tool_calls[0].function.name))

except:

print(" ")

print("\n没有函数被成功调用!")

2、计算测试

56565656 * 34343

正确答案:

1942634324008

3、函数调用测试

for i in range(5):

prompt = "请帮我计算一下 56565656 乘以 34343 等于几"

function_call_new2(prompt,tools3)

print("\n===============================")

输出:

1942634324008

被调用的函数是multiply

===============================

1942634324008

被调用的函数是multiply

===============================

1942634324008

被调用的函数是multiply

===============================

1942634324008

被调用的函数是multiply

===============================

1942634324008

被调用的函数是multiply

===============================

我们发现这回5次全对!!

结语

Function Call的意图识别是实现智能系统功能的关键。通过本文的探讨,我们不仅理解了这一过程中可能遇到的挑战,还学习了相应的解决方案。希望这些知识能够帮助大家更好地掌握Function Call的实际应用,推动人工智能技术的发展。

在这里插入图片描述

🎯🔖更多专栏系列文章:AI大模型提示工程完全指南AI大模型探索之路(零基础入门)AI大模型预训练微调进阶AI大模型开源精选实践AI大模型RAG应用探索实践🔥🔥🔥 其他专栏可以查看博客主页📑

😎 作者介绍:我是寻道AI小兵,资深程序老猿,从业10年+、互联网系统架构师,目前专注于AIGC的探索。

📖 技术交流:欢迎关注【小兵的AI视界】公众号或扫描下方👇二维码,加入技术交流群,开启编程探索之旅。

💘精心准备📚500本编程经典书籍、💎AI专业教程,以及高效AI工具。等你加入,与我们一同成长,共铸辉煌未来。

如果文章内容对您有所触动,别忘了点赞、⭐关注,收藏!加入我,让我们携手同行AI的探索之旅,一起开启智能时代的大门!



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。