def transform(self, data, test=False):
#make sure that data has the right shape.
if not type(data) == Variable:
if len(data.shape) < 4:
data = data[np.newaxis]
if len(data.shape) != 4:
raise TypeError("Invalid dimensions for image data. Dim = %s. Must be 4d array." % str(data.shape))
if data.shape[1] != self.color_channels:
if data.shape[-1] == self.color_channels:
data = data.transpose(0, 3, 1, 2)
else:
raise TypeError("Invalid dimensions for image data. Dim = %s"
% str(data.shape))
data = Variable(data)
else:
if len(data.data.shape) < 4:
data.data = data.data[np.newaxis]
if len(data.data.shape) != 4:
raise TypeError("Invalid dimensions for image data. Dim = %s. Must be 4d array." % str(data.data.shape))
if data.data.shape[1] != self.color_channels:
if data.data.shape[-1] == self.color_channels:
data.data = data.data.transpose(0, 3, 1, 2)
else:
raise TypeError("Invalid dimensions for image data. Dim = %s"
% str(data.shape))
# Actual transformation.
if self.flag_gpu:
data.to_gpu()
z = self._encode(data, test=test)[0]
z.to_cpu()
return z.data
def forward_eye_states(self, x_batch_curr, y_batch_curr, volatile):
current_sample = Variable(x_batch_curr, volatile=volatile)
y_batch_curr = np.asarray(y_batch_curr).reshape(32, -1)
current_output = Variable(y_batch_curr, volatile=volatile)
h1_current = F.sigmoid(self.model_to_use.x_h1(current_sample))
h2_current = F.sigmoid(self.model_to_use.h1_h2(h1_current))
h3_current = F.sigmoid(self.model_to_use.h2_h3(h2_current))
h4_current = F.sigmoid(self.model_to_use.h3_h4(h3_current))
h4 = h4_current
y = self.model_to_use.h4_y(h4)
y.data = y.data.reshape(32, -1)
loss = F.sigmoid_cross_entropy(y, current_output)
current_output.data = np.squeeze(current_output.data)
accuracy = F.accuracy(y, current_output)
return accuracy, loss, y
def inverse_transform(self, data, test=False):
if not type(data) == Variable:
if len(data.shape) < 2:
data = data[np.newaxis]
if len(data.shape) != 2:
raise TypeError("Invalid dimensions for latent data. Dim = %s. Must be a 2d array." % str(data.shape))
data = Variable(data)
else:
if len(data.data.shape) < 2:
data.data = data.data[np.newaxis]
if len(data.data.shape) != 2:
raise TypeError("Invalid dimensions for latent data. Dim = %s. Must be a 2d array." % str(data.data.shape))
assert data.data.shape[-1] == self.latent_width, "Latent shape %d != %d" % (data.data.shape[-1], self.latent_width)
if self.flag_gpu:
data.to_gpu()
out = self._decode(data, test=test)
out.to_cpu()
if self.mode == 'linear':
final = out.data
else:
final = out.data.transpose(0, 2, 3, 1)
return final
def update(self, trajs):
obs = np.concatenate([traj['observations'] for traj in trajs], axis=0)
if self.concat_time:
ts = np.concatenate([np.arange(len(traj['observations'])) / self.env_spec.timestep_limit for traj in trajs],
axis=0)
obs = np.concatenate([obs, ts[:, None]], axis=-1)
returns = np.concatenate([traj['returns'] for traj in trajs], axis=0)
baselines = np.concatenate([traj['baselines']
for traj in trajs], axis=0)
# regress to a mixture of current and past predictions
targets = returns * (1. - self.mixture_fraction) + \
baselines * self.mixture_fraction
# use lbfgs to perform the update
cur_params = get_flat_params(self)
obs = Variable(obs)
targets = Variable(targets.astype(np.float32))
def f_loss_grad(x):
set_flat_params(self, x)
self.cleargrads()
values = self.compute_baselines(obs)
loss = F.mean(F.square(values - targets))
loss.backward()
flat_grad = get_flat_grad(self)
return loss.data.astype(np.float64), flat_grad.astype(np.float64)
new_params = scipy.optimize.fmin_l_bfgs_b(
f_loss_grad, cur_params, maxiter=10)[0]
set_flat_params(self, new_params)
def visualize_walkthrough():
x_batch = sample_x_from_data_distribution(20)
z_batch = gen(x_batch, test=True)
if use_gpu:
z_batch.to_cpu()
fig = pylab.gcf()
fig.set_size_inches(16.0, 16.0)
pylab.clf()
if config.img_channel == 1:
pylab.gray()
z_a = z_batch.data[:10,:]
z_b = z_batch.data[10:,:]
for col in range(10):
_z_batch = z_a * (1 - col / 9.0) + z_b * col / 9.0
_z_batch = Variable(_z_batch)
if use_gpu:
_z_batch.to_gpu()
_x_batch = dec(_z_batch, test=True)
if use_gpu:
_x_batch.to_cpu()
for row in range(10):
pylab.subplot(10, 10, row * 10 + col + 1)
if config.img_channel == 1:
pylab.imshow(np.clip((_x_batch.data[row] + 1.0) / 2.0, 0.0, 1.0).reshape((config.img_width, config.img_width)), interpolation="none")
elif config.img_channel == 3:
pylab.imshow(np.clip((_x_batch.data[row] + 1.0) / 2.0, 0.0, 1.0).reshape((config.img_channel, config.img_width, config.img_width)), interpolation="none")
pylab.axis("off")
pylab.savefig("%s/walk_through.png" % args.visualization_dir)
class AdamLearner(Link):
def __init__(self, dim):
super(AdamLearner, self).__init__(
beta1=(dim, ),
beta2=(dim, )
)
self.beta1.data.fill(-1e12)
self.beta2.data.fill(-1e12)
self.m = Variable(np.zeros_like(self.beta1.data))
self.v = Variable(np.zeros_like(self.beta2.data))
def to_gpu(self, device=None):
super(AdamLearner, self).to_gpu()
self.m.to_gpu(device)
self.v.to_gpu(device)
def __call__(self, x):
f1 = F.sigmoid(self.beta1)
f2 = F.sigmoid(self.beta2)
#self.m = f1 * self.m + (1 - f1) * x
#self.v = f2 * self.v + (1 - f2) * x**2
self.m = self.beta1 * self.m + (1 - self.beta1) * x
self.v = self.beta2 * self.v + (1 - self.beta2) * x**2
g = 1e-3 * self.m / F.sqrt(self.v + 1e-8)
return g
def optimizeCRNN(iterNum,maxIndex,indicies):
batchSize = 1000
model = EvalCRNN(maxIndex,500)
print(len(indicies),computeEntropy(maxIndex,indicies))
learningRate = 0.001
epoch = 3
for j in range(epoch):
my_optimizer = optimizers.RMSpropGraves(lr = learningRate)
my_optimizer.setup(model)
my_optimizer.add_hook(optimizer.GradientClipping(1))
model.cRNN.reset()
loss = Variable(np.array([[0]]))
for i in range(iterNum):
t1 = time.clock()
model.zerograds()
loss.unchain_backward()
loss = model(indicies[batchSize*i:batchSize*(i+1)],iterNum*batchSize)
loss.backward()
t2 = time.clock()
msg = "iter: " + str(i + iterNum * j + 1) + "/" + str(iterNum * epoch)
msgLoss = "loss: " + str(loss.data/batchSize)
msgNorm = "grad: " + str(my_optimizer.compute_grads_norm())
msgTime = "time: " + str(t2 - t1) + " seconds"
print(msgLoss,msgNorm,msg,msgTime)
my_optimizer.update()
learningRate *= 0.50
print(model(indicies[batchSize*(iterNum):batchSize*(iterNum+10)]).data/(batchSize*10))
return model.cRNN
def sample_z_from_n_2d_gaussian_mixture(batchsize, z_dim, label_indices, n_labels, gpu=False):
if z_dim % 2 != 0:
raise Exception("z_dim must be a multiple of 2.")
def sample(x, y, label, n_labels):
shift = 1.4
r = 2.0 * np.pi / float(n_labels) * float(label)
new_x = x * cos(r) - y * sin(r)
new_y = x * sin(r) + y * cos(r)
new_x += shift * cos(r)
new_y += shift * sin(r)
return np.array([new_x, new_y]).reshape((2,))
x_var = 0.5
y_var = 0.05
x = np.random.normal(0, x_var, (batchsize, z_dim / 2))
y = np.random.normal(0, y_var, (batchsize, z_dim / 2))
z = np.empty((batchsize, z_dim), dtype=np.float32)
for batch in xrange(batchsize):
for zi in xrange(z_dim / 2):
z[batch, zi*2:zi*2+2] = sample(x[batch, zi], y[batch, zi], label_indices[batch], n_labels)
z = Variable(z)
if gpu:
z.to_gpu()
return z
def setUp(self):
chainer.set_debug(True)
np.random.seed(0)
dataset = VOC('train')
img, im_info, bbox = dataset[1]
self.x = Variable(img[None, ...])
self.im_info = Variable(im_info[None, ...])
self.gt_boxes = Variable(bbox[None, ...])
def update_core(self):
enc_optimizer = self.get_optimizer('enc')
dec_optimizer = self.get_optimizer('dec')
dis_optimizer = self.get_optimizer('dis')
enc, dec, dis = self.enc, self.dec, self.dis
xp = enc.xp
batch = self.get_iterator('main').next()
batchsize = len(batch)
in_ch = batch[0][0].shape[0]
""" Edit g """
#print("Batch size", len(batch))
#print("Batch all", batch)
#print("Batch -1[0]", batch[-1][0])
#print("Batch -1[1]", batch[-1][1])
#print("Batch -1[0][0]", batch[-1][0][0])
""" 最後のインデックスにアクセスして、情報を取り出す """
""" これは、バッチサイズが1のときのみ有効であるからして、気をつけること """
#path_through1 = []
#for in_contain in batch[-1][0][-1]:
#print("IN_CONTAIN", in_contain)
# for c in in_contain:
# path_through1.append(c)
#print("path-through len", len(path_through1))
""" ここまで """
out_ch = batch[0][1].shape[0]
w_in = 256
w_out = 256
x_in = xp.zeros((batchsize, in_ch, w_in, w_in)).astype("f")
t_out = xp.zeros((batchsize, out_ch, w_out, w_out)).astype("f")
for i in range(batchsize):
x_in[i,:] = xp.asarray(batch[i][0])
t_out[i,:] = xp.asarray(batch[i][1])
x_in = Variable(x_in)
z = enc(x_in, test=False)
""" このzベクトルを変化させれば、任意の方向性に持っていくことができる """
#print("z", z)
""" Zを直接編集するのは危険なので、decの引数を増やして対処したほうが良さそう """
#x_out = dec(z, path_through1, test=False)
x_out = dec(z, test=False)
y_fake = dis(x_in, x_out, test=False)
y_real = dis(x_in, t_out, test=False)
enc_optimizer.update(self.loss_enc, enc, x_out, t_out, y_fake)
for z_ in z:
z_.unchain_backward()
dec_optimizer.update(self.loss_dec, dec, x_out, t_out, y_fake)
x_in.unchain_backward()
x_out.unchain_backward()
dis_optimizer.update(self.loss_dis, dis, y_real, y_fake)
def __init__(self, dim):
super(AdamLearner, self).__init__(
beta1=(dim, ),
beta2=(dim, )
)
self.beta1.data.fill(-1e12)
self.beta2.data.fill(-1e12)
self.m = Variable(np.zeros_like(self.beta1.data))
self.v = Variable(np.zeros_like(self.beta2.data))
def sample_z_from_n_2d_gaussian_mixture(batchsize, z_dim, label_indices, n_labels, gpu=False): z = np.zeros((batchsize, z_dim), dtype=np.float32) for i in range(batchsize): z1 = np.random.normal(0.5, 0.2, 1) z2 = np.random.normal(0.5, 0.2, 1) z[i] = np.array([z1, z2]).reshape((2,)) z = Variable(z) if gpu: z.to_gpu() return z
def encode(self, data, test=False):
x = self.enc(data, test=test)
mean, ln_var = F.split_axis(x, 2, 1)
samp = np.random.standard_normal(mean.data.shape).astype('float32')
samp = Variable(samp)
if self.flag_gpu:
samp.to_gpu()
z = samp * F.exp(0.5*ln_var) + mean
return z, mean, ln_var
def multi_box_intersection(a, b):
w = multi_overlap(a.x, a.w, b.x, b.w)
h = multi_overlap(a.y, a.h, b.y, b.h)
zeros = Variable(np.zeros(w.shape, dtype=w.data.dtype))
zeros.to_gpu()
w = F.maximum(w, zeros)
h = F.maximum(h, zeros)
area = w * h
return area
def sample_x_from_data_distribution(batchsize): shape = config.img_channel * config.img_width * config.img_width x_batch = np.zeros((batchsize, shape), dtype=np.float32) for j in range(batchsize): data_index = np.random.randint(len(dataset)) img = dataset[data_index] x_batch[j] = img.reshape((shape,)) x_batch = Variable(x_batch) if config.use_gpu: x_batch.to_gpu() return x_batch
def generate_image(img_orig, img_style, width, nw, nh, max_iter, lr, img_gen=None):
batch_size = img_orig.shape[0]
mid_orig = nn.forward(Variable(img_orig, volatile=True))
style_mats = [get_matrix(y) for y in nn.forward(Variable(img_style, volatile=True))]
if img_gen is None:
if args.gpu >= 0:
img_gen_ = xp.random.uniform(-20,20,(3,width,width),dtype=np.float32)
img_gen = xp.random.uniform(-20,20,(batch_size,3,width,width),dtype=np.float32)
img_gen[:,:,:,:] = img_gen_
else:
img_gen_ = np.random.uniform(-20,20,(3,width,width)).astype(np.float32)
img_gen = np.random.uniform(-20,20,(batch_size,3,width,width)).astype(np.float32)
img_gen[:,:,:,:] = img_gen_
x = Variable(img_gen)
xg = xp.zeros_like(x.data)
optimizer = optimizers.Adam(alpha=lr)
optimizer.setup((img_gen,xg))
for i in range(max_iter):
x = Variable(img_gen)
y = nn.forward(x)
optimizer.zero_grads()
L = Variable(xp.zeros((), dtype=np.float32))
for l in range(len(y)):
gogh_matrix = get_matrix(y[l])
L1 = np.float32(args.lam) * np.float32(nn.alpha[l])*F.mean_squared_error(y[l], Variable(mid_orig[l].data))
L2 = np.float32(nn.beta[l])*F.mean_squared_error(gogh_matrix, Variable(style_mats[l].data))/np.float32(len(y))
L += L1+L2
if i%100==0:
print i,l,L1.data,L2.data
L.backward()
xg += x.grad
optimizer.update()
tmp_shape = img_gen.shape
if args.gpu >= 0:
img_gen += Clip().forward(img_gen).reshape(tmp_shape) - img_gen
else:
def clip(x):
return -120 if x<-120 else (136 if x>136 else x)
img_gen += np.vectorize(clip)(img_gen).reshape(tmp_shape) - img_gen
if i%50==0:
for j in range(img_gen.shape[0]):
save_image(img_gen[j], W, nw[j], nh[j], args.out_dir+"_%d/im_%05d.png"%(j,i))
for j in range(img_gen.shape[0]):
save_image(img_gen[j], W, nw[j], nh[j], args.out_dir+"_last/im_%d.png"%(j))
def setUp(self):
x = np.arange(2 * 9 * 14 * 14, dtype=np.float32)
self.x = Variable(x.reshape(1, 18, 14, 14))
self.img_info = Variable(np.array([[224, 224]], dtype=np.int32))
self.anchor_target_layer = AnchorTargetLayer(
16, [0.5, 1, 2], [8, 16, 32])
self.gt_boxes = Variable(np.array([[
[10, 10, 60, 200, 0],
[50, 100, 210, 210, 1],
[160, 40, 200, 70, 2]
]], dtype=np.float32))
self.feat_h, self.feat_w = 14, 14
def forward_one_step(self, state, action, reward, next_state, test=False): xp = cuda.cupy if config.use_gpu else np n_batch = state.shape[0] state = Variable(state.reshape((n_batch, config.rl_history_length * 34))) next_state = Variable(next_state.reshape((n_batch, config.rl_history_length * 34))) if config.use_gpu: state.to_gpu() next_state.to_gpu() q = self.compute_q_variable(state, test=test) q_ = self.compute_q_variable(next_state, test=test) max_action_indices = xp.argmax(q_.data, axis=1) if config.use_gpu: max_action_indices = cuda.to_cpu(max_action_indices) target_q = self.compute_target_q_variable(next_state, test=test) target = q.data.copy() for i in xrange(n_batch): max_action_index = max_action_indices[i] target_value = reward[i] + config.rl_discount_factor * target_q.data[i][max_action_indices[i]] action_index = self.get_index_for_action(action[i]) old_value = target[i, action_index] diff = target_value - old_value if diff > 1.0: target_value = 1.0 + old_value elif diff < -1.0: target_value = -1.0 + old_value target[i, action_index] = target_value target = Variable(target) loss = F.mean_squared_error(target, q) return loss, q
def train_word_embedding_batch(self, char_ids_batch): xp = self.xp word_vec = self.encode_word_batch(char_ids_batch) batchsize = char_ids_batch.shape[0] char_ids_batch = char_ids_batch.T # reconstruction loss loss_reconstruction = 0 self.word_decoder_lstm.reset_state() prev_y = None for i in xrange(char_ids_batch.shape[0]): if prev_y is None: prev_y = Variable(xp.zeros((batchsize, self.char_embed_size), dtype=xp.float32)) dec_in = F.concat((word_vec, prev_y)) y = self.word_decoder_lstm(dec_in, test=False) target = Variable(char_ids_batch[i]) if self.gpu_enabled: target.to_gpu() loss = F.softmax_cross_entropy(y, target) prev_y = self.embed_id(target) loss_reconstruction += loss self.zero_grads_generator() loss_reconstruction.backward() self.update_generator() # adversarial loss ## 0: from encoder ## 1: from noise real_z = self.sample_z(batchsize, self.word_embed_size) fake_z = word_vec y_fake = self.discriminator(fake_z, test=False) ## train generator loss_generator = F.softmax_cross_entropy(y_fake, Variable(xp.ones((batchsize,), dtype=xp.int32))) self.zero_grads_generator() loss_generator.backward() self.update_generator() # train discriminator y_real = self.discriminator(real_z, test=False) loss_discriminator = F.softmax_cross_entropy(y_fake, Variable(xp.zeros((batchsize,), dtype=xp.int32))) loss_discriminator += F.softmax_cross_entropy(y_real, Variable(xp.ones((batchsize,), dtype=xp.int32))) self.optimizer_discriminator.zero_grads() loss_discriminator.backward() self.optimizer_discriminator.update() return float(loss_reconstruction.data), float(loss_generator.data), float(loss_discriminator.data)
def sample_x_and_label_from_data_distribution(batchsize, sequential=False): shape = config.img_channel * config.img_width * config.img_width x_batch = np.zeros((batchsize, shape), dtype=np.float32) label_batch = np.zeros((batchsize, 1), dtype=np.int32) for j in range(batchsize): data_index = np.random.randint(len(dataset)) if sequential: data_index = j img = dataset[data_index] x_batch[j] = img.reshape((shape,)) label_batch[j] = labels[data_index] x_batch = Variable(x_batch) if use_gpu: x_batch.to_gpu() return x_batch, label_batch
def update_step(net, images, step_size=1.5, end='inception_4c/output', jitter=32, clip=True):
offset_x, offset_y = np.random.randint(-jitter, jitter + 1, 2)
data = np.roll(np.roll(images, offset_x, -1), offset_y, -2)
x = Variable(xp.asarray(data))
x.zerograd()
dest, = net(x, outputs=[end])
objective(dest).backward()
g = cuda.to_cpu(x.grad)
data[:] += step_size / np.abs(g).mean() * g
data = np.roll(np.roll(data, -offset_x, -1), -offset_y, -2)
if clip:
bias = net.mean.reshape((1, 3, 1, 1))
data[:] = np.clip(data, -bias, 255 - bias)
return data
def forward(self,x=None,t=None): if x is None: x=Tensor.context xp = Deel.xp volatile = 'off' if Deel.train else 'on' h = Variable(xp.asarray(x.value,dtype=xp.float32),volatile=volatile) self.optimizer.zero_grads() for i in range(len(self.layers)): h = F.dropout(self.activation(self.layers['l'+str(i)](h)),train=Deel.train) h = ChainerTensor(h) h.use() return h
def generate_image(img_orig, img_style, width, nw, nh, max_iter, lr, img_gen=None):
mid_orig = nn.forward(Variable(img_orig, volatile=True))
style_mats = [get_matrix(y) for y in nn.forward(Variable(img_style, volatile=True))]
if img_gen is None:
if args.gpu >= 0:
img_gen = xp.random.uniform(-20,20,(1,3,width,width),dtype=np.float32)
else:
img_gen = np.random.uniform(-20,20,(1,3,width,width)).astype(np.float32)
x = Variable(img_gen)
xg = xp.zeros_like(x.data)
optimizer = optimizers.Adam(alpha=lr)
optimizer.setup((img_gen,xg))
for i in range(max_iter):
x = Variable(img_gen)
y = nn.forward(x)
optimizer.zero_grads()
L = Variable(xp.zeros((), dtype=np.float32))
for l in range(len(y)):
ch = y[l].data.shape[1]
wd = y[l].data.shape[2]
gogh_y = F.reshape(y[l], (ch,wd**2))
gogh_matrix = F.matmul(gogh_y, gogh_y, transb=True)/np.float32(ch*wd**2)
L1 = np.float32(args.lam) * np.float32(nn.alpha[l])*F.mean_squared_error(y[l], Variable(mid_orig[l].data))
L2 = np.float32(nn.beta[l])*F.mean_squared_error(gogh_matrix, Variable(style_mats[l].data))/np.float32(len(y))
L += L1+L2
if i%100==0:
print i,l,L1.data,L2.data
L.backward()
xg += x.grad
optimizer.update()
tmp_shape = img_gen.shape
if args.gpu >= 0:
img_gen += Clip().forward(img_gen).reshape(tmp_shape) - img_gen
else:
def clip(x):
return -120 if x<-120 else (136 if x>136 else x)
img_gen += np.vectorize(clip)(img_gen).reshape(tmp_shape) - img_gen
if i%3000==0:
save_image(img_gen, W, nw, nh, i)
def sample_z_from_swiss_roll_distribution(batchsize, z_dim, label_indices, n_labels, gpu=False): def sample(label, n_labels): uni = np.random.uniform(0.0, 1.0) / float(n_labels) + float(label) / float(n_labels) r = math.sqrt(uni) * 3.0 rad = np.pi * 4.0 * math.sqrt(uni) x = r * cos(rad) y = r * sin(rad) return np.array([x, y]).reshape((2,)) z = np.zeros((batchsize, z_dim), dtype=np.float32) for batch in xrange(batchsize): for zi in xrange(z_dim / 2): z[batch, zi*2:zi*2+2] = sample(label_indices[batch], n_labels) z = Variable(z) if gpu: z.to_gpu() return z
def encode_word_batch(self, char_ids_batch, test=False): xp = self.xp self.word_encoder_lstm.reset_state() output = None char_ids_batch = char_ids_batch.T batchsize = char_ids_batch.shape[1] for i in xrange(char_ids_batch.shape[0]): condition_args = np.argwhere(char_ids_batch[i] == -1).reshape(-1) condition = np.full((batchsize, self.conf.word_encoder_lstm_units[0]), True, dtype=np.bool) for j in xrange(condition_args.shape[0]): condition[condition_args[j], :] = False condition = Variable(condition) if self.gpu_enabled: condition.to_gpu() c0 = Variable(xp.asanyarray(char_ids_batch[i], dtype=xp.int32)) c0 = self.embed_id(c0) output = self.word_encoder_lstm(c0, condition, test=test) output = self.word_encoder_fc(output, apply_f=True) return output
def sim():
zeta0 = (np.random.uniform(-10.0, 10.0, (1,1,H,W)).astype(np.float32))
zeta0 = Variable(chainer.cuda.to_gpu(zeta0.astype(np.float32)), volatile=True)
for it in range(100):
zeta0 += 0.1*lap.forward(zeta0)
zeta = 0.0 + zeta0
psi = poisson_jacobi(zeta, num_iter=1000)
rho = Variable(rho0, volatile=True)
for i in range(10000):
psi = poisson_jacobi(zeta, x0=psi)
dpdx = FTCS_X().forward(psi) # -vy
dpdy = FTCS_Y().forward(psi) # vx
dzdx = upwind(Kawamura_X().forward(zeta), dpdy)
dzdy = upwind(Kawamura_Y().forward(zeta), -dpdx)
lapz = lap.forward(zeta)
rho_ = rho-0.5*dt*(dpdy*upwind(Kawamura_X().forward(rho), dpdy)-dpdx*upwind(Kawamura_Y().forward(rho), -dpdx) - 0.000*lap.forward(rho))
rho_.data[0,0,:,0] = rho_.data[0,0,:,499]
sum_rho = chainer.functions.sum(rho_)
rho_ = rho_/(xp.zeros_like(rho.data)+sum_rho)
dzdt = dpdx*dzdy - dpdy*dzdx + nu*lapz
zeta_ = zeta+0.5*dt * dzdt
psi = poisson_jacobi(zeta_, x0=psi)
dpdx = FTCS_X().forward(psi) # -vy
dpdy = FTCS_Y().forward(psi) # vx
dzdx = upwind(Kawamura_X().forward(zeta_), dpdy)
dzdy = upwind(Kawamura_Y().forward(zeta_), -dpdx)
lapz = lap.forward(zeta_)
rho = rho - dt*(dpdy*upwind(Kawamura_X().forward(rho_), dpdy)-dpdx*upwind(Kawamura_Y().forward(rho_), -dpdx) - 0.000*lap.forward(rho_))
rho.data[0,0,:,0] = rho.data[0,0,:,499]
sum_rho = chainer.functions.sum(rho)
rho = rho/(xp.zeros_like(rho.data)+sum_rho)
dzdt = dpdx*dzdy - dpdy*dzdx + nu*lapz
zeta = zeta + dt * dzdt
if i%10==0:
yield zeta, psi, rho, i
def sample_x_y(self, x, argmax=False, test=False): batchsize = x.data.shape[0] y_distribution = self.encoder_x_y(x, test=test, softmax=True).data n_labels = y_distribution.shape[1] if self.gpu: y_distribution = cuda.to_cpu(y_distribution) sampled_y = np.zeros((batchsize, n_labels), dtype=np.float32) if argmax: args = np.argmax(y_distribution, axis=1) for b in xrange(batchsize): sampled_y[b, args[b]] = 1 else: for b in xrange(batchsize): label_id = np.random.choice(np.arange(n_labels), p=y_distribution[b]) sampled_y[b, label_id] = 1 sampled_y = Variable(sampled_y) if self.gpu: sampled_y.to_gpu() return sampled_y
def predict(test_data, classifier, batchsize = 5, gpu = True):
if gpu:
classifier.predictor.to_gpu()
else:
classifier.predictor.to_cpu()
classifier.predictor.train = False
num_samples = 0
predictions = np.zeros((len(test_data.index),25))
for data in test_data.generate_minibatch(batchsize):
num_samples += len(data)
#print num_samples, '/', len(test_data.index)
x = Variable(data)
if gpu:
x.to_gpu()
yhat = classifier.predictor(x)
yhat = F.softmax(yhat)
yhat.to_cpu()
predictions[num_samples-len(data):num_samples,:] = yhat.data
return predictions
def step(self,perm,batch_index,mode,epoch):
if mode=='train':
data, first_words, label=self.read_batch(perm,batch_index,self.train_data,mode)
train = True
else :
data, first_words, label=self.read_batch(perm,batch_index,self.test_data,mode)
train = False
data = Variable(cuda.to_gpu(data))
state = {name: Variable(self.xp.zeros((self.batchsize, 1024),dtype=self.xp.float32)) for name in ('c1', 'h1')}
loss=Variable(cuda.cupy.asarray(0.0).astype(np.float32))
acc=0.0
### image-encoder ###
h = self.enc(data, train=train, test=not train)
h=h.data
h=Variable(h)
### first LSTM ###
state,_ = self.dec(h, state,train=train, test=not train, image=True)
### input <SOS> ###
state,y = self.dec(Variable(cuda.to_gpu(first_words)), state,train=train, test=not train)
loss += F.softmax_cross_entropy(y, Variable(cuda.to_gpu(label.T[1])))
acc += F.accuracy(y, Variable(cuda.to_gpu(label.T[1])), ignore_label=-1).data.get()
for cur_word,next_word in zip(label.T[1:-1],label.T[2:]):
state,y = self.dec(Variable(cuda.to_gpu(cur_word)), state,train=train, test=not train)
loss += F.softmax_cross_entropy(y, Variable(cuda.to_gpu(next_word)))
acc += F.accuracy(y, Variable(cuda.to_gpu(next_word)), ignore_label=-1).data.get()
if mode=='train':
self.dec.cleargrads()
loss.backward()
self.o_dec.update()
return {"prediction": 0,
"current_loss": loss.data.get()/(label.T.shape[0]),
"current_accuracy": acc/(label.T.shape[0]),
}
def sample_ax_y(self, a, x, argmax=False, test=False): a = self.to_variable(a) x = self.to_variable(x) batchsize = self.get_batchsize(x) y_distribution = F.softmax(self.q_y_ax(a, x, test=test)).data n_labels = y_distribution.shape[1] if self.gpu_enabled: y_distribution = cuda.to_cpu(y_distribution) sampled_y = np.zeros((batchsize, n_labels), dtype=np.float32) if argmax: args = np.argmax(y_distribution, axis=1) for b in xrange(batchsize): sampled_y[b, args[b]] = 1 else: for b in xrange(batchsize): label_id = np.random.choice(np.arange(n_labels), p=y_distribution[b]) sampled_y[b, label_id] = 1 sampled_y = Variable(sampled_y) if self.gpu_enabled: sampled_y.to_gpu() return sampled_y
def __zeros(shape, dtype):
return Variable(XP.__lib.zeros(shape, dtype=dtype))
for image in train_files:
if image.endswith('.jpg') or image.endswith('.png'):
img = cv2.imread(base_dir + image)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.resize(img, (img_x, img_y), interpolation=cv2.INTER_AREA)
img_gs = img.flatten()
# print('img _gs len = %d' % len(img_gs))
x_train_data.append(img_gs)
# t_train_data.append(img_gs)
total_datacount = len(x_train_data)
x_train = np.array(x_train_data, dtype=np.float32)
x_train /= 255
print('x_train len = %d' % len(x_train))
x_train_data = None
# Learned data
enc_model_data_file = './enc_model6.npz'
enc = AutoEnc6()
serializers.load_npz(enc_model_data_file, enc)
chainer.config.train = False
x = Variable(x_train)
y = enc.forward(x)
out_genimages(output_dir, output_base, y)
def __array(array, dtype):
return Variable(XP.__lib.array(array, dtype=dtype))
def get(self, x):
# input x as float, output float
return self.predict(
Variable(np.array([x]).astype(np.float32).reshape(1,
1))).data[0][0]
def make_batch_src_tgt(training_data,
eos_idx=1,
padding_idx=0,
gpu=None,
need_arg_sort=False,
use_chainerx=False):
if need_arg_sort:
training_data_with_argsort = list(
six.moves.zip(training_data, six.moves.range(len(training_data))))
training_data_with_argsort.sort(key=lambda x: len(x[0][1]),
reverse=True)
training_data, argsort = list(
six.moves.zip(*training_data_with_argsort))
else:
training_data = sorted(training_data,
key=lambda x: len(x[1]),
reverse=True)
# max_src_size = max(len(x) for x, y in training_data)
max_tgt_size = max(len(y) for _, y in training_data)
mb_size = len(training_data)
src_batch, src_mask = make_batch_src([x for x, y in training_data],
padding_idx=padding_idx,
gpu=gpu,
use_chainerx=use_chainerx)
lengths_list = []
lowest_non_finished = mb_size - 1
for pos in six.moves.range(max_tgt_size + 1):
while pos > len(training_data[lowest_non_finished][1]):
lowest_non_finished -= 1
assert lowest_non_finished >= 0
mb_length_at_this_pos = lowest_non_finished + 1
assert len(
lengths_list) == 0 or mb_length_at_this_pos <= lengths_list[-1]
lengths_list.append(mb_length_at_this_pos)
tgt_batch = []
for i in six.moves.range(max_tgt_size + 1):
current_mb_size = lengths_list[i]
assert current_mb_size > 0
tgt_batch.append(np.empty((current_mb_size, ), dtype=np.int32))
for num_ex in six.moves.range(current_mb_size):
assert len(training_data[num_ex][1]) >= i
if len(training_data[num_ex][1]) == i:
tgt_batch[-1][num_ex] = eos_idx
else:
tgt_batch[-1][num_ex] = training_data[num_ex][1][i]
tgt_batch_v = [
Variable(move_input_to_device(x, gpu, use_chainerx),
requires_grad=False) for x in tgt_batch
]
# if gpu is not None:
# tgt_batch_v = [Variable(safe_to_gpu(x, gpu)) for x in tgt_batch]
# else:
# tgt_batch_v = [Variable(x) for x in tgt_batch]
if need_arg_sort:
return src_batch, tgt_batch_v, src_mask, argsort
else:
return src_batch, tgt_batch_v, src_mask
model = MLP(784, 10)
opt = chainer.optimizers.Adam()
opt.use_cleargrads()
opt.setup(model)
train_num = len(train)
test_num = len(test)
epoch_num = 10
for epoch in xrange(epoch_num):
train_loss_sum = 0
train_accuracy_sum = 0
for i in xrange(0, train_num, batchsize):
batch = train_iter.next()
x = Variable(np.asarray([s[0] for s in batch]))
t = Variable(np.asarray([s[1] for s in batch]))
y = model(x)
loss = F.softmax_cross_entropy(y, t)
model.cleargrads()
loss.backward()
opt.update()
train_loss_sum += loss.data
train_accuracy_sum += F.accuracy(y, t).data
print(train_loss_sum, train_accuracy_sum)
test_loss_sum = 0
test_accuracy_sum = 0
for i in xrange(0, test_num, batchsize):
batch = test_iter.next()
x = Variable(np.asarray([s[0] for s in batch]))
def __call__(self, x_data, y_data):
x = Variable(x_data.astype(np.float32).reshape(len(x_data),
1)) # Variableオブジェクトに変換
y = Variable(y_data.astype(np.float32).reshape(len(y_data),
1)) # Variableオブジェクトに変換
return F.mean_squared_error(self.predict(x), y)
def update_core(self):
#debug
# import tracemalloc
# snapshot1 = tracemalloc.take_snapshot()
# top_stats = snapshot1.statistics('lineno')
# with open("tracemalloc_raw.log", 'a') as f:
# print("[ Top 10 ]",file=f)
# for stat in top_stats[:10]:
# print(stat,file=f)
opt_g = self.get_optimizer('gen_g')
opt_f = self.get_optimizer('gen_f')
opt_x = self.get_optimizer('dis_x')
opt_y = self.get_optimizer('dis_y')
self._iter += 1
if self.is_new_epoch and self.epoch >= self._lrdecay_start:
decay_step = self.init_alpha / self._lrdecay_period
print('lr decay', decay_step)
if opt_g.alpha > decay_step:
opt_g.alpha -= decay_step
if opt_f.alpha > decay_step:
opt_f.alpha -= decay_step
if opt_x.alpha > decay_step:
opt_x.alpha -= decay_step
if opt_y.alpha > decay_step:
opt_y.alpha -= decay_step
batch_x = self.get_iterator('main').next()
batch_y = self.get_iterator('train_B').next()
x = Variable(self.converter(batch_x, self.device))
y = Variable(self.converter(batch_y, self.device))
x_y = self.gen_g(x)
x_y_copy = Variable(self._buffer_y.query(x_y.data))
x_y_x = self.gen_f(x_y)
y_x = self.gen_f(y)
y_x_copy = Variable(self._buffer_x.query(y_x.data))
y_x_y = self.gen_g(y_x)
loss_gen_g_adv = self.loss_func_adv_gen(self.dis_y(x_y))
loss_gen_f_adv = self.loss_func_adv_gen(self.dis_x(y_x))
loss_cycle_x = self._lambda_A * self.loss_func_rec_l1(x_y_x, x)
loss_cycle_y = self._lambda_B * self.loss_func_rec_l1(y_x_y, y)
loss_gen = loss_gen_g_adv + loss_gen_f_adv + loss_cycle_x + loss_cycle_y
if self._lambda_id > 0:
loss_id_x = self._lambda_id * F.mean_absolute_error(
x, self.gen_f(x))
loss_id_y = self._lambda_id * F.mean_absolute_error(
y, self.gen_g(y))
loss_gen = loss_gen + loss_id_x + loss_id_y
self.gen_f.cleargrads()
self.gen_g.cleargrads()
loss_gen.backward()
opt_f.update()
opt_g.update()
loss_dis_y_fake = self.loss_func_adv_dis_fake(self.dis_y(x_y_copy))
loss_dis_y_real = self.loss_func_adv_dis_real(self.dis_y(y))
loss_dis_y = (loss_dis_y_fake + loss_dis_y_real) * 0.5
self.dis_y.cleargrads()
loss_dis_y.backward()
opt_y.update()
loss_dis_x_fake = self.loss_func_adv_dis_fake(self.dis_x(y_x_copy))
loss_dis_x_real = self.loss_func_adv_dis_real(self.dis_x(x))
loss_dis_x = (loss_dis_x_fake + loss_dis_x_real) * 0.5
self.dis_x.cleargrads()
loss_dis_x.backward()
opt_x.update()
chainer.report({'loss': loss_dis_x}, self.dis_x)
chainer.report({'loss': loss_dis_y}, self.dis_y)
chainer.report({'loss_cycle': loss_cycle_y}, self.gen_g)
chainer.report({'loss_cycle': loss_cycle_x}, self.gen_f)
chainer.report({'loss_gen': loss_gen_g_adv}, self.gen_g)
chainer.report({'loss_gen': loss_gen_f_adv}, self.gen_f)
if self._lambda_id > 0:
chainer.report({'loss_id': loss_id_y}, self.gen_g)
chainer.report({'loss_id': loss_id_x}, self.gen_f)
def evaluate(self):
batch_x = self._iterators['main'].next()
batch_y = self._iterators['testB'].next()
models = self._targets
if self.eval_hook:
self.eval_hook(self)
fig = plt.figure(figsize=(9, 3 * (len(batch_x) + len(batch_y))))
gs = gridspec.GridSpec(len(batch_x) + len(batch_y),
3,
wspace=0.1,
hspace=0.1)
x = Variable(self.converter(batch_x, self.device))
y = Variable(self.converter(batch_y, self.device))
with chainer.using_config('train', False):
with chainer.function.no_backprop_mode():
if len(models) > 2:
x_y = models['dec_y'](models['enc_x'](x))
if self.single_encoder:
x_y_x = models['dec_x'](models['enc_x'](x_y))
else:
x_y_x = models['dec_x'](
models['enc_x'](x)) ## autoencoder
#x_y_x = models['dec_x'](models['enc_y'](x_y))
else:
x_y = models['gen_g'](x)
x_y_x = models['gen_f'](x_y)
# for i, var in enumerate([x, x_y]):
for i, var in enumerate([x, x_y, x_y_x]):
imgs = postprocess(var).astype(np.float32)
for j in range(len(imgs)):
ax = fig.add_subplot(gs[j, i])
if imgs[j].shape[2] == 1:
ax.imshow(imgs[j, :, :, 0],
interpolation='none',
cmap='gray',
vmin=0,
vmax=1)
else:
ax.imshow(imgs[j], interpolation='none', vmin=0, vmax=1)
ax.set_xticks([])
ax.set_yticks([])
with chainer.using_config('train', False):
with chainer.function.no_backprop_mode():
if len(models) > 2:
if self.single_encoder:
y_x = models['dec_x'](models['enc_x'](y))
else:
y_x = models['dec_x'](models['enc_y'](y))
# y_x_y = models['dec_y'](models['enc_y'](y)) ## autoencoder
y_x_y = models['dec_y'](models['enc_x'](y_x))
else: # (gen_g, gen_f)
y_x = models['gen_f'](y)
y_x_y = models['gen_g'](y_x)
# for i, var in enumerate([y, y_y]):
for i, var in enumerate([y, y_x, y_x_y]):
imgs = postprocess(var).astype(np.float32)
for j in range(len(imgs)):
ax = fig.add_subplot(gs[j + len(batch_x), i])
if imgs[j].shape[2] == 1:
ax.imshow(imgs[j, :, :, 0],
interpolation='none',
cmap='gray',
vmin=0,
vmax=1)
else:
ax.imshow(imgs[j], interpolation='none', vmin=0, vmax=1)
ax.set_xticks([])
ax.set_yticks([])
gs.tight_layout(fig)
plt.savefig(os.path.join(self.vis_out,
'count{:0>4}.jpg'.format(self.count)),
dpi=200)
self.count += 1
plt.close()
cycle_y_l1 = F.mean_absolute_error(y, y_x_y)
# cycle_y_l2 = F.mean_squared_error(y,y_x_y)
cycle_x_l1 = F.mean_absolute_error(x, x_y_x)
# id_xy_grad = losses.loss_grad(x,x_y)
result = {
"myval/cycle_y_l1": cycle_y_l1,
"myval/cycle_x_l1": cycle_x_l1
}
return result
def testplot_p4m(im=None, m=0, r=0):
if im is None:
# im = np.zeros((39, 39), dtype='float32')
# im[10:30, 14:16] = 1.
# im[10:12, 14:30] = 1.
# im[18:20, 14:24] = 1.
# im = gaussian_filter(im, sigma=1., mode='constant', cval=0.0)
im = np.zeros((5, 5), dtype='float32')
im[0:5, 1] = 1.
im[0, 1:4] = 1.
im[2, 1:3] = 1.
# im = gaussian_filter(im, sigma=1., mode='constant', cval=0.0)
# from gfunc.OLD.transform_Z2_func import rotate_flip_z2_func
from groupy.gfunc.z2func_array import Z2FuncArray
from groupy.garray.D4_array import D4Array
def rotate_flip_z2_func(im, flip, theta_index):
imf = Z2FuncArray(im)
rot = D4Array([flip, theta_index], 'int')
rot_imf = rot * imf
return rot_imf.v
im = rotate_flip_z2_func(im, m, r)
# im = lena()
# filter = np.array([1, 2, 1])[:, None] * np.array([-1, 0, 1.])[None, :]
filter_e = np.array([[-1., -4., 1.],
[-2., 0., 2.],
[-1., 0., 1.]])
# filter_e = np.array([[0, 1, 0, -1, 0],
# [0, 1, 0, -1, 0],
# [0, 0, 0, 0, 0],
# [0, -1, 0, 1, 0],
# [1, -1, 3, 1, -1.]])
filter_r1 = rotate_flip_z2_func(filter_e, flip=0, theta_index=1)
filter_r2 = rotate_flip_z2_func(filter_e, flip=0, theta_index=2)
filter_r3 = rotate_flip_z2_func(filter_e, flip=0, theta_index=3)
filter_m = rotate_flip_z2_func(filter_e, flip=1, theta_index=0)
filter_mr1 = rotate_flip_z2_func(filter_e, flip=1, theta_index=1)
filter_mr2 = rotate_flip_z2_func(filter_e, flip=1, theta_index=2)
filter_mr3 = rotate_flip_z2_func(filter_e, flip=1, theta_index=3)
print(filter_e)
print(filter_r1)
print(filter_r2)
print(filter_r3)
print(filter_m)
print(filter_mr1)
print(filter_mr2)
print(filter_mr3)
# filter_e = filter_e[::-1, ::-1]
# filter_r1 = filter_r1[::-1, ::-1]
# filter_r2 = filter_r2[::-1, ::-1]
# filter_r3 = filter_r3[::-1, ::-1]
# filter_m = filter_m[::-1, ::-1]
# filter_mr1 = filter_mr1[::-1, ::-1]
# filter_mr2 = filter_mr2[::-1, ::-1]
# filter_mr3 = filter_mr3[::-1, ::-1]
# imf_e = correlate2d(im, filter_e, 'valid')
# imf_r1 = correlate2d(im, filter_r1, 'valid')
# imf_r2 = correlate2d(im, filter_r2, 'valid')
# imf_r3 = correlate2d(im, filter_r3, 'valid')
# imf_m = correlate2d(im, filter_m, 'valid')
# imf_mr1 = correlate2d(im, filter_mr1, 'valid')
# imf_mr2 = correlate2d(im, filter_mr2, 'valid')
# imf_mr3 = correlate2d(im, filter_mr3, 'valid')
from chainer.functions import Convolution2D
from chainer import Variable
im = im.astype(np.float32)
ksize = filter_e.shape[0]
imf_e = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2,initialW=filter_e)(Variable(im[None, None])).data[0, 0]
imf_r1 = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_r1)(Variable(im[None, None])).data[0, 0]
imf_r2 = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_r2)(Variable(im[None, None])).data[0, 0]
imf_r3 = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_r3)(Variable(im[None, None])).data[0, 0]
imf_m = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_m)(Variable(im[None, None])).data[0, 0]
imf_mr1 = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_mr1)(Variable(im[None, None])).data[0, 0]
imf_mr2 = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_mr2)(Variable(im[None, None])).data[0, 0]
imf_mr3 = Convolution2D(in_channels=1, out_channels=1, ksize=ksize, bias=0., pad=2, initialW=filter_mr3)(Variable(im[None, None])).data[0, 0]
return im, np.r_[[imf_e, imf_r1, imf_r2, imf_r3, imf_m, imf_mr1, imf_mr2, imf_mr3]]
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
model.train = False
""" Load data """
print('loading data')
input_img = cv2.imread(input_file_path, cv2.IMREAD_COLOR)
print('upscaling to ', output_file_path)
if args.color == 'rgb':
input_img = np.transpose(input_img[:, :, :], (2, 0, 1))
input_img = input_img / 255.0 # Must be handled as float
input_img = input_img.reshape(
(1, input_img.shape[0], input_img.shape[1], input_img.shape[2]))
x_data = model.preprocess_x(input_img)
x = Variable(xp.asarray(x_data), volatile='on')
output_img = model(x)
if (args.gpu >= 0):
output_data = cuda.cupy.asnumpy(output_img.data)
else:
output_data = output_img.data
output_img = output_data[0].transpose(1, 2, 0) * 255.
elif args.color == 'yonly':
ycc_input_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2YCR_CB)
y_input_img = np.transpose(ycc_input_img[:, :, 0:1], (2, 0, 1))
y_input_img = y_input_img / 255.0 # Must be handled as float
y_input_img = y_input_img.reshape(
(1, y_input_img.shape[0], y_input_img.shape[1],
y_input_img.shape[2]))
x_test = data[ind[60:]]
t_test = x_test[:]
model, optimizer = create_model(dim)
loss = None
if mode == "loss":
tr = Trainer(model, optimizer)
loss = tr.train(x_train, t_train, bs=30, epoch=3000, display=False, ratio=0.2, bn=True)
serializers.save_npz(model_file_name, model)
serializers.save_npz(state_file_name, optimizer)
else:
model, optimizer = create_model(dim, model_file_name, state_file_name)
tr = Trainer(model, optimizer)
if mode == "acc":
x_restore = model.fwd(Variable(x_test)).data
y = F.sigmoid(model.l1(Variable(x_test))).data.argmax(axis=1)
#print("y:{}".format(y))
v_sum = 0
for i in range(h_dim):
subp = plt.subplot(2, 5, i + 1)
ind = np.where(y == i)[0]
if len(ind) > 0:
avg = x_restore[ind].mean(axis=0)
v = ((x_restore[ind] - avg) ** 2).mean()
v_sum += v
subp.set_title("no:%d, v:%.2f" % (i + 1, v))
print("no:%d, v:%.2f" % (i + 1, v))
for j in ind:
subp.plot(np.arange(0, 24), x_restore[j])
plt.savefig("acc_%02d" % h_dim)
for i in range(N):
Y2[i, Y[i]] = 1.0
index = np.arange(N)
xtrain = X[index[index % 2 != 0], :]
ytrain = Y2[index[index % 2 != 0], :]
xtest = X[index[index % 2 == 0], :]
yans = Y[index[index % 2 == 0]]
# モデルの生成
model = IrisChain()
optimizer = optimizers.SGD()
optimizer.setup(model)
# パラメータの更新
for i in range(10000):
x = Variable(xtrain)
y = Variable(ytrain)
model.cleargrads()
loss = model(x, y)
loss.backward()
optimizer.update()
# モデルの評価
xt = Variable(xtest)
yt = model.fwd(xt)
ans = yt.data
nrow, ncol = ans.shape
ok = 0
for i in range(nrow):
cls = np.argmax(ans[i, :])
if cls == yans[i]:
import numpy as np import chainer.functions as F import chainer.links as L from chainer import Variable, optimizers #모델 정의 model = L.Linear(1,1) optimizer = optimizers.SGD() optimizer.setup(model) #학습시킬 횟수 times = 50 #입력 벡터 x = Variable(np.array([[1]], dtype=np.float32)) #정답 벡터 t = Variable(np.array([[2]], dtype=np.float32)) #학습 그룹 for i in range(0, times): #경사를 초기화 optimizer.zero_grads() #여기에서 모델로 예측시킨다 y=model(x) #모델이 내린 답을 표시 print(y.data)
h = F.relu(self.l3(h))
h = self.l4(h)
return h
model = NN(784, 10)
optimizer = optimizers.Adam()
optimizer.setup(model)
n_epoch = 5
batch_size = 1000
for epoch in range(n_epoch):
sum_loss = 0
sum_accuracy = 0
perm = np.random.permutation(N)
for i in range(0, N, batch_size):
x = Variable(x_train[perm[i:i+batch_size]])
t = Variable(t_train[perm[i:i+batch_size]])
y = model.forward(x)
model.zerograds()
loss = F.softmax_cross_entropy(y, t)
acc = F.accuracy(y, t)
loss.backward()
optimizer.update()
sum_loss += loss.data*batch_size
sum_accuracy += acc.data*batch_size
print("epoch: {}, mean loss: {}, mean accuracy: {}".format(epoch, sum_loss/N, sum_accuracy/N))
cnt = 0
for i in range(10000):
x = Variable(np.array([x_test[i]], dtype=np.float32))
t = t_test[i]
model.to_gpu()
vgg.to_gpu()
xp = np if args.gpu < 0 else cuda.cupy
O = optimizers.Adam(alpha=args.lr)
O.setup(model)
if args.resume:
print('load optimizer state from', args.resume)
serializers.load_npz(args.resume, O)
style = vgg.preprocess(np.asarray(Image.open(args.style_image).convert('RGB').resize((image_size,image_size)), dtype=np.float32))
style = xp.asarray(style, dtype=xp.float32)
style_b = xp.zeros((batchsize,) + style.shape, dtype=xp.float32)
for i in range(batchsize):
style_b[i] = style
feature_s = vgg(Variable(style_b))
gram_s = [gram_matrix(y) for y in feature_s]
for epoch in range(n_epoch):
print('epoch', epoch)
for i in range(n_iter):
model.zerograds()
vgg.zerograds()
indices = range(i * batchsize, (i+1) * batchsize)
x = xp.zeros((batchsize, 3, image_size, image_size), dtype=xp.float32)
for j in range(batchsize):
x[j] = load_image(imagepaths[i*batchsize + j], image_size)
xc = Variable(x.copy())
x = Variable(x)
cuda.get_device(gpu_flag).use()
model.to_gpu()
# optimizer
optimizer = optimizers.RMSpropGraves()
optimizer.setup(model)
for epoch in range(epochs):
print('start_epoch:' + str(epoch))
cycle, output = make_cycle(num_of_data)
cycle = cuda.to_gpu(cycle)
output = cuda.to_gpu(output)
for k in range(num_of_data/100 + 1):
optimizer.zero_grads()
if k == 68:
x, t = Variable(cycle[100*k:100*k+69, :, :, :]), Variable(output[100*k:100*k+69])
else:
x, t = Variable(cycle[100*k:100*k+99, :, :, :]), Variable(output[100*k:100*k+99])
x = F.max_pooling_2d(F.relu(model.conv1(x)), 2)
x = F.max_pooling_2d(F.relu(model.conv2(x)), 2)
x = F.relu(model.conv3(x))
x = F.dropout(F.relu(model.l1(x)), ratio=dropout_ratio, train=True)
y = model.l2(x)
loss = F.softmax_cross_entropy(y, t)
acc = F.accuracy(y, t)
loss.backward()
optimizer.update()
cycle, output = make_batch(batch_size)
x, t = Variable(cuda.to_gpu(cycle)), Variable(cuda.to_gpu(output))
x = F.max_pooling_2d(F.relu(model.conv1(x)), 2)
x = F.max_pooling_2d(F.relu(model.conv2(x)), 2)
# read image
print("loading image...")
img = cv2.imread(image_file)
img = cv2.resize(img, (input_height, input_width))
img = np.asarray(img, dtype=np.float32) / 255.0
img = img.transpose(2, 0, 1)
# load model
print("loading model...")
model = Darknet19Predictor(Darknet19())
serializers.load_hdf5(weight_file, model) # load saved model
model.predictor.train = False
# forward
x_data = img[np.newaxis, :, :, :]
x = Variable(x_data)
if hasattr(cuda, "cupy"):
cuda.get_device(0).use()
model.to_gpu()
x.to_gpu()
y = model.predict(x).data
if hasattr(cuda, "cupy"):
y = y.get()
predicted_order = np.argsort(-y.flatten())
for index in predicted_order:
cls = labels[index]
prob = y.flatten()[index] * 100
print("%16s : %.2f%%" % (cls, prob))
def __call__(self, x, y):
y = Variable(np.array(y, dtype=np.float32))
pred, _, _ = self.prediction(x)
return F.mean_squared_error(pred, y)
for i in dir_lists:
sub_dirs = os.listdir(argv[3]+'/'+i+'/')
for j in xp.random.permutation(range(len(sub_dirs))):
img = Image.open(argv[3]+'/'+i+'/'+sub_dirs[j])
img = img.resize((input_size,input_size)).convert('RGB')
img = xp.asarray(img,dtype=xp.float32).transpose((2,0,1))/255.
train_data += [img]
train_label += [dir_lists.index(i)]
for e in range(epoch):
train_data_sub = []
train_label_sub = []
for i in xp.random.permutation(range(len(train_data))):
train_data_sub += [train_data[i]]
train_label_sub += [train_label[i]]
print('epoch',e)
for i in range(0,len(train_data_sub),batch):
x = Variable(xp.asarray(train_data_sub[i:i+batch],dtype=xp.float32))
t = Variable(xp.asarray(train_label_sub[i:i+batch]))
y,loss = net(x,t)
net.cleargrads()
loss.backward()
optimizer.update()
print(loss.data)
if e % 10 == 0:
serializers.save_npz('model/model.npz',net)
def loss_func_adv_gen(self, y_fake):
target = Variable(self.xp.full(y_fake.data.shape, 1.0).astype('f'))
return F.mean_squared_error(y_fake, target)
def mse(self, x, y, undo_norm):
y = Variable(np.array(y, dtype=np.float32))
pred, attention_ecfp, attention_fcfp = self.prediction(x)
pred = undo_norm(pred)
return F.mean_squared_error(pred, y), attention_ecfp, attention_fcfp
def loss_func_adv_dis_real(self, y_real):
target = Variable(self.xp.full(y_real.data.shape, 1.0).astype('f'))
return F.mean_squared_error(y_real, target)
def train_dcgan_labeled(gen, dis, epoch0=0):
o_gen = optimizers.Adam(alpha=0.0002, beta1=0.5)
o_dis = optimizers.Adam(alpha=0.0002, beta1=0.5)
o_gen.setup(gen)
o_dis.setup(dis)
o_gen.add_hook(chainer.optimizer.WeightDecay(0.00001))
o_dis.add_hook(chainer.optimizer.WeightDecay(0.00001))
zvis = (xp.random.uniform(-1, 1, (100, nz), dtype=np.float32))
for epoch in xrange(epoch0, n_epoch):
perm = np.random.permutation(n_train)
sum_l_dis = np.float32(0)
sum_l_gen = np.float32(0)
for i in xrange(0, n_train, batchsize):
# discriminator
# 0: from s_dataset
# 1: from s_dataset encode decode
# 2: from s_dataset encode decode
#print "load image start ", i
sx = np.zeros((batchsize, 3, 96, 96), dtype=np.float32)
tx = np.zeros((batchsize, 3, 96, 96), dtype=np.float32)
for j in range(batchsize):
try:
s_rnd = np.random.randint(len(s_dataset))
t_rnd = np.random.randint(len(t_dataset))
s_rnd2 = np.random.randint(2)
t_rnd2 = np.random.randint(2)
s_img = np.asarray(
Image.open(StringIO(
s_dataset[s_rnd])).convert('RGB')).astype(
np.float32).transpose(2, 0, 1)
t_img = np.asarray(
Image.open(StringIO(
s_dataset[t_rnd])).convert('RGB')).astype(
np.float32).transpose(2, 0, 1)
if s_rnd2 == 0:
sx[j, :, :, :] = (s_img[:, :, ::-1] - 128.0) / 128.0
else:
sx[j, :, :, :] = (s_img[:, :, :] - 128.0) / 128.0
if t_rnd2 == 0:
tx[j, :, :, :] = (t_img[:, :, ::-1] - 128.0) / 128.0
else:
tx[j, :, :, :] = (t_img[:, :, :] - 128.0) / 128.0
except:
print 'read image error occured', fs[t_rnd]
#print "load image done"
# train generator
sx = Variable(cuda.to_gpu(sx))
tx = Variable(cuda.to_gpu(tx))
sx2, sz = gen(sx)
tx2, tz = gen(tx)
sx3, sz2 = gen(sx2)
L_tid = F.mean_squared_error(tx, tx2)
L_const = F.mean_squared_error(sz, sz2)
L_tv = (((sx2[:, 1:] - sx2)**2 + (sx2[:, :, 1:] - sx2)**2) +
((tx2[:, 1:] - tx2)**2 +
(tx2[:, :, 1:] - tx2)**2)**0.5) / float(batchsize)
# train discriminator
yl_sx2 = dis(sx2)
yl_tx2 = dis(tx2)
yl_tx = dis(tx)
L_dis = F.softmax_cross_entropy(
yl_sx2, Variable(xp.zeros(batchsize, dtype=np.int32)))
L_dis += F.softmax_cross_entropy(
yl_tx2, Variable(xp.ones(batchsize, dtype=np.int32)))
L_dis += F.softmax_cross_entropy(
yl_tx, Variable(xp.ones(batchsize, dtype=np.int32) * 2))
L_gang = (
F.softmax_cross_entropy(
sx2, Variable(xp.ones(batchsize, dtype=np.int32) * 2)) +
F.softmax_cross_entropy(
tx2, Variable(xp.ones(batchsize, dtype=np.int32) * 2)))
L_gen = L_gang + alpha * L_const + beta * L_tid + gamma * L_tv
#print "forward done"
o_gen.zero_grads()
L_gen.backward()
o_gen.update()
o_dis.zero_grads()
L_dis.backward()
o_dis.update()
sum_l_gen += L_gen.data.get()
sum_l_dis += L_dis.data.get()
#print "backward done"
if i % image_save_interval == 0:
pylab.rcParams['figure.figsize'] = (16.0, 16.0)
pylab.clf()
vissize = 100
z = zvis
z[50:, :] = (xp.random.uniform(-1,
1, (50, nz),
dtype=np.float32))
z = Variable(z)
x = gen(z, test=True)
x = x.data.get()
for i_ in range(100):
tmp = ((np.vectorize(clip_img)(x[i_, :, :, :]) + 1) /
2).transpose(1, 2, 0)
pylab.subplot(10, 10, i_ + 1)
pylab.imshow(tmp)
pylab.axis('off')
pylab.savefig('%s/vis_%d_%d.png' % (out_image_dir, epoch, i))
serializers.save_hdf5(
"%s/dcgan_model_dis_%d.h5" % (out_model_dir, epoch), dis)
serializers.save_hdf5(
"%s/dcgan_model_gen_%d.h5" % (out_model_dir, epoch), gen)
serializers.save_hdf5(
"%s/dcgan_state_dis_%d.h5" % (out_model_dir, epoch), o_dis)
serializers.save_hdf5(
"%s/dcgan_state_gen_%d.h5" % (out_model_dir, epoch), o_gen)
print 'epoch end', epoch, sum_l_gen / n_train, sum_l_dis / n_train
def visualization(trainer):
updater = trainer.updater
# batch_x = updater.get_iterator('main').next()
# batch_y = updater.get_iterator('train_B').next()
batch_x = test_A_iter.next()
batch_y = test_B_iter.next()
batchsize = len(batch_x)
fig = plt.figure(figsize=(9, 6 * batchsize))
gs = gridspec.GridSpec(2 * batchsize, 2, wspace=0.1, hspace=0.1)
x = Variable(updater.converter(batch_x, updater.device))
y = Variable(updater.converter(batch_y, updater.device))
with chainer.using_config('train', False):
with chainer.function.no_backprop_mode():
if len(models) == 3:
# models = (enc_x, enc_y, dec_y)
x_y = models[2](models[0](x)) #
else: # (gen_g, gen_f)
x_y = models[0](x)
# x_y_x = models[1](x_y)
for i, var in enumerate([x, x_y]):
# for i, var in enumerate([x, x_y, x_y_x]):
imgs = postprocess(var)
for j in range(batchsize):
ax = fig.add_subplot(gs[j * 2, i])
ax.imshow(imgs[j],
interpolation='none',
cmap='gray',
vmin=0,
vmax=1)
ax.set_xticks([])
ax.set_yticks([])
with chainer.using_config('train', False):
with chainer.function.no_backprop_mode():
if len(models) == 3:
# models = (enc_x, enc_y, dec_y)
y_z = models[1](y)
y_y = models[2](y_z)
else: # (gen_g, gen_f)
y_x = models[1](y)
y_y = models[0](y_x)
for i, var in enumerate([y, y_y]):
# for i, var in enumerate([y, y_x, y_x_y]):
imgs = postprocess(var)
for j in range(batchsize):
ax = fig.add_subplot(gs[j * 2 + 1, i])
ax.imshow(imgs[j],
interpolation='none',
cmap='gray',
vmin=0,
vmax=1)
ax.set_xticks([])
ax.set_yticks([])
gs.tight_layout(fig)
plt.savefig(os.path.join(test_image_folder,
'epoch{:d}.jpg'.format(updater.epoch)),
dpi=200)
plt.close()
import numpy as np
from chainer import cuda, Function, FunctionSet, gradient_check, Variable, optimizers
import chainer.functions as F
x_data = np.array([[1,2,3], [4,5,6]], dtype=np.float32)
x = Variable(x_data)
f = F.Linear(3, 2)
y = f(x)
y.grad = np.ones((2,2), dtype=np.float32)
y.backward()
# ------------------------------------------------------
model = FunctionSet(
l1 = F.Linear(4, 3),
l2 = F.Linear(3, 2),
)
x = Variable(np.array([[1,2,3,4], [4,5,6,7]], dtype=np.float32))
h1 = model.l1(x)
h2 = model.l2(h1)
h2.grad = np.ones((2,2), dtype=np.float32)
h2.backward()
def get_predata(self, x):
return self.predict(Variable(x.astype(np.float32).reshape(len(x),
1))).data
class MLP(chainer.Chain): # MultiLayer Perceptron
def __init__(self, n_units, n_out):
super(MLP, self).__init__(
# the size of the inputs to each layer will be inferred
l1=L.Linear(None, n_units), # n_in -> n_units
l2=L.Linear(None, n_units), # n_units -> n_units
l3=L.Linear(None, n_out), # n_units -> n_out
)
def __call__(self, x):
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
return self.l3(h2)
model = MLP(5, 2)
x = Variable(np.ones((3, 5), dtype=np.float32))
y = model(x)
print("SDfdf")
print(y.data)
xp = cuda.cupy
print(cuda.get_device_from_id(0).use())
print(model.to_gpu())
x_gpu = cuda.cupy.array([1, 2, 3, 4, 5])
def total_variation(x):
xp = cuda.get_array_module(x.data)
b, ch, h, w = x.data.shape
wh = Variable(xp.asarray([[[[1], [-1]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[1], [-1]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[1], [-1]]]], dtype=np.float32))
ww = Variable(xp.asarray([[[[1, -1]], [[0, 0]], [[0, 0]]], [[[0, 0]], [[1, -1]], [[0, 0]]], [[[0, 0]], [[0, 0]], [[1, -1]]]], dtype=np.float32))
return F.sum(F.convolution_2d(x, W=wh) ** 2) + F.sum(F.convolution_2d(x, W=ww) ** 2)
def main(args):
model_path = args.MODEL_PATH
all_data_path = args.ALL_DATA_PATH
all_feature_path = args.ALL_FEATURE_PATH
save_path = args.SAVE_PATH
with open(args.WORD2ID_PATH, 'rb') as f:
word_id_dic = pickle.load(f)
bos = word_id_dic['<s>']
eos = word_id_dic['</s>']
unk = word_id_dic['<unk>']
id2word = {word_id_dic[x]: x for x in word_id_dic.keys()}
print('data loading...')
with open(all_data_path, 'rb') as f:
all_data = pickle.load(f)
with open(all_feature_path, 'rb') as f:
all_features = pickle.load(f)
print('data loaded!')
test_features, test_qa_ids, test_target_vecs = create_data(all_data, all_features, 'test')
feature_num = 2005
hidden_num = 1024
vocab_num = len(word_id_dic)
attr_num = 5
CaptionNet = ImageCaption(vocab_num, attr_num, feature_num, hidden_num)
serializers.load_hdf5(model_path, CaptionNet)
CaptionNet.to_gpu(gpu_device)
beam_width = 3
max_length = 100
question_list = []
for i in tqdm(range(len(test_qa_ids))):
qa_id = test_qa_ids[i]
target_vec = test_target_vecs[i]
target_var = Variable(xp.array([target_vec], dtype=xp.float32))
concat_feature = test_features[i]
feature_var = Variable(xp.array([concat_feature], dtype=xp.float32))
with chainer.using_config('train', False), chainer.no_backprop_mode():
CaptionNet.image_init(feature_var)
candidates = [(CaptionNet, [bos], 0)]
next_candidates = beam_search(candidates, target_var, norm=True)
for j in range(max_length):
next_candidates = beam_search(next_candidates, target_var, norm=True)
if all([x[1][-1] == eos for x in next_candidates]):
break
result = [k[1] for k in next_candidates]
tokens = [id2word[token_id] for token_id in result[0][1:-1]]
question_list.append([qa_id, tokens])
all_list = []
for each_question in question_list:
each_dic = {}
qa_id = each_question[0]
question = each_question[1]
join_question = (' '.join([word + '' for word in question]) + '?').capitalize()
each_dic['id'] = qa_id
each_dic['image_id'] = qa_id
each_dic['caption'] = join_question
all_list.append(each_dic)
with open(save_path, 'w') as f:
json.dump(all_list, f)
