def separate_lum_chr(gen_img_cvar):
gen_img = gen_img_cvar.data.copy()
if gpu_flag:
gen_img = xp.asnumpy(gen_img)
# roll back to standard arrangement and flip to RGB
gen_img = np.rollaxis(np.squeeze(gen_img, 0), 0, 3)[..., ::-1]
# separate channel
gen_img_lum, gen_img_chr = rgb_to_yiq(gen_img)
gen_img_lum = yiq_to_rgb(gen_img_lum)
gen_img_chr = yiq_to_rgb(gen_img_chr)
# flip to BGR
gen_img_lum = gen_img_lum[..., ::-1]
gen_img_chr = gen_img_chr[..., ::-1]
# convert to Chainer Variables
gen_img_lum = Variable(gen_img_lum)
gen_img_chr = Variable(gen_img_chr)
# transform images into bc01 arrangement
gen_img_lum = F.rollaxis(gen_img_lum, 2, 0)[np.newaxis, ...]
gen_img_chr = F.rollaxis(gen_img_chr, 2, 0)[np.newaxis, ...]
return gen_img_lum, gen_img_chr
def __call__(self, x, s1, s2):
h = F.relu(self.conv1(x))
self.r = self.conv2(h)
q = self.conv3(self.r)
self.v = F.max(q, axis=1, keepdims=True)
for i in xrange(self.k - 1):
q = self.conv3(self.r) + self.conv3b(self.v)
self.v = F.max(q, axis=1, keepdims=True)
q = self.conv3(self.r) + self.conv3b(self.v)
t = s2 * q.data.shape[3] + s1
q = F.reshape(q, (q.data.shape[0], q.data.shape[1], -1))
q = F.rollaxis(q, 2, 1)
t_data_cpu = chainer.cuda.to_cpu(t.data)
w = np.zeros(q.data.shape, dtype=np.float32)
w[six.moves.range(t_data_cpu.size), t_data_cpu] = 1.0
if isinstance(q.data, chainer.cuda.ndarray):
w = chainer.cuda.to_gpu(w)
w = chainer.Variable(w, volatile=not self.train)
q_out = F.sum(w * q, axis=1)
self.ret = self.l3(q_out)
return self.ret
def load_images(content_name, style_name):
# load images as arrays
content_img = sp.misc.imread(content_name, mode='RGB').astype(np.float32)
style_img = sp.misc.imread(style_name, mode='RGB').astype(np.float32)
style_img = sp.misc.imresize(style_img,
size=content_img.shape[0:2],
interp='lanczos').astype(np.float32)
# flip to BGR
content_img = content_img[..., ::-1]
style_img = style_img[..., ::-1]
# convert to Chainer Variables
content_img = Variable(content_img)
style_img = Variable(style_img)
# transform loaded images into bc01 arrangement
content_img = F.rollaxis(content_img, 2, 0)[np.newaxis, ...]
style_img = F.rollaxis(style_img, 2, 0)[np.newaxis, ...]
return content_img, style_img
def mean_subtraction(img_cvar):
mean_pixel = np.array([103.939, 116.779, 123.680]).astype(np.float32)
# roll back to standard arrangement
temp_img = np.rollaxis(np.squeeze(img_cvar.data.copy(), 0), 0, 3)
if gpu_flag:
temp_img = xp.asnumpy(temp_img)
temp_img -= mean_pixel
temp_cvar = Variable(temp_img)
temp_cvar = F.rollaxis(temp_cvar, 2, 0)[np.newaxis, ...]
return temp_cvar
def __call__(self, x):
if self.embed_input:
x = self.embed(x)
x = F.rollaxis(x, 3, 1)
h = self.l0(x)
if self.depth in ['one', 'two', 'three']:
h = F.relu(self.l1(h))
if self.depth in ['two', 'three']:
h = F.max_pooling_2d(h, (1, 2), (1, 2))
h = F.relu(self.l2(h))
h = F.relu(self.l3(h))
if self.depth in ['three']:
h = F.max_pooling_2d(h, (1, 2), (1, 2))
h = F.relu(self.l4(h))
h = F.relu(self.l5(h))
return F.max_pooling_2d(h, (1, self.width))
def histogram_match(cont_img_cvar, sty_img_cvar):
cont_img = cont_img_cvar.data.copy()
sty_img = sty_img_cvar.data.copy()
# roll back to standard arrangement
cont_img = np.rollaxis(np.squeeze(cont_img, 0), 0, 3)
sty_img = np.rollaxis(np.squeeze(sty_img, 0), 0, 3)
# compute row means
cont_mu = np.mean(cont_img, axis=(0, 1))
sty_mu = np.mean(sty_img, axis=(0, 1))
# compute covariance matrix
cont_sigma = np.cov(np.concatenate(cont_img), rowvar=False, bias=True)
sty_sigma = np.cov(np.concatenate(sty_img), rowvar=False, bias=True)
# eigendecomposition for square roots
sty_q, sty_l = sp.linalg.eig(sty_sigma)
sty_q = np.diag(np.sqrt(sty_q))
sty_sigma_sqrtm = sty_l.dot(sty_q).dot(sty_l.T)
sty_sigma_sqrtm_inv = np.linalg.inv(sty_sigma_sqrtm)
cont_sty_cov = sty_sigma_sqrtm.dot(cont_sigma).dot(sty_sigma_sqrtm)
cs_q, cs_l = sp.linalg.eig(cont_sty_cov)
cs_q = np.diag(np.sqrt(cs_q))
cs_sqrtm = cs_l.dot(cs_q).dot(cs_l.T)
# color matching transformation
a = sty_sigma_sqrtm_inv.dot(cs_sqrtm).dot(sty_sigma_sqrtm_inv)
sty_img_col = np.add(np.dot(sty_img - sty_mu, a.T), cont_mu).real
# normalize
sty_img_col = np.ceil(255.0 * normalize(sty_img_col))
# convert to a Chainer Variables
sty_img_cm_cvar = Variable(sty_img_col)
# transform image back to bc01
sty_img_cm_cvar = F.rollaxis(sty_img_cm_cvar, 2, 0)[np.newaxis, ...]
return sty_img_cm_cvar
def forward_cnn(self, h):
# Check and prepare for 2d convolutions
h = F.expand_dims(h, 2)
h = F.swapaxes(h, 1, 2)
# Apply each CNN layer
for i, cnn_layer in enumerate(self.cnns):
# cnn pass
h = self[cnn_layer](h)
# Apply batch normalization
if self.cnn_bn:
bn_lname = '{0:s}_bn'.format(cnn_layer)
h = self[bn_lname](h)
# Apply non-linearity
h = F.relu(h)
"""
Prepare return
batch size * num time frames after pooling * cnn out dim
"""
h = F.swapaxes(h, 1, 2)
h = F.reshape(h, h.shape[:2] + tuple([-1]))
h = F.rollaxis(h, 1)
return h
def f(x):
return functions.rollaxis(x, self.axis, self.start)
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.rollaxis(x, self.axis, self.start)
expect = numpy.rollaxis(self.x, self.axis, self.start)
testing.assert_allclose(y.data, expect)
def check_type_error(self, x):
with self.assertRaises(type_check.InvalidType):
functions.rollaxis(x, self.axis, self.start)
def f(x):
return functions.rollaxis(x, self.axis, self.start)
def test_invalid_start(self):
with self.assertRaises(TypeError):
functions.rollaxis(self.x, 0, start='a')
def get_element(*input, index=0, axis=1):
return [F.rollaxis(i, axis)[index] for i in input]
def f(x):
y = functions.rollaxis(x, self.axis, self.start)
return y * y
def forward(self, inputs, device):
x, = inputs
y = functions.rollaxis(x, self.axis, self.start)
return y,
def forward(self, inputs, device):
x, = inputs
y = functions.rollaxis(x, self.axis, self.start)
return y,
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.rollaxis(x, self.axis, self.start)
expect = numpy.rollaxis(self.x, self.axis, self.start)
testing.assert_allclose(y.data, expect)
def check_type_error(self, x):
with self.assertRaises(type_check.InvalidType):
functions.rollaxis(x, self.axis, self.start)
def __call__(self, x): return functions.rollaxis(x, self.axis, self.start)
def __call__(self, x): return functions.rollaxis(x, self.axis, self.start)
