Upload 14 files

code/compute_score.py

@@ -0,0 +1,107 @@
+import json
+import string
+import regex
+
+#Normalization from SQuAD evaluation script https://worksheets.codalab.org/rest/bundles/0x6b567e1cf2e041ec80d7098f031c5c9e/contents/blob/
+def normalize_answer(s):
+    def remove_articles(text):
+        return regex.sub(r'\b(a|an|the)\b', ' ', text)
+
+    def white_space_fix(text):
+        return ' '.join(text.split())
+
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return ''.join(ch for ch in text if ch not in exclude)
+
+    def lower(text):
+        return text.lower()
+
+    return white_space_fix(remove_articles(remove_punc(lower(s))))
+
+
+def cal_acc_multi(ground_truth, preds, return_id = False):
+    all_num = len(ground_truth)
+    acc_num = 0
+    ids = []
+    temp = []
+    for i, answer_id in enumerate(ground_truth):
+        pred = preds[i]
+        cnt = 0
+        for aid in answer_id:
+            if pred == aid:
+                cnt += 1
+        if cnt ==1:
+            acc_num += 1/3
+            
+        elif cnt == 2:
+            acc_num += 2/3
+
+        elif cnt > 2:
+            acc_num += 1
+
+
+    if return_id:
+        return acc_num / all_num, ids
+    else:
+        return acc_num,  all_num
+
+
+def ensemble(a):
+    return max(a[::-1], key = a.count)
+
+# Ground Truth Answers
+f=open("/root/okvqa/data/okvqa_val.json", "r")
+answer_dict=json.load(f)
+f.close()
+for k in answer_dict.keys():
+    for a_ind, a in enumerate(answer_dict[k]['multi_answers']):
+        answer_dict[k]['multi_answers'][a_ind] = normalize_answer(answer_dict[k]['multi_answers'][a_ind])
+
+
+# Load Predictions (for example, ensemble of three models' predictions)
+f1=open("/mnt/bn/qingyi-hl/finetunedModelonOKVQA/1e-41e-5FTwiki25-From-1e-41e-5PretrainWiki25Epo0/FTwiki25FromPretrainWiki25Epo0-1e41e5/predictions.json", "r")
+predict0_dict=json.load(f1)
+for p in predict0_dict.keys():
+    predict0_dict[p]=normalize_answer(predict0_dict[p])
+f1.close()
+f2=open("/mnt/bn/qingyi-hl/finetunedModelonOKVQA/1e-41e-5FTwiki25-From-1e-41e-5PretrainWiki25Epo1/predictions.json", "r")
+predict1_dict=json.load(f2)
+for p in predict1_dict.keys():
+    predict1_dict[p]=normalize_answer(predict1_dict[p])
+f2.close()
+f3=open("/mnt/bn/qingyi-hl/finetunedModelonOKVQA/1e-41e-5FTwiki25-From-1e-41e-5PretrainWiki25Epo2/predictions.json", "r")
+predict2_dict=json.load(f3)
+for p in predict2_dict.keys():
+    predict2_dict[p]=normalize_answer(predict2_dict[p])
+f3.close()
+
+
+
+answer_list=[]
+predict0_list=[]
+predict1_list=[]
+predict2_list=[]
+emsemble_predict=[]
+for k in answer_dict.keys():
+    answer_list.append( answer_dict[k]['multi_answers'])
+    predict0_list.append( predict0_dict[k])
+    predict1_list.append( predict1_dict[k])
+    predict2_list.append( predict2_dict[k])
+    
+    emsemble_predict.append(ensemble([predict0_dict[k], predict1_dict[k], predict2_dict[k])
+    
+
+
+acc_n0,all_n0=cal_acc_multi(answer_list,predict0_list)
+acc_n1,all_n1=cal_acc_multi(answer_list,predict1_list)
+acc_n2,all_n2=cal_acc_multi(answer_list,predict2_list)
+
+acc_ens,all_ens=cal_acc_multi(answer_list,emsemble_predict)
+
+print("0-accuracy",acc_n0/all_n0)
+print("1-accuracy",acc_n1/all_n1)
+print("2-accuracy",acc_n2/all_n2)
+
+
+print("ensemble-accuracy",acc_ens/all_ens)

code/config4LXMT5_DDP.py

@@ -0,0 +1,37 @@
+#!user/bin/env python
+# -*- coding:utf-8 -*-
+import argparse
+
+parser = argparse.ArgumentParser()
+# parser.add_argument("--inference", action="store_true", help='complete dataset or not')
+parser.add_argument("--pretrain", default=False, action="store_true", help='use vqa2.0 or not')
+parser.add_argument("--gpt3", default=False, action="store_true", help='use gpt3 to train on okvqa')
+parser.add_argument("--visualBERT", default=False, action="store_true", help='use visualBERT, if false use LXMERT')
+
+parser.add_argument('--batch_size', type=int, default=128,
+                    help='minibatch size')
+parser.add_argument('--seed', type=int, default=4, 
+                    help='random seed!')
+parser.add_argument('--num_wiki', type=int, default=25, 
+                    help='the number of wiki passages')
+parser.add_argument('--num_epochs', type=int, default=40, 
+                    help='number of epochs')
+parser.add_argument('--learning_rate', type=float, default=0.0001,
+                    help='LR')
+parser.add_argument('--learning_rate_LXM', type=float, default=0.00001, 
+                    help='LR_LXM')                 
+parser.add_argument('--model_dir', type=str, default='xxx/',
+                    help='model file path')
+parser.add_argument('--input_type', type=int, default=1,#200,
+                    help='input types: 1==Q-OFA-C-L-O; 2==Q-C-L-O; 3==Q-OFA-L-O; 4==Q-OFA-C-O; 5==Q-OFA-C-L')
+parser.add_argument('--describe', type=str, default='',
+                    help='the model description used as the saved-model name')
+parser.add_argument("--load_pthpath", default="",
+                    help="To continue training, path to .pth file of saved checkpoint.")
+parser.add_argument("--validate", default='True', action="store_true", help="Whether to validate on val split after every epoch.")
+parser.add_argument("--dataset", default="okvqa", help="dataset that model training on")
+parser.add_argument("--ofa", default="normal", help=" normal or finetune --- load the knowledge from Normal OFA or vqav2-Finetuned OFA")
+parser.add_argument('--local_rank', default=-1, type=int,
+                    help='node rank for distributed training')
+args = parser.parse_args()
+print(args)

code/dataset4LXMT5.py

@@ -0,0 +1,551 @@
+#!user/bin/env python
+# -*- coding:utf-8 -*-
+import collections
+import json
+
+
+import string
+
+import numpy as np
+from model_LXM2T5 import T5tokenizer, LXMT52T5, LXMtokenizer
+import pickle
+import torch
+from torch.utils.data import Dataset
+
+from config4LXMT5_DDP import args
+print('dataset4T5',args)
+from random import sample
+
+
+def normalize_wiki(s):
+    stopwords=['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're", "you've", "you'll", "you'd", 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', "she's", 'her', 'hers', 'herself', 'it', "it's", 'its', 'itself', 'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom', 'this', 'that', "that'll", 'these', 'those', 'am', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'a', 'an', 'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can', 'will', 'just', 'don', "don't", 'should', "should've", 'now', 'd', 'll', 'm', 'o', 're', 've', 'y', 'ain', 'aren', "aren't", 'couldn', "couldn't", 'didn', "didn't", 'doesn', "doesn't", 'hadn', "hadn't", 'hasn', "hasn't", 'haven', "haven't", 'isn', "isn't", 'ma', 'mightn', "mightn't", 'mustn', "mustn't", 'needn', "needn't", 'shan', "shan't", 'shouldn', "shouldn't", 'wasn', "wasn't", 'weren', "weren't", 'won', "won't", 'wouldn', "wouldn't"]
+
+
+    def white_space_fix(text):
+        return ' '.join(text.split())
+
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return ''.join(ch for ch in text if ch not in exclude)
+
+    def lower(text):
+        return text.lower()
+
+    def remove_stop_w(text):
+        to_be_removed = set(stopwords)
+        text_list = text.split(' ')
+        text_list = [item for item in text_list if item not in to_be_removed]
+        return ' '.join(text_list)
+
+    return white_space_fix(remove_stop_w(remove_punc(lower(s))))
+
+
+
+if args.dataset == 'okvqa':
+    with open('../data/image_features/vqa_img_feature_train.pickle', 'rb') as f:
+        pretrain_feature = pickle.load(f)
+    if args.pretrain:
+        with open('../data/pretrain/vqa_train_filter.json','r') as f:
+            vqa2 = json.load(f)
+        train_row = vqa2
+    else:
+        with open('../data/finetune/okvqa_train.json','r') as f:
+            train_row = json.load(f)
+
+    if args.pretrain:
+        with open('../data/pretrain/caption_predict_vqav2train.json', 'r') as f:
+            captions_train = json.load(f)
+        with open('../data/pretrain/labeling_predict_vqav2train.json', 'r') as f:
+            labelings_train = json.load(f)
+        with open('../data/pretrain/ocr_predict_vqav2train.json', 'r') as f:
+            ocrs_train = json.load(f)
+
+        with open('../data/pretrain/wiki_100sim_train.json', 'r') as f:
+            wikis_train = json.load(f)
+
+    else:
+        with open('../data/finetune/caption_predict_train.json', 'r') as f:
+            captions_train = json.load(f)
+        with open('../data/finetune/labeling_predict_train.json', 'r') as f:
+            labelings_train = json.load(f)
+        with open('../data/finetune/ocr_predict_train.json', 'r') as f:
+            ocrs_train = json.load(f)
+        if args.ofa=="normal":
+            with open('../data/finetune/ofa_predictions/OFA_zerorate_predict_train.json', 'r') as f:
+                ofas_train = json.load(f)#key为数字
+            with open('../data/finetune/ofa_predictions/OFA_zerorate_evidence_train.json', 'r') as f:
+                evid_train = json.load(f)#key为字符串
+        elif args.ofa=="finetune":
+            with open('../data/finetune/ofa_predictions/OFAvqa_zerorate_answer_train.json', 'r') as f:
+                ofas_train = json.load(f)#key为字符串
+            with open('../data/finetune/ofa_predictions/OFAvqa_zerorate_evidence_train.json', 'r') as f:
+                evid_train = json.load(f)#key为字符串
+        else:
+            assert 0==1
+        with open("../data/finetune/gpt3_okvqa_train2014_answers.pkl", 'rb') as f:
+            gpt3_train = pickle.load(f)
+        with open('../data/finetune/wiki_100sim_train.json', 'r') as f:
+            wikis_train = json.load(f)
+
+else:
+    assert 0==1
+
+
+
+def plural(word):
+    if word.endswith('y'):
+        return word[:-1] + 'ies'
+    elif word[-1] in 'sxo' or word[-2:] in ['sh', 'ch']:
+        return word + 'es'
+    elif word.endswith('an'):
+        return word[:-2] + 'en'
+    else:
+        return word + 's'
+
+image_ids = []
+qids = []
+questions = []
+answers = []
+labels = []
+objects = []
+answer_ids = []
+answers_lists = []
+question_lengths = []
+answers_most = []
+neg_answer = []
+
+
+train_captions = {}
+for item in captions_train:
+    if item['image_id'] in train_captions.keys():
+        print("IMG caption REPEATED!")
+        assert 0==1
+    train_captions[item['image_id']] = item['caption']
+
+train_labelings = {}
+for item in labelings_train:
+    if item['image_id'] in train_labelings.keys():
+        print("IMG labelings REPEATED!")
+        assert 0==1
+    train_labelings[str(item['image_id'])] = item['labeling']
+print("labeling number:", len(train_labelings.keys()))
+
+train_ocrs = {}
+for item in ocrs_train:
+    if item['image_id'] in train_ocrs.keys():
+        print("IMG ocrs REPEATED!")
+        assert 0==1
+    train_ocrs[str(item['image_id'])] = item['ocr']
+
+
+if not args.pretrain:
+    train_ofas = {}
+    if args.ofa=="normal":
+        for item in ofas_train:
+            if item['question_id'] in train_ofas.keys():
+                print("IMG ofas REPEATED!")
+                assert 0==1
+            train_ofas[str(item['question_id'])] = item['OFA_answer']+", "+evid_train[str(item['question_id'])]
+    elif  args.ofa=="finetune":
+        for k in evid_train.keys():
+            train_ofas[k] = ofas_train[k]+", "+evid_train[k]
+    else:
+        assert 0==1
+
+    train_gpt3 = {}
+    for k in gpt3_train.keys():
+        qid = k.split("#")[1]
+    
+        train_gpt3[str(qid)] = ", ".join(gpt3_train[k][0])#[(ans, evid)]
+
+
+train_wikis = wikis_train
+
+
+if args.pretrain: 
+    if args.num_wiki > 51:
+        for key in train_wikis.keys():
+            for i in range(args.num_wiki):
+                train_wikis[key][i]=normalize_wiki(train_wikis[key][i])
+
+
+
+
+n = 0
+
+
+for qid, item in train_row.items():
+    img_id = str(item['image_id'])
+    image_ids.append(img_id)
+    qids.append(qid)
+    question_clean = item['question']# + answer_sentence
+    questions.append(question_clean)
+ 
+
+
+    # multi-answer
+    if args.dataset == 'okvqa':
+        answers.append(item['multi_answers'])
+        # m_ans_id = [a_dic.get(i, 0) for i in item['multi_answers']]
+        # most_answer_ids.append(m_ans_id)
+
+
+    #single answer
+    else:
+        answers.append(item['answer'])
+
+
+
+
+def _create_gpt3_entry(imgage_ids, q_ids, questions, answer, captions,labelings, ocrs,ofas, gpt3, wikis,final_txt):
+
+    if not args.pretrain:
+        entry = {
+            'img_id': imgage_ids,
+            'qid': q_ids,
+            'question': questions,
+            'answer': answer,
+            'caption': captions,
+            'labeling':labelings,
+            'ocr': ocrs,
+            'ofa':ofas,
+            'gpt3':gpt3,
+            'wiki':wikis,
+            'final_txt':final_txt}
+
+    return entry
+
+
+
+def _create_entry(imgage_ids, q_ids, questions, answer, captions,labelings, ocrs,ofas, wikis,final_txt):
+    if not args.pretrain:
+        entry = {
+            'img_id': imgage_ids,
+            'qid': q_ids,
+            'question': questions,
+            'answer': answer,
+            'caption': captions,
+            'labeling':labelings,
+            'ocr': ocrs,
+            'ofa':ofas,
+            'wiki':wikis,
+            'final_txt':final_txt}
+    return entry
+
+
+def _create_vqav2_entry(imgage_ids, q_ids, questions, answer, captions,labelings, ocrs,wikis,final_txt):
+    if args.pretrain:
+        entry = {
+            'img_id': imgage_ids,
+            'qid': q_ids,
+            'question': questions,
+            'answer': answer,
+            'caption': captions,
+            'labeling':labelings,
+            'ocr': ocrs,
+            'wiki':wikis,
+            'final_txt':final_txt}
+    # else:
+    return entry
+
+
+def _load_dataset(train_row):
+    entries=[]
+    for qid, item in train_row.items():
+        qid = str(qid)
+        img_id = str(item['image_id'])
+        question = item['question']
+ 
+
+
+        # multi-answer
+        if args.dataset == 'okvqa':
+            answers=item['multi_answers']
+            
+
+        #single answer
+        else:
+            answers=item['answer']
+            
+        caption=train_captions[img_id]
+        labeling=train_labelings[img_id]
+        ocr_list=train_ocrs[img_id]
+        ocr = ", ".join(str(i) for i in ocr_list)
+        if not args.pretrain:
+            ofa=train_ofas[qid]
+            gpt3=train_gpt3[qid]
+        wiki=train_wikis[qid]
+        
+        if args.pretrain:
+            if args.num_wiki > 51:
+                final_txt = [question + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+            else:
+                final_txt = [question + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+        else:
+            if args.seed > 1000:
+                print("seed > 1000 denotes that ablation study on 2 encoders")
+                assert args.input_type==0
+            if args.gpt3:
+                if args.input_type==0:
+                
+                    if args.num_wiki > 51: 
+			# When there are a large number of Wiki passages, to save on GPU memory usage, Wiki passages are processed.
+                        final_txt = [question + " [SEP] " + ofa + " " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                    else:
+                        final_txt = [question + " [SEP] " + ofa + " " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+                elif args.input_type==1: 
+                    final_txt = question + " [SEP] " + ofa + " " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+                elif args.input_type==2:
+                    if args.num_wiki > 51:
+                        final_txt = [question + " [SEP] "  + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                    else:
+                        final_txt = [question + " [SEP] "  + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+                elif args.input_type==3: 
+                    final_txt = question + " [SEP] " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+                else:
+                    print('choose input-type in [0,1,2,3]')
+                    assert 0==1
+                
+                
+            else:
+                if args.input_type==0:
+                
+                    if args.num_wiki > 51:
+                        final_txt = [question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                    else:
+                        final_txt = [question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+                elif args.input_type==1: 
+                    final_txt = question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+                elif args.input_type==2: 
+                    if args.num_wiki > 51:
+                        final_txt = [question + " [SEP] "  + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                    else:
+                        final_txt = [question + " [SEP] "  + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+                elif args.input_type==3:
+                    final_txt = question + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+                else:
+                    print('choose input-type in [0,1,2,3,4,5]')
+                    assert 0==1
+                
+                
+                
+        
+        if args.pretrain:
+            entries.append(_create_vqav2_entry(img_id, qid, question, answers, caption,labeling, ocr, wiki, final_txt))
+        else:
+            if args.gpt3:
+                entries.append(_create_gpt3_entry(img_id, qid, question, answers, caption,labeling, ocr,ofa,gpt3, wiki, final_txt))
+            else:
+                entries.append(_create_entry(img_id, qid, question, answers, caption,labeling, ocr,ofa, wiki, final_txt))
+
+    return entries
+
+
+
+
+
+def _create_pretrain_entry(imgage_ids, q_ids, questions, answer):#, captions,labelings, ocrs,ofas,final_txt):
+    entry = {
+        'img_id': imgage_ids,
+        'qid': q_ids,
+        'question': questions,
+        'answer': answer}#,
+    return entry
+
+def _load_pretrain_dataset(train_row):
+    entries=[]
+    for qid, item in train_row.items():
+        qid = str(qid)
+
+        img_id = str(item['image_id'])
+        question = item['question']
+
+
+        # multi-answer
+        if args.dataset == 'okvqa':
+            answers=item['multi_answers']
+            # answers.append(item['multi_answers'])
+            # m_ans_id = [a_dic.get(i, 0) for i in item['multi_answers']]
+            # most_answer_ids.append(m_ans_id)
+
+
+        #single answer
+        else:
+            answers=item['answer']
+        
+        entries.append(_create_pretrain_entry(img_id, qid, question, answers))
+    return entries
+
+
+
+class KgDataset(Dataset):
+    def __init__(self, val=False, val_test=False):
+        self.entries = _load_dataset(train_row)
+        self.tokenize()
+
+    def __len__(self):
+        return len(self.entries)
+    def tokenize(self):
+        if args.input_type==0:
+            if args.num_wiki > 51:
+                max_source_length=200
+            else:
+                max_source_length=250 #300
+        else:
+            max_source_length=128
+        max_target_length=5
+        max_que_length=16
+        for entry in self.entries:
+            T5_input_seq, T5_input_ids, T5_input_masks = self.tokenizer_func( T5tokenizer, entry['final_txt'], max_length=max_source_length)
+            LXM_input_seq, LXM_input_ids, LXM_input_masks = self.tokenizer_func( LXMtokenizer, entry['question'], max_length=max_que_length)
+            
+            
+            all_Ans_T5_target_seq = []
+            all_Ans_T5_target_ids = []
+            all_Ans_T5_target_masks = []
+            if args.allAns:
+                for i in range(10):  
+                    if i%2==0:
+                        T5_target_seq, T5_target_ids, T5_target_masks = self.tokenizer_func( T5tokenizer, entry['answer'][i], max_length=max_target_length)
+                        all_Ans_T5_target_seq.append(T5_target_seq)
+                        all_Ans_T5_target_ids.append(torch.from_numpy(np.array(T5_target_ids)))
+                        all_Ans_T5_target_masks.append(torch.from_numpy(np.array(T5_target_masks)))
+                        # print()
+                all_Ans_T5_target_ids=torch.stack(all_Ans_T5_target_ids)
+                all_Ans_T5_target_masks=torch.stack(all_Ans_T5_target_masks)
+                
+                entry['T5_target_seq']=all_Ans_T5_target_seq
+                entry['T5_target_ids']=all_Ans_T5_target_ids
+                entry['T5_target_masks']=all_Ans_T5_target_masks
+
+            else:
+                T5_target_seq, T5_target_ids, T5_target_masks = self.tokenizer_func( T5tokenizer, entry['answer'][0], max_length=max_target_length)
+                entry['T5_target_seq']=T5_target_seq#torch.from_numpy(np.array(T5_target_seq))
+                entry['T5_target_ids']=torch.from_numpy(np.array(T5_target_ids))
+                entry['T5_target_masks']=torch.from_numpy(np.array(T5_target_masks))
+            entry['T5_input_seq']=T5_input_seq#torch.from_numpy(np.array(T5_input_seq))
+            entry['T5_input_ids']=torch.from_numpy(np.array(T5_input_ids))
+            entry['T5_input_masks']=torch.from_numpy(np.array(T5_input_masks))
+            entry['LXM_input_seq']=LXM_input_seq#torch.from_numpy(np.array(LXM_input_seq))
+            entry['LXM_input_ids']=torch.from_numpy(np.array(LXM_input_ids))
+            entry['LXM_input_masks']=torch.from_numpy(np.array(LXM_input_masks))
+            
+
+
+    def tokenizer_func(self, tokenizer, text, max_length=0):
+        if max_length==0:
+            print('plz set the max length of input sequence!')
+            assert 1==2
+       
+        out_seq = tokenizer(
+            text,
+            # batch_data['final_txt'],
+            padding='max_length',
+            max_length=max_length,
+            truncation=True,
+            # return_tensors="pt",
+            )
+        
+        tokens=out_seq.input_ids #['input_ids']
+        masks=out_seq.attention_mask
+        length = len(tokens)
+
+        return out_seq, tokens, masks
+
+    def __getitem__(self, index):
+
+        entry = self.entries[index]
+        qid=entry['qid']
+        question=entry['question']
+        answer=entry['answer']
+        img_id=entry['img_id']
+        image_feature = pretrain_feature[img_id]['feats']
+        
+        image_caption = entry['caption']
+        image_labeling = entry['labeling']
+        image_ocr_list = entry['ocr']
+        image_ocr = ", ".join(str(i) for i in image_ocr_list)
+        if not args.pretrain:
+            ofa = entry['ofa'] 
+            if args.gpt3:
+                gpt3 = entry['gpt3'] 
+        wiki = entry['wiki']
+        final_txt = entry['final_txt']
+        
+        
+        spatial_feature = pretrain_feature[img_id]['sp_feats']
+        
+        T5_input_seq, T5_input_ids, T5_input_masks = entry['T5_input_seq'], entry['T5_input_ids'], entry['T5_input_masks']#self.tokenizer_func( T5tokenizer, final_txt, max_length=max_source_length)
+        
+        LXM_input_seq, LXM_input_ids, LXM_input_masks = entry['LXM_input_seq'], entry['LXM_input_ids'], entry['LXM_input_masks']
+        
+        LXM_token_type_ids = torch.from_numpy(np.array(LXM_input_seq['token_type_ids']))#.to(device)
+        
+        T5_target_seq, T5_target_ids, T5_target_masks=entry['T5_target_seq'],entry['T5_target_ids'],entry['T5_target_masks']
+        
+        if not args.pretrain:
+            if not args.gpt3:
+                return qid, question, answer, image_feature, spatial_feature, image_caption, image_labeling, image_ocr, ofa, wiki, final_txt, T5_input_seq,T5_input_ids,T5_input_masks,LXM_input_ids,LXM_input_masks,LXM_token_type_ids,T5_target_seq,T5_target_ids,T5_target_masks  
+            elif args.gpt3:
+                return qid, question, answer, image_feature, spatial_feature, image_caption, image_labeling, image_ocr, ofa, gpt3, wiki, final_txt, T5_input_seq,T5_input_ids,T5_input_masks,LXM_input_ids,LXM_input_masks,LXM_token_type_ids,T5_target_seq,T5_target_ids,T5_target_masks  
+        else:
+            return qid, question, answer, image_feature, spatial_feature, image_caption, image_labeling, image_ocr, wiki, final_txt, T5_input_seq,T5_input_ids,T5_input_masks,LXM_input_ids,LXM_input_masks,LXM_token_type_ids,T5_target_seq,T5_target_ids,T5_target_masks  
+
+def my_collate(batch):
+    batch = list(zip(*batch))
+    if not args.pretrain:
+        if not args.gpt3:
+            res = {'id': batch[0], 'ques': batch[1], 'ans': batch[2],
+                    'img': batch[3], 'spatial': batch[4],
+                    'caption': batch[5], 'labeling': batch[6], 'ocr': batch[7], 'ofa': batch[8], 'wiki': batch[9], 'final_txt': batch[10],
+                    'T5_input_seq': batch[11], 'T5_input_ids': batch[12],'T5_input_masks': batch[13],'LXM_input_ids':batch[14], 'LXM_input_masks':batch[15], 'LXM_token_type_ids':batch[16], 'T5_target_seq':batch[17],'T5_target_ids':batch[18],'T5_target_masks':batch[19]}
+        elif args.gpt3:
+            res = {'id': batch[0], 'ques': batch[1], 'ans': batch[2],
+                    'img': batch[3], 'spatial': batch[4],
+                    'caption': batch[5], 'labeling': batch[6], 'ocr': batch[7], 'ofa': batch[8], 'gpt3': batch[9], 'wiki': batch[10], 'final_txt': batch[11],
+                    'T5_input_seq': batch[12], 'T5_input_ids': batch[13],'T5_input_masks': batch[14],'LXM_input_ids':batch[15], 'LXM_input_masks':batch[16], 'LXM_token_type_ids':batch[17], 'T5_target_seq':batch[18],'T5_target_ids':batch[19],'T5_target_masks':batch[20]}
+
+
+    else:
+        res = {'id': batch[0], 'ques': batch[1], 'ans': batch[2],
+                'img': batch[3], 'spatial': batch[4],
+                'caption': batch[5], 'labeling': batch[6], 'ocr': batch[7], 'wiki': batch[8], 'final_txt': batch[9],
+                'T5_input_seq': batch[10], 'T5_input_ids': batch[11],'T5_input_masks': batch[12],'LXM_input_ids':batch[13], 'LXM_input_masks':batch[14], 'LXM_token_type_ids':batch[15], 'T5_target_seq':batch[16],'T5_target_ids':batch[17],'T5_target_masks':batch[18]}
+
+            
+    del batch
+    return res
+
+def my_val_collate(batch):
+    batch = list(zip(*batch))
+    if 1:
+        res = {'id': batch[0], 'ques': batch[1], 'ans': batch[2],
+                'img': batch[3], 'spatial': batch[4],
+                'caption': batch[5], 'labeling': batch[6], 'ocr': batch[7], 'ofa': batch[8], 'wiki': batch[9], 'final_txt': batch[10],
+                'T5_input_seq': batch[11], 'T5_input_ids': batch[12],'T5_input_masks': batch[13],'LXM_input_ids':batch[14], 'LXM_input_masks':batch[15], 'LXM_token_type_ids':batch[16], 'T5_target_seq':batch[17],'T5_target_ids':batch[18],'T5_target_masks':batch[19]}
+    del batch
+    return res
+
+
+
+
+
+def my_gpt3_collate(batch):
+    batch = list(zip(*batch))
+    if 1:
+        res = {'id': batch[0], 'ques': batch[1], 'ans': batch[2],
+                'img': batch[3], 'spatial': batch[4],
+                'caption': batch[5], 'labeling': batch[6], 'ocr': batch[7], 'ofa': batch[8],'gpt3': batch[9], 'wiki': batch[10], 'final_txt': batch[11],
+                'T5_input_seq': batch[12], 'T5_input_ids': batch[13],'T5_input_masks': batch[14],'LXM_input_ids':batch[15], 'LXM_input_masks':batch[16], 'LXM_token_type_ids':batch[17], 'T5_target_seq':batch[18],'T5_target_ids':batch[19],'T5_target_masks':batch[20]}
+    del batch
+    return res
+
+def my_val_gpt3_collate(batch):
+    batch = list(zip(*batch))
+    if 1:
+        res = {'id': batch[0], 'ques': batch[1], 'ans': batch[2],
+                'img': batch[3], 'spatial': batch[4],
+                'caption': batch[5], 'labeling': batch[6], 'ocr': batch[7], 'ofa': batch[8],'gpt3': batch[9], 'wiki': batch[10], 'final_txt': batch[11],
+                'T5_input_seq': batch[12], 'T5_input_ids': batch[13],'T5_input_masks': batch[14],'LXM_input_ids':batch[15], 'LXM_input_masks':batch[16], 'LXM_token_type_ids':batch[17], 'T5_target_seq':batch[18],'T5_target_ids':batch[19],'T5_target_masks':batch[20]}
+    del batch
+    return res

code/dataset_val4LXMT5.py

@@ -0,0 +1,346 @@
+#!user/bin/env python
+# -*- coding:utf-8 -*-
+import collections
+import pickle
+from model_LXM2T5 import T5tokenizer, LXMT52T5, LXMtokenizer
+
+from torch.utils.data import Dataset
+import json
+import pickle
+import numpy as np
+import torch
+import string
+
+
+from config4LXMT5_DDP import args
+print('dataset_val4T5',args)
+from random import sample
+
+
+def normalize_wiki(s):
+    stopwords=['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're", "you've", "you'll", "you'd", 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', "she's", 'her', 'hers', 'herself', 'it', "it's", 'its', 'itself', 'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom', 'this', 'that', "that'll", 'these', 'those', 'am', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'a', 'an', 'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can', 'will', 'just', 'don', "don't", 'should', "should've", 'now', 'd', 'll', 'm', 'o', 're', 've', 'y', 'ain', 'aren', "aren't", 'couldn', "couldn't", 'didn', "didn't", 'doesn', "doesn't", 'hadn', "hadn't", 'hasn', "hasn't", 'haven', "haven't", 'isn', "isn't", 'ma', 'mightn', "mightn't", 'mustn', "mustn't", 'needn', "needn't", 'shan', "shan't", 'shouldn', "shouldn't", 'wasn', "wasn't", 'weren', "weren't", 'won', "won't", 'wouldn', "wouldn't"]
+    # def remove_articles(text):
+    #     return regex.sub(r'\b(a|an|the)\b', ' ', text)
+
+    def white_space_fix(text):
+        return ' '.join(text.split())
+
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return ''.join(ch for ch in text if ch not in exclude)
+
+    def lower(text):
+        return text.lower()
+
+    def remove_stop_w(text):
+        to_be_removed = set(stopwords)
+        text_list = text.split(' ')
+        text_list = [item for item in text_list if item not in to_be_removed]
+        return ' '.join(text_list)
+
+    return white_space_fix(remove_stop_w(remove_punc(lower(s))))
+
+if args.dataset == 'okvqa':
+    with open('../data/validate/okvqa_val.json','r') as f:
+        val_row = json.load(f)
+    with open('../data/image_features/vqa_img_feature_val.pickle', 'rb') as f:
+        pretrain_feature = pickle.load(f)
+    with open('../data/validate/caption_predict_val.json', 'r') as f:
+        captions_val = json.load(f)
+    with open('../data/validate/labeling_predict_val.json', 'r') as f:
+        labelings_val = json.load(f)
+    with open('../data/validate/ocr_predict_val.json', 'r') as f:
+        ocrs_val = json.load(f)
+    
+    if args.ofa=="normal":
+        with open('../data/validate/ofa_predictions/OFA_zerorate_predict_val.json', 'r') as f:
+            ofas_val = json.load(f)
+        with open('../data/validate/ofa_predictions/OFA_zerorate_evidence_val.json', 'r') as f:
+            evid_val = json.load(f)
+    elif args.ofa=="finetune":
+        with open('../data/validate/ofa_predictions/OFAvqa_zerorate_answer_val.json', 'r') as f:
+            ofas_val = json.load(f)
+        with open('../data/validate/ofa_predictions/OFAvqa_zerorate_evidence_val.json', 'r') as f:
+            evid_val = json.load(f)
+    else:
+        assert 0==1
+    with open("../data/validate/gpt3_okvqa_val2014_answers.pkl", 'rb') as f:
+        gpt3_val = pickle.load(f)
+    with open('../data/validate/wiki_100sim_val.json', 'r') as f:
+        wikis_val = json.load(f)
+    
+
+def plural(word):
+    if word.endswith('y'):
+        return word[:-1] + 'ies'
+    elif word[-1] in 'sxo' or word[-2:] in ['sh', 'ch']:
+        return word + 'es'
+    elif word.endswith('an'):
+        return word[:-2] + 'en'
+    else:
+        return word + 's'
+
+image_ids = []
+qids = []
+questions = []
+answers = []
+labels = []
+objects = []
+answer_ids = []
+answers_lists = []
+question_lengths = []
+most_answer = []
+neg_answer = []
+
+val_captions = {}
+for item in captions_val:
+    if item['image_id'] in val_captions.keys():
+        print("IMG caption REPEATED!")
+        assert 0==1
+    val_captions[item['image_id']] = item['caption']
+
+val_labelings = {}
+for item in labelings_val:
+    if item['image_id'] in val_labelings.keys():
+        print("IMG labelings REPEATED!")
+        assert 0==1
+    val_labelings[str(item['image_id'])] = item['labeling']
+
+val_ocrs = {}
+for item in ocrs_val:
+    if item['image_id'] in val_ocrs.keys():
+        print("IMG ocrs REPEATED!")
+        assert 0==1
+    val_ocrs[str(item['image_id'])] = item['ocr']
+    
+
+val_ofas = {}
+
+if args.ofa=="normal":
+    for item in ofas_val:
+        if item['question_id'] in val_ofas.keys():
+            print("IMG ofas REPEATED!")
+            assert 0==1
+        val_ofas[str(item['question_id'])] = item['OFA_answer']+", "+evid_val[str(item['question_id'])]
+elif  args.ofa=="finetune":
+    for k in evid_val.keys():
+        val_ofas[k] = ofas_val[k]+", "+evid_val[k]
+else:
+    assert 0==1
+
+
+
+val_gpt3 = {}
+for k in gpt3_val.keys():
+    qid = k.split("#")[1]
+    
+    val_gpt3[str(qid)] = ", ".join(gpt3_val[k][0]) #[(ans, evid)]
+
+
+val_wikis = wikis_val
+
+
+for qid, item in val_row.items():
+    img_id = str(item['image_id'])
+    image_ids.append(img_id)
+    qids.append(qid)
+
+    question_clean = item['question']  # + answer_sentence
+    questions.append(question_clean)
+    if args.dataset == 'okvqa' or args.dataset == 'vqav2':
+        answers.append(item['multi_answers'])
+        if args.dataset == 'okvqa':
+            objects.append(item['label'])
+    else:
+        answers.append(item['answer'])
+
+
+
+def _create_gpt3_entry(imgage_ids, q_ids, questions, answer, captions,labelings, ocrs,ofas,gpt3, wikis, final_txt):
+    entry = {
+        'img_id': imgage_ids,
+        'qid': q_ids,
+        'question': questions,
+        'answer': answer,
+        'caption': captions,
+        'labeling':labelings,
+        'ocr': ocrs,
+        'ofa':ofas,
+        'gpt3':gpt3,
+        'wiki': wikis,
+        'final_txt':final_txt}
+    return entry
+
+
+def _create_entry(imgage_ids, q_ids, questions, answer, captions,labelings, ocrs,ofas, wikis, final_txt):
+    entry = {
+        'img_id': imgage_ids,
+        'qid': q_ids,
+        'question': questions,
+        'answer': answer,
+        'caption': captions,
+        'labeling':labelings,
+        'ocr': ocrs,
+        'ofa':ofas,
+        'wiki': wikis,
+        'final_txt':final_txt}
+    return entry
+
+def _load_dataset(val_row):
+    entries=[]
+    for qid, item in val_row.items():
+        qid = str(qid)
+        img_id = str(item['image_id'])
+        question = item['question']# + answer_sentence
+
+        if args.dataset == 'okvqa':
+            answers=item['multi_answers']
+
+
+        else:
+            answers=item['answer']
+        caption=val_captions[img_id]
+        labeling=val_labelings[img_id]
+        ocr_list=val_ocrs[img_id]
+        ocr = ", ".join(str(i) for i in ocr_list)
+        ofa=val_ofas[qid]
+        gpt3=val_gpt3[qid]
+        wiki=val_wikis[qid]
+
+        if args.seed > 1000:
+            print("seed > 1000 denotes that ablation study on 2 encoders")
+            assert args.input_type==0
+
+        if args.gpt3:
+            if args.input_type==0:   
+                if args.num_wiki > 51:
+                    final_txt = [question + " [SEP] " + ofa + " " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                else:
+                    final_txt = [question + " [SEP] " + ofa + " " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+            elif args.input_type==1: 
+                final_txt = question + " [SEP] " + ofa + " " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+            elif args.input_type==2: 
+                if args.num_wiki > 51:
+                    final_txt = [question + " [SEP] "  + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                else:
+                    final_txt = [question + " [SEP] "  + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+            elif args.input_type==3:
+                final_txt = question + " [SEP] " + gpt3 + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+            else:
+                print('choose input-type in [0,1,2,3]')
+                assert 0==1   
+
+            entries.append(_create_gpt3_entry(img_id, qid, question, answers, caption,labeling, ocr,ofa,gpt3, wiki, final_txt))
+            
+        else:
+            if args.input_type==0:
+                
+                if args.num_wiki > 51:
+                    final_txt = [question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                else:
+                    final_txt = [question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+            elif args.input_type==1: 
+                final_txt = question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+            elif args.input_type==2: 
+                if args.num_wiki > 51:
+                    final_txt = [question + " [SEP] "  + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + normalize_wiki(x) for x in wiki[:args.num_wiki]]
+                else:
+                    final_txt = [question + " [SEP] "  + caption + " [SEP] " + labeling + " [SEP] " + ocr + " [SEP] " + x for x in wiki[:args.num_wiki]]
+            elif args.input_type==3: #什么知识都不加。知识单独的性能4（不要预训练）:什么知识都不加，只有视觉属性。
+                final_txt = question + " [SEP] " + ofa + " [SEP] " + caption + " [SEP] " + labeling + " [SEP] " + ocr
+            else:
+                print('choose input-type in [1,2,3,4,5]')
+                assert 0==1              
+
+            entries.append(_create_entry(img_id, qid, question, answers, caption,labeling, ocr,ofa, wiki, final_txt))
+    return entries
+
+
+
+
+
+
+class KgDatasetVal(Dataset):
+    def __init__(self, val=False, val_test=False):
+        self.entries = _load_dataset(val_row)
+        self.tokenize()
+
+
+    def __len__(self):
+        return len(self.entries)
+    def tokenize(self):
+        if args.input_type%2==0 : #当input_type=0或者2的时候，有wiki在，所以句子长度要长
+            if args.num_wiki > 51:
+                max_source_length=200
+            else:
+                max_source_length=250 #300
+        else:
+            max_source_length=128
+        max_target_length=5
+        max_que_length=16
+        for entry in self.entries:
+            T5_input_seq, T5_input_ids, T5_input_masks = self.tokenizer_func( T5tokenizer, entry['final_txt'], max_length=max_source_length)
+            LXM_input_seq, LXM_input_ids, LXM_input_masks = self.tokenizer_func( LXMtokenizer, entry['question'], max_length=max_que_length)
+            T5_target_seq, T5_target_ids, T5_target_masks = self.tokenizer_func( T5tokenizer, entry['answer'][0], max_length=max_target_length)
+            entry['T5_input_seq']=T5_input_seq#torch.from_numpy(np.array(T5_input_seq))
+            entry['T5_input_ids']=torch.from_numpy(np.array(T5_input_ids))
+            entry['T5_input_masks']=torch.from_numpy(np.array(T5_input_masks))
+            entry['LXM_input_seq']=LXM_input_seq#torch.from_numpy(np.array(LXM_input_seq))
+            entry['LXM_input_ids']=torch.from_numpy(np.array(LXM_input_ids))
+            entry['LXM_input_masks']=torch.from_numpy(np.array(LXM_input_masks))
+            entry['T5_target_seq']=T5_target_seq#torch.from_numpy(np.array(T5_target_seq))
+            entry['T5_target_ids']=torch.from_numpy(np.array(T5_target_ids))
+            entry['T5_target_masks']=torch.from_numpy(np.array(T5_target_masks))
+
+    def tokenizer_func(self, tokenizer, text, max_length=0):
+        if max_length==0:
+            print('plz set the max length of input sequence!')
+            assert 1==2
+
+        out_seq = tokenizer(
+            text,
+            padding='max_length',
+            max_length=max_length,
+            truncation=True,
+            # return_tensors="pt",
+            )
+
+        tokens=out_seq.input_ids #['input_ids']
+        masks=out_seq.attention_mask
+        length = len(tokens)
+        return out_seq, tokens, masks
+
+    def __getitem__(self, index):
+        entry = self.entries[index]
+        qid=entry['qid']
+        question=entry['question']
+        answer=entry['answer']
+        img_id=entry['img_id']
+
+        image_feature = pretrain_feature[img_id]['feats']
+        
+        image_caption = entry['caption']
+        image_labeling = entry['labeling']
+        image_ocr_list = entry['ocr']
+        image_ocr = ", ".join(str(i) for i in image_ocr_list)
+        ofa = entry['ofa'] 
+        if args.gpt3:
+            gpt3 = entry['gpt3'] 
+        wiki = entry['wiki']
+        final_txt = entry['final_txt']
+
+
+        spatial_feature = pretrain_feature[img_id]['sp_feats']
+        T5_input_seq, T5_input_ids, T5_input_masks = entry['T5_input_seq'], entry['T5_input_ids'], entry['T5_input_masks']#self.tokenizer_func( T5tokenizer, final_txt, max_length=max_source_length)
+        LXM_input_seq, LXM_input_ids, LXM_input_masks = entry['LXM_input_seq'], entry['LXM_input_ids'], entry['LXM_input_masks']
+        LXM_token_type_ids = torch.from_numpy(np.array(LXM_input_seq['token_type_ids']))#.to(device)
+        T5_target_seq, T5_target_ids, T5_target_masks=entry['T5_target_seq'],entry['T5_target_ids'],entry['T5_target_masks']
+
+
+        
+        if args.gpt3:
+            return qid, question, answer, image_feature, spatial_feature, image_caption, image_labeling, image_ocr, ofa, gpt3, wiki, final_txt, T5_input_seq,T5_input_ids,T5_input_masks,LXM_input_ids,LXM_input_masks,LXM_token_type_ids,T5_target_seq,T5_target_ids,T5_target_masks  
+        elif not args.gpt3:
+            return qid, question, answer, image_feature, spatial_feature, image_caption, image_labeling, image_ocr, ofa, wiki, final_txt, T5_input_seq,T5_input_ids,T5_input_masks,LXM_input_ids,LXM_input_masks,LXM_token_type_ids,T5_target_seq,T5_target_ids,T5_target_masks  
+
+

code/dist_train.py

@@ -0,0 +1,75 @@
+import io
+import os
+
+import torch
+import torch.distributed as dist
+
+
+_print = print
+
+
+def get_world_size(): return int(os.getenv('WORLD_SIZE', 1))
+def get_rank(): return int(os.getenv('RANK', 0))
+def get_local_rank(): return int(os.getenv('LOCAL_RANK', 0))
+
+
+def is_dist():
+    return dist.is_available() and dist.is_initialized() and get_world_size() > 1
+
+
+def print(*argc, all=False, **kwargs):
+    if not is_dist():
+        _print(*argc, **kwargs)
+        return
+
+    if not all and get_local_rank() != 0:
+        return
+
+    output = io.StringIO()
+    kwargs['end'] = ''
+    kwargs['file'] = output
+    kwargs['flush'] = True
+    _print(*argc, **kwargs)
+
+    s = output.getvalue()
+    output.close()
+
+    s = '[rank {}] {}'.format(dist.get_rank(), s)
+    _print(s)
+
+
+def reduce_mean(tensor, nprocs=None):
+    if not is_dist():
+        return tensor
+    if not isinstance(tensor, torch.Tensor):
+        device = torch.cuda.current_device()
+        rt = torch.tensor(tensor, device=device)
+    else:
+        rt = tensor.clone()
+    dist.all_reduce(rt, op=dist.ReduceOp.SUM)
+    nprocs = nprocs if nprocs else dist.get_world_size()
+    rt = rt / nprocs
+    if not isinstance(tensor, torch.Tensor):
+        rt = rt.item()
+    return rt
+
+
+
+def reduce_sum(tensor):
+    if not is_dist():
+        return tensor
+    if not isinstance(tensor, torch.Tensor):
+        device = torch.cuda.current_device()
+        rt = torch.tensor(tensor, device=device)
+    else:
+        rt = tensor.clone()
+    dist.all_reduce(rt, op=dist.ReduceOp.SUM)
+    if not isinstance(tensor, torch.Tensor):
+        rt = rt.item()
+    return rt
+
+
+def barrier():
+    if not is_dist():
+        return
+    dist.barrier()

code/model_LXM2T5.py

@@ -0,0 +1,95 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import init
+import copy
+from config4LXMT5_DDP import args
+import collections
+from transformers import LxmertConfig, LxmertTokenizer, LxmertModel,BertTokenizer#,BaseModelOutputWithPastAndCrossAttentions
+from transformers import T5Tokenizer, T5Model, T5Config, T5ForConditionalGeneration
+from transformers.modeling_outputs import  BaseModelOutputWithPastAndCrossAttentions
+T5tokenizer = T5Tokenizer.from_pretrained("../model/t5-large")#"t5-large")
+LXMtokenizer = BertTokenizer.from_pretrained('../model/bert-base-uncased/vocab.txt') 
+T5config = T5Config.from_pretrained('../model/t5-large')
+
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+LXM_source_masks=None,token_type_ids=None, visual_features=None, spatial_features=None,T5_target_ids=None,T5_target_masks=None):
+attention_mask=LXM_source_masks, token_type_ids=token_type_ids, visual_feats=visual_features, visual_pos=spatial_features)
+
+
+
+
+class LXMT52T5(nn.Module):
+    def __init__(self):
+        super(LXMT52T5, self).__init__()
+        self.T5model = T5ForConditionalGeneration.from_pretrained("../model/t5-large").to(device)
+        self.LXMmodel = LxmertModel.from_pretrained('../model/lxmert-base-uncased').to(device)
+        self.mapping = torch.nn.Sequential(
+            torch.nn.Linear(768, 1024),
+            torch.nn.ReLU(inplace=True),   
+            torch.nn.Linear(1024, 1024)
+            )
+
+
+
+    def LXMT5end2T5dec(self,  train=None, LXM_source_ids=None, LXM_source_masks=None,T5_source_ids=None, T5_source_masks=None,token_type_ids=None, visual_features=None, spatial_features=None,T5_target_ids=None,T5_target_masks=None):
+       
+        if 1:
+            LXM_encoder_output_seq = self.LXMmodel(input_ids=LXM_source_ids, attention_mask=LXM_source_masks, token_type_ids=token_type_ids, visual_feats=visual_features, visual_pos=spatial_features)
+            LXM_lang_enc_out = LXM_encoder_output_seq.language_output
+            LXM_visual_enc_out = LXM_encoder_output_seq.vision_output
+            
+            LXM_VL_encoder_output_seq = torch.cat((LXM_lang_enc_out, LXM_visual_enc_out),1)
+            
+
+
+
+
+        
+        #if 1: #  (w/o wiki passages)
+        #    T5_encoder_output_seq = self.T5model.encoder(input_ids=T5_source_ids, attention_mask=T5_source_masks)
+        #    final_encoder_output_seq = torch.cat((final_LXM_encoder_output_seq, T5_encoder_output_seq["last_hidden_state"]),1)
+        
+
+        if 1: # (w/ wiki passages)
+            final_encoder_output_seq_list = []
+            final_T5_encoder_output_seq_list = []
+            
+            for ind in range(args.num_wiki):
+                T5_encoder_output_seq = self.T5model.encoder(input_ids=T5_source_ids[:,ind,:], attention_mask=T5_source_masks[:,ind,:])
+                #if 1: #(T5 encoder only)
+                #    final_T5_encoder_output_seq_list.append(T5_encoder_output_seq["last_hidden_state"])
+                tmp_encoder_output_seq = torch.cat((final_LXM_encoder_output_seq, T5_encoder_output_seq["last_hidden_state"]),1)
+                final_encoder_output_seq_list.append(tmp_encoder_output_seq)
+            final_encoder_output_seq = torch.cat(final_encoder_output_seq_list,1)
+       
+	# ablation study on two encoders 
+        # LXMERTenc-T5dec
+        final_encoder_output_seq = final_LXM_encoder_output_seq
+        # T5enc-T5dec
+        final_encoder_output_seq = torch.cat(final_T5_encoder_output_seq_list,1)
+
+
+
+
+        
+        
+        my_order_dict=T5_encoder_output_seq 
+        # replace the origin order_dict with our designed final_encoder_output_seq
+	my_order_dict.last_hidden_state=final_encoder_output_seq
+
+        if train:
+            if args.allAns:
+                outputs = self.T5model(encoder_outputs=my_order_dict, labels=T5_target_ids, decoder_attention_mask=T5_target_masks)
+            else:
+                outputs = self.T5model(encoder_outputs=my_order_dict, labels=T5_target_ids, decoder_attention_mask=T5_target_masks)
+            return outputs
+        else:
+            if torch.cuda.device_count() > 1:
+                pred = self.T5model.generate(encoder_outputs=my_order_dict)
+            else:
+                pred = self.T5model.generate(encoder_outputs=my_order_dict)
+            return pred
+
+    def forward(self,  train=None, LXM_source_ids=None, LXM_source_masks=None,T5_source_ids=None, T5_source_masks=None,token_type_ids=None, visual_features=None, spatial_features=None,T5_target_ids=None,T5_target_masks=None):
+        return self.LXMT5end2T5dec(train, LXM_source_ids, LXM_source_masks, T5_source_ids, T5_source_masks, token_type_ids, visual_features, spatial_features, T5_target_ids, T5_target_masks)

code/model_ViB2T5.py

@@ -0,0 +1,68 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import init
+import copy
+from config4LXMT5_DDP import args
+import collections
+from transformers import LxmertConfig, LxmertTokenizer, LxmertModel,BertTokenizer
+from transformers import T5Tokenizer, T5Model, T5Config, T5ForConditionalGeneration
+from transformers.modeling_outputs import  BaseModelOutputWithPastAndCrossAttentions
+T5tokenizer = T5Tokenizer.from_pretrained("../model/t5-large")#"t5-large")
+LXMtokenizer = BertTokenizer.from_pretrained('../model/bert-base-uncased/vocab.txt') 
+T5config = T5Config.from_pretrained('../model/t5-large')
+from transformers import VisualBertConfig, VisualBertModel
+
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+class ViBT52T5(nn.Module):
+    def __init__(self):
+        super(ViBT52T5, self).__init__()
+        self.T5model = T5ForConditionalGeneration.from_pretrained("../model/t5-large").to(device)
+        self.ViBmodel = VisualBertModel.from_pretrained('../model/visualBERT').to(device)
+        self.mapping = torch.nn.Sequential(
+            torch.nn.Linear(768, 1024),
+            torch.nn.ReLU(inplace=True),   
+            torch.nn.Linear(1024, 1024)
+            )
+
+
+    def LXMT5end2T5dec(self,  train=None, LXM_source_ids=None, LXM_source_masks=None,T5_source_ids=None, T5_source_masks=None,token_type_ids=None, visual_features=None, spatial_features=None,T5_target_ids=None,T5_target_masks=None):
+        if 1:
+
+            ViB_encoder_output_seq = self.ViBmodel(input_ids=LXM_source_ids, attention_mask=LXM_source_masks,token_type_ids=token_type_ids, visual_embeds=visual_features) 
+            ViB_VL_encoder_output_seq = ViB_encoder_output_seq[0]
+            final_ViB_encoder_output_seq = self.mapping(ViB_VL_encoder_output_seq)
+
+
+
+
+	# w/o wiki passages
+        #T5_encoder_output_seq = self.T5model.encoder(input_ids=T5_source_ids, attention_mask=T5_source_masks)
+        #final_encoder_output_seq = torch.cat((final_ViB_encoder_output_seq, T5_encoder_output_seq["last_hidden_state"]),1)
+        
+
+        # w/ wiki passages
+	if 1:
+            final_encoder_output_seq_list = []
+            for ind in range(args.num_wiki):
+                T5_encoder_output_seq = self.T5model.encoder(input_ids=T5_source_ids[:,ind,:], attention_mask=T5_source_masks[:,ind,:])
+                tmp_encoder_output_seq = torch.cat((final_ViB_encoder_output_seq, T5_encoder_output_seq["last_hidden_state"]),1)
+                final_encoder_output_seq_list.append(tmp_encoder_output_seq)
+            final_encoder_output_seq = torch.cat(final_encoder_output_seq_list,1)
+        my_order_dict=T5_encoder_output_seq 
+        my_order_dict.last_hidden_state=final_encoder_output_seq
+
+        if train:
+            outputs = self.T5model(encoder_outputs=my_order_dict, labels=T5_target_ids, decoder_attention_mask=T5_target_masks)
+            return outputs
+        else:
+            if torch.cuda.device_count() > 1:
+                pred = self.T5model.generate(encoder_outputs=my_order_dict)
+            else:
+                pred = self.T5model.generate(encoder_outputs=my_order_dict)
+            return pred
+
+
+    def forward(self,  train=None, LXM_source_ids=None, LXM_source_masks=None,T5_source_ids=None, T5_source_masks=None,token_type_ids=None, visual_features=None, spatial_features=None,T5_target_ids=None,T5_target_masks=None):
+        return self.LXMT5end2T5dec(train, LXM_source_ids, LXM_source_masks, T5_source_ids, T5_source_masks, token_type_ids, visual_features, spatial_features, T5_target_ids, T5_target_masks)

code/run_DDP_finetune.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+#!/usr/bin/env bash
+#!/bin/sh
+export load_pthpath=${10}
+export pre_epo=${11}
+export load_pthmodel=$load_pthpath/model_for_epoch_$pre_epo.pth
+
+export NCCL_P2P_LEVEL=NVL
+cd /opt/tiger/okvqa
+export dataset=$1
+
+export model_dir=$2
+mkdir $model_dir
+mkdir $load_pthpath
+
+
+echo "$1, $2, $3, $4, $5, $6, $7, $8, $9, ${10}, ${11}, ${12}"
+echo "dataset $1, model dir $2, input type $3, describe $4, lr $5, lr_LXM $6, batch_size $7, wiki num $8, gpu_num $9, load path ${10}, pre_epo ${11}, seed ${12}"
+
+
+export input_type=$3
+export describe=$4
+export lr=$5
+export lr_LXM=$6
+export batch_size=$7
+export wiki_num=$8
+export gpu_num=$9
+export seed=${12}
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+port=${ports[0]}
+
+echo "total workers: ${ARNOLD_WORKER_NUM}"
+echo "cur worker id: ${ARNOLD_ID}"
+echo "gpus per worker: ${ARNOLD_WORKER_GPU}"
+echo "master ip: ${METIS_WORKER_0_HOST}"
+echo "master port: ${port}"
+
+
+
+export OMP_NUM_THREADS=8
+export NCCL_IB_DISABLE=0
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=${ARNOLD_RDMA_DEVICE}
+export NCCL_SOCKET_IFNAME=eth0
+
+
+python3 -m torch.distributed.launch --nproc_per_node $gpu_num  \
+    --nnodes=${ARNOLD_WORKER_NUM} --node_rank=${ARNOLD_ID} --master_addr=${METIS_WORKER_0_HOST} --master_port ${port} \
+    train4LXMT5_DDP.py \
+    --dataset $dataset \
+    --model_dir $model_dir \
+    --input_type $input_type \
+    --describe $describe \
+    --learning_rate $lr \
+    --learning_rate_LXM $lr_LXM \
+    --validate \
+    --gpt3 \
+    --ofa finetune \
+    --batch_size $batch_size \
+    --load_pthpath $load_pthmodel \
+    --num_wiki $wiki_num \
+    --seed $seed

code/run_DDP_finetune_visualBERT.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+#!/usr/bin/env bash
+#!/bin/sh
+export load_pthpath=${10}
+export pre_epo=${11}
+export load_pthmodel=$load_pthpath/model_for_epoch_$pre_epo.pth
+
+export NCCL_P2P_LEVEL=NVL
+cd /opt/tiger/okvqa
+export dataset=$1
+
+export model_dir=$2
+mkdir $model_dir
+mkdir $load_pthpath
+
+echo "hdfs done"
+echo "$1, $2, $3, $4, $5, $6, $7, $8, $9, ${10}, ${11}, ${12}"
+echo "dataset $1, model dir $2, input type $3, describe $4, lr $5, lr_LXM $6, batch_size $7, wiki num $8, gpu_num $9, load path ${10}, pre_epo ${11}, seed ${12}"
+
+
+
+export input_type=$3
+#model_name to save
+export describe=$4
+export lr=$5
+export lr_LXM=$6
+
+export batch_size=$7
+export wiki_num=$8
+export gpu_num=$9
+export seed=${12}
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+port=${ports[0]}
+
+echo "total workers: ${ARNOLD_WORKER_NUM}"
+echo "cur worker id: ${ARNOLD_ID}"
+echo "gpus per worker: ${ARNOLD_WORKER_GPU}"
+echo "master ip: ${METIS_WORKER_0_HOST}"
+echo "master port: ${port}"
+
+
+
+export OMP_NUM_THREADS=8
+export NCCL_IB_DISABLE=0
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=${ARNOLD_RDMA_DEVICE}
+export NCCL_SOCKET_IFNAME=eth0
+
+python3 -m torch.distributed.launch --nproc_per_node $gpu_num  \
+    --nnodes=${ARNOLD_WORKER_NUM} --node_rank=${ARNOLD_ID} --master_addr=${METIS_WORKER_0_HOST} --master_port ${port} \
+    train4LXMT5_jiqun_wiki_DDP_multiVal_GPT3.py \
+    --dataset $dataset \
+    --model_dir $model_dir \
+    --input_type $input_type \
+    --describe $describe \
+    --learning_rate $lr \
+    --learning_rate_LXM $lr_LXM \
+    --validate \
+    --gpt3 \
+    --ofa finetune \
+    --batch_size $batch_size \
+    --load_pthpath $load_pthmodel \
+    --num_wiki $wiki_num \
+    --seed $seed \
+    --visualBERT
+    

code/run_DDP_pretrain.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+
+export NCCL_P2P_LEVEL=NVL
+echo "dataset $1, model dir $2, input type $3, describe $4, lr $5, lr_LXM $6, batch size $7, wiki num $8, gpu_num $9 "
+
+export dataset=$1
+export model_dir=$2
+mkdir $model_dir
+export input_type=$3
+#model_name to save
+export describe=$4
+export lr=$5
+export lr_LXM=$6
+export batch_size=$7
+# export port=$7
+export wiki_num=$8
+export gpu_num=$9
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+port=${ports[0]}
+
+echo "total workers: ${ARNOLD_WORKER_NUM}"
+echo "cur worker id: ${ARNOLD_ID}"
+echo "gpus per worker: ${ARNOLD_WORKER_GPU}"
+echo "master ip: ${METIS_WORKER_0_HOST}"
+echo "master port: ${port}"
+
+
+
+export OMP_NUM_THREADS=8
+export NCCL_IB_DISABLE=0
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=${ARNOLD_RDMA_DEVICE}
+export NCCL_SOCKET_IFNAME=eth0
+
+python3 -m torch.distributed.launch --nproc_per_node $gpu_num  \
+    --nnodes=${ARNOLD_WORKER_NUM} --node_rank=${ARNOLD_ID} --master_addr=${METIS_WORKER_0_HOST} --master_port ${port} \
+    train4LXMT5_DDP.py \  
+    --dataset $dataset \
+    --model_dir $model_dir \
+    --input_type $input_type \
+    --describe $describe \
+    --learning_rate $lr \
+    --learning_rate_LXM $lr_LXM \
+    --validate \
+    --batch_size $batch_size \
+    --num_wiki $wiki_num \
+    --pretrain 
+    

code/run_DDP_pretrain_visualBERT.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+export NCCL_P2P_LEVEL=NVL
+echo "dataset $1, model dir $2, input type $3, describe $4, lr $5, lr_LXM $6, batch size $7, wiki num $8, gpu_num $9 "
+export dataset=$1
+export model_dir=$2
+mkdir $model_dir
+export input_type=$3
+#model_name to save
+export describe=$4
+export lr=$5
+export lr_LXM=$6
+export batch_size=$7
+# export port=$7
+export wiki_num=$8
+export gpu_num=$9
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+port=${ports[0]}
+
+echo "total workers: ${ARNOLD_WORKER_NUM}"
+echo "cur worker id: ${ARNOLD_ID}"
+echo "gpus per worker: ${ARNOLD_WORKER_GPU}"
+echo "master ip: ${METIS_WORKER_0_HOST}"
+echo "master port: ${port}"
+
+
+
+export OMP_NUM_THREADS=8
+export NCCL_IB_DISABLE=0
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=${ARNOLD_RDMA_DEVICE}
+export NCCL_SOCKET_IFNAME=eth0
+
+python3 -m torch.distributed.launch --nproc_per_node $gpu_num  \
+    --nnodes=${ARNOLD_WORKER_NUM} --node_rank=${ARNOLD_ID} --master_addr=${METIS_WORKER_0_HOST} --master_port ${port} \
+    train4LXMT5_DDP.py \
+    --dataset $dataset \
+    --model_dir $model_dir \
+    --input_type $input_type \
+    --describe $describe \
+    --learning_rate $lr \
+    --learning_rate_LXM $lr_LXM \
+    --validate \
+    --batch_size $batch_size \
+    --num_wiki $wiki_num \
+    --visualBERT \
+    --pretrain

code/test4LXMT5.py

@@ -0,0 +1,53 @@
+from model_LXM2T5 import T5tokenizer, LXMT52T5, LXMtokenizer
+import tqdm
+from dataset_val4LXMT5 import KgDatasetVal
+model = LXMT52T5()
+model.module.load_state_dict(torch.load("xxxx.pth"))
+test_dataset = KgDatasetVal(val=False)
+
+
+test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False,
+                            num_workers=0, collate_fn=my_val_collate)
+
+model.eval()  
+answers = []  # [batch_answers,...]
+preds = []  # [batch_preds,...]
+preds_list = []
+answers_list = []
+id2pred_list = {}
+for i, batch_data in enumerate(tqdm(test_dataloader)):
+    with torch.no_grad():
+        val_T5_input_id = torch.stack(batch_data['T5_input_ids']).to(device)
+        val_T5_input_mask = torch.stack(batch_data['T5_input_masks']).to(device)
+        val_visual_faetures = torch.tensor(np.array(batch_data['img'])).float().to(device)           
+        val_spatial_features = torch.tensor(np.array(batch_data['spatial'])).float().to(device)
+ 
+        val_LXM_input_id = torch.stack(batch_data['LXM_input_ids']).to(device)
+        val_LXM_input_mask = torch.stack(batch_data['LXM_input_masks']).to(device)
+        val_LXM_token_type_ids = torch.stack(batch_data['LXM_token_type_ids']).to(device)
+                    
+
+
+        val_outputs = model(train=False, LXM_source_ids=val_LXM_input_id, LXM_source_masks=val_LXM_input_mask,T5_source_ids=val_T5_input_id, T5_source_masks=val_T5_input_mask,token_type_ids=val_LXM_token_type_ids, visual_features=val_visual_faetures, spatial_features=val_spatial_features,T5_target_ids=None)
+                        
+
+                
+        val_list_predict = T5tokenizer.batch_decode(val_outputs, skip_special_tokens=True)
+
+
+ 
+        for i, pre in enumerate(batch_data['ans']):
+                        
+            preds_list.append(val_list_predict[i])
+                        
+            answers_list.append(batch_data['ans'][i])
+                         
+            id2pred_list[str(batch_data['id'][i])]=val_list_predict[i]
+
+
+
+
+f=open("file_to_save.json", 'w')
+json.dump(id2pred_list, f)
+f.close()
+                        

code/train4LXMT5_DDP.py

@@ -0,0 +1,470 @@
+#!user/bin/env python
+# -*- coding:utf-8 -*-
+import argparse
+import json
+import os
+import datetime
+import pickle
+import random
+import torch
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from bisect import bisect
+from math import fabs
+from torch.optim import lr_scheduler
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import LxmertTokenizer
+from dist_train import get_world_size, get_rank, get_local_rank, barrier, reduce_sum
+
+import numpy as np
+from transformers.tokenization_utils_base import ENCODE_KWARGS_DOCSTRING
+from config4LXMT5_DDP import args
+
+from dataset4LXMT5 import KgDataset, my_collate, my_val_gpt3_collate, my_val_collate 
+from dataset_val4LXMT5 import KgDatasetVal
+
+if args.visualBERT:
+    from model_ViB2T5 import T5tokenizer, ViBT52T5, LXMtokenizer
+else:
+    from model_LXM2T5 import T5tokenizer, LXMT52T5, LXMtokenizer
+
+from transformers import get_linear_schedule_with_warmup
+from transformers import LxmertConfig, LxmertTokenizer, LxmertModel,BertTokenizer
+
+dist.init_process_group(backend='nccl',timeout=datetime.timedelta(seconds=5400))
+torch.cuda.set_device(args.local_rank)
+
+
+# LR = 1e-5
+LR = args.learning_rate
+LR_LXM = args.learning_rate_LXM
+# LR = 1e-4
+
+torch.multiprocessing.set_sharing_strategy('file_system')
+
+torch.cuda.set_device(get_local_rank())
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+def reduce_tensor(tensor: torch.Tensor):
+    rt = tensor.clone().float()
+    dist.all_reduce(rt,op=dist.ReduceOp.SUM)
+    rt /= dist.get_world_size()#.float() 
+    return rt
+
+def set_seed(rank):
+    random.seed(args.seed+rank) 
+    np.random.seed(args.seed+rank)
+    torch.manual_seed(args.seed+rank)
+    torch.cuda.manual_seed(args.seed+rank)
+    torch.cuda.manual_seed_all(args.seed+rank)
+    torch.backends.cudnn.deterministic = True
+
+set_seed(get_rank())
+
+
+
+
+
+def cal_acc_multi(ground_truth, preds, return_id = False):
+    all_num = len(ground_truth)
+    acc_num = 0
+    ids = []
+    temp = []
+    for i, answer_id in enumerate(ground_truth):
+        pred = preds[i]
+        # ids.append([i, int(pred)])
+        cnt = 0
+        for aid in answer_id:
+            if pred == aid:
+                cnt += 1
+        if cnt ==1:
+            acc_num += 1/3 
+        elif cnt == 2:
+            acc_num += 2/3 
+        elif cnt > 2:
+            acc_num += 1
+
+    if return_id:
+        return acc_num / all_num, ids
+    else:
+        return acc_num,  all_num
+   
+def cal_acc(ground_truth, preds, return_id = False):
+    all_num = len(ground_truth)
+    acc_num = 0
+    ids = []
+    temp = []
+    for i, answer_id in enumerate(ground_truth):
+        pred = preds[i]
+        # ids.append([i, int(pred)])
+        cnt = 0
+        for aid in answer_id:
+            if pred == aid:
+                acc_num += 1
+    if return_id:
+        return acc_num / all_num, ids
+    else:
+        return acc_num, all_num
+
+
+def train():
+    if not args.describe:
+        print('please set the description for the saved-model name! use --describe !')
+        assert 1==0
+    else:
+        model_name=args.describe
+    if not args.pretrain:
+        train_dataset = KgDataset(val=False)
+        train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+        train_dataloader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, sampler=train_sampler,#shuffle=True,
+                                      num_workers=0, collate_fn=my_collate)#, pin_memory=True)
+
+        if args.validate:
+            test_dataset = KgDatasetVal(val=False)
+            if args.gpt3:
+                test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False,
+                                            num_workers=0, collate_fn=my_val_gpt3_collate)
+            elif not args.gpt3:
+                test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False,
+                                            num_workers=0, collate_fn=my_val_collate)
+    else:
+        train_dataset = KgDataset(val=False)
+
+        train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+        train_dataloader = DataLoader(dataset=train_dataset, batch_size=args.batch_size,#pin_memory=True,
+                                      num_workers=0, collate_fn=my_collate,  sampler=train_sampler)
+        if args.validate:
+            test_dataset = KgDatasetVal(val=False)
+            if args.gpt3:
+                test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size,
+                                            num_workers=0, collate_fn=my_val_gpt3_collate, shuffle=False)#sampler=test_sampler)
+            elif not args.gpt3:
+                test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False,
+                                            num_workers=0, collate_fn=my_val_collate)
+
+    if args.pretrain:
+        if get_rank() == 0: 
+            print('pre-training!')
+        if args.visualBERT:
+            model=  ViBT52T5()
+        else:
+            model = LXMT52T5()
+    else:
+        if get_rank() == 0: 
+            print('fine-tuning!')
+        if args.visualBERT:
+            model = ViBT52T5()
+        else:
+            model = LXMT52T5()
+
+    model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
+    model = model.to(device)
+    if get_world_size() > 1:
+        if get_rank() == 0: 
+            print("Let's use", get_world_size(), "GPUs!")
+        model = nn.parallel.DistributedDataParallel(model, device_ids=[get_local_rank()], output_device=get_local_rank(),find_unused_parameters=True)
+
+    print(model.named_modules)
+    if get_world_size() > 1:
+        if args.visualBERT:
+            optimizer = optim.AdamW([
+                {'params': model.module.T5model.parameters(), 'lr': LR},
+                {'params': model.module.ViBmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.module.mapping.parameters(), 'lr': LR_LXM},
+            ])
+        else:
+            optimizer = optim.AdamW([
+                {'params': model.module.T5model.parameters(), 'lr': LR},
+                {'params': model.module.LXMmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.module.mapping.parameters(), 'lr': LR_LXM},
+    
+            ])
+    else:
+        if args.visualBERT:
+            optimizer = optim.AdamW([
+                {'params': model.T5model.parameters(), 'lr': LR},
+                {'params': model.ViBmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.mapping.parameters(), 'lr': LR_LXM},
+            ])
+        else:
+            optimizer = optim.AdamW([
+                {'params': model.T5model.parameters(), 'lr': LR},
+                {'params': model.LXMmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.mapping.parameters(), 'lr': LR_LXM},
+            ])
+    
+    if args.pretrain:
+        steps_num = 100000 # batch_size should be set small 
+    else:
+        steps_num = 4000 
+
+
+
+    args.num_epochs = steps_num // (len(train_dataset) / (args.batch_size * get_world_size())) \
+        if len(train_dataset) % args.batch_size == 0 \
+        else  (steps_num // (len(train_dataset) / (args.batch_size * get_world_size())) )+1 
+    args.num_epochs = int(args.num_epochs)
+
+    if get_rank() == 0: 
+        print('total_epoch', args.num_epochs)
+        print('total_steps', "we set steps=",steps_num)
+        print('warmup_steps', int(steps_num/10)) #0.05*total_steps)
+    scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=int(steps_num/10), #0.01 * total_steps,
+                                                num_training_steps=steps_num)
+    
+
+    if args.load_pthpath == "":
+        start_epoch = 0
+    else:
+        if get_rank() == 0: 
+            print('load model')
+        start_epoch = 0
+
+        if get_world_size() > 1:
+            model.module.load_state_dict(torch.load(args.load_pthpath))
+        else:
+            model.load_state_dict(torch.load(args.load_pthpath))
+
+
+    best_acc_t = 0
+    best_epoch_t = 0
+    best_acc_t3 = 0
+    step_ind = 0
+
+    for epoch in range(start_epoch, args.num_epochs):
+        train_preds_trip = []
+        train_sampler.set_epoch(epoch)
+        train_answers_trip = []
+        s=0
+        for batch_data in tqdm(train_dataloader):
+            step_ind+=1
+            if get_rank()==0:
+                print("step_ind",step_ind)
+            s=s+1
+            visual_faetures = torch.from_numpy(np.array(batch_data['img'], dtype=float)).float().to(device)
+            spatial_features = torch.tensor(np.array(batch_data['spatial'])).float().to(device)
+            if 1:
+                T5_input_id = torch.stack(batch_data['T5_input_ids']).to(device)
+                T5_input_mask = torch.stack(batch_data['T5_input_masks']).to(device)
+
+
+            LXM_input_id = torch.stack(batch_data['LXM_input_ids']).to(device)
+            LXM_input_mask = torch.stack(batch_data['LXM_input_masks']).to(device)
+            LXM_token_type_ids = torch.stack(batch_data['LXM_token_type_ids']).to(device)
+
+            T5_target_id = torch.stack(batch_data['T5_target_ids']).to(device)
+
+            neg100 = torch.ones_like(T5_target_id)*(-100)
+            T5_target_id = torch.where(T5_target_id==T5tokenizer.pad_token_id,neg100, T5_target_id)
+
+
+            
+
+            model.zero_grad()
+
+
+            optimizer.zero_grad()
+            if args.pretrain:
+                outputs = model(train=True, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)#,T5_target_masks=None
+            else:
+                outputs = model(train=True, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)#,T5_target_masks=None
+            loss = outputs.loss
+
+            loss_stat = torch.mean(loss.detach()).item()
+
+            if get_rank() == 0: 
+                print("loss on GPU0", loss_stat)
+            loss.sum().backward()
+            optimizer.step()
+            scheduler.step()
+            model.eval()
+            with torch.no_grad():
+                if args.pretrain:
+                    eval_outputs = model(train=False, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)
+                else:
+                    eval_outputs = model(train=False, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)
+                trip_predict = T5tokenizer.batch_decode(eval_outputs, skip_special_tokens=True)
+                if get_rank() == 0: 
+                    print('epoch', epoch, 'step', s, '>>>', '\tans:', batch_data['ans'][0], 'pred:', trip_predict[0])
+                for i, pre in enumerate(batch_data['ans']):
+                    train_answers_trip.append(batch_data['ans'][i])
+                    train_preds_trip.append(trip_predict[i])
+                            
+            model.train()            
+            barrier()
+            
+
+
+
+
+
+
+
+
+        barrier()
+
+        if 1:
+            train_acc_1_num, train_total_1_num = cal_acc_multi(train_answers_trip, train_preds_trip)
+
+            train_reduce_acc_num=reduce_tensor(torch.tensor(train_acc_1_num).cuda(args.local_rank)).item()
+            train_reduce_total_num=reduce_tensor(torch.tensor(train_total_1_num).cuda(args.local_rank)).item()
+            train_acc_1_trip = train_reduce_acc_num/train_reduce_total_num
+            if get_rank() == 0:
+                print('epoch %d train_loss of GPU0= %.1f, acc_trip on all GPUs= %.4f' % (epoch, loss_stat,
+                                                                          train_acc_1_trip))
+        if args.validate:
+            model.eval()  
+            answers = []  # [batch_answers,...]
+            preds = []  # [batch_preds,...]
+            preds_trip = []
+            preds_trip_3 = []
+            answers_trip = []
+            id2pred_trip = {}
+            print(f"\nValidation after epoch {epoch}:")
+            for i, batch_data in enumerate(tqdm(test_dataloader)):
+                with torch.no_grad():
+                    val_T5_input_id = torch.stack(batch_data['T5_input_ids']).to(device)
+                    val_T5_input_mask = torch.stack(batch_data['T5_input_masks']).to(device)
+
+                    val_visual_faetures = torch.tensor(np.array(batch_data['img'])).float().to(device)
+                    val_spatial_features = torch.tensor(np.array(batch_data['spatial'])).float().to(device)
+
+                    val_LXM_input_id = torch.stack(batch_data['LXM_input_ids']).to(device)
+                    val_LXM_input_mask = torch.stack(batch_data['LXM_input_masks']).to(device)
+                    val_LXM_token_type_ids = torch.stack(batch_data['LXM_token_type_ids']).to(device)
+
+
+                    if args.pretrain:
+                        val_outputs = model(train=False, LXM_source_ids=val_LXM_input_id, LXM_source_masks=val_LXM_input_mask,T5_source_ids=val_T5_input_id, T5_source_masks=val_T5_input_mask,token_type_ids=val_LXM_token_type_ids, visual_features=val_visual_faetures, spatial_features=val_spatial_features,T5_target_ids=None)
+                    else:
+                        val_outputs = model(train=False, LXM_source_ids=val_LXM_input_id, LXM_source_masks=val_LXM_input_mask,T5_source_ids=val_T5_input_id, T5_source_masks=val_T5_input_mask,token_type_ids=val_LXM_token_type_ids, visual_features=val_visual_faetures, spatial_features=val_spatial_features,T5_target_ids=None)
+
+
+                    val_trip_predict = T5tokenizer.batch_decode(val_outputs, skip_special_tokens=True)
+
+
+                    
+                    for i, pre in enumerate(batch_data['ans']):
+                        preds_trip.append(val_trip_predict[i])
+                        answers_trip.append(batch_data['ans'][i])
+
+                        id2pred_trip[str(batch_data['id'][i])]=val_trip_predict[i]
+
+
+            if args.dataset == 'krvqa':
+                acc_1_num, total_1_num = cal_acc(answers_trip, preds_trip)
+                reduce_acc_num=reduce_tensor(torch.tensor(acc_1_num).cuda(args.local_rank)).item()
+                reduce_total_num=reduce_tensor(torch.tensor(total_1_num).cuda(args.local_rank)).item()
+                acc_1_trip = reduce_acc_num/reduce_total_num
+                if get_rank() == 0: 
+                    print('epoch %d ,  acc_trip on all GPUs= %.4f' % (epoch, acc_1_trip))
+
+            else:
+                acc_1_num, total_1_num = cal_acc_multi(answers_trip, preds_trip)
+                reduce_acc_num=reduce_tensor(torch.tensor(acc_1_num).cuda(args.local_rank)).item()
+                reduce_total_num=reduce_tensor(torch.tensor(total_1_num).cuda(args.local_rank)).item()
+                acc_1_trip = reduce_acc_num/reduce_total_num
+                if get_rank() == 0: 
+                    print('epoch %d ,  acc_trip on all GPUs= %.4f' % (epoch, acc_1_trip))
+
+            if acc_1_trip > best_acc_t:
+                
+                best_acc_t = acc_1_trip
+                best_epoch_t = epoch
+                if not args.pretrain:
+                    if get_rank() == 0:
+                        f=open(args.model_dir+"/predictions.json", 'w')
+                        json.dump(id2pred_trip, f)
+                        f.close()
+
+                        """
+			# ablations on two encoders
+			#  LXMERTenc-T5dec
+                            if args.load_pthpath == "":
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/C1_LXMERTencOnly_noPre_predictions.json", 'w') #GPT-noPre
+                            else:
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/C3_LXMERTencOnly_predictions.json", 'w') #GPT
+
+                            json.dump(id2pred_trip, fx)
+                            fx.close()
+			# T5enc-T5dec
+                            if args.load_pthpath == "":
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/C2_T5encOnly_noPre_predictions.json", 'w') #GPT-noPre
+                            else:
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/C4_T5encOnly_predictions.json", 'w') #GPT
+                            
+                            json.dump(id2pred_trip, fx)
+                            fx.close()
+			"""
+                        """
+			# ablations on Knowledge types
+			if args.gpt3:
+                            if args.input_type==0 and args.load_pthpath == "":
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/A2_noPre_predictions.json", 'w') #GPT-noPre
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            elif args.input_type==1 and (args.load_pthpath != ""):
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/A3_noWiki_predictions.json", 'w') #GPT
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            elif args.input_type==2 and (args.load_pthpath != ""):
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/A4_noOFA_predictions.json", 'w') #GPT
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            elif args.input_type==3 and (args.load_pthpath == ""):
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/B1_onlyGPT3_predictions.json", 'w')  #GPT-noPre
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                        else:
+                            if args.input_type==0 and args.load_pthpath != "":
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/A5_noGPT3_predictions.json", 'w')    #noGPT
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            elif args.input_type==0 and args.load_pthpath == "":
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/A6_noGPT3noPre_predictions.json", 'w')    #noGPT
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            
+                            elif args.input_type==1 and (args.load_pthpath == ""):
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/B2_onlyOFA_predictions.json", 'w')   #noGPT-noPre
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            elif args.input_type==2 and (args.load_pthpath == ""):
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/B3_onlyWiki_predictions.json", 'w')  #noGPT-noPre
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+                            elif args.input_type==3 and (args.load_pthpath == ""):
+                                fx=open("/mnt/bn/qingyi-bn-lq/okvqa-output/B4_onlyVisualNoKnowledge_predictions.json", 'w') #noGPT-noPre
+                                json.dump(id2pred_trip, fx)
+                                fx.close()
+
+                        """     
+                        
+
+                        print('saving model at epoch', epoch, '!!')
+                        if get_world_size() > 1:
+                            torch.save(model.module.state_dict(), args.model_dir+'/best_finetuned_model_'+model_name+'.pth')
+                        else:
+                            torch.save(model.state_dict(), args.model_dir+'/best_finetuned_model_'+model_name+'.pth')
+
+            if get_rank() == 0: 
+                print("best_acc@1t={:.2%}, epoch{}\n\n".format(best_acc_t, best_epoch_t))
+
+            model.train()        
+        if args.pretrain:
+            if get_rank() == 0:
+                if get_world_size() > 1:
+                    torch.save(model.module.state_dict(), args.model_dir+ '/model_for_epoch_%d.pth' % epoch)
+                else:
+                    torch.save(model.state_dict(), args.model_dir+ '/model_for_epoch_%d.pth' % epoch)
+
+        barrier()
+        
+
+    dist.destroy_process_group()
+if __name__ == "__main__":
+    train()

code/train4LXMT5_DDP_original.py

@@ -0,0 +1,435 @@
+#!user/bin/env python
+# -*- coding:utf-8 -*-
+import argparse
+import json
+import os
+import datetime
+import pickle
+import random
+import torch
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from bisect import bisect
+from math import fabs
+from torch.optim import lr_scheduler
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import LxmertTokenizer
+from dist_train import get_world_size, get_rank, get_local_rank, barrier, reduce_sum
+
+import numpy as np
+from transformers.tokenization_utils_base import ENCODE_KWARGS_DOCSTRING
+from config4LXMT5_DDP import args
+
+from dataset4LXMT5 import KgDataset,my_collate,my_val_collate
+from dataset_val4LXMT5 import KgDatasetVal
+
+if args.visualBERT:
+    from model_ViB2T5 import T5tokenizer, ViBT52T5, LXMtokenizer
+else:
+    from model_LXM2T5 import T5tokenizer, LXMT52T5, LXMtokenizer
+
+from transformers import get_linear_schedule_with_warmup
+from transformers import LxmertConfig, LxmertTokenizer, LxmertModel,BertTokenizer
+
+dist.init_process_group(backend='nccl',timeout=datetime.timedelta(seconds=5400))
+torch.cuda.set_device(args.local_rank)
+
+
+# LR = 1e-5
+LR = args.learning_rate
+LR_LXM = args.learning_rate_LXM
+# LR = 1e-4
+
+torch.multiprocessing.set_sharing_strategy('file_system')
+
+torch.cuda.set_device(get_local_rank())
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+def reduce_tensor(tensor: torch.Tensor):
+    rt = tensor.clone().float()
+    dist.all_reduce(rt,op=dist.ReduceOp.SUM)
+    rt /= dist.get_world_size()#.float() 
+    return rt
+
+def set_seed(rank):
+    random.seed(args.seed+rank) 
+    np.random.seed(args.seed+rank)
+    torch.manual_seed(args.seed+rank)
+    torch.cuda.manual_seed(args.seed+rank)
+    torch.cuda.manual_seed_all(args.seed+rank)
+    torch.backends.cudnn.deterministic = True
+
+set_seed(get_rank())
+
+
+
+
+
+def cal_acc_multi(ground_truth, preds, return_id = False):
+    all_num = len(ground_truth)
+    acc_num = 0
+    ids = []
+    temp = []
+    for i, answer_id in enumerate(ground_truth):
+        pred = preds[i]
+        # ids.append([i, int(pred)])
+        cnt = 0
+        for aid in answer_id:
+            if pred == aid:
+                cnt += 1
+        if cnt ==1:
+            acc_num += 1/3 
+        elif cnt == 2:
+            acc_num += 2/3 
+        elif cnt > 2:
+            acc_num += 1
+    if return_id:
+        return acc_num / all_num, ids
+    else:
+        return acc_num,  all_num
+   
+def cal_acc(ground_truth, preds, return_id = False):
+    all_num = len(ground_truth)
+    acc_num = 0
+    ids = []
+    temp = []
+    for i, answer_id in enumerate(ground_truth):
+        pred = preds[i]
+        # ids.append([i, int(pred)])
+        cnt = 0
+        for aid in answer_id:
+            if pred == aid:
+                acc_num += 1
+    if return_id:
+        return acc_num / all_num, ids
+    else:
+        return acc_num, all_num
+
+
+def train():
+    if not args.describe:
+        print('please set the description for the saved-model name! use --describe !')
+        assert 1==0
+    else:
+        model_name=args.describe
+    if not args.pretrain:
+        train_dataset = KgDataset(val=False)
+        train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+        train_dataloader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, sampler=train_sampler,#shuffle=True,
+                                      num_workers=0, collate_fn=my_collate)#, pin_memory=True)
+        
+        if args.validate:
+            test_dataset = KgDatasetVal(val=False)
+            test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False,
+                                         num_workers=0, collate_fn=my_val_collate)
+    else:
+        train_dataset = KgDataset(val=False)
+        
+        train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+        train_dataloader = DataLoader(dataset=train_dataset, batch_size=args.batch_size,#pin_memory=True,
+                                      num_workers=0, collate_fn=my_collate,  sampler=train_sampler)#shuffle=True,
+                                    #   num_workers=0, collate_fn=my_collate_pretrain,  sampler=train_sampler)#shuffle=True,
+        if args.validate:
+            test_dataset = KgDatasetVal(val=False)
+            test_dataloader = DataLoader(dataset=test_dataset, batch_size=args.batch_size,
+                                         num_workers=0, collate_fn=my_val_collate, shuffle=False)#sampler=test_sampler)
+    if args.pretrain:
+        if get_rank() == 0: 
+            print('pre-training!')
+        if args.visualBERT:
+            model=  ViBT52T5()
+        else:
+            model = LXMT52T5()
+    else:
+        if get_rank() == 0: 
+            print('fine-tuning!')
+        if args.visualBERT:
+            model=  ViBT52T5()
+        else:
+            model = LXMT52T5()
+
+    model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
+    model = model.to(device)
+
+    if get_world_size() > 1:
+        if get_rank() == 0: 
+            
+            print("Let's use", get_world_size(), "GPUs!")
+        
+        model = nn.parallel.DistributedDataParallel(model, device_ids=[get_local_rank()], output_device=get_local_rank(),find_unused_parameters=True)
+
+    print(model.named_modules)
+    if get_world_size() > 1:
+        if args.visualBERT:
+            optimizer = optim.AdamW([
+                {'params': model.module.T5model.parameters(), 'lr': LR},
+                {'params': model.module.ViBmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.module.mapping.parameters(), 'lr': LR_LXM},
+            ])
+        else:
+            optimizer = optim.AdamW([
+                {'params': model.module.T5model.parameters(), 'lr': LR},
+                {'params': model.module.LXMmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.module.mapping.parameters(), 'lr': LR_LXM},
+    
+            ])
+    else:
+        if args.visualBERT:
+            optimizer = optim.AdamW([
+                {'params': model.T5model.parameters(), 'lr': LR},
+                {'params': model.ViBmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.mapping.parameters(), 'lr': LR_LXM},
+            ])
+        else:
+            optimizer = optim.AdamW([
+                {'params': model.T5model.parameters(), 'lr': LR},
+                {'params': model.LXMmodel.parameters(), 'lr': LR_LXM},
+                {'params': model.mapping.parameters(), 'lr': LR_LXM},
+            ])
+    
+
+
+    if args.pretrain:
+        steps_num = 100000
+    else:
+        steps_num = 20000
+
+
+
+
+    args.num_epochs = steps_num // (len(train_dataset) / (args.batch_size * get_world_size())) \
+        if len(train_dataset) % args.batch_size == 0 \
+        else  (steps_num // (len(train_dataset) / (args.batch_size * get_world_size())) )+1 
+        
+    args.num_epochs = int(args.num_epochs)
+
+    if get_rank() == 0: 
+        print('total_epoch', args.num_epochs)
+        print('total_steps', "we set steps=",steps_num)
+        print('warmup_steps', int(steps_num/10)) #0.05*total_steps)
+    scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=int(steps_num/10), #0.01 * total_steps,
+                                                num_training_steps=steps_num)
+    
+
+    if args.load_pthpath == "":
+        start_epoch = 0
+    else:
+        if get_rank() == 0: 
+            print('load model')
+        start_epoch = 0
+        
+
+        if get_world_size() > 1:
+            model.module.load_state_dict(torch.load(args.load_pthpath))
+        else:
+            model.load_state_dict(torch.load(args.load_pthpath))
+
+
+
+    best_acc = 0
+    best_epoch = 0
+    best_acc_t = 0
+    best_epoch_t = 0
+    best_acc_t3 = 0
+    step_ind = 0
+
+    for epoch in range(start_epoch, args.num_epochs):
+        train_preds_trip = []
+        train_sampler.set_epoch(epoch)
+        train_answers_trip = []
+        s=0
+        for batch_data in tqdm(train_dataloader):
+            step_ind+=1
+            if get_rank()==0:
+                print("step_ind",step_ind)
+            s=s+1
+            
+            visual_faetures = torch.from_numpy(np.array(batch_data['img'], dtype=float)).float().to(device)
+            spatial_features = torch.tensor(np.array(batch_data['spatial'])).float().to(device)
+            
+            if 1:
+                
+                T5_input_id = torch.stack(batch_data['T5_input_ids']).to(device)
+                T5_input_mask = torch.stack(batch_data['T5_input_masks']).to(device)
+
+
+            LXM_input_id = torch.stack(batch_data['LXM_input_ids']).to(device)
+            LXM_input_mask = torch.stack(batch_data['LXM_input_masks']).to(device)
+            LXM_token_type_ids = torch.stack(batch_data['LXM_token_type_ids']).to(device)
+
+
+            T5_target_id = torch.stack(batch_data['T5_target_ids']).to(device)
+
+            neg100 = torch.ones_like(T5_target_id)*(-100)
+            T5_target_id = torch.where(T5_target_id==T5tokenizer.pad_token_id,neg100, T5_target_id)
+
+
+            
+
+            model.zero_grad()
+
+
+            optimizer.zero_grad()
+            if args.pretrain:
+                outputs = model(train=True, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)#,T5_target_masks=None
+                
+
+            else:
+                outputs = model(train=True, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)#,T5_target_masks=None
+            loss = outputs.loss
+
+            loss_stat = torch.mean(loss.detach()).item()
+
+            if get_rank() == 0: 
+                print("loss on GPU0", loss_stat)
+
+            loss.sum().backward()
+            optimizer.step()
+            scheduler.step()
+
+            with torch.no_grad():
+                
+                if args.pretrain:
+                    eval_outputs = model(train=False, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)#,T5_target_masks=None
+
+                else:
+                    eval_outputs = model(train=False, LXM_source_ids=LXM_input_id, LXM_source_masks=LXM_input_mask,T5_source_ids=T5_input_id, T5_source_masks=T5_input_mask,token_type_ids=LXM_token_type_ids, visual_features=visual_faetures, spatial_features=spatial_features,T5_target_ids=T5_target_id)#,T5_target_masks=None
+
+                trip_predict = T5tokenizer.batch_decode(eval_outputs, skip_special_tokens=True)
+                if get_rank() == 0: 
+                    print('epoch', epoch, 'step', s, '>>>', '\tans:', batch_data['ans'][0], 'pred:', trip_predict[0])
+                
+                for i, pre in enumerate(batch_data['ans']):
+                    train_answers_trip.append(batch_data['ans'][i])
+                    train_preds_trip.append(trip_predict[i])
+
+            barrier()
+        barrier()
+
+        
+        if args.dataset == 'krvqa':
+            train_acc_1_num, train_total_1_num = cal_acc(train_answers_trip, train_preds_trip)
+
+            train_reduce_acc_num=reduce_tensor(torch.tensor(train_acc_1_num).cuda(args.local_rank)).item()
+            train_reduce_total_num=reduce_tensor(torch.tensor(train_total_1_num).cuda(args.local_rank)).item()
+            train_acc_1_trip = train_reduce_acc_num/train_reduce_total_num
+
+            if get_rank() == 0: 
+                # print("train_acc_1_trip all GPUs:", train_acc_1_trip)
+                print('epoch %d train_loss = %.1f, acc_trip = %.4f' % (epoch, loss_stat,train_acc_1_trip))
+        else:
+
+            train_acc_1_num, train_total_1_num = cal_acc_multi(train_answers_trip, train_preds_trip)
+
+            train_reduce_acc_num=reduce_tensor(torch.tensor(train_acc_1_num).cuda(args.local_rank)).item()
+            train_reduce_total_num=reduce_tensor(torch.tensor(train_total_1_num).cuda(args.local_rank)).item()
+            train_acc_1_trip = train_reduce_acc_num/train_reduce_total_num
+            if get_rank() == 0:
+
+                print('epoch %d train_loss of GPU0= %.1f, acc_trip on all GPUs= %.4f' % (epoch, loss_stat,
+                                                                          train_acc_1_trip))
+
+        barrier()
+        if args.validate:
+            model.eval()  
+            answers = []  # [batch_answers,...]
+            preds = []  # [batch_preds,...]
+            preds_trip = []
+            preds_trip_3 = []
+            answers_trip = []
+            id2pred_trip = {}
+            print(f"\nValidation after epoch {epoch}:")
+            for i, batch_data in enumerate(tqdm(test_dataloader)):
+                with torch.no_grad():
+                    val_T5_input_id = torch.stack(batch_data['T5_input_ids']).to(device)
+                    val_T5_input_mask = torch.stack(batch_data['T5_input_masks']).to(device)
+
+
+                    val_visual_faetures = torch.tensor(np.array(batch_data['img'])).float().to(device)
+
+                    val_spatial_features = torch.tensor(np.array(batch_data['spatial'])).float().to(device)
+
+
+
+                    val_LXM_input_id = torch.stack(batch_data['LXM_input_ids']).to(device)
+                    val_LXM_input_mask = torch.stack(batch_data['LXM_input_masks']).to(device)
+                    val_LXM_token_type_ids = torch.stack(batch_data['LXM_token_type_ids']).to(device)
+
+
+
+                    if args.pretrain:
+                        val_outputs = model(train=False, LXM_source_ids=val_LXM_input_id, LXM_source_masks=val_LXM_input_mask,T5_source_ids=val_T5_input_id, T5_source_masks=val_T5_input_mask,token_type_ids=val_LXM_token_type_ids, visual_features=val_visual_faetures, spatial_features=val_spatial_features,T5_target_ids=None)#,T5_target_masks=None
+                       
+                    else:
+                        val_outputs = model(train=False, LXM_source_ids=val_LXM_input_id, LXM_source_masks=val_LXM_input_mask,T5_source_ids=val_T5_input_id, T5_source_masks=val_T5_input_mask,token_type_ids=val_LXM_token_type_ids, visual_features=val_visual_faetures, spatial_features=val_spatial_features,T5_target_ids=None)#,T5_target_masks=None
+
+
+
+                    val_trip_predict = T5tokenizer.batch_decode(val_outputs, skip_special_tokens=True)
+
+
+                    
+                    
+                    for i, pre in enumerate(batch_data['ans']):
+                        preds_trip.append(val_trip_predict[i])
+                        answers_trip.append(batch_data['ans'][i])
+
+                        id2pred_trip[str(batch_data['id'][i])]=val_trip_predict[i]
+
+
+            if args.dataset == 'krvqa':
+                acc_1_num, total_1_num = cal_acc(answers_trip, preds_trip)
+                reduce_acc_num=reduce_tensor(torch.tensor(acc_1_num).cuda(args.local_rank)).item()
+                reduce_total_num=reduce_tensor(torch.tensor(total_1_num).cuda(args.local_rank)).item()
+                acc_1_trip = reduce_acc_num/reduce_total_num
+                if get_rank() == 0: 
+                    print('epoch %d ,  acc_trip on all GPUs= %.4f' % (epoch, acc_1_trip))
+
+            else:
+                acc_1_num, total_1_num = cal_acc_multi(answers_trip, preds_trip)
+                reduce_acc_num=reduce_tensor(torch.tensor(acc_1_num).cuda(args.local_rank)).item()
+                reduce_total_num=reduce_tensor(torch.tensor(total_1_num).cuda(args.local_rank)).item()
+                acc_1_trip = reduce_acc_num/reduce_total_num
+                if get_rank() == 0: 
+                    print('epoch %d ,  acc_trip on all GPUs= %.4f' % (epoch, acc_1_trip))
+
+            if acc_1_trip > best_acc_t:
+                
+                best_acc_t = acc_1_trip
+                best_epoch_t = epoch
+                if not args.pretrain:
+                    if get_rank() == 0:
+                        f=open(args.model_dir+"/predictions.json", 'w')
+                        json.dump(id2pred_trip, f)
+                        f.close()
+                        print('saving model at epoch', epoch, '!!')
+                        
+                        if get_world_size() > 1:
+                            torch.save(model.module.state_dict(), args.model_dir+'/best_finetuned_model_'+model_name+'.pth')
+                        else:
+                            torch.save(model.state_dict(), args.model_dir+'/best_finetuned_model_'+model_name+'.pth')
+
+
+  
+            if get_rank() == 0: 
+                print("best_acc@1t={:.2%}, epoch{}\n\n".format(best_acc_t, best_epoch_t))
+            model.train()        
+        if args.pretrain:
+           
+            if get_rank() == 0: #对于预训练，那么每个模型都保存一下，以便后面选取合适的，或者进行相应分析。
+                if get_world_size() > 1:
+                    torch.save(model.module.state_dict(), args.model_dir+ '/model_for_epoch_%d.pth' % epoch)
+                else:
+                    torch.save(model.state_dict(), args.model_dir+ '/model_for_epoch_%d.pth' % epoch)
+
+
+        barrier()
+        
+
+    dist.destroy_process_group()
+if __name__ == "__main__":
+    train()