Add files using upload-large-folder tool

之前的代码版本/HuatuoGPT-Vision/cli.py

@@ -0,0 +1,388 @@
+import sys
+import os
+file_path = os.path.abspath(__file__)
+dir_path = os.path.dirname(file_path)
+print(dir_path)
+sys.path.insert(0, dir_path)
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from llava.model import *
+
+from transformers import AutoTokenizer
+from transformers import TextIteratorStreamer
+from threading import Thread
+import torch
+
+from PIL import Image
+
+class HuatuoChatbot():
+    def __init__(self, model_dir, device = 'cuda'):
+        self.model_dir = model_dir
+
+        self.gen_kwargs = {
+            'do_sample': True,
+            'max_new_tokens': 512,
+            'min_new_tokens': 1,
+            'temperature': .2,
+            'repetition_penalty': 1.2
+        }
+        self.device = device
+        self.init_components()
+        self.history = []
+        self.images = []
+        self.debug = True
+        self.max_image_num = 6
+        
+
+    def init_components(self):
+        
+        d = self.model_dir
+        if 'huatuogpt-vision-7b' in d.lower():
+            print(f'loading from {self.model_dir}')
+            from llava.model.language_model.llava_qwen2 import LlavaQwen2ForCausalLM
+            model, loading_info = LlavaQwen2ForCausalLM.from_pretrained(self.model_dir, init_vision_encoder_from_ckpt=True, output_loading_info=True, torch_dtype=torch.bfloat16)
+            missing_keys = loading_info['missing_keys'] # keys exists in model architecture but does not exist in ckpt
+            unexpected_keys = loading_info['unexpected_keys'] # keys exists in ckpt but are not loaded by the model 
+            assert all(['vision_tower' in k for k in unexpected_keys])
+
+            tokenizer = AutoTokenizer.from_pretrained(self.model_dir)
+            tokenizer.pad_token_id = tokenizer.eos_token_id
+            self.gen_kwargs['eos_token_id'] = tokenizer.eos_token_id
+            self.gen_kwargs['pad_token_id'] = tokenizer.pad_token_id if tokenizer.pad_token_id else tokenizer.eos_token_id
+            vision_tower = model.get_vision_tower()
+            if not vision_tower.is_loaded:
+                vision_tower.load_model()
+                vision_tower.vision_tower = vision_tower.vision_tower.from_pretrained(self.model_dir)
+            vision_tower.to(dtype=torch.bfloat16, device=model.device)
+            image_processor = vision_tower.image_processor
+            
+        elif 'huatuogpt' in d.lower():
+            print(f'loading from {self.model_dir}')
+            from llava.model.language_model.llava_llama import LlavaLlamaForCausalLM
+            model, loading_info = LlavaLlamaForCausalLM.from_pretrained(self.model_dir, init_vision_encoder_from_ckpt=True, output_loading_info=True, torch_dtype=torch.bfloat16)
+            missing_keys = loading_info['missing_keys'] # keys exists in model architecture but does not exist in ckpt
+            unexpected_keys = loading_info['unexpected_keys'] # keys exists in ckpt but are not loaded by the model 
+            assert all(['vision_tower' in k for k in unexpected_keys])
+
+            tokenizer = AutoTokenizer.from_pretrained(self.model_dir)
+            tokenizer.pad_token_id = tokenizer.eos_token_id
+            self.gen_kwargs['eos_token_id'] = tokenizer.eos_token_id
+            self.gen_kwargs['pad_token_id'] = tokenizer.pad_token_id if tokenizer.pad_token_id else tokenizer.eos_token_id
+            vision_tower = model.get_vision_tower()
+            if not vision_tower.is_loaded:
+                vision_tower.load_model()
+                vision_tower.vision_tower = vision_tower.vision_tower.from_pretrained(self.model_dir)
+            vision_tower.to(dtype=torch.bfloat16, device=model.device)
+            image_processor = vision_tower.image_processor
+
+        else:
+            raise NotImplementedError
+
+        model.eval()
+        self.model = model.to(self.device)
+        self.model.config.tokenizer_padding_side = 'left'
+        self.tokenizer = tokenizer
+        self.processor = image_processor
+
+
+    def clear_history(self,):
+        self.images = []
+        self.history = []
+
+    def tokenizer_image_token(self, prompt, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None): # copied from llava
+        prompt_chunks = [self.tokenizer(chunk, add_special_tokens=False).input_ids for chunk in prompt.split('<image>')]
+
+        def insert_separator(X, sep):
+            return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+        input_ids = []
+        offset = 0
+        if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == self.tokenizer.bos_token_id:
+            offset = 1
+            input_ids.append(prompt_chunks[0][0])
+
+        for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):
+            input_ids.extend(x[offset:])
+
+        if return_tensors is not None:
+            if return_tensors == 'pt':
+                return torch.tensor(input_ids, dtype=torch.long)
+            raise ValueError(f'Unsupported tensor type: {return_tensors}')
+        return input_ids
+
+    def preprocess(self, data: list, return_tensors='pt'):
+        '''
+        [
+            {
+                'from': 'human',
+                'value': xxx,
+            },
+            {
+                'from': 'gpt',
+                'value': xxx
+            }
+        ]
+        '''
+        if not isinstance(data, list):
+            raise ValueError('must be a list')        
+        return self.preprocess_huatuo(data, return_tensors=return_tensors)
+    
+    def preprocess_huatuo(self, convs: list, return_tensors) -> list: # tokenize and concat the coversations
+        input_ids = None
+        convs = [ conv for conv in convs if conv['value'] is not None]
+        round_num = len(convs)//2
+
+        for ind in range(round_num):
+            h = convs[ind*2]['value'].strip()
+            h = f"<|user|>\n{h}\n" 
+
+            g = convs[ind*2+1]['value']
+            g = f"<|assistant|>\n{g} \n"
+
+            cur_input_ids = self.tokenizer_image_token(prompt=h, return_tensors=return_tensors)
+
+            if input_ids is None:
+                input_ids = cur_input_ids
+            else:
+                input_ids = torch.cat([input_ids, cur_input_ids])
+            
+            cur_input_ids = self.tokenizer(g, add_special_tokens= False, truncation=True, return_tensors='pt').input_ids[0]
+            input_ids = torch.cat([input_ids, cur_input_ids])
+        
+        h = convs[-1]['value'].strip()
+        h = f"<|user|>\n{h}\n<|assistant|>\n"
+        cur_input_ids = self.tokenizer_image_token(prompt=h, return_tensors=return_tensors)
+
+        if input_ids is None:
+            input_ids = cur_input_ids
+        else:
+            input_ids = torch.cat([input_ids, cur_input_ids])
+        
+        if self.debug:
+            self.debug = False
+
+        return input_ids
+
+
+    def input_moderation(self, t: str):
+        blacklist = ['<image>', '<s>', '</s>']
+        for b in blacklist:
+            t = t.replace(b, '')
+        return t
+    
+    def insert_image_placeholder(self, t, num_images, placeholder='<image>', sep='\n'):
+        for _ in range(num_images):
+            t = f"{placeholder}{sep}" + t
+
+        return t
+    
+    def get_conv(self, text):
+        ret = []
+        if self.history is None:
+            self.history = []
+        
+        for conv in self.history:
+            ret.append({'from': 'human', 'value': conv[0]})
+            ret.append({'from': 'gpt', 'value': conv[1]})
+
+        ret.append({'from': 'human', 'value': text})
+        ret.append({'from': 'gpt', 'value': None})
+
+        return ret
+
+    def get_conv_without_history(self, text):
+        ret = []
+
+        ret.append({'from': 'human', 'value': text})
+        ret.append({'from': 'gpt', 'value': None})
+
+        return ret
+    
+    def get_image_tensors(self, images):
+        list_image_tensors = []
+        crop_size = self.processor.crop_size
+        processor = self.processor
+        for fp in images:
+            if fp is None: # None is used as a placeholder
+                continue
+            elif isinstance(fp, str):
+                image = Image.open(fp).convert('RGB')
+            elif isinstance(fp, Image.Image):
+                image = fp # already an image
+            else:
+                raise TypeError(f'Unsupported type {type(fp)}')
+
+            if True or self.data_args.image_aspect_ratio == 'pad':
+                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
+                image = expand2square(image, tuple(int(x*255) for x in processor.image_mean))
+                image = processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
+            else:
+                image = processor.preprocess(image, return_tensors='pt')['pixel_values'][0] # a tensor
+            list_image_tensors.append(image.to(self.device))
+        if len(list_image_tensors) == 0:
+            list_image_tensors.append(torch.zeros(3, crop_size['height'], crop_size['width']).to(self.device))
+        return list_image_tensors
+
+    def inference(self, text, images=None):
+        '''
+        text: str
+        images: list[str]
+        '''
+        
+        # image
+        if images is None:
+            images = []
+
+        if isinstance(images,str):
+            images = [images]
+
+        valid_images = []
+        for img in images:
+            try:
+                if isinstance(img, str):
+                    Image.open(img).convert('RGB') # make sure that the path exists
+                valid_images.append(img)
+            except:
+                print(f'{img} This image is wrong.')
+                continue
+        images = valid_images
+        if len(valid_images) > self.max_image_num:
+            images = images[:self.max_image_num]
+
+        # text
+        text = self.input_moderation(text)
+        text = self.insert_image_placeholder(text, len(images) if None not in images else 0)
+
+        conv = self.get_conv_without_history(text)
+        input_ids = self.preprocess(conv, return_tensors='pt').unsqueeze(0).to(self.device)
+
+        if len(images) > 0:
+            list_image_tensors = self.get_image_tensors(images)
+            image_tensors = torch.stack(list_image_tensors).to(dtype=torch.bfloat16).to(self.device)
+        else:
+            image_tensors = None
+
+        with torch.inference_mode():
+            output_ids = self.model.generate(
+                input_ids,
+                images=image_tensors,
+                use_cache=True,
+                **self.gen_kwargs)
+        answers = []
+        for output_id in output_ids:
+            answers.append(self.tokenizer.decode(output_id, skip_special_tokens=True).strip())
+        return answers
+
+    def chat(self, text: str, images: list[str]=None, ):
+        '''
+        images: list[str], images for this round
+        text: str
+        '''
+        text = self.input_moderation(text)
+        if text == '':
+            return 'Please type in something'
+
+        if isinstance(images, str) or isinstance(images, Image.Image):
+            images = [images]
+        
+        valid_images = []
+        if images is None:
+            images = []
+        
+        for img in images:
+            try:
+                if isinstance(img, str):
+                    Image.open(img).convert('RGB') # make sure that the path exists
+                valid_images.append(img)
+            except:
+                continue
+
+        images = valid_images
+
+        self.images.extend(images)
+
+
+        assert len(images) < self.max_image_num, f'at most {self.max_image_num} images'
+
+        text = self.insert_image_placeholder(text, len(images) if None not in images else 0)
+        # make conv
+        conv = self.get_conv(text)
+        # make input ids
+        input_ids = self.preprocess(conv, return_tensors='pt').unsqueeze(0).to(self.device)
+
+        if len(self.images) > 0:
+            list_image_tensors = self.get_image_tensors(self.images)
+            image_tensors = torch.stack(list_image_tensors)
+        else:
+            image_tensors = None
+
+        streamer = TextIteratorStreamer(self.tokenizer,skip_prompt=True, skip_special_tokens=True)
+        generation_kwargs = dict(inputs=input_ids,images=image_tensors.to(dtype=torch.bfloat16) if image_tensors is not None else image_tensors, streamer=streamer,use_cache=True,**self.gen_kwargs)
+
+
+        with torch.inference_mode():
+            thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
+            thread.start()
+            generated_text = ''
+            sep = self.tokenizer.convert_ids_to_tokens(self.tokenizer.eos_token_id)
+            for new_text in streamer:
+                if sep in new_text:
+                    new_text = self.remove_overlap(generated_text,new_text[:-len(sep)])
+                    for char in new_text:
+                        generated_text += char
+                        print(char,end='',flush = True)
+                    break
+                for char in new_text:
+                    generated_text += char
+                    print(char,end='',flush = True)
+        answer = generated_text
+
+        self.history.append([text, answer])
+
+        return answer
+
+
+if __name__ =="__main__":
+
+    import argparse
+    parser = argparse.ArgumentParser(description='Args of Data Preprocess')
+
+    parser.add_argument('--model_dir', default='', type=str)
+    parser.add_argument('--device', default='cuda:0', type=str)
+    args = parser.parse_args()
+
+    bot = HuatuoChatbot(args.model_dir, args.device)
+
+    # test
+    # print(bot.inference('what show in this picture?',['./output.png']))
+    # print(bot.inference('hi'))
+
+    while True:
+        images = input('images, split by ",": ')
+        images = [i.strip() for i in images.split(',') if len(i.strip()) > 1 ]
+        text = input('USER ("clear" to clear history, "q" to exit): ')
+        if text.lower() in ['q', 'quit']:
+            exit()
+
+        if text.lower() == 'clear':
+            bot.history = []
+            bot.images = []
+            continue
+
+        answer = bot.chat(images=images, text=text)
+
+        images = None # already in the history
+
+        print()
+        print(f'GPT: {answer}')
+        print()

