Add files using upload-large-folder tool

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/eval_scripts/run_all_diff_region.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# run_all_diff_region: grounding_diff_region.py
+# Oversized models (32B/34B/27B-IT) are pushed to the very end, after every
+# normal-size model has finished, so a stuck/OOM large model never blocks them.
+export CUDA_VISIBLE_DEVICES=0
+cd "$(dirname "$0")/.."
+
+echo "=== [qianwen] Qwen25VL_7B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_region/diff_region_COCO_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_7B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_region/diff_region_VGMED_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_3B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_region/diff_region_COCO_Qwen25VL_3B.sh
+echo "=== [qianwen] Qwen25VL_3B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_region/diff_region_VGMED_Qwen25VL_3B.sh
+echo "=== [llava-natural] LLaVA_7B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_region/diff_region_COCO_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_7B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_region/diff_region_VGMED_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_13B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_region/diff_region_COCO_LLaVA_13B.sh
+echo "=== [llava-natural] LLaVA_13B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_region/diff_region_VGMED_LLaVA_13B.sh
+echo "=== [llava-med] LLaVA_Med_7B COCO ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/diff_region/diff_region_COCO_LLaVA_Med_7B.sh
+echo "=== [llava-med] LLaVA_Med_7B VGMED ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/diff_region/diff_region_VGMED_LLaVA_Med_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_region/diff_region_COCO_HuatuoGPT_V_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_region/diff_region_VGMED_HuatuoGPT_V_7B.sh
+echo "=== [gemma] MedGemma_4B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_region/diff_region_COCO_MedGemma_4B_IT.sh
+echo "=== [gemma] MedGemma_4B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_region/diff_region_VGMED_MedGemma_4B_IT.sh
+
+# ── Oversized models (run last; failures here don't block anything above) ──
+echo "=== [qianwen] Qwen25VL_32B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_region/diff_region_COCO_Qwen25VL_32B.sh
+echo "=== [qianwen] Qwen25VL_32B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_region/diff_region_VGMED_Qwen25VL_32B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_region/diff_region_COCO_HuatuoGPT_V_34B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_region/diff_region_VGMED_HuatuoGPT_V_34B.sh
+echo "=== [gemma] MedGemma_27B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_region/diff_region_COCO_MedGemma_27B_IT.sh
+echo "=== [gemma] MedGemma_27B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_region/diff_region_VGMED_MedGemma_27B_IT.sh
+
+echo "All diff_region jobs finished."

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/eval_scripts/run_all_diff_text.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# run_all_diff_text: grounding_diff_text.py
+# Oversized models (32B/34B/27B-IT) are pushed to the very end, after every
+# normal-size model has finished, so a stuck/OOM large model never blocks them.
+export CUDA_VISIBLE_DEVICES=0
+cd "$(dirname "$0")/.."
+
+echo "=== [qianwen] Qwen25VL_7B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_text/diff_text_COCO_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_7B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_text/diff_text_VGMED_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_3B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_text/diff_text_COCO_Qwen25VL_3B.sh
+echo "=== [qianwen] Qwen25VL_3B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_text/diff_text_VGMED_Qwen25VL_3B.sh
+echo "=== [llava-natural] LLaVA_7B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_text/diff_text_COCO_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_7B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_text/diff_text_VGMED_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_13B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_text/diff_text_COCO_LLaVA_13B.sh
+echo "=== [llava-natural] LLaVA_13B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/diff_text/diff_text_VGMED_LLaVA_13B.sh
+echo "=== [llava-med] LLaVA_Med_7B COCO ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/diff_text/diff_text_COCO_LLaVA_Med_7B.sh
+echo "=== [llava-med] LLaVA_Med_7B VGMED ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/diff_text/diff_text_VGMED_LLaVA_Med_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_text/diff_text_COCO_HuatuoGPT_V_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_text/diff_text_VGMED_HuatuoGPT_V_7B.sh
+echo "=== [gemma] MedGemma_4B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_text/diff_text_COCO_MedGemma_4B_IT.sh
+echo "=== [gemma] MedGemma_4B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_text/diff_text_VGMED_MedGemma_4B_IT.sh
+
+# ── Oversized models (run last; failures here don't block anything above) ──
+echo "=== [qianwen] Qwen25VL_32B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_text/diff_text_COCO_Qwen25VL_32B.sh
+echo "=== [qianwen] Qwen25VL_32B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/diff_text/diff_text_VGMED_Qwen25VL_32B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_text/diff_text_COCO_HuatuoGPT_V_34B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/diff_text/diff_text_VGMED_HuatuoGPT_V_34B.sh
+echo "=== [gemma] MedGemma_27B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_text/diff_text_COCO_MedGemma_27B_IT.sh
+echo "=== [gemma] MedGemma_27B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/diff_text/diff_text_VGMED_MedGemma_27B_IT.sh
+
+echo "All diff_text jobs finished."

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/eval_scripts/run_all_mask_region.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# run_all_mask_region: grounding_mask_region.py
+# Oversized models (32B/34B/27B-IT) are pushed to the very end, after every
+# normal-size model has finished, so a stuck/OOM large model never blocks them.
+export CUDA_VISIBLE_DEVICES=0
+cd "$(dirname "$0")/.."
+
+echo "=== [qianwen] Qwen25VL_7B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_region/mask_region_COCO_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_7B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_region/mask_region_VGMED_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_3B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_region/mask_region_COCO_Qwen25VL_3B.sh
+echo "=== [qianwen] Qwen25VL_3B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_region/mask_region_VGMED_Qwen25VL_3B.sh
+echo "=== [llava-natural] LLaVA_7B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_region/mask_region_COCO_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_7B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_region/mask_region_VGMED_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_13B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_region/mask_region_COCO_LLaVA_13B.sh
+echo "=== [llava-natural] LLaVA_13B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_region/mask_region_VGMED_LLaVA_13B.sh
+echo "=== [llava-med] LLaVA_Med_7B COCO ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/mask_region/mask_region_COCO_LLaVA_Med_7B.sh
+echo "=== [llava-med] LLaVA_Med_7B VGMED ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/mask_region/mask_region_VGMED_LLaVA_Med_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_region/mask_region_COCO_HuatuoGPT_V_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_region/mask_region_VGMED_HuatuoGPT_V_7B.sh
+echo "=== [gemma] MedGemma_4B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_region/mask_region_COCO_MedGemma_4B_IT.sh
+echo "=== [gemma] MedGemma_4B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_region/mask_region_VGMED_MedGemma_4B_IT.sh
+
+# ── Oversized models (run last; failures here don't block anything above) ──
+echo "=== [qianwen] Qwen25VL_32B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_region/mask_region_COCO_Qwen25VL_32B.sh
+echo "=== [qianwen] Qwen25VL_32B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_region/mask_region_VGMED_Qwen25VL_32B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_region/mask_region_COCO_HuatuoGPT_V_34B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_region/mask_region_VGMED_HuatuoGPT_V_34B.sh
+echo "=== [gemma] MedGemma_27B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_region/mask_region_COCO_MedGemma_27B_IT.sh
+echo "=== [gemma] MedGemma_27B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_region/mask_region_VGMED_MedGemma_27B_IT.sh
+
+echo "All mask_region jobs finished."

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/eval_scripts/run_all_mask_text.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# run_all_mask_text: grounding_mask_text.py
+# Oversized models (32B/34B/27B-IT) are pushed to the very end, after every
+# normal-size model has finished, so a stuck/OOM large model never blocks them.
+export CUDA_VISIBLE_DEVICES=0
+cd "$(dirname "$0")/.."
+
+echo "=== [qianwen] Qwen25VL_7B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_text/mask_text_COCO_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_7B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_text/mask_text_VGMED_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_3B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_text/mask_text_COCO_Qwen25VL_3B.sh
+echo "=== [qianwen] Qwen25VL_3B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_text/mask_text_VGMED_Qwen25VL_3B.sh
+echo "=== [llava-natural] LLaVA_7B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_text/mask_text_COCO_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_7B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_text/mask_text_VGMED_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_13B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_text/mask_text_COCO_LLaVA_13B.sh
+echo "=== [llava-natural] LLaVA_13B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/grounding/mask_text/mask_text_VGMED_LLaVA_13B.sh
+echo "=== [llava-med] LLaVA_Med_7B COCO ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/mask_text/mask_text_COCO_LLaVA_Med_7B.sh
+echo "=== [llava-med] LLaVA_Med_7B VGMED ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/grounding/mask_text/mask_text_VGMED_LLaVA_Med_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_text/mask_text_COCO_HuatuoGPT_V_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_text/mask_text_VGMED_HuatuoGPT_V_7B.sh
+echo "=== [gemma] MedGemma_4B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_text/mask_text_COCO_MedGemma_4B_IT.sh
+echo "=== [gemma] MedGemma_4B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_text/mask_text_VGMED_MedGemma_4B_IT.sh
+
+# ── Oversized models (run last; failures here don't block anything above) ──
+echo "=== [qianwen] Qwen25VL_32B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_text/mask_text_COCO_Qwen25VL_32B.sh
+echo "=== [qianwen] Qwen25VL_32B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/grounding/mask_text/mask_text_VGMED_Qwen25VL_32B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_text/mask_text_COCO_HuatuoGPT_V_34B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/grounding/mask_text/mask_text_VGMED_HuatuoGPT_V_34B.sh
+echo "=== [gemma] MedGemma_27B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_text/mask_text_COCO_MedGemma_27B_IT.sh
+echo "=== [gemma] MedGemma_27B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/grounding/mask_text/mask_text_VGMED_MedGemma_27B_IT.sh
+
+echo "All mask_text jobs finished."

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/eval_scripts/run_all_measure_attention.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# GPU2: measure_attention for all models (sequential, MedGemma last)
+# Env: qianwen -> llava-natural -> llava-med -> huatuogpt -> gemma
+# Oversized models (32B/34B/27B-IT) are pushed to the very end, after every
+# normal-size model has finished, so a stuck/OOM large model never blocks them.
+export CUDA_VISIBLE_DEVICES=0
+cd "$(dirname "$0")/.."
+
+echo "=== [qianwen] Qwen25VL_7B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/measure_attention/measure_attention_COCO_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_7B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/measure_attention/measure_attention_VGMED_Qwen25VL_7B.sh
+echo "=== [qianwen] Qwen25VL_3B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/measure_attention/measure_attention_COCO_Qwen25VL_3B.sh
+echo "=== [qianwen] Qwen25VL_3B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/measure_attention/measure_attention_VGMED_Qwen25VL_3B.sh
+echo "=== [llava-natural] LLaVA_7B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/measure_attention/measure_attention_COCO_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_7B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/measure_attention/measure_attention_VGMED_LLaVA_7B.sh
+echo "=== [llava-natural] LLaVA_13B COCO ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/measure_attention/measure_attention_COCO_LLaVA_13B.sh
+echo "=== [llava-natural] LLaVA_13B VGMED ==="
+conda run --no-capture-output -n llava-natural bash eval_scripts/measure_attention/measure_attention_VGMED_LLaVA_13B.sh
+echo "=== [llava-med] LLaVA_Med_7B COCO ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/measure_attention/measure_attention_COCO_LLaVA_Med_7B.sh
+echo "=== [llava-med] LLaVA_Med_7B VGMED ==="
+conda run --no-capture-output -n llava-med bash eval_scripts/measure_attention/measure_attention_VGMED_LLaVA_Med_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/measure_attention/measure_attention_COCO_HuatuoGPT_V_7B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_7B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/measure_attention/measure_attention_VGMED_HuatuoGPT_V_7B.sh
+echo "=== [gemma] MedGemma_4B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/measure_attention/measure_attention_COCO_MedGemma_4B_IT.sh
+echo "=== [gemma] MedGemma_4B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/measure_attention/measure_attention_VGMED_MedGemma_4B_IT.sh
+
+# ── Oversized models (run last; failures here don't block anything above) ──
+echo "=== [qianwen] Qwen25VL_32B COCO ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/measure_attention/measure_attention_COCO_Qwen25VL_32B.sh
+echo "=== [qianwen] Qwen25VL_32B VGMED ==="
+conda run --no-capture-output -n qianwen bash eval_scripts/measure_attention/measure_attention_VGMED_Qwen25VL_32B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B COCO ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/measure_attention/measure_attention_COCO_HuatuoGPT_V_34B.sh
+echo "=== [huatuogpt] HuatuoGPT_V_34B VGMED ==="
+conda run --no-capture-output -n huatuogpt bash eval_scripts/measure_attention/measure_attention_VGMED_HuatuoGPT_V_34B.sh
+echo "=== [gemma] MedGemma_27B_IT COCO ==="
+conda run --no-capture-output -n gemma bash eval_scripts/measure_attention/measure_attention_COCO_MedGemma_27B_IT.sh
+echo "=== [gemma] MedGemma_27B_IT VGMED ==="
+conda run --no-capture-output -n gemma bash eval_scripts/measure_attention/measure_attention_VGMED_MedGemma_27B_IT.sh
+
+echo "All measure_attention jobs finished."

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/.ipynb_checkpoints/HealthGPT-checkpoint.py

