公有云小白的大模型实践-ChatGLM on PAI

# 下载最新版本的miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
# 安装 一路回车即可
sh Miniconda3-latest-Linux-x86_64.sh
# 初始化conda环境，会自动配置PATH保证不同环境激活的是专用的py环境
conda init
# 重启kernel
exit
# 查看虚拟环境列表
conda env list
# 创建 glm6b专用的虚拟环境
conda create -n glm6b python=3.9
# 激活 glm6b的环境
conda activate glm6b

# 通过ipykernel将环境注册到jupyter中
conda install -n glm6b ipykernel
# 或 pip install ipykernel
# 注册当前环境
python -m ipykernel install --user --name glm6b --display-name "glm6b"
#验证
import sys; print('Python %s on %s\nsys path:\n%s' % (sys.version, sys.platform, sys.path))

# 通过git下载项目代码和模型文件
# 更新apt-get库
sudo apt-get update
# 下载git 以及较大模型文件所依赖的 git-lfs
sudo apt-get install git
sudo apt-get install git-lfs
# 初始化
git init
git lfs install
mkdir glm
# 下载项目代码
git clone https://github.com/THUDM/ChatGLM-6B
# 安装项目依赖
python -m pip install -r requirements.txt
mkdir models
# 下载模型文件
git clone https://huggingface.co/THUDM/chatglm-6b
# 模型文件比较大,20G,可以用下面这个看下下载速度
sudo apt-get install bwm-ng
bwm-ng

# 官网样例
import os
import torch
from transformers import AutoTokenizer, AutoModel
model_path = "/mnt/workspace/glm/models/chatglm-6b"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModel.from_pretrained(model_path, trust_remote_code=True).half().cuda()
response, history = model.chat(tokenizer, "你好", history=[])
print(response)

# 更改一下脚本里面的模型加载路径，改为从本地加载（上面通过git在huggingface上已经做了下载），hugging face有时候网络环境不太好
python web_demo.py
# Running on local URL:  http://127.0.0.1:7860
# 直接点击日志弹出的url，dsw会自动进行公网代理的跳转，很丝滑

cd /mnt/workspace/glm/ChatGLM-6B/ptuning
# 看一下官网给的训练脚本
vim tran.sh
# 里面需要根据自己的场景，更改或者重新设定下如下参数
# sequence长度（PRE_SEQ_LEN）
# 学习率（LR）
# GPU（CUDA_VISIBLE_DEVICES）
# 训练集（tran_file）
# 验证集（validation_file）
# prompt字段（prompt_column）
# 返回字段（response_column）
# 模型名称或者文件路径（model_name_or_path）
# 输出文件目录（output_dir）
# 量化位（quantization_bit）

# fine-tune数据集下载
wget -O AdvertiseGen.tar.gz https://cloud.tsinghua.edu.cn/f/b3f119a008264b1cabd1/?dl=1
# 解压
tar -xzvf AdvertiseGen.tar.gz
# 训练数据

sh dsw.sh /mnt/workspace > ./dsw/log.out.20230615 &
# 可以看到训练日志中 有加载模型，打印训练超参数，打印样例数据，训练的loss，学习率和epoch的进度
# ↓训练输出的文档中会包含每次的cp，这个和flink的sp或者cp是一致的，异常failover后可以从这里恢复，不用再从头开训

# 导入相关模块
import os
import torch
from transformers import AutoConfig, AutoModel, AutoTokenizer
# 导入原始模型
model_path = "/mnt/workspace/glm/models/chatglm-6b"
# 导入tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
# 添加prefix层的config
config = AutoConfig.from_pretrained(model_path, trust_remote_code=True, pre_seq_len=128)
# 加载原始模型
model = AutoModel.from_pretrained(model_path, config=config, trust_remote_code=True)
# 加载checkpoint的训练结果
prefix_state_dict = torch.load(os.path.join("/mnt/workspace/model/ChatGLM-6B/ptuning/output/adgen-chatglm-6b-pt-128-2e-2/checkpoint-3000", "pytorch_model.bin"))
# 导入prefix encoder
new_prefix_state_dict = {}
for k, v in prefix_state_dict.items():
    new_prefix_state_dict[k[len("transformer.prefix_encoder."):]] = v
model.transformer.prefix_encoder.load_state_dict(new_prefix_state_dict)

# client demo入口代码
cli_demo.py
# 初始化基于本地文件做QA的主类，包含了llm，embedding等
- local_doc_qa = LocalDocQA()
# 初始化向量库
- local_doc_qa.init_knowledge_vector_store(filepath)
## 通过上传的本地知识库地址加载知识，支持 .md .txt .pdf .jps .png以及非结构化的知识文档，详见图1
-- load_file(filepath, sentence_size)
# 调用方法根据知识库，生成回答
- local_doc_qa.get_knowledge_based_answer()
## 加载存储的向量库
-- load_vector_store(vs_path, self.embeddings)
## 得到和问题最相似的topk个知识内容
-- related_docs_with_score = vector_store.similarity_search_with_score(query, k=self.top_k)
## 判断知识库中内容是否有被检索出来
-- if len(related_docs_with_score)>0:
### 根据相关联的知识库和问题生成promt，详见图2
--- true: promt = generate_prompt(related_docs_with_score, query)
#### 根据预设的promt将知识内容和问题组合，详见图3，图4
---- PROMPT_TEMPLATE.replace("{question}", query).replace("{context}", context)
### 知识库中没有内容，直接将问题输入大模型
--- false: promt = query
## 输入到大模型进行回答的生成
--  self.llm.generatorAnswer(prompt)