之前的代码版本/HuatuoGPT-Vision/convert_llm_to_vl.py

@@ -0,0 +1,82 @@
+#%%
+import torch
+import argparse
+from transformers import (
+    Qwen2_5_VLForConditionalGeneration,
+    AutoProcessor,
+    Qwen2ForCausalLM,
+)
+
+#%%
+def parse_args():
+    parser = argparse.ArgumentParser(description="Convert Qwen2.5-LLM weights into Qwen2.5-VL")
+    parser.add_argument("--vl_model_path", type=str, required=True, help="Path to the pretrained Qwen2.5-VL model")
+    parser.add_argument("--llm_model_path", type=str, required=True, help="Path to the pretrained Qwen2.5-LLM model")
+    parser.add_argument("--save_path", type=str, required=True, help="Path to save the converted Qwen2.5-VL model")
+    return parser.parse_args()
+
+#%%
+def main():
+    args = parse_args()
+
+    # Load models
+    print("Loading VL model from:", args.vl_model_path)
+    model_vl = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+        args.vl_model_path, torch_dtype="auto"
+    )
+
+    print("Loading LLM model from:", args.llm_model_path)
+    model_lm = Qwen2ForCausalLM.from_pretrained(
+        args.llm_model_path, torch_dtype="auto"
+    )
+
+    # Print model parameter info
+    print("==== Parameters of model_vl ====")
+    vl_params = list(model_vl.named_parameters())
+    print(f"Total number of VL model parameters: {len(vl_params)}")
+    print("Sample parameters:")
+    for i, (name, _) in enumerate(vl_params[:10]):
+        print(f"  {name}")
+
+    print("\n==== Parameters of model_lm ====")
+    lm_params = list(model_lm.named_parameters())
+    print(f"Total number of LLM model parameters: {len(lm_params)}")
+    print("Sample parameters:")
+    for i, (name, _) in enumerate(lm_params[:10]):
+        print(f"  {name}")
+
+    # Parameter replacement
+    print("\n==== Starting parameter replacement ====")
+    lm_state_dict = model_lm.state_dict()
+    vl_model_state_dict = model_vl.state_dict()
+    new_vl_model_state_dict = {}
+
+    replaced_count = 0
+    skipped_count = 0
+
+    for key in vl_model_state_dict.keys():
+        if key in lm_state_dict and vl_model_state_dict[key].shape == lm_state_dict[key].shape:
+            new_vl_model_state_dict[key] = lm_state_dict[key]
+            replaced_count += 1
+        else:
+            new_vl_model_state_dict[key] = vl_model_state_dict[key]
+            skipped_count += 1
+            if key not in lm_state_dict:
+                print(f"Parameter not found in LLM model: {key}")
+            else:
+                print(f"Shape mismatch - skipping: {key}, VL shape: {vl_model_state_dict[key].shape}, LLM shape: {lm_state_dict[key].shape}")
+
+    model_vl.load_state_dict(new_vl_model_state_dict)
+    print(f"\nParameter replacement completed! Replaced: {replaced_count}, Skipped: {skipped_count}")
+
+    # Save model
+    print(f"\nSaving converted VL model to: {args.save_path}")
+    model_vl.save_pretrained(args.save_path)
+
+    processor = AutoProcessor.from_pretrained(args.vl_model_path)
+    processor.save_pretrained(args.save_path)
+    print("Processor saved successfully.")
+
+#%%
+if __name__ == "__main__":
+    main()

之前的代码版本/HuatuoGPT-Vision/eval.py

@@ -0,0 +1,179 @@
+"""Code for finetune_huatuo"""
+
+import os
+import copy
+import json
+import torch
+import logging
+import argparse
+from transformers.generation.utils import LogitsProcessorList
+from transformers.generation.logits_process import LogitsProcessor
+import sys
+import ast
+
+from tqdm import tqdm
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from accelerate import Accelerator, DeepSpeedPlugin
+from transformers import set_seed
+import datasets
+import shutil
+import json
+import random
+from scorer import score_mix_llava
+from cli import HuatuoChatbot
+
+
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel, AutoModelWithLMHead
+os.umask(0)
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level='INFO')
+
+
+class TestDataset(torch.utils.data.Dataset):
+    def __init__(self, config, data_path):
+        self.config = config
+        self.dataset = {}
+        with open(data_path) as f:
+            self.dataset = json.load(f)
+        self.datas = []
+
+        test_id = 1
+        for da in self.dataset:
+            da['query'] = self.llava_prompt(da)
+            da['test_id'] = test_id
+            test_id += 1
+            self.datas.append(da)
+
+    def mmmu_prompt(self,da):
+        self.query_prompt = "Please answer the multiple-choice questions below.\n{}\n{}"
+        opt_title = ['A','B','C','D','E','F','G']
+        if isinstance(da['options'],str):
+            da['options'] = ast.literal_eval(da['options'])
+        option_str = '\n'.join(f'{opt}. {ops}' for opt,ops in zip(opt_title,da['options']))
+        return self.query_prompt.format(da['question'],option_str)
+    
+    def OmniMedVQA_prompt(self,entity):
+        q_str = entity['question'] + f'Here are {len(entity["options"])} candidate answers:' + str(entity["options"])+' Only return what you think is the correct answer from the candidate answers, do not return any other irrelevant text!'
+        return q_str
+
+    def llava_prompt(self,da):
+        self.query_prompt = "{}\n{}\nAnswer with the option's letter from the given choices directly."
+        opt_title = ['A','B','C','D','E','F','G','H','I','J','K']
+        if isinstance(da['options'],str):
+            da['options'] = ast.literal_eval(da['options'])
+        option_str = '\n'.join(f'{opt}. {ops}' for opt,ops in zip(opt_title,da['options']))
+        return self.query_prompt.format(da['question'],option_str)
+
+    def __getitem__(self, index):
+        da = self.datas[index]
+        return {
+            'data': da,
+            'query': da['query'],
+            'image': da['image']
+        }
+    
+    def __len__(self):
+        return len(self.datas)
+
+    def collate_fn(self, batch):
+        out_batch = {}
+        out_batch['query'] = [x['query'] for x in batch]
+        out_batch['data'] = [x['data'] for x in batch]
+        out_batch['image'] = [x['image'] for x in batch]
+        return out_batch
+
+
+def get_response(inputs,outputs,tokenizer,num_return):
+    responses_list=[]
+    batch_return=[]
+    for i, output in enumerate(outputs):
+        input_len = len(inputs[0])
+        generated_output = output[input_len:]
+        batch_return.append(tokenizer.decode(generated_output, skip_special_tokens=True))
+        if i%num_return==num_return-1:
+            responses_list.append(batch_return)
+            batch_return=[]
+    return responses_list
+
+def table_to_csv_string(table):
+    rows = [",".join(table.columns)]  
+    for row in table.data:
+        rows.append(",".join(map(str, row)))
+    return "\n".join(rows)
+
+def test(args):
+    accelerator = Accelerator()
+    torch.cuda.set_device(accelerator.process_index)
+    accelerator.print(f'args:\n{args}')
+
+    bot = HuatuoChatbot(args.model_path)
+    accelerator.print(f'load_finish')
+
+    bot.gen_kwargs['max_new_tokens'] = args.max_new_tokens
+
+    dataset = TestDataset(args, args.data_path)
+
+    val_dataloader = DataLoader(dataset, batch_size=1, shuffle=False, drop_last=False, collate_fn=dataset.collate_fn)
+    
+    val_dataloader = accelerator.prepare(val_dataloader)
+    accelerator.wait_for_everyone()
+    cache_data = []
+
+    with torch.no_grad():
+        ress = []
+
+        dataloader_iterator = tqdm(val_dataloader, total=len(val_dataloader)) if accelerator.is_main_process else val_dataloader
+
+        for batch in dataloader_iterator:
+            for da,query,image in zip(batch["data"],batch['query'],batch['image']):
+                response = bot.inference(query,[os.path.join(os.path.dirname(args.data_path),x) for x in image])
+                for img in [os.path.join(os.path.dirname(args.data_path),x) for x in image]:
+                    assert os.path.exists(img),f'{img} not exists'
+                da['model_output'] = response[0]
+                cache_data.append(da)
+
+        torch.cuda.empty_cache()
+        accelerator.wait_for_everyone()
+        
+        all_data =  [None] * dist.get_world_size()
+        all_response =  [None] * dist.get_world_size()
+
+        dist.all_gather_object(all_data,cache_data)
+
+        all_data = [item for sublist in all_data for item in sublist]
+
+        for d in all_data:
+            ress.append(d)
+
+        if accelerator.is_main_process:
+            task_name =  os.path.basename(args.model_path) + f'_{os.path.split(args.data_path)[-1].replace(".json","")}'
+            out_file = f'./{task_name}.json'
+            with open(out_file,'w') as fw:
+                json.dump(ress,fw,ensure_ascii=False,indent=2)
+            print(f'test results: {out_file}')
+            print(f'question num: {len(ress)}')
+            val_res = score_mix_llava(ress)
+            outstr = json.dumps(val_res,ensure_ascii=False,indent = 2)
+            accelerator.print(outstr)
+            with open(f'{task_name}_result.json','w') as fw:
+                json.dump(val_res,fw,ensure_ascii=False,indent=2)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Args of sft')
+
+    # Model Args
+    parser.add_argument('--data_path', default='medical_multimodel_evaluation_data.json', type=str)
+    parser.add_argument('--model_path', default='HuatuoGPT-Vision-7B', type=str)
+    parser.add_argument('--max_new_tokens', default=256, type=int)
+    parser.add_argument('--batch_size', default=2, type=int)
+
+    # Other Args
+    parser.add_argument('--seed', default=42, type=int)
+
+    args = parser.parse_args()
+
+    set_seed(args.seed)
+    test(args)           

之前的代码版本/HuatuoGPT-Vision/medsam3_wrapper.py

