def __call__(self, x, mask):
y = self.fwd(x)
y_9x9 = F.reshape(y, (9, 9))
sum_0 = F.sum(y_9x9, axis=0)
sum_1 = F.sum(y_9x9, axis=1)
prod_0 = F.prod(y_9x9, axis=0)
prod_1 = F.prod(y_9x9, axis=1)
sum_mask_1 = F.square(F.sum(y * self.seg_mask_1) - 45.0)
sum_mask_2 = F.square(F.sum(y * self.seg_mask_2) - 45.0)
sum_mask_3 = F.square(F.sum(y * self.seg_mask_3) - 45.0)
sum_mask_4 = F.square(F.sum(y * self.seg_mask_4) - 45.0)
sum_mask_5 = F.square(F.sum(y * self.seg_mask_5) - 45.0)
sum_mask_6 = F.square(F.sum(y * self.seg_mask_6) - 45.0)
sum_mask_7 = F.square(F.sum(y * self.seg_mask_7) - 45.0)
sum_mask_8 = F.square(F.sum(y * self.seg_mask_8) - 45.0)
sum_mask_9 = F.square(F.sum(y * self.seg_mask_9) - 45.0)
loss = (F.sum(F.sum(F.reshape(F.square((y * mask) - x), (9, 9)), axis=0) +
F.square(sum_0-self.y_sum) +
F.log(F.square(prod_0-self.y_prod) + 1e-8) +
F.square(sum_1-self.y_sum)) +\
sum_mask_1 + sum_mask_2 + sum_mask_3 + sum_mask_4 + sum_mask_5 + sum_mask_6 + sum_mask_7 + sum_mask_8 + sum_mask_9)
#F.log(F.square(prod_0-self.y_prod) + 1e-8) +
#F.log(F.square(prod_1-self.y_prod) + 1e-8))
return loss
def distort_points(coef, x):
"""Apply distortion to given points.
Args:
coef (:class `~chainer.Variable` or :ref:`ndarray`):
Distortion coefficients.
A 2-D array of shape `(B, K)`
K is 4 or 5 or 8. The elements corresponds to
(k1, k2, p1, p2, [k3, [k4, k5 k6]])
respectively.
x (:class `~chainer.Variable` or :ref:`ndarray`):
A 3-D array of shape `(B, 2, N)`
Returns:
~chainer.Variable:
A 3-D array of shape `(B, 2, N)`
"""
xp = backend.get_array_module(x)
_, K = coef.shape
if K < 8:
coef = F.pad(coef, ((0, 0), (0, 8 - K)), 'constant')
coef = coef[:, :, None]
# Compute
# f = (1 + k1r^2 + k2r^4 + k3r^6) / (1 + k4r^2 + k5r^4 + k6r^6)
r2 = F.sum(x * x, 1, keepdims=True) # r^2
f = (1 + r2 * (coef[:, 0:1] + r2 * (coef[:, 1:2] + r2 * coef[:, 4:5]))) / \
(1 + r2 * (coef[:, 5:6] + r2 * (coef[:, 6:7] + r2 * coef[:, 7:8])))
xy = F.prod(x, 1, keepdims=True)
return x * f + 2 * xy * coef[:, 2:4] + coef[:, 3:1:-1] * (r2 + 2 * x * x)
def __call__(self, x, mask):
y = self.fwd(x)
sum_0 = F.sum(y)
prod_0 = F.prod(y)
loss = (F.sum(F.square((y * mask) - x)) + F.square(sum_0 - 45.))
#F.log(F.square(prod_0 - 362880.) + 1e-8))
return loss
def _gau_kl(p_mu, p_ln_var, q_mu, q_ln_var):
"""
Kullback-Liebler divergence from Gaussian p_mu,p_ln_var to Gaussian q_mu,q_ln_var.
Diagonal covariances are assumed. Divergence is expressed in nats.
"""
p_var = F.exp(p_ln_var)
q_var = F.exp(q_ln_var)
# Determinants of diagonal covariances p_var, q_var
dp_var = F.prod(p_var, axis=0)
dq_var = F.prod(q_var, axis=0)
# Inverse of diagonal covariance q_var
iq_var = 1. / q_var
# Difference between means p_mu, q_mu
diff = q_mu - p_mu
return F.sum(0.5 * (
F.log(dq_var / dp_var) # log |\Sigma_q| / |\Sigma_p|
+ F.sum(iq_var * p_var, axis=0) # + tr(\Sigma_q^{-1} * \Sigma_p)
+ F.sum(diff * iq_var * diff,
axis=0) # + (\mu_q-\mu_p)^T\Sigma_q^{-1}(\mu_q-\mu_p)
- len(p_mu))) # - N
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.prod(x, axis=self.axis, keepdims=self.keepdims)
self.assertEqual(y.data.dtype, self.dtype)
y_expect = self.x.prod(axis=self.axis, keepdims=self.keepdims)
if self.dtype == numpy.float16:
options = {'atol': 1e-3, 'rtol': 1e-3}
else:
options = {}
testing.assert_allclose(y_expect, y.data, **options)
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.prod(x, axis=self.axis, keepdims=self.keepdims)
self.assertEqual(y.data.dtype, self.dtype)
y_expect = self.x.prod(axis=self.axis, keepdims=self.keepdims)
if self.dtype == numpy.float16:
options = {'atol': 1e-3, 'rtol': 1e-3}
else:
options = {}
testing.assert_allclose(y_expect, y.data, **options)
def __call__(self, x, mask):
y = self.fwd(x)
sum_0 = F.sum(y)
prod_0 = F.prod(y)
diff_total = Variable(np.array([0.]))
for i in range(8):
for j in range(i + 1, 9):
diff_total += (y.data[0][i] - y.data[0][j])**2
loss = ( #F.sum(F.square((y * mask) - x)) +
#F.square(sum_0 - 45.) +
F.log(F.square(prod_0 - 362880.) + 1e-8))
#F.log(F.square(diff_total - 540.0) + 1e-8))
return loss
def __call__(self, A, B, C, num_sample):
# C -> [batch size, 3, 64, 64]
v = self.encoder(C)
# v -> [batch size, hidden size=128]
param = self.decoder(v)
occupancy = Occupancy_networks(param, A, B,
num_sample) # [batch, num_smaple, 600]
#trans_prob = F.sum(F.softplus(-occupancy), axis=1)
trans_prob = F.prod(occupancy, axis=1) # -> [batch, 600]
# l = 1.7322 / (num_sample-1)
l = 9.0 / (num_sample - 1)
trans_prob = (trans_prob + 1e-8)**l # trans_prob = trans_prob^l
return trans_prob
def f(x):
return functions.prod(x, self.axis, self.keepdims)
def forward(self, inputs, device):
x, = inputs
y = functions.prod(x, axis=self.axis, keepdims=self.keepdims)
return y,
def undistort_points(coef, p, iteration=5):
"""Remove distortion from given points.
Args:
coef (:class `~chainer.Variable` or :ref:`ndarray`):
Distortion coefficients.
A 2-D array of shape `(B, K)`
K is 4 or 5 or 8. The elements corresponds to
(k1, k2, p1, p2, [k3, [k4, k5 k6]])
respectively.
p (:class `~chainer.Variable` or :ref:`ndarray`):
A 3-D array of shape `(B, 2, N)`
Returns:
~chainer.Variable:
A 3-D array of shape `(B, 2, N)`
"""
xp = backend.get_array_module(p)
B, _, N = p.shape
_, K = coef.shape
if K < 8:
coef = F.pad(coef, ((0, 0), (0, 8 - K)), 'constant')
# (B, 8) -> (B, 1, 8)
coef = coef[:, None, :]
k1 = coef[:, :, 0:1]
k2 = coef[:, :, 1:2]
p1 = coef[:, :, 2:3]
p2 = coef[:, :, 3:4]
k3 = coef[:, :, 4:5]
k4 = coef[:, :, 5:6]
k5 = coef[:, :, 6:7]
k6 = coef[:, :, 7:8]
# (B, 2, N) -> (B, N, 2)
p = p.transpose((0, 2, 1))
r2 = F.sum(p * p, 2, keepdims=True) # r^2
# Compute initial guess
X = (1 - r2 * (k1 + r2 * (3 * k1**2 - k2 + r2 *
(8 * k1 * k2 - 12 * k1**3 - k3)))) * p
# Refinement by Newton-Raphson method
for i in range(iteration):
x = X[:, :, 0:1]
y = X[:, :, 1:2]
xy = F.prod(X, 2, keepdims=True)
r2 = F.sum(X * X, 2, keepdims=True) # r^2
a = 1 + r2 * (k1 + r2 * (k2 + r2 * k3))
b = 1 + r2 * (k4 + r2 * (k5 + r2 * k6))
da = k1 + r2 * (2 * k2 + 3 * r2 * k3)
db = k4 + r2 * (2 * k5 + 3 * r2 * k6)
g = a / b
dg = (da * b - a * db) / b**2
J00 = g + 2 * x**2 * dg + 2 * y * p1 + 6 * x * p2
J11 = g + 2 * y**2 * dg + 2 * x * p2 + 6 * y * p1
J01 = 2 * F.prod(x, 2, keepdims=True) * dg + 2 * x * p1 + 2 * y * p2
jacobian = F.stack([J00, J01, J01, J11], axis=2).reshape(B, N, 2, 2)
d = g * X + 2 * xy * coef[:, :, 2:4] + coef[:, :,
3:1:-1] * (r2 + 2 * X * X)
jacobian = jacobian.reshape(-1, 2, 2)
f = (d - p).reshape(-1, 2)
X = X - F.batch_matmul(F.batch_inv(jacobian), f).reshape(B, N, 2)
# (B, N, 2) -> (B, 2, N)
return X.transpose((0, 2, 1))
def test_invalid_axis_type_in_tuple(self):
with self.assertRaises(TypeError):
functions.prod(self.x, axis=(1, 'x'))
def test_invalid_axis_type(self):
with self.assertRaises(TypeError):
functions.prod(self.x, axis=[0])
def f(x):
return functions.prod(x, self.axis, self.keepdims)
def test_invalid_axis_type(self):
with self.assertRaises(TypeError):
functions.prod(self.x, axis=[0])
def test_duplicate_axis(self):
with self.assertRaises(ValueError):
functions.prod(self.x, axis=(0, 0))
def f(x):
x = functions.prod(x, self.axis, self.keepdims)
return x * x
def test_duplicate_axis(self):
with self.assertRaises(ValueError):
functions.prod(self.x, axis=(0, 0))
def test_invalid_axis_type_in_tuple(self):
with self.assertRaises(TypeError):
functions.prod(self.x, axis=(1, 'x'))
def __call__(self, x):
self.chi = F.concat((x, self.r))
(self.nu, self.xi) = F.split_axis(self.l_dl(self.chi), [self.Y], 1)
(self.kr, self.betar, self.kw, self.betaw, self.e, self.v, self.f, self.ga, self.gw, self.pi) = \
F.split_axis(self.xi, self.xi_split_indices, 1)
self.kr = F.reshape(self.kr, (self.R, self.W)) # R * W
self.betar = 1 + F.softplus(self.betar) # 1 * R
# self.kw: 1 * W
self.betaw = 1 + F.softplus(self.betaw) # 1 * 1
self.e = F.sigmoid(self.e) # 1 * W
# self.v : 1 * W
self.f = F.sigmoid(self.f) # 1 * R
self.ga = F.sigmoid(self.ga) # 1 * 1
self.gw = F.sigmoid(self.gw) # 1 * 1
self.pi = F.softmax(F.reshape(self.pi,
(self.R, 3))) # R * 3 (softmax for 3)
# self.wr : N * R
self.psi_mat = 1 - F.broadcast_to(self.f,
(self.N, self.R)) * self.wr # N x R
self.psi = F.prod(self.psi_mat, 1).reshape(self.N, 1) # N x 1
# self.ww, self.u : N * 1
self.u = (self.u + self.ww - (self.u * self.ww)) * self.psi
self.a = u2a(self.u.data) # N * 1
self.cw = C(self.M.data, self.kw.data, self.betaw.data) # N * 1
self.ww = F.matmul(
F.matmul(self.a, self.ga) + F.matmul(self.cw, 1.0 - self.ga),
self.gw) # N * 1
self.M = self.M * (xp.ones(
(self.N, self.W)).astype(xp.float32) - F.matmul(
self.ww, self.e)) + F.matmul(self.ww, self.v) # N * W
if self.K > 0:
self.p = (1.0 - F.matmul(Variable(xp.ones((self.N, 1)).astype(xp.float32)), F.reshape(F.sum(self.ww), (1, 1)))) \
* self.p + self.ww # N * 1
self.p.data = xp.sort(self.p.data, 0)
self.p.data[0:-self.K] = 0.
self.p.data[-self.K:] = self.p.data[-self.K:] / xp.sum(
self.p.data[-self.K:])
self.ww.data = xp.sort(self.ww.data, 0)
self.ww.data[0:-self.K] = 0.
self.ww.data[-self.K:] = self.ww[-self.K:].data / xp.sum(
self.ww.data[-self.K:])
self.wwrep = F.matmul(
self.ww, Variable(xp.ones(
(1, self.N)).astype(xp.float32))) # N * N
self.ww_p_product = xp.zeros((self.N, self.N)).astype(xp.float32)
self.ww_p_product[-self.K:, -self.K:] = F.matmul(
self.ww[-self.K:, -self.K:],
F.transpose(self.p[-self.K:, -self.K:])).data
self.L = (1.0 - self.wwrep - F.transpose(
self.wwrep)) * self.L + self.ww_p_product # N * N
self.L = self.L * (xp.ones(
(self.N, self.N)) - xp.eye(self.N)) # force L[i,i] == 0
self.L.data[self.L.data < 1 / self.K] = 0.
else:
self.p = (1.0 - F.matmul(Variable(xp.ones((self.N, 1)).astype(xp.float32)),
F.reshape(F.sum(self.ww), (1, 1)))) \
* self.p + self.ww # N * 1
self.wwrep = F.matmul(
self.ww, Variable(xp.ones(
(1, self.N)).astype(xp.float32))) # N * N
self.L = (1.0 - self.wwrep -
F.transpose(self.wwrep)) * self.L + F.matmul(
self.ww, F.transpose(self.p)) # N * N
self.L = self.L * (xp.ones(
(self.N, self.N)) - xp.eye(self.N)) # force L[i,i] == 0
self.fo = F.matmul(self.L, self.wr) # N * R
self.ba = F.matmul(F.transpose(self.L), self.wr) # N * R
self.cr = C(self.M.data, self.kr.data, self.betar.data)
self.bacrfo = F.concat((
F.reshape(F.transpose(self.ba), (self.R, self.N, 1)),
F.reshape(F.transpose(self.cr), (self.R, self.N, 1)),
F.reshape(F.transpose(self.fo), (self.R, self.N, 1)),
), 2) # R * N * 3
self.pi = F.reshape(self.pi, (self.R, 3, 1)) # R * 3 * 1
self.wr = F.transpose(
F.reshape(F.batch_matmul(self.bacrfo, self.pi),
(self.R, self.N))) # N * R
self.r = F.reshape(F.matmul(F.transpose(self.M), self.wr),
(1, self.R * self.W)) # W * R (-> 1 * RW)
self.y = self.l_Wr(self.r) + self.nu # 1 * Y
return self.y
def forward(self, inputs, device):
x, = inputs
y = functions.prod(x, axis=self.axis, keepdims=self.keepdims)
return y,
