【多模态】MiniCPM-V多模态大模子使用学习

媒介

前面学习了一些常见多模态模子的架构，现在开始学习使用minicpm-v-2.6模子，记载学习过程，接待品评指正～
排行榜上数据供参考，测试下来qwen2-vl轻微好一点点，然后minivpm-v-2.6稍差一点点

1. 模子文件下载和选择

   在modelscope上下载，此中int4的模子推理显存占用7-9GB，效果和全量模子很接近。全量模子下载推理可能轻微慢一些，int4就够用了，而且int4的推理挺快的，平均不到0.5秒一张图，如果同时开4个进程就是一秒钟4张图左右。

1. #模型下载
2. from modelscope import snapshot_download
3. model_dir = snapshot_download('OpenBMB/MiniCPM-V-2_6-int4',cache_dir='要存放模型的路径')

复制代码

2. 环境安装配置

   有几个点需要注意的：

• 官方飞书文档里面说微调时deepspeed需要手动安装，不知道为什么手动下载源码的安装的跑不乐成，主动安装的pip install deepspeed最新的比如0.15.0，微调就不会报错
  
• swift的安装最好直接安装，不要从源代码安装，否则万一删除了源代码环境就无了，然后也不方便，直接pip install ‘ms-swift[llm]’ -U
  
• 如果要和qwen2-vl的环境通用，注意pip install transformers==4.46.1
  
• flash-attn可以先在官方github上下载whl文件，如果网速慢的话，一样平常直接pip install flash-attn就行
  
• 如果要使用vllm安装pip install vllm
  

3. 模子微调

微调有好几种选择：(1)qlora微调minicpm-v-int4；(2)lora微调minicpm-v；(3)lora微调minicpm-v-int4，然后量化为int4

• 测试下来(1)(2)(3)正确率的差距不大，可能有的情况下(2)比(3)好一点点
  
• 显卡试了RTX-8000和A100-40/80GB，还是A100比较好，RTX-8000跑大半天，A100半小时到一小时
  

3.1 qlora微调minicpm-v-int4

  qlora微调时需要把–tune_vision设置为false，同时–qlora设置为true
显存开销上，ds_config_zero2和batchsize=1的情况下，qlora大概30-40GB显存开销，如果显存够大用ds_config_zero2，否则用ds_config_zero3(训练速度变慢)。
  训练时如果出现data fetch error注意检查路径和数据json文件的格式，应该不会有其他什么问题。

1. #!/bin/bash
2. GPUS_PER_NODE=1 # 改成你的机器每个节点共有多少张显卡，如果是单机八卡就是8
3. NNODES=1 # 改成你的机器有多少个节点，如果就是一台服务器就是1
4. NODE_RANK=0 # 使用第几个服务器训练
5. MASTER_ADDR=localhost
6. MASTER_PORT=6001
8. MODEL="/root/ld/ld_model_pretrained/Minicpmv2_6" # 本地模型路径 or openbmb/MiniCPM-V-2.5
9. # ATTENTION: specify the path to your training data, which should be a json file consisting of a list of conversations.
10. # See the section for finetuning in README for more information.
11. DATA="/root/ld/ld_project/MiniCPM-V/finetune/mllm_demo.json" # 训练数据文件地址
12. LLM_TYPE="qwen2" # if use openbmb/MiniCPM-V-2, please set LLM_TYPE=minicpm
14. export NCCL_P2P_DISABLE=1 # a100等支持nccl_p2p的显卡去掉此行
15. export NCCL_IB_DISABLE=1 # a100等显卡去掉此行
17. DISTRIBUTED_ARGS="
18.     --nproc_per_node $GPUS_PER_NODE \
19.     --nnodes $NNODES \
20.     --node_rank $NODE_RANK \
21.     --master_addr $MASTER_ADDR \
22.     --master_port $MASTER_PORT
23. "
24. .conda/envs/yourenv/python -m torchrun $DISTRIBUTED_ARGS finetune.py  \
25.     --model_name_or_path $MODEL \
26.     --llm_type $LLM_TYPE \
27.     --data_path $DATA \
28.     --remove_unused_columns false \
29.     --label_names "labels" \ # 数据构造，不要动
30.     --prediction_loss_only false \
31.     --bf16 false \ # 使用bf16精度训练，4090，a100，h100等可以开启
32.     --bf16_full_eval false \ # 使用bf16精度测试
33.     --fp16 true \ # 使用fp16精度训练
34.     --fp16_full_eval true \ # 使用pf16精度测试
35.     --do_train \ # 是否训练
36.     --tune_vision true \ # 是否微调siglip(vit)模块
37.     --tune_llm false \ # 是否微调大语言模型模块
38.     --use_lora true \ # 是否lora微调
39.     --lora_target_modules "llm\..*layers\.\d+\.self_attn\.(q_proj|k_proj｜v_proj)" \ #lora插入的层，这里写的是正则表达式，建议不改
40.     --model_max_length 2048 \ # 模型训练的最大长度
41.     --max_slice_nums 9 \ # 模型最大切分次数
42.     --max_steps 1000 \ # 最多训练步数
43.     --output_dir output/output_minicpmv2_lora \ # 模型lora保存地址
44.     --logging_dir output/output_minicpmv2_lora \ # 日志保存地址
45.     --logging_strategy "steps" \ # 日志输出策略（可选epoch）
46.     --per_device_train_batch_size 2 \ # 每张卡训练的batch_size
47.     --gradient_accumulation_steps 1 \ # 梯度累积，当显存少时可以增大这个参数从而减少per_device_train_batch_size
48.     --save_strategy "steps" \ # 保存策略(可选epoch)与save_steps同时起作用
49.     --save_steps 1000 \ # 1000个step保存一次
50.     --save_total_limit 1 \ # 最大储存总数
51.     --learning_rate 1e-6 \ # 学习率
52.     --weight_decay 0.1 \ # 权重正则化参数
53.     --adam_beta2 0.95 \ #
54.     --warmup_ratio 0.01 \ # 总步数的预热率，即：总训练步数*warmup_ratio=预热步数
55.     --lr_scheduler_type "cosine" \ # 学习率调整器
56.     --logging_steps 10 \
57.     --gradient_checkpointing false \ # 梯度检查点，建议开启，极大减少显存使用
58.     --deepspeed ds_config_zero2.json \ # 使用zero3，显存充足建议使用ds_config_zero2.json

