​华盛顿大学提出全新量化和微调方法，在DB-GPT上享受33B参数的LLM

git clone https://github.com/artidoro/qlora.git

conda create -n qenv python-3.10
conda activate qenv
cd qlora
pip install -r requirements.txt

# 安装 bitsandbytes，transformers, accelerate， peft
pip install -q -U bitsandbytes
pip install -q -U git+https://github.com/huggingface/transformers.git
pip install -q -U git+https://github.com/huggingface/peft.git
pip install -q -U git+https://github.com/huggingface/accelerate.git

#这四个库的版本号应该为：
bitsandbytes 0.39.0
transformers 4.30.0.dev0
accelerate 0.20.0.dev0
peft 0.4.0.dev0

#若官方安装方法不成功可以试试手动安装：
#transformers
git clone https://github.com/huggingface/transformers.git
cd transformers
python -m pip install -e . -i https://mirror.baidu.com/pypi/simple

#bitsandbytes
git clone https://github.com/TimDettmers/bitsandbytes.git
cd bitsandbytes
# CUDA_VERSIONS in {110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 120}
# make argument in {cuda110, cuda11x, cuda12x}
# 看好自己的cuda版本, cuda11.8 对应 118和cuda11x . 
CUDA_VERSION=118 make cuda11x
python setup.py install

#peft
git clone https://github.com/huggingface/peft.git
cd peft && pip install -e . -i https://mirror.baidu.com/pypi/simple

#accelerate
git clone https://github.com/huggingface/accelerate.git
cd accelerate && pip install -e . -i https://mirror.baidu.com/pypi/simple

model = AutoModelForCausalLM.from_pretrained(
        model_name_or_path='/name/or/path/to/your/model',
        load_in_4bit=True, #设置为True才可以调用BitsAndBytesConfig
        device_map={"": 0},  #调用GPU，并使用accelerate加载模型
        max_memory=max_memory,
        torch_dtype=torch.bfloat16,
        quantization_config=BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.bfloat16, #计算时采用BF16最快，默认为FP32
            bnb_4bit_use_double_quant=True, #二次量化
            bnb_4bit_quant_type='nf4' #量化时使用nf4最优，也可以使用fp4
        )
    )


# 若想使用Paged Optimizer，则在qlora.py中调用 --optim paged_adamw_32bit

import torch
from peft import PeftModel    
from transformers import AutoModelForCausalLM, AutoTokenizer, LlamaTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer

model_name = "decapoda-research/llama-7b-hf"
adapters_name = 'timdettmers/guanaco-7b'

print(f"Starting to load the model {model_name} into memory")

m = AutoModelForCausalLM.from_pretrained(
    model_name,
    #load_in_4bit=True,
    torch_dtype=torch.bfloat16,
    device_map={"": 0}
)
m = PeftModel.from_pretrained(m, adapters_name)
m = m.merge_and_unload()
tok = LlamaTokenizer.from_pretrained(model_name)
tok.bos_token_id = 1

stop_token_ids = [0]

print(f"Successfully loaded the model {model_name} into memory")

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
sudo apt-get install git-lfs

#设置学术加速
source /etc/network_turbo
cd auto-tmp
# 下载项目代码
git clone https://github.com/csunny/DB-GPT.git

# 更新bashrc中的环境变量
conda init bash && source /root/.bashrc

#构建并激活conda环境
conda create -n dbgpt_env python=3.10 
conda activate dbgpt_env

#安装环境依赖，这里保险起见我加入了信任的镜像源下载
cd DB-GPT
pip install -r requirements.txt -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com

#若后续使用guanaco，还需安装QLoRA的bitsandbytes，transformers，accelerate，peft，安装方法在上面
#这四个库的版本号应该为：
bitsandbytes 0.39.0
transformers 4.30.0.dev0
accelerate 0.20.0.dev0
peft 0.4.0.dev0

#若想体验完整的DB-GPT项目，建议也下载vicuna-13b和all-MiniLM-L6-v2
git clone https://huggingface.co/Tribbiani/vicuna-13b 
git clone https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2

#guanaco-33b-merged是量化后可以直接使用的33b模型，如需使用其他量化模型，可自行选择合成或下载
git clone https://huggingface.co/timdettmers/guanaco-33b-merged

# 首先更新apt源
sudo apt update

#下载mysql-server
sudo apt install mysql-server

#查看mysql的状态，开启mysql
sudo service mysql status
sudo service mysql start

#进入mysql终端
sudo mysql

#设置root密码，注意这里的密码应该和DB-GPT中的.env文件保持一致
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'aa12345678';

#登录mysql，这里会提示输入密码，可以查看自己密码创建是否正确
mysql -u root -p

#切换分支
git checkout dev
#更新分支
git pull origin dev

# 运行命令启动服务端：
python pilot/server/llmserver.py 

cd autodl-tmp/DB-GPT
conda activate dbgpt_env

#由于AutoDL的实例无独立公网IP，因此不能任意开启额外的端口。但是AutoDL为每个实例都预留了一个可对外暴露的端口，技术实现为将实例中的6006端口映射到公网可供访问的ip:port上，而ip:port可在「自定义服务」入口获取，这里我们使用6006开启客户端
python pilot/server/webserver.py --port 6006

class GuanacoAdapter(BaseLLMAdaper):
    """TODO Support guanaco"""

    def match(self, model_path: str):
        return "guanaco" in model_path

    def loader(self, model_path: str, from_pretrained_kwargs: dict):
        tokenizer = LlamaTokenizer.from_pretrained(model_path)
        model = AutoModelForCausalLM.from_pretrained(
            model_path, load_in_4bit=True, device_map={"": 0}, **from_pretrained_kwargs
        )
        return model, tokenizer

import torch
import copy
from threading import Thread
from transformers import TextIteratorStreamer, StoppingCriteriaList, StoppingCriteria


def guanaco_generate_output(model, tokenizer, params, device, context_len=2048):


    print(params)
    stop = params.get("stop", "###")
    prompt = params["prompt"]
    query = prompt
    print("Query Message: ", query)

    input_ids = tokenizer(query, return_tensors="pt").input_ids
    input_ids = input_ids.to(model.device)

    streamer = TextIteratorStreamer(
        tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True
    )
    stop_token_ids = [0]

    class StopOnTokens(StoppingCriteria):
        def __call__(
            self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs
        ) -> bool:
            for stop_id in stop_token_ids:
                if input_ids[0][-1] == stop_id:
                    return True
            return False

    stop = StopOnTokens()

    generate_kwargs = dict(
        input_ids=input_ids,
        max_new_tokens=512,
        temperature=1.0,
        do_sample=True,
        top_k=1,
        streamer=streamer,
        repetition_penalty=1.7,
        stopping_criteria=StoppingCriteriaList([stop]),
    )

    t1 = Thread(target=model.generate, kwargs=generate_kwargs)
    t1.start()

    generator = model.generate(**generate_kwargs)
    for output in generator:
        # new_tokens = len(output) - len(input_ids[0])
        decoded_output = tokenizer.decode(output)
        if output[-1] in [tokenizer.eos_token_id]:
            break

        out = decoded_output.split("### Response:")[-1].strip()

        yield out