ChatGPT平替- ChatGLM多用户并行访问部署过程

kka10011

这篇文章主要介绍了ChatGPT平替- ChatGLM多用户并行访问部署，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

+

目录

        ChatGLM对话模型基本环境配置和部署请参考上一篇博文《ChatGPT平替-ChatGLM环境搭建与部署运行》，地址为“https://www.jb51.net/article/283295.htm”。但是，默认部署程序仅支持单用户访问，多用户则需要排队访问。测试过相关的几个Github多用户工程，但是其中一些仍然不满足要求。本节将系统介绍如何实现多用户同时访问ChatGLM的部署接口，包括http、websocket（流式输出，stream）和web页面等方式，主要目录如下所示。

        （1）api.py http多用户并行

        （2）api.py websocket多用户并行（流式输出，stream）

        （3）web_demo.py多用户并行

        本节所涉及程序可根据文中描述自行编写或替换，也可在“https://download.csdn.net/download/suiyingy/87742178”进行下载，文中所有程序均在其中。

1 api.py http多用户并行
! C$ n) d! o: H- T0 b1.1 fastapi并行

        ChatGLM-6B工程的api.py是基于fastapi编写的http post服务程序。具体介绍及调用方式请参考上一篇博文。运行程序后，当多用户同时调用该http接口时，程序需要排队执行，即当前用户指令需要等待上一用户获取结果完成之后才进行执行。

        实现接口并行的关键在于去除create_item的async，相应程序如下所示，该函数段由RdFast小程序自动生成。我们可以根据如下描述编写程序，也可前往“https://download.csdn.net/download/suiyingy/87742178”进行下载，对应下载后的api_http_one_worker.py文件。

1. #该函数段由RdFast小程序自动生成
   
2. from pydantic import BaseModel
   
3. class User(BaseModel):
   
4.     prompt: str
   
