如何在服务器上部署开源大模型 GLM-4-9B-Chat 并应用到RAG应用中

本地服务器部署开源大模型有一个前提，就是得有 GPU 显卡资源，在我下面的例子中我租用了 autodl 中的算力资源，具体是租用了一张消费级别的 RTX 3090 显卡。

环境配置

操作系统及版本：ubuntu 22.04
CUDA 版本： 12.1
pytorch 版本：2.3.0+cu121

pip 换源和安装依赖包。

 1# 升级pip
 2python -m pip install --upgrade pip
 3# 更换 pypi 源加速库的安装
 4pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
 5
 6pip install fastapi==0.104.1
 7pip install uvicorn==0.24.0.post1
 8pip install requests==2.25.1
 9pip install modelscope==1.9.5
10pip install transformers==4.42.4
11pip install streamlit==1.24.0
12pip install sentencepiece==0.1.99
13pip install accelerate==0.24.1
14pip install tiktoken==0.7.0

这里要注意 transformers 的版本是 4.42.4

模型下载

GLM-4-9B-Chat 模型大小为 18 GB，下载模型大概需要 10~20 分钟。

由于后面我们要使用一个开源的 embedding 模型 BAAI/bge-base-zh-v1.5

所以使用以下代码下载 2 个模型文件到本地文件系统：

运行 python download.py

1import torch
2from modelscope import snapshot_download, AutoModel, AutoTokenizer
3import os
4model_dir = snapshot_download('ZhipuAI/glm-4-9b-chat', cache_dir='/root/autodl-tmp', revision='master')
5embedding_model_dir = snapshot_download('BAAI/bge-base-zh-v1.5', cache_dir='/root/autodl-tmp', revision='master')

模型测试

GLM 开源模型官方给了一个 Demo 方便我们做测试，以下是代码：

运行 python trans_cli_demo.py

 1"""
 2This script creates a CLI demo with transformers backend for the glm-4-9b model,
 3allowing users to interact with the model through a command-line interface.
 4
 5Usage:
 6- Run the script to start the CLI demo.
 7- Interact with the model by typing questions and receiving responses.
 8
 9Note: The script includes a modification to handle markdown to plain text conversion,
10ensuring that the CLI interface displays formatted text correctly.
11
12If you use flash attention, you should install the flash-attn and  add attn_implementation="flash_attention_2" in model loading.
13"""
14
15import os
16import torch
17from threading import Thread
18from transformers import AutoTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer, AutoModelForCausalLM
19
20MODEL_PATH = os.environ.get('MODEL_PATH', '/root/autodl-tmp/ZhipuAI/glm-4-9b-chat')
21
22tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)
23
24model = AutoModelForCausalLM.from_pretrained(
25    MODEL_PATH,
26    trust_remote_code=True,
27    device_map="auto"
28).eval()
29
30class StopOnTokens(StoppingCriteria):
31    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
32        stop_ids = model.config.eos_token_id
33        for stop_id in stop_ids:
34            if input_ids[0][-1] == stop_id:
35                return True
36        return False
37
38if __name__ == "__main__":
39    history = []
40    max_length = 8192
41    top_p = 0.8
42    temperature = 0.6
43    stop = StopOnTokens()
44
45    print("Welcome to the GLM-4-9B CLI chat. Type your messages below.")
46    while True:
47        user_input = input("\nYou: ")
48        if user_input.lower() in ["exit", "quit"]:
49            break
50        history.append([user_input, ""])
51
52        messages = []
53        for idx, (user_msg, model_msg) in enumerate(history):
54            if idx == len(history) - 1 and not model_msg:
55                messages.append({"role": "user", "content": user_msg})
56                break
57            if user_msg:
58                messages.append({"role": "user", "content": user_msg})
59            if model_msg:
60                messages.append({"role": "assistant", "content": model_msg})
61        model_inputs = tokenizer.apply_chat_template(
62            messages,
63            add_generation_prompt=True,
64            tokenize=True,
65            return_tensors="pt"
66        ).to(model.device)
67        streamer = TextIteratorStreamer(
68            tokenizer=tokenizer,
69            timeout=60,
70            skip_prompt=True,
71            skip_special_tokens=True
72        )
73        generate_kwargs = {
74            "input_ids": model_inputs,
75            "streamer": streamer,
76            "max_new_tokens": max_length,
77            "do_sample": False,  # 改为 False
78            "top_p": top_p,
79            "temperature": temperature,
80            "stopping_criteria": StoppingCriteriaList([stop]),
81            "repetition_penalty": 1.2,
82            "eos_token_id": model.config.eos_token_id,
83        }
84        try:
85            t = Thread(target=model.generate, kwargs=generate_kwargs)
86            t.start()
87            print("GLM-4:", end="", flush=True)
88            for new_token in streamer:
89                if new_token:
90                    print(new_token, end="", flush=True)
91                    history[-1][1] += new_token
92        except Exception as e:
93            print(f"An error occurred: {e}")
94            print(f"Error type: {type(e)}")
95            import traceback
96            traceback.print_exc()
97
98        history[-1][1] = history[-1][1].strip()

