大模型能力对外提供服务

我们在上一篇介绍了如何在本地部署大模型。大模型有了，下一步，很自然的就会想到怎么让模型对外提供服务。毕竟只有用户使用了产品、解决了问题，产品才有价值。

文章目录

1、编程方式和大模型交互
2、使用FastAPI开发大模型web端
- 2.1、数据实体
- 2.2、服务层
- 2.3、控制层
- 2.4、启动类
- 2.5、测试类
3、java开发中间层
4、参考资料

1、编程方式和大模型交互

这里直接参考了hugging face上的代码示例。
可以自己先验证一下下面的示例代码在你机器上是否可用。

from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("模型路径", trust_remote_code=True)
model = AutoModel.from_pretrained("模型路径", trust_remote_code=True).half().cuda()
model = model.eval()
response, history = model.chat(tokenizer, "你好", history=[])
print(response)

2、使用FastAPI开发大模型web端

示例代码如果跑通了，下面其实就是搭建大模型web端，将能力暴露出去。这里我们使用FastAPI，一个Python的web端高性能框架来搭建web端。
先看一下web端的代码层级

project_name/
│
├── controller/
│   ├── chat_controller.py       # web控制器
│
├── services/                    # 服务层目录
│   ├── chat_service.py          # 聊天服务相关实现
│
├── schemas/                     
│   ├── chat_schema.py           # 数据实体.类似java中的entity
│
├── tests/                
│   ├── test_chat_controller.py  # 测试web控制器脚本

2.1、数据实体

数据实体就是chat_schema.py文件

#pydantic可以理解成java的validation数据校验组件
from pydantic import BaseModel, Field
from typing import Optional, List

#类只要继承了BaseModel，就相当于拥有了数据校验的能力。
#类似于validation校验框架的@NotEmpty、@NotBlank注解，如果写过java，应该了解这个
class Message(BaseModel):
    role: str
    content: str

class ChatMessage(BaseModel):
    prompt: str    
    max_tokens: int    
    temperature: float    
    top_p: float = Field(default=1.0)

2.2、服务层

服务层，就是java中的service层，主要就是和大模型进行交互。
在这里是chat_service.py文件

import datetime
import model_manager
from schemas.chat_schema import ChatMessage
class ChatService:
    def post_message(self, message: ChatMessage):
        model = model_manager.ModelManager.get_model()
        tokenizer = model_manager.ModelManager.get_tokenizer()
        #我们这里使用的是chat方法,chat方法是一次性输出推理结果,这个方法的弊端是如果推理时间长,用户要等很久,体验不好。除了chat方法，还可以使用stream_chat方法，类似于一个字一个字往外输出的效果，避免用户长时间等待
        response = model.chat( 
                tokenizer,            
                message.prompt,            
                history=[],
                max_length=message.max_tokens,
                top_p=message.top_p,
                temperature=message.temperature
        )
        # 获取当前时间
        now = datetime.datetime.now()
        # 格式化时间为字符串
        time = now.strftime("%Y-%m-%d %H:%M:%S")
        answer = {            
                "response": response,            
                "status": 200,            
                "time": time        
                }
        log = "[" + time + "] " + '", prompt:"' + message.prompt + '", response:"' + repr(response) + '"'
        print(log)
        return answer
    def get_messages(self):
        return {"message": "get message"}

2.3、控制层

这里就引入了fastapi框架

from fastapi import APIRouter

from schemas.chat_schema import ChatMessage
from services.chat_service import ChatService

#定义一个API转发器。作用：对API进行路由
chat_router = APIRouter()
#这个就类似于spring框架的@Autowired注解,在controller中注入了一个chat_service服务
chat_service = ChatService()

#发布一个post方法
@chat_router.post("/new/message/")
def post_message(message: ChatMessage):
    print("进入post方法")
    return chat_service.post_message(message)

#发布一个get方法
@chat_router.get("/get/messages/")
def get_messages():
    return chat_service.get_messages()

2.4、启动类

#uvicorn用来发布web服务。类似于tomcat服务器
import uvicorn
from fastapi import FastAPI
from controller.chat_controller import chat_router as chat_router