@@ -0,0 +1,112 @@
+"""
+medsam3_wrapper.py
+===================
+MedSAM3Wrapper: lazy-loads MedSAM3's LoRA inference model and runs
+text-query-driven bbox/mask prediction for a single (image, keyword) pair.
+
+Migrated from the earlier eval_textquery_medsam3_attnbias_both.py prototype
+(see F:\\文本提示的分割\\数据集\\之前尝试版本-关于关键区域和关键文本\\HuatuoGPT-Vision\\),
+so eval_attnbias_sam.py's `--intervention vis`/`--intervention both` modes can
+import a real implementation instead of degrading to the full-image fallback.
+
+Requires MedSAM3 to be installed (see _lazy_load below) and --medsam3_config /
+--medsam3_dir to point at a valid SAM3LoRAInference config and repo checkout.
+"""
+
+import os
+
+import numpy as np
+from PIL import Image
+
+
+class MedSAM3Wrapper:
+    def __init__(self, config_path, device="cuda", threshold=0.3, nms_iou=0.5,
+                 medsam3_dir=None):
+        self.threshold    = threshold
+        self.nms_iou      = nms_iou
+        self.device       = device
+        self._inferencer  = None
+        self._config_path = config_path
+        self._medsam3_dir = medsam3_dir or os.path.dirname(
+            os.path.dirname(os.path.abspath(config_path))
+        )
+
+    def _lazy_load(self):
+        if self._inferencer is not None:
+            return
+        import sys
+        if self._medsam3_dir not in sys.path:
+            sys.path.insert(0, self._medsam3_dir)
+        try:
+            from infer_sam import SAM3LoRAInference
+        except ImportError:
+            raise ImportError(
+                "找不到 MedSAM3。请先安装：\n"
+                "  git clone https://github.com/Joey-S-Liu/MedSAM3.git\n"
+                "  cd MedSAM3 && pip install -e ."
+            )
+        print("[MedSAM3] 加载模型...")
+        _orig_dir = os.getcwd()
+        try:
+            os.chdir(self._medsam3_dir)
+            self._inferencer = SAM3LoRAInference(
+                config_path=self._config_path, device=self.device,
+            )
+        finally:
+            os.chdir(_orig_dir)
+        print("[MedSAM3] 加载完成")
+
+    def predict_bbox(self, image: Image.Image, keyword: str):
+        self._lazy_load()
+        import tempfile
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+                tmp_path = tmp.name
+            image.convert("RGB").save(tmp_path)
+            _tmp_size = os.path.getsize(tmp_path)
+            print(f"[MedSAM3-debug] wrote {tmp_path} size={_tmp_size} bytes "
+                  f"image.size={image.size} keyword='{keyword}'")
+            if _tmp_size == 0:
+                print(f"[MedSAM3-debug] WARNING: {tmp_path} is empty after save()!")
+            _orig_dir = os.getcwd()
+            os.chdir(self._medsam3_dir)
+            try:
+                result = self._inferencer.predict(tmp_path, [keyword])
+            finally:
+                os.chdir(_orig_dir)
+                os.unlink(tmp_path)
+        except Exception as e:
+            import traceback; traceback.print_exc()
+            return [], None, f"MedSAM3 推理失败('{keyword}'): {e}"
+
+        pred = result.get(0, None)
+        if pred is None or pred.get("num_detections", 0) == 0:
+            return [], None, f"MedSAM3 未检测到 '{keyword}'"
+        n     = pred.get("num_detections", 0)
+        boxes = pred.get("boxes", None)
+        masks = pred.get("masks", None)
+
+        combined_mask = None
+        if masks is not None:
+            for m in masks[:n]:
+                m_f = m.astype(np.float32)
+                combined_mask = m_f if combined_mask is None else np.maximum(combined_mask, m_f)
+
+        if boxes is not None and len(boxes) > 0:
+            bbox_list = [[int(v) for v in b] for b in boxes[:n]]
+            info = f"MedSAM3('{keyword}') {len(bbox_list)}个box→{bbox_list}"
+            return bbox_list, combined_mask, info
+
+        if masks is not None and len(masks) > 0:
+            bbox_list = []
+            for mask in masks[:n]:
+                if not mask.any():
+                    continue
+                ys = np.where(np.any(mask, axis=1))[0]
+                xs = np.where(np.any(mask, axis=0))[0]
+                bbox_list.append([int(xs[0]), int(ys[0]), int(xs[-1]), int(ys[-1])])
+            if bbox_list:
+                info = f"MedSAM3('{keyword}') {len(bbox_list)}个mask→bbox"
+                return bbox_list, combined_mask, info
+
+        return [], None, f"MedSAM3 无有效结果: '{keyword}'"

之前的代码版本/HuatuoGPT-Vision/run_ablation_grid.sh