注意以上代码和 GLM 官方提供的可能不太一样，因为官方的有的报错，所以我略为修改了一下。

直接运行 trans_cli_demo.py 就可以和模型交互了

利用 FastApi 调用模型

运行以下代码创建并启动 Api 服务：

运行 python api.py

 1from fastapi import FastAPI, Request
 2from transformers import AutoTokenizer, AutoModelForCausalLM
 3import uvicorn
 4import json
 5import datetime
 6import torch
 7
 8# 设置设备参数
 9DEVICE = "cuda"  # 使用CUDA
10DEVICE_ID = "0"  # CUDA设备ID，如果未设置则为空
11CUDA_DEVICE = f"{DEVICE}:{DEVICE_ID}" if DEVICE_ID else DEVICE  # 组合CUDA设备信息
12
13# 清理GPU内存函数
14def torch_gc():
15    if torch.cuda.is_available():  # 检查是否可用CUDA
16        with torch.cuda.device(CUDA_DEVICE):  # 指定CUDA设备
17            torch.cuda.empty_cache()  # 清空CUDA缓存
18            torch.cuda.ipc_collect()  # 收集CUDA内存碎片
19
20# 创建FastAPI应用
21app = FastAPI()
22
23# 处理POST请求的端点
24@app.post("/")
25async def create_item(request: Request):
26    global model, tokenizer  # 声明全局变量以便在函数内部使用模型和分词器
27    json_post_raw = await request.json()  # 获取POST请求的JSON数据
28    json_post = json.dumps(json_post_raw)  # 将JSON数据转换为字符串
29    json_post_list = json.loads(json_post)  # 将字符串转换为Python对象
30    prompt = json_post_list.get('prompt')  # 获取请求中的提示
31    history = json_post_list.get('history')  # 获取请求中的历史记录
32    max_length = json_post_list.get('max_length', 2048)  # 获取请求中的最大长度
33    top_p = json_post_list.get('top_p', 0.7)  # 获取请求中的top_p参数
34    temperature = json_post_list.get('temperature', 0.95)  # 获取请求中的温度参数
35
36    # 准备输入
37    messages = []
38    if history:
39        for h in history:
40            messages.append({"role": "user", "content": h[0]})
41            messages.append({"role": "assistant", "content": h[1]})
42    messages.append({"role": "user", "content": prompt})
43
44    input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
45
46    # 生成回复
47    with torch.no_grad():
48        outputs = model.generate(
49            input_ids,
50            max_new_tokens=max_length,
51            do_sample=True,
52            top_p=top_p,
53            temperature=temperature,
54        )
55
56    response = tokenizer.decode(outputs[0][input_ids.shape[1]:], skip_special_tokens=True)
57
58    now = datetime.datetime.now()  # 获取当前时间
59    time = now.strftime("%Y-%m-%d %H:%M:%S")  # 格式化时间为字符串
60    # 构建响应JSON
61    answer = {
62        "response": response,
63        "history": history + [[prompt, response]],
64        "status": 200,
65        "time": time
66    }
67    # 构建日志信息
68    log = "[" + time + "] " + '", prompt:"' + prompt + '", response:"' + repr(response) + '"'
69    print(log)  # 打印日志
70    torch_gc()  # 执行GPU内存清理
71    return answer  # 返回响应
72
73# 主函数入口
74if __name__ == '__main__':
75    # 加载预训练的分词器和模型
76    tokenizer = AutoTokenizer.from_pretrained("/root/autodl-tmp/ZhipuAI/glm-4-9b-chat", trust_remote_code=True)
77    model = AutoModelForCausalLM.from_pretrained(
78        "/root/autodl-tmp/ZhipuAI/glm-4-9b-chat",
79        torch_dtype=torch.bfloat16,
80        trust_remote_code=True,
81        device_map="auto",
82    )
83    model.eval()  # 设置模型为评估模式
84    # 启动FastAPI应用
85    # 用6006端口可以将autodl的端口映射到本地，从而在本地使用api
86    uvicorn.run(app, host='0.0.0.0', port=6006, workers=1)  # 在指定端口和主机上启动应用

