create repository for releasing

Author: Yinda Zhang

.gitignore

@@ -0,0 +1,3 @@
+*.zip
+*.t7
+*.DS*

BatchIterator.lua

@@ -0,0 +1,134 @@
+require 'image'
+require 'utils'
+
+local BatchIterator = torch.class('BatchIterator')
+
+function BatchIterator:__init(config, train_set, test_set)
+
+    self.batch_size = config.batch_size or 128
+    self.pixel_means = config.pixel_means or {0, 0, 0}
+    self.mr = config.mr
+
+    self.train = {}
+    self.test  = {}
+
+    self.train.data = train_set
+    self.test.data  = test_set
+    if #train_set > 0 then
+        self.train.order = torch.randperm(#self.train.data)
+    else
+        self.train.order = torch.Tensor(0);
+    end
+    -- self.test.order  = torch.randperm(#self.test.data)
+    self.test.order = torch.range(1,#self.test.data)
+    self.train.id = 1
+    self.test.id  = 1
+
+    self.epoch = 0
+
+end
+
+function BatchIterator:setBatchSize(batch_size)
+    self.batch_size = batch_size or 128
+end
+
+function BatchIterator:nextEntry(set)
+    local i = self[set].i or 1
+    self[set].i = i
+    if i > #self[set].data then
+        if set == "train" then
+            self[set].order = torch.randperm(#self[set].data)
+        end
+        i = 1
+        self.epoch = self.epoch + 1
+    end
+
+    local index = self[set].order[i]
+    self[set].i = self[set].i + 1
+    return self[set].data[index]
+end
+
+function BatchIterator:currentName(set)
+    local i = self[set].i
+    local index = self[set].order[i-1]
+    return self[set].data[index].name
+end
+
+function BatchIterator:nextBatch(set, config)
+    -- print(use_photo_realistic)
+    -- local use_pr = use_photo_realistic or true
+    -- print(use_photo_realistic)
+
+    local batch = {}
+    batch.input = {}
+    batch.output = {}
+    batch.valid = {}
+
+    for i = 1, self.batch_size do
+        local entry = self:nextEntry(set)      
+
+        if set == "train" then
+
+            while not (file_exists(entry.input_file) and file_exists(entry.input_valid) and file_exists(entry.output_file)) do
+                entry = self:nextEntry(set)
+            end
+
+            local output = image.load(entry.output_file)
+            local valid = image.load(entry.input_valid)
+
+            -- define your data process here
+            output = output:add(-0.5):mul(2)
+            output = output:index(2,torch.range(1,output:size(2),2):long())
+            output = output:index(3,torch.range(1,output:size(3),2):long())
+            valid = valid:index(2,torch.range(1,valid:size(2),2):long())
+            valid = valid:index(3,torch.range(1,valid:size(3),2):long())
+            -- end
+
+            table.insert(batch.output, output)
+            table.insert(batch.valid, valid)
+
+            if config.verbose then
+                print(string.format("output max: %f, min: %f, size: %d %d", output:max(), output:min(), output:size(2), output:size(3)))
+                print(string.format("valid max: %f, min: %f, size: %d %d", valid:max(), valid:min(), valid:size(2), valid:size(3)))
+            end
+        end
+
+
+        local input = image.load(entry.input_file)
+
+        -- process your input here
+        input = input[{{1,3},{},{}}]
+        for ch = 1, 3 do
+            if math.max(unpack(self.pixel_means)) < 1 then
+                input[{ch, {}, {}}]:add(-self.pixel_means[ch])
+            else
+                input[{ch, {}, {}}]:add(-self.pixel_means[ch] / 255)
+            end
+        end
+        input = input:index(2,torch.range(1,input:size(2),2):long())
+        input = input:index(3,torch.range(1,input:size(3),2):long())
+        -- end
+
+        table.insert(batch.input, input)
+        if config.verbose then
+            print(string.format("input max: %f, min: %f, size: %d %d", input:max(), input:min(), input:size(2), input:size(3)))
+        end 
+    end
+
+    -- format img
+    local ch, h, w = batch.input[1]:size(1), batch.input[1]:size(2), batch.input[1]:size(3)
+    batch.input = torch.cat(batch.input, 1):view(self.batch_size, ch, h, w)
+    
+    -- ch, h, w= batch.input[1]:size(1), batch.input[1]:size(2), batch.input[1]:size(3)
+    -- batch.input = torch.cat(batch.input):view(self.batch_size, ch, h, w)
+    -- print(string.format("input size: %d %d %d %d", batch.input:size()))
+
+    if set == "train" then
+        ch, h, w = batch.output[1]:size(1), batch.output[1]:size(2), batch.output[1]:size(3)
+        batch.output = torch.cat(batch.output, 1):view(self.batch_size, ch, h, w)
+        ch, h, w = batch.valid[1]:size(1), batch.valid[1]:size(2), batch.valid[1]:size(3)
+        batch.valid  = torch.cat(batch.valid, 1):view(self.batch_size, ch, h, w)
+    end
+
+    return batch
+end

config.lua

@@ -0,0 +1,68 @@
+require "utils"
+--- All parameters goes here
+local config = config or {}
+
+function config.parse(arg)
+	local cmd = torch.CmdLine()
+	cmd:text()
+	cmd:text('Multi-Task Classification FCN')
+	cmd:text()
+	-- Parameters
+
+    -- model configuration
+    cmd:option('-model', 'model_deep.lua', 'model file')
+    cmd:option('-input_channel', 3, '# of input channels')
+    cmd:option('-output_channel', 3, '# of output channels')
+
+    -- testing
+    cmd:option('-test_model', '', 'model used for testing')
+    cmd:option('-result_path', './result/', 'path to save result')
+    cmd:option('-max_count', 1000000, 'max number of data to test')
+
+    -- data loader
+    cmd:option('-train_file', '', 'train file, compulsory');
+    cmd:option('-test_file',  './image/test_list.txt', 'test file, compulsory');
+	
+    -- training and testing
+    cmd:option('-gpuid', 1, 'gpu id')
+    cmd:option('-optim_state', {rho=0.95, eps=1e-6, learningRate=1e-3, learningRateMin=1e-7, momentum=0.9}, 'optim state')
+    cmd:option('-lr_decay', 150000, 'iterations between lr decreses')
+    cmd:option('-lr_decay_t', 5, 'lr decay times')
+    cmd:option('-nb_epoch', 20, 'number of epoches')
+    cmd:option('-batch_size', 10, 'batch size')
+    cmd:option('-pixel_means', {128, 128, 128}, 'Pixel mean values (RGB order)')
+
+    -- resume
+    cmd:option('-resume_training', false, 'whether resume training')
+    cmd:option('-saved_model_weights', '', 'path to saved model weights')
+    cmd:option('-saved_optim_state', '', 'path to saved model weights')
+
+    -- finetune
+    cmd:option('-finetune', false, '')
+    cmd:option('-finetune_model', '', '')
+    cmd:option('-finetune_init_lr', 1e-4, '')
+
+    -- save/print/log
+	cmd:option('-snapshot_iters', 10000, 'Iterations between snapshots (used for saving the network)')
+	cmd:option('-print_iters', 20, 'Iterations between print')
+	cmd:option('-log_iters', 20, 'Iterations between log')
+	cmd:option('-log_path','./logs/','Path to be used for logging')
+    cmd:option('-ps', '', 'prefix: path&name to model and snapshot')
+    cmd:option('-verbose', false, 'show more message')
+
+	-- Parsing the command line 
+	config = cmd:parse(arg or {})
+    config.colors = {{0, 0, 0}, -- black 
+                     {1, 0, 0}, -- red
+                     {0, 1, 0}, -- green
+                     {0, 0, 1}, -- blue
+                     {1, 1, 0}, -- yellow
+                     {1, 0, 1}, -- magenta
+                     {0, 1, 1}, -- cyan
+                     {1, 1, 1}  -- white
+                    }
+
+    return config
+end
+
+return config

image/0000_color.png

@@ -0,0 +1,5 @@
+./image/0000
+./image/0001
+./image/0008
+./image/0013
+./image/0014

image/0001_color.png

@@ -0,0 +1,81 @@
+require 'nn'
+require 'cutorch'
+require 'cunn'
+require 'cudnn'
+require 'nngraph'
+require 'optim'
+require 'image'
+
+require 'BatchIterator'
+require 'utils'
+-- require 'hdf5'
+
+local config = dofile('config.lua')
+config = config.parse(arg)
+print(config)
+cutorch.setDevice(config.gpuid)
+
+local tmp1 = split(config.test_model, "/")
+config.result_path = config.result_path .. "/" .. string.sub(tmp1[#tmp1],1,-4)
+
+
+config.result_path = config.result_path .. "_nyu_sample_test/"
+
+os.execute("mkdir " .. config.result_path)
+
+-- local model = dofile('model_multi_task.lua')(config.do_normal, config.do_semantic, config.do_boundary, config.do_room)
+local model = dofile(config.model)(config) 
+
+parameters, gradParameters = model:getParameters()
+model:cuda()
+parameters, gradParameters = model:getParameters()
+parameters:copy(torch.load(config.test_model))
+
+-- dataset
+local train_data = {}
+local test_data  = loadData(config.test_file, config)
+local batch_iterator = BatchIterator(config, train_data, test_data)
+batch_iterator:setBatchSize(1)
+
+local test_count = 0
+
+while batch_iterator.epoch==0 and test_count<=config.max_count do
+	local batch = batch_iterator:nextBatch('test', config)
+	local currName = batch_iterator:currentName('test')
+    print(currName)
+	local k = split(currName, "/")
+    if config.matterport then
+	    saveName = k[#k-2] .. "_" .. k[#k]
+    else
+        saveName = k[#k-1] .. "_" .. k[#k]
+    end
+	print(string.format("Testing %s", saveName))
+	
+
+	local inputs = batch.input
+    inputs = inputs:contiguous():cuda()
+    local outputs = model:forward(inputs)
+
+    local ch, h, w = 0, 0, 0
+    local normal_est, normal_mask, normal_gnd, f_normal, df_do_normal, normal_outputs = nil,nil,nil,nil,nil,nil
+
+    normal_est = outputs
+    ch, h, w = normal_est:size(2), normal_est:size(3), normal_est:size(4)
+    normal_est = normal_est:permute(1, 3, 4, 2):contiguous()
+    normal_est = normal_est:view(-1, ch)
+    local normalize_layer = nn.Normalize(2):cuda()
+    normal_outputs = normalize_layer:forward(normal_est)
+	normal_outputs = normal_outputs:view(1, h, w, ch)
+	normal_outputs = normal_outputs:permute(1, 4, 2, 3):contiguous()
+	normal_outputs = normal_outputs:view( ch, h, w)
+	normal_outputs = normal_outputs:float()
+
+	image.save(string.format("%s%s_normal_est.png", config.result_path, saveName), normal_outputs:add(1):mul(0.5))
+
+
+    test_count = test_count + 1
+end
+
+print("Finish!")
+
+