Add files using upload-large-folder tool

HuatuoGPT-Vision-Abla/HuatuoGPT-Vision-7B_medical_multimodel_evaluation_data_result.json

@@ -0,0 +1,22 @@
+{
+  "OmniMedVQA": 0.7396619920891766,
+  "PMC-VQA_test": 0.5405,
+  "PathVQA_test": 0.5758477096966091,
+  "SLAKE_test": 0.7668269230769231,
+  "VQA-RAD_test": 0.5936254980079682,
+  "MMMU_Medical_Validation": 0.5448275862068965,
+  "The total score for multiple-choice questions": 0.6816973060469419,
+  "OmniMedVQA_MR (Mag-netic Resonance Imaging)": 0.725,
+  "OmniMedVQA_ultrasound": 0.7799113737075333,
+  "OmniMedVQA_OCT (Optical Coherence Tomography": 0.8701754385964913,
+  "OmniMedVQA_Dermoscopy": 0.707286432160804,
+  "OmniMedVQA_CT(Computed Tomography)": 0.6519337016574586,
+  "OmniMedVQA_X-Ray": 0.8007850834151129,
+  "OmniMedVQA_Microscopy Images": 0.7623626373626373,
+  "OmniMedVQA_Fundus Photography": 0.8226837060702875,
+  "MMMU_Medical_Validation_validation_Public_Health": 0.5333333333333333,
+  "MMMU_Medical_Validation_validation_Diagnostics_and_Laboratory_Medicine": 0.4,
+  "MMMU_Medical_Validation_validation_Pharmacy": 0.5185185185185185,
+  "MMMU_Medical_Validation_validation_Basic_Medical_Science": 0.6071428571428571,
+  "MMMU_Medical_Validation_validation_Clinical_Medicine": 0.6666666666666666
+}

HuatuoGPT-Vision-Abla/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-Abla/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-Abla/eval.py

