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)