测试服务

1curl -X POST "http://127.0.0.1:6006" \
2     -H 'Content-Type: application/json' \
3     -d '{"prompt": "你好", "history": []}'
4

利用 FastApi 同样可以测试模型的调用和交互。

注意，以上代码你可能会在网络上找到类似的，我在最开始使用那些代码的时候报各种错，原因大概包括模型和代码版本不兼容，组件库版本问题等。所以以上代码是经过我的修改之后可运行的代码

RAG

在之前的文章中

提速 RAG 应用：用 DeepSeek API 替换本地 Ollama 模型

LlamaIndex 实战解析提升RAG应用性能：使用智谱AI的GLM-4和Embedding-3模型优化文档检索

Milvus实战：如何用一个数据库提升你的AI项目性能

我们通过 Ollama 在笔记本电脑上部署过大模型，通过大模型产品的 API 调用过大模型，唯独没有在服务器上私有化部署一个大模型。

前文我们已经在服务器上部署好了大模型 glm-4-9b-chat 这是一个拥有 90 亿参数的模型。下面我们介绍如何在 llamaindex 中调用它。

很简单，首先我们还是先自定义一个LLM ，参考以下代码：

 1import logging
 2from typing import Any, List, Optional
 3from llama_index.core.llms import (
 4    CustomLLM,
 5    CompletionResponse,
 6    CompletionResponseGen,
 7    LLMMetadata,
 8)
 9from llama_index.core.llms.callbacks import llm_completion_callback