复制代码

3.2 lora微调minicpm-v

  显存开销上，ds_config_zero2和batchsize=1的情况下，lora大概77-79GB显存开销，如果显存够大用ds_config_zero2，否则用ds_config_zero3(训练速度变慢)
3.3 merge_lora

  使用官方飞书文档里面的copy之后，注意需要检查是否拷贝全了，通常会由于原始模子目次下面产生了asset等临时文件，会报错然后漏拷贝image_processing_minicpmv.py、preprocessor_config.json和processing_minicpmv.py。

• 注意，这里如果存的是bin而不是safetensor格式的文件，后面使用官方飞书文档里面的awq量化会报错，awq量化那里输入要求safetensor格式存储的模子
  

1. from peft import PeftModel
2. from transformers import AutoModel, AutoTokenizer
3. import os
4. import shutil
6. model_type = "原始minicpm-v模型地址"  # Local model path or huggingface id
7. path_to_adapter = "存放输出lora文件的地址"  # Path to the saved LoRA adapter
8. merge_path = "合并后模型地址"  # Path to save the merged model
10. # 保证原始模型的各个文件不遗漏保存到merge_path中
11. def copy_files_not_in_B(A_path, B_path):
12.     """
13.     Copies files from directory A to directory B if they exist in A but not in B.
15.     :param A_path: Path to the source directory (A).
16.     :param B_path: Path to the destination directory (B).
17.     """
18.     # 保证路径存在
19.     if not os.path.exists(A_path):
20.         raise FileNotFoundError(f"The directory {A_path} does not exist.")
21.     if not os.path.exists(B_path):
22.         os.makedirs(B_path)
24.     # 获取路径A中所有非权重文件
25.     files_in_A = os.listdir(A_path)
26.     files_in_A = set([file for file in files_in_A if not (".bin" in file or "safetensors" in file)])
27.     # List all files in directory B
28.     files_in_B = set(os.listdir(B_path))
30.     # 找到所有A中存在但B中不存在的文件
31.     files_to_copy = files_in_A - files_in_B
33.     # 将这些文件复制到B路径下
34.     for file in files_to_copy:
35.         if os.path.isfile(file):
36.             src_file = os.path.join(A_path, file)
37.             dst_file = os.path.join(B_path, file)
38.             shutil.copy2(src_file, dst_file)
40. # 加载原始模型
41. model = AutoModel.from_pretrained(
42.     model_type,
43.     trust_remote_code=True
44. )
46. # 加载lora模块到原始模型中
47. lora_model = PeftModel.from_pretrained(
48.     model,
49.     path_to_adapter,
50.     device_map="auto",
51.     trust_remote_code=True
52. ).eval()
54. # 将加载的lora模块合并到原始模型中
55. merge_model = lora_model.merge_and_unload()
57. # 将新合并的模型进行保存
58. merge_model.save_pretrained(merge_path, safe_serialization=True)
60. # 加载分词器
61. tokenizer = AutoTokenizer.from_pretrained(model_type, trust_remote_code=True)
62. tokenizer.save_pretrained(merge_path)
64. copy_files_not_in_B(model_type,merge_path)

