def test_save_loss_graphs_no_class_weight(self): x = np.random.uniform(-1, 1, self.x_shape) x = Variable(x.astype(np.float32)) t = np.random.randint( 0, 12, (self.x_shape[0], self.x_shape[2], self.x_shape[3])) t = Variable(t.astype(np.int32)) for depth in six.moves.range(1, self.n_encdec + 1): model = segnet.SegNet(n_encdec=self.n_encdec, n_classes=12, in_channel=self.x_shape[1]) model = segnet.SegNetLoss(model, class_weight=None, train_depth=depth) y = model(x, t) cg = build_computational_graph([y], variable_style=_var_style, function_style=_func_style).dump() for e in range(1, self.n_encdec + 1): self.assertTrue( 'encdec{}'.format(e) in model.predictor._children) fn = 'tests/SegNet_xt_depth-{}_{}.dot'.format(self.n_encdec, depth) if os.path.exists(fn): continue with open(fn, 'w') as f: f.write(cg) subprocess.call('dot -Tpng {} -o {}'.format( fn, fn.replace('.dot', '.png')), shell=True)
def get_xt(self): x = np.random.uniform(-1, 1, self.x_shape) x = Variable(x.astype(np.float32)) t = np.random.randint( 0, self.n_classes, (self.x_shape[0], self.x_shape[2], self.x_shape[3])) t = Variable(t.astype(np.int32)) return x, t
def test(): args = parse_args() cfg = Config.from_file(args.config) data_path = cfg.test.source_data out = cfg.test.out model_path = cfg.test.gen_path print('GPU: {}'.format(args.gpu)) # number of gesture classes and users n_gesture = cfg.train.n_gesture n_user = len(cfg.train.dataset_dirs) n_style = n_gesture if cfg.style == 'gesture' else n_user ## Import generator model gen = getattr(models, cfg.train.generator.model)(cfg.train.generator, n_style=n_style) serializers.load_npz(model_path, gen) print('') print(f'loading generator weight from {model_path}') ## Set GPU if args.gpu >= 0: # Make a specified GPU current chainer.backends.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() test_data = data_load(data_path, ges_class=cfg.test.ges_class) test_data = np.expand_dims(test_data, axis=1) style_label = np.zeros((test_data.shape[0], n_style * 2, 1, 1)) source = cfg.test.ges_class if cfg.style == 'gesture' else cfg.source_user target = cfg.test.target_style style_label[:, source] += 1 style_label[:, target + n_style] += 1 test_data = Variable(cuda.to_gpu(test_data.astype(np.float32))) style_label = Variable(cuda.to_gpu(style_label.astype(np.float32))) with chainer.using_config('train', False), chainer.using_config( 'enable_backprop', False): gen_data = gen(test_data, style_label) gen_data.to_cpu() if cfg.style == 'gesture': save_path = f'./{out}/user{cfg.source_user}/ges{target}_from_ges{source}' else: save_path = f'./{out}/user{target}/ges{cfg.test.ges_class}_from_user{source}' if not os.path.exists(os.path.dirname(save_path)): os.makedirs(os.path.dirname(save_path)) print('saving generated data to ' + save_path + '.npy') np.save(save_path, gen_data.data)
def real_batch(self, iterator): batch = iterator.next() x, y = self.converter(batch, self.device) c = x[:, -3:, :, :] x = x[:, :-3, :, :] #cast 16bit -> 32bit (cannot use tensor core) x = Variable(x.astype('float32')) y = Variable(y.astype('float32')) c = Variable(c.astype('float32')) return x, y, c
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 real_batch(self, iter_key='main'): batch = self.get_iterator(iter_key).next() batch = self.converter(batch, self.device) if isinstance(batch, tuple) or isinstance(batch, list): x, t = batch #16bit -> 32bit (not use tensor core) x = Variable(x.astype('float32')) t = Variable(t.astype('float32')) return x, t x = Variable(batch.astype('float32')) return x, None
def compute_loss(self, state, action, reward, next_state, episode_ends): batchsize = state.shape[0] xp = self.dqn.model.xp with chainer.using_config("train", True): q = self.dqn.compute_q_value(state) with chainer.no_backprop_mode(): max_target_q_data = self.dqn.compute_target_q_value( next_state).data max_target_q_data = xp.amax(max_target_q_data, axis=1) t = reward + (1 - episode_ends) * self.discount_factor * max_target_q_data t = Variable(xp.reshape(t.astype(xp.float32), (-1, 1))) y = functions.reshape(functions.select_item(q, action), (-1, 1)) if self.clip_loss: loss = functions.huber_loss(t, y, delta=1.0) else: loss = functions.mean_squared_error(t, y) / 2 loss = functions.sum(loss) # check NaN loss_value = float(loss.data) if loss_value != loss_value: import pdb pdb.set_trace() return loss
def make_img(self, x, l, num_lm, random=0): if random == 0: lm = Variable(xp.clip(l.data, 0, 1)) else: eps = xp.random.normal(0, 1, size=l.data.shape).astype(xp.float32) lm = xp.clip(l.data + eps * xp.sqrt(self.vars), 0, 1) lm = Variable(lm.astype(xp.float32)) if self.use_gpu: xm = make_sampled_image.generate_xm_const_size_gpu( lm.data, self.gsize, x.data, num_lm, g_size=self.gsize, img_size=self.img_size) else: xm = make_sampled_image.generate_xm_const_size( lm.data, self.gsize, x.data, num_lm, g_size=self.gsize, img_size=self.img_size) return xm, lm
def make_img(self, x, l, s, num_lm, random=0): if random == 0: lm = Variable(xp.clip(l.data, 0, 1)) sm = Variable(xp.clip(s.data, 0, 1)) else: eps = xp.random.normal(0, 1, size=l.data.shape).astype(xp.float32) epss = xp.random.normal(0, 1, size=s.data.shape).astype(xp.float32) sm = xp.clip((s.data + xp.sqrt(self.var) * epss), 0, 1).astype(xp.float32) lm = xp.clip(l.data + eps * xp.sqrt(self.vars), 0, 1) sm = Variable(sm) lm = Variable(lm.astype(xp.float32)) if self.use_gpu: xm = make_sampled_image.generate_xm_rgb_gpu(lm.data, sm.data, x, num_lm, g_size=self.gsize) else: xm = make_sampled_image.generate_xm_rgb(lm.data, sm.data, x, num_lm, g_size=self.gsize) return xm, lm, sm
def pool1(self, x): x = Variable( x.astype(cp.float32).reshape(-1, 1, self.atomsize, self.lensize)) h = F.leaky_relu(self.bn1(self.conv1(x))) # 1st conv h = F.average_pooling_2d(h, (self.k2, 1), stride=self.s2, pad=(self.k2 // 2, 0)) # 1st pooling return h.data
def fingerprint(self, x): x = Variable( x.astype(cp.float32).reshape(-1, 1, self.atomsize, self.lensize)) h = F.leaky_relu(self.bn1(self.conv1(x))) # 1st conv h = F.average_pooling_2d(h, (self.k2, 1), stride=self.s2, pad=(self.k2 // 2, 0)) # 1st pooling h = F.leaky_relu(self.bn2(self.conv2(h))) # 2nd conv h = F.average_pooling_2d(h, (self.k3, 1), stride=self.s3, pad=(self.k3 // 2, 0)) # 2nd pooling h = F.max_pooling_2d(h, (self.l4, 1)) # grobal max pooling, fingerprint return h.data
def test(gen_infogan,gen_cgan,n_tests,n_z_infogan, n_z_cgan, n_continuous): # cinfogan z_infogan = np.random.uniform(-2, 2, (n_tests, n_z_infogan+n_continuous)) z_infogan = Variable(np.array(z_infogan, dtype=np.float32)) # cgan z_cgan = np.random.uniform(-2, 2, (n_tests, n_z_cgan)) z_cgan = Variable(np.array(z_cgan, dtype=np.float32)) x = np.random.uniform(0.0, 1.0, (n_tests,12)); x = Variable(x.astype(np.float32)) infogan_xi= gen_infogan(z_infogan,x) cgan_xi = gen_cgan(z_cgan,x) return collisions_measure(x.data,cgan_xi.data,infogan_xi.data)
def make_img(self, x, l, num_lm, random=0): s = xp.log10(xp.ones((1, 1)) * self.gsize / self.img_size) + 1 sm = xp.repeat(s, num_lm, axis=0) if random == 0: lm = Variable(xp.clip(l.data, 0, 1)) else: eps = xp.random.normal(0, 1, size=l.data.shape).astype(xp.float32) lm = xp.clip(l.data + eps * xp.sqrt(self.vars), 0, 1) lm = Variable(lm.astype(xp.float32)) if self.use_gpu: xm = make_sampled_image.generate_xm_rgb_gpu(lm.data, sm, x, num_lm, g_size=self.gsize) else: xm = make_sampled_image.generate_xm_rgb(lm.data, sm, x, num_lm, g_size=self.gsize) return xm, lm
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 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 update_core(self): batch = self._iterators['main'].next() in_arrays = self.converter(batch, self.device) true_x = in_arrays # mnist (200, 1, 28, 28) # create input z as random batchsize = true_x.shape[0] if self.device == 0: z = cuda.cupy.random.normal(size=(batchsize, self.z_dim, 1, 1), dtype=np.float32) z = Variable(z) else: z = np.random.uniform(-1, 1, (batchsize, self.z_dim, 1, 1)) z = z.astype(dtype=np.float32) z = Variable(z) # G -> x1 -> y of gen # + -> X -> D -> split # Truedata -> x2 -> y of true data gen_output = self.gen(z) # gen_output (200, 1, 28, 28) x = F.concat((gen_output, true_x), 0) # gen_output + true_data = (400, 1, 28, 28) dis_output = self.dis(x) y_gen, y_data = F.split_axis(dis_output, 2, 0) # 0~1 value (200, 1, 1, 1) # DがGの生成物を1(間違い), TrueDataを0(正しい)と判定するように学習させる # sigmoid_cross_entropy(x, 0) == softplus(x) # sigmoid_cross_entropy(x, 1) == softplus(-x) loss_gen = F.sum(F.softplus(-y_gen)) loss_data = F.sum(F.softplus(y_data)) loss = (loss_gen + loss_data) / batchsize for optimizer in self._optimizers.values(): optimizer.target.cleargrads() loss.backward() for optimizer in self._optimizers.values(): optimizer.update() reporter.report({'loss':loss, 'gen/loss':loss_gen / batchsize, 'dis/loss':loss_data / batchsize}) save_image(gen_output, self.epoch, self.device)
def test_save_normal_graphs(self): x = np.random.uniform(-1, 1, self.x_shape) x = Variable(x.astype(np.float32)) for depth in six.moves.range(1, self.n_encdec + 1): model = segnet.SegNet(n_encdec=self.n_encdec, in_channel=self.x_shape[1]) y = model(x, depth) cg = build_computational_graph([y], variable_style=_var_style, function_style=_func_style).dump() for e in range(1, self.n_encdec + 1): self.assertTrue('encdec{}'.format(e) in model._children) fn = 'tests/SegNet_x_depth-{}_{}.dot'.format(self.n_encdec, depth) if os.path.exists(fn): continue with open(fn, 'w') as f: f.write(cg) subprocess.call('dot -Tpng {} -o {}'.format( fn, fn.replace('.dot', '.png')), shell=True)
def __call__(self, X): # generate random values R = np.random.randn(X.data.shape[0], self.rand_sz) R = Variable(R.astype("float32")) # attach random to the inputs h = F.concat([R, X]) #h = R h = self.ipt(h) #h = F.dropout(h) y = self.out(h) # prior knowledge: environment observation is one - hot vector obs = F.softmax(y[:, :-2]) # prior knowledge: reward is in [0,1] rew = F.sigmoid(y[:, [-2]]) fin = F.sigmoid(y[:, [-1]]) y = F.concat([obs, rew, fin]) return y
def __call__(self, x, t): x = Variable(x.astype(np.float32).reshape(x.shape[0], 4)) t = Variable(t.astype("i")) y = self.forward(x) return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def predict(self, x): x = Variable(x.astype(np.float32).reshape(x.shape[0],1)) y = self.forward(x) return y.data
def main(): # Set the number of epochs parser = argparse.ArgumentParser(description='IaGo:') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=0, help='GPU ID to be used') args = parser.parse_args() # Model definition model = network.Value() optimizer = optimizers.Adam() optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(5e-4)) cuda.get_device(args.gpu).use() test_x = np.load('./value_data/npy/states_test.npy') test_y = np.load('./value_data/npy/results_test.npy') test_x = np.stack([test_x==1, test_x==2], axis=0).astype(np.float32) test_x = Variable(cuda.to_gpu(test_x.transpose(1,0,2,3))) test_y = Variable(cuda.to_gpu(test_y.astype(np.float32))) # Load train dataset train_x = np.load('./value_data/npy/states.npy') train_y = np.load('./value_data/npy/results.npy') train_size = train_y.shape[0] minibatch_size = 4096 # 2**12 # Learing loop for epoch in tqdm(range(args.epoch)): model.to_gpu(args.gpu) # Should be unnecessary... #chainer.config.train = True #chainer.config.enable_backprop = True # Shuffle train dataset rands = np.random.choice(train_size, train_size, replace=False) train_x = train_x[rands,:,:] train_y = train_y[rands] # Minibatch learning for idx in tqdm(range(0, train_size, minibatch_size)): x = train_x[idx:min(idx+minibatch_size, train_size), :, :] x = np.stack([x==1, x==2], axis=0).astype(np.float32) x = Variable(cuda.to_gpu(x.transpose(1,0,2,3))) y = train_y[idx:min(idx+minibatch_size, train_size)] y = Variable(cuda.to_gpu(y.astype(np.float32))) train_pred = model(x) train_loss = mean_squared_error(train_pred, y) model.cleargrads() train_loss.backward() optimizer.update() # Calculate loss with chainer.using_config('train', False): with chainer.using_config('enable_backprop', False): test_pred = model(test_x) test_loss = mean_squared_error(test_pred, test_y) print('\nepoch :', epoch, ' loss :', test_loss) # Log with open("./log_value.txt", "a") as f: f.write(str(test_loss)[9:15]+", \n") # Save models model.to_cpu() serializers.save_npz('./models/value_model.npz', model) serializers.save_npz('./models/value_optimizer.npz', optimizer)
def __call__(self, x_data, y_data, train=True, n_patches=32): if not isinstance(x_data, Variable): x = Variable(x_data, volatile=not train) else: x = x_data x_data = x.data #self.n_images = y_data.shape[0] self.n_images = 1 self.n_patches = x_data.shape[0] # print x_data.shape[0] # print y_data.shape[0] self.n_patches_per_image = self.n_patches / self.n_images #self.n_patches_per_image = 32 h = F.relu(self.conv1(x)) h = F.relu(self.conv2(h)) h = F.max_pooling_2d(h, 2) h = F.relu(self.conv3(h)) h = F.relu(self.conv4(h)) h = F.max_pooling_2d(h, 2) h = F.relu(self.conv5(h)) h = F.relu(self.conv6(h)) h = F.max_pooling_2d(h, 2) h = F.relu(self.conv7(h)) h = F.relu(self.conv8(h)) h = F.max_pooling_2d(h, 2) h = F.relu(self.conv9(h)) h = F.relu(self.conv10(h)) h = F.max_pooling_2d(h, 2) h_ = h self.h = h_ h = F.dropout(F.relu(self.fc1(h_)), train=train, ratio=0.5) h = self.fc2(h) if self.top == "weighted": a = F.dropout(F.relu(self.fc1_a(h_)), train=train, ratio=0.5) a = F.relu(self.fc2_a(a)) + 0.000001 t = Variable(y_data, volatile=not train) self.weighted_loss(h, a, t) elif self.top == "patchwise": a = xp.ones_like(h.data) #y_data.data, to make y_data do not be a Variable t = xp.repeat(y_data.data, 1) t = xp.array(t.astype(np.float32)) #print h.data #print len(t) #print t self.patchwise_loss(h, a, t) if train: reporter.report({'loss': self.loss}, self) #print 'self.lose:', self.loss.data return self.loss else: return self.loss, self.y
total_loss, acc = model(x, y) return total_loss # model.save_model("./model.npz",save_format="npz") model.load_model("./model.npz", load_format="npz") serializers.load_npz("./opt.npz", opt) step = 0 while True: # x = Variable(data=np.zeros(shape=[10, 3, 60, 160], dtype=np.float32)) # y = Variable(data=np.zeros(shape=[10, 5], dtype=np.int32)) x, y = yzmData.nextBatch(testOrTrain="train", batch_size=64) x = Variable(x.astype(np.float32)) y = Variable(y.astype(np.int32)) x.to_gpu(0) y.to_gpu(0) opt.update(loss, x.data, y.data) print("step:%d\ttotal_loss:%f\terro_rate:%f" % (step, model.loss.data, model.acc.data)) if step % 100 == 0: model.save_model("./model.npz", save_format="npz") serializers.save_npz("./opt.npz", opt) test_x, test_t = yzmData.nextBatch(testOrTrain="test", batch_size=40) test_x = Variable(test_x.astype(np.float32)) test_t = Variable(test_t.astype(np.int32)) test_x.to_gpu(0)
T, F = s_x.shape Y = np.zeros((8, T, F), dtype=np.complex64) Y[ch-1, :, :] = s_x s_x_abs = 20 * log_sp(np.abs(s_x)) s_x_abs = stack_features(s_x_abs.astype(np.float32), 5) s_x_abs = Variable(s_x_abs) if args.gpu >= 0: s_x_abs.to_gpu(args.gpu) s_x_abs_list.append(s_x_abs) elif args.single == 1: audio_data = read_audio(cur_line) fx, tx, s_x = signal.stft(audio_data, fs=16000, nperseg=512, noverlap=512-128, nfft=512) s_x = np.transpose(s_x) s_x_abs = 20 * log_sp(np.abs(s_x)) s_x_abs = stack_features(s_x_abs.astype(np.float32), 5) s_x_abs = Variable(s_x_abs) if args.gpu >= 0: s_x_abs.to_gpu(args.gpu) s_x_abs_list.append(s_x_abs) with chainer.no_backprop_mode(): X = model.predict(s_x_abs_list) if args.gpu >= 0: X.to_cpu() if args.single == 0: xs = X.data xs = np.reshape(xs, (8, xs.shape[0] // 8, xs.shape[1])) taps = 10 xs_power = np.square(exp_sp(xs/20)) Y_hat = np.copy(Y)
def __call__(self, x, t): x = Variable(x.astype(np.float32).reshape(x.shape[0],1)) t = Variable(t.astype(np.float32).reshape(t.shape[0],1)) return F.mean_squared_error(self.forward(x), t)
def layer1(self, x): x = Variable( x.astype(cp.float32).reshape(-1, 1, self.atomsize, self.lensize)) h = self.bn1(self.conv1(x)) # 1st conv return h.data