@@ -0,0 +1,183 @@
+"""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()
+
+        if accelerator.num_processes > 1:
+            all_data = [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]
+        else:
+            # single-process run (accelerate launch --num_processes=1): torch.distributed's
+            # default process group is never initialized in this mode, so dist.get_world_size()/
+            # dist.all_gather_object would raise "Default process group has not been initialized"
+            # -- there is only one rank's data to begin with, so just use it directly.
+            all_data = cache_data
+
+        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-Abla/full_pipeline_gpu0.log

@@ -0,0 +1 @@
+nohup: ignoring input

HuatuoGPT-Vision-Abla/llava/model/language_model/llava_qwen2.py

@@ -0,0 +1,168 @@
+#    Copyright 2023 Haotian Liu
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# import sys
+# sys.path.insert(0, '/opt/conda/lib/python3.10')
+# print(sys.path)
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer, \
+                         Qwen2ForCausalLM, Qwen2Config, Qwen2Model \
+
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+from ..llava_arch import LlavaMetaModel, LlavaMetaForCausalLM
+
+
+class LlavaQwenConfig(Qwen2Config):
+    model_type = "llava_qwen2"
+
+
+class LlavaQwen2Model(LlavaMetaModel, Qwen2Model):
+    config_class = LlavaQwenConfig
+
+    def __init__(self, config: Qwen2Config):
+        super(LlavaQwen2Model, self).__init__(config)
+
+
+class LlavaQwen2ForCausalLM(Qwen2ForCausalLM, LlavaMetaForCausalLM):
+    config_class = LlavaQwenConfig
+
+    def __init__(self, config, init_vision_encoder_from_ckpt=False):
+        # config._attn_implementation = "flash_attention_2"
+        # config._flash_attn_2_enabled = True
+        super(Qwen2ForCausalLM, self).__init__(config)
+        self.model = LlavaQwen2Model(config)
+        # assert self.model._use_flash_attention_2 == True
+        # self.tokenizer = AutoTokenizer.from_pretrained(config._name_or_path,padding_side="left")
+        self.tokenizer = None
+        # self.pretraining_tp = config.pretraining_tp
+        self.vocab_size = config.vocab_size
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # if getattr(config, 'init_vision_encoder_from_ckpt', True):
+        if init_vision_encoder_from_ckpt:
+            vision_tower = self.get_vision_tower()
+            print(f'loading from CLIP first. This should only be used at inference!!!')
+            vision_tower.load_model() # 
+            
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_model(self):
+        return self.model
+    
+    def get_tokenizer(self):
+        return self.tokenizer
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        images: Optional[torch.FloatTensor] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+
+        if inputs_embeds is None:
+            (
+                input_ids,
+                position_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                labels
+            # ) = self.prepare_inputs_labels_for_multimodal(
+            ) = self.prepare_inputs_labels_for_multimodal_new(
+                input_ids,
+                position_ids,
+                attention_mask,
+                past_key_values,
+                labels,
+                images
+            )
+
+        return super().forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            labels=labels,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict
+        )
+
+    @torch.no_grad()
+    def generate(
+        self,
+        inputs: Optional[torch.Tensor] = None,
+        images: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) :
+        position_ids = kwargs.pop("position_ids", None)
+        attention_mask = kwargs.pop("attention_mask", None)
+        if "inputs_embeds" in kwargs:
+            raise NotImplementedError("`inputs_embeds` is not supported")
+
+        if images is not None:
+            (
+                inputs,
+                position_ids,
+                attention_mask,
+                _,
+                inputs_embeds,
+                _
+            ) = self.prepare_inputs_labels_for_multimodal_new(
+                inputs,
+                position_ids,
+                attention_mask,
+                None,
+                None,
+                images
+            )
+        else:
+            inputs_embeds = self.get_model().embed_tokens(inputs)
+
+        # print(inputs_embeds.shape)
+        return super().generate(
+            position_ids=None,
+            attention_mask=None,
+            inputs_embeds=inputs_embeds,
+            **kwargs
+        )
+
+    def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
+        images = kwargs.pop("images", None)
+        _inputs = super().prepare_inputs_for_generation(
+            input_ids, past_key_values=past_key_values, inputs_embeds=inputs_embeds, **kwargs
+        )
+        if images is not None:
+            _inputs['images'] = images
+        return _inputs
+
+# AutoConfig.register("llava", LlavaQwenConfig)
+AutoConfig.register("llava_qwen2", LlavaQwenConfig)
+AutoModelForCausalLM.register(LlavaQwenConfig, LlavaQwen2ForCausalLM)

HuatuoGPT-Vision-Abla/llava/model/multimodal_projector/builder.py

@@ -0,0 +1,51 @@
+import torch
+import torch.nn as nn
+import re
+
+
+class IdentityMap(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, *args, **kwargs):
+        return x
+
+    @property
+    def config(self):
+        return {"mm_projector_type": 'identity'}
+
+
+class SimpleResBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.pre_norm = nn.LayerNorm(channels)
+
+        self.proj = nn.Sequential(
+            nn.Linear(channels, channels),
+            nn.GELU(),
+            nn.Linear(channels, channels)
+        )
+    def forward(self, x):
+        x = self.pre_norm(x)
+        return x + self.proj(x)
+
+
+def build_vision_projector(config, delay_load=False, **kwargs):
+    projector_type = getattr(config, 'mm_projector_type', 'linear')
+
+    if projector_type == 'linear':
+        return nn.Linear(config.mm_hidden_size, config.hidden_size)
+
+    mlp_gelu_match = re.match(r'^mlp(\d+)x_gelu$', projector_type)
+    if mlp_gelu_match:
+        mlp_depth = int(mlp_gelu_match.group(1))
+        modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]
+        for _ in range(1, mlp_depth):
+            modules.append(nn.GELU())
+            modules.append(nn.Linear(config.hidden_size, config.hidden_size))
+        return nn.Sequential(*modules)
+
+    if projector_type == 'identity':
+        return IdentityMap()
+
+    raise ValueError(f'Unknown projector type: {projector_type}')

HuatuoGPT-Vision-Abla/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-Abla/results_attnbias/HuatuoGPT-Vision-7B/sam_vis/HuatuoGPT-Vision-7B_medical_multimodel_evaluation_data_vis_Lt17_kt0.0_nt0.0_Lv17_kv1.0_nv0.0_result.json

@@ -0,0 +1,22 @@
+{
+  "OmniMedVQA": 0.7444264653002517,
+  "PMC-VQA_test": 0.5475,
+  "PathVQA_test": 0.5847709696609161,
+  "SLAKE_test": 0.7475961538461539,
+  "VQA-RAD_test": 0.6135458167330677,
+  "MMMU_Medical_Validation": 0.5241379310344828,
+  "The total score for multiple-choice questions": 0.6869580298300382,
+  "OmniMedVQA_MR (Mag-netic Resonance Imaging)": 0.7309405940594059,
+  "OmniMedVQA_ultrasound": 0.7740029542097489,
+  "OmniMedVQA_OCT (Optical Coherence Tomography": 0.8614035087719298,
+  "OmniMedVQA_Dermoscopy": 0.7185929648241206,
+  "OmniMedVQA_CT(Computed Tomography)": 0.6569563033651431,
+  "OmniMedVQA_X-Ray": 0.8056918547595682,
+  "OmniMedVQA_Microscopy Images": 0.7802197802197802,
+  "OmniMedVQA_Fundus Photography": 0.8306709265175719,
+  "MMMU_Medical_Validation_validation_Public_Health": 0.4666666666666667,
+  "MMMU_Medical_Validation_validation_Diagnostics_and_Laboratory_Medicine": 0.36666666666666664,
+  "MMMU_Medical_Validation_validation_Pharmacy": 0.48148148148148145,
+  "MMMU_Medical_Validation_validation_Basic_Medical_Science": 0.5714285714285714,
+  "MMMU_Medical_Validation_validation_Clinical_Medicine": 0.7333333333333333
+}

HuatuoGPT-Vision-Abla/results_attnbias/HuatuoGPT-Vision-7B/sam_vis/_snapshot/run_ablation_grid_pick.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+# Picks the best (strength_text, strength_vis) across the full grid and syncs
+# it into every run_eval_attnbias_sam_*.sh via sync_attn_params.py. Run this
+# ONCE, by hand, after every run_ablation_grid_worker.sh slice (on every GPU
+# you split the grid across) has finished -- it requires *all* combos'
+# *_result.json to be present, since the "best" choice isn't meaningful until
+# the whole grid has been scored.
+#
+# FINAL METHOD = run_eval_attnbias_sam_both.sh: nonkey_bias is
+# pinned at 0 (amplify_only -- boost key regions only, no suppression) AND the
+# grid was searched with the auction mechanism OFF (see
+# run_ablation_grid_worker.sh), matching the final method exactly.
+# run_eval_attnbias_sam_both_suppress_only.sh has been dropped from
+# run_all_attnbias_sam.sh's comparison set (no longer a live ablation arm), so
+# there's no risk of this sync corrupting it.
+set -e
+
+source /home/jinhua/miniconda3/etc/profile.d/conda.sh
+conda activate huatuovision
+
+LAYER=17
+# must stay identical to run_ablation_grid_worker.sh's copy of these arrays.
+STRENGTHS_TEXT=(1.0 2.0 3.0 4.0 5.0)
+STRENGTHS_VIS=(1.0 2.0 3.0 4.0 5.0)
+
+# ── pick the best (s_text, s_vis) across the full grid, layer fixed at 17.
+#    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_S_TEXT=""
+BEST_S_VIS=""
+BEST_SCORE=""
+for S_TEXT in "${STRENGTHS_TEXT[@]}"; do
+    for S_VIS in "${STRENGTHS_VIS[@]}"; do
+        OUTPUT_PATH="results_attnbias_ablation/HuatuoGPT-Vision-7B/sam_both_amplify_noauction_layer${LAYER}_stext${S_TEXT}_svis${S_VIS}"
+        RESULT_F=$(ls "$OUTPUT_PATH"/*_result.json 2>/dev/null | head -n1)
+        if [ -z "$RESULT_F" ]; then
+            echo "[ablation-grid-pick] missing *_result.json under $OUTPUT_PATH -- cannot pick best (s_text, s_vis). Did every run_ablation_grid_worker.sh slice finish?" >&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-pick] s_text=$S_TEXT s_vis=$S_VIS score=$SCORE"
+        if [ -z "$BEST_SCORE" ] || python -c "exit(0 if $SCORE > $BEST_SCORE else 1)"; then
+            BEST_SCORE="$SCORE"
+            BEST_S_TEXT="$S_TEXT"
+            BEST_S_VIS="$S_VIS"
+        fi
+    done
+done
+
+echo "[ablation-grid-pick] best overall: layer=$LAYER s_text=$BEST_S_TEXT s_vis=$BEST_S_VIS (score=$BEST_SCORE)"
+echo "[ablation-grid-pick] syncing into every run_eval_attnbias_sam_*.sh via sync_attn_params.py"
+
+python sync_attn_params.py \
+    --layers_text "$LAYER" --key_bias_text "$BEST_S_TEXT" --nonkey_bias_text "0" \
+    --layers_vis  "$LAYER" --key_bias_vis  "$BEST_S_VIS"  --nonkey_bias_vis  "0"
+
+echo "[ablation-grid-pick] done. All run_eval_attnbias_sam_*.sh now use the ablation-selected layer/strength (nonkey_bias=0, amplify_only style)"
+echo "[ablation-grid-pick] (amplify_only keeps its pinned-zero side; text.sh/vis.sh keep their single-modality side -- see sync_attn_params.py)."

HuatuoGPT-Vision-Abla/results_attnbias/HuatuoGPT-Vision-7B/sam_vis/_snapshot/run_eval_attnbias_sam_both.sh

@@ -0,0 +1,45 @@
+#!/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-Abla/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision-Abla/MedSAM3"
+
+# FINAL METHOD: both mode, amplify-only (nonkey_bias pinned at 0 -- boost key
+# regions, don't suppress anything else) and auction OFF -- every Stage1/SAM-
+# detected key position gets boosted directly, not just an auction-selected
+# subset (ablation found the auction mechanism doesn't help over this simpler
+# design; see run_eval_attnbias_sam_both_noauction.sh, kept around for
+# reference but no longer part of the active comparison set).
+INTERVENTION="both"
+ATTN_LAYERS_TEXT=17
+ATTN_KEY_BIAS_TEXT=5.0
+ATTN_NONKEY_BIAS_TEXT=0
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=1.0
+ATTN_NONKEY_BIAS_VIS=0
+
+MAX_SAMPLES=""
+
+accelerate launch --num_processes=1 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-Abla/run_ablation_grid.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+# Full grid search over (strength_text, strength_vis) for the "both"
+# intervention mode WITH Budgeted Token Auction enabled, split across GPU 0
+# and GPU 2 and run concurrently via run_ablation_grid_worker.sh (GPU 1/3 are
+# occupied by other people's jobs on this workstation, so 0/2 are used
+# instead of the usual 0/1 -- see run_eval.sh for the same reasoning). The bias
+# layer is fixed at 17 for both modalities; text and vis each get their own
+# strength sweep and every (strength_text, strength_vis) combination is run --
+# kbt=nbt=-s_text, kbv=nbv=-s_vis for s_text in STRENGTHS_TEXT, s_vis in
+# STRENGTHS_VIS. Stage1/SAM results are 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
+# a combo only re-pays the much cheaper bias-intervention generation pass.
+# Auction budgets/alpha/beta are fixed at their defaults here -- this script
+# only sweeps bias 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.
+#
+# NOTE: picking the best (s_text, s_vis) and syncing it into every
+# run_eval_attnbias_sam_*.sh needs the WHOLE grid scored first, so it is
+# NOT done here -- run ./run_ablation_grid_pick.sh by hand once this script
+# (both GPU workers) finishes. STRENGTHS_TEXT/STRENGTHS_VIS/LAYER are defined
+# independently in run_ablation_grid_worker.sh and run_ablation_grid_pick.sh;
+# keep all three in sync if you change the grid.
+#
+# Pass 0 (keyword/Stage1/SAM extraction) in eval_attnbias_sam.py caches its
+# output keyed only on (data_path, model_path, seed) -- every combo in this
+# grid shares the exact same key, so both GPU workers would hit the *same*
+# cache file. accelerator.wait_for_everyone() only synchronizes ranks within
+# one `accelerate launch` process group; GPU0's and GPU2's workers are two
+# fully independent processes with no cross-process coordination, so if both
+# ran Pass 0 concurrently on a cold cache they'd race to read-modify-write the
+# same JSON file (worst case: interleaved writes corrupt it; typical case:
+# whichever finishes last silently clobbers the other's freshly-computed
+# entries with the stale snapshot it read at startup) and both would
+# redundantly re-run the expensive Stage1+SAM pass over the whole dataset.
+# Fix: run ONE combo alone first (GPU 0, combo index 0) to fully populate the
+# cache -- Pass 0 always covers the whole dataset regardless of which combo is
+# running, so after this single warmup run every subsequent Pass 0 (on either
+# GPU) is a pure cache hit and never writes to the file, making the parallel
+# phase below race-free.
+set -e
+
+echo "[ablation-grid] warmup: running combo 0 alone on GPU 0 to populate the Pass0 cache before parallelizing"
+./run_ablation_grid_worker.sh 0 0 1 > ablation_grid_warmup.log 2>&1
+echo "[ablation-grid] warmup done (log: ablation_grid_warmup.log)"
+
+TOTAL=25   # len(STRENGTHS_TEXT) * len(STRENGTHS_VIS), see run_ablation_grid_worker.sh
+SPLIT=13   # combos [1, SPLIT) -> GPU 0, combos [SPLIT, TOTAL) -> GPU 2
+# combo 0 already ran during warmup above -- GPU0's parallel slice starts at
+# index 1 (not 0) so it isn't touched again at all, not even via the
+# OUTPUT_PATH-exists skip check.
+
+echo "[ablation-grid] launching GPU 0 on combos [1, $SPLIT) and GPU 2 on combos [$SPLIT, $TOTAL) in parallel"
+
+./run_ablation_grid_worker.sh 0 1 $((SPLIT - 1)) > ablation_grid_gpu0.log 2>&1 &
+PID0=$!
+./run_ablation_grid_worker.sh 2 "$SPLIT" $((TOTAL - SPLIT)) > ablation_grid_gpu2.log 2>&1 &
+PID1=$!
+
+echo "[ablation-grid] gpu0 worker pid=$PID0 (log: ablation_grid_gpu0.log), gpu2 worker pid=$PID1 (log: ablation_grid_gpu2.log)"
+
+wait "$PID0"
+STATUS0=$?
+wait "$PID1"
+STATUS1=$?
+
+if [ "$STATUS0" -ne 0 ] || [ "$STATUS1" -ne 0 ]; then
+    echo "[ablation-grid] a worker failed (gpu0 exit=$STATUS0, gpu2 exit=$STATUS1) -- check ablation_grid_gpu{0,2}.log before running run_ablation_grid_pick.sh" >&2
+    exit 1
+fi
+
+echo "[ablation-grid] both workers finished, all $TOTAL combinations done"
+echo "[ablation-grid] now run: ./run_ablation_grid_pick.sh"

HuatuoGPT-Vision-Abla/run_eval.sh

@@ -0,0 +1,19 @@
+#!/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
+
+# 单卡跑，卡1/卡3被其他任务占用(其他人的进程)，显式锁定卡0(确认空闲的卡)。
+# Single GPU -- pin to GPU 0 explicitly (confirmed free; GPU 1/3 are occupied
+# by other jobs on this workstation).
+export CUDA_VISIBLE_DEVICES=0
+
+accelerate launch --num_processes=1 eval.py \
+    --data_path       "$DATA_PATH"       \
+    --model_path      "$MODEL_PATH"      \
+    --seed            "$SEED"            \
+    --max_new_tokens  "$MAX_NEW_TOKENS"

HuatuoGPT-Vision-Abla/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-Abla/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision-Abla/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=0
+ATTN_LAYERS_VIS=17
+ATTN_KEY_BIAS_VIS=0.0
+ATTN_NONKEY_BIAS_VIS=0
+
+AUCTION_TOTAL_RATIO=0.8
+AUCTION_NEG_RATIO=0.8
+
+MAX_SAMPLES=""
+
+accelerate launch --num_processes=1 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-Abla/run_eval_attnbias_sam_vis.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_vis"
+
+SEED=42
+MAX_NEW_TOKENS=256
+
+MEDSAM3_CONFIG="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision-Abla/MedSAM3/configs/full_lora_config.yaml"
+MEDSAM3_DIR="/home/jinhua/ExplainableVQA/HuatuoGPT-Vision-Abla/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"). Matches run_eval_attnbias_sam_both.sh's
+# mechanism (amplify-only, auction OFF) so this differs from the final method
+# by exactly one factor (modality restricted to vis); 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=1.0
+ATTN_NONKEY_BIAS_VIS=0
+
+MAX_SAMPLES=""
+
+accelerate launch --num_processes=1 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"              \
+    ${MAX_SAMPLES:+--max_samples "$MAX_SAMPLES"}

HuatuoGPT-Vision-Abla/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)