From 1d7feb0880088d861da0c65406ed17d89e9d2b52 Mon Sep 17 00:00:00 2001 From: Jiasen Lu Date: Sun, 5 Jun 2016 18:10:25 -0700 Subject: [PATCH] init_update --- README.md | 122 +++++++++- data/cocoqa_preprocess.py | 4 +- data/vqa_preprocess.py | 4 +- eval.lua | 193 +++++++++++++++ misc/DataLoader.lua | 161 +++++++++++++ misc/DataLoaderDisk.lua | 168 +++++++++++++ misc/DataLoaderRaw.lua | 163 +++++++++++++ misc/LSTM.lua | 64 +++++ misc/LanguageEmbedding.lua | 79 ++++++ misc/attention.lua | 170 +++++++++++++ misc/attention_visu.lua | 174 ++++++++++++++ misc/cnnModel.lua | 75 ++++++ misc/maskSoftmax.lua | 30 +++ misc/optim_updates.lua | 84 +++++++ misc/phrase_level.lua | 91 +++++++ misc/ques_level.lua | 168 +++++++++++++ misc/recursive_atten.lua | 44 ++++ misc/utils.lua | 71 ++++++ misc/word_level.lua | 115 +++++++++ predict.ipynb | 423 +++++++++++++++++++++++++++++++++ prepro/prepro_cocoqa.py | 4 +- prepro/prepro_img_residule.lua | 6 +- prepro/prepro_img_vgg.lua | 12 +- prepro/prepro_vqa.py | 12 +- train.lua | 362 ++++++++++++++++++++++++++++ vis/demo_img1.jpg | Bin 0 -> 213947 bytes 26 files changed, 2774 insertions(+), 25 deletions(-) create mode 100644 eval.lua create mode 100644 misc/DataLoader.lua create mode 100644 misc/DataLoaderDisk.lua create mode 100644 misc/DataLoaderRaw.lua create mode 100644 misc/LSTM.lua create mode 100644 misc/LanguageEmbedding.lua create mode 100644 misc/attention.lua create mode 100644 misc/attention_visu.lua create mode 100644 misc/cnnModel.lua create mode 100644 misc/maskSoftmax.lua create mode 100644 misc/optim_updates.lua create mode 100644 misc/phrase_level.lua create mode 100644 misc/ques_level.lua create mode 100644 misc/recursive_atten.lua create mode 100644 misc/utils.lua create mode 100644 misc/word_level.lua create mode 100644 predict.ipynb create mode 100644 train.lua create mode 100644 vis/demo_img1.jpg diff --git a/README.md b/README.md index faf18f2..dd434a9 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,123 @@ # Hierarchical Co-Attention for Visual Question Answering -Train a Hierarchical Co-Attention model for Visual Question Answering. This current code can get 62.1 on Open-Ended and 66.1 on Multiple-Choice on test-standard split. You can check Codalab leaderboard for more details. +Train a Hierarchical Co-Attention model for Visual Question Answering. This current code can get 62.1 on Open-Ended and 66.1 on Multiple-Choice on test-standard split. For COCO-QA, this code can get 65.4 on Accuracy. For more information, please refer the paper [https://arxiv.org/abs/1606.00061](https://arxiv.org/abs/1606.00061) -![teaser results](https://raw.github.com/jiasenlu/HieCoAttenVQA/master/vis/demo.png) +### Requirements +This code is written in Lua and requires [Torch](http://torch.ch/). The preprocssinng code is in Python, and you need to install [NLTK](http://www.nltk.org/) if you want to use NLTK to tokenize the question. + +You also need to install the following package in order to sucessfully run the code. + +- [cudnn.torch](https://github.com/soumith/cudnn.torch) +- [torch-hdf5](https://github.com/deepmind/torch-hdf5) +- [lua-cjson](http://www.kyne.com.au/~mark/software/lua-cjson.php) +- [loadcaffe](https://github.com/szagoruyko/loadcaffe) +- [iTorch](https://github.com/facebook/iTorch) + +### Training + +We have prepared everything for you ;) + +##### Download Dataset +The first thing you need to do is to download the data and do some preprocessing. Head over to the `data/` folder and run + +For **VQA**: + +``` +$ python vqa_preprocessing.py --download True --split 1 +``` +`--download Ture` means you choose to download the VQA data from the [VQA website](http://www.visualqa.org/) and `--split 1` means you use COCO train set to train and validation set to evaluation. `--split 2 ` means you use COCO train+val set to train and test set to evaluate. After this step, it will generate two files under the `data` folder. `vqa_raw_train.json` and `vqa_raw_test.json` + +For **COCO-QA** + +``` +$ python vqa_preprocessing.py --download True +``` +This will download the COCO-QA dataset from [here](http://www.cs.toronto.edu/~mren/imageqa/data/cocoqa/) and generate two files under the `data` folder. `cocoqa_raw_train.json` and `cocoqa_raw_test.json` + +##### Download Image Model +Here we use VGG_ILSVRC_19_layers [model](https://gist.github.com/ksimonyan/3785162f95cd2d5fee77) and Deep Residual network implement by Facebook [model](https://github.com/facebook/fb.resnet.torch). + +Head over to the `image_model` folder and run + +``` +$ python download_model --download 'VGG' +``` +This will download the VGG_ILSVRC_19_layers model under `image_model` folder. To download the Deep Residual Model, you need to change the `VGG` to `Residual`. + +##### Generate Image/Question Features + +Head over to the `prepro` folder and run + +For **VQA**: + +``` +$ python prepro_vqa.py --input_train_json ../data/vqa_raw_train.json --input_test_json ../data/vqa_raw_test.json --num_ans 1000 +``` +to get the question features. --num_ans specifiy how many top answers you want to use during training. You will also see some question and answer statistics in the terminal output. This will generate two files in `data/` folder, `vqa_data_prepro.h5` and `vqa_data_prepro.json`. + + +For **COCO-QA** + +``` +$ python prepro_cocoqa.py --input_train_json ../data/cocoqa_raw_train.json --input_test_json ../data/cocoqa_raw_test.json +``` +COCO-QA use all the answers in train, so there is no `--num_ans` option. This will generate two files in `data/` folder, `cocoqa_data_prepro.h5` and `cocoqa_data_prepro.json`. + +Then we are ready to extract the image features. -## Comming soon! +For **VGG** image feature: + +``` +$ th prepro_img_vgg.lua -input_json ../data/vqa_data_prepro.json -image_root /home/jiasenlu/data/ -cnn_proto ../image_model/VGG_ILSVRC_19_layers_deploy.prototxt -cnn_model ../image_model/VGG_ILSVRC_19_layers.caffemodel +``` +you can change the `-gpuid`, `-backend` and `-batch_size` based on your gpu. + +For **Deep Residual** image feature: + +##### Train the model + +We have everything ready to train the VQA and COCO-QA model. Back to the `main` folder + +``` +th train.lua -input_img_train_h5 data/vqa_data_img_vgg_train.h5 -input_img_test_h5 data/vqa_data_img_vgg_test.h5 -input_ques_h5 data/vqa_data_prepro.h5 -input_json data/vqa_data_prepro.json -co_atten_type Alternating -feature_type VGG +``` + +to train **Alternating co-attention** model on VQA using VGG image feature. You can train the **Parallel co-attention** by setting `-co_atten_type Parallel`. The prallel co-attention usually takes more time than alternating co-attention. + +##### Note +- Deep Residual Image Feature is 4 times larger than VGG feature, make sure you have enough RAM when you extract or load the features. +- If you didn't have large RAM, replace the `require 'misc.DataLoader'` (Line 11 in `train.lua`) with `require 'misc.DataLoaderDisk`. The model will read the data directly from the hard disk (SSD prefered) + +### Evaluation + +##### Evaluate using Pre-trained Model +The pre-trained model can be download [here](https://filebox.ece.vt.edu/~jiasenlu/codeRelease/co_atten/model/) + +##### Metric + +To Evaluate VQA, you need to download the VQA [evaluation tool](https://github.com/VT-vision-lab/VQA). To evaluate COCO-QA, you can use script `evaluate_cocoqa.py` under `metric/` folder. If you need to evaluate based on WUPS, download the evaluation script from [here](http://datasets.d2.mpi-inf.mpg.de/mateusz14visual-turing/calculate_wups.py) + +##### VQA on Single Image with Free Form Question + +We use iTorch to demo the visual question answering with pre-trained model. +In the root folder, open `itorch notebook`, then you can load any image and ask question using the itorch notebook. + +##### Attention Visualization + + +### Reference + +If you use this code as part of any published research, please acknowledge the following paper + +``` +@misc{Lu2016Hie, +author = {Lu, Jiasen and Yang, Jianwei and Batra, Dhruv and Parikh, Devi}, +title = {Hierarchical Question-Image Co-Attention for Visual Question Answering}, +journal = {arXiv preprint arXiv:1606.00061v2}, +year = {2016} +} +``` + +### Attention Demo + +![teaser results](https://raw.github.com/jiasenlu/HieCoAttenVQA/master/vis/demo.png) diff --git a/data/cocoqa_preprocess.py b/data/cocoqa_preprocess.py index 677827b..b6593d2 100755 --- a/data/cocoqa_preprocess.py +++ b/data/cocoqa_preprocess.py @@ -128,8 +128,8 @@ def main(params): tp = types[i] test.append({'ques_id': question_id, 'img_path': image_path, 'question': question, 'types': tp,'ans': ans}) - json.dump(train, open('coco_qa_raw_train.json', 'w')) - json.dump(test, open('coco_qa_raw_test.json', 'w')) + json.dump(train, open('cocoqa_raw_train.json', 'w')) + json.dump(test, open('cocoqa_raw_test.json', 'w')) if __name__ == "__main__": diff --git a/data/vqa_preprocess.py b/data/vqa_preprocess.py index 183f8c0..1c4b139 100755 --- a/data/vqa_preprocess.py +++ b/data/vqa_preprocess.py @@ -122,8 +122,8 @@ def main(params): parser = argparse.ArgumentParser() # input json - parser.add_argument('--download', default=0, type=int, help='Download and extract data from VQA server') - parser.add_argument('--split', default=2, type=int, help='1: train on Train and test on Val, 2: train on Train+Val and test on Test') + parser.add_argument('--download', default=1, type=int, help='Download and extract data from VQA server') + parser.add_argument('--split', default=1, type=int, help='1: train on Train and test on Val, 2: train on Train+Val and test on Test') args = parser.parse_args() params = vars(args) diff --git a/eval.lua b/eval.lua new file mode 100644 index 0000000..1e15792 --- /dev/null +++ b/eval.lua @@ -0,0 +1,193 @@ + +require 'nn' +require 'torch' +require 'optim' +require 'misc.DataLoader' +require 'misc.word_level' +require 'misc.phrase_level' +require 'misc.ques_level' +require 'misc.recursive_atten' +require 'misc.optim_updates' +local utils = require 'misc.utils' +require 'xlua' + + +cmd = torch.CmdLine() +cmd:text() +cmd:text('evaluate a Visual Question Answering model') +cmd:text() +cmd:text('Options') + +-- Data input settings +cmd:option('-input_img_train_h5','data/vqa_data_img_vgg_train.h5','path to the h5file containing the image feature') +cmd:option('-input_img_test_h5','data/vqa_data_img_vgg_test.h5','path to the h5file containing the image feature') +cmd:option('-input_ques_h5','data/vqa_data_prepro.h5','path to the h5file containing the preprocessed dataset') +cmd:option('-input_json','data/vqa_data_prepro.json','path to the json file containing additional info and vocab') + +cmd:option('-start_from', 'model/vqa_model/model_alternating_train_vgg.t7', 'path to a model checkpoint to initialize model weights from. Empty = don\'t') +cmd:option('-co_atten_type', 'Alternating', 'co_attention type. Parallel or Alternating, alternating trains more faster than parallel.') +cmd:option('-feature_type', 'VGG', 'VGG or Residual') + +-- misc +cmd:option('-backend', 'cudnn', 'nn|cudnn') +cmd:option('-gpuid', 2, 'which gpu to use. -1 = use CPU') +cmd:option('-seed', 123, 'random number generator seed to use') + +cmd:text() + +local batch_size = 256 + +------------------------------------------------------------------------------- +-- Basic Torch initializations +------------------------------------------------------------------------------- +local opt = cmd:parse(arg) +torch.manualSeed(opt.seed) +print(opt) +torch.setdefaulttensortype('torch.FloatTensor') -- for CPU + +if opt.gpuid >= 0 then + require 'cutorch' + require 'cunn' + if opt.backend == 'cudnn' then + require 'cudnn' + end + cutorch.manualSeed(opt.seed) + --cutorch.setDevice(opt.gpuid+1) -- note +1 because lua is 1-indexed +end + +opt = cmd:parse(arg) + +------------------------------------------------------------------------ +--Design Parameters and Network Definitions +------------------------------------------------------------------------ +local protos = {} +print('Building the model...') +-- intialize language model +local loaded_checkpoint +local lmOpt +if string.len(opt.start_from) > 0 then + + loaded_checkpoint = torch.load(opt.start_from) + lmOpt = loaded_checkpoint.lmOpt +else + lmOpt = {} + lmOpt.vocab_size = loader:getVocabSize() + lmOpt.input_encoding_size = opt.input_encoding_size + lmOpt.rnn_size = opt.rnn_size + lmOpt.num_layers = opt.rnn_layers + lmOpt.dropout = 0.5 + lmOpt.seq_length = loader:getSeqLength() + lmOpt.batch_size = opt.batch_size + lmOpt.output_size = opt.rnn_size + lmOpt.atten_type = opt.co_atten_type + lmOpt.feature_type = opt.feature_type +end +lmOpt.hidden_size = 512 +lmOpt.feature_type = 'VGG' +lmOpt.atten_type = opt.co_atten_type +print(lmOpt) + +protos.word = nn.word_level(lmOpt) +protos.phrase = nn.phrase_level(lmOpt) +protos.ques = nn.ques_level(lmOpt) + +protos.atten = nn.recursive_atten() +protos.crit = nn.CrossEntropyCriterion() + +if opt.gpuid >= 0 then + for k,v in pairs(protos) do v:cuda() end +end + +local wparams, grad_wparams = protos.word:getParameters() +local pparams, grad_pparams = protos.phrase:getParameters() +local qparams, grad_qparams = protos.ques:getParameters() +local aparams, grad_aparams = protos.atten:getParameters() + + +if string.len(opt.start_from) > 0 then + print('Load the weight...') + wparams:copy(loaded_checkpoint.wparams) + pparams:copy(loaded_checkpoint.pparams) + qparams:copy(loaded_checkpoint.qparams) + aparams:copy(loaded_checkpoint.aparams) +end + +print('total number of parameters in word_level: ', wparams:nElement()) +assert(wparams:nElement() == grad_wparams:nElement()) + +print('total number of parameters in phrase_level: ', pparams:nElement()) +assert(pparams:nElement() == grad_pparams:nElement()) + +print('total number of parameters in ques_level: ', qparams:nElement()) +assert(qparams:nElement() == grad_qparams:nElement()) +protos.ques:shareClones() + +print('total number of parameters in recursive_attention: ', aparams:nElement()) +assert(aparams:nElement() == grad_aparams:nElement()) + +------------------------------------------------------------------------------- +-- Create the Data Loader instance +------------------------------------------------------------------------------- + +local loader = DataLoader{h5_img_file_train = opt.input_img_train_h5, h5_img_file_test = opt.input_img_test_h5, h5_ques_file = opt.input_ques_h5, json_file = opt.input_json, feature_type = opt.feature_type} + +collectgarbage() + +function eval_split(split) + + protos.word:evaluate() + protos.phrase:evaluate() + protos.ques:evaluate() + protos.atten:evaluate() + loader:resetIterator(split) + + local n = 0 + local loss_evals = 0 + local predictions = {} + local total_num = loader:getDataNum(2) + print(total_num) + local logprob_all = torch.Tensor(total_num, 1000) + local ques_id = torch.Tensor(total_num) + + for i = 1, total_num, batch_size do + xlua.progress(i, total_num) + local r = math.min(i+batch_size-1, total_num) + + local data = loader:getBatch{batch_size = r-i+1, split = split} + -- ship the data to cuda + if opt.gpuid >= 0 then + data.images = data.images:cuda() + data.questions = data.questions:cuda() + data.ques_len = data.ques_len:cuda() + end + + local word_feat, img_feat, w_ques, w_img, mask = unpack(protos.word:forward({data.questions, data.images})) + + local conv_feat, p_ques, p_img = unpack(protos.phrase:forward({word_feat, data.ques_len, img_feat, mask})) + + local q_ques, q_img = unpack(protos.ques:forward({conv_feat, data.ques_len, img_feat, mask})) + + local feature_ensemble = {w_ques, w_img, p_ques, p_img, q_ques, q_img} + local out_feat = protos.atten:forward(feature_ensemble) + + logprob_all:sub(i, r):copy(out_feat:float()) + ques_id:sub(i, r):copy(data.ques_id) + + end + + + tmp,pred=torch.max(logprob_all,2); + + for i=1,total_num do + local ans = loader.ix_to_ans[tostring(pred[{i,1}])] + table.insert(predictions,{question_id=ques_id[i],answer=ans}) + end + + return {predictions} +end + +predictions = eval_split(2) + +utils.write_json('OpenEnded_mscoco_co-atten_results.json', predictions[1]) + +--utils.write_json('MultipleChoice_mscoco_co-atten_results.json', predictions[2]) diff --git a/misc/DataLoader.lua b/misc/DataLoader.lua new file mode 100644 index 0000000..f4390f7 --- /dev/null +++ b/misc/DataLoader.lua @@ -0,0 +1,161 @@ +require 'hdf5' +local utils = require 'misc.utils' +local DataLoader = torch.class('DataLoader') + +function DataLoader:__init(opt) + + if opt.h5_img_file_train ~= nil then + print('DataLoader loading h5 image file: ', opt.h5_img_file_train) + local h5_file = hdf5.open(opt.h5_img_file_train, 'r') + self.fv_im_train = h5_file:read('/images_train'):all() + h5_file:close() + end + + if opt.h5_img_file_train ~= nil then + print('DataLoader loading h5 image file: ', opt.h5_img_file_test) + local h5_file = hdf5.open(opt.h5_img_file_test, 'r') + self.fv_im_test = h5_file:read('/images_test'):all() + h5_file:close() + end + + print('DataLoader loading h5 question file: ', opt.h5_ques_file) + local h5_file = hdf5.open(opt.h5_ques_file, 'r') + self.ques_train = h5_file:read('/ques_train'):all() + self.ques_len_train = h5_file:read('/ques_len_train'):all() + self.img_pos_train = h5_file:read('/img_pos_train'):all() + self.ques_id_train = h5_file:read('/ques_id_train'):all() + self.answer = h5_file:read('/answers'):all() + self.split_train = h5_file:read('/split_train'):all() + + self.ques_test = h5_file:read('/ques_test'):all() + self.ques_len_test = h5_file:read('/ques_len_test'):all() + self.img_pos_test = h5_file:read('/img_pos_test'):all() + self.ques_id_test = h5_file:read('/ques_id_test'):all() + self.split_test = h5_file:read('/split_test'):all() + self.ans_test = h5_file:read('/ans_test'):all() + + h5_file:close() + print('Transform the image feature...') + + if opt.h5_img_file_train ~= nil then + if opt.feature_type == 'VGG' then + self.fv_im_train = self.fv_im_train:view(-1, 196, 512):contiguous() + elseif opt.feature_type == 'Residual' then + self.fv_im_train = self.fv_im_train:view(-1, 196, 2048):contiguous() + else + error('feature type error') + end + end + + if opt.h5_img_file_test ~= nil then + if opt.feature_type == 'VGG' then + self.fv_im_test = self.fv_im_test:view(-1, 196, 512):contiguous() + elseif opt.feature_type == 'Residual' then + self.fv_im_test = self.fv_im_test:view(-1, 196, 2048):contiguous() + else + error('feature type error') + end + end + + print('DataLoader loading json file: ', opt.json_file) + local json_file = utils.read_json(opt.json_file) + self.ix_to_word = json_file.ix_to_word + self.ix_to_ans = json_file.ix_to_ans + + self.seq_length = self.ques_train:size(2) + + -- count the vocabulary key! + self.vocab_size = utils.count_key(self.ix_to_word) + + -- Let's get the split for train and val and test. + self.split_ix = {} + self.iterators = {} + + for i = 1,self.split_train:size(1) do + local idx = self.split_train[i] + if not self.split_ix[idx] then + self.split_ix[idx] = {} + self.iterators[idx] = 1 + end + table.insert(self.split_ix[idx], i) + end + + for i = 1,self.split_test:size(1) do + local idx = self.split_test[i] + if not self.split_ix[idx] then + self.split_ix[idx] = {} + self.iterators[idx] = 1 + end + table.insert(self.split_ix[idx], i) + end + + for k,v in pairs(self.split_ix) do + print(string.format('assigned %d images to split %s', #v, k)) + end + collectgarbage() -- do it often and there is no harm ;) +end + +function DataLoader:resetIterator(split) + self.iterators[split] = 1 +end + +function DataLoader:getVocabSize() + return self.vocab_size +end + +function DataLoader:getSeqLength() + return self.seq_length +end + +function DataLoader:getDataNum(split) + return #self.split_ix[split] +end + +function DataLoader:getBatch(opt) + local split = utils.getopt(opt, 'split') -- lets require that user passes this in, for safety + local batch_size = utils.getopt(opt, 'batch_size', 128) + + local split_ix = self.split_ix[split] + assert(split_ix, 'split ' .. split .. ' not found.') + + local max_index = #split_ix + local infos = {} + local ques_idx = torch.LongTensor(batch_size):fill(0) + local img_idx = torch.LongTensor(batch_size):fill(0) + + for i=1,batch_size do + local ri = self.iterators[split] -- get next index from iterator + local ri_next = ri + 1 -- increment iterator + if ri_next > max_index then ri_next = 1 end + self.iterators[split] = ri_next + if split == 0 then + ix = split_ix[torch.random(max_index)] + else + ix = split_ix[ri] + end + assert(ix ~= nil, 'bug: split ' .. split .. ' was accessed out of bounds with ' .. ri) + ques_idx[i] = ix + if split == 0 or split == 1 then + img_idx[i] = self.img_pos_train[ix] + else + img_idx[i] = self.img_pos_test[ix] + end + end + + local data = {} + -- fetch the question and image features. + if split == 0 or split == 1 then + data.images = self.fv_im_train:index(1,img_idx) + data.questions = self.ques_train:index(1, ques_idx) + data.ques_id = self.ques_id_train:index(1, ques_idx) + data.ques_len = self.ques_len_train:index(1, ques_idx) + data.answer = self.answer:index(1, ques_idx) + else + data.images = self.fv_im_test:index(1,img_idx) + data.questions = self.ques_test:index(1, ques_idx) + data.ques_id = self.ques_id_test:index(1, ques_idx) + data.ques_len = self.ques_len_test:index(1, ques_idx) + data.answer = self.ans_test:index(1, ques_idx) + end + return data +end diff --git a/misc/DataLoaderDisk.lua b/misc/DataLoaderDisk.lua new file mode 100644 index 0000000..46b1ec1 --- /dev/null +++ b/misc/DataLoaderDisk.lua @@ -0,0 +1,168 @@ +require 'hdf5' +local utils = require 'misc.utils' +local DataLoader = torch.class('DataLoader') + +function DataLoader:__init(opt) + + if opt.h5_img_file_train ~= nil then + print('DataLoader loading h5 image file: ', opt.h5_img_file_train) + self.h5_img_file_train = hdf5.open(opt.h5_img_file_train, 'r') + end + + if opt.h5_img_file_train ~= nil then + print('DataLoader loading h5 image file: ', opt.h5_img_file_test) + self.h5_img_file_test = hdf5.open(opt.h5_img_file_test, 'r') + end + + print('DataLoader loading h5 question file: ', opt.h5_ques_file) + local h5_file = hdf5.open(opt.h5_ques_file, 'r') + self.ques_train = h5_file:read('/ques_train'):all() + self.ques_len_train = h5_file:read('/ques_len_train'):all() + self.img_pos_train = h5_file:read('/img_pos_train'):all() + self.ques_id_train = h5_file:read('/ques_id_train'):all() + self.answer = h5_file:read('/answers'):all() + self.split_train = h5_file:read('/split_train'):all() + + self.ques_test = h5_file:read('/ques_test'):all() + self.ques_len_test = h5_file:read('/ques_len_test'):all() + self.img_pos_test = h5_file:read('/img_pos_test'):all() + self.ques_id_test = h5_file:read('/ques_id_test'):all() + self.split_test = h5_file:read('/split_test'):all() + self.ans_test = h5_file:read('/ans_test'):all() + + h5_file:close() + + print('DataLoader loading json file: ', opt.json_file) + local json_file = utils.read_json(opt.json_file) + self.ix_to_word = json_file.ix_to_word + self.ix_to_ans = json_file.ix_to_ans + self.feature_type = opt.feature_type + self.seq_length = self.ques_train:size(2) + + -- count the vocabulary key! + self.vocab_size = utils.count_key(self.ix_to_word) + + -- Let's get the split for train and val and test. + self.split_ix = {} + self.iterators = {} + + for i = 1,self.split_train:size(1) do + local idx = self.split_train[i] + if not self.split_ix[idx] then + self.split_ix[idx] = {} + self.iterators[idx] = 1 + end + table.insert(self.split_ix[idx], i) + end + + for i = 1,self.split_test:size(1) do + local idx = self.split_test[i] + if not self.split_ix[idx] then + self.split_ix[idx] = {} + self.iterators[idx] = 1 + end + table.insert(self.split_ix[idx], i) + end + + for k,v in pairs(self.split_ix) do + print(string.format('assigned %d images to split %s', #v, k)) + end + collectgarbage() -- do it often and there is no harm ;) +end + +function DataLoader:resetIterator(split) + self.iterators[split] = 1 +end + +function DataLoader:getVocabSize() + return self.vocab_size +end + +function DataLoader:getSeqLength() + return self.seq_length +end + +function DataLoader:getDataNum(split) + return #self.split_ix[split] +end + +function DataLoader:getBatch(opt) + local split = utils.getopt(opt, 'split') -- lets require that user passes this in, for safety + local batch_size = utils.getopt(opt, 'batch_size', 128) + + local split_ix = self.split_ix[split] + assert(split_ix, 'split ' .. split .. ' not found.') + + local max_index = #split_ix + local infos = {} + local ques_idx = torch.LongTensor(batch_size):fill(0) + local img_idx = torch.LongTensor(batch_size):fill(0) + + if self.feature_type == 'VGG' then + self.img_batch = torch.Tensor(batch_size, 14, 14, 512) + elseif self.feature_type == 'Residual' then + self.img_batch = torch.Tensor(batch_size, 14, 14, 2048) + end + + for i=1,batch_size do + local ri = self.iterators[split] -- get next index from iterator + local ri_next = ri + 1 -- increment iterator + if ri_next > max_index then ri_next = 1 end + self.iterators[split] = ri_next + if split == 0 then + ix = split_ix[torch.random(max_index)] + else + ix = split_ix[ri] + end + assert(ix ~= nil, 'bug: split ' .. split .. ' was accessed out of bounds with ' .. ri) + ques_idx[i] = ix + if split == 0 or split == 1 then + img_idx[i] = self.img_pos_train[ix] + if self.h5_img_file_train ~= nil then + if self.feature_type == 'VGG' then + local img = self.h5_img_file_train:read('/images_train'):partial({img_idx[i],img_idx[i]},{1,14}, + {1,14},{1,512}) + self.img_batch[i] = img + elseif self.feature_type == 'Residual' then + local img = self.h5_img_file_train:read('/images_train'):partial({img_idx[i],img_idx[i]},{1,14}, + {1,14},{1,2048}) + self.img_batch[i] = img + else + error('feature type error') + end + end + else + img_idx[i] = self.img_pos_test[ix] + if self.h5_img_file_test ~= nil then + if self.feature_type == 'VGG' then + local img = self.h5_img_file_test:read('/images_test'):partial({img_idx[i],img_idx[i]},{1,14}, + {1,14},{1,512}) + self.img_batch[i] = img + elseif self.feature_type == 'Residual' then + local img = self.h5_img_file_test:read('/images_test'):partial({img_idx[i],img_idx[i]},{1,14}, + {1,14},{1,2048}) + self.img_batch[i] = img + else + error('feature type error') + end + end + end + end + + local data = {} + -- fetch the question and image features. + if split == 0 or split == 1 then + data.images = self.img_batch:view(batch_size, 196, -1):contiguous() + data.questions = self.ques_train:index(1, ques_idx) + data.ques_id = self.ques_id_train:index(1, ques_idx) + data.ques_len = self.ques_len_train:index(1, ques_idx) + data.answer = self.answer:index(1, ques_idx) + else + data.images = self.img_batch:view(batch_size, 196, -1):contiguous() + data.questions = self.ques_test:index(1, ques_idx) + data.ques_id = self.ques_id_test:index(1, ques_idx) + data.ques_len = self.ques_len_test:index(1, ques_idx) + data.answer = self.ans_test:index(1, ques_idx) + end + return data +end diff --git a/misc/DataLoaderRaw.lua b/misc/DataLoaderRaw.lua new file mode 100644 index 0000000..4f7f857 --- /dev/null +++ b/misc/DataLoaderRaw.lua @@ -0,0 +1,163 @@ +-- Load raw image and question. +-- image and question is saved in predict/ folder + +local utils = require 'misc.utils' +local DataLoaderRaw = torch.class('DataLoaderRaw') + +function DataLoader:__init(opt) + + if opt.h5_img_file_train ~= nil then + print('DataLoader loading h5 image file: ', opt.h5_img_file_train) + local h5_file = hdf5.open(opt.h5_img_file_train, 'r') + self.fv_im_train = h5_file:read('/images_train'):all() + h5_file:close() + end + + if opt.h5_img_file_train ~= nil then + print('DataLoader loading h5 image file: ', opt.h5_img_file_test) + local h5_file = hdf5.open(opt.h5_img_file_test, 'r') + self.fv_im_test = h5_file:read('/images_test'):all() + h5_file:close() + end + + print('DataLoader loading h5 question file: ', opt.h5_ques_file) + local h5_file = hdf5.open(opt.h5_ques_file, 'r') + self.ques_train = h5_file:read('/ques_train'):all() + self.ques_len_train = h5_file:read('/ques_len_train'):all() + self.img_pos_train = h5_file:read('/img_pos_train'):all() + self.ques_id_train = h5_file:read('/ques_id_train'):all() + self.answer = h5_file:read('/answers'):all() + self.split_train = h5_file:read('/split_train'):all() + + self.ques_test = h5_file:read('/ques_test'):all() + self.ques_len_test = h5_file:read('/ques_len_test'):all() + self.img_pos_test = h5_file:read('/img_pos_test'):all() + self.ques_id_test = h5_file:read('/ques_id_test'):all() + self.split_test = h5_file:read('/split_test'):all() + self.ans_test = h5_file:read('/ans_test'):all() + + h5_file:close() + print('Transform the image feature...') + + if opt.h5_img_file_train ~= nil then + if opt.feature_type == 'VGG' then + self.fv_im_train = self.fv_im_train:view(-1, 196, 512):contiguous() + elseif opt.feature_type == 'Residual' then + self.fv_im_train = self.fv_im_train:view(-1, 196, 2048):contiguous() + else + error('feature type error') + end + end + + if opt.h5_img_file_test ~= nil then + if opt.feature_type == 'VGG' then + self.fv_im_test = self.fv_im_test:view(-1, 196, 512):contiguous() + elseif opt.feature_type == 'Residual' then + self.fv_im_test = self.fv_im_test:view(-1, 196, 2048):contiguous() + else + error('feature type error') + end + end + + print('DataLoader loading json file: ', opt.json_file) + local json_file = utils.read_json(opt.json_file) + self.ix_to_word = json_file.ix_to_word + self.ix_to_ans = json_file.ix_to_ans + + self.seq_length = self.ques_train:size(2) + + -- count the vocabulary key! + self.vocab_size = utils.count_key(self.ix_to_word) + + -- Let's get the split for train and val and test. + self.split_ix = {} + self.iterators = {} + + for i = 1,self.split_train:size(1) do + local idx = self.split_train[i] + if not self.split_ix[idx] then + self.split_ix[idx] = {} + self.iterators[idx] = 1 + end + table.insert(self.split_ix[idx], i) + end + + for i = 1,self.split_test:size(1) do + local idx = self.split_test[i] + if not self.split_ix[idx] then + self.split_ix[idx] = {} + self.iterators[idx] = 1 + end + table.insert(self.split_ix[idx], i) + end + + for k,v in pairs(self.split_ix) do + print(string.format('assigned %d images to split %s', #v, k)) + end + collectgarbage() -- do it often and there is no harm ;) +end + +function DataLoader:resetIterator(split) + self.iterators[split] = 1 +end + +function DataLoader:getVocabSize() + return self.vocab_size +end + +function DataLoader:getSeqLength() + return self.seq_length +end + +function DataLoader:getDataNum(split) + return #self.split_ix[split] +end + +function DataLoader:getBatch(opt) + local split = utils.getopt(opt, 'split') -- lets require that user passes this in, for safety + local batch_size = utils.getopt(opt, 'batch_size', 128) + + local split_ix = self.split_ix[split] + assert(split_ix, 'split ' .. split .. ' not found.') + + local max_index = #split_ix + local infos = {} + local ques_idx = torch.LongTensor(batch_size):fill(0) + local img_idx = torch.LongTensor(batch_size):fill(0) + + for i=1,batch_size do + local ri = self.iterators[split] -- get next index from iterator + local ri_next = ri + 1 -- increment iterator + if ri_next > max_index then ri_next = 1 end + self.iterators[split] = ri_next + if split == 0 then + ix = split_ix[torch.random(max_index)] + else + ix = split_ix[ri] + end + assert(ix ~= nil, 'bug: split ' .. split .. ' was accessed out of bounds with ' .. ri) + ques_idx[i] = ix + if split == 0 or split == 1 then + img_idx[i] = self.img_pos_train[ix] + else + img_idx[i] = self.img_pos_test[ix] + end + end + + local data = {} + -- fetch the question and image features. + if split == 0 or split == 1 then + data.images = self.fv_im_train:index(1,img_idx) + data.questions = self.ques_train:index(1, ques_idx) + data.ques_id = self.ques_id_train:index(1, ques_idx) + data.ques_len = self.ques_len_train:index(1, ques_idx) + data.answer = self.answer:index(1, ques_idx) + else + data.images = self.fv_im_test:index(1,img_idx) + data.questions = self.ques_test:index(1, ques_idx) + data.ques_id = self.ques_id_test:index(1, ques_idx) + data.ques_len = self.ques_len_test:index(1, ques_idx) + data.answer = self.ans_test:index(1, ques_idx) + end + return data +end diff --git a/misc/LSTM.lua b/misc/LSTM.lua new file mode 100644 index 0000000..bb10040 --- /dev/null +++ b/misc/LSTM.lua @@ -0,0 +1,64 @@ +require 'nn' +require 'nngraph' + +local LSTM = {} +function LSTM.lstm(input_size, rnn_size, n, dropout) + dropout = dropout or 0.5 + + -- there will be 2*n+1 inputs + local inputs = {} + table.insert(inputs, nn.Identity()()) -- indices giving the sequence of symbols + for L = 1,n do + table.insert(inputs, nn.Identity()()) -- prev_c[L] + table.insert(inputs, nn.Identity()()) -- prev_h[L] + end + + local x, input_size_L + local outputs = {} + for L = 1,n do + -- c,h from previos timesteps + local prev_h = inputs[L*2+1] + local prev_c = inputs[L*2] + -- the input to this layer + if L == 1 then + x = inputs[1] + --x = nn.BatchNormalization(input_size)(x) + input_size_L = input_size + else + x = outputs[(L-1)*2] + if dropout > 0 then x = nn.Dropout(dropout)(x):annotate{name='drop_' .. L} end -- apply dropout, if any + input_size_L = rnn_size + end + -- evaluate the input sums at once for efficiency + local i2h = nn.Linear(input_size_L, 4 * rnn_size)(x):annotate{name='i2h_'..L} + local h2h = nn.Linear(rnn_size, 4 * rnn_size)(prev_h):annotate{name='h2h_'..L} + local all_input_sums = nn.CAddTable()({i2h, h2h}) + + local reshaped = nn.Reshape(4, rnn_size)(all_input_sums) + local n1, n2, n3, n4 = nn.SplitTable(2)(reshaped):split(4) + -- decode the gates + local in_gate = nn.Sigmoid()(n1) + local forget_gate = nn.Sigmoid()(n2) + local out_gate = nn.Sigmoid()(n3) + -- decode the write inputs + local in_transform = nn.Tanh()(n4) + -- perform the LSTM update + local next_c = nn.CAddTable()({ + nn.CMulTable()({forget_gate, prev_c}), + nn.CMulTable()({in_gate, in_transform}) + }) + -- gated cells form the output + local next_h = nn.CMulTable()({out_gate, nn.Tanh()(next_c)}) + + table.insert(outputs, next_c) + table.insert(outputs, next_h) + end + -- set up the decoder + local top_h = nn.Identity()(outputs[#outputs]) + if dropout > 0 then top_h = nn.Dropout(dropout)(top_h):annotate{name='drop_final'} end + table.insert(outputs, top_h) + + return nn.gModule(inputs, outputs) +end + +return LSTM \ No newline at end of file diff --git a/misc/LanguageEmbedding.lua b/misc/LanguageEmbedding.lua new file mode 100644 index 0000000..9e382dc --- /dev/null +++ b/misc/LanguageEmbedding.lua @@ -0,0 +1,79 @@ +-- +require 'nn' +require 'nngraph' +require 'rnn' +require 'cudnn' + +local LanguageEmbedding = {} + +function LanguageEmbedding.LE(vocab_size, embedding_size, conv_size, seq_length) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + + local seq = inputs[1] + + local embed = nn.Dropout(0.5)(nn.Tanh()(nn.LookupTableMaskZero(vocab_size, embedding_size)(seq))) + + table.insert(outputs, embed) + + return nn.gModule(inputs, outputs) +end + + +function LanguageEmbedding.conv(conv_size,embedding_size, seq_length) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + + local embed = inputs[1] + + local unigram = cudnn.TemporalConvolution(embedding_size, conv_size, 1, 1, 0)(embed) + local bigram = cudnn.TemporalConvolution(embedding_size, conv_size, 2, 1, 1)(embed) + local trigram = cudnn.TemporalConvolution(embedding_size,conv_size,3, 1, 1)(embed) + + local bigram = nn.Narrow(2,1,seq_length)(bigram) + + local unigram_dim = nn.View(-1, seq_length, conv_size, 1)(unigram) + local bigram_dim = nn.View(-1, seq_length, conv_size, 1)(bigram) + local trigram_dim = nn.View(-1, seq_length, conv_size, 1)(trigram) + + local feat = nn.JoinTable(4)({unigram_dim, bigram_dim, trigram_dim}) + local max_feat = nn.Dropout(0.5)(nn.Tanh()(nn.Max(3, 3)(feat))) + + table.insert(outputs, max_feat) + + return nn.gModule(inputs, outputs) +end +--[[ +function LanguageEmbedding.conv(conv_size,embedding_size, seq_length) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + + local embed = inputs[1] + + local unigram = nn.TemporalConvolution(embedding_size, conv_size, 1)(embed) + local bigram = nn.TemporalConvolution(embedding_size, conv_size, 2)(embed) + local trigram = nn.TemporalConvolution(embedding_size,conv_size,3)(embed) + + local bigram_pad = nn.Padding(1,-1,2,0)(bigram) + local trigram_pad = nn.Padding(1,1,2,0)(trigram) + local trigram_pad = nn.Padding(1,-1,2,0)(trigram_pad) + + local unigram_dim = nn.View(seq_length, conv_size, 1):setNumInputDims(3)(unigram) + local bigram_dim = nn.View(seq_length, conv_size, 1):setNumInputDims(3)(bigram_pad) + local trigram_dim = nn.View(seq_length, conv_size, 1):setNumInputDims(3)(trigram_pads) + + local feat = nn.JoinTable(4)({unigram_dim, bigram_dim, trigram_dim}) + local max_feat = nn.Dropout(0.5)(nn.Max(3, 3)(feat)) + + table.insert(outputs, max_feat) + + return nn.gModule(inputs, outputs) +end +]]-- +return LanguageEmbedding diff --git a/misc/attention.lua b/misc/attention.lua new file mode 100644 index 0000000..4a63758 --- /dev/null +++ b/misc/attention.lua @@ -0,0 +1,170 @@ +require 'nngraph' +require 'nn' +require 'misc.maskSoftmax' +local attention = {} +function attention.parallel_atten(input_size_ques, input_size_img, embedding_size, ques_seq_size, img_seq_size) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local ques_feat = inputs[1] + local img_feat = inputs[2] + local mask = inputs[3] + + + local img_corr_dim = nn.Linear(input_size_img, input_size_ques)(nn.View(input_size_img):setNumInputDims(2)(img_feat)) + local img_corr = nn.View(img_seq_size, embedding_size):setNumInputDims(2)(img_corr_dim) + + local weight_matrix = nn.Tanh()(nn.MM(false, true)({ques_feat, img_corr})) + + local ques_embed_dim = nn.Linear(input_size_ques, embedding_size)(nn.View(input_size_ques):setNumInputDims(2)(ques_feat)) + local ques_embed = nn.View(ques_seq_size, embedding_size):setNumInputDims(2)(ques_embed_dim) + + local img_embed_dim = nn.Linear(input_size_img, input_size_ques)(nn.View(input_size_img):setNumInputDims(2)(img_feat)) + local img_embed = nn.View(img_seq_size, embedding_size):setNumInputDims(2)(img_embed_dim) + + local transform_img = nn.MM(false, false)({weight_matrix, img_embed}) + local ques_atten_sum = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({transform_img, ques_embed}))) + local ques_atten_embedding = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(ques_atten_sum)) + local ques_atten = nn.maskSoftMax()({nn.View(ques_seq_size):setNumInputDims(2)(ques_atten_embedding),mask}) + + local transform_ques = nn.MM(true, false)({weight_matrix, ques_embed}) + local img_atten_sum = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({transform_ques, img_embed}))) + local img_atten_embedding = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(img_atten_sum)) + local img_atten = nn.SoftMax()(nn.View(img_seq_size):setNumInputDims(2)(img_atten_embedding)) + + local ques_atten_dim = nn.View(1,-1):setNumInputDims(1)(ques_atten) + local img_atten_dim = nn.View(1,-1):setNumInputDims(1)(img_atten) + + local ques_atten_feat = nn.MM(false, false)({ques_atten_dim, ques_feat}) + local ques_atten_feat = nn.View(input_size_ques):setNumInputDims(2)(ques_atten_feat) + + local img_atten_feat = nn.MM(false, false)({img_atten_dim, img_feat}) + local img_atten_feat = nn.View(input_size_img):setNumInputDims(2)(img_atten_feat) + + table.insert(outputs, ques_atten_feat) + table.insert(outputs, img_atten_feat) + + return nn.gModule(inputs, outputs) +end + + +function attention.alternating_atten(input_size_ques, input_size_img, embedding_size, ques_seq_size, img_seq_size) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local ques_feat = inputs[1] + local img_feat = inputs[2] + local mask = inputs[3] + + local ques_embed_dim = nn.Linear(input_size_ques, embedding_size)(nn.View(-1, input_size_ques)(ques_feat)) + local ques_embed = nn.View(-1, ques_seq_size, embedding_size)(ques_embed_dim) + + local feat = nn.Dropout(0.5)(nn.Tanh()(ques_embed)) + local h1 = nn.Linear(embedding_size, 1)(nn.View(-1, embedding_size)(feat)) + local P1 = nn.maskSoftMax()({nn.View(-1, ques_seq_size)(h1),mask}) + local ques_atten = nn.View(1,-1):setNumInputDims(1)(P1) + local quesAtt1 = nn.MM(false, false)({ques_atten, ques_feat}) + local ques_atten_feat_1 = nn.View(-1, input_size_ques)(quesAtt1) + + + -- img attention + local ques_embed_img = nn.Linear(input_size_ques, embedding_size)(ques_atten_feat_1) + + local img_embed_dim = nn.Linear(input_size_img, embedding_size)(nn.View(-1, input_size_img)(img_feat)) + + local img_embed = nn.View(-1, img_seq_size, embedding_size)(img_embed_dim) + + local ques_replicate = nn.Replicate(img_seq_size,2)(ques_embed_img) + + local feat = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({img_embed, ques_replicate}))) + local h2 = nn.Linear(embedding_size, 1)(nn.View(-1, embedding_size)(feat)) + local P2 = nn.SoftMax()(nn.View(-1, img_seq_size)(h2)) + local img_atten = nn.View(1,-1):setNumInputDims(1)(P2) + local visAtt = nn.MM(false, false)({img_atten, img_feat}) + local img_atten_feat = nn.View(-1, input_size_img)(visAtt) + + -- question attention + + local img_embed = nn.Linear(input_size_img, embedding_size)(img_atten_feat) + local img_replicate = nn.Replicate(ques_seq_size,2)(img_embed) + + local ques_embed_dim = nn.Linear(input_size_ques, embedding_size)(nn.View(-1, input_size_ques)(ques_feat)) + local ques_embed = nn.View(-1, ques_seq_size, embedding_size)(ques_embed_dim) + + local feat = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({ques_embed, img_replicate}))) + + local h3 = nn.Linear(embedding_size, 1)(nn.View(-1, embedding_size)(feat)) + local P3 = nn.maskSoftMax()({nn.View(-1, ques_seq_size)(h3),mask}) + local probs3dim = nn.View(1,-1):setNumInputDims(1)(P3) + local quesAtt = nn.MM(false, false)({probs3dim, ques_feat}) + local ques_atten_feat = nn.View(-1, 512)(quesAtt) + + -- combine image attention feature and language attention feature + + table.insert(outputs, ques_atten_feat) + table.insert(outputs, img_atten_feat) + + --table.insert(outputs, probs3dim) + ---table.insert(outputs, img_atten) + + return nn.gModule(inputs, outputs) +end + +function attention.fuse(input_size, ques_seq_size) + local inputs = {} + local outputs = {} + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local fore_lstm = inputs[1] + local back_lstm = inputs[2] + + local concat_lstm = nn.JoinTable(2)({fore_lstm, back_lstm}) + + local ques_feat_dim = nn.Linear(input_size*2, input_size)(nn.View(input_size*2):setNumInputDims(2)(concat_lstm)) + local ques_feat = nn.Dropout(0.5)(nn.View(ques_seq_size, input_size):setNumInputDims(2)(ques_feat_dim)) + + table.insert(outputs, ques_feat) + return nn.gModule(inputs, outputs) +end + + +function attention.recursive_atten(input_size, embedding_size, last_embed_size, output_size) + local inputs = {} + local outputs = {} + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local embed_ques = inputs[1] + local embed_img = inputs[2] + local conv_ques = inputs[3] + local conv_img = inputs[4] + local lstm_ques = inputs[5] + local lstm_img = inputs[6] + + local feat1 = nn.Dropout(0.5)(nn.CAddTable()({embed_ques, embed_img})) + local hidden1 = nn.Tanh()(nn.Linear(input_size, embedding_size)(feat1)) + local feat2 = nn.Dropout(0.5)(nn.JoinTable(2)({nn.CAddTable()({conv_ques, conv_img}), hidden1})) + local hidden2 = nn.Tanh()(nn.Linear(embedding_size+input_size, embedding_size)(feat2)) + local feat3 = nn.Dropout(0.5)(nn.JoinTable(2)({nn.CAddTable()({lstm_ques, lstm_img}), hidden2})) + local hidden3 = nn.Tanh()(nn.Linear(embedding_size+input_size, last_embed_size)(feat3)) + local outfeat = nn.Linear(last_embed_size, output_size)(nn.Dropout(0.5)(hidden3)) + + table.insert(outputs, outfeat) + + return nn.gModule(inputs, outputs) +end + +return attention diff --git a/misc/attention_visu.lua b/misc/attention_visu.lua new file mode 100644 index 0000000..b52cc3a --- /dev/null +++ b/misc/attention_visu.lua @@ -0,0 +1,174 @@ +require 'nngraph' +require 'nn' +require 'misc.maskSoftmax' +local attention = {} + +function attention.parallel_atten(input_size_ques, input_size_img, embedding_size, ques_seq_size, img_seq_size) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local ques_feat = inputs[1] + local img_feat = inputs[2] + local mask = inputs[3] + + + local img_corr_dim = nn.Linear(input_size_img, input_size_ques)(nn.View(input_size_img):setNumInputDims(2)(img_feat)) + local img_corr = nn.View(img_seq_size, embedding_size):setNumInputDims(2)(img_corr_dim) + + local weight_matrix = nn.Tanh()(nn.MM(false, true)({ques_feat, img_corr})) + + local ques_embed_dim = nn.Linear(input_size_ques, embedding_size)(nn.View(input_size_ques):setNumInputDims(2)(ques_feat)) + local ques_embed = nn.View(ques_seq_size, embedding_size):setNumInputDims(2)(ques_embed_dim) + + local img_embed_dim = nn.Linear(input_size_img, input_size_ques)(nn.View(input_size_img):setNumInputDims(2)(img_feat)) + local img_embed = nn.View(img_seq_size, embedding_size):setNumInputDims(2)(img_embed_dim) + + local transform_img = nn.MM(false, false)({weight_matrix, img_embed}) + local ques_atten_sum = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({transform_img, ques_embed}))) + local ques_atten_embedding = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(ques_atten_sum)) + local ques_atten = nn.maskSoftMax()({nn.View(ques_seq_size):setNumInputDims(2)(ques_atten_embedding),mask}) + + local transform_ques = nn.MM(true, false)({weight_matrix, ques_embed}) + local img_atten_sum = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({transform_ques, img_embed}))) + local img_atten_embedding = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(img_atten_sum)) + local img_atten = nn.SoftMax()(nn.View(img_seq_size):setNumInputDims(2)(img_atten_embedding)) + + local ques_atten_dim = nn.View(1,-1):setNumInputDims(1)(ques_atten) + local img_atten_dim = nn.View(1,-1):setNumInputDims(1)(img_atten) + + local ques_atten_feat = nn.MM(false, false)({ques_atten_dim, ques_feat}) + local ques_atten_feat = nn.View(input_size_ques):setNumInputDims(2)(ques_atten_feat) + + local img_atten_feat = nn.MM(false, false)({img_atten_dim, img_feat}) + local img_atten_feat = nn.View(input_size_img):setNumInputDims(2)(img_atten_feat) + + table.insert(outputs, ques_atten_feat) + table.insert(outputs, img_atten_feat) + + table.insert(outputs, ques_atten) + table.insert(outputs, img_atten) + + return nn.gModule(inputs, outputs) +end + + +function attention.alternating_atten(input_size_ques, input_size_img, embedding_size, ques_seq_size, img_seq_size) + local inputs = {} + local outputs = {} + + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local ques_feat = inputs[1] + local img_feat = inputs[2] + local mask = inputs[3] + + local ques_embed_dim = nn.Linear(input_size_ques, embedding_size)(nn.View(input_size_ques):setNumInputDims(2)(ques_feat)) + local ques_embed = nn.View(ques_seq_size, embedding_size):setNumInputDims(2)(ques_embed_dim) + + local feat = nn.Dropout(0.5)(nn.Tanh()(ques_embed)) + local h1 = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(feat)) + local P1 = nn.maskSoftMax()({nn.View(ques_seq_size):setNumInputDims(2)(h1),mask}) + local ques_atten = nn.View(1,-1):setNumInputDims(1)(P1) + local quesAtt1 = nn.MM(false, false)({ques_atten, ques_feat}) + local ques_atten_feat_1 = nn.View(input_size_ques):setNumInputDims(2)(quesAtt1) + + + -- img attention + local ques_embed_img = nn.Linear(input_size_ques, embedding_size)(ques_atten_feat_1) + + local img_embed_dim = nn.Linear(input_size_img, embedding_size)(nn.View(input_size_img):setNumInputDims(2)(img_feat)) + + local img_embed = nn.View(img_seq_size, embedding_size):setNumInputDims(2)(img_embed_dim) + + local ques_replicate = nn.Replicate(img_seq_size,2)(ques_embed_img) + + local feat = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({img_embed, ques_replicate}))) + local h2 = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(feat)) + local P2 = nn.SoftMax()(nn.View(img_seq_size):setNumInputDims(2)(h2)) + local img_atten = nn.View(1,-1):setNumInputDims(1)(P2) + local visAtt = nn.MM(false, false)({img_atten, img_feat}) + local img_atten_feat = nn.View(input_size_img):setNumInputDims(2)(visAtt) + + -- question attention + + local img_embed = nn.Linear(input_size_img, embedding_size)(img_atten_feat) + local img_replicate = nn.Replicate(ques_seq_size,2)(img_embed) + + local ques_embed_dim = nn.Linear(input_size_ques, embedding_size)(nn.View(input_size_ques):setNumInputDims(2)(ques_feat)) + local ques_embed = nn.View(ques_seq_size, embedding_size):setNumInputDims(2)(ques_embed_dim) + + local feat = nn.Dropout(0.5)(nn.Tanh()(nn.CAddTable()({ques_embed, img_replicate}))) + + local h3 = nn.Linear(embedding_size, 1)(nn.View(embedding_size):setNumInputDims(2)(feat)) + local P3 = nn.maskSoftMax()({nn.View(ques_seq_size):setNumInputDims(2)(h3),mask}) + local probs3dim = nn.View(1,-1):setNumInputDims(1)(P3) + local quesAtt = nn.MM(false, false)({probs3dim, ques_feat}) + local ques_atten_feat = nn.View(512):setNumInputDims(2)(quesAtt) + + -- combine image attention feature and language attention feature + + table.insert(outputs, ques_atten_feat) + table.insert(outputs, img_atten_feat) + + table.insert(outputs, probs3dim) + table.insert(outputs, img_atten) + + return nn.gModule(inputs, outputs) +end + +function attention.fuse(input_size, ques_seq_size) + local inputs = {} + local outputs = {} + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local fore_lstm = inputs[1] + local back_lstm = inputs[2] + + local concat_lstm = nn.JoinTable(2)({fore_lstm, back_lstm}) + + local ques_feat_dim = nn.Linear(input_size*2, input_size)(nn.View(input_size*2):setNumInputDims(2)(concat_lstm)) + local ques_feat = nn.Dropout(0.5)(nn.View(ques_seq_size, input_size):setNumInputDims(2)(ques_feat_dim)) + + table.insert(outputs, ques_feat) + return nn.gModule(inputs, outputs) +end + + +function attention.recursive_atten(input_size, embedding_size, last_embed_size, output_size) + local inputs = {} + local outputs = {} + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + table.insert(inputs, nn.Identity()()) + + local embed_ques = inputs[1] + local embed_img = inputs[2] + local conv_ques = inputs[3] + local conv_img = inputs[4] + local lstm_ques = inputs[5] + local lstm_img = inputs[6] + + local feat1 = nn.Dropout(0.5)(nn.CAddTable()({embed_ques, embed_img})) + local hidden1 = nn.Tanh()(nn.Linear(input_size, embedding_size)(feat1)) + local feat2 = nn.Dropout(0.5)(nn.JoinTable(2)({nn.CAddTable()({conv_ques, conv_img}), hidden1})) + local hidden2 = nn.Tanh()(nn.Linear(embedding_size+input_size, embedding_size)(feat2)) + local feat3 = nn.Dropout(0.5)(nn.JoinTable(2)({nn.CAddTable()({lstm_ques, lstm_img}), hidden2})) + local hidden3 = nn.Tanh()(nn.Linear(embedding_size+input_size, last_embed_size)(feat3)) + local outfeat = nn.Linear(last_embed_size, output_size)(nn.Dropout(0.5)(hidden3)) + + table.insert(outputs, outfeat) + + return nn.gModule(inputs, outputs) +end + +return attention diff --git a/misc/cnnModel.lua b/misc/cnnModel.lua new file mode 100644 index 0000000..4f39292 --- /dev/null +++ b/misc/cnnModel.lua @@ -0,0 +1,75 @@ +require 'nn' +local utils = require 'misc.utils' +require 'loadcaffe' + +--local LSTM_img = require 'misc.LSTM_img' + +------------------------------------------------------------------------------- +-- Image Model core +------------------------------------------------------------------------------- + +local layer, parent = torch.class('nn.cnnModel', 'nn.Module') +function layer:__init(opt) + parent.__init(self) + + local layer_num = utils.getopt(opt, 'layer_num', 37) + self.input_size = utils.getopt(opt, 'input_size_image') + local dropout = utils.getopt(opt, 'dropout', 0) + self.output_size = utils.getopt(opt, 'output_size') + self.cnn_proto = utils.getopt(opt, 'cnn_proto') + self.cnn_model = utils.getopt(opt, 'cnn_model') + self.backend = utils.getopt(opt, 'backend') + -- option for Image Model + self.h = utils.getopt(opt, 'h') + self.w = utils.getopt(opt, 'w') + assert(self.h==self.w) -- h and w should be same here + self.seq_length = self.h * self.w + print(self.cnn_proto, self.cnn_model, self.backend) + local cnn_raw = loadcaffe.load(self.cnn_proto, self.cnn_model, self.backend) + self.cnn_part = nn.Sequential() + for i = 1, layer_num do + local layer = cnn_raw:get(i) + self.cnn_part:add(layer) + end + self.cnn_part:add(nn.View(-1, 512, 196)) + self.cnn_part:add(nn.Transpose({2,3})) +end + + +function layer:parameters() + local params = {} + local grad_params = {} + + local p2,g2 = self.cnn_part:parameters() + for k,v in pairs(p2) do table.insert(params, v) end + for k,v in pairs(g2) do table.insert(grad_params, v) end + + return params, grad_params +end + +function layer:training() + self.cnn_part:training() + +end + +function layer:evaluate() + self.cnn_part:evaluate() +end + +function layer:updateOutput(input) + local imgs = input + self.output = self.cnn_part:forward(imgs) + + return self.output + +end + +function layer:updateGradInput(input, gradOutput) + local imgs = input + + local dummy = self.cnn_part:backward(imgs, gradOutput) + self.gradInput = {} + return self.gradInput +end + + diff --git a/misc/maskSoftmax.lua b/misc/maskSoftmax.lua new file mode 100644 index 0000000..63da95a --- /dev/null +++ b/misc/maskSoftmax.lua @@ -0,0 +1,30 @@ +local maskSoftMax, _ = torch.class('nn.maskSoftMax', 'nn.Module') + +function maskSoftMax:updateOutput(input) + local data = input[1] + local mask = input[2] + data:maskedFill(mask, -9999999) + + data.THNN.SoftMax_updateOutput( + data:cdata(), + self.output:cdata() + ) + return self.output +end + +function maskSoftMax:updateGradInput(input, gradOutput) + local data = input[1] + local mask = input[2] + data:maskedFill(mask, -9999999) + data.THNN.SoftMax_updateGradInput( + data:cdata(), + gradOutput[1]:cdata(), + self.gradInput:cdata(), + self.output:cdata() + ) + if not self.dummy_out then + self.dummy_out = mask:clone() + end + self.dummy_out:resizeAs(mask):zero() + return {self.gradInput, self.dummy_out} +end \ No newline at end of file diff --git a/misc/optim_updates.lua b/misc/optim_updates.lua new file mode 100644 index 0000000..a116190 --- /dev/null +++ b/misc/optim_updates.lua @@ -0,0 +1,84 @@ + +-- optim, simple as it should be, written from scratch. That's how I roll + +function sgd(x, dx, lr) + x:add(-lr, dx) +end + +function sgdm(x, dx, lr, alpha, state) + -- sgd with momentum, standard update + if not state.v then + state.v = x.new(#x):zero() + end + state.v:mul(alpha) + state.v:add(lr, dx) + x:add(-1, state.v) +end + +function sgdmom(x, dx, lr, alpha, state) + -- sgd momentum, uses nesterov update (reference: http://cs231n.github.io/neural-networks-3/#sgd) + if not state.m then + state.m = x.new(#x):zero() + state.tmp = x.new(#x) + end + state.tmp:copy(state.m) + state.m:mul(alpha):add(-lr, dx) + x:add(-alpha, state.tmp) + x:add(1+alpha, state.m) +end + +function adagrad(x, dx, lr, epsilon, state) + if not state.m then + state.m = x.new(#x):zero() + state.tmp = x.new(#x) + end + -- calculate new mean squared values + state.m:addcmul(1.0, dx, dx) + -- perform update + state.tmp:sqrt(state.m):add(epsilon) + x:addcdiv(-lr, dx, state.tmp) +end + +-- rmsprop implementation, simple as it should be +function rmsprop(x, dx, lr, alpha, epsilon, state) + if not state.m then + state.m = x.new(#x):zero() + state.tmp = x.new(#x) + end + -- calculate new (leaky) mean squared values + state.m:mul(alpha) + state.m:addcmul(1.0-alpha, dx, dx) + -- perform update + state.tmp:sqrt(state.m):add(epsilon) + x:addcdiv(-lr, dx, state.tmp) +end + +function adam(x, dx, lr, beta1, beta2, epsilon, state) + local beta1 = beta1 or 0.9 + local beta2 = beta2 or 0.999 + local epsilon = epsilon or 1e-8 + + if not state.m then + -- Initialization + state.t = 0 + -- Exponential moving average of gradient values + state.m = x.new(#dx):zero() + -- Exponential moving average of squared gradient values + state.v = x.new(#dx):zero() + -- A tmp tensor to hold the sqrt(v) + epsilon + state.tmp = x.new(#dx):zero() + end + + -- Decay the first and second moment running average coefficient + state.m:mul(beta1):add(1-beta1, dx) + state.v:mul(beta2):addcmul(1-beta2, dx, dx) + state.tmp:copy(state.v):sqrt():add(epsilon) + + state.t = state.t + 1 + local biasCorrection1 = 1 - beta1^state.t + local biasCorrection2 = 1 - beta2^state.t + local stepSize = lr * math.sqrt(biasCorrection2)/biasCorrection1 + + -- perform update + x:addcdiv(-stepSize, state.m, state.tmp) +end diff --git a/misc/phrase_level.lua b/misc/phrase_level.lua new file mode 100644 index 0000000..e9634b5 --- /dev/null +++ b/misc/phrase_level.lua @@ -0,0 +1,91 @@ +require 'nn' +local utils = require 'misc.utils' +local LanguageEmbedding = require 'misc.LanguageEmbedding' +local attention = require 'misc.attention' + + +local layer, parent = torch.class('nn.phrase_level', 'nn.Module') +function layer:__init(opt) + parent.__init(self) + self.vocab_size = utils.getopt(opt, 'vocab_size') -- required + self.hidden_size = utils.getopt(opt, 'hidden_size') + local dropout = utils.getopt(opt, 'dropout', 0) + + self.seq_length = utils.getopt(opt, 'seq_length') + self.atten_type = utils.getopt(opt, 'atten_type') + self.feature_type = utils.getopt(opt, 'feature_type') + + self.conv = LanguageEmbedding.conv(self.hidden_size, self.hidden_size, self.seq_length) + + if self.atten_type == 'Alternating' then + self.atten = attention.alternating_atten(self.hidden_size, self.hidden_size, self.hidden_size, self.seq_length, 196) + elseif self.atten_type == 'Parallel' then + self.atten = attention.parallel_atten(self.hidden_size, self.hidden_size, self.hidden_size, self.seq_length, 196) + else + error('Must provide an valid attention type.') + end +end + +function layer:getModulesList() + return {self.conv, self.atten} +end + +function layer:parameters() + -- we only have two internal modules, return their params + local p1,g1 = self.conv:parameters() + local p3,g3 = self.atten:parameters() + + local params = {} + for k,v in pairs(p1) do table.insert(params, v) end + for k,v in pairs(p3) do table.insert(params, v) end + + local grad_params = {} + for k,v in pairs(g1) do table.insert(grad_params, v) end + for k,v in pairs(g3) do table.insert(grad_params, v) end + + return params, grad_params +end + + +function layer:training() + self.atten:training() + self.conv:training() + +end + +function layer:evaluate() + self.atten:evaluate() + self.conv:evaluate() +end + +function layer:updateOutput(input) + local ques = input[1] + local seq_len = input[2] + local img = input[3] + self.mask = input[4] + + self.conv_out = self.conv:forward(ques) + local w_conv_ques, w_conv_img, ques_atten, img_atten = unpack(self.atten:forward({self.conv_out, img, self.mask})) + + return {self.conv_out, w_conv_ques, w_conv_img, ques_atten, img_atten} + +end + +function layer:updateGradInput(input, gradOutput) + local ques = input[1] + local seq_len = input[2] + local img = input[3] + + local batch_size = ques:size(1) + + local d_core_output, d_imgfeat, dummy = unpack(self.atten:backward({self.conv_out, img, self.mask}, {gradOutput[2], gradOutput[3]})) + + d_core_output:add(gradOutput[1]) + + local d_embedding = self.conv:backward(ques, d_core_output) + + self.gradInput = {d_embedding,d_imgfeat} + + + return self.gradInput +end diff --git a/misc/ques_level.lua b/misc/ques_level.lua new file mode 100644 index 0000000..3db9b7f --- /dev/null +++ b/misc/ques_level.lua @@ -0,0 +1,168 @@ +require 'nn' +local utils = require 'misc.utils' +local LSTM = require 'misc.LSTM' +local LanguageEmbedding = require 'misc.LanguageEmbedding' +local attention = require 'misc.attention' +local LanguageEmbedding = require 'misc.LanguageEmbedding' + +local layer, parent = torch.class('nn.ques_level', 'nn.Module') +function layer:__init(opt) + parent.__init(self) + self.rnn_size = utils.getopt(opt, 'rnn_size') + self.num_layers = utils.getopt(opt, 'num_layers', 1) + local dropout = utils.getopt(opt, 'dropout', 0) + self.hidden_size = utils.getopt(opt, 'hidden_size') + self.seq_length = utils.getopt(opt, 'seq_length') + self.atten_type = utils.getopt(opt, 'atten_type') + + self.core = LSTM.lstm(self.rnn_size, self.rnn_size, self.num_layers, dropout) + + if self.atten_type == 'Alternating' then + self.atten = attention.alternating_atten(self.hidden_size, self.hidden_size, self.hidden_size, self.seq_length, 196) + elseif self.atten_type == 'Parallel' then + self.atten = attention.parallel_atten(self.hidden_size, self.hidden_size, self.hidden_size, self.seq_length, 196) + else + error('Must provide an valid attention type.') + end + self:_createInitState(1) + self.mask = torch.Tensor() + self.core_output = torch.Tensor() +end + +function layer:_createInitState(batch_size) + assert(batch_size ~= nil, 'batch size must be provided') + -- construct the initial state for the LSTM + if not self.init_state then self.init_state = {} end -- lazy init + for h=1,self.num_layers*2 do + -- note, the init state Must be zeros because we are using init_state to init grads in backward call too + if self.init_state[h] then + if self.init_state[h]:size(1) ~= batch_size then + self.init_state[h]:resize(batch_size, self.rnn_size):zero() -- expand the memory + end + else + self.init_state[h] = torch.zeros(batch_size, self.rnn_size) + end + end + self.num_state = #self.init_state + end + +function layer:createClones() + print('constructing clones inside the ques_level') + self.cores = {self.core} + for t=1,self.seq_length do + self.cores[t] = self.core:clone('weight', 'bias', 'gradWeight', 'gradBias') + end +end + +function layer:shareClones() + if self.cores == nil then self:createClones(); return; end + print('resharing clones inside the ques_level') + self.cores[1] = self.core + for t=1,self.seq_length do + self.cores[t]:share(self.core, 'weight', 'bias', 'gradWeight', 'gradBias') + end +end + +function layer:getModulesList() + return {self.core, self.atten} +end + +function layer:parameters() + -- we only have two internal modules, return their params + local p1,g1 = self.core:parameters() + local p3,g3 = self.atten:parameters() + + local params = {} + for k,v in pairs(p1) do table.insert(params, v) end + for k,v in pairs(p3) do table.insert(params, v) end + + local grad_params = {} + for k,v in pairs(g1) do table.insert(grad_params, v) end + for k,v in pairs(g3) do table.insert(grad_params, v) end + + return params, grad_params +end + + +function layer:training() + if self.cores == nil then self:createClones() end -- create these lazily if needed + for k,v in pairs(self.cores) do v:training() end + self.atten:training() +end + +function layer:evaluate() + if self.cores == nil then self:createClones() end -- create these lazily if needed + for k,v in pairs(self.cores) do v:evaluate() end + self.atten:evaluate() +end + +function layer:updateOutput(input) + local ques = input[1] + local seq_len = input[2] + local img = input[3] + self.mask = input[4] + + + if self.cores == nil then self:createClones() end -- lazily create clones on first forward pass + local batch_size = ques:size(1) + self.tmax = torch.max(seq_len) + self.tmin = torch.min(seq_len) + + self:_createInitState(batch_size) + self.fore_state = {[0] = self.init_state} + self.fore_inputs = {} + self.core_output:resize(batch_size, self.seq_length, self.rnn_size):zero() + + + for t=1,self.tmax do + self.fore_inputs[t] = {ques:narrow(2,t,1):contiguous():view(-1, self.rnn_size), unpack(self.fore_state[t-1])} + local out = self.cores[t]:forward(self.fore_inputs[t]) + if t > self.tmin then + for i=1,self.num_state+1 do + out[i]:maskedFill(self.mask:narrow(2,t,1):contiguous():view(batch_size,1):expandAs(out[i]), 0) + end + end + self.fore_state[t] = {} -- the rest is state + for i=1,self.num_state do table.insert(self.fore_state[t], out[i]) end + + self.core_output:narrow(2,t,1):copy(out[self.num_state+1]) + end + + local w_lstm_ques, w_lstm_img, ques_atten, img_atten = unpack(self.atten:forward({self.core_output, img, self.mask})) + + return {w_lstm_ques, w_lstm_img, ques_atten, img_atten} +end + +function layer:updateGradInput(input, gradOutput) + local ques = input[1] + local seq_len = input[2] + local img = input[3] + + local batch_size = ques:size(1) + + local d_core_output, d_imgfeat, dummy = unpack(self.atten:backward({self.core_output, img, self.mask}, gradOutput)) + + -- go backwards and lets compute gradients + local d_core_state = {[self.tmax] = self.init_state} -- initial dstates + local d_embed_core = d_embed_core or self.core_output:new() + d_embed_core:resize(batch_size, self.seq_length, self.rnn_size):zero() + + for t=self.tmax,1,-1 do + -- concat state gradients and output vector gradients at time step t + local dout = {} + for k=1,#d_core_state[t] do table.insert(dout, d_core_state[t][k]) end + table.insert(dout, d_core_output:narrow(2,t,1):contiguous():view(-1, self.hidden_size)) + local dinputs = self.cores[t]:backward(self.fore_inputs[t], dout) + + if t > self.tmin then + for k=1,self.num_state+1 do + dinputs[k]:maskedFill(self.mask:narrow(2,t,1):contiguous():view(batch_size,1):expandAs(dinputs[k]), 0) + end + end + d_core_state[t-1] = {} -- copy over rest to state grad + for k=2,self.num_state+1 do table.insert(d_core_state[t-1], dinputs[k]) end + d_embed_core:narrow(2,t,1):copy(dinputs[1]) + end + self.gradInput = {d_embed_core, d_imgfeat} + return self.gradInput +end diff --git a/misc/recursive_atten.lua b/misc/recursive_atten.lua new file mode 100644 index 0000000..42c6cb0 --- /dev/null +++ b/misc/recursive_atten.lua @@ -0,0 +1,44 @@ +require 'nn' +local utils = require 'misc.utils' +local attention = require 'misc.attention' + +local layer, parent = torch.class('nn.recursive_atten', 'nn.Module') +function layer:__init(opt) + parent.__init(self) + + self.atten_encode = attention.recursive_atten(512,512,1024,1000) + + -- self.atten_encode = attention.recursive_atten(512,512,512,1000) -- coco_qa +end + +function layer:getModulesList() + return {self.atten_encode} +end + +function layer:parameters() + local p1,g1 = self.atten_encode:parameters() + local params = {} + for k,v in pairs(p1) do table.insert(params, v) end + local grad_params = {} + for k,v in pairs(g1) do table.insert(grad_params, v) end + + return params, grad_params +end + +function layer:training() + self.atten_encode:training() +end + +function layer:evaluate() + self.atten_encode:evaluate() +end + +function layer:updateOutput(input) + local out_feat = self.atten_encode:forward(input) + return out_feat +end + +function layer:updateGradInput(input, gradOutput) + self.gradInput = self.atten_encode:backward(input, gradOutput) + return self.gradInput +end diff --git a/misc/utils.lua b/misc/utils.lua new file mode 100644 index 0000000..0c8e55d --- /dev/null +++ b/misc/utils.lua @@ -0,0 +1,71 @@ +local cjson = require 'cjson' +local utils = {} +require 'nn' +-- Assume required if default_value is nil +function utils.getopt(opt, key, default_value) + if default_value == nil and (opt == nil or opt[key] == nil) then + error('error: required key ' .. key .. ' was not provided in an opt.') + end + if opt == nil then return default_value end + + local v = opt[key] + if v == nil then v = default_value end + return v +end + +function utils.read_json(path) + local file = io.open(path, 'r') + local text = file:read() + file:close() + local info = cjson.decode(text) + return info +end + +function utils.write_json(path, j) + -- API reference http://www.kyne.com.au/~mark/software/lua-cjson-manual.html#encode + --cjson.encode_sparse_array(true, 2, 10) + local text = cjson.encode(j) + local file = io.open(path, 'w') + file:write(text) + file:close() +end + +function utils.right_align(seq, lengths) + -- right align the questions. + local v=seq:clone():fill(0) + local N=seq:size(2) + for i=1,seq:size(1) do + v[i][{{N-lengths[i]+1,N}}]=seq[i][{{1,lengths[i]}}] + end + return v +end + +function utils.normlize_image(imgFeat) + local length = imgFeat:size(2) + local nm=torch.sqrt(torch.sum(torch.cmul(imgFeat,imgFeat),2)) + return torch.cdiv(imgFeat,torch.repeatTensor(nm,1,length)):float() +end + +function utils.count_key(t) + local count = 1 + for i, w in pairs(t) do + count = count + 1 + end + return count +end + + +function utils.prepro(im, on_gpu) + assert(on_gpu ~= nil, 'pass this in. careful here.') + + im=im*255 + local im2=im:clone() + im2[{{},{3},{},{}}]=im[{{},{1},{},{}}]-123.68 + im2[{{},{2},{},{}}]=im[{{},{2},{},{}}]-116.779 + im2[{{},{1},{},{}}]=im[{{},{3},{},{}}]-103.939 + + return im2 +end + + +return utils \ No newline at end of file diff --git a/misc/word_level.lua b/misc/word_level.lua new file mode 100644 index 0000000..e2f275e --- /dev/null +++ b/misc/word_level.lua @@ -0,0 +1,115 @@ +require 'nn' +local utils = require 'misc.utils' +local LanguageEmbedding = require 'misc.LanguageEmbedding' +local attention = require 'misc.attention' + + +local layer, parent = torch.class('nn.word_level', 'nn.Module') +function layer:__init(opt) + parent.__init(self) + self.vocab_size = utils.getopt(opt, 'vocab_size') -- required + self.hidden_size = utils.getopt(opt, 'hidden_size') + local dropout = utils.getopt(opt, 'dropout', 0) + self.seq_length = utils.getopt(opt, 'seq_length') + self.atten_type = utils.getopt(opt, 'atten_type') + self.feature_type = utils.getopt(opt, 'feature_type') + self.LE = LanguageEmbedding.LE(self.vocab_size, self.hidden_size, self.hidden_size, self.seq_length) + + if self.atten_type == 'Alternating' then + self.atten = attention.alternating_atten(self.hidden_size, self.hidden_size, self.hidden_size, self.seq_length, 196) + elseif self.atten_type == 'Parallel' then + self.atten = attention.parallel_atten(self.hidden_size, self.hidden_size, self.hidden_size, self.seq_length, 196) + else + error('Must provide an valid attention type.') + end + + if self.feature_type == 'VGG' then + self.cnn = nn.Sequential() + :add(nn.View(512):setNumInputDims(2)) + :add(nn.Linear(512, self.hidden_size)) + :add(nn.View(-1, 196, self.hidden_size)) + :add(nn.Tanh()) + :add(nn.Dropout(0.5)) + elseif self.feature_type == 'Residual' then + self.cnn = nn.Sequential() + :add(nn.View(2048):setNumInputDims(2)) + :add(nn.Linear(2048, self.hidden_size)) + :add(nn.View(-1, 196, self.hidden_size)) + :add(nn.Tanh()) + :add(nn.Dropout(0.5)) + end + + self.mask = torch.Tensor() +end + + +function layer:getModulesList() + return {self.LE, self.atten, self.cnn} +end + +function layer:parameters() + local p1,g1 = self.cnn:parameters() + + local p2,g2 = self.LE:parameters() + local p3,g3 = self.atten:parameters() + + local params = {} + for k,v in pairs(p1) do table.insert(params, v) end + for k,v in pairs(p2) do table.insert(params, v) end + for k,v in pairs(p3) do table.insert(params, v) end + + local grad_params = {} + for k,v in pairs(g1) do table.insert(grad_params, v) end + for k,v in pairs(g2) do table.insert(grad_params, v) end + for k,v in pairs(g3) do table.insert(grad_params, v) end + + return params, grad_params +end + +function layer:training() + self.LE:training() + self.atten:training() + self.cnn:training() +end + +function layer:evaluate() + self.atten:evaluate() + self.LE:evaluate() + self.cnn:evaluate() +end + +function layer:updateOutput(input) + local seq = input[1] + local img = input[2] + + local batch_size = seq:size(1) + self.mask:resizeAs(seq):zero() + self.mask[torch.eq(seq, 0)] = 1 + + self.img_feat = self.cnn:forward(img) + + self.embed_output = self.LE:forward(seq) + local w_embed_ques, w_embed_img, ques_atten, img_atten = unpack(self.atten:forward({self.embed_output, self.img_feat, self.mask})) + + return {self.embed_output, self.img_feat, w_embed_ques, w_embed_img, self.mask, ques_atten, img_atten} +end + +function layer:updateGradInput(input, gradOutput) + local seq = input[1] + local img = input[2] + + local batch_size = seq:size(1) + + local d_embed_ques, d_embed_img, dummy = unpack(self.atten:backward({self.embed_output, self.img_feat, self.mask}, {gradOutput[2], gradOutput[3]})) + + d_embed_ques:add(gradOutput[1]) + + local dummy = self.LE:backward(seq, d_embed_ques) + + d_embed_img:add(gradOutput[4]) + d_embed_img:add(gradOutput[5]) + local d_imgfeat = self.cnn:backward(img, d_embed_img) + self.gradInput = d_imgfeat + + return self.gradInput +end diff --git a/predict.ipynb b/predict.ipynb new file mode 100644 index 0000000..6da564d --- /dev/null +++ b/predict.ipynb @@ -0,0 +1,423 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "image_model/VGG_ILSVRC_19_layers_deploy.prototxt\timage_model/VGG_ILSVRC_19_layers.caffemodel\tcudnn\t\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "Successfully loaded image_model/VGG_ILSVRC_19_layers.caffemodel\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv1_1: 64 3 3 3\n", + "conv1_2: 64 64 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv2_1: 128 64 3 3\n", + "conv2_2: 128 128 3 3\n", + "conv3_1: 256 128 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv3_2: 256 256 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv3_3: 256 256 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv3_4: 256 256 3 3\n", + "conv4_1: 512 256 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv4_2: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv4_3: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv4_4: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv5_1: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv5_2: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv5_3: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "conv5_4: 512 512 3 3\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "fc6: 1 1 25088 4096\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "fc7: 1 1 4096 4096\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "fc8: 1 1 4096 1000\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "0.01 *\n", + "-4.1915\n", + "[torch.CudaTensor of size 1]\n", + "\n", + "Load the weight...\t\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + " 0.1113\n", + "[torch.CudaTensor of size 1]\n", + "\n", + "total number of parameters in cnn_model: \t20024384\t\n", + "total number of parameters in word_level: \t8031747\t\n", + "total number of parameters in phrase_level: \t2889219\t\n", + "total number of parameters in ques_level: \t5517315\t\n", + "constructing clones inside the ques_level\t\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "total number of parameters in recursive_attention: \t2862056\t\n" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "require 'nn'\n", + "require 'torch'\n", + "require 'optim'\n", + "require 'misc.DataLoader'\n", + "require 'misc.word_level'\n", + "require 'misc.phrase_level'\n", + "require 'misc.ques_level'\n", + "require 'misc.recursive_atten'\n", + "require 'misc.cnnModel'\n", + "require 'misc.optim_updates'\n", + "utils = require 'misc.utils'\n", + "require 'xlua'\n", + "require 'image'\n", + "\n", + "\n", + "opt = {}\n", + "\n", + "opt.vqa_model = 'model/vqa_model/model_alternating_train_vgg.t7'\n", + "opt.cnn_proto = 'image_model/VGG_ILSVRC_19_layers_deploy.prototxt'\n", + "opt.cnn_model = 'image_model/VGG_ILSVRC_19_layers.caffemodel'\n", + "opt.json_file = 'data/vqa_data_prepro.json'\n", + "opt.backend = 'cudnn'\n", + "opt.gpuid = 1\n", + "if opt.gpuid >= 0 then\n", + " require 'cutorch'\n", + " require 'cunn'\n", + " if opt.backend == 'cudnn' then \n", + " require 'cudnn' \n", + " end\n", + " --cutorch.setDevice(opt.gpuid+1) -- note +1 because lua is 1-indexed\n", + "end\n", + "\n", + "local loaded_checkpoint = torch.load(opt.vqa_model)\n", + "local lmOpt = loaded_checkpoint.lmOpt\n", + "\n", + "lmOpt.hidden_size = 512\n", + "lmOpt.feature_type = 'VGG'\n", + "lmOpt.atten_type = 'Alternating'\n", + "cnnOpt = {}\n", + "cnnOpt.cnn_proto = opt.cnn_proto\n", + "cnnOpt.cnn_model = opt.cnn_model\n", + "cnnOpt.backend = opt.backend\n", + "cnnOpt.input_size_image = 512\n", + "cnnOpt.output_size = 512\n", + "cnnOpt.h = 14\n", + "cnnOpt.w = 14\n", + "cnnOpt.layer_num = 37\n", + "\n", + "-- load the vocabulary and answers.\n", + "\n", + "local json_file = utils.read_json(opt.json_file)\n", + "ix_to_word = json_file.ix_to_word\n", + "ix_to_ans = json_file.ix_to_ans\n", + "\n", + "word_to_ix = {}\n", + "for ix, word in pairs(ix_to_word) do\n", + " word_to_ix[word]=ix\n", + "end\n", + "\n", + "-- load the model\n", + "protos = {}\n", + "protos.word = nn.word_level(lmOpt)\n", + "protos.phrase = nn.phrase_level(lmOpt)\n", + "protos.ques = nn.ques_level(lmOpt)\n", + "\n", + "protos.atten = nn.recursive_atten()\n", + "protos.crit = nn.CrossEntropyCriterion()\n", + "protos.cnn = nn.cnnModel(cnnOpt)\n", + "\n", + "if opt.gpuid >= 0 then\n", + " for k,v in pairs(protos) do v:cuda() end\n", + "end\n", + "\n", + "cparams, grad_cparams = protos.cnn:getParameters()\n", + "wparams, grad_wparams = protos.word:getParameters()\n", + "pparams, grad_pparams = protos.phrase:getParameters()\n", + "qparams, grad_qparams = protos.ques:getParameters()\n", + "aparams, grad_aparams = protos.atten:getParameters()\n", + "\n", + "print(wparams:sub(1,1))\n", + "print('Load the weight...')\n", + "wparams:copy(loaded_checkpoint.wparams)\n", + "pparams:copy(loaded_checkpoint.pparams)\n", + "qparams:copy(loaded_checkpoint.qparams)\n", + "aparams:copy(loaded_checkpoint.aparams)\n", + "print(pparams:sub(1,10))\n", + "\n", + "print('total number of parameters in cnn_model: ', cparams:nElement())\n", + "assert(cparams:nElement() == grad_cparams:nElement())\n", + "\n", + "print('total number of parameters in word_level: ', wparams:nElement())\n", + "assert(wparams:nElement() == grad_wparams:nElement())\n", + "\n", + "print('total number of parameters in phrase_level: ', pparams:nElement())\n", + "assert(pparams:nElement() == grad_pparams:nElement())\n", + "\n", + "print('total number of parameters in ques_level: ', qparams:nElement())\n", + "assert(qparams:nElement() == grad_qparams:nElement())\n", + "protos.ques:shareClones()\n", + "\n", + "print('total number of parameters in recursive_attention: ', aparams:nElement())\n", + "assert(aparams:nElement() == grad_aparams:nElement())" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "[string \"-- specify the image and the question....\"]:46: ')' expected near 'ans'", + "evalue": "", + "output_type": "error", + "traceback": [ + "[string \"-- specify the image and the question....\"]:46: ')' expected near 'ans'" + ] + } + ], + "source": [ + "-- specify the image and the question.\n", + "local img_path = 'visu/demo_img1.jpg'\n", + "local question = 'what is the color of the hat ?'\n", + "\n", + "-- load the image\n", + "local img = image.load(img_path)\n", + "-- scale the image\n", + "img = image.scale(img,448,448)\n", + "itorch.image(img)\n", + "img = img:view(1,img:size(1),img:size(2),img:size(3))\n", + "-- parse and encode the question (in a simple way).\n", + "local ques_encode = torch.IntTensor(26):zero()\n", + "\n", + "local count = 1\n", + "for word in string.gmatch(question, \"%S+\") do\n", + " ques_encode[count] = word_to_ix[word] or word_to_ix['UNK']\n", + " count = count + 1\n", + "end\n", + "ques_encode = ques_encode:view(1,ques_encode:size(1))\n", + "-- doing the prediction\n", + "\n", + "protos.word:evaluate()\n", + "protos.phrase:evaluate()\n", + "protos.ques:evaluate()\n", + "protos.atten:evaluate()\n", + "protos.cnn:evaluate()\n", + "\n", + "local image_raw = utils.prepro(img, false)\n", + "image_raw = image_raw:cuda()\n", + "ques_encode = ques_encode:cuda()\n", + "\n", + "local image_feat = protos.cnn:forward(image_raw)\n", + "local ques_len = torch.Tensor(1,1):cuda()\n", + "ques_len[1] = count-1\n", + "\n", + "local word_feat, img_feat, w_ques, w_img, mask = unpack(protos.word:forward({ques_encode, image_feat}))\n", + "local conv_feat, p_ques, p_img = unpack(protos.phrase:forward({word_feat, ques_len, img_feat, mask}))\n", + "local q_ques, q_img = unpack(protos.ques:forward({conv_feat, ques_len, img_feat, mask}))\n", + "\n", + "local feature_ensemble = {w_ques, w_img, p_ques, p_img, q_ques, q_img}\n", + "local out_feat = protos.atten:forward(feature_ensemble)\n", + "\n", + "local tmp,pred=torch.max(out_feat,2)\n", + "local ans = ix_to_ans[tostring(pred[1][1])]\n", + "\n", + "print('The answer is:' ans)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "-- Attention Visualization\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "iTorch", + "language": "lua", + "name": "itorch" + }, + "language_info": { + "name": "lua", + "version": "5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/prepro/prepro_cocoqa.py b/prepro/prepro_cocoqa.py index 26b8d46..b727b7c 100755 --- a/prepro/prepro_cocoqa.py +++ b/prepro/prepro_cocoqa.py @@ -240,8 +240,8 @@ def main(params): parser = argparse.ArgumentParser() # input json - parser.add_argument('--input_train_json', default='../data/coco_qa_raw_train.json', help='input json file to process into hdf5') - parser.add_argument('--input_test_json', default='../data/coco_qa_raw_test.json', help='input json file to process into hdf5') + parser.add_argument('--input_train_json', default='../data/cocoqa_raw_train.json', help='input json file to process into hdf5') + parser.add_argument('--input_test_json', default='../data/cocoqa_raw_test.json', help='input json file to process into hdf5') parser.add_argument('--output_json', default='../data/cocoqa_data_prepro.json', help='output json file') parser.add_argument('--output_h5', default='../data/cocoqa_data_prepro.h5', help='output h5 file') diff --git a/prepro/prepro_img_residule.lua b/prepro/prepro_img_residule.lua index 2469932..58e05e6 100755 --- a/prepro/prepro_img_residule.lua +++ b/prepro/prepro_img_residule.lua @@ -10,7 +10,7 @@ require 'hdf5' cjson=require('cjson') require 'xlua' require 'cudnn' -local t = require 'misc/transforms' +local t = require 'image_model.transforms' ------------------------------------------------------------------------------- -- Input arguments and options @@ -18,8 +18,8 @@ local t = require 'misc/transforms' cmd = torch.CmdLine() cmd:text() cmd:text('Options') -cmd:option('-input_json','','path to the json file containing vocab and answers') -cmd:option('-image_root','','path to the image root') +cmd:option('-input_json','../data/vqa_data_prepro.json','path to the json file containing vocab and answers') +cmd:option('-image_root','/home/jiasenlu/data/','path to the image root') cmd:option('-residule_path', '') cmd:option('-batch_size', 10, 'batch_size') diff --git a/prepro/prepro_img_vgg.lua b/prepro/prepro_img_vgg.lua index 96c8fe8..e0d9b27 100755 --- a/prepro/prepro_img_vgg.lua +++ b/prepro/prepro_img_vgg.lua @@ -16,17 +16,15 @@ require 'xlua' cmd = torch.CmdLine() cmd:text() cmd:text('Options') -cmd:option('-input_json','data/cocoqa_data_prepro.json','path to the json file containing vocab and answers') +cmd:option('-input_json','../data/vqa_data_prepro.json','path to the json file containing vocab and answers') cmd:option('-image_root','/home/jiasenlu/data/','path to the image root') -cmd:option('-cnn_proto', '/home/jiasenlu/code/vqa_code/vqaSoA/CNN_model/VGG_ILSVRC_19_layers_deploy.prototxt', 'path to the cnn prototxt') -cmd:option('-cnn_model', '/home/jiasenlu/code/vqa_code/vqaSoA/CNN_model/VGG_ILSVRC_19_layers.caffemodel', 'path to the cnn model') ---cmd:option('-cnn_proto', '/home/jiasenlu/code/vqa_code/vqaSoA/CNN_model/ResNet-101-deploy.prototxt', 'path to the cnn prototxt') ---cmd:option('-cnn_model', '/home/jiasenlu/code/vqa_code/vqaSoA/CNN_model/ResNet-101-model.caffemodel', 'path to the cnn model') +cmd:option('-cnn_proto', '../image_model/VGG_ILSVRC_19_layers_deploy.prototxt', 'path to the cnn prototxt') +cmd:option('-cnn_model', '../image_model/VGG_ILSVRC_19_layers.caffemodel', 'path to the cnn model') cmd:option('-batch_size', 20, 'batch_size') -cmd:option('-out_name_train', 'data/cocoqa_data_img_vgg_train.h5', 'output name') -cmd:option('-out_name_test', 'data/cocoqa_data_img_vgg_test.h5', 'output name') +cmd:option('-out_name_train', '../data/vqa_data_img_vgg_train.h5', 'output name train') +cmd:option('-out_name_test', '../data/vqa_data_img_vgg_test.h5', 'output name test') cmd:option('-gpuid', 6, 'which gpu to use. -1 = use CPU') cmd:option('-backend', 'cudnn', 'nn|cudnn') diff --git a/prepro/prepro_vqa.py b/prepro/prepro_vqa.py index 6aeeaae..fec5859 100755 --- a/prepro/prepro_vqa.py +++ b/prepro/prepro_vqa.py @@ -182,8 +182,8 @@ def main(params): imgs_train = json.load(open(params['input_train_json'], 'r')) imgs_test = json.load(open(params['input_test_json'], 'r')) - #imgs_train = imgs_train[:5000] - #imgs_test = imgs_test[:5000] + imgs_train = imgs_train[:5000] + imgs_test = imgs_test[:5000] # get top answers top_ans = get_top_answers(imgs_train, params) atoi = {w:i+1 for i,w in enumerate(top_ans)} @@ -214,7 +214,7 @@ def main(params): # get the answer encoding. ans_train = encode_answer(imgs_train, atoi) - #ans_test = encode_answer(imgs_test, atoi) + ans_test = encode_answer(imgs_test, atoi) MC_ans_test = encode_mc_answer(imgs_test, atoi) # get the split @@ -234,7 +234,7 @@ def main(params): f.create_dataset("ques_test", dtype='uint32', data=ques_test) f.create_dataset("answers", dtype='uint32', data=ans_train) - #f.create_dataset("ans_test", dtype='uint32', data=ans_test) + f.create_dataset("ans_test", dtype='uint32', data=ans_test) f.create_dataset("ques_id_train", dtype='uint32', data=question_id_train) f.create_dataset("ques_id_test", dtype='uint32', data=question_id_test) @@ -277,8 +277,8 @@ def main(params): parser.add_argument('--input_test_json', default='../data/vqa_raw_test.json', help='input json file to process into hdf5') parser.add_argument('--num_ans', default=1000, type=int, help='number of top answers for the final classifications.') - parser.add_argument('--output_json', default='../data_prepro_all.json', help='output json file') - parser.add_argument('--output_h5', default='../data_prepro_all.h5', help='output h5 file') + parser.add_argument('--output_json', default='../data/vqa_data_prepro.json', help='output json file') + parser.add_argument('--output_h5', default='../data/vqa_data_prepro.h5', help='output h5 file') # options parser.add_argument('--max_length', default=26, type=int, help='max length of a caption, in number of words. captions longer than this get clipped.') diff --git a/train.lua b/train.lua new file mode 100644 index 0000000..281de26 --- /dev/null +++ b/train.lua @@ -0,0 +1,362 @@ +------------------------------------------------------------------------------ +-- Hierarchical Question-Image Co-Attention for Visual Question Answering +-- J. Lu, J. Yang, D. Batra, and D. Parikh +-- https://arxiv.org/abs/1606.00061, 2016 +-- if you have any question about the code, please contact jiasenlu@vt.edu +----------------------------------------------------------------------------- + +require 'nn' +require 'torch' +require 'optim' +require 'misc.DataLoaderDisk' +require 'misc.word_level' +require 'misc.phrase_level' +require 'misc.ques_level' +require 'misc.recursive_atten' +require 'misc.optim_updates' +local utils = require 'misc.utils' +require 'xlua' + +------------------------------------------------------------------------------- +-- Input arguments and options +------------------------------------------------------------------------------- + +cmd = torch.CmdLine() +cmd:text() +cmd:text('Train a Visual Question Answering model') +cmd:text() +cmd:text('Options') + +-- Data input settings +cmd:option('-input_img_train_h5','data/vqa_data_img_vgg_train.h5','path to the h5file containing the image feature') +cmd:option('-input_img_test_h5','data/vqa_data_img_vgg_test.h5','path to the h5file containing the image feature') +cmd:option('-input_ques_h5','data/vqa_data_prepro.h5','path to the h5file containing the preprocessed dataset') +cmd:option('-input_json','data/vqa_data_prepro.json','path to the json file containing additional info and vocab') + +cmd:option('-start_from', '', 'path to a model checkpoint to initialize model weights from. Empty = don\'t') +cmd:option('-co_atten_type', 'Alternating', 'co_attention type. Parallel or Alternating, alternating trains more faster than parallel.') +cmd:option('-feature_type', 'VGG', 'VGG or Residual') + + +cmd:option('-hidden_size',512,'the hidden layer size of the model.') +cmd:option('-rnn_size',512,'size of the rnn in number of hidden nodes in each layer') +cmd:option('-batch_size',200,'what is theutils batch size in number of images per batch? (there will be x seq_per_img sentences)') +cmd:option('-output_size', 1000, 'number of output answers') +cmd:option('-rnn_layers',2,'number of the rnn layer') + + +-- Optimization +cmd:option('-optim','rmsprop','what update to use? rmsprop|sgd|sgdmom|adagrad|adam') +cmd:option('-learning_rate',4e-4,'learning rate') +cmd:option('-learning_rate_decay_start', 0, 'at what iteration to start decaying learning rate? (-1 = dont)') +cmd:option('-learning_rate_decay_every', 300, 'every how many epoch thereafter to drop LR by 0.1?') +cmd:option('-optim_alpha',0.99,'alpha for adagrad/rmsprop/momentum/adam') +cmd:option('-optim_beta',0.995,'beta used for adam') +cmd:option('-optim_epsilon',1e-8,'epsilon that goes into denominator in rmsprop') +cmd:option('-max_iters', -1, 'max number of iterations to run for (-1 = run forever)') +cmd:option('-iterPerEpoch', 1200) + +-- Evaluation/Checkpointing +cmd:option('-save_checkpoint_every', 6000, 'how often to save a model checkpoint?') +cmd:option('-checkpoint_path', 'save/train_vgg', 'folder to save checkpoints into (empty = this folder)') + +-- Visualization +cmd:option('-losses_log_every', 600, 'How often do we save losses, for inclusion in the progress dump? (0 = disable)') + +-- misc +cmd:option('-id', '0', 'an id identifying this run/job. used in cross-val and appended when writing progress files') +cmd:option('-backend', 'cudnn', 'nn|cudnn') +cmd:option('-gpuid', 6, 'which gpu to use. -1 = use CPU') +cmd:option('-seed', 123, 'random number generator seed to use') + +cmd:text() + +------------------------------------------------------------------------------- +-- Basic Torch initializations +------------------------------------------------------------------------------- +local opt = cmd:parse(arg) +torch.manualSeed(opt.seed) +print(opt) +torch.setdefaulttensortype('torch.FloatTensor') -- for CPU + +if opt.gpuid >= 0 then + require 'cutorch' + require 'cunn' + if opt.backend == 'cudnn' then + require 'cudnn' + end + --cutorch.manualSeed(opt.seed) + --cutorch.setDevice(opt.gpuid+1) -- note +1 because lua is 1-indexed +end + +opt = cmd:parse(arg) + +------------------------------------------------------------------------------- +-- Create the Data Loader instance +------------------------------------------------------------------------------- +local loader = DataLoader{h5_img_file_train = opt.input_img_train_h5, h5_img_file_test = opt.input_img_test_h5, h5_ques_file = opt.input_ques_h5, json_file = opt.input_json, feature_type = opt.feature_type} +------------------------------------------------------------------------ +--Design Parameters and Network Definitions +------------------------------------------------------------------------ +local protos = {} +print('Building the model...') +-- intialize language model +local loaded_checkpoint +local lmOpt +if string.len(opt.start_from) > 0 then + local start_path = path.join(opt.checkpoint_path .. '_' .. opt.co_atten_type , opt.start_from) + loaded_checkpoint = torch.load(start_path) + lmOpt = loaded_checkpoint.lmOpt +else + lmOpt = {} + lmOpt.vocab_size = loader:getVocabSize() + lmOpt.hidden_size = opt.hidden_size + lmOpt.rnn_size = opt.rnn_size + lmOpt.num_layers = opt.rnn_layers + lmOpt.dropout = 0.5 + lmOpt.seq_length = loader:getSeqLength() + lmOpt.batch_size = opt.batch_size + lmOpt.output_size = opt.rnn_size + lmOpt.atten_type = opt.co_atten_type + lmOpt.feature_type = opt.feature_type +end + +protos.word = nn.word_level(lmOpt) +protos.phrase = nn.phrase_level(lmOpt) +protos.ques = nn.ques_level(lmOpt) + +protos.atten = nn.recursive_atten() +protos.crit = nn.CrossEntropyCriterion() +-- ship everything to GPU, maybe + +if opt.gpuid >= 0 then + for k,v in pairs(protos) do v:cuda() end +end + +local wparams, grad_wparams = protos.word:getParameters() +local pparams, grad_pparams = protos.phrase:getParameters() +local qparams, grad_qparams = protos.ques:getParameters() +local aparams, grad_aparams = protos.atten:getParameters() + + +if string.len(opt.start_from) > 0 then + print('Load the weight...') + wparams:copy(loaded_checkpoint.wparams) + pparams:copy(loaded_checkpoint.pparams) + qparams:copy(loaded_checkpoint.qparams) + aparams:copy(loaded_checkpoint.aparams) +end + +print('total number of parameters in word_level: ', wparams:nElement()) +assert(wparams:nElement() == grad_wparams:nElement()) + +print('total number of parameters in phrase_level: ', pparams:nElement()) +assert(pparams:nElement() == grad_pparams:nElement()) + +print('total number of parameters in ques_level: ', qparams:nElement()) +assert(qparams:nElement() == grad_qparams:nElement()) +protos.ques:shareClones() + +print('total number of parameters in recursive_attention: ', aparams:nElement()) +assert(aparams:nElement() == grad_aparams:nElement()) + +collectgarbage() + +------------------------------------------------------------------------------- +-- Validation evaluation +------------------------------------------------------------------------------- +local function eval_split(split) + + protos.word:evaluate() + protos.phrase:evaluate() + protos.ques:evaluate() + protos.atten:evaluate() + loader:resetIterator(split) + + local n = 0 + local loss_sum = 0 + local loss_evals = 0 + local right_sum = 0 + local predictions = {} + local total_num = loader:getDataNum(split) + while true do + local data = loader:getBatch{batch_size = opt.batch_size, split = split} + -- ship the data to cuda + if opt.gpuid >= 0 then + data.answer = data.answer:cuda() + data.images = data.images:cuda() + data.questions = data.questions:cuda() + data.ques_len = data.ques_len:cuda() + end + n = n + data.images:size(1) + xlua.progress(n, total_num) + + local word_feat, img_feat, w_ques, w_img, mask = unpack(protos.word:forward({data.questions, data.images})) + + local conv_feat, p_ques, p_img = unpack(protos.phrase:forward({word_feat, data.ques_len, img_feat, mask})) + + local q_ques, q_img = unpack(protos.ques:forward({conv_feat, data.ques_len, img_feat, mask})) + + local feature_ensemble = {w_ques, w_img, p_ques, p_img, q_ques, q_img} + local out_feat = protos.atten:forward(feature_ensemble) + + -- forward the language model criterion + local loss = protos.crit:forward(out_feat, data.answer) + + local tmp,pred=torch.max(out_feat,2) + + for i = 1, pred:size()[1] do + + if pred[i][1] == data.answer[i] then + right_sum = right_sum + 1 + end + end + + loss_sum = loss_sum + loss + loss_evals = loss_evals + 1 + if n >= total_num then break end + end + + return loss_sum/loss_evals, right_sum / total_num +end + + +------------------------------------------------------------------------------- +-- Loss function +------------------------------------------------------------------------------- +local iter = 0 +local function lossFun() + protos.word:training() + grad_wparams:zero() + + protos.phrase:training() + grad_pparams:zero() + + protos.ques:training() + grad_qparams:zero() + + protos.atten:training() + grad_aparams:zero() + + ---------------------------------------------------------------------------- + -- Forward pass + ----------------------------------------------------------------------------- + -- get batch of data + local data = loader:getBatch{batch_size = opt.batch_size, split = 0} + if opt.gpuid >= 0 then + data.answer = data.answer:cuda() + data.questions = data.questions:cuda() + data.ques_len = data.ques_len:cuda() + data.images = data.images:cuda() + end + + local word_feat, img_feat, w_ques, w_img, mask = unpack(protos.word:forward({data.questions, data.images})) + + local conv_feat, p_ques, p_img = unpack(protos.phrase:forward({word_feat, data.ques_len, img_feat, mask})) + + local q_ques, q_img = unpack(protos.ques:forward({conv_feat, data.ques_len, img_feat, mask})) + + local feature_ensemble = {w_ques, w_img, p_ques, p_img, q_ques, q_img} + local out_feat = protos.atten:forward(feature_ensemble) + + -- forward the language model criterion + local loss = protos.crit:forward(out_feat, data.answer) + ----------------------------------------------------------------------------- + -- Backward pass + ----------------------------------------------------------------------------- + -- backprop criterion + local dlogprobs = protos.crit:backward(out_feat, data.answer) + + local d_w_ques, d_w_img, d_p_ques, d_p_img, d_q_ques, d_q_img = unpack(protos.atten:backward(feature_ensemble, dlogprobs)) + + local d_ques_feat, d_ques_img = unpack(protos.ques:backward({conv_feat, data.ques_len, img_feat}, {d_q_ques, d_q_img})) + + --local d_ques1 = protos.bl1:backward({ques_feat_0, data.ques_len}, d_ques2) + local d_conv_feat, d_conv_img = unpack(protos.phrase:backward({word_feat, data.ques_len, img_feat}, {d_ques_feat, d_p_ques, d_p_img})) + + local dummy = protos.word:backward({data.questions, data.images}, {d_conv_feat, d_w_ques, d_w_img, d_conv_img, d_ques_img}) + + ----------------------------------------------------------------------------- + -- and lets get out! + local stats = {} + stats.dt = dt + local losses = {} + losses.total_loss = loss + return losses, stats +end + +------------------------------------------------------------------------------- +-- Main loop +------------------------------------------------------------------------------- + +local loss0 +local w_optim_state = {} +local p_optim_state = {} +local q_optim_state = {} +local a_optim_state = {} +local loss_history = {} +local accuracy_history = {} +local learning_rate_history = {} +local best_val_loss = 10000 +local ave_loss = 0 +local timer = torch.Timer() +local decay_factor = math.exp(math.log(0.1)/opt.learning_rate_decay_every/opt.iterPerEpoch) +local learning_rate = opt.learning_rate +-- create the path to save the model. +paths.mkdir(opt.checkpoint_path .. '_' .. opt.co_atten_type) + +while true do + -- eval loss/gradient + local losses, stats = lossFun() + ave_loss = ave_loss + losses.total_loss + -- decay the learning rate + if iter > opt.learning_rate_decay_start and opt.learning_rate_decay_start >= 0 then + learning_rate = learning_rate * decay_factor -- set the decayed rate + end + + if iter % opt.losses_log_every == 0 then + ave_loss = ave_loss / opt.losses_log_every + loss_history[iter] = losses.total_loss + accuracy_history[iter] = ave_loss + learning_rate_history[iter] = learning_rate + + print(string.format('iter %d: %f, %f, %f, %f', iter, losses.total_loss, ave_loss, learning_rate, timer:time().real)) + + ave_loss = 0 + end + + -- save checkpoint once in a while (or on final iteration) + if (iter % opt.save_checkpoint_every == 0 or iter == opt.max_iters) then + local val_loss, val_accu = eval_split(2) + print('validation loss: ', val_loss, 'accuracy ', val_accu) + + local checkpoint_path = path.join(opt.checkpoint_path .. '_' .. opt.co_atten_type, 'model_id' .. opt.id .. '_iter'.. iter) + torch.save(checkpoint_path..'.t7', {wparams=wparams, pparams = pparams, qparams=qparams, aparams=aparams, lmOpt=lmOpt}) + + local checkpoint = {} + checkpoint.opt = opt + checkpoint.iter = iter + checkpoint.loss_history = loss_history + checkpoint.accuracy_history = accuracy_history + checkpoint.learning_rate_history = learning_rate_history + + local checkpoint_path = path.join(opt.checkpoint_path .. '_' .. opt.co_atten_type, 'checkpoint' .. '.json') + + utils.write_json(checkpoint_path, checkpoint) + print('wrote json checkpoint to ' .. checkpoint_path .. '.json') + + end + + -- perform a parameter update + if opt.optim == 'rmsprop' then + rmsprop(wparams, grad_wparams, learning_rate, opt.optim_alpha, opt.optim_epsilon, w_optim_state) + rmsprop(pparams, grad_pparams, learning_rate, opt.optim_alpha, opt.optim_epsilon, p_optim_state) + rmsprop(qparams, grad_qparams, learning_rate, opt.optim_alpha, opt.optim_epsilon, q_optim_state) + rmsprop(aparams, grad_aparams, learning_rate, opt.optim_alpha, opt.optim_epsilon, a_optim_state) + else + error('bad option opt.optim') + end + + iter = iter + 1 + if opt.max_iters > 0 and iter >= opt.max_iters then break end -- stopping criterion +end diff --git a/vis/demo_img1.jpg b/vis/demo_img1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0ce087e9cbf4ba36d6bd0d58f9035def1357d64b GIT binary patch literal 213947 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 literal 0 HcmV?d00001