5.     history: list
   8 J- f+ q. }6 T$ u/ [
6. @app.post("/http/noasync")
   ( T& W$ \9 l, s' Z. i9 w% c  s
7. def create_item(request: User):
   * v3 ^+ ]! P  a( q; A
8.     global model, tokenizer
   6 z" p+ w( \0 b- r& I
9.     json_post_raw = request.dict()
   ' {! R8 }3 r  r/ [
10.     json_post = json.dumps(json_post_raw)
    
11.     json_post_list = json.loads(json_post)
    8 s: ^1 m2 y9 t" v! a/ e
12.     prompt = json_post_list.get('prompt')
    4 j0 n" Y) m$ i: Q# ]4 y4 _. m
13.     history = json_post_list.get('history')
    9 K( k% @1 I8 i' E4 L& I1 ^4 L
14.     max_length = json_post_list.get('max_length')
    6 u+ g" D7 {5 N
15.     top_p = json_post_list.get('top_p')
    
16.     temperature = json_post_list.get('temperature')
    
17.     response, history = model.chat(tokenizer,
    4 c" h1 ^# O4 O7 R5 |: y
18.                                    prompt,
    & P1 V" J6 n/ j+ F/ A0 F8 y
19.                                    history=history,
      `, Q  ^, g0 m
20.                                    max_length=max_length if max_length else 2048,
    
21.                                    top_p=top_p if top_p else 0.7,
    3 U: q- p  l: Y' w
22.                                    temperature=temperature if temperature else 0.95)
    , e- o! t" O0 ]0 B! ?7 z0 S) W
23.     now = datetime.datetime.now()
    2 S) g0 b& h9 |" `( ^
24.     time = now.strftime("%Y-%m-%d %H:%M:%S")
    
25.     answer = {
    
26.         "response": response,
    # o. n* y. s7 m+ Y. m: E" w, h( a" y
27.         "history": history,
    7 _  {7 _$ A. S1 t7 V! z
28.         "status": 200,
    
29.         "time": time
    
30.     }
    ( X+ P/ R5 i" V* O/ |0 d/ `
31.     log = "[" + time + "] " + '", prompt:"' + prompt + '", response:"' + repr(response) + '"'
    
32.     print(log)
    
33.     torch_gc()

复制代码

/ R, T: R( @: |7 A4 b& F

我们通过输入“你好”来进行测试，并模拟三个用户进行同时访问。修改之前三个用户获取返回结果所需时间分别为2.08s、4.05s和6.02s，而修改之后获取结果所需时间分别为6.73s、6.78和6.88s。修改前程序顺序执行，最后一个用户获取结果所需时间为6.02s。修改后程序是并行执行的，三个用户几乎同时获得访问结果。

        由于模型参数在多个线程之间是共享的，且多线程状态下程序会交替运行，因此多线程状态下获取结果的总时间反而增加了。因此，这种修改并不适合http模式，比较适合于websocket流式输出。模拟多用户调用的测试程序如下所示。

1. import json
   - m" }6 M+ `/ f
2. import time
   0 S  ^# a+ C8 n5 G5 {
3. import requests
   
4. import threading
   * {+ `( g' x0 T7 D) H) t; k
5. def get_ans(id, prompt):
   
6.     t0 = time.time()
   8 Z: n' a( U8 i9 y2 u
7.     headers = {'Content-Type': 'application/json'}
   / N+ j. L8 b) G' k* @
8.     url = 'http://IP:Port/http/noasync'
   
9.     data = {'prompt': prompt, 'history': []}
   ' _/ u- q' ~# O
10.     data = json.dumps(data)
    0 T  W/ e0 {3 k( t2 S+ Y& T
11.     reponse = requests.post(url=url, data=data, headers=headers)
    
12.     print(id, '耗时为：', round(time.time() - t0, 2), 's，结果为：', reponse .text)
    
13. if __name__ == '__main__':
    
14.     t1 = threading.Thread(target=get_ans, args=('线程1', '你好'))
    
15.     t2 = threading.Thread(target=get_ans, args=('线程2', '你好'))
    ; }, {7 A5 M( D+ ?7 O3 v. L0 l( L
16.     t3 = threading.Thread(target=get_ans, args=('线程3', '你好'))
    6 @6 Y* M0 p9 s  I! P3 n; _
17.     t1.start()
    
18.     t2.start()
    
19.     t3.start()

复制代码

" D, m; a# ]+ L: H1.2 fastapi多线程并行

        fastapi多线程通过启动参数workers来进行控制。如果程序直接将api.py中的workers设置为大于1的数值，即“uvicorn.run(app, host='0.0.0.0', port=8000, workers=2)”，那么会报错“WARNING:  You must pass the application as an import string to enable 'reload' or 'workers'.”，报错后程序退出并停止执行。正确修改为“uvicorn.run('api:app', host='0.0.0.0', port=8000, workers=2)”，其中api表示当前python文件名称。

        这相当于各个线程分别运行api.py文件的app，运行次数由workers决定。从这里可以看到，程序并不能识别’__main__’函数中的变量，因此要把模型定义放在全局位置，如下所示，否则会报错误“NameError: name 'model' is not defined”。

1. app = FastAPI()
   # p% Z3 |* d- E, ?* u% r1 ?2 d
2. tokenizer = AutoTokenizer.from_pretrained("chatglm-6b-int4-qe", trust_remote_code=True)
   
3. model = AutoModel.from_pretrained("chatglm-6b-int4-qe", trust_remote_code=True).half().cuda()
   
4. model.eval()

复制代码

. A$ O3 w/ Y8 i0 ?( b( T8 K

   在多线程情况下，类似上一节，无论是否使用asnc，程序运行时间基本一致。但是，基本显存会随着线程数量增多而增加。实际运行时，单个线程应需要10GB左右显存，包括模型加载和推理。各个线程数量下的模型加载显存如下所示。而1.1节的方法中单个线程仅需要3939MB。

Workers=1, 7329MB
Workers=2, 17875MB
Workers=3, 24843MB
# X8 T- f+ j$ V5 @Workers=4, 31811MB
Workers=5, 38779MB

        我们可以根据上述描述编写程序，也可前往“https://download.csdn.net/download/suiyingy/87742178”进行下载，对应下载后的api_http_three_worker.py文件。

. g, V5 r5 [5 R2 m/ X0 o1 q1 f2 api.py websocket多用户并行

        Fastapi websocket的创建方法如下所示，该示例程序来源于RdFast小程序自动生成。

1. #该示例程序来源于RdFast小程序自动生成。
   
2. from fastapi import FastAPI, WebSocket, WebSocketDisconnect
   
3. app = FastAPI()
   0 A& u/ P! v' u
4. connected_websockets = {}
   
5. @app.websocket("/ws/{client_id}")
   % U* S3 u/ \6 J0 q' ^
6. async def websocket_endpoint(websocket: WebSocket, client_id: str):
   0 G  F# D1 y1 I, s8 P/ D( [$ @* i
7.     await websocket.accept()
   & ?; Y3 G) l* z  X9 I) Z) q+ U
8.     connected_websockets[client_id] = websocket
   
9.     try:
   
10.         while True:
    5 n( {; R* m2 v) o8 X
11.             # 接收客户端websocket发送过来的信息
    
12.             data = await websocket.receive_text()
    
13.             # 将接收到的信息通过所有已连接的websocket广播给其他客户端
    
14.             for ws in connected_websockets.values():
    
15.                 await ws.send_text(f"Client {client_id}: {data}")
    : g1 T0 j/ L( o. ?# G5 R
16.     except WebSocketDisconnect:
    5 U" n" {8 w# k* m! Z5 O$ C
17.         # 连接断开时，从已连接的客户端中移除
    
18.         del connected_websockets[client_id]

复制代码

将上述程序与ChatGLM结合即可实现ChatGLM的websocket api接口。示例程序如下所示：

1. @app.websocket("/ws/{client_id}")
   , P+ E) ~& U7 {, P8 j* s+ s2 x  b
2. async def websocket_endpoint(ws: WebSocket, client_id: str):
   % h6 g' ]) A1 h6 ~1 ~. v
3.     await ws.accept()
   
4.     print('已连接')
   
5.     try:
     q7 A' i4 N, o+ u2 ^  h
6.         while True:
   8 n+ }8 F) [- o0 c0 ?- t- U$ J
7.             # 接收客户端websocket发送过来的信息
   
8.             data = await ws.receive_text()
   " C7 u$ m8 T; a, V0 [# _) q
9.             print('收到消息：', data)
   # i* \# i! s5 i# s& z
10.             resp0 = ''
    
11.             for response, history in model.stream_chat(tokenizer, data, [], max_length= 2048,top_p= 0.7, temperature= 0.95):
    
12.                 print('response：', response)
    ( f" W. T$ B- o" q- Y3 d
13.                 res = response.replace(resp0, '')
    
14.                 resp0 = response
    4 @* G& |# c9 ?3 i6 d3 e/ v2 N4 Q- s
15.                 await ws.send_text(res)
    9 @3 Y& [+ \7 z+ m
16.             await ws.send_text('<rdfast stop>')#自定义结束符
    6 }" l6 B8 I6 t( U6 P4 z
17.     except WebSocketDisconnect:
    ) `& H" K: \0 \9 I
18.         print('连接已断开')

复制代码

. d: |  `( }- f3 a9 ?, y

  我们可以根据上述描述编写程序，也可前往“https://download.csdn.net/download/suiyingy/87742178”进行下载，对应下载后的api_http_one_worker.py文件。Websocket测试程序如下所示。

1. from websocket import create_connection
   
2. def connect_node(ques):
   
3.     ans = ''
   
4.     url = "ws://IP:Port/ws/2"
   5 U4 c! x. G1 ^' ^5 k8 X; V( Q
5.     ws = create_connection(url)
   ) X, Y9 z( ?8 I( ]. R7 y* q/ p
6.     ws.send(ques)
   / l" \8 g2 K! V9 e: }1 @
7.     while True:
   7 b6 Y8 d6 c0 F* Z& v6 p
8.         try:
   
9.             recv_text = ws.recv()
   
10.             print(recv_text)
    
11.             if '<rdfast stop>' in recv_text:
    
12.                 print('break')
    . `* o: D9 Y4 t8 X9 M
13.                 break
    
14.             ans += recv_text
    
15.         except Exception as e:
    
16.             print('except： ', str(e))
    
17.             recv_text = ws.recv()
    8 L6 ~7 j7 p9 f# _1 s' C
18.             break
    / `# W6 Q/ f8 |& W/ e
19.     print(ans)
    
20.     ws.close()
    
21. connect_node('你好')

复制代码

类似http接口，使用async时多用户调用websocket将排队获取结果。此时，程序去除async之后无法获取结果。使用1.2中多线程启动方式则可以实现多用户同时获得结果，程序基本一致，也可参考“https://download.csdn.net/download/suiyingy/87742178”的api_http_three_worker.py。

        另外，不同的python包所支持的工作方式不同。例如，websocket-server支持多用户同时调用websocket接口，安装方式为“pip install websocket-server”。运行程序时可能会出现错误提示“KeyError: 'upgrade'”，但这不影响结果获取。websocket-server ChatGLM相应程序见“https://download.csdn.net/download/suiyingy/87742178”的api_ws.py程序。

/ b4 q- V) q, q6 {* L' A* ~" A. U3 web_demo.py多用户并行

        Web_demo.py默认状态下多用户会排队访问，使用下面命令启动时可同时获取结果。concurrency_count表示最多可同时获取结果的用户数，即并发数。max_size表示排队的数量，即最多允许多少个用户处于排队状态。使用时只需将web_demo.py的最后一行替换成如下启动方式即可。Web_demo2.py采用streamlit实现，默认支持多用户同时访问。

1. demo.queue(
   
2.     concurrency_count=5,
   
3.     max_size=500).launch(share=False,
   
4.                 inbrowser=True,
   
5.                 server_name="0.0.0.0",
   
6.                 server_port=8000)

复制代码

# c3 W- `+ i% R' C

到此这篇关于ChatGPT平替- ChatGLM多用户并行访问部署的文章就介绍到这了。

' @/ p' R5 Z! D2 t9 ~8 w! ~" k: g

0 a4 _' `- W5 s+ K( A" N