@@ -0,0 +1,122 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+# Full grid search over (layer, strength) for the "both" intervention mode WITH
+# Budgeted Token Auction enabled. Previously this was a 2-stage greedy search
+# (fix layer, sweep strength; then fix the best strength, sweep layer) to avoid
+# the cost of re-running Stage1 (model generation) + SAM for every one of the
+# 5 layers x 4 strengths = 20 combinations. Stage1/SAM results are now cached
+# in eval_attnbias_sam.py (keyed on data_path/model_path/seed, see
+# HuatuoGPT-Vision/cache/sam_stage1_cache/) and are independent of the bias
+# layer/strength/auction args, so re-running this file for a new (layer,
+# strength) combo only re-pays the much cheaper bias-intervention generation
+# pass -- a full grid is no longer prohibitively expensive.
+# kbt=kbv=s, nbt=nbv=-s for s in {0.5, 1.0, 2.0, 4.0}; layer in {3, 10, 17, 24, 27}.
+# Auction budgets/alpha/beta are fixed at their defaults here -- this script
+# only sweeps bias layer/strength, not the auction hyperparameters themselves.
+# Each combo writes to its own output dir under results_attnbias_ablation/, so
+# this never touches results_attnbias/HuatuoGPT-Vision-7B/sam_both or any other
+# previously saved result.
+set -e
+
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate huatuovision
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+INTERVENTION="both"
+LAYERS=(3 10 17 24 27)
+STRENGTHS=(0.5 1.0 2.0 4.0)
+
+AUCTION_TOTAL_RATIO=0.7
+AUCTION_NEG_RATIO=0.7
+
+MAX_SAMPLES=""
+
+for LAYER in "${LAYERS[@]}"; do
+    for S in "${STRENGTHS[@]}"; do
+        OUTPUT_PATH="results_attnbias_ablation/HuatuoGPT-Vision-7B/sam_both_auction_layer${LAYER}_s${S}"
+        if [ -d "$OUTPUT_PATH" ]; then
+            echo "[ablation-grid] $OUTPUT_PATH already exists, skipping layer=$LAYER s=$S (delete the dir manually to re-run)"
+            continue
+        fi
+
+        echo "=================================================="
+        echo "[ablation-grid] layer=$LAYER  strength=$S  ->  $OUTPUT_PATH"
+        echo "=================================================="
+
+        accelerate launch eval_attnbias_sam.py \
+            --data_path              "$DATA_PATH"              \
+            --model_path             "$MODEL_PATH"             \
+            --seed                   "$SEED"                   \
+            --max_new_tokens         "$MAX_NEW_TOKENS"         \
+            --output_path            "$OUTPUT_PATH"            \
+            --intervention           "$INTERVENTION"           \
+            --attn_layers_text       "$LAYER"                  \
+            --attn_key_bias_text     "$S"                      \
+            --attn_nonkey_bias_text  "-$S"                      \
+            --attn_layers_vis        "$LAYER"                  \
+            --attn_key_bias_vis      "$S"                      \
+            --attn_nonkey_bias_vis   "-$S"                      \
+            --medsam3_config         "$MEDSAM3_CONFIG"         \
+            --medsam3_dir            "$MEDSAM3_DIR"            \
+            --auction_enable                                   \
+            --auction_total_ratio      "$AUCTION_TOTAL_RATIO"      \
+            --auction_neg_ratio        "$AUCTION_NEG_RATIO"        \
+            ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}
+
+        echo "[ablation-grid] layer=$LAYER s=$S finished"
+    done
+done
+
+echo "[ablation-grid] all ${#LAYERS[@]}x${#STRENGTHS[@]} combinations finished"
+
+# ── pick the best (layer, strength) across the full grid. Each combo's output
+#    dir holds exactly one *_result.json (eval_attnbias_sam.py's hparam_tag
+#    already makes the filename unique per layer/strength/auction config, so
+#    no risk of stale files from a previous combo lingering in the same dir),
+#    so glob for it directly instead of hand-reconstructing the filename --
+#    that reconstruction is what broke last time hparam_tag's format changed.
+BEST_LAYER=""
+BEST_STRENGTH=""
+BEST_SCORE=""
+for LAYER in "${LAYERS[@]}"; do
+    for S in "${STRENGTHS[@]}"; do
+        OUTPUT_PATH="results_attnbias_ablation/HuatuoGPT-Vision-7B/sam_both_auction_layer${LAYER}_s${S}"
+        RESULT_F=$(ls "$OUTPUT_PATH"/*_result.json 2>/dev/null | head -n1)
+        if [ -z "$RESULT_F" ]; then
+            echo "[ablation-grid] missing *_result.json under $OUTPUT_PATH -- cannot pick best (layer, strength)" >&2
+            exit 1
+        fi
+        SCORE=$(python -c "
+import json
+with open('$RESULT_F') as f:
+    d = json.load(f)
+print(d['The total score for multiple-choice questions'])
+")
+        echo "[ablation-grid] layer=$LAYER s=$S score=$SCORE"
+        if [ -z "$BEST_SCORE" ] || python -c "exit(0 if $SCORE > $BEST_SCORE else 1)"; then
+            BEST_SCORE="$SCORE"
+            BEST_LAYER="$LAYER"
+            BEST_STRENGTH="$S"
+        fi
+    done
+done
+
+echo "[ablation-grid] best overall: layer=$BEST_LAYER strength=$BEST_STRENGTH (score=$BEST_SCORE)"
+echo "[ablation-grid] syncing into every run_eval_attnbias_sam_*.sh via sync_attn_params.py"
+
+NONKEY_STRENGTH="-$BEST_STRENGTH"
+python sync_attn_params.py \
+    --layers_text "$BEST_LAYER" --key_bias_text "$BEST_STRENGTH" --nonkey_bias_text "$NONKEY_STRENGTH" \
+    --layers_vis  "$BEST_LAYER" --key_bias_vis  "$BEST_STRENGTH" --nonkey_bias_vis  "$NONKEY_STRENGTH"
+
+echo "[ablation-grid] done. All run_eval_attnbias_sam_*.sh now use the ablation-selected layer/strength"
+echo "[ablation-grid] (amplify_only/suppress_only keep their pinned-zero side; text.sh/vis.sh keep their single-modality side -- see sync_attn_params.py)."

之前的代码版本/HuatuoGPT-Vision/run_all_attnbias_sam.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+# 先跑 baseline（无干预的 eval.py），再依次跑完主干对比三组：
+# none（无attention干预）/ both_noauction（传统全有全无）/ both（auction精选，正式配置）
+# 任意一个失败就停止，避免在错误的环境下继续浪费时间
+set -e
+
+# 默认使用 huatuovision conda 环境，不依赖调用者当前激活的环境
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate huatuovision
+
+SCRIPTS=(
+    "run_eval.sh"
+    "run_eval_attnbias_sam_none.sh"
+    "run_eval_attnbias_sam_both_noauction.sh"
+    "run_eval_attnbias_sam_both.sh"
+    "run_eval_attnbias_sam_text.sh"
+    "run_eval_attnbias_sam_vis.sh"
+    "run_eval_attnbias_sam_both_amplify_only.sh"
+    "run_eval_attnbias_sam_both_suppress_only.sh"
+    "run_eval_attnbias_sam_both_random.sh"
+)
+
+for script in "${SCRIPTS[@]}"; do
+    echo "=================================================="
+    echo "[run_all] 开始运行 $script"
+    echo "=================================================="
+    bash "$script"
+    echo "[run_all] $script 运行完成"
+done
+
+echo "[run_all] 全部干预模式运行完成"

之前的代码版本/HuatuoGPT-Vision/run_eval.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+accelerate launch eval.py \
+    --data_path       "$DATA_PATH"       \
+    --model_path      "$MODEL_PATH"      \
+    --seed            "$SEED"            \
+    --max_new_tokens  "$MAX_NEW_TOKENS"

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_both.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_both"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+# both mode + Budgeted Token Auction: instead of amplifying every SAM patch /
+# scispaCy keyword and suppressing everything else, score every candidate by its
+# original attention and select only top-k under a fixed budget (see
+# BudgetedTokenAuction in eval_attnbias_sam.py).
+INTERVENTION="both"
+ATTN_LAYERS_TEXT=17
+ATTN_KEY_BIAS_TEXT=3.0
+ATTN_NONKEY_BIAS_TEXT=-3.0
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=3.0
+ATTN_NONKEY_BIAS_VIS=-3.0
+
+AUCTION_TOTAL_RATIO=0.7
+AUCTION_NEG_RATIO=0.7
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path                "$DATA_PATH"                \
+    --model_path               "$MODEL_PATH"               \
+    --seed                     "$SEED"                     \
+    --max_new_tokens           "$MAX_NEW_TOKENS"           \
+    --output_path              "$OUTPUT_PATH"              \
+    --intervention              "$INTERVENTION"             \
+    --attn_layers_text          "$ATTN_LAYERS_TEXT"         \
+    --attn_key_bias_text        "$ATTN_KEY_BIAS_TEXT"       \
+    --attn_nonkey_bias_text     "$ATTN_NONKEY_BIAS_TEXT"    \
+    --attn_layers_vis           "$ATTN_LAYERS_VIS"          \
+    --attn_key_bias_vis         "$ATTN_KEY_BIAS_VIS"        \
+    --attn_nonkey_bias_vis      "$ATTN_NONKEY_BIAS_VIS"     \
+    --medsam3_config            "$MEDSAM3_CONFIG"           \
+    --medsam3_dir               "$MEDSAM3_DIR"              \
+    --auction_enable                                       \
+    --auction_total_ratio       "$AUCTION_TOTAL_RATIO"      \
+    --auction_neg_ratio         "$AUCTION_NEG_RATIO"        \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_both_noauction.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_both_noauction"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+# both mode, auction OFF (legacy behavior): every SAM patch / scispaCy keyword
+# gets amplified, everything else gets suppressed -- no scoring, no budget. This
+# is the "before" half of the main ablation: none vs both-noauction vs both+auction.
+INTERVENTION="both"
+ATTN_LAYERS_TEXT=17
+ATTN_KEY_BIAS_TEXT=3.0
+ATTN_NONKEY_BIAS_TEXT=-3.0
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=3.0
+ATTN_NONKEY_BIAS_VIS=-3.0
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path              "$DATA_PATH"              \
+    --model_path             "$MODEL_PATH"             \
+    --seed                   "$SEED"                   \
+    --max_new_tokens         "$MAX_NEW_TOKENS"         \
+    --output_path            "$OUTPUT_PATH"            \
+    --intervention           "$INTERVENTION"           \
+    --attn_layers_text       "$ATTN_LAYERS_TEXT"       \
+    --attn_key_bias_text     "$ATTN_KEY_BIAS_TEXT"     \
+    --attn_nonkey_bias_text  "$ATTN_NONKEY_BIAS_TEXT"  \
+    --attn_layers_vis        "$ATTN_LAYERS_VIS"        \
+    --attn_key_bias_vis      "$ATTN_KEY_BIAS_VIS"      \
+    --attn_nonkey_bias_vis   "$ATTN_NONKEY_BIAS_VIS"   \
+    --medsam3_config         "$MEDSAM3_CONFIG"         \
+    --medsam3_dir            "$MEDSAM3_DIR"            \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_both_random.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_both_random"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+# Ablation control: same "both" bias strengths/layers/auction params as
+# run_eval_attnbias_sam_both.sh, but the scispaCy keyword positions and SAM
+# bbox patches are each replaced (--ablation_random_text/--ablation_random_vis)
+# with an equal-count RANDOM sample from the same candidate pool (all question
+# text tokens / full 24x24 visual grid, excluding the true key positions),
+# seeded by $SEED for reproducibility. Auction stays ON so this differs from
+# "both" by exactly one factor (random vs real key positions feeding the
+# auction's bidding) -- tests whether gains come from biasing the
+# *semantically correct* tokens, or merely from biasing *some* tokens of the
+# same count. Compare this run's accuracy against run_eval_attnbias_sam_both.sh.
+INTERVENTION="both"
+ATTN_LAYERS_TEXT=17
+ATTN_KEY_BIAS_TEXT=3.0
+ATTN_NONKEY_BIAS_TEXT=-3.0
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=3.0
+ATTN_NONKEY_BIAS_VIS=-3.0
+
+AUCTION_TOTAL_RATIO=0.7
+AUCTION_NEG_RATIO=0.7
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path                "$DATA_PATH"                \
+    --model_path               "$MODEL_PATH"               \
+    --seed                     "$SEED"                     \
+    --max_new_tokens           "$MAX_NEW_TOKENS"           \
+    --output_path              "$OUTPUT_PATH"              \
+    --intervention              "$INTERVENTION"             \
+    --attn_layers_text          "$ATTN_LAYERS_TEXT"         \
+    --attn_key_bias_text        "$ATTN_KEY_BIAS_TEXT"       \
+    --attn_nonkey_bias_text     "$ATTN_NONKEY_BIAS_TEXT"    \
+    --attn_layers_vis           "$ATTN_LAYERS_VIS"          \
+    --attn_key_bias_vis         "$ATTN_KEY_BIAS_VIS"        \
+    --attn_nonkey_bias_vis      "$ATTN_NONKEY_BIAS_VIS"     \
+    --medsam3_config            "$MEDSAM3_CONFIG"           \
+    --medsam3_dir               "$MEDSAM3_DIR"              \
+    --auction_enable                                       \
+    --auction_total_ratio       "$AUCTION_TOTAL_RATIO"      \
+    --auction_neg_ratio         "$AUCTION_NEG_RATIO"        \
+    --ablation_random_text                                 \
+    --ablation_random_vis                                  \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_both_suppress_only.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_both_suppress_only"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+# Ablation: suppress-only. nonkey_bias_* keeps the negative bias (distractors
+# suppressed), but key_bias_* is 0 instead of positive -- isolates how much of
+# the "both" result comes from suppressing non-keyword text / non-SAM visual
+# patches, with no amplification of the key set. Auction stays ON with the
+# same ratio/alpha/beta as run_eval_attnbias_sam_both.sh, so this differs from
+# "both" by exactly one factor (key_bias_*); compare against
+# run_eval_attnbias_sam_both_amplify_only.sh (same setup, opposite side
+# zeroed) and run_eval_attnbias_sam_both.sh.
+INTERVENTION="both"
+ATTN_LAYERS_TEXT=17
+ATTN_KEY_BIAS_TEXT=0.0
+ATTN_NONKEY_BIAS_TEXT=-3.0
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=0.0
+ATTN_NONKEY_BIAS_VIS=-3.0
+
+AUCTION_TOTAL_RATIO=0.7
+AUCTION_NEG_RATIO=0.7
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path                "$DATA_PATH"                \
+    --model_path               "$MODEL_PATH"               \
+    --seed                     "$SEED"                     \
+    --max_new_tokens           "$MAX_NEW_TOKENS"           \
+    --output_path              "$OUTPUT_PATH"              \
+    --intervention              "$INTERVENTION"             \
+    --attn_layers_text          "$ATTN_LAYERS_TEXT"         \
+    --attn_key_bias_text        "$ATTN_KEY_BIAS_TEXT"       \
+    --attn_nonkey_bias_text     "$ATTN_NONKEY_BIAS_TEXT"    \
+    --attn_layers_vis           "$ATTN_LAYERS_VIS"          \
+    --attn_key_bias_vis         "$ATTN_KEY_BIAS_VIS"        \
+    --attn_nonkey_bias_vis      "$ATTN_NONKEY_BIAS_VIS"     \
+    --medsam3_config            "$MEDSAM3_CONFIG"           \
+    --medsam3_dir               "$MEDSAM3_DIR"              \
+    --auction_enable                                       \
+    --auction_total_ratio       "$AUCTION_TOTAL_RATIO"      \
+    --auction_neg_ratio         "$AUCTION_NEG_RATIO"        \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_none.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_none"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+# none: no attention intervention (model_output reuses plain inference result)
+INTERVENTION="none"
+ATTN_LAYERS_TEXT="17"
+ATTN_KEY_BIAS_TEXT=3.0
+ATTN_NONKEY_BIAS_TEXT=-3.0
+ATTN_LAYERS_VIS="17"
+ATTN_KEY_BIAS_VIS=3.0
+ATTN_NONKEY_BIAS_VIS=-3.0
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path              "$DATA_PATH"              \
+    --model_path             "$MODEL_PATH"             \
+    --seed                   "$SEED"                   \
+    --max_new_tokens         "$MAX_NEW_TOKENS"         \
+    --output_path            "$OUTPUT_PATH"            \
+    --intervention           "$INTERVENTION"           \
+    --attn_layers_text       "$ATTN_LAYERS_TEXT"       \
+    --attn_key_bias_text     "$ATTN_KEY_BIAS_TEXT"     \
+    --attn_nonkey_bias_text  "$ATTN_NONKEY_BIAS_TEXT"  \
+    --attn_layers_vis        "$ATTN_LAYERS_VIS"        \
+    --attn_key_bias_vis      "$ATTN_KEY_BIAS_VIS"      \
+    --attn_nonkey_bias_vis   "$ATTN_NONKEY_BIAS_VIS"   \
+    --medsam3_config         "$MEDSAM3_CONFIG"         \
+    --medsam3_dir            "$MEDSAM3_DIR"            \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_text.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_text"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+# Modality ablation: text-only. Only the scispaCy keyword text positions get
+# biased (key_bias_text / nonkey_bias_text); the vis side is forced to 0 bias
+# inside _make_attn_ctx regardless of what's passed here. SAM/MedSAM3 is
+# skipped entirely (_needs_sam is False for "text"), so no medsam3_* args.
+# Auction stays ON with the same ratio/alpha/beta as run_eval_attnbias_sam_both.sh
+# (clear_market sizes its budget off only the text-side candidate pool here,
+# since vis_enabled=False when intervention=="text" -- see clear_market's
+# text_enabled/vis_enabled params), so this differs from "both" by exactly one
+# factor (modality); compare against run_eval_attnbias_sam_vis.sh and
+# run_eval_attnbias_sam_both.sh.
+INTERVENTION="text"
+ATTN_LAYERS_TEXT=17
+ATTN_KEY_BIAS_TEXT=3.0
+ATTN_NONKEY_BIAS_TEXT=-3.0
+ATTN_LAYERS_VIS="17"
+
+AUCTION_TOTAL_RATIO=0.7
+AUCTION_NEG_RATIO=0.7
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path                "$DATA_PATH"                \
+    --model_path               "$MODEL_PATH"               \
+    --seed                     "$SEED"                     \
+    --max_new_tokens           "$MAX_NEW_TOKENS"           \
+    --output_path              "$OUTPUT_PATH"              \
+    --intervention              "$INTERVENTION"             \
+    --attn_layers_text          "$ATTN_LAYERS_TEXT"         \
+    --attn_key_bias_text        "$ATTN_KEY_BIAS_TEXT"       \
+    --attn_nonkey_bias_text     "$ATTN_NONKEY_BIAS_TEXT"    \
+    --attn_layers_vis           "$ATTN_LAYERS_VIS"          \
+    --auction_enable                                       \
+    --auction_total_ratio       "$AUCTION_TOTAL_RATIO"      \
+    --auction_neg_ratio         "$AUCTION_NEG_RATIO"        \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/run_eval_attnbias_sam_vis.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+DATA_PATH="/home/jinhua/ExplainableVQA/benchmarks/Medical_Multimodal_Evaluation_Data/medical_multimodel_evaluation_data.json"
+MODEL_PATH="FreedomIntelligence/HuatuoGPT-Vision-7B"
+OUTPUT_PATH="results_attnbias/HuatuoGPT-Vision-7B/sam_vis"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision/MedSAM3"
+
+# Modality ablation: vis-only. Only the SAM bbox patches get biased
+# (key_bias_vis / nonkey_bias_vis); the text side is forced to 0 bias inside
+# _make_attn_ctx regardless of what's passed here. SAM/MedSAM3 still runs
+# (_needs_sam is True for "vis"). Auction stays ON with the same
+# ratio/alpha/beta as run_eval_attnbias_sam_both.sh (clear_market sizes its
+# budget off only the vis-side candidate pool here, since text_enabled=False
+# when intervention=="vis" -- see clear_market's text_enabled/vis_enabled
+# params), so this differs from "both" by exactly one factor (modality);
+# compare against run_eval_attnbias_sam_text.sh and run_eval_attnbias_sam_both.sh.
+INTERVENTION="vis"
+ATTN_LAYERS_TEXT=17
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=3.0
+ATTN_NONKEY_BIAS_VIS=-3.0
+
+AUCTION_TOTAL_RATIO=0.7
+AUCTION_NEG_RATIO=0.7
+
+MAX_SAMPLES=""
+
+accelerate launch eval_attnbias_sam.py \
+    --data_path                "$DATA_PATH"                \
+    --model_path               "$MODEL_PATH"               \
+    --seed                     "$SEED"                     \
+    --max_new_tokens           "$MAX_NEW_TOKENS"           \
+    --output_path              "$OUTPUT_PATH"              \
+    --intervention              "$INTERVENTION"             \
+    --attn_layers_text          "$ATTN_LAYERS_TEXT"         \
+    --attn_layers_vis           "$ATTN_LAYERS_VIS"          \
+    --attn_key_bias_vis         "$ATTN_KEY_BIAS_VIS"        \
+    --attn_nonkey_bias_vis      "$ATTN_NONKEY_BIAS_VIS"     \
+    --medsam3_config            "$MEDSAM3_CONFIG"           \
+    --medsam3_dir               "$MEDSAM3_DIR"              \
+    --auction_enable                                       \
+    --auction_total_ratio       "$AUCTION_TOTAL_RATIO"      \
+    --auction_neg_ratio         "$AUCTION_NEG_RATIO"        \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

之前的代码版本/HuatuoGPT-Vision/scorer.py

@@ -0,0 +1,195 @@
+#%%
+import re
+import json,os
+from collections import defaultdict
+import random
+import ast
+import wandb
+# import argparse
+import traceback
+
+import difflib
+
+def str_similarity(str1, str2):
+    seq = difflib.SequenceMatcher(None, str1, str2)
+    return seq.ratio()
+
+def find_most_similar_index(str_list, target_str):
+    """
+    Given a list of strings and a target string, returns the index of the most similar string in the list.
+    """
+    # Initialize variables to keep track of the most similar string and its index
+    most_similar_str = None
+    most_similar_index = None
+    highest_similarity = 0
+    
+    # Iterate through each string in the list
+    for i, str in enumerate(str_list):
+        # Calculate the similarity between the current string and the target string
+        similarity = str_similarity(str, target_str)
+        
+        # If the current string is more similar than the previous most similar string, update the variables
+        if similarity >= highest_similarity:
+            most_similar_str = str
+            most_similar_index = i
+            highest_similarity = similarity
+    
+    # Return the index of the most similar string
+    return most_similar_index
+
+def match_choice3(text,options):
+    matches = list(re.finditer(r"(is |是|\*|\W|\ |\(|为|^|'|\"|#)(?![aA] )([abcdefghijklmnABCDEFGHIJKLMN])(\W|$)", text, re.S))
+    if matches:
+        ans = matches[0].group(2)
+        return ans,1
+
+    text = text.lower()
+
+    opsindex = [(opt,text.rindex(options[opt].lower())) for opt in options if options[opt].lower() in text]
+    if len(opsindex) > 0:
+        return sorted(opsindex,key=lambda x:x[1],reverse=True)[0][0],2
+    
+    oplabels = [x for x in options]
+    opans = [options[x].lower() for x in options]
+    ansindex = find_most_similar_index(opans,text.lower())
+    return oplabels[ansindex], 3
+
+def test_OmniMedVQA(da):
+    a,b,c,d = da.get('option_A'), da.get('option_B'), da.get('option_C'), da.get('option_D')
+    answer_list = [a, b]
+    if c is not None:
+        answer_list.append(c)
+    if d is not None:
+        answer_list.append(d)
+    # print(f'answer_list {answer_list}')
+    # print(f"answer_list {answer_list[find_most_similar_index(answer_list, da['model_output'])] == da['gt_answer']}")
+    return answer_list[find_most_similar_index(answer_list, da['model_output'])] == da['gt_answer']
+
+def test_OmniMedVQA_new(da):
+    answer_list = da['options']
+    choice = find_most_similar_index(answer_list, da['model_output'])
+    label = answer_list[choice] == da['answer']
+    return label,choice
+
+def test_choice_simple(da):
+    choice = ['A','B','C','D','E','F','G'].index(da['model_output'][0])    
+    answer_list = da['options']
+    label = answer_list[choice] == da['answer']
+    return label,choice
+
+
+wrong_ans = []
+def test_mmlu(da):
+    global wrong_ans
+    ans = match_choice3(da['model_output'],da)
+    # ans = match_choice3(da['huatuo_answer'],da)
+    if len(ans) == 0:
+        wrong_ans.append(da)
+        ans = 'A'
+    return ans[0] == da['answer']
+
+
+wrong_data = []
+sample_num = 5
+wrong_ans_num = 0
+def test_choice_llava(input_data):
+    global wrong_ans_num
+    type2score = {}
+    sub_type2score = {}
+    sample_data = {}
+    ty_set = set()
+    res = {}
+
+    miss_match_num = 0
+
+    if len(input_data) == 0:
+        return sample_data,res
+    
+    for da in input_data:
+        ty = da['dataset']
+        
+        if ty not in type2score:
+            type2score[ty] = [0,0]
+
+        type2score[ty][1] += 1
+        
+        try:
+            opt_title = ['A','B','C','D','E','F','G','H','I','J','K']
+            if da['answer'] == '?':
+                da['is_correct'] = False
+            else:
+                answer_label = opt_title[da['options'].index(da['answer'])]
+                da['answer'] = answer_label
+                da['is_correct'] = test_mmlu(da)
+        except Exception as e:
+            print(da)
+            traceback.print_exc()
+            assert False,da
+
+        if da['is_correct']:
+            type2score[ty][0] += 1
+        else:
+            wrong_data.append(da)
+        
+        def update_sub_record(sub_type2score,type_name,iscorrect):
+            if type_name not in sub_type2score:
+                sub_type2score[type_name] = [0,0]
+            sub_type2score[type_name][1] += 1
+            if iscorrect:
+                sub_type2score[type_name][0] += 1
+        if 'subset' in da and da['subset']!= '':
+            update_sub_record(sub_type2score, f'{ty}_{da["subset"]}',da['is_correct'])
+
+
+    for k,v in type2score.items():
+        print(f'【{k}】Accuracy：{(v[0]/v[1] if v[0] > 0 else 0) :.4f}   question number:{v[1]}')
+        res[k] = (v[0]/v[1] if v[0] > 0 else 0)
+
+    print(f'The total score for multiple-choice questions：{sum([sc[0] for k,sc in type2score.items() if "___" not in k ])/len(input_data) :.3f}   question number: {len(input_data)}')
+    res['The total score for multiple-choice questions'] = sum([sc[0] for k,sc in type2score.items() if "___" not in k ])/len(input_data)
+
+    print('\n'+f'-------'*4)
+    for k,v in sub_type2score.items():
+        print(f'【{k}】Accuracy：{(v[0]/v[1] if v[0] > 0 else 0) :.4f}   question number:{v[1]}')
+        res[k] = (v[0]/v[1] if v[0] > 0 else 0)
+
+    sample_data = [{'Input':x['query'],'Output':x['model_output'],'Answer': x['answer'], 'Dataset':x['dataset']} for x in random.sample(input_data,5)]
+    print(f'\n wrong_ans_num {wrong_ans_num}')
+    return sample_data,res
+
+def test_chat(chat_data,sample_data):
+    for da in chat_data:
+        ty = da['dataset']
+        da['answer'] = da['output']
+        if sample_data is not None:
+            sample_data[ty] = []
+            if len(sample_data[ty]) < sample_num:
+                sample_data[ty].append(da)
+    return sample_data
+
+
+def score_mix_llava(datas, iswandb = False):
+    global test_func
+    test_func = match_choice3
+    filted_data = []
+    test_id_set = set()
+    for da in datas:
+        if 'question_type' in da and da['question_type'] == 'open':
+            continue
+        if da['test_id'] in test_id_set:
+            continue
+        if len(da['options']) == 0:
+            continue
+        test_id_set.add(da['test_id'])
+        filted_data.append(da)
+    print(f'filted_data: {len(filted_data)} datas:{len(datas)}')
+
+    sample_data,res = test_choice_llava(filted_data)    
+
+    if iswandb:
+        table = wandb.Table(columns=["Input", "Output","Answer","Dataset"])
+        for da in sample_data:
+            table.add_data(da['Input'],da['Output'],da['Answer'],da['Dataset'])
+        res['InputOutputTable'] = table
+    return res
+

之前的代码版本/HuatuoGPT-Vision/sync_attn_params.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Sync the best attention-bias hyperparameters (layers + key/nonkey bias for
+text and vis) across all run_eval_attnbias_sam_*.sh ablation scripts, so a
+single grid-search result doesn't have to be hand-copied into 8 files.
+
+Two scripts intentionally keep one side pinned at 0 as part of what they're
+ablating, and must NOT be overwritten on that side:
+  - run_eval_attnbias_sam_both_amplify_only.sh : ATTN_NONKEY_BIAS_{TEXT,VIS} stay 0
+  - run_eval_attnbias_sam_both_suppress_only.sh: ATTN_KEY_BIAS_{TEXT,VIS}    stay 0
+run_eval_attnbias_sam_none.sh has no attention-bias variables and is skipped.
+
+Usage:
+    python sync_attn_params.py --layers_text 17 --key_bias_text 4.0 --nonkey_bias_text -4.0 \\
+                                --layers_vis 17  --key_bias_vis 1.0  --nonkey_bias_vis -1.0
+    python sync_attn_params.py --layers_text 17 --key_bias_text 4.0 --nonkey_bias_text -4.0 \\
+                                --layers_vis 17  --key_bias_vis 1.0  --nonkey_bias_vis -1.0 --dry_run
+"""
+import argparse
+import glob
+import os
+import re
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# variable name -> argparse dest
+VARS = {
+    "ATTN_LAYERS_TEXT": "layers_text",
+    "ATTN_KEY_BIAS_TEXT": "key_bias_text",
+    "ATTN_NONKEY_BIAS_TEXT": "nonkey_bias_text",
+    "ATTN_LAYERS_VIS": "layers_vis",
+    "ATTN_KEY_BIAS_VIS": "key_bias_vis",
+    "ATTN_NONKEY_BIAS_VIS": "nonkey_bias_vis",
+}
+
+# files where one side must stay pinned at 0 -- those variables are skipped
+PINNED_ZERO = {
+    "run_eval_attnbias_sam_both_amplify_only.sh": {"ATTN_NONKEY_BIAS_TEXT", "ATTN_NONKEY_BIAS_VIS"},
+    "run_eval_attnbias_sam_both_suppress_only.sh": {"ATTN_KEY_BIAS_TEXT", "ATTN_KEY_BIAS_VIS"},
+}
+
+SKIP_FILES = {"run_eval_attnbias_sam_none.sh"}
+
+# text-only / vis-only scripts don't set the other side's bias vars at all
+# (they're forced to 0 inside eval_attnbias_sam.py regardless) -- only sync
+# the side that's actually present in the file.
+ONE_SIDED_FILES = {
+    "run_eval_attnbias_sam_text.sh": {"ATTN_LAYERS_VIS", "ATTN_KEY_BIAS_VIS", "ATTN_NONKEY_BIAS_VIS"},
+    "run_eval_attnbias_sam_vis.sh": {"ATTN_KEY_BIAS_TEXT", "ATTN_NONKEY_BIAS_TEXT"},
+}
+
+
+def sync_file(path, values, dry_run):
+    fname = os.path.basename(path)
+    if fname in SKIP_FILES:
+        return 0
+
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    skip_vars = PINNED_ZERO.get(fname, set()) | ONE_SIDED_FILES.get(fname, set())
+
+    n_changed = 0
+    for var, dest in VARS.items():
+        if var not in content or var in skip_vars or dest not in values:
+            continue
+        new_val = values[dest]
+        pattern = re.compile(rf'^({re.escape(var)}=)(.*)$', re.MULTILINE)
+
+        def _replace(m, new_val=new_val):
+            return f"{m.group(1)}{new_val}"
+
+        new_content, count = pattern.subn(_replace, content)
+        if count:
+            content = new_content
+            n_changed += count
+
+    if n_changed and not dry_run:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+    return n_changed
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--layers_text", type=str, default=None)
+    p.add_argument("--key_bias_text", type=str, default=None)
+    p.add_argument("--nonkey_bias_text", type=str, default=None)
+    p.add_argument("--layers_vis", type=str, default=None)
+    p.add_argument("--key_bias_vis", type=str, default=None)
+    p.add_argument("--nonkey_bias_vis", type=str, default=None)
+    p.add_argument("--dry_run", action="store_true", default=False,
+                    help="print what would change, without writing files")
+    args = p.parse_args()
+
+    values = {k: v for k, v in vars(args).items() if k != "dry_run" and v is not None}
+    if not values:
+        p.error("provide at least one of --layers_text/--key_bias_text/... to sync")
+
+    sh_files = sorted(glob.glob(os.path.join(SCRIPT_DIR, "run_eval_attnbias_sam_*.sh")))
+    total = 0
+    for path in sh_files:
+        fname = os.path.basename(path)
+        n = sync_file(path, values, args.dry_run)
+        total += n
+        if n:
+            tag = " (dry-run)" if args.dry_run else ""
+            print(f"[sync]{tag} {fname}: updated {n} variable(s)")
+        elif fname not in SKIP_FILES:
+            print(f"[sync] {fname}: no matching variables (skipped/pinned)")
+
+    print(f"[sync] done, {total} variable assignment(s) {'would be ' if args.dry_run else ''}updated "
+          f"across {len(sh_files)} file(s)")
+
+
+if __name__ == "__main__":
+    main()

之前的代码版本/HuatuoGPT-Vision/train_vl.py

@@ -0,0 +1,496 @@
+import os
+import copy
+import json
+import torch
+import logging
+import argparse
+import random
+import shutil
+from typing import List, Dict, Any
+from dataclasses import dataclass
+
+import wandb
+import datasets
+from tqdm import tqdm
+import gc
+from jinja2 import Template
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from accelerate import Accelerator
+from transformers import (
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen2_5_VLProcessor,
+    set_seed,
+    get_cosine_schedule_with_warmup
+)
+from torch.optim.lr_scheduler import LambdaLR
+import math
+from qwen_vl_utils import fetch_image
+
+# Set environment variables
+os.environ['WANDB_DISABLE_CODE'] = 'true'
+os.environ["WANDB_API_KEY"] = ''
+os.umask(0)
+
+# Set up logging
+logger = logging.getLogger(__name__)
+logging.basicConfig(level='INFO')
+
+def get_custom_cosine_schedule_with_warmup(
+    optimizer, 
+    num_warmup_steps, 
+    num_training_steps, 
+    min_lr_ratio=0.0, 
+    num_cycles=0.5
+):
+    """
+    Custom cosine scheduler supporting minimum learning rate ratio
+    """
+    def lr_lambda(current_step):
+        if current_step < num_warmup_steps:
+            return float(current_step) / float(max(1, num_warmup_steps))
+        progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))
+        cosine_factor = 0.5 * (1.0 + math.cos(math.pi * 2 * num_cycles * progress))
+        scaled_factor = (1 - min_lr_ratio) * cosine_factor + min_lr_ratio
+        return scaled_factor
+
+    return LambdaLR(optimizer, lr_lambda, last_epoch=-1)
+
+def get_learning_rate(step, initial_lr, num_warmup_steps, num_training_steps, min_lr_ratio, num_cycles=0.5):
+    if step < num_warmup_steps:
+        return float(step) / float(max(1, num_warmup_steps)) * initial_lr
+    progress = float(step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))
+    cosine_factor = 0.5 * (1.0 + math.cos(math.pi * 2 * num_cycles * progress))
+    scaled_factor = (1 - min_lr_ratio) * cosine_factor + min_lr_ratio
+    return scaled_factor * initial_lr
+
+class TrainingMetrics:
+    def __init__(self, device):
+        self.n_step = 0
+        self.right = torch.Tensor([0]).to(device=device)
+        self.total = torch.Tensor([0]).to(device=device)
+        self.total_loss = torch.Tensor([0]).to(device=device)
+        self.world_size = dist.get_world_size()
+
+    def __call__(self, logits, labels, loss):
+        return self.update(logits, labels, loss)
+
+    def update(self, logits, labels, loss):
+        self.n_step += 1
+        with torch.no_grad():
+            shift_preds = logits[..., :-1, :].argmax(dim=-1)
+            shift_labels = labels[..., 1:]
+            self.right += (shift_preds == shift_labels).masked_fill(shift_labels.eq(-100), 0).sum().item()
+            self.total += (shift_labels != -100).sum().item()
+            self.total_loss += loss.item()
+
+    def get_metric(self, reset=True):
+        dist.all_reduce(self.right, op=torch.distributed.ReduceOp.SUM)
+        dist.all_reduce(self.total, op=torch.distributed.ReduceOp.SUM)
+        dist.all_reduce(self.total_loss, op=torch.distributed.ReduceOp.SUM)
+
+        acc = (self.right / self.total).item()
+        loss = self.total_loss.item() / (self.world_size * self.n_step)
+
+        if reset:
+            self.n_step = 0
+            self.right.fill_(0)
+            self.total.fill_(0)
+            self.total_loss.fill_(0)
+        return acc, loss
+
+class SftDataset(Dataset):
+    """Pretraining dataset class"""
+    def __init__(self, config, processor, accelerator):
+        self.config = config
+        self.processor = processor
+        self.accelerator = accelerator
+
+        # Load pretraining data (supports multiple sources)
+        self.data = []
+        with open(config.data_path,'r') as f:
+            data = json.load(f)
+        self.data = data
+
+        # Convert conversation format
+        role_map = {'system': 'system', 'human': 'user', 'gpt': 'assistant'}
+        if 'value' in data[0]['conversations'][0]:
+            for da in data:
+                conv = []
+                for x in da['conversations']:
+                    conv.append({
+                        'role': role_map[x['from']],
+                        'content': x['value']
+                    })
+                da['conversations'] = conv
+
+        # Filter long samples and ensure assistant response is valid
+        tmp_data = []
+        for da in self.data:
+            if len(da['image']) > 8:
+                continue
+            if da['conversations'][-1]['role'] != 'assistant' or len(da['conversations'][-1]['content'].strip()) == 0:
+                continue
+            tmp_data.append(da)
+        self.data = tmp_data
+        accelerator.print(f'Training data size: {len(self.data)} samples')
+
+        self.assistant_token_id = self.processor.tokenizer.convert_tokens_to_ids("<|im_start|>")
+        self.assistant_prefix_ids = self.processor.tokenizer.encode("<|im_start|>assistant\n", add_special_tokens=False, return_tensors="pt")[0]
+        self.eos_token_id = self.processor.tokenizer.convert_tokens_to_ids("<|im_end|>")
+
+        self.image_sizes = (config.max_width, config.max_height)
+        accelerator.print(f'Total dataset size: {len(self.data)}')
+
+        # Padding
+        self.image_padding = {'pixel_values': torch.zeros(24, 1176), 'image_grid_thw': torch.tensor([[1, 4, 6]])}
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, index: int) -> Dict[str, torch.Tensor]:
+        return self.data[index]
+
+    def collate_fn(self, batch: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
+        texts = []
+        images = []
+
+        for item in batch:
+            img_num = 0
+
+            if len(item['image']) > 0 and '<image>' not in ''.join([x['content'] for x in item['conversations']]):
+                item["conversations"][0]['content'] = '\n'.join(['<image>']*len(item['image']))+'\n'+item["conversations"][0]['content']
+
+            if len(item['image']) > 0:
+                for k in item["conversations"]:
+                    img_num +=  k['content'].count('<image>')
+                    k['content'] = k['content'].replace("<image>", "<|vision_start|><|image_pad|><|vision_end|>")
+                assert img_num == len(item['image']), f"Image count mismatch: {img_num} != {len(item['image'])}\n{item['conversations']}"
+            input_text = self.processor.apply_chat_template(item["conversations"], add_generation_prompt=False, tokenize=False)
+            texts.append(input_text)
+            images.extend(item["image"])
+
+        img_list = [fetch_image({"type": "image", "image": img_path,"max_pixels": self.image_sizes[0] * self.image_sizes[1]}) for img_path in images]
+
+        if len(img_list) > 0:
+            inputs = self.processor(text=texts, images=img_list, return_tensors="pt", padding=True)
+            pixel_values = inputs['pixel_values']
+            image_grid_thw = inputs['image_grid_thw']
+            assert inputs['input_ids'].shape[0] <= self.config.max_seq_len, f"input_ids length exceeds max_seq_len: {inputs['input_ids'].shape[0]} > {self.config.max_seq_len}, may cause errors!!"
+        else:
+            inputs = self.processor.tokenizer(text=texts, return_tensors="pt", add_special_tokens=False, truncation=True, padding=True, max_length=self.config.max_seq_len)
+            pixel_values = self.image_padding['pixel_values']
+            image_grid_thw = self.image_padding['image_grid_thw']
+
+        labels = torch.full_like(inputs['input_ids'], -100)
+        for batch_idx in range(inputs['input_ids'].size(0)):
+            input_ids = inputs['input_ids'][batch_idx]
+            assistant_indices = (input_ids == self.assistant_token_id).nonzero(as_tuple=True)[0]
+
+            stop_flag = False
+            
+            for idx in reversed(assistant_indices):
+                if not torch.equal(input_ids[idx:idx+len(self.assistant_prefix_ids)], self.assistant_prefix_ids):
+                    continue
+
+                for j in range(idx + len(self.assistant_prefix_ids), len(input_ids)):
+                    labels[batch_idx, j] = input_ids[j]
+                    if input_ids[j] == self.eos_token_id:
+                        stop_flag = True
+                        break
+                
+                if stop_flag:
+                    break
+
+        assert inputs['attention_mask'].shape[0] <= self.config.max_seq_len, f"attention_mask length exceeds max_seq_len: {inputs['attention_mask'].shape[0]} > {self.config.max_seq_len}"
+
+        return {
+            "input_ids": inputs['input_ids'][:, :self.config.max_seq_len],
+            "labels": labels[:, :self.config.max_seq_len],
+            "attention_mask": inputs['attention_mask'][:, :self.config.max_seq_len],
+            "pixel_values": pixel_values,
+            "image_grid_thw": image_grid_thw
+        }
+
+def save_checkpoint(
+    model,
+    processor,
+    accelerator: Accelerator,
+    args: argparse.Namespace,
+    epoch: int,
+    step: int,
+    global_step: int,
+    is_last: bool = False
+) -> None:
+    save_dir = os.path.join(args.output_dir, f"checkpoint-{epoch}-{global_step}")
+    
+    if accelerator.is_main_process:
+        # Manage number of checkpoints
+        checkpoint_files = [f for f in os.listdir(args.output_dir) if f.startswith("checkpoint-")]
+        if args.max_ckpts > 0 and len(checkpoint_files) >= args.max_ckpts:
+            oldest_ckpt = min(checkpoint_files, key=lambda x: os.path.getctime(os.path.join(args.output_dir, x)))
+            shutil.rmtree(os.path.join(args.output_dir, oldest_ckpt))
+
+        os.makedirs(save_dir, exist_ok=True)
+        output_dir = os.path.join(save_dir, 'tfmr')
+
+        # Save model and tokenizer
+        if accelerator.state.deepspeed_plugin.zero_stage != 3:
+            model.save_pretrained(output_dir, state_dict=accelerator.get_state_dict(model))
+        processor.save_pretrained(output_dir)
+
+        logger.info(f'Model saved in {output_dir}')
+
+    # Handle DeepSpeed stage 3
+    if accelerator.state.deepspeed_plugin.zero_stage == 3:
+        unwrap_model = accelerator.unwrap_model(model)
+        unwrap_model.save_pretrained(
+            os.path.join(save_dir, 'tfmr'),
+            is_main_process=accelerator.is_main_process,
+            save_function=accelerator.save,
+            state_dict=accelerator.get_state_dict(model)
+        )
+
+    accelerator.wait_for_everyone()
+    logger.info(f'Checkpoint {epoch}-{global_step} saved successfully')
+
+    if args.save_state:
+        try:
+            accelerator.save_state(save_dir)
+        except Exception as e:
+            logger.info(f"Failed to save state: {e}")
+
+
+def train(args: argparse.Namespace) -> None:
+    """Main training function"""
+    accelerator = Accelerator(
+        mixed_precision='bf16',
+        gradient_accumulation_steps=args.gradient_accumulation_steps
+    )
+
+    if accelerator.is_main_process:
+        wandb.init(
+            project=args.experiment_name,
+            name=args.run_name,
+            config=args,
+            dir=args.log_dir,
+            mode="offline"
+        )
+
+    accelerator.state.deepspeed_plugin.deepspeed_config['train_micro_batch_size_per_gpu'] = args.train_bsz_per_gpu
+    accelerator.state.deepspeed_plugin.deepspeed_config['train_batch_size'] = (
+        args.train_bsz_per_gpu * 
+        dist.get_world_size() * 
+        accelerator.gradient_accumulation_steps
+    )
+
+    processor = Qwen2_5_VLProcessor.from_pretrained(args.model_path, trust_remote_code=True)
+    model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+        args.model_path,
+        trust_remote_code=True,
+        attn_implementation='flash_attention_2',
+        torch_dtype=torch.bfloat16
+    )
+
+    if args.gradient_checkpointing:
+        model.gradient_checkpointing_enable()
+
+    # Freeze components if required
+    if args.freeze_vision_tower:
+        logger.info("Freezing vision tower parameters")
+        for param in model.visual.parameters():
+            param.requires_grad = False
+        for param in model.visual.merger.parameters():
+            param.requires_grad = True
+
+    if args.freeze_multi_modal_projector:
+        logger.info("Freezing multi-modal projector parameters")
+        for param in model.visual.merger.parameters():
+            param.requires_grad = False
+
+    if args.freeze_language_model:
+        logger.info("Freezing language model parameters")
+        for param in model.model.parameters():
+            param.requires_grad = False
+
+    # Display parameter statistics
+    if args.freeze_vision_tower or args.freeze_language_model or args.freeze_multi_modal_projector:
+        trainable_params, all_params = 0, 0
+        param_status = {}
+        for name, param in model.named_parameters():
+            all_params += param.numel()
+            if param.requires_grad:
+                trainable_params += param.numel()
+                module_name = name.split('.')[0] if '.' in name else name
+                if module_name not in param_status:
+                    param_status[module_name] = {'trainable': 0, 'frozen': 0}
+                param_status[module_name]['trainable'] += param.numel()
+            else:
+                module_name = name.split('.')[0] if '.' in name else name
+                if module_name not in param_status:
+                    param_status[module_name] = {'trainable': 0, 'frozen': 0}
+                param_status[module_name]['frozen'] += param.numel()
+
+        accelerator.print(f"Total model params: {all_params/1e6:.2f}M, Trainable: {trainable_params/1e6:.2f}M ({trainable_params/all_params*100:.2f}%)")
+        accelerator.print("Module-wise parameter status:")
+        for module, stats in param_status.items():
+            total = stats['trainable'] + stats['frozen']
+            if total > 0:
+                accelerator.print(f"  - {module}: Total {total/1e6:.2f}M, Trainable {stats['trainable']/1e6:.2f}M ({stats['trainable']/total*100:.2f}%), Frozen {stats['frozen']/1e6:.2f}M ({stats['frozen']/total*100:.2f}%)")
+
+    # Optimizer setup
+    no_decay = ["bias", "LayerNorm.weight"]
+    optimizer_grouped_parameters = [
+        {"params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], "weight_decay": args.weight_decay},
+        {"params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], "weight_decay": 0.0},
+    ]
+    optimizer = torch.optim.AdamW(optimizer_grouped_parameters, lr=args.learning_rate)
+
+    train_dataset = SftDataset(args, processor, accelerator)
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=args.train_bsz_per_gpu,
+        shuffle=True,
+        drop_last=True,
+        collate_fn=train_dataset.collate_fn,
+        num_workers=4
+    )
+
+    num_training_steps = int(len(train_dataloader) * args.n_epochs) // accelerator.gradient_accumulation_steps // dist.get_world_size()
+    lr_scheduler = get_custom_cosine_schedule_with_warmup(
+        optimizer,
+        num_warmup_steps=int(args.warmup_rates * num_training_steps),
+        num_training_steps=num_training_steps,
+        min_lr_ratio=args.min_lr_ratio
+    )
+
+    model, optimizer, train_dataloader = accelerator.prepare(model, optimizer, train_dataloader)
+    metric = TrainingMetrics(device=torch.cuda.current_device())
+    model.train()
+
+    global_step = 0
+    inepoch_step = 0
+    start_epoch = 0
+
+    for epoch in range(start_epoch, args.n_epochs):
+        train_iter = tqdm(train_dataloader, total=len(train_dataloader)) if accelerator.is_main_process else train_dataloader
+
+        for batch in train_iter:
+            if inepoch_step > 0:
+                inepoch_step -= 1
+                continue
+
+            outputs = model(
+                input_ids=batch['input_ids'],
+                labels=batch['labels'],
+                attention_mask=batch['attention_mask'],
+                pixel_values=batch['pixel_values'],
+                image_grid_thw=batch['image_grid_thw'],
+                return_dict=True,
+                use_cache=False
+            )
+            loss = outputs.loss
+            metric(outputs.logits, batch['labels'], loss)
+
+            accelerator.backward(loss)
+
+            if args.max_grad_norm > 0:
+                accelerator.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+
+            if (global_step + 1) % accelerator.gradient_accumulation_steps == 0:
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+
+                if (global_step + 1) % (accelerator.gradient_accumulation_steps * 2) == 0:
+                    torch.cuda.empty_cache()
+
+            global_step += 1
+
+            if (global_step + 1) % accelerator.gradient_accumulation_steps == 0:
+                acc, train_loss = metric.get_metric()
+                if accelerator.is_main_process:
+                    train_iter.set_postfix(
+                        epoch=epoch,
+                        step=global_step - 1,
+                        total_steps=len(train_dataloader),
+                        skip=accelerator.optimizer_step_was_skipped,
+                        length=len(batch["input_ids"][0]),
+                        loss=f"{train_loss:.3f}",
+                        acc=f"{acc:.3f}",
+                        lr=f"{lr_scheduler.get_last_lr()[0]:.2e}"
+                    )
+
+                    wandb.log({
+                        'loss': train_loss,
+                        'acc': acc,
+                        'lr': lr_scheduler.get_last_lr()[0]
+                    }, step=global_step)
+
+        accelerator.wait_for_everyone()
+        save_checkpoint(
+            model=model,
+            processor=processor, 
+            accelerator=accelerator,
+            args=args,
+            epoch=epoch,
+            step=global_step - 1,
+            global_step=global_step,
+            is_last=True
+        )
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Pretraining Configuration')
+    
+    # Experiment
+    parser.add_argument('--experiment_name', type=str, help='Experiment name')
+    parser.add_argument('--run_name', type=str, default=None, help='Run name')
+    parser.add_argument('--model_path', type=str, default='', help='Pretrained model path')
+
+    # Data
+    parser.add_argument('--data_path', type=str, required=True, help='Training data path')
+    parser.add_argument('--output_dir', type=str, default='./', help='Model save path')
+    parser.add_argument('--max_ckpts', type=int, default=3, help='Max number of checkpoints')
+    parser.add_argument('--log_dir', type=str, default='./', help='Log directory')
+
+    # Training
+    parser.add_argument('--max_seq_len', type=int, default=4096, help='Max sequence length')
+    parser.add_argument('--gradient_checkpointing', action='store_true', help='Enable gradient checkpointing')
+    parser.add_argument('--gradient_accumulation_steps', type=int, default=16, help='Gradient accumulation steps')
+    parser.add_argument('--max_grad_norm', type=float, default=1.0, help='Gradient clipping threshold')
+    parser.add_argument('--train_bsz_per_gpu', type=int, default=1, help='Batch size per GPU')
+    parser.add_argument('--weight_decay', type=float, default=0.1, help='Weight decay')
+    parser.add_argument('--learning_rate', type=float, default=5e-6, help='Learning rate')
+    parser.add_argument('--min_lr_ratio', type=float, default=0.15, help='Min learning rate ratio')
+    parser.add_argument('--warmup_rates', type=float, default=0.05, help='Warmup rate')
+    parser.add_argument('--n_epochs', type=int, default=2, help='Number of training epochs')
+    parser.add_argument('--save_steps', type=int, default=2000, help='Checkpoint saving interval')
+    parser.add_argument('--save_state', action='store_true', help='Save accelerator state')
+    parser.add_argument('--resume_from_checkpoint', action='store_true', help='Resume from checkpoint')
+
+    parser.add_argument('--freeze_vision_tower', action='store_true', help='Freeze vision tower')
+    parser.add_argument('--freeze_language_model', action='store_true', help='Freeze language model')
+    parser.add_argument('--freeze_multi_modal_projector', action='store_true', help='Freeze multi-modal projector')
+
+    # Image
+    parser.add_argument('--max_width', type=int, default=420, help='Max image width')
+    parser.add_argument('--max_height', type=int, default=360, help='Max image height')
+
+    # Misc
+    parser.add_argument('--seed', type=int, default=42, help='Random seed')
+
+    args = parser.parse_args()
+    
+    # Set paths
+    args.log_dir = os.path.join(args.log_dir, args.experiment_name)
+    args.output_dir = os.path.join(args.output_dir, args.experiment_name)
+    if args.run_name:
+        args.output_dir = os.path.join(args.output_dir, args.run_name)
+
+    os.makedirs(args.log_dir, exist_ok=True)
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    set_seed(args.seed)
+    train(args)

之前的代码版本/注意力关键词用于sam的/MedEvalKit/LLaVA-NeXT/playground/demo/video_demo.py

@@ -0,0 +1,335 @@
+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_anyres_image,tokenizer_image_token, get_model_name_from_path, KeywordsStoppingCriteria
+
+import json
+import os
+import math
+from tqdm import tqdm
+from decord import VideoReader, cpu
+
+from transformers import AutoConfig
+
+import cv2
+import base64
+import openai
+
+from PIL import Image
+
+
+
+import numpy as np
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i : i + chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+def parse_args():
+    """
+    Parse command-line arguments.
+    """
+    parser = argparse.ArgumentParser()
+
+    # Define the command-line arguments
+    parser.add_argument("--video_path", help="Path to the video files.", required=True)
+    parser.add_argument("--output_dir", help="Directory to save the model results JSON.", required=True)
+    parser.add_argument("--output_name", help="Name of the file for storing results JSON.", required=True)
+    parser.add_argument("--model-path", type=str, default="facebook/opt-350m")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--conv-mode", type=str, default=None)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--mm_resampler_type", type=str, default="spatial_pool")
+    parser.add_argument("--mm_spatial_pool_stride", type=int, default=4)
+    parser.add_argument("--mm_spatial_pool_out_channels", type=int, default=1024)
+    parser.add_argument("--mm_spatial_pool_mode", type=str, default="average")
+    parser.add_argument("--image_aspect_ratio", type=str, default="anyres")
+    parser.add_argument("--image_grid_pinpoints", type=str, default="[(224, 448), (224, 672), (224, 896), (448, 448), (448, 224), (672, 224), (896, 224)]")
+    parser.add_argument("--mm_patch_merge_type", type=str, default="spatial_unpad")
+    parser.add_argument("--overwrite", type=lambda x: (str(x).lower() == 'true'), default=True)
+    parser.add_argument("--for_get_frames_num", type=int, default=4)
+    parser.add_argument("--load_8bit",  type=lambda x: (str(x).lower() == 'true'), default=False)
+    parser.add_argument("--prompt", type=str, default=None) 
+    parser.add_argument("--api_key", type=str, help="OpenAI API key")
+    parser.add_argument("--mm_newline_position", type=str, default="no_token")
+    parser.add_argument("--force_sample", type=lambda x: (str(x).lower() == 'true'), default=False)
+    parser.add_argument("--add_time_instruction", type=str, default=False)
+    return parser.parse_args()
+
+def load_video(video_path,args):
+    if args.for_get_frames_num == 0:
+        return np.zeros((1, 336, 336, 3))
+    vr = VideoReader(video_path, ctx=cpu(0),num_threads=1)
+    total_frame_num = len(vr)
+    video_time = total_frame_num / vr.get_avg_fps()
+    fps = round(vr.get_avg_fps())
+    frame_idx = [i for i in range(0, len(vr), fps)]
+    frame_time = [i/fps for i in frame_idx]
+    if len(frame_idx) > args.for_get_frames_num or args.force_sample:
+        sample_fps = args.for_get_frames_num
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, sample_fps, dtype=int)
+        frame_idx = uniform_sampled_frames.tolist()
+        frame_time = [i/vr.get_avg_fps() for i in frame_idx]
+    frame_time = ",".join([f"{i:.2f}s" for i in frame_time])
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    # import pdb;pdb.set_trace()
+
+    return spare_frames,frame_time,video_time
+
+
+
+
+def load_video_base64(path):
+    video = cv2.VideoCapture(path)
+
+    base64Frames = []
+    while video.isOpened():
+        success, frame = video.read()
+        if not success:
+            break
+        _, buffer = cv2.imencode(".jpg", frame)
+        base64Frames.append(base64.b64encode(buffer).decode("utf-8"))
+
+    video.release()
+    # print(len(base64Frames), "frames read.")
+    return base64Frames
+
+
+def run_inference(args):
+    """
+    Run inference on ActivityNet QA DataSet using the Video-ChatGPT model.
+
+    Args:
+        args: Command-line arguments.
+    """
+    # Initialize the model
+    if "gpt4v" != args.model_path:
+        model_name = get_model_name_from_path(args.model_path)
+        # Set model configuration parameters if they exist
+        if args.overwrite == True:
+            overwrite_config = {}
+            overwrite_config["mm_spatial_pool_mode"] = args.mm_spatial_pool_mode
+            overwrite_config["mm_spatial_pool_stride"] = args.mm_spatial_pool_stride
+            overwrite_config["mm_newline_position"] = args.mm_newline_position
+
+            cfg_pretrained = AutoConfig.from_pretrained(args.model_path)
+
+            # import pdb;pdb.set_trace()
+            if "qwen" not in args.model_path.lower():
+                if "224" in cfg_pretrained.mm_vision_tower:
+                    # suppose the length of text tokens is around 1000, from bo's report
+                    least_token_number = args.for_get_frames_num*(16//args.mm_spatial_pool_stride)**2 + 1000
+                else:
+                    least_token_number = args.for_get_frames_num*(24//args.mm_spatial_pool_stride)**2 + 1000
+
+                scaling_factor = math.ceil(least_token_number/4096)
+                if scaling_factor >= 2:
+                    if "vicuna" in cfg_pretrained._name_or_path.lower():
+                        print(float(scaling_factor))
+                        overwrite_config["rope_scaling"] = {"factor": float(scaling_factor), "type": "linear"}
+                    overwrite_config["max_sequence_length"] = 4096 * scaling_factor
+                    overwrite_config["tokenizer_model_max_length"] = 4096 * scaling_factor
+
+            tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name, load_8bit=args.load_8bit, overwrite_config=overwrite_config)
+        else:
+            tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name)
+    else:
+        pass
+
+    # import pdb;pdb.set_trace()
+    if getattr(model.config, "force_sample", None) is not None:
+        args.force_sample = model.config.force_sample
+    else:
+        args.force_sample = False
+
+    # import pdb;pdb.set_trace()
+
+    if getattr(model.config, "add_time_instruction", None) is not None:
+        args.add_time_instruction = model.config.add_time_instruction
+    else:
+        args.add_time_instruction = False
+
+    # Create the output directory if it doesn't exist
+    if not os.path.exists(args.output_dir):
+        os.makedirs(args.output_dir)
+
+    output_name = args.output_name
+    answers_file = os.path.join(args.output_dir, f"{output_name}.json")
+    ans_file = open(answers_file, "w")
+
+    video_path = args.video_path
+
+    all_video_pathes = []
+
+    # Check if the video_path is a directory or a file
+    if os.path.isdir(video_path):
+        # If it's a directory, loop over all files in the directory
+        for filename in os.listdir(video_path):
+                    # Load the video file
+            cur_video_path = os.path.join(video_path, f"{filename}")
+            all_video_pathes.append(os.path.join(video_path, cur_video_path))
+    else:
+        # If it's a file, just process the video
+        all_video_pathes.append(video_path) 
+
+    # import pdb;pdb.set_trace()
+    for video_path in all_video_pathes:
+
+        sample_set = {}
+        question = args.prompt
+        sample_set["Q"] = question
+        sample_set["video_name"] = video_path
+        
+
+        # Check if the video exists
+        if os.path.exists(video_path):
+            if "gpt4v" != args.model_path:
+                video,frame_time,video_time = load_video(video_path, args)
+                video = image_processor.preprocess(video, return_tensors="pt")["pixel_values"].half().cuda()
+                video = [video]
+            else:
+                spare_frames,frame_time,video_time = load_video_base64(video_path)
+                interval = int(len(video) / args.for_get_frames_num)
+
+        # try:
+        # Run inference on the video and add the output to the list
+        if "gpt4v" != args.model_path:
+            qs = question
+            if args.add_time_instruction:
+                time_instruciton = f"The video lasts for {video_time:.2f} seconds, and {len(video[0])} frames are uniformly sampled from it. These frames are located at {frame_time}.Please answer the following questions related to this video."
+                qs = f'{time_instruciton}\n{qs}'
+            if model.config.mm_use_im_start_end:
+                qs = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + "\n" + qs
+            else:
+                qs = DEFAULT_IMAGE_TOKEN + "\n" + qs
+
+            conv = conv_templates[args.conv_mode].copy()
+            conv.append_message(conv.roles[0], qs)
+            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).cuda()
+            if tokenizer.pad_token_id is None:
+                if "qwen" in tokenizer.name_or_path.lower():
+                    print("Setting pad token to bos token for qwen model.")
+                    tokenizer.pad_token_id = 151643
+                    
+            attention_masks = input_ids.ne(tokenizer.pad_token_id).long().cuda()
+
+            stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
+            keywords = [stop_str]
+            stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
+
+            cur_prompt = question
+        else:
+            prompt = question
+
+        system_error = ""
+
+        if "gpt4v" != args.model_path:
+
+
+            with torch.inference_mode():
+                # model.update_prompt([[cur_prompt]])
+                # import pdb;pdb.set_trace()
+                # output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=True, temperature=0.2, max_new_tokens=1024, use_cache=True, stopping_criteria=[stopping_criteria])
+                if "mistral" not in cfg_pretrained._name_or_path.lower():
+                    output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=False, temperature=0.0, max_new_tokens=1024, top_p=0.1,num_beams=1,use_cache=True, stopping_criteria=[stopping_criteria])
+                    # output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=True, temperature=0.2, max_new_tokens=1024, use_cache=True, stopping_criteria=[stopping_criteria])
+                else:
+                    output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=False, temperature=0.0, max_new_tokens=1024, top_p=0.1, num_beams=1, use_cache=True)
+                    # output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=True, temperature=0.2, max_new_tokens=1024, use_cache=True)
+        else:
+            openai.api_key = args.api_key  # Your API key here
+
+            max_num_retries = 0
+            retry = 5
+            PROMPT_MESSAGES = [
+                {
+                    "role": "user",
+                    "content": [
+                        f"These are frames from a video that I want to upload. Answer me one question of this video: {prompt}",
+                        *map(lambda x: {"image": x, "resize": 336}, video[0::interval]),
+                    ],
+                },
+            ]
+            params = {
+                "model": "gpt-4-vision-preview", #gpt-4-1106-vision-preview
+                "messages": PROMPT_MESSAGES,
+                "max_tokens": 1024,
+            }
+            sucess_flag=False
+            while max_num_retries < retry:
+                try:
+                    result = openai.ChatCompletion.create(**params)
+                    outputs = result.choices[0].message.content
+                    sucess_flag = True
+                    break
+                except Exception as inst :
+                    if 'error' in dir(inst):
+                        # import pdb;pdb.set_trace()
+                        if  inst.error.code == 'rate_limit_exceeded':
+                            if "TPM" in inst.error.message:
+                                time.sleep(30)
+                                continue
+                            else:
+                                import pdb;pdb.set_trace()
+                        elif inst.error.code == 'insufficient_quota':
+                            print(f'insufficient_quota key')
+                            exit()
+                        elif inst.error.code == 'content_policy_violation':
+                            print(f'content_policy_violation')
+                            system_error = "content_policy_violation"
+
+                            break
+                        print('Find error message in response: ',str(inst.error.message), 'error code: ', str(inst.error.code))
+
+                    continue
+            if not sucess_flag:
+                print(f'Calling OpenAI failed after retrying for {max_num_retries} times. Check the logs for details.')
+                exit()
+
+        if "gpt4v" != args.model_path:
+            outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+        else:
+            print(len(video[0::interval]))
+        
+        print(f"Question: {prompt}\n")
+        print(f"Response: {outputs}\n")
+
+        if "gpt4v" == args.model_path:
+            if system_error == 'content_policy_violation':
+                continue
+            elif system_error == "":
+                continue
+            else:
+                import pdb;pdb.set_trace()
+
+        # import pdb;pdb.set_trace()
+        if "mistral" not in cfg_pretrained._name_or_path.lower():
+            if outputs.endswith(stop_str):
+                outputs = outputs[: -len(stop_str)]
+
+        outputs = outputs.strip()
+
+        sample_set["pred"] = outputs
+        ans_file.write(json.dumps(sample_set, ensure_ascii=False) + "\n")
+        ans_file.flush()
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    run_inference(args)

之前的代码版本/注意力关键词用于sam的/MedEvalKit/LLaVA-NeXT/playground/remove_mid_ckpt.py

@@ -0,0 +1,35 @@
+import os
+import shutil
+import glob
+
+
+def remove_checkpoints(directory, pattern):
+    # Walk through the directory
+    for root, dirs, files in os.walk(directory):
+        # Use glob to find paths matching the pattern
+        for file_path in glob.glob(os.path.join(root, pattern)):
+            # Check if it is a directory
+            if "llava-1.6-mistral-7b" in file_path:
+                continue
+            if os.path.isdir(file_path):
+                # Remove the directory
+                print(f"Removing {file_path}")
+                input("Press Enter to continue...")
+                shutil.rmtree(file_path)
+                print(f"Removed directory: {file_path}")
+            else:
+                print(f"Removing {file_path}")
+                input("Press Enter to continue...")
+                # Remove the file
+                os.remove(file_path)
+                print(f"Removed file: {file_path}")
+
+
+# Directory containing the checkpoints
+directory = "/mnt/bn/vl-research/checkpoints/feng/"
+
+# Pattern to match in the file names
+pattern = "global_step*"
+
+# Call the function
+remove_checkpoints(directory, pattern)