# 初始化ak
./eascmd64 config -i <access_id> -k <access_key>
# 查看当前endpoint 下ak对应的eas服务的list
./eascmd list

# 初始化环境。
# 输入Python版本（默认为3.6版本），系统会自动创建Python环境ENV目录、预测服务代码模板app.py及服务部署模板app.json。
./eascmd pysdk init ./pysdk_demo
# 打包
eascmd pysdk pack ./demo
# 或者 手动打成zip或者tar.gz的包
tar -zxvf pysdk_demo.tar.gz ./pysdk_demo

# -*- coding: utf-8 -*-
import allspark
from transformers import AutoTokenizer, AutoModel
import json
class MyProcessor(allspark.BaseProcessor):
    """ MyProcessor is a example
        you can send message like this to predict
        curl -v http://127.0.0.1:8080/api/predict/service_name -d '2 105'
    """
    def initialize(self):
        """ load module, executed once at the start of the service
         do service initialization and load models in this function.
        """
        # 非量化后的模型
        self.model_path = "/mnt/data/glm/models/chatglm-6b"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
        self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True).half().cuda()
        self.model.eval()
        print('model init done')
    def pre_process(self, data):
        """ data format pre process
        {
          "id": "1662",
          "query": "FLINK是什么",
          "history": []
        }
        """
        pre = json.loads(data.decode(encoding='utf-8'))
        print(f'row data: {pre}')
        return pre
    def post_process(self, state: str, id: str, res: str, history: list):
        """ process after process
        """
        init = {'id': id,
                'state': state,
                'response': res,
                'history': history
                }
        res = json.dumps(init, ensure_ascii=False)
        print(f'return data: {res}')
        return bytes(res, encoding='utf8')
    def process(self, data):
        """ process the request data
        """
        try:
            data = self.pre_process(data)
            res, history = self.model.chat(self.tokenizer, data.get('query'), history=data.get('history'))
            return self.post_process("SUCCESS", data.get('id'), res, history), 200
        except Exception as e:
            return self.post_process("FAILED", data.get('id'), None, None), 400
if __name__ == '__main__':
    # parameter worker_threads indicates concurrency of processing
    runner = MyProcessor(worker_threads=10)
    runner.run()

# 更改 app.json中的服务名称 和oss地址
eascmd create app.json

# 简单测试
curl http://****.vpc.cn-beijing.pai-eas.aliyuncs.com/api/predict/pysdk_demo -H 'Authorization: **' -d 'hello eas'

FROM ubuntu:22.04
LABEL maintainer="***"
RUN chsh -s /bin/bash
SHELL ["/bin/bash", "-c"]
RUN mkdir -p /root/data
RUN mkdir -p /root/opt
RUN mkdir -p /root/service
COPY s.txt /root/data/
COPY requirements.txt /root/service/
COPY tornado_test02.py /root/service/
RUN apt-get update && \
apt-get install -y curl
RUN curl "https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh" -o /root/opt/miniconda.sh && \
/bin/bash /root/opt/miniconda.sh -b -p /root/miniconda && \
ln -s /root/miniconda/etc/profile.d/conda.sh /etc/profile.d/conda.sh && \
echo ". /root/miniconda/etc/profile.d/conda.sh" >> ~/.bashrc
ENV PATH /root/miniconda/bin:/root/miniconda/condabin:$PATH
RUN conda create -n glm python=3.10 -y
RUN echo "conda activate glm" >> ~/.bashrc
ENV PATH /root/miniconda/envs/glm/bin:$PATH
RUN python -m pip install -r /root/service/requirements.txt

# 构建镜像
# ENTRYPOINT ["python" ,"/root/service/tornado_test02.py"]
docker build -t **:1.0 .
# 查看本地镜像
docker image ls -a
# 登录acr镜像库
docker login --username=***@**.cn-beijing.aliyuncs.com
# tag
docker tag [ImageId] registry.cn-beijing.aliyuncs.com/**/**:[镜像版本号]
# push
docker push registry.cn-beijing.aliyuncs.com/**/**:[镜像版本号]

import tornado.ioloop
import tornado.web
class PostMethodHandler(tornado.web.RequestHandler):
    def post(self):
        data = self.request.body
        print(data)
        # do something with the data
        self.write("Data received successfully!")
if __name__ == "__main__":
    app = tornado.web.Application([
        (r"/post-method", PostMethodHandler),
    ])
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

{
    "cloud": {
        "computing": {
            "instance_type": "ecs.gn6i-c8g1.2xlarge"
        },
        "networking": {
            "security_group_id": "sg-2zefgh******tc3",
            "vpc_id": "vpc-2ze8******5fby1av",
            "vswitch_id": "vsw-2ze******aw56hdi"
        }
    },
    "metadata": {
        "cpu": 8,
        "gpu": 1,
        "instance": 1,
        "memory": 31000,
        "name": "****m_test02"
    },
    "processor_entry": "pai_eas_glm.py",
    "processor_path": "o**://**/***/pysdk_demo.tar.gz",
    "processor_type": "python",
    "storage": [
        {
            "mount_path": "/mnt/data/",
            "nfs": {
                "path": "/",
                "server": "***rn23.cn-beijing.nas.aliyuncs.com"
            },
            "properties": {
                "resource_type": "code"
            }
        }
    ]
} 

import base64
req = """{
          "id": "1662",
          "query": "你好",
          "history": []
        }"""
# 64编码
print(base64.b64encode(req.encode('utf-8')))
# b'ewogICAgICAgICAgImlkIjo***ICAiaGlzdG9yeSI6IFtdCiAgICAgICAgfQ=='
# 这里复制上去压测的时候不要把b\'\'带上

eascmd modify <service_name> -s <service_desc_json>