10from transformers import AutoTokenizer, AutoModelForCausalLM
11import torch
12
13# 设置日志
14logging.basicConfig(level=logging.DEBUG)
15logger = logging.getLogger(__name__)
16
17class LocalGLM4(CustomLLM):
18
19    context_window: int = 8192  # 默认上下文窗口大小
20    num_output: int = 2048  # 默认输出的token数量
21    model_name: str = "glm-4-9b-chat"  # 模型名称
22    tokenizer: object = None  # 分词器
23    model: object = None  # 模型
24
25    def __init__(self, pretrained_model_name_or_path: str):
26        super().__init__()
27
28        # GPU方式加载模型
29        self.tokenizer = AutoTokenizer.from_pretrained(
30            pretrained_model_name_or_path, trust_remote_code=True
31        )
32        self.model = AutoModelForCausalLM.from_pretrained(
33            pretrained_model_name_or_path,
34            torch_dtype=torch.float16,  # 或者使用 torch.bfloat16
35            low_cpu_mem_usage=True,
36            trust_remote_code=True,
37            device_map="auto",
38        )
39
40        # CPU方式加载模型
41        # self.tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path, device_map="cpu", trust_remote_code=True)
42        # self.model = AutoModelForCausalLM.from_pretrained(pretrained_model_name_or_path, device_map="cpu", trust_remote_code=True)
43        # self.model = self.model.float()
44
45        # 尝试获取模型的实际上下文窗口大小
46        if hasattr(self.model.config, 'seq_length'):
47            self.context_window = self.model.config.seq_length
48        elif hasattr(self.model.config, 'max_position_embeddings'):
49            self.context_window = self.model.config.max_position_embeddings
50        logger.info(f"Using context window size: {self.context_window}")
51
52    @property
53    def metadata(self) -> LLMMetadata:
54        """Get LLM metadata."""
55        # 得到LLM的元数据
56        return LLMMetadata(
57            context_window=self.context_window,
58            num_output=self.num_output,
59            model_name=self.model_name,
60        )
61
62    @llm_completion_callback()
63    def complete(self, prompt: str, **kwargs: Any) -> CompletionResponse:
64        # 完成函数
65        print("完成函数")
66
67        inputs = self.tokenizer.encode(prompt, return_tensors="pt").cuda()  # GPU方式
68        # inputs = self.tokenizer.encode(prompt, return_tensors='pt')  # CPU方式
69        outputs = self.model.generate(inputs, max_length=self.num_output)
70        response = self.tokenizer.decode(outputs[0])
71        return CompletionResponse(text=response)
72
73    @llm_completion_callback()
74    def stream_complete(self, prompt: str, **kwargs: Any) -> CompletionResponseGen:
75        # 流式完成函数
76        print("流式完成函数")
77
78        inputs = self.tokenizer.encode(prompt, return_tensors="pt").cuda()  # GPU方式
79        # inputs = self.tokenizer.encode(prompt, return_tensors='pt')  # CPU方式
80        outputs = self.model.generate(inputs, max_length=self.num_output)
81        response = self.tokenizer.decode(outputs[0])
82        for token in response:
83            yield CompletionResponse(text=token, delta=token)

剩下的步骤跟之前的调用方式、代码编程模型几乎没有任何区别：

 1    embed_model_path = "/root/autodl-tmp/BAAI/bge-base-zh-v1.5"
 2    pretrained_model_name_or_path = r"/root/autodl-tmp/ZhipuAI/glm-4-9b-chat"
 3
 4    # 设置LLM和嵌入模型
 5    logger.info("Setting up LLM and embedding model")
 6    Settings.llm = LocalGLM4(pretrained_model_name_or_path)
 7    Settings.embed_model = HuggingFaceEmbedding(
 8        model_name=f"{embed_model_path}", device="cuda"
 9    )
10
11    # 从指定目录加载文档数据
12    logger.info("Loading documents")
13    documents = SimpleDirectoryReader(input_files=["./data/sample.txt"]).load_data()
14
15    # 创建索引和查询引擎
16    logger.info("Creating index and query engine")
17    index = VectorStoreIndex.from_documents(documents)
18    query_engine = index.as_query_engine(streaming=False)
19
20    # 执行查询
21    logger.info("Executing query")
22    response = query_engine.query(query)
23
24    # 处理并输出响应
25    if hasattr(response, "response_gen"):
26        # 流式输出
27        for text in response.response_gen:
28            print(text, end="", flush=True)
29            sys.stdout.flush()  # 确保立即输出
30    else:
31        # 非流式输出
32        print(response.response, end="", flush=True)

相关代码可以在这里查看：https://github.com/xiaobox/llamaindex_test

总结

利用租用的 GPU 资源部署了开源大模型 glm-4-9b-chat ，通过熟悉部署方式和流程，你可以照猫画虎部署其他开源模型。接着我们将之前 RAG 项目中对LLM的调用改为服务器部署的本地开源模型，实现了模型和调用的私有化。希望这篇文章能够帮助到有类似需求的朋友。