@@ -0,0 +1,173 @@
+import os, sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+import torch
+import transformers
+import tokenizers
+
+from PIL import Image
+from tqdm import tqdm
+from packaging import version
+IS_TOKENIZER_GREATER_THAN_0_14 = version.parse(tokenizers.__version__) >= version.parse('0.14')
+
+
+from .llava import conversation as conversation_lib
+from .llava.model import *
+from .llava.mm_utils import tokenizer_image_token,process_images
+from .llava.model.language_model.llava_phi3 import LlavaPhiForCausalLM, LlavaPhiConfig
+
+from .utils import find_all_linear_names, add_special_tokens_and_resize_model, load_weights, expand2square,com_vision_args
+
+
+class HealthGPT:
+    def __init__(self,model_path,args):
+        super().__init__()
+        self.llm = LlavaQwen2ForCausalLM.from_pretrained(
+        pretrained_model_name_or_path = model_path,
+        attn_implementation="flash_attention_2",
+        torch_dtype= torch.float16,
+        device_map="cuda"
+    )
+        from .llava.peft import LoraConfig, get_peft_model
+        print("load model done")
+        lora_config = LoraConfig(
+            r= 32,
+            lora_alpha=64,
+            target_modules=find_all_linear_names(self.llm),
+            lora_dropout=0.0,
+            bias='none',
+            task_type="CAUSAL_LM",
+            lora_nums=4,
+        )
+        self.llm = get_peft_model(self.llm, lora_config)
+        print("load lora done")
+
+        self.tokenizer = transformers.AutoTokenizer.from_pretrained(
+            model_path,
+            padding_side="right",
+            use_fast=False,
+        )
+        if self.tokenizer.unk_token:
+            self.tokenizer.pad_token = tokenizer.unk_token
+        else:
+            self.tokenizer.legacy = False
+        print("load tokenizer done")
+
+        from .utils import com_vision_args
+        com_vision_args.model_name_or_path = model_path
+        com_vision_args.vision_tower = '/mnt/workspace/workgroup_dev/longli/models/hub/clip-vit-large-patch14-336'
+        com_vision_args.version = "qwen_2"
+
+        self.llm.get_model().initialize_vision_modules(model_args=com_vision_args)
+        self.llm.get_vision_tower().to(dtype=torch.float16)
+        self.llm.get_model().mm_projector.to(dtype=torch.float16)
+        print("load vision tower done")
+
+        self.llm = load_weights(self.llm, "/mnt/workspace/workgroup_dev/longli/models/hub/HealthGPT-XL32/com_hlora_weights_QWEN_32B.bin")
+        print("load weights done")
+        self.llm.eval()
+        self.llm.to(dtype=torch.float16).cuda()
+
+        self.temperature = args.temperature
+        self.top_p = args.top_p
+        self.repetition_penalty = args.repetition_penalty
+        self.max_tokens = args.max_new_tokens
+
+
+    def process_messages(self,messages):
+        conv = conversation_lib.conv_templates["qwen_2"].copy()
+        conv.messages = []
+        if  "system" in messages:
+            conv.system = messages["system"]
+        
+        imgs = []
+        if "image" in messages:
+            image = messages["image"]
+            if isinstance(image,str):
+                image = Image.open(image).convert('RGB')
+            elif isinstance(image,Image.Image):
+                image = image.convert('RGB')
+            
+            
+            imgs.append(image)
+            prompt = DEFAULT_IMAGE_TOKEN + '\n' + messages["prompt"]
+        elif "images" in messages:
+            images = messages["images"]
+            prompt = ""
+            for i,image in enumerate(images):
+                prompt += f"<image_{i+1}>: " + DEFAULT_IMAGE_TOKEN + '\n'
+                if isinstance(image,str):
+                    if os.path.exists(image):
+                        image = Image.open(image)
+                elif isinstance(image,Image.Image):
+                    image = image.convert("RGB")
+                imgs.append(image)
+            prompt += messages["prompt"]
+        else:
+            prompt = messages["prompt"]
+        conv.append_message(conv.roles[0],prompt)
+        conv.append_message(conv.roles[1],None) 
+        prompt = conv.get_prompt()
+        imgs = None if len(imgs) == 0 else imgs
+        return prompt,imgs
+
+
+    def generate_output(self,messages):
+        prompt,imgs = self.process_messages(messages)
+        if imgs:
+            # imgs = imgs[0]
+            input_ids = tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze_(0).cuda()
+            imgs = [expand2square(img, tuple(int(x*255) for x in self.llm.get_vision_tower().image_processor.image_mean)) for img in imgs]
+            imgs = self.llm.get_vision_tower().image_processor.preprocess(imgs, return_tensors='pt')['pixel_values'].to(dtype=torch.float16, device='cuda', non_blocking=True)
+            # imgs = process_images(imgs,self.llm.get_vision_tower().image_processor,self.llm.config)
+        else:
+            input_ids = tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze_(0).cuda()
+            imgs = None
+
+        with torch.inference_mode():
+            do_sample = False if self.temperature == 0 else True
+            output_ids = self.llm.base_model.model.generate(input_ids,images=imgs,do_sample=do_sample,num_beams=5,max_new_tokens=self.max_tokens,temperature = self.temperature,top_p = self.top_p,repetition_penalty = self.repetition_penalty,use_cache=True)
+
+        outputs = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+        return outputs
+    
+    def generate_outputs(self,messages_list):
+        outputs = []
+        for messages in tqdm(messages_list):
+            output = self.generate_output(messages)
+            outputs.append(output)
+        return outputs
+
+if __name__ == '__main__':
+    # def construct_messages(sample):
+    #     question = sample["question"]
+    #     image = sample["image"]
+    #     answer = sample["answer"]
+    #     if answer in ["yes","no"]:
+    #         question += "Please output 'yes' or 'no'(no extra output)"
+    #         if os.environ.get("STRICT_PROMPT","False") == "True":
+    #             question += "Wrap your final answer between <answer> and </answer>, for example: <answer>yes</answer>"
+    #     else:
+    #         question += 'Answer the question concisely(Keep it short and concise).'
+    #         if os.environ.get("STRICT_PROMPT","False") == "True":
+    #             question += "Wrap your final answer between <answer> and </answer>, for example: <answer>positive influence</answer>"
+    #     messages = {"prompt":question,"image":image}
+    #     sample["messages"] = messages
+    #     return sample
+    
+    # from datasets import load_dataset
+    # from tqdm import tqdm
+    # dataset = load_dataset("/mnt/workspace/workgroup_dev/longli/MedLLMBenchmarks/benchmarks/VQA_RAD",split="test")
+
+    # llm = HealthGPT()
+    # for data in tqdm(dataset):
+    #     data = construct_messages(data)
+    #     image = data["image"]
+    #     messages = {"prompt":data["question"],"image":image}
+    #     result = llm.generate_output(messages)
+
+    llm = HealthGPT()
+    image = "/mnt/workspace/workgroup_dev/longli/MedLLMBenchmarks/benchmarks/OmniMedVQA/Images/ACRIMA/Im553_g_ACRIMA.png"
+    image2 = "/mnt/workspace/workgroup_dev/longli/MedLLMBenchmarks/benchmarks/OmniMedVQA/Images/BreakHis/benign/SOB_B_A-14-22549AB-40-005.png"
+    messages = [{ 'images': [image,image2],"prompt":"\nQuestion:  你是一个医疗助手，我的问题是这两张图片里的内容是什么？"}]
+    result = llm.generate_outputs(messages)
+    print("result:",result)

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/.ipynb_checkpoints/HealthGPT_phi-checkpoint.py

@@ -0,0 +1,169 @@
+import os, sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+import torch
+import transformers
+import tokenizers
+
+from PIL import Image
+from tqdm import tqdm
+from packaging import version
+IS_TOKENIZER_GREATER_THAN_0_14 = version.parse(tokenizers.__version__) >= version.parse('0.14')
+
+
+from .llava.constants import  IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN
+from .llava.peft import LoraConfig, get_peft_model
+from .llava import conversation as conversation_lib
+from .llava.model import *
+from .llava.mm_utils import tokenizer_image_token,process_images
+from .llava.model.language_model.llava_phi3 import LlavaPhiForCausalLM
+from .utils import find_all_linear_names, add_special_tokens_and_resize_model, load_weights, expand2square,com_vision_args
+
+
+class HealthGPT:
+    def __init__(self,model_path,args):
+        super().__init__()
+        self.llm = LlavaPhiForCausalLM.from_pretrained(
+        pretrained_model_name_or_path = model_path,
+        attn_implementation="flash_attention_2",
+        torch_dtype= torch.float16,
+        device_map="cuda"
+    )
+        print("load model done")
+        lora_config = LoraConfig(
+            r= 32,
+            lora_alpha=64,
+            target_modules=find_all_linear_names(self.llm),
+            lora_dropout=0.0,
+            bias='none',
+            task_type="CAUSAL_LM",
+            lora_nums=4,
+        )
+        self.llm = get_peft_model(self.llm, lora_config)
+        print("load lora done")
+
+        self.tokenizer = transformers.AutoTokenizer.from_pretrained(
+            model_path,
+            padding_side="right",
+            use_fast=False,
+        )
+        print("load tokenizer done")
+
+        num_new_tokens = add_special_tokens_and_resize_model(self.tokenizer, self.llm, 8192)
+        print(f"Number of new tokens added for unified task: {num_new_tokens}")
+
+        com_vision_args.model_name_or_path = model_path
+        com_vision_args.vision_tower = '/mnt/workspace/workgroup_dev/longli/models/hub/clip-vit-large-patch14-336'
+        com_vision_args.version = "phi4_instruct"
+
+        self.llm.get_model().initialize_vision_modules(model_args=com_vision_args)
+        self.llm.get_vision_tower().to(dtype=torch.float16)
+        self.llm.get_model().mm_projector.to(dtype=torch.float16)
+        print("load vision tower done")
+
+        self.llm = load_weights(self.llm, "/mnt/workspace/workgroup_dev/longli/models/hub/HealthGPT-L14/com_hlora_weights_phi4.bin")
+        print("load weights done")
+        self.llm.eval()
+        self.llm.to(dtype=torch.float16).cuda()
+
+        self.temperature = args.temperature
+        self.top_p = args.top_p
+        self.repetition_penalty = args.repetition_penalty
+        self.max_tokens = args.max_new_tokens
+
+
+    def process_messages(self,messages):
+        conv = conversation_lib.conv_templates["phi4_instruct"].copy()
+        conv.messages = []
+        if  "system" in messages:
+            conv.system = messages["system"]
+        
+        imgs = []
+        if "image" in messages:
+            image = messages["image"]
+            if isinstance(image,str):
+                image = Image.open(image).convert('RGB')
+            elif isinstance(image,Image.Image):
+                image = image.convert('RGB')
+            imgs.append(image)
+            prompt = DEFAULT_IMAGE_TOKEN + '\n' + messages["prompt"]
+        elif "images" in messages:
+            images = messages["images"]
+            prompt = ""
+            for i,image in enumerate(images):
+                prompt += f"<image_{i+1}>: " + DEFAULT_IMAGE_TOKEN + '\n'
+                if isinstance(image,str):
+                    if os.path.exists(image):
+                        image = Image.open(image)
+                elif isinstance(image,Image.Image):
+                    image = image.convert("RGB")
+                imgs.append(image)
+            prompt += messages["prompt"]
+        else:
+            prompt = messages["prompt"]
+        conv.append_message(conv.roles[0],prompt)
+        conv.append_message(conv.roles[1],None) 
+        prompt = conv.get_prompt()
+        imgs = None if len(imgs) == 0 else imgs
+        return prompt,imgs
+
+
+    def generate_output(self,messages):
+        prompt,imgs = self.process_messages(messages)
+        if imgs:
+            # imgs = imgs[0]
+            input_ids = tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze_(0).cuda()
+            imgs = [expand2square(img, tuple(int(x*255) for x in self.llm.get_vision_tower().image_processor.image_mean)) for img in imgs]
+            imgs = self.llm.get_vision_tower().image_processor.preprocess(imgs, return_tensors='pt')['pixel_values'].to(dtype=torch.float16, device='cuda', non_blocking=True)
+            # imgs = process_images(imgs,self.llm.get_vision_tower().image_processor,self.llm.config)
+        else:
+            input_ids = tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze_(0).cuda()
+            imgs = None
+
+        with torch.inference_mode():
+            do_sample = False if self.temperature == 0 else True
+            output_ids = self.llm.base_model.model.generate(input_ids,images=imgs,do_sample=do_sample,num_beams=5,max_new_tokens=self.max_tokens,temperature = self.temperature,top_p = self.top_p,repetition_penalty = self.repetition_penalty,use_cache=True)
+
+        outputs = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+        return outputs
+    
+    def generate_outputs(self,messages_list):
+        outputs = []
+        for messages in tqdm(messages_list):
+            output = self.generate_output(messages)
+            outputs.append(output)
+        return outputs
+
+if __name__ == '__main__':
+    # def construct_messages(sample):
+    #     question = sample["question"]
+    #     image = sample["image"]
+    #     answer = sample["answer"]
+    #     if answer in ["yes","no"]:
+    #         question += "Please output 'yes' or 'no'(no extra output)"
+    #         if os.environ.get("STRICT_PROMPT","False") == "True":
+    #             question += "Wrap your final answer between <answer> and </answer>, for example: <answer>yes</answer>"
+    #     else:
+    #         question += 'Answer the question concisely(Keep it short and concise).'
+    #         if os.environ.get("STRICT_PROMPT","False") == "True":
+    #             question += "Wrap your final answer between <answer> and </answer>, for example: <answer>positive influence</answer>"
+    #     messages = {"prompt":question,"image":image}
+    #     sample["messages"] = messages
+    #     return sample
+    
+    # from datasets import load_dataset
+    # from tqdm import tqdm
+    # dataset = load_dataset("/mnt/workspace/workgroup_dev/longli/MedLLMBenchmarks/benchmarks/VQA_RAD",split="test")
+
+    # llm = HealthGPT()
+    # for data in tqdm(dataset):
+    #     data = construct_messages(data)
+    #     image = data["image"]
+    #     messages = {"prompt":data["question"],"image":image}
+    #     result = llm.generate_output(messages)
+
+    llm = HealthGPT()
+    image = "/mnt/workspace/workgroup_dev/longli/MedLLMBenchmarks/benchmarks/OmniMedVQA/Images/ACRIMA/Im553_g_ACRIMA.png"
+    image2 = "/mnt/workspace/workgroup_dev/longli/MedLLMBenchmarks/benchmarks/OmniMedVQA/Images/BreakHis/benign/SOB_B_A-14-22549AB-40-005.png"
+    messages = [{ 'images': [image,image2],"prompt":"\nQuestion:  你是一个医疗助手，我的问题是这两张图片里的内容是什么？"}]
+    result = llm.generate_outputs(messages)
+    print("result:",result)

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/demo/com_infer_phi4.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+MODEL_NAME_OR_PATH="microsoft/Phi-4"
+VIT_PATH="openai/clip-vit-large-patch14-336/"
+HLORA_PATH="com_hlora_weights_phi4.bin"
+
+python3 com_infer_phi4.py \
+    --model_name_or_path "$MODEL_NAME_OR_PATH" \
+    --dtype "FP16" \
+    --hlora_r "32" \
+    --hlora_alpha "64" \
+    --hlora_nums "4" \
+    --vq_idx_nums "8192" \
+    --instruct_template "phi4_instruct" \
+    --vit_path "$VIT_PATH" \
+    --hlora_path "$HLORA_PATH" \
+    --question "Your question" \
+    --img_path "path/to/image.jpg"

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/demo/utils.py

