Refactoring all the code to simplify things

.gitignore

@@ -0,0 +1,3 @@
+*~
+*.swp
+cachedir/*

BatchProviderBase.lua

@@ -0,0 +1,149 @@
+local argcheck = require 'argcheck'
+
+local function createWindowBase(rec,i,j,is_bg)
+  local label = is_bg == true and 0+1 or rec.label[j]+1
+  local window = {i,rec.boxes[j][1],rec.boxes[j][2],
+                    rec.boxes[j][3],rec.boxes[j][4],
+                    label}
+  return window
+end
+
+local function createWindowAngle(rec,i,j,is_bg)
+  local label = is_bg == true and 0+1 or rec.label[j]+1
+  --local ang = ( is_bg == false and rec.objects[rec.correspondance[j] ] ) and 
+  --                  rec.objects[rec.correspondance[j] ].viewpoint.azimuth or 0
+  local ang
+  if is_bg == false and rec.objects[rec.correspondance[j] ] then
+    if rec.objects[rec.correspondance[j] ].viewpoint.distance == '0' then
+      ang = rec.objects[rec.correspondance[j] ].viewpoint.azimuth_coarse
+    else
+      ang = rec.objects[rec.correspondance[j] ].viewpoint.azimuth
+    end
+  else
+    ang = 0
+  end
+  local window = {i,rec.boxes[j][1],rec.boxes[j][2],
+                    rec.boxes[j][3],rec.boxes[j][4],
+                    label,ang}
+  return window
+end
+
+--[[
+local argcheck = require 'argcheck'
+local initcheck = argcheck{
+  pack=true,
+  noordered=true,
+  {name="dataset",
+   type="nnf.DataSetPascal",
+   help="A dataset class" 
+  },
+  {name="batch_size",
+   type="number",
+   default=128,
+   help="batch size"},
+  {name="fg_fraction",
+   type="number",
+   default=0.25,
+   help="foreground fraction in batch" 
+  },
+  {name="fg_threshold",
+   type="number",
+   default=0.5,
+   help="foreground threshold" 
+  },
+  {name="bg_threshold",
+   type="table",
+   default={0,0.5},
+   help="background threshold, in the form {LO,HI}" 
+  },
+  {name="createWindow",
+   type="function",
+   default=createWindowBase,
+   help="" 
+  },
+  {name="do_flip",
+   type="boolean",
+   default=true,
+   help="sample batches with random flips" 
+  },
+}
+--]]
+
+local BatchProviderBase = torch.class('nnf.BatchProviderBase')
+
+function BatchProviderBase:__init(...)
+
+  self.dataset = nil
+  self.batch_size = 128
+  self.fg_fraction = 0.25
+  self.fg_threshold = 0.5
+  self.bg_threshold = {0,0.5}
+  self.createWindow = createWindowBase
+  self.do_flip = true
+
+  --local opts = initcheck(...)
+  --for k,v in pairs(opts) do self[k] = v end
+
+end
+
+-- allow changing the way self.bboxes are formatted
+function BatchProviderBase:setCreateWindow(createWindow)
+  self.createWindow = createWindow
+end
+
+function BatchProviderBase:setupData()
+  local dataset = self.dataset
+  local bb = {}
+  local bbT = {}
+
+  for i=0,dataset.num_classes do -- 0 because of background
+    bb[i] = {}
+  end
+
+  for i=1,dataset.num_imgs do
+    bbT[i] = {}
+  end
+
+  for i = 1,dataset.num_imgs do
+    if dataset.num_imgs > 10 then
+      xlua.progress(i,dataset.num_imgs)
+    end
+
+    local rec = dataset:attachProposals(i)
+
+    for j=1,rec:size() do    
+      local id = rec.label[j]
+      local is_fg = (rec.overlap[j] >= self.fg_threshold)
+      local is_bg = (not is_fg) and (rec.overlap[j] >= self.bg_threshold[1]  and
+                                     rec.overlap[j] <  self.bg_threshold[2])
+      if is_fg then
+        local window = self.createWindow(rec,i,j,is_bg)
+        table.insert(bb[1], window) -- could be id instead of 1
+      elseif is_bg then
+        local window = self.createWindow(rec,i,j,is_bg)
+        table.insert(bb[0], window)
+      end
+
+    end
+
+    for j=0,dataset.num_classes do -- 0 because of background
+      if #bb[j] > 0 then
+        bbT[i][j] = torch.FloatTensor(bb[j])
+      end
+    end
+
+    bb = {}
+    for i=0,dataset.num_classes do -- 0 because of background
+      bb[i] = {}
+    end
+    collectgarbage()
+  end
+  self.bboxes = bbT
+  --return bbT
+end
+
+function BatchProviderBase:getBatch()
+  error("You can't use BatchProviderBase")
+  return input,target
+end
+

BatchProviderIC.lua

@@ -0,0 +1,164 @@
+local BatchProvider, parent = torch.class('nnf.BatchProviderIC','nnf.BatchProviderBase')
+
+local argcheck = require 'argcheck'
+
+local env = require 'argcheck.env' -- retrieve argcheck environement
+-- this is the default type function
+-- which can be overrided by the user
+function env.istype(obj, typename)
+  if typename == 'DataSet' then
+    return obj and obj._isDataSet
+  end
+  if typename == 'FeatureProvider' then
+    return obj and obj._isFeatureProvider
+  end
+  return torch.type(obj) == typename
+end
+
+
+local initcheck = argcheck{
+  pack=true,
+  noordered=true,
+  {name="dataset",
+   type="DataSet",
+   help="A dataset class" 
+  },
+  {name="feat_provider",
+   type="nnf.FRCNN",
+   help="A feat provider class" 
+  },
+  {name="batch_size",
+   type="number",
+   opt=true,
+   help="batch size"},
+  {name="imgs_per_batch",
+   type="number",
+   default=2,
+   help="number of images to sample in a batch"},
+  {name="fg_fraction",
+   type="number",
+   default=0.25,
+   help="foreground fraction in batch" 
+  },
+  {name="fg_threshold",
+   type="number",
+   default=0.5,
+   help="foreground threshold" 
+  },
+  {name="bg_threshold",
+   type="table",
+   default={0.1,0.5},
+   help="background threshold, in the form {LO,HI}" 
+  },
+  {name="do_flip",
+   type="boolean",
+   default=true,
+   help="sample batches with random flips" 
+  },
+}
+
+function BatchProvider:__init(...)
+  parent.__init(self)
+
+  local opts = initcheck(...)
+  for k,v in pairs(opts) do self[k] = v end
+end
+
+-- setup is the same
+
+function BatchProvider:permuteIdx()
+  local total_img    = self.dataset:size()
+  local imgs_per_batch = self.imgs_per_batch
+
+  self._cur = self._cur or math.huge
+
+  if self._cur + imgs_per_batch > total_img  then
+    self._perm = torch.randperm(total_img)
+    self._cur = 1
+  end
+
+  local img_idx = self._perm[{{self._cur,self._cur + self.imgs_per_batch - 1}}]
+  self._cur     = self._cur + self.imgs_per_batch
+
+  local img_idx_end  = imgs_per_batch
+
+  local fg_windows = {}
+  local bg_windows = {}
+  for i=1,img_idx_end do
+    local curr_idx = img_idx[i]
+    bg_windows[i] = {}
+    if self.bboxes[curr_idx][0] then
+      for j=1,self.bboxes[curr_idx][0]:size(1) do
+        table.insert(bg_windows[i],{curr_idx,j})
+      end
+    end
+    fg_windows[i] = {}
+    if self.bboxes[curr_idx][1] then
+      for j=1,self.bboxes[curr_idx][1]:size(1) do
+        table.insert(fg_windows[i],{curr_idx,j})
+      end
+    end
+  end
+  local do_flip = torch.FloatTensor(imgs_per_batch):random(0,1)
+  local opts = {img_idx=img_idx,img_idx_end=img_idx_end,do_flip=do_flip}
+  return fg_windows,bg_windows,opts
+
+end
+
+function BatchProvider:selectBBoxes(fg_windows,bg_windows)
+  local fg_num_each  = torch.round(self.fg_num_each/self.imgs_per_batch)
+  local bg_num_each  = torch.round(self.bg_num_each/self.imgs_per_batch)
+
+  local bboxes = {}
+  local labels = {}
+  for im=1,self.imgs_per_batch do
+    local window_idx = torch.randperm(#bg_windows[im])
+    local end_idx = math.min(bg_num_each,#bg_windows[im])
+    local bbox = {}
+    for i=1,end_idx do
+      local curr_idx = bg_windows[im][window_idx[i] ][1]
+      local position = bg_windows[im][window_idx[i] ][2]
+      local dd = self.bboxes[curr_idx][0][position][{{2,6}}]
+      table.insert(bbox,{dd[1],dd[2],dd[3],dd[4]})
+      table.insert(labels,dd[5])
+    end
+
+    window_idx = torch.randperm(#fg_windows[im])
+    local end_idx = math.min(fg_num_each,#fg_windows[im])
+    for i=1,end_idx do
+      local curr_idx = fg_windows[im][window_idx[i] ][1]
+      local position = fg_windows[im][window_idx[i] ][2]
+      local dd = self.bboxes[curr_idx][1][position][{{2,6}}]
+      table.insert(bbox,{dd[1],dd[2],dd[3],dd[4]})
+      table.insert(labels,dd[5])
+    end
+    table.insert(bboxes,torch.FloatTensor(bbox))
+  end
+  labels = torch.IntTensor(labels)
+  return bboxes, labels
+end
+
+function BatchProvider:getBatch()
+  local dataset = self.dataset
+
+  self.fg_num_each = self.fg_fraction * self.batch_size
+  self.bg_num_each = self.batch_size - self.fg_num_each
+
+  local fg_windows,bg_windows,opts = self:permuteIdx()
+
+  self.targets = self.targets or torch.FloatTensor()
+
+  local batches = self.batches
+  local targets = self.targets
+
+  local imgs = {}
+  for i=1,opts.img_idx:size(1) do
+    table.insert(imgs,dataset:getImage(opts.img_idx[i]))
+  end
+  local boxes,labels = self:selectBBoxes(fg_windows,bg_windows)
+  self.batches = self.feat_provider:getFeature(imgs,boxes,opts.do_flip)
+
+  targets:resize(labels:size()):copy(labels)
+
+  return self.batches, self.targets
+end