app = FastAPI()
#对请求进行路由,将前缀为/chat的请求路由到chat_router服务
app.include_router(chat_router, prefix="/chat", tags=["chat"])

#类似于java中的main方法
if __name__ == "__main__":
	#启动web服务
    uvicorn.run(app, host="0.0.0.0", port=6006, log_level="info", workers=1)

2.5、测试类

import json
import requests

url1 = "http://127.0.0.1:6006/chat/new/message/"
data = {
    "history":[
        {
            "role":"user",
            "content":"北京今天的天气怎么样"
        }
    ],
    "prompt":"只回答温度和风力",
    "max_tokens":12000,
    "temperature":0.5
}



response1 = requests.post(url1, data=json.dumps(data))
print(response1.text)

url2 = "http://127.0.0.1:6006/chat/get/messages/"
response2 = requests.get(url2)
print(response2.text)

3、java开发中间层

java中间层的作用是：调用大模型web端，获取推理结果，展示给用户。

为什么需要有这样一个java中间层呢？其他语言写这个中间层可以吗？
我们现在做的只是一个demo版本，真正上线使用的话，要考虑很多东西。比如：限流、熔断、降级等等。保护大模型服务
在web方面，java发展了20多年的时间，有非常厚的沉淀和非常好的生态，所以用java开发web比较合适，用其他语言来写这个中间层也可以，但是没有java语言好，这是利用了java语言的长处。

调用大模型获取推理结果，我们可以考虑以下两种方式
一次性获取推理结果
引入Hutool

    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.6.5</version>
    </dependency>

@PostMapping(value = "/sendMessageHutool")
    public void sendMessageHutool(@RequestBody ChatRequest request, HttpServletResponse response) {
        try {
            log.info("参数为:{}",JSONObject.toJSONString(request));
            String channelResponse = HttpRequest.post(URL)
                    .body(JSONObject.toJSONString(request)).execute().body();
            log.info("channelResponse的值:{}",channelResponse);
        } catch (Exception e) {
            log.error("流式调用异常", e);
        }
    }

流式获取推理结果
使用okhttp3。okhttp3提供了流式获取大模型结果的API。依赖如下：

//引入okttp3的依赖
<dependency>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>okhttp-sse</artifactId>
      <version>5.0.0-alpha.14</version>
    </dependency>
//引入kotlin依赖
<dependency>
      <groupId>org.jetbrains.kotlin</groupId>
      <artifactId>kotlin-stdlib</artifactId>
      <version>2.0.0</version>
    </dependency>

极客时间的专栏课上提供了demo示例，大家可以根据这个思路试一试


@ApiOperation(value = "流式发送对话消息")
@PostMapping(value = "sendMessage")
public void sendMessage(@RequestBody ChatRequest request, HttpServletResponse response) {
  try {
    JSONObject body = new JSONObject();
    body.put("model", request.getModel());
    body.put("stream", true);
    JSONArray messages = new JSONArray();
    JSONObject query = new JSONObject();
    query.put("role", "user");
    query.put("content", request.getQuery());
    messages.add(query);
    body.put("messages", messages);
    EsListener eventSourceListener = new EsListener(request, response);

    RequestBody formBody = RequestBody.create(body, MediaType.parse("application/json"));
    Request.Builder requestBuilder = new Request.Builder();

    Request request2 = requestBuilder.url(URL).post(formBody).build();
    EventSource.Factory factory = EventSources.createFactory(OkHttpUtil.getInstance());

    factory.newEventSource(request2, eventSourceListener);
    eventSourceListener.getCountDownLatch().await();
  } catch (Exception e) {
    log.error("流式调用异常", e);
  }
}

//EsListener继承了EventSourceListener类，重写了其中的onEvent方法,onEvent不断地接收大模型的推理结果，写回到前端
@Override
public void onEvent(EventSource eventSource, String id, String type, String data) {
  try {
    output.append(data);
    if ("finish".equals(type)) {
    }
    if ("error".equals(type)) {
    }

    // 开始处理data，此处只展示基本操作
    // 开发过程中具体逻辑可自行扩展
    if (response != null) {
      response.getWriter().write(data);
      response.getWriter().flush();
    }
  } catch (Exception e) {
    log.error("事件处理异常", e);
  }
}