复制代码

3.4 lora微调后量化int4

• 这里的注意点和merge_lora一样，如果使用bnb量化，按照官方飞书文档，量化完了之后记得确认文件是否都在，否则拷贝即可
  
• awq量化，最好重新conda create一个新的环境专门装这个，而且保证模子是safetensor格式存储即可进行awq量化，awq环境需要使用官方飞书文档里面先容的环境
  

1. from datasets import load_dataset
2. from awq import AutoAWQForCausalLM
3. from transformers import AutoTokenizer
4. import os
5. import shutil
6. model_path = 'minicpm-v-2_6路径'
7. quant_path = '存储量化模型路径'
8. quant_config = { "zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM"}
10. # Load model
11. model = AutoAWQForCausalLM.from_pretrained(model_path,trust_remote_code=True,device_map='cuda')
12. tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True,device_map='cuda')
14. def copy_files_not_in_B(A_path, B_path):
15.     """
16.     Copies files from directory A to directory B if they exist in A but not in B.
18.     :param A_path: Path to the source directory (A).
19.     :param B_path: Path to the destination directory (B).
20.     """
21.     # 保证路径存在
22.     if not os.path.exists(A_path):
23.         raise FileNotFoundError(f"The directory {A_path} does not exist.")
24.     if not os.path.exists(B_path):
25.         os.makedirs(B_path)
27.     # 获取路径A中所有非权重文件
28.     files_in_A = os.listdir(A_path)
29.     files_in_A = set([file for file in files_in_A if not (".bin" in file or "safetensors" in file )])
30.     # List all files in directory B
31.     files_in_B = set(os.listdir(B_path))
33.     # 找到所有A中存在但B中不存在的文件
34.     files_to_copy = files_in_A - files_in_B
36.     # 将这些文件复制到B路径下
37.     for file in files_to_copy:
38.         src_file = os.path.join(A_path, file)
39.         dst_file = os.path.join(B_path, file)
40.         shutil.copy2(src_file, dst_file)
41. # Define data loading methods
42. def load_alpaca():
43.     #data = load_dataset('/root/ld/pull_request/MiniCPM/quantize/quantize_data/alpaca', split="train")
44.     data = load_dataset('tatsu-lab/alpaca', split="train")
45.     # concatenate data
46.     def concatenate_data(x):
47.         msgs=[{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": x['input']},{"role": "system", "content": x['output']}]
48.         data=tokenizer.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
49.         return {"text": data}
50.    
51.     concatenated = data.map(concatenate_data)
52.     return [text for text in concatenated["text"]][:1000]
54. def load_wikitext():
55.     data = load_dataset('wikitext', 'wikitext-2-raw-v1', split="train")
56.     return [text for text in data["text"] if text.strip() != '' and len(text.split(' ')) > 20]
58. # Quantize
59. model.quantize(tokenizer, quant_config=quant_config, calib_data=load_alpaca())
61. # Save quantized model
62. model.save_quantized(quant_path)
63. tokenizer.save_pretrained(quant_path)
65. print(f'Model is quantized and saved at "{quant_path}"')
67. copy_files_not_in_B(model_path,quant_path)

复制代码

4. 模子推理

4.1 huggingface API

• huggingface的方式进行batch inference时，需要找到模子的modeling_minicpmv.py文件，定位里面的chat()函数，把if batched is False后面else那部分注释掉，int4的A100-80GB可以把batch size开到26
  

1.     def chat(
2.         self,
3.         image,
4.         msgs,
5.         tokenizer,
6.         processor=None,
7.         vision_hidden_states=None,
8.         max_new_tokens=2048,
9.         min_new_tokens=0,
10.         sampling=True,
11.         max_inp_length=8192,
12.         system_prompt='',
13.         stream=False,
14.         max_slice_nums=None,
15.         use_image_id=None,
16.         **kwargs
17.     ):
18.         if isinstance(msgs[0], list):
19.             batched = True
20.         else:
21.             batched = False
22.         msgs_list = msgs
23.         images_list = image
24.         
25.         if batched is False:
26.             images_list, msgs_list = [images_list], [msgs_list]
27.         #else:
28.         #    assert images_list is None, "Please integrate image to msgs when using batch inference."
29.        #     images_list = [None] * len(msgs_list)
30.        # assert len(images_list) == len(msgs_list), "The batch dim of images_list and msgs_list should be the same."
32.         if processor is None:
33.             if self.processor is None:
34.                 self.processor = AutoProcessor.from_pretrained(self.config._name_or_path, trust_remote_code=True)
35.             processor = self.processor

复制代码

推理时，使用如下代码：

1. prompt = 'What can you see in the image?'
2. msgs = [{'role': 'user', 'content': prompt}]
4. img1 = Image.open('AAA.jpg')
5. img2 = Image.open('BBB.jpg')
6. images_input_list.append(img1)
7. images_input_list.append(img2)
8. prompt_input_list.append(msgs)
9. prompt_input_list.append(msgs)
11. # batch inference
12. with torch.inference_mode():
13.     res = model.chat(images_input_list,msgs=prompt_input_list,tokenizer=tokenizer,sampling=False,max_new_tokens=30)

复制代码

• 可以使用flash-attention加速，只需要网络良好的情况下，pip install flash-attn，然后加载模子时，指定attn_implementation=‘flash_attention_2’
  

1. model = AutoModel.from_pretrained('/', trust_remote_code=True,attn_implementation='flash_attention_2')

复制代码

4.2 swift API

(A) swift（不支持batch inference）

1. import os
2. os.environ['CUDA_VISIBLE_DEVICES'] = '0'
3. os.environ['MAX_SLICE_NUMS'] = '9'
4. from swift.llm import (
5.     get_model_tokenizer, get_template, inference, ModelType,
6.     get_default_template_type, inference_stream
7. )
8. from swift.utils import seed_everything
9. import torch
11. model_type = ModelType.minicpm_v_v2_6_chat
12. template_type = get_default_template_type(model_type)
13. print(f'template_type: {template_type}')
15. model_id_or_path = '模型地址'
16. model, tokenizer = get_model_tokenizer(model_type, torch.bfloat16,model_id_or_path=model_id_or_path,
17.                                        model_kwargs={'device_map': 'auto'})
18. model.generation_config.max_new_tokens = 256
19. template = get_template(template_type, tokenizer)
20. seed_everything(42)
21. model.generation_config.do_sample = False
22. query = """<img>要推理的图片存储地址</img>"""
23. prompt=" What can you see in this image?"
25. query = query+prompt
26. response, history = inference(model, template, query)
27. print(f'query: {query}')
28. print(f'response: {response}')

复制代码

minicpm-v-awq-int4的，不能使用swift的vllm推理，可以使用原始的VLLM推理，不外速度上差异倒不是特别大
(B) swift的VLLM

1. # swift的infer
2. import os
3. os.environ['CUDA_VISIBLE_DEVICES'] = '0'
4. os.environ['TENSOR_PARALLEL_SIZE'] = '1'
5. from swift.llm import (
6.     ModelType, get_vllm_engine, get_default_template_type,
7.     get_template, inference_vllm, inference_stream_vllm
8. )
9. from swift.utils import seed_everything
10. import torch
11. model_type = ModelType.minicpm_v_v2_6_chat
12. model_id_or_path = '模型路径'
13. llm_engine = get_vllm_engine(model_type, model_id_or_path=model_id_or_path)
14. template_type = get_default_template_type(model_type)
15. template = get_template(template_type, llm_engine.hf_tokenizer)
16. generation_info = {}
18. query1 = """<img>图片路径1</img>"""
19. query2 = """<img>图片路径2</img>"""
21. query1 = '.......'
22. query2 = '.......'
23. request_list = [{'query':query1},{'query':query2}]
25. resp_list = inference_vllm(llm_engine, template, request_list, generation_info=generation_info)
26. for request, resp in zip(request_list, resp_list):
27.     print(f"query: {request['query']}")
28.     print(f"response: {resp['response']}")
29. print(generation_info)

复制代码

4.3 VLLM

(A) 单个推理

1. from PIL import Image
2. from transformers import AutoTokenizer
3. from vllm import LLM, SamplingParams
5. # 图像文件路径列表
6. IMAGES = [
7.     "图片路径",  # 本地图片路径
8. ]
10. # 改成你量化后的awq路径/ 原始minicpm-v的路径
11. # awq模型路径
12. MODEL_NAME = '模型路径'
13. # 打开并转换图像
14. image = Image.open(IMAGES[0]).convert("RGB")
16. # 初始化分词器
17. tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
19. # 初始化语言模型
20. llm = LLM(model=MODEL_NAME,
21.            gpu_memory_utilization=0.5,  # 1表示使用全部GPU内存，如果希望gpu占用率降低，就减少gpu_memory_utilization
22.            trust_remote_code=True,
23.            max_model_len=2048)  # 根据内存状况可调整此值
24. # 构建对话消息
25. messages = [{'role': 'user', 'content': '(<image>./</image>)\n' + '请描述这张图片'}]
27. # 应用对话模板到消息
28. prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
30. # 设置停止符ID
31. # 2.0
32. # stop_token_ids = [tokenizer.eos_id]
33. # 2.5
34. #stop_token_ids = [tokenizer.eos_id, tokenizer.eot_id]
35. # 2.6
36. stop_tokens = ['<|im_end|>', '<|endoftext|>']
37. stop_token_ids = [tokenizer.convert_tokens_to_ids(i) for i in stop_tokens]
39. # 设置生成参数
40. sampling_params = SamplingParams(
41.     stop_token_ids=stop_token_ids,
42.     # temperature=0.7,
43.     # top_p=0.8,
44.     # top_k=100,
45.     # seed=3472,
46.     max_tokens=1024,
47.     # min_tokens=150,
48.     temperature=0,
49.     use_beam_search=True,
50.     # length_penalty=1.2,
51.     best_of=3)
53. # 获取模型输出
54. outputs = llm.generate({
55.     "prompt": prompt,
56.     "multi_modal_data": {
57.         "image": img1_path
58.     }
59. }, sampling_params=sampling_params)
60. print(outputs[0].outputs[0].text)

复制代码

(B) batch inference

1. from PIL import Image
2. from transformers import AutoTokenizer
3. from vllm import LLM, SamplingParams
5. # 所有待输入的图像
6. IMAGES = [
7.     "图片地址1",
8.     "图片地址2"
9. ]
11. # MODEL_NAME = "HwwwH/MiniCPM-V-2" # If you use the local MiniCPM-V-2 model, please update the model code from HwwwH/MiniCPM-V-2
12. # If using a local model, please update the model code to the latest
13. MODEL_NAME = '模型路径'
14. images = [Image.open(i).convert("RGB") for i in IMAGES]
16. tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
17. llm = LLM(model=MODEL_NAME,
18.           gpu_memory_utilization=1,
19.           trust_remote_code=True,
20.           max_model_len=1024)
21. prompt = 'What can you see in this image?'
22. messages = [{'role': 'user', 'content': '(<image>./</image>)\n' + prompt}]
23. prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
24. # Construct multiple inputs. This example shares prompt, or you don’t need to share prompt.
25. inputs=[{"prompt": prompt,"multi_modal_data": {"image": i }} for i in images]
26. # 2.0
27. # stop_token_ids = [tokenizer.eos_id]
28. # 2.5
29. #stop_token_ids = [tokenizer.eos_id, tokenizer.eot_id]
30. # 2.6
31. stop_tokens = ['<|im_end|>', '<|endoftext|>']
32. stop_token_ids = [tokenizer.convert_tokens_to_ids(i) for i in stop_tokens]
34. sampling_params = SamplingParams(
35.     stop_token_ids=stop_token_ids,
36.     # temperature=0.7,
37.     # top_p=0.8,
38.     # top_k=100,
39.     # seed=3472,
40.     max_tokens=200,
41.     # min_tokens=150,
42.     temperature=0,
43.     use_beam_search=True,
44.     # length_penalty=1.2,
45.     best_of=3)
47. outputs = llm.generate(inputs, sampling_params=sampling_params)
48. for i in range(len(inputs)):
49.     print(outputs[i].outputs[0].text)

复制代码

5. 参考链接

• minicpm-v的官方飞书文档，真的学到了许多，群里面有问题回复也超及时，感谢官方和社区分享：https://modelbest.feishu.cn/wiki/SgGpwVz4aiSDwNkVMrmcMpHsnAF
  
• swift的官方文档：https://swift.readthedocs.io/en/stable/index.html
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。