76 lines
2.8 KiB
Lua
76 lines
2.8 KiB
Lua
local RandomBinaryCriterion, parent = torch.class('w2nn.RandomBinaryCriterion','nn.Criterion')
|
|
|
|
local function create_filters(ch, n, k)
|
|
local filter = w2nn.RandomBinaryConvolution(ch, n, k, k)
|
|
-- channel identify
|
|
for i = 1, ch do
|
|
filter.weight[i]:fill(0)
|
|
filter.weight[i][i][math.floor(k/2)+1][math.floor(k/2)+1] = 1
|
|
end
|
|
return filter
|
|
end
|
|
function RandomBinaryCriterion:__init(ch, n, k)
|
|
parent.__init(self)
|
|
self.gamma = 0.1
|
|
self.n = n or 32
|
|
self.k = k or 3
|
|
self.ch = ch
|
|
self.filter1 = create_filters(self.ch, self.n, self.k)
|
|
self.filter2 = self.filter1:clone()
|
|
self.diff = torch.Tensor()
|
|
self.diff_abs = torch.Tensor()
|
|
self.square_loss_buff = torch.Tensor()
|
|
self.linear_loss_buff = torch.Tensor()
|
|
self.input = torch.Tensor()
|
|
self.target = torch.Tensor()
|
|
end
|
|
function RandomBinaryCriterion:updateOutput(input, target)
|
|
if input:dim() == 2 then
|
|
local k = math.sqrt(input:size(2) / self.ch)
|
|
input = input:reshape(input:size(1), self.ch, k, k)
|
|
end
|
|
if target:dim() == 2 then
|
|
local k = math.sqrt(target:size(2) / self.ch)
|
|
target = target:reshape(target:size(1), self.ch, k, k)
|
|
end
|
|
self.input:resizeAs(input):copy(input):clamp(0, 1)
|
|
self.target:resizeAs(target):copy(target):clamp(0, 1)
|
|
|
|
local lb1 = self.filter1:forward(self.input)
|
|
local lb2 = self.filter2:forward(self.target)
|
|
|
|
-- huber loss
|
|
self.diff:resizeAs(lb1):copy(lb1)
|
|
for i = 1, lb1:size(1) do
|
|
self.diff[i]:add(-1, lb2[i])
|
|
end
|
|
self.diff_abs:resizeAs(self.diff):copy(self.diff):abs()
|
|
|
|
local square_targets = self.diff[torch.lt(self.diff_abs, self.gamma)]
|
|
local linear_targets = self.diff[torch.ge(self.diff_abs, self.gamma)]
|
|
local square_loss = self.square_loss_buff:resizeAs(square_targets):copy(square_targets):pow(2.0):mul(0.5):sum()
|
|
local linear_loss = self.linear_loss_buff:resizeAs(linear_targets):copy(linear_targets):abs():add(-0.5 * self.gamma):mul(self.gamma):sum()
|
|
|
|
--self.outlier_rate = linear_targets:nElement() / input:nElement()
|
|
self.output = (square_loss + linear_loss) / lb1:nElement()
|
|
|
|
return self.output
|
|
end
|
|
|
|
function RandomBinaryCriterion:updateGradInput(input, target)
|
|
local d2 = false
|
|
if input:dim() == 2 then
|
|
d2 = true
|
|
local k = math.sqrt(input:size(2) / self.ch)
|
|
input = input:reshape(input:size(1), self.ch, k, k)
|
|
end
|
|
local norm = self.n / self.input:nElement()
|
|
self.gradInput:resizeAs(self.diff):copy(self.diff):mul(norm)
|
|
local outlier = torch.ge(self.diff_abs, self.gamma)
|
|
self.gradInput[outlier] = torch.sign(self.diff[outlier]) * self.gamma * norm
|
|
local grad_input = self.filter1:updateGradInput(input, self.gradInput)
|
|
if d2 then
|
|
grad_input = grad_input:reshape(grad_input:size(1), grad_input:size(2) * grad_input:size(3) * grad_input:size(4))
|
|
end
|
|
return grad_input
|
|
end
|