@@ -0,0 +1,103 @@
+import torch
+import transformers
+import tokenizers
+import os, sys
+from dataclasses import dataclass, field
+import argparse
+from PIL import Image
+
+def expand2square(pil_img, background_color):
+    width, height = pil_img.size
+    if width == height:
+        return pil_img
+    elif width > height:
+        result = Image.new(pil_img.mode, (width, width), background_color)
+        result.paste(pil_img, (0, (width - height) // 2))
+        return result
+    else:
+        result = Image.new(pil_img.mode, (height, height), background_color)
+        result.paste(pil_img, ((height - width) // 2, 0))
+        return result
+
+def find_all_linear_names(model):
+    cls = torch.nn.Linear
+    lora_module_names = set()
+    multimodal_keywords = ['mm_projector', 'vision_tower', 'vision_resampler']
+    for name, module in model.named_modules():
+        if any(mm_keyword in name for mm_keyword in multimodal_keywords):
+            continue
+        if isinstance(module, cls):
+            names = name.split('.')
+            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
+
+    if 'lm_head' in lora_module_names: # needed for 16-bit
+        lora_module_names.remove('lm_head')
+    return list(lora_module_names)
+
+def add_special_tokens_and_resize_model(tokenizer, model, vq_idx_nums=8192):
+    if len(tokenizer.additional_special_tokens) != 0:
+        return tokenizer.additional_special_tokens
+    index_tokens = [f"<idx_{i}>" for i in range(vq_idx_nums)]
+    special_tokens = {
+        'additional_special_tokens': ['<start_index>'] + index_tokens + ['<end_index>'] + ['<pixel_newline>']
+    }
+    num_new_tokens = tokenizer.add_special_tokens(special_tokens)
+    model.resize_token_embeddings(len(tokenizer))
+    if num_new_tokens > 0:
+        input_embeddings = model.get_input_embeddings().weight.data
+        output_embeddings = model.get_output_embeddings().weight.data
+
+        input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(
+            dim=0, keepdim=True)
+        output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(
+            dim=0, keepdim=True)
+
+        input_embeddings[-num_new_tokens:] = input_embeddings_avg
+        output_embeddings[-num_new_tokens:] = output_embeddings_avg
+    
+    return num_new_tokens
+
+com_vision_args = argparse.Namespace(
+    freeze_backbone=False,
+    mm_patch_merge_type='flat',
+    mm_projector_type='mlp2x_gelu',
+    mm_use_im_patch_token=False,
+    mm_use_im_start_end=False,
+    mm_vision_select_feature='patch',
+    mm_vision_select_layer=-2,
+    model_name_or_path=None,
+    pretrain_mm_mlp_adapter=None,
+    tune_mm_mlp_adapter=False,
+    version=None,
+    vision_tower=None
+)
+
+gen_vision_args = argparse.Namespace(
+    freeze_backbone=False,
+    mm_patch_merge_type='flat',
+    mm_projector_type='mlp2x_gelu',
+    mm_use_im_patch_token=False,
+    mm_use_im_start_end=False,
+    mm_vision_select_feature='patch',
+    mm_vision_select_layer=1,
+    model_name_or_path=None,
+    pretrain_mm_mlp_adapter=None,
+    tune_mm_mlp_adapter=False,
+    version=None,
+    vision_tower=None
+)
+
+def load_weights(model, hlora_path, fusion_layer_path=None):
+    hlora_weights = torch.load(hlora_path)
+    hlora_unexpected_keys = model.load_state_dict(hlora_weights, strict=False)[1]
+    if hlora_unexpected_keys:
+        print(f"Warning: Unexpected keys in hlora checkpoint: {hlora_unexpected_keys}")
+
+    if fusion_layer_path:
+        fusion_layer_weights = torch.load(fusion_layer_path)
+        fusion_layer_unexpected_keys = model.load_state_dict(fusion_layer_weights, strict=False)[1]
+        if fusion_layer_unexpected_keys:
+            print(f"Warning: Unexpected keys in fusion_layer checkpoint: {fusion_layer_unexpected_keys}")
+
+    return model
+

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/peft/__init__.py

@@ -0,0 +1,53 @@
+# flake8: noqa
+# There's no way to ignore "F401 '...' imported but unused" warnings in this
+# module, but to preserve other warnings. So, don't check this module at all.
+
+# coding=utf-8
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.3.0.dev0"
+
+from .mapping import MODEL_TYPE_TO_PEFT_MODEL_MAPPING, PEFT_TYPE_TO_CONFIG_MAPPING, get_peft_config, get_peft_model
+from .peft_model import (
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+)
+from .tuners import (
+    LoraConfig,
+    LoraModel,
+    PrefixEncoder,
+    PrefixTuningConfig,
+    PromptEmbedding,
+    PromptEncoder,
+    PromptEncoderConfig,
+    PromptEncoderReparameterizationType,
+    PromptTuningConfig,
+    PromptTuningInit,
+)
+from .utils import (
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    PeftConfig,
+    PeftType,
+    PromptLearningConfig,
+    TaskType,
+    bloom_model_postprocess_past_key_value,
+    get_peft_model_state_dict,
+    # prepare_model_for_int8_training,
+    set_peft_model_state_dict,
+    shift_tokens_right,
+)

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/peft/mapping.py

@@ -0,0 +1,152 @@
+# coding=utf-8
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .peft_model import (
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+)
+from .tuners import LoraConfig, PrefixTuningConfig, PromptEncoderConfig, PromptTuningConfig
+from .utils import PromptLearningConfig
+
+
+MODEL_TYPE_TO_PEFT_MODEL_MAPPING = {
+    "SEQ_CLS": PeftModelForSequenceClassification,
+    "SEQ_2_SEQ_LM": PeftModelForSeq2SeqLM,
+    "CAUSAL_LM": PeftModelForCausalLM, # here
+    "TOKEN_CLS": PeftModelForTokenClassification,
+}
+
+PEFT_TYPE_TO_CONFIG_MAPPING = {
+    "PROMPT_TUNING": PromptTuningConfig,
+    "PREFIX_TUNING": PrefixTuningConfig,
+    "P_TUNING": PromptEncoderConfig,
+    "LORA": LoraConfig,
+}
+
+TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING = {
+    "t5": ["q", "v"],
+    "mt5": ["q", "v"],
+    "bart": ["q_proj", "v_proj"],
+    "gpt2": ["c_attn"],
+    "bloom": ["query_key_value"],
+    "opt": ["q_proj", "v_proj"],
+    "gptj": ["q_proj", "v_proj"],
+    "gpt_neox": ["query_key_value"],
+    "gpt_neo": ["q_proj", "v_proj"],
+    "bert": ["query", "value"],
+    "roberta": ["query", "value"],
+    "xlm-roberta": ["query", "value"],
+    "electra": ["query", "value"],
+    "deberta-v2": ["query_proj", "value_proj"],
+    "deberta": ["in_proj"],
+    "layoutlm": ["query", "value"],
+    "llama": ["q_proj", "v_proj"],
+    "chatglm": ["query_key_value"],
+}
+
+
+def get_peft_config(config_dict):
+    """
+    Returns a Peft config object from a dictionary.
+
+    Args:
+        config_dict (`Dict[str, Any]`): Dictionary containing the configuration parameters.
+    """
+
+    return PEFT_TYPE_TO_CONFIG_MAPPING[config_dict["peft_type"]](**config_dict)
+
+
+def _prepare_prompt_learning_config(peft_config, model_config):
+    if peft_config.num_layers is None:
+        if "num_hidden_layers" in model_config:
+            num_layers = model_config["num_hidden_layers"]
+        elif "num_layers" in model_config:
+            num_layers = model_config["num_layers"]
+        elif "n_layer" in model_config:
+            num_layers = model_config["n_layer"]
+        else:
+            raise ValueError("Please specify `num_layers` in `peft_config`")
+        peft_config.num_layers = num_layers
+
+    if peft_config.token_dim is None:
+        if "hidden_size" in model_config:
+            token_dim = model_config["hidden_size"]
+        elif "n_embd" in model_config:
+            token_dim = model_config["n_embd"]
+        elif "d_model" in model_config:
+            token_dim = model_config["d_model"]
+        else:
+            raise ValueError("Please specify `token_dim` in `peft_config`")
+        peft_config.token_dim = token_dim
+
+    if peft_config.num_attention_heads is None:
+        if "num_attention_heads" in model_config:
+            num_attention_heads = model_config["num_attention_heads"]
+        elif "n_head" in model_config:
+            num_attention_heads = model_config["n_head"]
+        elif "num_heads" in model_config:
+            num_attention_heads = model_config["num_heads"]
+        elif "encoder_attention_heads" in model_config:
+            num_attention_heads = model_config["encoder_attention_heads"]
+        else:
+            raise ValueError("Please specify `num_attention_heads` in `peft_config`")
+        peft_config.num_attention_heads = num_attention_heads
+
+    if getattr(peft_config, "encoder_hidden_size", None) is None:
+        setattr(peft_config, "encoder_hidden_size", token_dim)
+
+    return peft_config
+
+
+def _prepare_lora_config(peft_config, model_config):
+    if peft_config.target_modules is None:
+        if model_config["model_type"] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+            raise ValueError("Please specify `target_modules` in `peft_config`")
+        peft_config.target_modules = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config["model_type"]]
+    if len(peft_config.target_modules) == 1:
+        peft_config.fan_in_fan_out = True
+        peft_config.enable_lora = [True, False, True]
+    if peft_config.inference_mode:
+        peft_config.merge_weights = True
+    return peft_config
+
+
+def get_peft_model(model, peft_config):
+    """
+    Returns a Peft model object from a model and a config.
+
+    Args:
+        model ([`transformers.PreTrainedModel`]): Model to be wrapped.
+        peft_config ([`PeftConfig`]): Configuration object containing the parameters of the Peft model.
+    """
+
+    model_config = model.config.to_dict()
+    peft_config.base_model_name_or_path = model.__dict__.get("name_or_path", None)
+
+    # PeftModelForCausalLM <- PeftModel
+    if peft_config.task_type not in MODEL_TYPE_TO_PEFT_MODEL_MAPPING.keys():
+        peft_config = _prepare_lora_config(peft_config, model_config)
+        return PeftModel(model, peft_config)
+    if not isinstance(peft_config, PromptLearningConfig): # -------------> here
+        peft_config = _prepare_lora_config(peft_config, model_config)
+    else:
+        peft_config = _prepare_prompt_learning_config(peft_config, model_config)
+
+
+    return MODEL_TYPE_TO_PEFT_MODEL_MAPPING[peft_config.task_type](model, peft_config)
+        

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/peft/peft_model.py

@@ -0,0 +1,932 @@
+# coding=utf-8
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import os
+import warnings
+from contextlib import contextmanager
+import sys
+
+
+import torch
+from accelerate import dispatch_model, infer_auto_device_map
+from accelerate.hooks import AlignDevicesHook, add_hook_to_module, remove_hook_from_submodules
+from accelerate.utils import get_balanced_memory
+from huggingface_hub import hf_hub_download
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import SequenceClassifierOutput, TokenClassifierOutput
+from transformers.utils import PushToHubMixin
+
+from .tuners import LoraModel, PrefixEncoder, PromptEmbedding, PromptEncoder
+from .utils import (
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    WEIGHTS_NAME,
+    PeftConfig,
+    PeftType,
+    PromptLearningConfig,
+    TaskType,
+    _set_trainable,
+    get_peft_model_state_dict,
+    set_peft_model_state_dict,
+    shift_tokens_right,
+)
+
+
+class PeftModel(PushToHubMixin, torch.nn.Module):
+    """
+    Parameter-Efficient Fine-Tuning Model. Base model encompassing various Peft methods.
+
+    Args:
+        model ([`PreTrainedModel`]): The base transformer model used for Peft.
+        peft_config ([`PeftConfig`]): The configuration of the Peft model.
+
+
+    **Attributes**:
+        - **base_model** ([`PreTrainedModel`]) -- The base transformer model used for Peft.
+        - **peft_config** ([`PeftConfig`]) -- The configuration of the Peft model.
+        - **modules_to_save** (`list` of `str`) -- The list of sub-module names to save when
+        saving the model.
+        - **prompt_encoder** ([`PromptEncoder`]) -- The prompt encoder used for Peft if
+        `isinstance(self.peft_config, PromptLearningConfig)`.
+        - **prompt_tokens** (`torch.Tensor`) -- The virtual prompt tokens used for Peft if
+        `isinstance(self.peft_config, PromptLearningConfig)`.
+        - **transformer_backbone_name** (`str`) -- The name of the transformer
+        backbone in the base model if `isinstance(self.peft_config, PromptLearningConfig)`.
+        - **word_embeddings** (`torch.nn.Embedding`) -- The word embeddings of the transformer backbone
+        in the base model if `isinstance(self.peft_config, PromptLearningConfig)`.
+    """
+
+    def __init__(self, model, peft_config: PeftConfig): # casualLM, LoraConfig
+        super().__init__()
+        self.peft_config = peft_config
+        self.base_model = model
+        self.config = self.base_model.config
+        self.modules_to_save = None
+        if isinstance(self.peft_config, PromptLearningConfig):
+            self._setup_prompt_encoder()
+        else: # --------------> here
+            self.base_model = LoraModel(peft_config, model)
+        if getattr(self.peft_config, "modules_to_save", None) is not None:
+            self.modules_to_save = self.peft_config.modules_to_save
+            _set_trainable(self)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def save_pretrained(self, save_directory, **kwargs):
+        r"""
+        Args:
+        This function saves the adapter model and the adapter configuration files to a directory, so that it can be
+        re-loaded using the `LoraModel.from_pretrained` class method, and also used by the `LoraModel.push_to_hub`
+        method.
+            save_directory (`str`):
+                Directory where the adapter model and configuration files will be saved (will be created if it does not
+                exist).
+            **kwargs:
+                Additional keyword arguments passed along to the `push_to_hub` method.
+        """
+        if os.path.isfile(save_directory):
+            raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file")
+        os.makedirs(save_directory, exist_ok=True)
+
+        # save only the trainable weights
+        output_state_dict = get_peft_model_state_dict(self, kwargs.get("state_dict", None))
+        torch.save(output_state_dict, os.path.join(save_directory, WEIGHTS_NAME))
+
+        # save the config and change the inference mode to `True`
+        if self.peft_config.base_model_name_or_path is None:
+            self.peft_config.base_model_name_or_path = (
+                self.base_model.__dict__.get("name_or_path", None)
+                if isinstance(self.peft_config, PromptLearningConfig)
+                else self.base_model.model.__dict__.get("name_or_path", None)
+            )
+        inference_mode = self.peft_config.inference_mode
+        self.peft_config.inference_mode = True
+        self.peft_config.save_pretrained(save_directory)
+        self.peft_config.inference_mode = inference_mode
+
+    @classmethod
+    def from_pretrained(cls, model, model_id, **kwargs):
+        r"""
+        Args:
+        Instantiate a `LoraModel` from a pretrained Lora configuration and weights.
+            model (`transformers.PreTrainedModel`):
+                The model to be adapted. The model should be initialized with the `from_pretrained` method. from
+                `transformers` library.
+            model_id (`str`):
+                The name of the Lora configuration to use. Can be either:
+                    - A string, the `model id` of a Lora configuration hosted inside a model repo on
+                        huggingface Hub
+                    - A path to a directory containing a Lora configuration file saved using the
+                        `save_pretrained` method, e.g., ``./my_lora_config_directory/``.
+        """
+        from .mapping import MODEL_TYPE_TO_PEFT_MODEL_MAPPING, PEFT_TYPE_TO_CONFIG_MAPPING
+
+        # load the config
+        config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig.from_pretrained(model_id).peft_type].from_pretrained(model_id)
+
+        if getattr(model, "hf_device_map", None) is not None:
+            remove_hook_from_submodules(model)
+
+        if config.task_type not in MODEL_TYPE_TO_PEFT_MODEL_MAPPING.keys():
+            model = cls(model, config)
+        else: # -----------------> here
+            model = MODEL_TYPE_TO_PEFT_MODEL_MAPPING[config.task_type](model, config)
+            
+        if os.path.exists(os.path.join(model_id, WEIGHTS_NAME)):
+            filename = os.path.join(model_id, WEIGHTS_NAME)
+        else:
+            try:
+                filename = hf_hub_download(model_id, WEIGHTS_NAME)
+            except:
+                raise ValueError(
+                    f"Can't find weights for {model_id} in {model_id} or in the Hugging Face Hub. "
+                    f"Please check that the file {WEIGHTS_NAME} is present at {model_id}."
+                )
+
+        adapters_weights = torch.load(
+            filename, map_location=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        )
+        # load the weights into the model
+        model = set_peft_model_state_dict(model, adapters_weights)
+
+
+        if getattr(model, "hf_device_map", None) is not None:
+            device_map = kwargs.get("device_map", "auto")
+            max_memory = kwargs.get("max_memory", None)
+            no_split_module_classes = model._no_split_modules
+            if device_map != "sequential":
+                max_memory = get_balanced_memory(
+                    model,
+                    max_memory=max_memory,
+                    no_split_module_classes=no_split_module_classes,
+                    low_zero=(device_map == "balanced_low_0"),
+                )
+            if isinstance(device_map, str):
+                device_map = infer_auto_device_map(
+                    model, max_memory=max_memory, no_split_module_classes=no_split_module_classes
+                )
+            model = dispatch_model(model, device_map=device_map)
+            hook = AlignDevicesHook(io_same_device=True)
+            if model.peft_config.peft_type == PeftType.LORA:
+                add_hook_to_module(model.base_model.model, hook)
+            else:
+                remove_hook_from_submodules(model.prompt_encoder)
+                add_hook_to_module(model.base_model, hook)
+        return model
+
+    def _setup_prompt_encoder(self):
+        transformer_backbone = None
+        for name, module in self.base_model.named_children():
+            for param in module.parameters():
+                param.requires_grad = False
+            if isinstance(module, PreTrainedModel):
+                # Make sure to freeze Tranformers model
+                if transformer_backbone is None:
+                    transformer_backbone = module
+                    self.transformer_backbone_name = name
+
+        if self.peft_config.num_transformer_submodules is None:
+            self.peft_config.num_transformer_submodules = (
+                2 if self.peft_config.task_type == TaskType.SEQ_2_SEQ_LM else 1
+            )
+
+        for named_param, value in list(transformer_backbone.named_parameters()):
+            if value.shape[0] == self.base_model.config.vocab_size:
+                self.word_embeddings = transformer_backbone.get_submodule(named_param.replace(".weight", ""))
+                break
+
+        if self.peft_config.peft_type == PeftType.PROMPT_TUNING:
+            prompt_encoder = PromptEmbedding(self.peft_config, self.word_embeddings)
+        elif self.peft_config.peft_type == PeftType.P_TUNING:
+            prompt_encoder = PromptEncoder(self.peft_config)
+        elif self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            prompt_encoder = PrefixEncoder(self.peft_config)
+        else:
+            raise ValueError("Not supported")
+        self.prompt_encoder = prompt_encoder
+        self.prompt_tokens = torch.arange(
+            self.peft_config.num_virtual_tokens * self.peft_config.num_transformer_submodules
+        ).long()
+
+    def get_prompt_embedding_to_save(self):
+        """
+        Returns the prompt embedding to save when saving the model. Only applicable when `peft_config.peft_type !=
+        PeftType.LORA`.
+        """
+        prompt_tokens = self.prompt_tokens.unsqueeze(0).expand(1, -1).to(self.device)
+        if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            prompt_tokens = prompt_tokens[:, : self.peft_config.num_virtual_tokens]
+        prompt_embeddings = self.prompt_encoder(prompt_tokens)
+        return prompt_embeddings[0].detach().cpu()
+
+    def get_prompt(self, batch_size):
+        """
+        Returns the virtual prompts to use for Peft. Only applicable when `peft_config.peft_type != PeftType.LORA`.
+        """
+        prompt_tokens = self.prompt_tokens.unsqueeze(0).expand(batch_size, -1).to(self.device)
+        if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            prompt_tokens = prompt_tokens[:, : self.peft_config.num_virtual_tokens]
+            if self.peft_config.inference_mode:
+                past_key_values = self.prompt_encoder.embedding.weight.repeat(batch_size, 1, 1)
+            else:
+                past_key_values = self.prompt_encoder(prompt_tokens)
+            past_key_values = past_key_values.view(
+                batch_size,
+                self.peft_config.num_virtual_tokens,
+                self.peft_config.num_layers * 2,
+                self.peft_config.num_attention_heads,
+                self.peft_config.token_dim // self.peft_config.num_attention_heads,
+            )
+            if self.peft_config.num_transformer_submodules == 2:
+                past_key_values = torch.cat([past_key_values, past_key_values], dim=2)
+            past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(
+                self.peft_config.num_transformer_submodules * 2
+            )
+            if TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING.get(self.config.model_type, None) is not None:
+                post_process_fn = TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING[self.config.model_type]
+                past_key_values = post_process_fn(past_key_values)
+            return past_key_values
+        else:
+            if self.peft_config.inference_mode:
+                prompts = self.prompt_encoder.embedding.weight.repeat(batch_size, 1, 1)
+            else:
+                prompts = self.prompt_encoder(prompt_tokens)
+            return prompts
+
+    def print_trainable_parameters(self):
+        """
+        Prints the number of trainable parameters in the model.
+        """
+        trainable_params = 0
+        all_param = 0
+        for _, param in self.named_parameters():
+            num_params = param.numel()
+            # if using DS Zero 3 and the weights are initialized empty
+            if num_params == 0 and hasattr(param, "ds_numel"):
+                num_params = param.ds_numel
+
+            all_param += num_params
+            if param.requires_grad:
+                # print(f'trainable, name: {_}, params: {param}')
+                trainable_params += num_params
+            # else:
+            #     print(f'freeze, name: {_}, params: {param}')
+        print(
+            f"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}"
+        )
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            return getattr(self.base_model, name)
+
+    def forward(self, *args, **kwargs):  # pylint: disable=E0202
+        """
+        Forward pass of the model.
+        """
+        return self.get_base_model()(*args, **kwargs)
+
+    @contextmanager
+    def disable_adapter(self):
+        """
+        Disables the adapter module.
+        """
+        if isinstance(self.peft_config, PromptLearningConfig):
+            old_forward = self.forward
+            self.forward = self.base_model.forward
+        else:
+            self.base_model.disable_adapter_layers()
+        yield
+        if isinstance(self.peft_config, PromptLearningConfig):
+            self.forward = old_forward
+        else:
+            self.base_model.enable_adapter_layers()
+
+    def get_base_model(self):
+        """
+        Returns the base model.
+        """
+        return self.base_model if isinstance(self.peft_config, PromptLearningConfig) else self.base_model.model
+
+
+class PeftModelForSequenceClassification(PeftModel):
+    """
+    Peft model for sequence classification tasks.
+
+    Args:
+        model ([`PreTrainedModel`]): Base transformer model
+        peft_config ([`PeftConfig`]): Peft config.
+
+    **Attributes**:
+        - **config** ([`PretrainedConfig`]) -- The configuration object of the base model.
+        - **cls_layer_name** (`str`) -- The name of the classification layer.
+
+    Example::
+
+        >>> from transformers import AutoModelForSequenceClassification >>> from peft import
+        PeftModelForSequenceClassification, get_peft_config >>> config = {
+                'peft_type': 'PREFIX_TUNING', 'task_type': 'SEQ_CLS', 'inference_mode': False, 'num_virtual_tokens':
+                20, 'token_dim': 768, 'num_transformer_submodules': 1, 'num_attention_heads': 12, 'num_layers': 12,
+                'encoder_hidden_size': 768, 'prefix_projection': False, 'postprocess_past_key_value_function': None
+            }
+        >>> peft_config = get_peft_config(config) >>> model =
+        AutoModelForSequenceClassification.from_pretrained("bert-base-cased") >>> peft_model =
+        PeftModelForSequenceClassification(model, peft_config) >>> peft_model.print_trainable_parameters() trainable
+        params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117
+    """
+
+    def __init__(self, model, peft_config: PeftConfig):
+        super().__init__(model, peft_config)
+        self.modules_to_save = ["classifier", "score"]
+
+        for name, _ in self.base_model.named_children():
+            if any(module_name in name for module_name in self.modules_to_save):
+                self.cls_layer_name = name
+                break
+
+        # to make sure classifier layer is trainable
+        _set_trainable(self)
+
+    def forward(    # pylint: disable=W0221
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if not isinstance(self.peft_config, PromptLearningConfig):
+            return self.base_model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                inputs_embeds=inputs_embeds,
+                labels=labels,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+                **kwargs,
+            )
+
+        batch_size = input_ids.shape[0]
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, self.peft_config.num_virtual_tokens).to(self.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get("position_ids", None) is not None:
+            warnings.warn("Position ids are not supported for parameter efficient tuning. Ignoring position ids.")
+            kwargs["position_ids"] = None
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get("token_type_ids", None) is not None:
+                kwargs["token_type_ids"] = torch.cat(
+                    (
+                        torch.zeros(batch_size, self.peft_config.num_virtual_tokens).to(self.device),
+                        kwargs["token_type_ids"],
+                    ),
+                    dim=1,
+                ).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        batch_size = input_ids.shape[0]
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update(
+            {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "inputs_embeds": inputs_embeds,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+                "past_key_values": past_key_values,
+            }
+        )
+        if "past_key_values" in fwd_params:
+            return self.base_model(labels=labels, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if "past_key_values" not in fwd_params:
+                raise ValueError("Model does not support past key values which are required for prefix tuning.")
+            outputs = transformer_backbone_name(**kwargs)
+            pooled_output = outputs[1] if len(outputs) > 1 else outputs[0]
+            if "dropout" in [name for name, _ in list(self.base_model.named_children())]:
+                pooled_output = self.base_model.dropout(pooled_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(pooled_output)
+
+            loss = None
+            if labels is not None:
+                if self.config.problem_type is None:
+                    if self.base_model.num_labels == 1:
+                        self.config.problem_type = "regression"
+                    elif self.base_model.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                        self.config.problem_type = "single_label_classification"
+                    else:
+                        self.config.problem_type = "multi_label_classification"
+
+                if self.config.problem_type == "regression":
+                    loss_fct = MSELoss()
+                    if self.base_model.num_labels == 1:
+                        loss = loss_fct(logits.squeeze(), labels.squeeze())
+                    else:
+                        loss = loss_fct(logits, labels)
+                elif self.config.problem_type == "single_label_classification":
+                    loss_fct = CrossEntropyLoss()
+                    loss = loss_fct(logits.view(-1, self.base_model.num_labels), labels.view(-1))
+                elif self.config.problem_type == "multi_label_classification":
+                    loss_fct = BCEWithLogitsLoss()
+                    loss = loss_fct(logits, labels)
+            if not return_dict:
+                output = (logits,) + outputs[2:]
+                return ((loss,) + output) if loss is not None else output
+
+            return SequenceClassifierOutput(
+                loss=loss,
+                logits=logits,
+                hidden_states=outputs.hidden_states,
+                attentions=outputs.attentions,
+            )
+
+
+class PeftModelForCausalLM(PeftModel):
+    """
+    Peft model for Causal LM
+
+    Args:
+        model ([`PreTrainedModel`]): Base transformer model
+        peft_config ([`PeftConfig`]): Peft config.
+
+
+    Example::
+
+        >>> from transformers import AutoModelForCausalLM >>> from peft import PeftModelForCausalLM, get_peft_config
+        >>> config = {
+                'peft_type': 'PREFIX_TUNING', 'task_type': 'CAUSAL_LM', 'inference_mode': False, 'num_virtual_tokens':
+                20, 'token_dim': 1280, 'num_transformer_submodules': 1, 'num_attention_heads': 20, 'num_layers': 36,
+                'encoder_hidden_size': 1280, 'prefix_projection': False, 'postprocess_past_key_value_function': None
+            }
+        >>> peft_config = get_peft_config(config) >>> model = AutoModelForCausalLM.from_pretrained("gpt2-large") >>>
+        peft_model = PeftModelForCausalLM(model, peft_config) >>> peft_model.print_trainable_parameters() trainable
+    """
+
+    def __init__(self, model, peft_config: PeftConfig): # casualLM, LoraConfig
+        super().__init__(model, peft_config)
+        self.base_model_prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+
+    def forward(# pylint: disable=W0221
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        # task_types=None,
+        **kwargs,
+    ):
+        if not isinstance(self.peft_config, PromptLearningConfig): # here
+            return self.base_model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                inputs_embeds=inputs_embeds,
+                labels=labels,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+                # task_types=task_types,
+                **kwargs,
+            )
+
+        batch_size = input_ids.shape[0]
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, self.peft_config.num_virtual_tokens).to(self.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+
+        if kwargs.get("position_ids", None) is not None:
+            warnings.warn("Position ids are not supported for parameter efficient tuning. Ignoring position ids.")
+            kwargs["position_ids"] = None
+        if kwargs.get("token_type_ids", None) is not None:
+            warnings.warn("Token type ids are not supported for parameter efficient tuning. Ignoring token type ids")
+            kwargs["token_type_ids"] = None
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            past_key_values = self.get_prompt(batch_size)
+            return self.base_model(input_ids=input_ids, past_key_values=past_key_values, **kwargs)
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            # concat prompt labels
+            if labels is not None:
+                prefix_labels = torch.full((batch_size, self.peft_config.num_virtual_tokens), -100).to(self.device)
+                kwargs["labels"] = torch.cat((prefix_labels, labels), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def generate(self, **kwargs):
+        self.base_model.prepare_inputs_for_generation = self.prepare_inputs_for_generation
+        try:
+            outputs = self.base_model.generate(**kwargs)
+        except:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            raise
+        else:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            return outputs
+
+    def prepare_inputs_for_generation(self, *args, **kwargs):
+        model_kwargs = self.base_model_prepare_inputs_for_generation(*args, **kwargs)
+        if isinstance(self.peft_config, PromptLearningConfig):
+            if model_kwargs["past_key_values"] is None and self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+                past_key_values = self.get_prompt(batch_size=model_kwargs["input_ids"].shape[0])
+                model_kwargs["past_key_values"] = past_key_values
+            else:
+                if model_kwargs["past_key_values"] is None:
+                    inputs_embeds = self.word_embeddings(model_kwargs["input_ids"])
+                    prompts = self.get_prompt(batch_size=model_kwargs["input_ids"].shape[0])
+                    prompts = prompts.to(inputs_embeds.dtype)
+                    model_kwargs["inputs_embeds"] = torch.cat((prompts, inputs_embeds), dim=1)
+                    model_kwargs["input_ids"] = None
+
+        return model_kwargs
+
+
+
+class PeftModelForSeq2SeqLM(PeftModel):
+    """
+    Peft model for Seq2Seq LM
+
+    Args:
+        model ([`PreTrainedModel`]): Base transformer model
+        peft_config ([`PeftConfig`]): Peft config.
+
+
+    Example::
+
+        >>> from transformers import AutoModelForSeq2SeqLM >>> from peft import PeftModelForSeq2SeqLM, get_peft_config
+        >>> config = {
+                'peft_type': 'LORA', 'task_type': 'SEQ_2_SEQ_LM', 'inference_mode': False, 'r': 8, 'target_modules':
+                ['q', 'v'], 'lora_alpha': 32, 'lora_dropout': 0.1, 'merge_weights': False, 'fan_in_fan_out': False,
+                'enable_lora': None, 'bias': 'none'
+            }
+        >>> peft_config = get_peft_config(config) >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base") >>>
+        peft_model = PeftModelForSeq2SeqLM(model, peft_config) >>> peft_model.print_trainable_parameters() trainable
+        params: 884736 || all params: 223843584 || trainable%: 0.3952474242013566
+    """
+
+    def __init__(self, model, peft_config: PeftConfig):
+        super().__init__(model, peft_config)
+        self.base_model_prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+        self.base_model_prepare_encoder_decoder_kwargs_for_generation = (
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation
+        )
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        decoder_input_ids=None,
+        decoder_attention_mask=None,
+        decoder_inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        if not isinstance(self.peft_config, PromptLearningConfig):
+            return self.base_model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                inputs_embeds=inputs_embeds,
+                decoder_input_ids=decoder_input_ids,
+                decoder_attention_mask=decoder_attention_mask,
+                decoder_inputs_embeds=decoder_inputs_embeds,
+                labels=labels,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+                **kwargs,
+            )
+
+        batch_size = input_ids.shape[0]
+        if decoder_attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, self.peft_config.num_virtual_tokens).to(self.device)
+            decoder_attention_mask = torch.cat((prefix_attention_mask, decoder_attention_mask), dim=1)
+
+        if kwargs.get("position_ids", None) is not None:
+            warnings.warn("Position ids are not supported for parameter efficient tuning. Ignoring position ids.")
+            kwargs["position_ids"] = None
+        if kwargs.get("token_type_ids", None) is not None:
+            warnings.warn("Token type ids are not supported for parameter efficient tuning. Ignoring token type ids")
+            kwargs["token_type_ids"] = None
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "decoder_attention_mask": decoder_attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            past_key_values = self.get_prompt(batch_size)
+            return self.base_model(
+                input_ids=input_ids, decoder_input_ids=decoder_input_ids, past_key_values=past_key_values, **kwargs
+            )
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            if decoder_inputs_embeds is None and decoder_input_ids is None:
+                decoder_input_ids = shift_tokens_right(
+                    labels, self.config.pad_token_id, self.config.decoder_start_token_id
+                )
+                decoder_inputs_embeds = self.word_embeddings(decoder_input_ids)
+
+            if attention_mask is not None:
+                # concat prompt attention mask
+                prefix_attention_mask = torch.ones(batch_size, self.peft_config.num_virtual_tokens).to(self.device)
+                kwargs["attention_mask"] = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+            # concat prompt labels
+            if labels is not None:
+                if self.peft_config.num_transformer_submodules == 1:
+                    kwargs["labels"] = labels
+                elif self.peft_config.num_transformer_submodules == 2:
+                    prefix_labels = torch.full((batch_size, self.peft_config.num_virtual_tokens), -100).to(self.device)
+                    kwargs["labels"] = torch.cat((prefix_labels, labels), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts[:, : self.peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+            if self.peft_config.num_transformer_submodules == 1:
+                return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+            elif self.peft_config.num_transformer_submodules == 2:
+                decoder_inputs_embeds = torch.cat(
+                    (prompts[:, self.peft_config.num_virtual_tokens :], decoder_inputs_embeds), dim=1
+                )
+                return self.base_model(
+                    inputs_embeds=inputs_embeds, decoder_inputs_embeds=decoder_inputs_embeds, **kwargs
+                )
+
+    def generate(self, **kwargs):
+        self.base_model.prepare_inputs_for_generation = self.prepare_inputs_for_generation
+        self.base_model._prepare_encoder_decoder_kwargs_for_generation = (
+            self._prepare_encoder_decoder_kwargs_for_generation
+        )
+        try:
+            if not isinstance(self.peft_config, PromptLearningConfig):
+                outputs = self.base_model.generate(**kwargs)
+            else:
+                if "input_ids" not in kwargs:
+                    raise ValueError("input_ids must be provided for Peft model generation")
+                if kwargs.get("position_ids", None) is not None:
+                    warnings.warn(
+                        "Position ids are not supported for parameter efficient tuning. Ignoring position ids."
+                    )
+                    kwargs["position_ids"] = None
+                if kwargs.get("token_type_ids", None) is not None:
+                    warnings.warn(
+                        "Token type ids are not supported for parameter efficient tuning. Ignoring token type ids"
+                    )
+                    kwargs["token_type_ids"] = None
+
+                if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+                    outputs = self.base_model.generate(**kwargs)
+                else:
+                    raise NotImplementedError
+        except:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation = (
+                self.base_model_prepare_encoder_decoder_kwargs_for_generation
+            )
+            raise
+        else:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation = (
+                self.base_model_prepare_encoder_decoder_kwargs_for_generation
+            )
+            return outputs
+
+    def prepare_inputs_for_generation(self, *args, **kwargs):
+        model_kwargs = self.base_model_prepare_inputs_for_generation(*args, **kwargs)
+        if model_kwargs["past_key_values"] is None and self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            batch_size = model_kwargs["decoder_input_ids"].shape[0]
+            past_key_values = self.get_prompt(batch_size)
+            model_kwargs["past_key_values"] = past_key_values
+        return model_kwargs
+
+
+class PeftModelForTokenClassification(PeftModel):
+    """
+    Peft model for sequence classification tasks.
+
+    Args:
+        model ([`PreTrainedModel`]): Base transformer model
+        peft_config ([`PeftConfig`]): Peft config.
+
+    **Attributes**:
+        - **config** ([`PretrainedConfig`]) -- The configuration object of the base model.
+        - **cls_layer_name** (`str`) -- The name of the classification layer.
+
+    Example::
+
+        >>> from transformers import AutoModelForSequenceClassification >>> from peft import
+        PeftModelForTokenClassification, get_peft_config >>> config = {
+                'peft_type': 'PREFIX_TUNING', 'task_type': 'TOKEN_CLS', 'inference_mode': False, 'num_virtual_tokens':
+                20, 'token_dim': 768, 'num_transformer_submodules': 1, 'num_attention_heads': 12, 'num_layers': 12,
+                'encoder_hidden_size': 768, 'prefix_projection': False, 'postprocess_past_key_value_function': None
+            }
+        >>> peft_config = get_peft_config(config) >>> model =
+        AutoModelForTokenClassification.from_pretrained("bert-base-cased") >>> peft_model =
+        PeftModelForTokenClassification(model, peft_config) >>> peft_model.print_trainable_parameters() trainable
+        params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117
+    """
+
+    def __init__(self, model, peft_config: PeftConfig):
+        super().__init__(model, peft_config)
+        self.modules_to_save = ["classifier", "score"]
+
+        for name, _ in self.base_model.named_children():
+            if any(module_name in name for module_name in self.modules_to_save):
+                self.cls_layer_name = name
+                break
+
+        # to make sure classifier layer is trainable
+        _set_trainable(self)
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if not isinstance(self.peft_config, PromptLearningConfig):
+            return self.base_model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                inputs_embeds=inputs_embeds,
+                labels=labels,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+                **kwargs,
+            )
+
+        batch_size = input_ids.shape[0]
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, self.peft_config.num_virtual_tokens).to(self.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get("position_ids", None) is not None:
+            warnings.warn("Position ids are not supported for parameter efficient tuning. Ignoring position ids.")
+            kwargs["position_ids"] = None
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if self.peft_config.peft_type == PeftType.PREFIX_TUNING:
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get("token_type_ids", None) is not None:
+                kwargs["token_type_ids"] = torch.cat(
+                    (
+                        torch.zeros(batch_size, self.peft_config.num_virtual_tokens).to(self.device),
+                        kwargs["token_type_ids"],
+                    ),
+                    dim=1,
+                ).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        batch_size = input_ids.shape[0]
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update(
+            {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "inputs_embeds": inputs_embeds,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+                "past_key_values": past_key_values,
+            }
+        )
+        if "past_key_values" in fwd_params:
+            return self.base_model(labels=labels, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if "past_key_values" not in fwd_params:
+                raise ValueError("Model does not support past key values which are required for prefix tuning.")
+            outputs = transformer_backbone_name(**kwargs)
+            sequence_output = outputs[0]
+            if "dropout" in [name for name, _ in list(self.base_model.named_children())]:
+                sequence_output = self.base_model.dropout(sequence_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(sequence_output)
+
+            loss = None
+            loss = None
+            if labels is not None:
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+            if not return_dict:
+                output = (logits,) + outputs[2:]
+                return ((loss,) + output) if loss is not None else output
+
+            return TokenClassifierOutput(
+                loss=loss,
+                logits=logits,
+                hidden_states=outputs.hidden_states,
+                attentions=outputs.attentions,
+            )

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/peft/tuners/__init__.py

@@ -0,0 +1,23 @@
+# flake8: noqa
+# There's no way to ignore "F401 '...' imported but unused" warnings in this
+# module, but to preserve other warnings. So, don't check this module at all
+
+# coding=utf-8
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .lora import LoraConfig, LoraModel
+from .p_tuning import PromptEncoder, PromptEncoderConfig, PromptEncoderReparameterizationType
+from .prefix_tuning import PrefixEncoder, PrefixTuningConfig
+from .prompt_tuning import PromptEmbedding, PromptTuningConfig, PromptTuningInit

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/peft/tuners/p_tuning.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+import warnings
+from dataclasses import dataclass, field
+from typing import Union
+
+import torch
+
+from ..utils import PeftType, PromptLearningConfig
+
+
+class PromptEncoderReparameterizationType(str, enum.Enum):
+    MLP = "MLP"
+    LSTM = "LSTM"
+
+
+@dataclass
+class PromptEncoderConfig(PromptLearningConfig):
+    """
+    This is the configuration class to store the configuration of a [`~peft.PromptEncoder`].
+
+    Args:
+        encoder_reparameterization_type
+            (Union[[`PromptEncoderReparameterizationType`], `str`]): The type of reparameterization to use.
+        encoder_hidden_size (`int`): The hidden size of the prompt encoder.
+        encoder_num_layers (`int`): The number of layers of the prompt encoder.
+        encoder_dropout (`float`): The dropout probability of the prompt encoder.
+    """
+
+    encoder_reparameterization_type: Union[str, PromptEncoderReparameterizationType] = field(
+        default=PromptEncoderReparameterizationType.MLP,
+        metadata={"help": "How to reparameterize the prompt encoder"},
+    )
+    encoder_hidden_size: int = field(
+        default=None,
+        metadata={"help": "The hidden size of the prompt encoder"},
+    )
+    encoder_num_layers: int = field(
+        default=2,
+        metadata={"help": "The number of layers of the prompt encoder"},
+    )
+    encoder_dropout: float = field(
+        default=0.0,
+        metadata={"help": "The dropout of the prompt encoder"},
+    )
+
+    def __post_init__(self):
+        self.peft_type = PeftType.P_TUNING
+
+
+# Based on https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/nlp/modules/common/prompt_encoder.py
+# with some refactor
+class PromptEncoder(torch.nn.Module):
+    """
+    The prompt encoder network that is used to generate the virtual token embeddings for p-tuning.
+
+    Args:
+        config ([`PromptEncoderConfig`]): The configuration of the prompt encoder.
+
+    Example::
+
+        >>> from peft import PromptEncoder, PromptEncoderConfig >>> config = PromptEncoderConfig(
+                peft_type="P_TUNING", task_type="SEQ_2_SEQ_LM", num_virtual_tokens=20, token_dim=768,
+                num_transformer_submodules=1, num_attention_heads=12, num_layers=12,
+                encoder_reparameterization_type="MLP", encoder_hidden_size=768
+            )
+        >>> prompt_encoder = PromptEncoder(config)
+
+    **Attributes**:
+        - **embedding** ([`~torch.nn.Embedding`]) -- The embedding layer of the prompt encoder.
+        - **mlp_head** ([`~torch.nn.Sequential`]) -- The MLP head of the prompt encoder if `inference_mode=False`.
+        - **lstm_head** ([`~torch.nn.LSTM`]) -- The LSTM head of the prompt encoder if `inference_mode=False` and
+        `encoder_reparameterization_type="LSTM"`.
+        - **token_dim** (`int`) -- The hidden embedding dimension of the base transformer model.
+        - **input_size** (`int`) -- The input size of the prompt encoder.
+        - **output_size** (`int`) -- The output size of the prompt encoder.
+        - **hidden_size** (`int`) -- The hidden size of the prompt encoder.
+        - **total_virtual_tokens** (`int`): The total number of virtual tokens of the
+        prompt encoder.
+        - **encoder_type** (Union[[`PromptEncoderReparameterizationType`], `str`]):
+            The encoder type of the prompt encoder.
+
+
+    Input shape: (batch_size, total_virtual_tokens)
+
+    Output shape: (batch_size, total_virtual_tokens, token_dim)
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.token_dim = config.token_dim
+        self.input_size = self.token_dim
+        self.output_size = self.token_dim
+        self.hidden_size = config.encoder_hidden_size
+        self.total_virtual_tokens = config.num_virtual_tokens * config.num_transformer_submodules
+        self.encoder_type = config.encoder_reparameterization_type
+
+        # embedding
+        self.embedding = torch.nn.Embedding(self.total_virtual_tokens, self.token_dim)
+        if not config.inference_mode:
+            if self.encoder_type == PromptEncoderReparameterizationType.LSTM:
+                lstm_dropout = config.encoder_dropout
+                num_layers = config.encoder_num_layers
+                # LSTM
+                self.lstm_head = torch.nn.LSTM(
+                    input_size=self.input_size,
+                    hidden_size=self.hidden_size,
+                    num_layers=num_layers,
+                    dropout=lstm_dropout,
+                    bidirectional=True,
+                    batch_first=True,
+                )
+
+                self.mlp_head = torch.nn.Sequential(
+                    torch.nn.Linear(self.hidden_size * 2, self.hidden_size * 2),
+                    torch.nn.ReLU(),
+                    torch.nn.Linear(self.hidden_size * 2, self.output_size),
+                )
+
+            elif self.encoder_type == PromptEncoderReparameterizationType.MLP:
+                warnings.warn(
+                    f"for {self.encoder_type}, the `encoder_num_layers` is ignored. Exactly 2 MLP layers are used."
+                )
+                layers = [
+                    torch.nn.Linear(self.input_size, self.hidden_size),
+                    torch.nn.ReLU(),
+                    torch.nn.Linear(self.hidden_size, self.hidden_size),
+                    torch.nn.ReLU(),
+                    torch.nn.Linear(self.hidden_size, self.output_size),
+                ]
+                self.mlp_head = torch.nn.Sequential(*layers)
+
+            else:
+                raise ValueError("Prompt encoder type not recognized. Please use one of MLP (recommended) or LSTM.")
+
+    def forward(self, indices):
+        input_embeds = self.embedding(indices)
+        if self.encoder_type == PromptEncoderReparameterizationType.LSTM:
+            output_embeds = self.mlp_head(self.lstm_head(input_embeds)[0])
+        elif self.encoder_type == PromptEncoderReparameterizationType.MLP:
+            output_embeds = self.mlp_head(input_embeds)
+        else:
+            raise ValueError("Prompt encoder type not recognized. Please use one of MLP (recommended) or LSTM.")
+
+        return output_embeds

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/peft/tuners/prompt_tuning.py

@@ -0,0 +1,120 @@
+# coding=utf-8
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+import math
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+import torch
+
+from ..utils import PeftType, PromptLearningConfig
+
+
+class PromptTuningInit(str, enum.Enum):
+    TEXT = "TEXT"
+    RANDOM = "RANDOM"
+
+
+@dataclass
+class PromptTuningConfig(PromptLearningConfig):
+    """
+    This is the configuration class to store the configuration of a [`~peft.PromptEmbedding`].
+
+    Args:
+        prompt_tuning_init (Union[[`PromptTuningInit`], `str`]): The initialization of the prompt embedding.
+        prompt_tuning_init_text ( Optional[`str`]): The text to initialize the prompt embedding.
+            Only used if `prompt_tuning_init` is `TEXT`
+        tokenizer_name_or_path ( Optional[`str`]): The name or path of the tokenizer.
+            Only used if `prompt_tuning_init` is `TEXT`
+    """
+
+    prompt_tuning_init: Union[PromptTuningInit, str] = field(
+        default=PromptTuningInit.RANDOM,
+        metadata={"help": "How to initialize the prompt tuning parameters"},
+    )
+    prompt_tuning_init_text: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The text to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`"
+        },
+    )
+    tokenizer_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The tokenizer to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`"
+        },
+    )
+
+    def __post_init__(self):
+        self.peft_type = PeftType.PROMPT_TUNING
+
+
+class PromptEmbedding(torch.nn.Module):
+    """
+    The model to encode virtual tokens into prompt embeddings.
+
+    Args:
+        config ([`PromptTuningConfig`]): The configuration of the prompt embedding.
+        word_embeddings (`torch.nn.Module`): The word embeddings of the base transformer model.
+
+    **Attributes**:
+        **embedding** (`torch.nn.Embedding`) -- The embedding layer of the prompt embedding.
+
+    Example::
+
+        >>> from peft import PromptEmbedding, PromptTuningConfig >>> config = PromptTuningConfig(
+                peft_type="PROMPT_TUNING", task_type="SEQ_2_SEQ_LM", num_virtual_tokens=20, token_dim=768,
+                num_transformer_submodules=1, num_attention_heads=12, num_layers=12, prompt_tuning_init="TEXT",
+                prompt_tuning_init_text="Predict if sentiment of this review is positive, negative or neutral",
+                tokenizer_name_or_path="t5-base",
+            )
+        >>> # t5_model.shared is the word embeddings of the base model >>> prompt_embedding = PromptEmbedding(config,
+        t5_model.shared)
+
+
+    Input Shape: (batch_size, total_virtual_tokens)
+
+    Output Shape: (batch_size, total_virtual_tokens, token_dim)
+    """
+
+    def __init__(self, config, word_embeddings):
+        super().__init__()
+
+        total_virtual_tokens = config.num_virtual_tokens * config.num_transformer_submodules
+        self.embedding = torch.nn.Embedding(total_virtual_tokens, config.token_dim)
+        if config.prompt_tuning_init == PromptTuningInit.TEXT:
+            from transformers import AutoTokenizer
+
+            tokenizer = AutoTokenizer.from_pretrained(config.tokenizer_name_or_path)
+            init_text = config.prompt_tuning_init_text
+            init_token_ids = tokenizer(init_text)["input_ids"]
+            # Trim or iterate until num_text_tokens matches total_virtual_tokens
+            num_text_tokens = len(init_token_ids)
+            if num_text_tokens > total_virtual_tokens:
+                init_token_ids = init_token_ids[:total_virtual_tokens]
+            elif num_text_tokens < total_virtual_tokens:
+                num_reps = math.ceil(total_virtual_tokens / num_text_tokens)
+                init_token_ids = init_token_ids * num_reps
+            init_token_ids = init_token_ids[:total_virtual_tokens]
+
+            word_embedding_weights = word_embeddings(torch.LongTensor(init_token_ids)).detach().clone()
+            word_embedding_weights = word_embedding_weights.to(torch.float32)
+            self.embedding.weight = torch.nn.Parameter(word_embedding_weights)
+
+    def forward(self, indices):
+        # Just get embeddings
+        prompt_embeddings = self.embedding(indices)
+        return prompt_embeddings

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/serve/cli.py

@@ -0,0 +1,126 @@
+import argparse
+import torch
+
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from llava.conversation import conv_templates, SeparatorStyle
+from llava.model.builder import load_pretrained_model
+from llava.utils import disable_torch_init
+from llava.mm_utils import process_images, tokenizer_image_token, get_model_name_from_path
+
+from PIL import Image
+
+import requests
+from PIL import Image
+from io import BytesIO
+from transformers import TextStreamer
+
+
+def load_image(image_file):
+    if image_file.startswith('http://') or image_file.startswith('https://'):
+        response = requests.get(image_file)
+        image = Image.open(BytesIO(response.content)).convert('RGB')
+    else:
+        image = Image.open(image_file).convert('RGB')
+    return image
+
+
+def main(args):
+    # Model
+    disable_torch_init()
+
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name, args.load_8bit, args.load_4bit, device=args.device)
+
+    if "llama-2" in model_name.lower():
+        conv_mode = "llava_llama_2"
+    elif "mistral" in model_name.lower():
+        conv_mode = "mistral_instruct"
+    elif "v1.6-34b" in model_name.lower():
+        conv_mode = "chatml_direct"
+    elif "v1" in model_name.lower():
+        conv_mode = "llava_v1"
+    elif "mpt" in model_name.lower():
+        conv_mode = "mpt"
+    else:
+        conv_mode = "llava_v0"
+
+    if args.conv_mode is not None and conv_mode != args.conv_mode:
+        print('[WARNING] the auto inferred conversation mode is {}, while `--conv-mode` is {}, using {}'.format(conv_mode, args.conv_mode, args.conv_mode))
+    else:
+        args.conv_mode = conv_mode
+
+    conv = conv_templates[args.conv_mode].copy()
+    if "mpt" in model_name.lower():
+        roles = ('user', 'assistant')
+    else:
+        roles = conv.roles
+
+    image = load_image(args.image_file)
+    image_size = image.size
+    # Similar operation in model_worker.py
+    image_tensor = process_images([image], image_processor, model.config)
+    if type(image_tensor) is list:
+        image_tensor = [image.to(model.device, dtype=torch.float16) for image in image_tensor]
+    else:
+        image_tensor = image_tensor.to(model.device, dtype=torch.float16)
+
+    while True:
+        try:
+            inp = input(f"{roles[0]}: ")
+        except EOFError:
+            inp = ""
+        if not inp:
+            print("exit...")
+            break
+
+        print(f"{roles[1]}: ", end="")
+
+        if image is not None:
+            # first message
+            if model.config.mm_use_im_start_end:
+                inp = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + inp
+            else:
+                inp = DEFAULT_IMAGE_TOKEN + '\n' + inp
+            image = None
+        
+        conv.append_message(conv.roles[0], inp)
+        conv.append_message(conv.roles[1], None)
+        prompt = conv.get_prompt()
+
+        input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(model.device)
+        stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
+        keywords = [stop_str]
+        streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+        with torch.inference_mode():
+            output_ids = model.generate(
+                input_ids,
+                images=image_tensor,
+                image_sizes=[image_size],
+                do_sample=True if args.temperature > 0 else False,
+                temperature=args.temperature,
+                max_new_tokens=args.max_new_tokens,
+                streamer=streamer,
+                use_cache=True)
+
+        outputs = tokenizer.decode(output_ids[0]).strip()
+        conv.messages[-1][-1] = outputs
+
+        if args.debug:
+            print("\n", {"prompt": prompt, "outputs": outputs}, "\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, default="facebook/opt-350m")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--image-file", type=str, required=True)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--conv-mode", type=str, default=None)
+    parser.add_argument("--temperature", type=float, default=0.2)
+    parser.add_argument("--max-new-tokens", type=int, default=512)
+    parser.add_argument("--load-8bit", action="store_true")
+    parser.add_argument("--load-4bit", action="store_true")
+    parser.add_argument("--debug", action="store_true")
+    args = parser.parse_args()
+    main(args)

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/serve/controller.py

@@ -0,0 +1,298 @@
+"""
+A controller manages distributed workers.
+It sends worker addresses to clients.
+"""
+import argparse
+import asyncio
+import dataclasses
+from enum import Enum, auto
+import json
+import logging
+import time
+from typing import List, Union
+import threading
+
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+import numpy as np
+import requests
+import uvicorn
+
+from llava.constants import CONTROLLER_HEART_BEAT_EXPIRATION
+from llava.utils import build_logger, server_error_msg
+
+
+logger = build_logger("controller", "controller.log")
+
+
+class DispatchMethod(Enum):
+    LOTTERY = auto()
+    SHORTEST_QUEUE = auto()
+
+    @classmethod
+    def from_str(cls, name):
+        if name == "lottery":
+            return cls.LOTTERY
+        elif name == "shortest_queue":
+            return cls.SHORTEST_QUEUE
+        else:
+            raise ValueError(f"Invalid dispatch method")
+
+
+@dataclasses.dataclass
+class WorkerInfo:
+    model_names: List[str]
+    speed: int
+    queue_length: int
+    check_heart_beat: bool
+    last_heart_beat: str
+
+
+def heart_beat_controller(controller):
+    while True:
+        time.sleep(CONTROLLER_HEART_BEAT_EXPIRATION)
+        controller.remove_stable_workers_by_expiration()
+
+
+class Controller:
+    def __init__(self, dispatch_method: str):
+        # Dict[str -> WorkerInfo]
+        self.worker_info = {}
+        self.dispatch_method = DispatchMethod.from_str(dispatch_method)
+
+        self.heart_beat_thread = threading.Thread(
+            target=heart_beat_controller, args=(self,), daemon=True)
+        self.heart_beat_thread.start()
+
+        logger.info("Init controller")
+
+    def register_worker(self, worker_name: str, check_heart_beat: bool,
+                        worker_status: dict):
+        if worker_name not in self.worker_info:
+            logger.info(f"Register a new worker: {worker_name}")
+        else:
+            logger.info(f"Register an existing worker: {worker_name}")
+
+        if not worker_status:
+            worker_status = self.get_worker_status(worker_name)
+        if not worker_status:
+            return False
+
+        self.worker_info[worker_name] = WorkerInfo(
+            worker_status["model_names"], worker_status["speed"], worker_status["queue_length"],
+            check_heart_beat, time.time())
+
+        logger.info(f"Register done: {worker_name}, {worker_status}")
+        return True
+
+    def get_worker_status(self, worker_name: str):
+        try:
+            r = requests.post(worker_name + "/worker_get_status", timeout=5)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Get status fails: {worker_name}, {e}")
+            return None
+
+        if r.status_code != 200:
+            logger.error(f"Get status fails: {worker_name}, {r}")
+            return None
+
+        return r.json()
+
+    def remove_worker(self, worker_name: str):
+        del self.worker_info[worker_name]
+
+    def refresh_all_workers(self):
+        old_info = dict(self.worker_info)
+        self.worker_info = {}
+
+        for w_name, w_info in old_info.items():
+            if not self.register_worker(w_name, w_info.check_heart_beat, None):
+                logger.info(f"Remove stale worker: {w_name}")
+
+    def list_models(self):
+        model_names = set()
+
+        for w_name, w_info in self.worker_info.items():
+            model_names.update(w_info.model_names)
+
+        return list(model_names)
+
+    def get_worker_address(self, model_name: str):
+        if self.dispatch_method == DispatchMethod.LOTTERY:
+            worker_names = []
+            worker_speeds = []
+            for w_name, w_info in self.worker_info.items():
+                if model_name in w_info.model_names:
+                    worker_names.append(w_name)
+                    worker_speeds.append(w_info.speed)
+            worker_speeds = np.array(worker_speeds, dtype=np.float32)
+            norm = np.sum(worker_speeds)
+            if norm < 1e-4:
+                return ""
+            worker_speeds = worker_speeds / norm
+            if True:  # Directly return address
+                pt = np.random.choice(np.arange(len(worker_names)),
+                    p=worker_speeds)
+                worker_name = worker_names[pt]
+                return worker_name
+
+            # Check status before returning
+            while True:
+                pt = np.random.choice(np.arange(len(worker_names)),
+                    p=worker_speeds)
+                worker_name = worker_names[pt]
+
+                if self.get_worker_status(worker_name):
+                    break
+                else:
+                    self.remove_worker(worker_name)
+                    worker_speeds[pt] = 0
+                    norm = np.sum(worker_speeds)
+                    if norm < 1e-4:
+                        return ""
+                    worker_speeds = worker_speeds / norm
+                    continue
+            return worker_name
+        elif self.dispatch_method == DispatchMethod.SHORTEST_QUEUE:
+            worker_names = []
+            worker_qlen = []
+            for w_name, w_info in self.worker_info.items():
+                if model_name in w_info.model_names:
+                    worker_names.append(w_name)
+                    worker_qlen.append(w_info.queue_length / w_info.speed)
+            if len(worker_names) == 0:
+                return ""
+            min_index = np.argmin(worker_qlen)
+            w_name = worker_names[min_index]
+            self.worker_info[w_name].queue_length += 1
+            logger.info(f"names: {worker_names}, queue_lens: {worker_qlen}, ret: {w_name}")
+            return w_name
+        else:
+            raise ValueError(f"Invalid dispatch method: {self.dispatch_method}")
+
+    def receive_heart_beat(self, worker_name: str, queue_length: int):
+        if worker_name not in self.worker_info:
+            logger.info(f"Receive unknown heart beat. {worker_name}")
+            return False
+
+        self.worker_info[worker_name].queue_length = queue_length
+        self.worker_info[worker_name].last_heart_beat = time.time()
+        logger.info(f"Receive heart beat. {worker_name}")
+        return True
+
+    def remove_stable_workers_by_expiration(self):
+        expire = time.time() - CONTROLLER_HEART_BEAT_EXPIRATION
+        to_delete = []
+        for worker_name, w_info in self.worker_info.items():
+            if w_info.check_heart_beat and w_info.last_heart_beat < expire:
+                to_delete.append(worker_name)
+
+        for worker_name in to_delete:
+            self.remove_worker(worker_name)
+
+    def worker_api_generate_stream(self, params):
+        worker_addr = self.get_worker_address(params["model"])
+        if not worker_addr:
+            logger.info(f"no worker: {params['model']}")
+            ret = {
+                "text": server_error_msg,
+                "error_code": 2,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+        try:
+            response = requests.post(worker_addr + "/worker_generate_stream",
+                json=params, stream=True, timeout=5)
+            for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"):
+                if chunk:
+                    yield chunk + b"\0"
+        except requests.exceptions.RequestException as e:
+            logger.info(f"worker timeout: {worker_addr}")
+            ret = {
+                "text": server_error_msg,
+                "error_code": 3,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+
+    # Let the controller act as a worker to achieve hierarchical
+    # management. This can be used to connect isolated sub networks.
+    def worker_api_get_status(self):
+        model_names = set()
+        speed = 0
+        queue_length = 0
+
+        for w_name in self.worker_info:
+            worker_status = self.get_worker_status(w_name)
+            if worker_status is not None:
+                model_names.update(worker_status["model_names"])
+                speed += worker_status["speed"]
+                queue_length += worker_status["queue_length"]
+
+        return {
+            "model_names": list(model_names),
+            "speed": speed,
+            "queue_length": queue_length,
+        }
+
+
+app = FastAPI()
+
+
+@app.post("/register_worker")
+async def register_worker(request: Request):
+    data = await request.json()
+    controller.register_worker(
+        data["worker_name"], data["check_heart_beat"],
+        data.get("worker_status", None))
+
+
+@app.post("/refresh_all_workers")
+async def refresh_all_workers():
+    models = controller.refresh_all_workers()
+
+
+@app.post("/list_models")
+async def list_models():
+    models = controller.list_models()
+    return {"models": models}
+
+
+@app.post("/get_worker_address")
+async def get_worker_address(request: Request):
+    data = await request.json()
+    addr = controller.get_worker_address(data["model"])
+    return {"address": addr}
+
+
+@app.post("/receive_heart_beat")
+async def receive_heart_beat(request: Request):
+    data = await request.json()
+    exist = controller.receive_heart_beat(
+        data["worker_name"], data["queue_length"])
+    return {"exist": exist}
+
+
+@app.post("/worker_generate_stream")
+async def worker_api_generate_stream(request: Request):
+    params = await request.json()
+    generator = controller.worker_api_generate_stream(params)
+    return StreamingResponse(generator)
+
+
+@app.post("/worker_get_status")
+async def worker_api_get_status(request: Request):
+    return controller.worker_api_get_status()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="localhost")
+    parser.add_argument("--port", type=int, default=21001)
+    parser.add_argument("--dispatch-method", type=str, choices=[
+        "lottery", "shortest_queue"], default="shortest_queue")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    controller = Controller(args.dispatch_method)
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/serve/model_worker.py

@@ -0,0 +1,288 @@
+"""
+A model worker executes the model.
+"""
+import argparse
+import asyncio
+import json
+import time
+import threading
+import uuid
+
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import StreamingResponse
+import requests
+import torch
+import uvicorn
+from functools import partial
+
+from llava.constants import WORKER_HEART_BEAT_INTERVAL
+from llava.utils import (build_logger, server_error_msg,
+    pretty_print_semaphore)
+from llava.model.builder import load_pretrained_model
+from llava.mm_utils import process_images, load_image_from_base64, tokenizer_image_token
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from transformers import TextIteratorStreamer
+from threading import Thread
+
+
+GB = 1 << 30
+
+worker_id = str(uuid.uuid4())[:6]
+logger = build_logger("model_worker", f"model_worker_{worker_id}.log")
+global_counter = 0
+
+model_semaphore = None
+
+
+def heart_beat_worker(controller):
+
+    while True:
+        time.sleep(WORKER_HEART_BEAT_INTERVAL)
+        controller.send_heart_beat()
+
+
+class ModelWorker:
+    def __init__(self, controller_addr, worker_addr,
+                 worker_id, no_register,
+                 model_path, model_base, model_name,
+                 load_8bit, load_4bit, device, use_flash_attn=False):
+        self.controller_addr = controller_addr
+        self.worker_addr = worker_addr
+        self.worker_id = worker_id
+        if model_path.endswith("/"):
+            model_path = model_path[:-1]
+        if model_name is None:
+            model_paths = model_path.split("/")
+            if model_paths[-1].startswith('checkpoint-'):
+                self.model_name = model_paths[-2] + "_" + model_paths[-1]
+            else:
+                self.model_name = model_paths[-1]
+        else:
+            self.model_name = model_name
+
+        self.device = device
+        logger.info(f"Loading the model {self.model_name} on worker {worker_id} ...")
+        self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
+            model_path, model_base, self.model_name, load_8bit, load_4bit, device=self.device, use_flash_attn=use_flash_attn)
+        self.is_multimodal = 'llava' in self.model_name.lower()
+
+        if not no_register:
+            self.register_to_controller()
+            self.heart_beat_thread = threading.Thread(
+                target=heart_beat_worker, args=(self,), daemon=True)
+            self.heart_beat_thread.start()
+
+    def register_to_controller(self):
+        logger.info("Register to controller")
+
+        url = self.controller_addr + "/register_worker"
+        data = {
+            "worker_name": self.worker_addr,
+            "check_heart_beat": True,
+            "worker_status": self.get_status()
+        }
+        r = requests.post(url, json=data)
+        assert r.status_code == 200
+
+    def send_heart_beat(self):
+        logger.info(f"Send heart beat. Models: {[self.model_name]}. "
+                    f"Semaphore: {pretty_print_semaphore(model_semaphore)}. "
+                    f"global_counter: {global_counter}")
+
+        url = self.controller_addr + "/receive_heart_beat"
+
+        while True:
+            try:
+                ret = requests.post(url, json={
+                    "worker_name": self.worker_addr,
+                    "queue_length": self.get_queue_length()}, timeout=5)
+                exist = ret.json()["exist"]
+                break
+            except requests.exceptions.RequestException as e:
+                logger.error(f"heart beat error: {e}")
+            time.sleep(5)
+
+        if not exist:
+            self.register_to_controller()
+
+    def get_queue_length(self):
+        if model_semaphore is None:
+            return 0
+        else:
+            return args.limit_model_concurrency - model_semaphore._value + (len(
+                model_semaphore._waiters) if model_semaphore._waiters is not None else 0)
+
+    def get_status(self):
+        return {
+            "model_names": [self.model_name],
+            "speed": 1,
+            "queue_length": self.get_queue_length(),
+        }
+
+    @torch.inference_mode()
+    def generate_stream(self, params):
+        tokenizer, model, image_processor = self.tokenizer, self.model, self.image_processor
+
+        prompt = params["prompt"]
+        ori_prompt = prompt
+        images = params.get("images", None)
+        num_image_tokens = 0
+        if images is not None and len(images) > 0 and self.is_multimodal:
+            if len(images) > 0:
+                if len(images) != prompt.count(DEFAULT_IMAGE_TOKEN):
+                    raise ValueError("Number of images does not match number of <image> tokens in prompt")
+
+                images = [load_image_from_base64(image) for image in images]
+                image_sizes = [image.size for image in images]
+                images = process_images(images, image_processor, model.config)
+
+                if type(images) is list:
+                    images = [image.to(self.model.device, dtype=torch.float16) for image in images]
+                else:
+                    images = images.to(self.model.device, dtype=torch.float16)
+
+                replace_token = DEFAULT_IMAGE_TOKEN
+                if getattr(self.model.config, 'mm_use_im_start_end', False):
+                    replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN
+                prompt = prompt.replace(DEFAULT_IMAGE_TOKEN, replace_token)
+
+                num_image_tokens = prompt.count(replace_token) * model.get_vision_tower().num_patches
+            else:
+                images = None
+                image_sizes = None
+            image_args = {"images": images, "image_sizes": image_sizes}
+        else:
+            images = None
+            image_args = {}
+
+        temperature = float(params.get("temperature", 1.0))
+        top_p = float(params.get("top_p", 1.0))
+        max_context_length = getattr(model.config, 'max_position_embeddings', 2048)
+        max_new_tokens = min(int(params.get("max_new_tokens", 256)), 1024)
+        stop_str = params.get("stop", None)
+        do_sample = True if temperature > 0.001 else False
+
+        input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(self.device)
+        keywords = [stop_str]
+        # stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
+        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True, timeout=15)
+
+        max_new_tokens = min(max_new_tokens, max_context_length - input_ids.shape[-1] - num_image_tokens)
+
+        if max_new_tokens < 1:
+            yield json.dumps({"text": ori_prompt + "Exceeds max token length. Please start a new conversation, thanks.", "error_code": 0}).encode() + b"\0"
+            return
+
+        thread = Thread(target=model.generate, kwargs=dict(
+            inputs=input_ids,
+            do_sample=do_sample,
+            temperature=temperature,
+            top_p=top_p,
+            max_new_tokens=max_new_tokens,
+            streamer=streamer,
+            use_cache=True,
+            **image_args
+        ))
+        thread.start()
+
+        generated_text = ori_prompt
+        for new_text in streamer:
+            generated_text += new_text
+            if generated_text.endswith(stop_str):
+                generated_text = generated_text[:-len(stop_str)]
+            yield json.dumps({"text": generated_text, "error_code": 0}).encode() + b"\0"
+
+    def generate_stream_gate(self, params):
+        try:
+            for x in self.generate_stream(params):
+                yield x
+        except ValueError as e:
+            print("Caught ValueError:", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+        except torch.cuda.CudaError as e:
+            print("Caught torch.cuda.CudaError:", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+        except Exception as e:
+            print("Caught Unknown Error", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+
+app = FastAPI()
+
+
+def release_model_semaphore(fn=None):
+    model_semaphore.release()
+    if fn is not None:
+        fn()
+
+
+@app.post("/worker_generate_stream")
+async def generate_stream(request: Request):
+    global model_semaphore, global_counter
+    global_counter += 1
+    params = await request.json()
+
+    if model_semaphore is None:
+        model_semaphore = asyncio.Semaphore(args.limit_model_concurrency)
+    await model_semaphore.acquire()
+    worker.send_heart_beat()
+    generator = worker.generate_stream_gate(params)
+    background_tasks = BackgroundTasks()
+    background_tasks.add_task(partial(release_model_semaphore, fn=worker.send_heart_beat))
+    return StreamingResponse(generator, background=background_tasks)
+
+
+@app.post("/worker_get_status")
+async def get_status(request: Request):
+    return worker.get_status()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="localhost")
+    parser.add_argument("--port", type=int, default=21002)
+    parser.add_argument("--worker-address", type=str,
+        default="http://localhost:21002")
+    parser.add_argument("--controller-address", type=str,
+        default="http://localhost:21001")
+    parser.add_argument("--model-path", type=str, default="facebook/opt-350m")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--model-name", type=str)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--multi-modal", action="store_true", help="Multimodal mode is automatically detected with model name, please make sure `llava` is included in the model path.")
+    parser.add_argument("--limit-model-concurrency", type=int, default=5)
+    parser.add_argument("--stream-interval", type=int, default=1)
+    parser.add_argument("--no-register", action="store_true")
+    parser.add_argument("--load-8bit", action="store_true")
+    parser.add_argument("--load-4bit", action="store_true")
+    parser.add_argument("--use-flash-attn", action="store_true")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    if args.multi_modal:
+        logger.warning("Multimodal mode is automatically detected with model name, please make sure `llava` is included in the model path.")
+
+    worker = ModelWorker(args.controller_address,
+                         args.worker_address,
+                         worker_id,
+                         args.no_register,
+                         args.model_path,
+                         args.model_base,
+                         args.model_name,
+                         args.load_8bit,
+                         args.load_4bit,
+                         args.device,
+                         use_flash_attn=args.use_flash_attn)
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

之前的代码版本/第二版代码-简单干预文本侧，图像侧，both的代码/MedEvalKit/models/HealthGPT/llava/serve/test_message.py

@@ -0,0 +1,62 @@
+import argparse
+import json
+
+import requests
+
+from llava.conversation import default_conversation
+
+
+def main():
+    if args.worker_address:
+        worker_addr = args.worker_address
+    else:
+        controller_addr = args.controller_address
+        ret = requests.post(controller_addr + "/refresh_all_workers")
+        ret = requests.post(controller_addr + "/list_models")
+        models = ret.json()["models"]
+        models.sort()
+        print(f"Models: {models}")
+
+        ret = requests.post(controller_addr + "/get_worker_address",
+            json={"model": args.model_name})
+        worker_addr = ret.json()["address"]
+        print(f"worker_addr: {worker_addr}")
+
+    if worker_addr == "":
+        return
+
+    conv = default_conversation.copy()
+    conv.append_message(conv.roles[0], args.message)
+    prompt = conv.get_prompt()
+
+    headers = {"User-Agent": "LLaVA Client"}
+    pload = {
+        "model": args.model_name,
+        "prompt": prompt,
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": 0.7,
+        "stop": conv.sep,
+    }
+    response = requests.post(worker_addr + "/worker_generate_stream", headers=headers,
+            json=pload, stream=True)
+
+    print(prompt.replace(conv.sep, "\n"), end="")
+    for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False, delimiter=b"\0"):
+        if chunk:
+            data = json.loads(chunk.decode("utf-8"))
+            output = data["text"].split(conv.sep)[-1]
+            print(output, end="\r")
+    print("")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--controller-address", type=str, default="http://localhost:21001")
+    parser.add_argument("--worker-address", type=str)
+    parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
+    parser.add_argument("--max-new-tokens", type=int, default=32)
+    parser.add_argument("--message", type=str, default=
+        "Tell me a story with more than 1000 words.")
+    args = parser.parse_args()
+
+    main()