AIGC学习笔记（5）——AI大模型开发工程师

AI大模型开发工程师

004 垂直领域的智能在线搜索平台

1 智能在线搜索平台需求分析

大模型不够“聪明”

增强大模型的方式

• 主要有两种：RAG 和 微调（难度比较大）

需求分析

• 用户提问（Prompt）给大模型
  • 如果大模型知道，就直接根据大模型知识库给出回答
  • 如果大模型不知道，那就通过工具进行外部搜索，最终给出回答

• 进行外部搜索，不太可能针对全网进行搜索，原因主要有：
  • 知识产权的问题
  • 爬虫解析的问题
• 只需要针对 IT 程序员经常使用的网站进行在线搜索

2 智能在线搜索平台方案设计

方案设计

技术选型

大模型版本

~ % pip show zhipuai   
Name: zhipuai
Version: 2.1.5.20230904
Summary: A SDK library for accessing big model apis from ZhipuAI
Home-page: 
Author: Zhipu AI
Author-email: 
License: 
Location: /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages
Requires: cachetools, httpx, pydantic, pydantic-core, pyjwt
Required-by: 

~ % pip show openai  
Name: openai
Version: 1.52.2
Summary: The official Python library for the openai API
Home-page: https://github.com/openai/openai-python
Author: 
Author-email: OpenAI <support@openai.com>
License: 
Location: /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages
Requires: anyio, distro, httpx, jiter, pydantic, sniffio, tqdm, typing-extensions
Required-by: 

GLM-4大模型注册使用

• 地址：https://open.bigmodel.cn/
• 完成注册并登录，极其简单，只需要绑定手机号和邮箱就行

• 注册成功开始使用

• 可以进行一下实名认证，解锁更多权益

• 获取API Key，并保存到本地环境变量中 export ZHIPU_API_KEY=xxx

• 现在没有赠送金额了，所以需要充值

• 控制台可以体验功能，进行模型选择、模型微调、新建应用、知识库（相当于一个向量数据库或网盘）等

Google Cloud平台注册

• 地址：https://console.cloud.google.com/
• 新建项目：OnlineSearch

• 选择项目OnlineSearch – APIs and Services

• 选择 Library，搜索 “Google Search”，选择 “Custom Search API”

• Enable 启用，生成凭证 Credentials API Key

• 保存 API Key，可以在本地设置环境变量 export GOOGLE_SEARCH_API_KEY = xxxx

创建可编程的搜索引擎

• 地址：https://programmablesearchengine.google.com/

• 添加搜索引擎

• 创建

• 保存 cse_id，设置环境变量 export CSE_ID=xxx

3 智能在线搜索平台代码落地

完成在线搜索思路分析

GLM4调用外部函数测试

• GLM4的 function calling 工具代码封装
• 代码和ChatGPT的几乎一模一样

import os
import openai
from openai import OpenAI
import shutil

import numpy as np
import pandas as pd

import json
import io
import inspect
import requests
import re
import random
import string

## 初始化客户端
api_key = os.getenv("ZHIPU_API_KEY")

from zhipuai import ZhipuAI
client = ZhipuAI(api_key=api_key)

def sunwukong_function(data):
    """
    孙悟空算法函数，该函数定义了数据集计算过程
    :param data: 必要参数，表示带入计算的数据表，用字符串进行表示
    :return：sunwukong_function函数计算后的结果，返回结果为表示为JSON格式的Dataframe类型对象
    """
    data = io.StringIO(data)
    df_new = pd.read_csv(data, sep='\s+', index_col=0)
    res = df_new * 10
    return json.dumps(res.to_string())

def auto_functions(functions_list):
    """
    Chat模型的functions参数编写函数
    :param functions_list: 包含一个或者多个函数对象的列表；
    :return：满足Chat模型functions参数要求的functions对象
    """
    def functions_generate(functions_list):
        # 创建空列表，用于保存每个函数的描述字典
        functions = []
        # 对每个外部函数进行循环
        for function in functions_list:
            # 读取函数对象的函数说明
            function_description = inspect.getdoc(function)
            # 读取函数的函数名字符串
            function_name = function.__name__

            system_prompt = '以下是某的函数说明：%s,输出结果必须是一个JSON格式的字典，只输出这个字典即可，前后不需要任何前后修饰或说明的语句' % function_description
            user_prompt = '根据这个函数的函数说明，请帮我创建一个JSON格式的字典，这个字典有如下5点要求：\
                           1.字典总共有三个键值对；\
                           2.第一个键值对的Key是字符串name，value是该函数的名字：%s，也是字符串；\
                           3.第二个键值对的Key是字符串description，value是该函数的函数的功能说明，也是字符串；\
                           4.第三个键值对的Key是字符串parameters，value是一个JSON Schema对象，用于说明该函数的参数输入规范。\
                           5.输出结果必须是一个JSON格式的字典，只输出这个字典即可，前后不需要任何前后修饰或说明的语句' % function_name

            response = client.chat.completions.create(
                              model="glm-4",
                              messages=[
                                {
   "role": "system", "content": system_prompt},
                                {
   "role": "user", "content": user_prompt}
                              ]
                            )
            json_str=response.choices[0].message.content.replace("```json","").replace("```","")
            json_function_description=json.loads(json_str)
            json_str={
   "type": "function","function":json_function_description}
            functions.append(json_str)
        return functions
    ## 最大可以尝试4次
    max_attempts = 4
    attempts = 0

    while attempts < max_attempts:
        try:
            functions = functions_generate(functions_list)
            break  # 如果代码成功执行，跳出循环
        except Exception as e:
            attempts += 1  # 增加尝试次数
            print("发生错误：", e)
            if attempts == max_attempts:
                print("已达到最大尝试次数，程序终止。")
                raise  # 重新引发最后一个异常
            else:
                print("正在重新运行...")
    return functions

def run_conversation(messages, functions_list=None, model="glm-4"):
    """
    能够自动执行外部函数调用的对话模型
    :param messages: 必要参数，字典类型，输入到Chat模型的messages参数对象
    :param functions_list: 可选参数，默认为None，可以设置为包含全部外部函数的列表对象
    :param model: Chat模型，可选参数，默认模型为glm-4
    :return：Chat模型输出结果
    """
    # 如果没有外部函数库，则执行普通的对话任务
    if functions_list == None:
        response = client.chat.completions.create(
                        model=model,
                        messages=messages,
                        )
        response_message = response.choices[0].message
        final_response = response_message.content
  
    # 若存在外部函数库，则需要灵活选取外部函数并进行回答
    else:
        # 创建functions对象
        tools = auto_functions(functions_list)

        # 创建外部函数库字典
        available_functions = {
   func.__name__: func for func in functions_list}

        # 第一次调用大模型
        response = client.chat.completions.create(
                        model=model,
                        messages=messages,
                        tools=tools,
                        tool_choice="auto", )
        response_message = response.choices[0].message


        tool_calls = response_message.tool_calls

        if tool_calls:

            #messages.append(response.choices[0].message)
            messages.append(response.choices[0].message.model_dump())
            for tool_call in tool_calls:
                function_name = tool_call.function.name
                function_to_call = available_functions[function_name]
                function_args = json.loads(tool_call.function.arguments)
                ## 真正执行外部函数的就是这儿的代码
                function_response = function_to_call(**function_args)
                messages.append(
                    {
   
                        "role": "tool",
                        "content": function_response,
                        "tool_call_id": tool_call.id,
                    }
                ) 
            ##