def main(): xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy hyperparams = Hyperparameters(args.snapshot_path) hyperparams.print() num_bins_x = 2.0**hyperparams.num_bits_x encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() with chainer.no_backprop_mode() and encoder.reverse() as decoder: while True: z = xp.random.normal(0, args.temperature, size=( 1, 3, ) + hyperparams.image_size).astype("float32") x, _ = decoder.reverse_step(z) x_img = make_uint8(x.data[0], num_bins_x) plt.imshow(x_img, interpolation="none") plt.pause(.01)
def setInitAllParameters(self, optimizer, init_type="default", init_scale=0.1): sys.stdout.write("############ Current Parameters BEGIN\n") self.printAllParameters(optimizer) sys.stdout.write("############ Current Parameters END\n") if init_type == "uniform": sys.stdout.write("# initializer is [uniform] [%f]\n" % init_scale) t_initializer = chainer.initializers.Uniform(init_scale) named_params = sorted(optimizer.target.namedparams(), key=lambda x: x[0]) for n, p in named_params: with cuda.get_device(p.data): p.copydata(chainer.Parameter(t_initializer, p.data.shape)) elif init_type == "normal": sys.stdout.write("# initializer is [normal] [%f]\n" % init_scale) t_initializer = chainer.initializers.Normal(init_scale) named_params = sorted(optimizer.target.namedparams(), key=lambda x: x[0]) for n, p in named_params: with cuda.get_device(p.data): p.copydata(chainer.Parameter(t_initializer, p.data.shape)) else: # "default" sys.stdout.write("# initializer is [defalit] [%f]\n" % init_scale) named_params = sorted(optimizer.target.namedparams(), key=lambda x: x[0]) for n, p in named_params: with cuda.get_device(p.data): p.data *= init_scale self.printAllParameters(optimizer, init_type, init_scale) return 0
def _create_new_model(self, steps_list, epoch_num=None, batch_size=2048): epoch_num = self.default_params[ 'create_new_model_epoch_num'] if epoch_num is None else epoch_num model = DualNet() model.load(self.model_filename) if self.gpu_device >= 0: cuda.get_device(self.gpu_device).use() model.to_gpu(self.gpu_device) optimizer = chainer.optimizers.Adam() optimizer.setup(model) for i in range(epoch_num): x_train, y_train_policy, y_train_value = self._get_train_batch( steps_list, batch_size) y_policy, y_value = model(x_train) model.cleargrads() loss = F.mean_squared_error(y_policy, y_train_policy) + F.mean_squared_error( y_value, y_train_value) loss.backward() optimizer.update() print("[new nodel] epoch: {} / {}, loss: {}".format( i + 1, epoch_num, loss)) if self.gpu_device >= 0: model.to_cpu() return model
def run_inference(model_dir: str, epoch: Optional[int], device: str, metric: str): chainer.config.train = False if device >= 0: cuda.get_device(device).use() set_seed() configs = json.load(open(os.path.join(model_dir, "args"))) snapshot_file, prediction_path = select_snapshot(epoch, metric, model_dir) logger.debug(f"creat prediction into {prediction_path}") vocab = Vocabulary.prepare(configs) num_word_vocab = configs["num_word_vocab"] num_char_vocab = configs["num_char_vocab"] num_tag_vocab = configs["num_tag_vocab"] model = BiLSTM_CRF(configs, num_word_vocab, num_char_vocab, num_tag_vocab) model_path = os.path.join(model_dir, snapshot_file) chainer.serializers.load_npz(model_path, model) logger.debug(f"load {snapshot_file}") if device >= 0: model.to_gpu(device) transformer = DatasetTransformer(vocab) transform = transformer.transform test_iterator = create_iterator( vocab, configs, "test", transform, return_original_sentence=True ) with open(prediction_path, "w", encoding="utf-8") as file: for batch in test_iterator: batch, original_sentences = list(zip(*batch)) in_arrays, t_arrays = converter(batch, device) p_arrays = model.predict(in_arrays) word_sentences, t_tag_sentences = list( zip(*transformer.itransform(in_arrays[0], t_arrays)) ) _, p_tag_sentences = list( zip(*transformer.itransform(in_arrays[0], p_arrays)) ) sentence_gen = zip( word_sentences, t_tag_sentences, p_tag_sentences, original_sentences, ) # NOQA for ws, ts, ps, _os in sentence_gen: for w, t, p, o in zip(ws, ts, ps, _os): w = w.replace(" ", "<WHITESPACE>") o = o.replace(" ", "<WHITESPACE>") if w != o: w = f"{w}({o})" print(f"{w} {t} {p}", file=file) print(file=file)
def main(): xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy hyperparams = Hyperparameters(args.snapshot_path) hyperparams.print() num_bins_x = 2.0**hyperparams.num_bits_x image_size = (28, 28) images = chainer.datasets.mnist.get_mnist(withlabel=False)[0] images = 255.0 * np.asarray(images).reshape((-1, ) + image_size + (1, )) if hyperparams.num_image_channels != 1: images = np.broadcast_to(images, (images.shape[0], ) + image_size + (hyperparams.num_image_channels, )) images = preprocess(images, hyperparams.num_bits_x) dataset = glow.dataset.Dataset(images) iterator = glow.dataset.Iterator(dataset, batch_size=1) print(tabulate([["#image", len(dataset)]])) encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() fig = plt.figure(figsize=(8, 4)) left = fig.add_subplot(1, 2, 1) right = fig.add_subplot(1, 2, 2) with chainer.no_backprop_mode() and encoder.reverse() as decoder: while True: for data_indices in iterator: x = to_gpu(dataset[data_indices]) x += xp.random.uniform(0, 1.0 / num_bins_x, size=x.shape) factorized_z_distribution, _ = encoder.forward_step(x) factorized_z = [] for (zi, mean, ln_var) in factorized_z_distribution: factorized_z.append(zi) # for zi in factorized_z: # noise = xp.random.normal( # 0, 0.2, size=zi.shape).astype("float32") # zi.data += noise rev_x, _ = decoder.reverse_step(factorized_z) x_img = make_uint8(x[0], num_bins_x) rev_x_img = make_uint8(rev_x.data[0], num_bins_x) left.imshow(x_img, interpolation="none") right.imshow(rev_x_img, interpolation="none") plt.pause(.01)
def test_get_device_warning(self): with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cuda.get_device(cuda.cupy.array([1])) assert len(w) == 1 assert w[0].category is DeprecationWarning assert ('get_device is deprecated. Please use get_device_from_id' ' or get_device_from_array instead.' in str(w[0].message))
def test_get_device_warning(self): with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cuda.get_device(cuda.cupy.array([1])) assert len(w) == 1 assert w[0].category is DeprecationWarning assert ('get_device is deprecated. Please use get_device_from_id' ' or get_device_from_array instead.' in str(w[0].message))
def test_get_device_warning(self): with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cuda.get_device(cuda.cupy.array([1])) self.assertEqual(len(w), 1) self.assertIs(w[0].category, DeprecationWarning) self.assertIn( 'get_device is deprecated. Please use get_device_from_id' ' or get_device_from_array instead.', str(w[0].message))
def test_get_device_warning(self): with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cuda.get_device(cuda.cupy.array([1])) self.assertEqual(len(w), 1) self.assertIs(w[0].category, DeprecationWarning) self.assertIn( 'get_device is deprecated. Please use get_device_from_id' ' or get_device_from_array instead.', str(w[0].message))
def main(): xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy hyperparams = Hyperparameters(args.snapshot_path) hyperparams.print() num_bins_x = 2.0**hyperparams.num_bits_x assert args.dataset_format in ["png", "npy"] files = Path(args.dataset_path).glob("*.{}".format(args.dataset_format)) if args.dataset_format == "png": images = [] for filepath in files: image = np.array(Image.open(filepath)).astype("float32") image = preprocess(image, hyperparams.num_bits_x) images.append(image) assert len(images) > 0 images = np.asanyarray(images) elif args.dataset_format == "npy": images = [] for filepath in files: array = np.load(filepath).astype("float32") array = preprocess(array, hyperparams.num_bits_x) images.append(array) assert len(images) > 0 num_files = len(images) images = np.asanyarray(images) images = images.reshape((num_files * images.shape[1], ) + images.shape[2:]) else: raise NotImplementedError dataset = glow.dataset.Dataset(images) iterator = glow.dataset.Iterator(dataset, batch_size=1) print(tabulate([["#image", len(dataset)]])) encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() with chainer.no_backprop_mode() and encoder.reverse() as decoder: for data_indices in iterator: print("data:", data_indices) x = to_gpu(dataset[data_indices]) x += xp.random.uniform(0, 1.0 / num_bins_x, size=x.shape) factorized_z_distribution, _ = encoder.forward_step(x) for (_, mean, ln_var) in factorized_z_distribution: print(xp.mean(mean.data), xp.mean(xp.exp(ln_var.data)))
def main(): xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy model1 = get_model(args.snapshot_path_1, using_gpu) model2 = get_model(args.snapshot_path_2, using_gpu) model3 = get_model(args.snapshot_path_3, using_gpu) num_bins_x, hyperparams = model1[1:] fig = plt.figure(figsize=(12, 4)) left = fig.add_subplot(1, 3, 1) center = fig.add_subplot(1, 3, 2) right = fig.add_subplot(1, 3, 3) while True: z = xp.random.normal(0, args.temperature, size=( 1, 3, ) + hyperparams.image_size).astype("float32") with chainer.no_backprop_mode(): encoder = model1[0] with encoder.reverse() as decoder: hyperparams = model1[2] x, _ = decoder.reverse_step(z) x_img = make_uint8(x.data[0], num_bins_x) left.imshow(x_img, interpolation="none") left.set_title("#channels = {}".format( hyperparams.nn_hidden_channels)) encoder = model2[0] with encoder.reverse() as decoder: hyperparams = model2[2] x, _ = decoder.reverse_step(z) x_img = make_uint8(x.data[0], num_bins_x) center.imshow(x_img, interpolation="none") center.set_title("#channels = {}".format( hyperparams.nn_hidden_channels)) encoder = model3[0] with encoder.reverse() as decoder: hyperparams = model3[2] x, _ = decoder.reverse_step(z) x_img = make_uint8(x.data[0], num_bins_x) right.imshow(x_img, interpolation="none") right.set_title("#channels = {}".format( hyperparams.nn_hidden_channels)) plt.pause(.01)
def load_models(args: argparse.Namespace) -> dict[str, chainer.Chain]: """Load models using a args config Args: args (argparse.Namespace): argparse namespace containing config such as the arch and color Returns: dict[str, chainer.Chain]: Mapping of model names to chainer.Chain models """ ch = 3 if args.color == "rgb" else 1 if args.model_dir is None: model_dir = THISDIR + f"/models/{args.arch.lower()}" else: model_dir = args.model_dir models = {} flag = False if args.method == "noise_scale": model_name = f"anime_style_noise{args.noise_level}_scale_{args.color}.npz" model_path = os.path.join(model_dir, model_name) if os.path.exists(model_path): models["noise_scale"] = srcnn.archs[args.arch](ch) load_npz(model_path, models["noise_scale"]) alpha_model_name = f"anime_style_scale_{args.color}.npz" alpha_model_path = os.path.join(model_dir, alpha_model_name) models["alpha"] = srcnn.archs[args.arch](ch) load_npz(alpha_model_path, models["alpha"]) else: flag = True if args.method == "scale" or flag: model_name = f"anime_style_scale_{args.color}.npz" model_path = os.path.join(model_dir, model_name) models["scale"] = srcnn.archs[args.arch](ch) load_npz(model_path, models["scale"]) if args.method == "noise" or flag: model_name = f"anime_style_noise{args.noise_level}_{args.color}.npz" model_path = os.path.join(model_dir, model_name) if not os.path.exists(model_path): model_name = f"anime_style_noise{args.noise_level}_scale_{args.color}.npz" model_path = os.path.join(model_dir, model_name) models["noise"] = srcnn.archs[args.arch](ch) load_npz(model_path, models["noise"]) if args.gpu >= 0: cuda.check_cuda_available() cuda.get_device(args.gpu).use() for _, model in models.items(): model.to_gpu() return models
def main(): os.makedirs(args.log_directory) os.makedirs(args.model_directory) # GPU usage gp = np gpu_device = args.gpu_device assigned_gpu = gpu_device>=0 if assigned_gpu: cuda.get_device(gpu_device).use() gp = cp # Dataset data_train = read_dataset(args.train_dataset_directory) if args.test_dataset_directory is not None: data_test = read_dataset(args.test_dataset_directory) # # Logging # csv = data_format # csv.load(args.logdirectory) # Optimizer optimizer = chainer.optimizers.Adam(alpha=0.001, beta1=0.9, beta2=0.999, eps=1e-08, eta=1.0, weight_decay_rate=0, amsgrad=False, adabound=False, final_lr=0.1, gamma=0.001) print(optimizer) # Training dataset_size = len(data_train) for epoch in range(args.epochs): print("Epoch: "+str(epoch)) for subset_index,subset in enumerate(data_train): batches = sampler(data, batch_size=args.batch_size) for batch_index, data in enumerate(batches): images, uncertainties = subset[data] z =
def lossfun_multi_leam(self, z, t): with cuda.get_device(z): z_class = z[-self.n_class:] z = z[:-self.n_class] t_class = Variable(cp.array(range(self.n_class))) loss = - (F.mean(t * F.log(z) + (1-t)*F.log1p(-z))) / z.shape[0] + F.softmax_cross_entropy(z_class, t_class) return loss
def print_strings(self, train_mode, epoch, cMBSize, encLen, decLen, start_time, args): with cuda.get_device(self.lossVal): msg0 = 'Epoch: %3d | LL: %9.6f PPL: %10.4f' % ( epoch, float(self.lossVal / max(1, self.procTot)), math.exp(min(10, float(self.lossVal / max(1, self.procTot))))) msg1 = '| gN: %8.4f %8.4f %8.4f' % (self.gnorm, self.gnormLimit, self.pnorm) dt = self.corTot + self.incorTot msg2 = '| acc: %6.2f %8d %8d ' % (float( 100.0 * self.corTot / max(1, dt)), self.corTot, self.incorTot) msg3 = '| tot: %8d proc: %8d | num: %8d %6d %6d ' % ( self.trainsizeTot, self.procTot, self.instanceNum, self.encMaxLen, self.decMaxLen) msg4 = '| MB: %4d %6d %4d %4d | Time: %10.4f' % ( cMBSize, self.batchCount, encLen, decLen, time.time() - start_time) # dev.dataのときは必ず評価,学習データのときはオプションに従う if train_mode == 0: msgA = '%s %s %s %s' % (msg0, msg2, msg3, msg4) # elif args.doEvalAcc > 0: msgA = '%s %s %s %s %s' % (msg0, msg1, msg2, msg3, msg4) # else: # msgA = '%s %s %s %s' % (msg0, msg1, msg3, msg4) return msgA
def objective(trial, train, test, dir): #trialからパラメータを取得 n_unit6 = trial.suggest_int('n_unit6', 4, 2048) n_unit7 = trial.suggest_int('n_unit7', 4, 2048) batch_size = trial.suggest_int('batch_size', 2, 128) class_labels = 12 n_epoch = 20 gpu = 0 #モデルを定義 model = VGG(n_units6=n_unit6, n_units7=n_unit7, class_labels=class_labels) optimizer = create_optimizer(trial, model) cuda.get_device(0).use() model.to_gpu(0) #trainer周りの設定 train_iter = iterators.SerialIterator(train, batch_size) test_iter = iterators.SerialIterator(test, 1, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer, device=gpu) trainer = training.Trainer(updater, (n_epoch, 'epoch'), out=dir) trainer.extend(integrator) trainer.extend(extensions.LogReport()) trainer.extend(extensions.observe_lr()) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'test/main/loss', 'test/main/accuracy', 'elapsed_time', 'lr', ])) trainer.extend(extensions.ProgressBar(update_interval=1)) trainer.extend(extensions.Evaluator(test_iter, model, device=gpu), name='test') #学習の実行 trainer.run() # accuracyを評価指標として用いる return 1 - trainer.observation['test/main/accuracy']
def main(): xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy hyperparams = Hyperparameters(args.snapshot_path) hyperparams.print() num_bins_x = 2.0**hyperparams.num_bits_x encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() temperatures = [0.0, 0.25, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] total = len(temperatures) fig = plt.figure(figsize=(total * 4, 4)) subplots = [] for n in range(total): subplot = fig.add_subplot(1, total, n + 1) subplots.append(subplot) with chainer.no_backprop_mode() and encoder.reverse() as decoder: while True: z_batch = [] for temperature in temperatures: z = np.random.normal(0, temperature, size=(3, ) + hyperparams.image_size).astype("float32") z_batch.append(z) z_batch = np.asanyarray(z_batch) if using_gpu: z_batch = cuda.to_gpu(z_batch) x, _ = decoder.reverse_step(z_batch) for n, (temperature, subplot) in enumerate(zip(temperatures, subplots)): x_img = make_uint8(x.data[n], num_bins_x) # x_img = np.broadcast_to(x_img, (28, 28, 3)) subplot.imshow(x_img, interpolation="none") subplot.set_title("temperature={}".format(temperature)) plt.pause(.01)
def __init__(self, gpuid=-1, alpha=0.5, gamma=0.95, train=True, backprop=True): self.timing = brica.Timing(5, 1, 0) self.agent = self._set_agent(gpuid=gpuid) self.reward = 0 self.time = 0 if gpuid < 0: self.xp = numpy else: print("Use GPU") cuda.get_device(gpuid).use() self.xp = cuda.cupy chainer.config.train = train chainer.config.enable_backprop = backprop
def objective(trial): # Create model instance model = TripletClassifier( MyNeuralNetwork(n_mid_units=mid_size, n_out=out_size)) optimizer = create_optimizer(trial, model) batchsize = trial.suggest_int('batchsize', 10, len(y)) epoch = trial.suggest_int('epoch', 10, 50) # Assign GPU or CPU to the model if gpu_id >= 0: cuda.get_device(gpu_id).use() model.to_gpu(gpu_id) # Define Iterator train_set = datasets.TupleDataset(train_triplet, train_label) test_set = datasets.TupleDataset(test_triplet, test_label) train_iter = iterators.SerialIterator(train_set, batchsize) test_iter = iterators.SerialIterator(test_set, batchsize, repeat=False, shuffle=False) # Define Trainer updater = chainer.training.StandardUpdater(train_iter, optimizer) trainer = chainer.training.Trainer(updater, (epoch, 'epoch')) trainer.extend(chainer.training.extensions.Evaluator(test_iter, model)) log_report_extension = chainer.training.extensions.LogReport(log_name=None) trainer.extend( chainer.training.extensions.PrintReport([ 'epoch', 'main/squared_error', 'validation/main/squared_error', 'main/abs_error', 'validation/main/abs_error', 'elapsed_time' ])) trainer.extend(log_report_extension) trainer.run() log_last = log_report_extension.log[-1] for key, value in log_last.items(): trial.set_user_attr(key, value) val_err = log_report_extension.log[-1]['validation/main/squared_error'] return val_err
def __call__(self, x, finetune=False): if self.gamma is not None: gamma = self.gamma else: with cuda.get_device(self._device_id): gamma = variable.Variable( self.xp.ones(self.avg_mean.shape, dtype=x.dtype)) if self.beta is not None: beta = self.beta else: with cuda.get_device(self._device_id): beta = variable.Variable( self.xp.zeros(self.avg_mean.shape, dtype=x.dtype)) if configuration.config.train: if finetune: self.N += 1 decay = 1. - 1. / self.N else: decay = self.decay func = batch_renormalization.BatchRenormalizationFunction( self.eps, self.avg_mean, self.avg_var, decay, self.rmax, self.dmax, self.freeze_running_statistics) if self.freeze_running_statistics: func.r = self.r func.d = self.d ret = func(x, gamma, beta) if self.freeze_running_statistics and self.r is None: self.r = func.r self.d = func.d self.avg_mean[:] = func.running_mean self.avg_var[:] = func.running_var else: # Use running average statistics or fine-tuned statistics. mean = variable.Variable(self.avg_mean) var = variable.Variable(self.avg_var) ret = batch_renormalization.fixed_batch_renormalization( x, gamma, beta, mean, var, self.eps) return ret
def __call__(self, x, finetune=False): if self.gamma is not None: gamma = self.gamma else: with cuda.get_device(self._device_id): gamma = variable.Variable(self.xp.ones( self.avg_mean.shape, dtype=x.dtype)) if self.beta is not None: beta = self.beta else: with cuda.get_device(self._device_id): beta = variable.Variable(self.xp.zeros( self.avg_mean.shape, dtype=x.dtype)) if configuration.config.train: if finetune: self.N += 1 decay = 1. - 1. / self.N else: decay = self.decay func = batch_renormalization.BatchRenormalizationFunction( self.eps, self.avg_mean, self.avg_var, decay, self.rmax, self.dmax, self.freeze_running_statistics) if self.freeze_running_statistics: func.r = self.r func.d = self.d ret = func(x, gamma, beta) if self.freeze_running_statistics and self.r is None: self.r = func.r self.d = func.d self.avg_mean[:] = func.running_mean self.avg_var[:] = func.running_var else: # Use running average statistics or fine-tuned statistics. mean = variable.Variable(self.avg_mean) var = variable.Variable(self.avg_var) ret = batch_renormalization.fixed_batch_renormalization( x, gamma, beta, mean, var, self.eps) return ret
def auc_fun_leam(self, z, t): aucs = [] with cuda.get_device(z): z = z[:-self.n_class] t = np.array(chainer.cuda.to_cpu(t)) z = chainer.cuda.to_cpu(z.data) for i in range(6): fpr, tpr, thresholds = metrics.roc_curve(t[::,i], z[::,i]) aucs.append(metrics.auc(fpr, tpr)) print(aucs) return Variable(np.array(sum(aucs)/len(aucs)))
def auc_fun_cnn(z, t): aucs = [] with cuda.get_device(z): z = z t = chainer.cuda.to_cpu(t) z = chainer.cuda.to_cpu(z.data) for i in range(6): fpr, tpr, thresholds = metrics.roc_curve(t[::,i], z[::,i]) aucs.append(metrics.auc(fpr, tpr)) return Variable(np.array(sum(aucs)/len(aucs)))
def update_core(self): # get_optimizer mehtod allows to get optimizer gen_optimizer = self.get_optimizer("gen") critic_optimizer = self.get_optimizer("critic") # obtain batch data # get_iterator("main") is SerialIterator so next() returns next minibatch batch = self.get_iterator("main").next() batch_size = len(batch) # start with the critic at optimum even in the first iterations. if self.iteration < 25 or self.iteration % 500 == 0: n_critic = 100 else: n_critic = self.n_critic # optimize Critic for _ in range(n_critic): # prepare the minibatch real data x_real = self.converter( batch, self.device ) # self.converter() is concat_example() また self.deviceでデータをgpuに送る x_real = Variable(x_real) x_real = (x_real - 127.5) / 127.5 # normalize image data # prepare the minibatch fake data z = Variable(self.xp.asarray( self.gen.make_hidden(batch_size))) # genertate z random vector # inference y_real = self.critic(x_real) # Genuine image estimation result y_fake = self.critic(self.gen(z)) # backward critic_optimizer.update(self.loss_critic, y_fake, y_real) # clip w for param in self.critic.params(): if param.data is None: continue with cuda.get_device(param.data): xp = cuda.get_array_module(param.data) param.data = xp.clip(param.data, self.clip_lower, self.clip_upper) # optimize generator z = Variable(self.xp.asarray( self.gen.make_hidden(batch_size))) # genertate z random vector y_fake = self.critic(self.gen(z)) # Estimation result of fake image # backward gen_optimizer.update(self.loss_gen, y_fake)
def printAllParameters(self, optimizer, init_type="***", init_scale=1.0): total_norm = 0 total_param = 0 named_params = sorted(optimizer.target.namedparams(), key=lambda x: x[0]) for n, p in named_params: t_norm = chainer.optimizer_hooks.gradient_clipping._sum_sqnorm( p.data) sys.stdout.write('### {} {} {} {} {}\n'.format( p.name, p.data.ndim, p.data.shape, p.data.size, t_norm)) total_norm += t_norm total_param += p.data.size with cuda.get_device(total_norm): sys.stdout.write( '# param size= [{}] norm = [{}] scale=[{}, {}]\n'.format( total_param, self.model.xp.sqrt(total_norm), init_type, init_scale))
def lossfun(x, t): with cuda.get_device(t): soft20_x = x[:, :20] soft100_x = x[:, 20:120] soft200_x = x[:, 120:320] soft20_label = t[:, 1:21] soft100_label = t[:, 21:121] soft200_label = t[:, 121:321] soft20_loss = -(F.sum( soft20_label * F.log_softmax(soft20_x))) / soft20_x.shape[0] soft100_loss = -(F.sum( soft100_label * F.log_softmax(soft100_x))) / soft100_x.shape[0] soft200_loss = -(F.sum( soft200_label * F.log_softmax(soft200_x))) / soft200_x.shape[0] loss = soft20_loss + soft100_loss + soft200_loss return loss
def main(): try: os.makedirs(args.figure_directory) except: pass #============================================================================== # Utilities #============================================================================== def read_files(directory): filenames = [] files = os.listdir(directory) # ipdb.set_trace() for filename in files: if filename.endswith(".h5"): filenames.append(filename) filenames.sort() dataset_images = [] dataset_viewpoints = [] for i in range(len(filenames)): F = h5py.File(os.path.join(directory, filenames[i])) tmp_images = list(F["images"]) tmp_viewpoints = list(F["viewpoints"]) dataset_images.extend(tmp_images) dataset_viewpoints.extend(tmp_viewpoints) # for i in range(len(filenames)): # images_npy_path = os.path.join(directory, "images", filenames[i]) # viewpoints_npy_path = os.path.join(directory, "viewpoints", filenames[i]) # tmp_images = np.load(images_npy_path) # tmp_viewpoints = np.load(viewpoints_npy_path) # assert tmp_images.shape[0] == tmp_viewpoints.shape[0] # dataset_images.extend(tmp_images) # dataset_viewpoints.extend(tmp_viewpoints) dataset_images = np.array(dataset_images) dataset_viewpoints = np.array(dataset_viewpoints) dataset = list() for i in range(len(dataset_images)): item = { 'image': dataset_images[i], 'viewpoint': dataset_viewpoints[i] } dataset.append(item) return dataset def to_device(array): # if using_gpu: array = cuda.to_gpu(array) return array def fill_observations_axis(observation_images): axis_observations_image = np.full( (3, image_shape[1], total_observations_per_scene * image_shape[2]), black_color, dtype=np.float32) num_current_obs = len(observation_images) total_obs = total_observations_per_scene width = image_shape[2] x_start = width * (total_obs - num_current_obs) // 2 for obs_image in observation_images: x_end = x_start + width axis_observations_image[:, :, x_start:x_end] = obs_image x_start += width return axis_observations_image def compute_camera_angle_at_frame(t): return t * 2 * math.pi / (fps * 2) def rotate_query_viewpoint(horizontal_angle_rad, camera_distance, camera_position_y): camera_position = np.array([ camera_distance * math.sin(horizontal_angle_rad), # x camera_position_y, camera_distance * math.cos(horizontal_angle_rad), # z ]) center = np.array((0, camera_position_y, 0)) camera_direction = camera_position - center yaw, pitch = compute_yaw_and_pitch(camera_direction) query_viewpoints = xp.array( ( camera_position[0], camera_position[1], camera_position[2], math.cos(yaw), math.sin(yaw), math.cos(pitch), math.sin(pitch), ), dtype=np.float32, ) query_viewpoints = xp.broadcast_to(query_viewpoints, (1, ) + query_viewpoints.shape) return query_viewpoints def render(representation, camera_distance, camera_position_y, total_frames, animation_frame_array, rotate_camera=True): # viewpoint_file = open('viewpoints.txt','w') for t in range(0, total_frames): artist_array = [ axis_observations.imshow(cv2.cvtColor( make_uint8(axis_observations_image), cv2.COLOR_BGR2RGB), interpolation="none", animated=True) ] horizontal_angle_rad = compute_camera_angle_at_frame(t) if rotate_camera == False: horizontal_angle_rad = compute_camera_angle_at_frame(0) query_viewpoints = rotate_query_viewpoint(horizontal_angle_rad, camera_distance, camera_position_y) generated_images = model.generate_image(query_viewpoints, representation)[0] generated_images = chainer.backends.cuda.to_cpu(generated_images) generated_images = make_uint8(generated_images) generated_images = cv2.cvtColor(generated_images, cv2.COLOR_BGR2RGB) artist_array.append( axis_generation.imshow(generated_images, interpolation="none", animated=True)) animation_frame_array.append(artist_array) def render_wVar(representation, camera_distance, camera_position_y, total_frames, animation_frame_array, no_of_samples, rotate_camera=True, wVariance=True): # highest_var = 0.0 # with open("queries.txt",'w') as file_wviews, open("variance.txt",'w') as file_wvar: for t in range(0, total_frames): artist_array = [ axis_observations.imshow(cv2.cvtColor( make_uint8(axis_observations_image), cv2.COLOR_BGR2RGB), interpolation="none", animated=True) ] horizontal_angle_rad = compute_camera_angle_at_frame(t) if rotate_camera == False: horizontal_angle_rad = compute_camera_angle_at_frame(0) query_viewpoints = rotate_query_viewpoint(horizontal_angle_rad, camera_distance, camera_position_y) # q_x, q_y, q_z, _, _, _, _ = query_viewpoints[0] # file_wviews.writelines("".join(str(q_x))+", "+ # "".join(str(q_y))+", "+ # "".join(str(q_z))+"\n") generated_images = cp.squeeze( cp.array( model.generate_images(query_viewpoints, representation, no_of_samples))) # ipdb.set_trace() var_image = cp.var(generated_images, axis=0) mean_image = cp.mean(generated_images, axis=0) mean_image = make_uint8( np.squeeze(chainer.backends.cuda.to_cpu(mean_image))) mean_image_rgb = cv2.cvtColor(mean_image, cv2.COLOR_BGR2RGB) var_image = chainer.backends.cuda.to_cpu(var_image) # grayscale r, g, b = var_image gray_var_image = 0.2989 * r + 0.5870 * g + 0.1140 * b # thresholding Otsu's method # thresh = threshold_otsu(gray_var_image) # var_binary = gray_var_image > thresh ## hill climb algorthm for searching highest variance # cur_var = np.mean(gray_var_image) # if cur_var>highest_var: # highest_var = cur_var # if wVariance==True: # print('highest variance: '+str(highest_var)+', viewpoint: '+str(query_viewpoints[0])) # highest_var_vp = query_viewpoints[0] # file_wvar.writelines('highest variance: '+str(highest_var)+', viewpoint: '+str(highest_var_vp)+'\n') # else: # pass artist_array.append( axis_generation_var.imshow(gray_var_image, cmap=plt.cm.gray, interpolation="none", animated=True)) artist_array.append( axis_generation_mean.imshow(mean_image_rgb, interpolation="none", animated=True)) animation_frame_array.append(artist_array) # if wVariance==True: # print('final highest variance: '+str(highest_var)+', viewpoint: '+str(highest_var_vp)) # file_wvar.writelines('final highest variance: '+str(highest_var)+', viewpoint: '+str(highest_var_vp)+'\n') # else: # pass # file_wviews.close() # file_wvar.close() # loading dataset & model cuda.get_device(args.gpu_device).use() xp = cp hyperparams = HyperParameters() assert hyperparams.load(args.snapshot_directory) model = Model(hyperparams) chainer.serializers.load_hdf5(args.snapshot_file, model) model.to_gpu() total_observations_per_scene = 4 fps = 30 black_color = -0.5 image_shape = (3, ) + hyperparams.image_size axis_observations_image = np.zeros( (3, image_shape[1], total_observations_per_scene * image_shape[2]), dtype=np.float32) #============================================================================== # Visualization #============================================================================== plt.style.use("dark_background") fig = plt.figure(figsize=(6, 7)) plt.subplots_adjust(left=0.1, right=0.95, bottom=0.1, top=0.95) # fig.suptitle("GQN") axis_observations = fig.add_subplot(2, 1, 1) axis_observations.axis("off") axis_observations.set_title("observations") axis_generation = fig.add_subplot(2, 1, 2) axis_generation.axis("off") axis_generation.set_title("Rendered Predictions") axis_generation_var = fig.add_subplot(2, 2, 3) axis_generation_var.axis("off") axis_generation_var.set_title("Variance Render") axis_generation_mean = fig.add_subplot(2, 2, 4) axis_generation_mean.axis("off") axis_generation_mean.set_title("Mean Render") # iterator dataset = read_files(args.dataset_directory) file_number = 1 with chainer.no_backprop_mode(): iterator = chainer.iterators.SerialIterator(dataset, batch_size=1) # ipdb.set_trace() for i in tqdm(range(len(iterator.dataset))): animation_frame_array = [] images, viewpoints = np.array([ iterator.dataset[i]["image"] ]), np.array([iterator.dataset[i]["viewpoint"]]) camera_distance = np.mean( np.linalg.norm(viewpoints[:, :, :3], axis=2)) camera_position_y = np.mean(viewpoints[:, :, 1]) images = images.transpose((0, 1, 4, 2, 3)).astype(np.float32) images = preprocess_images(images) batch_index = 0 total_views = images.shape[1] random_observation_view_indices = list(range(total_views)) random.shuffle(random_observation_view_indices) random_observation_view_indices = random_observation_view_indices[: total_observations_per_scene] observed_images = images[batch_index, random_observation_view_indices] observed_viewpoints = viewpoints[batch_index, random_observation_view_indices] observed_images = to_device(observed_images) observed_viewpoints = to_device(observed_viewpoints) # Scene encoder representation = model.compute_observation_representation( observed_images[None, :1], observed_viewpoints[None, :1]) # Update figure observation_index = random_observation_view_indices[0] observed_image = images[batch_index, observation_index] axis_observations_image = fill_observations_axis([observed_image]) # Neural rendering # render(representation, camera_distance, camera_position_y, # fps * 2, animation_frame_array) render_wVar(representation, camera_distance, camera_position_y, fps * 2, animation_frame_array, 100) for n in range(total_observations_per_scene): observation_indices = random_observation_view_indices[:n + 1] axis_observations_image = fill_observations_axis( images[batch_index, observation_indices]) # Scene encoder representation = model.compute_observation_representation( observed_images[None, :n + 1], observed_viewpoints[None, :n + 1]) # Neural rendering # render(representation, camera_distance, camera_position_y, # fps // 2, animation_frame_array,rotate_camera=False) render_wVar(representation, camera_distance, camera_position_y, fps // 2, animation_frame_array, 100, rotate_camera=False, wVariance=False) # Scene encoder with all given observations representation = model.compute_observation_representation( observed_images[None, :total_observations_per_scene + 1], observed_viewpoints[None, :total_observations_per_scene + 1]) # Neural rendering # render(representation, camera_distance, camera_position_y, # fps * 6, animation_frame_array) render_wVar(representation, camera_distance, camera_position_y, fps * 6, animation_frame_array, 100) anim = animation.ArtistAnimation( fig, animation_frame_array, interval=1 / fps, # originally 1/fps blit=True, repeat_delay=0) anim.save("{}/observations_{}.gif".format(args.figure_directory, file_number), writer="imagemagick", fps=10) # ipdb.set_trace() # anim.save( # "{}/rooms_ring_camera_observations_{}.mp4".format( # args.figure_directory, file_number), # writer='ffmpeg', # fps=10) file_number += 1
paths = [] for j in range(0, G): pathsAndLabels.append(np.asarray([os.path.join(os.path.join(train_dir, 'image3'), 'stage'+str(j)+'\\'), j])) for j in range(0, G): paths.append(np.asarray([os.path.join(os.path.join(test_dir, 'image2'), 'stage'+str(j)+'\\'), j])) (x_train, t_train), correct_train_label = image2Train(pathsAndLabels) (x_test, t_test), correct_test_label = image2Test(paths) model = CNN()#モデルの選択 #GPUの設定 cuda.get_device(0).use() model.to_gpu(0) optimizer = optimizers.Adam() # 最適化関数 optimizer.setup(model) #ラベルごとのトータル誤判別数 miss_train_total = np.zeros(G) miss_test_total = np.zeros(G) #ラベルごとのトータル正解数 correct_train_total = np.zeros(G) correct_test_total = np.zeros(G) #何を何と判別したか2次元配列 miss_train_judge = np.zeros([G,G])
def main(): try: os.mkdir(args.snapshot_directory) except: pass np.random.seed(0) xp = np device_gpu = args.gpu_device device_cpu = -1 using_gpu = device_gpu >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy dataset = gqn.data.Dataset(args.dataset_directory) hyperparams = HyperParameters() hyperparams.generator_share_core = args.generator_share_core hyperparams.generator_share_prior = args.generator_share_prior hyperparams.generator_generation_steps = args.generation_steps hyperparams.generator_share_upsampler = args.generator_share_upsampler hyperparams.inference_share_core = args.inference_share_core hyperparams.inference_share_posterior = args.inference_share_posterior hyperparams.h_channels = args.h_channels hyperparams.z_channels = args.z_channels hyperparams.u_channels = args.u_channels hyperparams.image_size = (args.image_size, args.image_size) hyperparams.representation_channels = args.representation_channels hyperparams.representation_architecture = args.representation_architecture hyperparams.pixel_n = args.pixel_n hyperparams.pixel_sigma_i = args.initial_pixel_variance hyperparams.pixel_sigma_f = args.final_pixel_variance hyperparams.save(args.snapshot_directory) print(hyperparams) model = Model(hyperparams, snapshot_directory=args.snapshot_directory, optimized=args.optimized) if using_gpu: model.to_gpu() scheduler = Scheduler(sigma_start=args.initial_pixel_variance, sigma_end=args.final_pixel_variance, final_num_updates=args.pixel_n, snapshot_directory=args.snapshot_directory) print(scheduler) optimizer = AdamOptimizer(model.parameters, mu_i=args.initial_lr, mu_f=args.final_lr, initial_training_step=scheduler.num_updates) print(optimizer) pixel_var = xp.full((args.batch_size, 3) + hyperparams.image_size, scheduler.pixel_variance**2, dtype="float32") pixel_ln_var = xp.full((args.batch_size, 3) + hyperparams.image_size, math.log(scheduler.pixel_variance**2), dtype="float32") representation_shape = (args.batch_size, hyperparams.representation_channels, args.image_size // 4, args.image_size // 4) fig = plt.figure(figsize=(9, 3)) axis_data = fig.add_subplot(1, 3, 1) axis_data.set_title("Data") axis_data.axis("off") axis_reconstruction = fig.add_subplot(1, 3, 2) axis_reconstruction.set_title("Reconstruction") axis_reconstruction.axis("off") axis_generation = fig.add_subplot(1, 3, 3) axis_generation.set_title("Generation") axis_generation.axis("off") current_training_step = 0 for iteration in range(args.training_iterations): mean_kld = 0 mean_nll = 0 mean_mse = 0 mean_elbo = 0 total_num_batch = 0 start_time = time.time() for subset_index, subset in enumerate(dataset): iterator = gqn.data.Iterator(subset, batch_size=args.batch_size) for batch_index, data_indices in enumerate(iterator): # shape: (batch, views, height, width, channels) # range: [-1, 1] images, viewpoints = subset[data_indices] # (batch, views, height, width, channels) -> (batch, views, channels, height, width) images = images.transpose((0, 1, 4, 2, 3)).astype(np.float32) total_views = images.shape[1] # Sample number of views num_views = random.choice(range(1, total_views + 1)) observation_view_indices = list(range(total_views)) random.shuffle(observation_view_indices) observation_view_indices = observation_view_indices[:num_views] query_index = random.choice(range(total_views)) if num_views > 0: observation_images = preprocess_images( images[:, observation_view_indices]) observation_query = viewpoints[:, observation_view_indices] representation = model.compute_observation_representation( observation_images, observation_query) else: representation = xp.zeros(representation_shape, dtype="float32") representation = chainer.Variable(representation) # Sample query query_index = random.choice(range(total_views)) query_images = preprocess_images(images[:, query_index]) query_viewpoints = viewpoints[:, query_index] # Transfer to gpu if necessary query_images = to_device(query_images, device_gpu) query_viewpoints = to_device(query_viewpoints, device_gpu) z_t_param_array, mean_x = model.sample_z_and_x_params_from_posterior( query_images, query_viewpoints, representation) # Compute loss ## KL Divergence loss_kld = 0 for params in z_t_param_array: mean_z_q, ln_var_z_q, mean_z_p, ln_var_z_p = params kld = gqn.functions.gaussian_kl_divergence( mean_z_q, ln_var_z_q, mean_z_p, ln_var_z_p) loss_kld += cf.sum(kld) ## Negative log-likelihood of generated image loss_nll = cf.sum( gqn.functions.gaussian_negative_log_likelihood( query_images, mean_x, pixel_var, pixel_ln_var)) # Calculate the average loss value loss_nll = loss_nll / args.batch_size loss_kld = loss_kld / args.batch_size loss = loss_nll / scheduler.pixel_variance + loss_kld model.cleargrads() loss.backward() optimizer.update(current_training_step) loss_nll = float(loss_nll.data) + math.log(256.0) loss_kld = float(loss_kld.data) elbo = -(loss_nll + loss_kld) loss_mse = float( cf.mean_squared_error(query_images, mean_x).data) printr( "Iteration {}: Subset {} / {}: Batch {} / {} - elbo: {:.2f} - loss: nll: {:.2f} mse: {:.6e} kld: {:.5f} - lr: {:.4e} - pixel_variance: {:.5f} - step: {} " .format(iteration + 1, subset_index + 1, len(dataset), batch_index + 1, len(iterator), elbo, loss_nll, loss_mse, loss_kld, optimizer.learning_rate, scheduler.pixel_variance, current_training_step)) scheduler.step(iteration, current_training_step) pixel_var[...] = scheduler.pixel_variance**2 pixel_ln_var[...] = math.log(scheduler.pixel_variance**2) total_num_batch += 1 current_training_step += 1 mean_kld += loss_kld mean_nll += loss_nll mean_mse += loss_mse mean_elbo += elbo model.serialize(args.snapshot_directory) # Visualize if args.with_visualization: axis_data.imshow(make_uint8(query_images[0]), interpolation="none") axis_reconstruction.imshow(make_uint8(mean_x.data[0]), interpolation="none") with chainer.no_backprop_mode(): generated_x = model.generate_image( query_viewpoints[None, 0], representation[None, 0]) axis_generation.imshow(make_uint8(generated_x[0]), interpolation="none") plt.pause(1e-8) elapsed_time = time.time() - start_time print( "\033[2KIteration {} - elbo: {:.2f} - loss: nll: {:.2f} mse: {:.6e} kld: {:.5f} - lr: {:.4e} - pixel_variance: {:.5f} - step: {} - time: {:.3f} min" .format(iteration + 1, mean_elbo / total_num_batch, mean_nll / total_num_batch, mean_mse / total_num_batch, mean_kld / total_num_batch, optimizer.learning_rate, scheduler.pixel_variance, current_training_step, elapsed_time / 60)) model.serialize(args.snapshot_directory)
def run_training(config: str, device: int, seed: int): configs = ConfigParser.parse(config) params = yaml.load(open(config, encoding="utf-8")) if device >= 0: cuda.get_device(device).use() set_seed(seed, device) vocab = Vocabulary.prepare(configs) num_word_vocab = max(vocab.dictionaries["word2idx"].values()) + 1 num_char_vocab = max(vocab.dictionaries["char2idx"].values()) + 1 num_tag_vocab = max(vocab.dictionaries["tag2idx"].values()) + 1 model = BiLSTM_CRF(configs, num_word_vocab, num_char_vocab, num_tag_vocab) transformer = DatasetTransformer(vocab) transform = transformer.transform external_configs = configs["external"] if "word_vector" in external_configs: syn0 = model.embed_word.W.data _, word_dim = syn0.shape pre_word_dim = vocab.gensim_model.vector_size if word_dim != pre_word_dim: msg = "Mismatch vector size between model and pre-trained word vectors" # NOQA msg += f"(model: \x1b[31m{word_dim}\x1b[0m" msg += f", pre-trained word vector: \x1b[31m{pre_word_dim}\x1b[0m" raise Exception(msg) word2idx = vocab.dictionaries["word2idx"] syn0 = prepare_pretrained_word_vector(word2idx, vocab.gensim_model, syn0, num_word_vocab) model.set_pretrained_word_vectors(syn0) train_iterator = create_iterator(vocab, configs, "train", transform) valid_iterator = create_iterator(vocab, configs, "valid", transform) test_iterator = create_iterator(vocab, configs, "test", transform) if device >= 0: model.to_gpu(device) optimizer = create_optimizer(configs) optimizer.setup(model) optimizer = add_hooks(optimizer, configs) updater = T.StandardUpdater(train_iterator, optimizer, converter=converter, device=device) params = configs.export() params["num_word_vocab"] = num_word_vocab params["num_char_vocab"] = num_char_vocab params["num_tag_vocab"] = num_tag_vocab epoch = configs["iteration"]["epoch"] trigger = (epoch, "epoch") model_path = configs["output"] timestamp = datetime.datetime.now() timestamp_str = timestamp.isoformat() output_path = Path(f"{model_path}.{timestamp_str}") trainer = T.Trainer(updater, trigger, out=output_path) save_args(params, output_path) msg = f"Create \x1b[31m{output_path}\x1b[0m for saving model snapshots" logging.debug(msg) entries = ["epoch", "iteration", "elapsed_time", "lr", "main/loss"] entries += ["validation/main/loss", "validation/main/fscore"] entries += ["validation_1/main/loss", "validation_1/main/fscore"] valid_evaluator = NamedEntityEvaluator(valid_iterator, model, transformer.itransform, converter, device=device) test_evaluator = NamedEntityEvaluator(test_iterator, model, transformer.itransform, converter, device=device) epoch_trigger = (1, "epoch") snapshot_filename = "snapshot_epoch_{.updater.epoch:04d}" trainer.extend(valid_evaluator, trigger=epoch_trigger) trainer.extend(test_evaluator, trigger=epoch_trigger) trainer.extend(E.observe_lr(), trigger=epoch_trigger) trainer.extend(E.LogReport(trigger=epoch_trigger)) trainer.extend(E.PrintReport(entries=entries), trigger=epoch_trigger) trainer.extend(E.ProgressBar(update_interval=20)) trainer.extend(E.snapshot_object(model, filename=snapshot_filename), trigger=(1, "epoch")) if "learning_rate_decay" in params: logger.debug("Enable Learning Rate decay") trainer.extend( LearningRateDecay("lr", params["learning_rate"], params["learning_rate_decay"]), trigger=epoch_trigger, ) trainer.run()
def main(): xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy hyperparams = Hyperparameters(args.snapshot_path) hyperparams.print() num_bins_x = 2.0**hyperparams.num_bits_x encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() total = hyperparams.levels + 1 fig = plt.figure(figsize=(4 * total, 4)) subplots = [] for n in range(total): subplot = fig.add_subplot(1, total, n + 1) subplots.append(subplot) def reverse_step(z, sampling=True): if isinstance(z, list): factorized_z = z else: factorized_z = encoder.factor_z(z) assert len(factorized_z) == len(encoder.blocks) out = None sum_logdet = 0 for block, zi in zip(encoder.blocks[::-1], factorized_z[::-1]): out, logdet = block.reverse_step( out, gaussian_eps=zi, squeeze_factor=encoder.hyperparams.squeeze_factor, sampling=sampling) sum_logdet += logdet return out, sum_logdet with chainer.no_backprop_mode() and encoder.reverse() as decoder: while True: base_z = xp.random.normal(0, args.temperature, size=( 1, 3, ) + hyperparams.image_size, dtype="float32") factorized_z = encoder.factor_z(base_z) rev_x, _ = decoder.reverse_step(factorized_z) rev_x_img = make_uint8(rev_x.data[0], num_bins_x) subplots[0].imshow(rev_x_img, interpolation="none") z = xp.copy(base_z) factorized_z = encoder.factor_z(z) for n in range(hyperparams.levels - 1): factorized_z[n] = xp.random.normal(0, args.temperature, size=factorized_z[n].shape, dtype="float32") rev_x, _ = decoder.reverse_step(factorized_z) rev_x_img = make_uint8(rev_x.data[0], num_bins_x) subplots[1].imshow(rev_x_img, interpolation="none") # for n in range(hyperparams.levels): # z = xp.copy(base_z) # factorized_z = encoder.factor_z(z) # for m in range(n + 1): # factorized_z[m] = xp.random.normal( # 0, # args.temperature, # size=factorized_z[m].shape, # dtype="float32") # # factorized_z[m] = xp.zeros_like(factorized_z[m]) # out = None # for k, (block, zi) in enumerate( # zip(encoder.blocks[::-1], factorized_z[::-1])): # sampling = False # out, _ = block.reverse_step( # out, # gaussian_eps=zi, # squeeze_factor=encoder.hyperparams.squeeze_factor, # sampling=sampling) # rev_x = out # rev_x_img = make_uint8(rev_x.data[0], num_bins_x) # subplots[n + 1].imshow(rev_x_img, interpolation="none") for n in range(hyperparams.levels): z = xp.copy(base_z) factorized_z = encoder.factor_z(z) factorized_z[n] = xp.random.normal(0, args.temperature, size=factorized_z[n].shape, dtype="float32") factorized_z[n] = xp.zeros_like(factorized_z[n]) out = None for k, (block, zi) in enumerate( zip(encoder.blocks[::-1], factorized_z[::-1])): sampling = False if k == hyperparams.levels - n - 1 else True out, _ = block.reverse_step( out, gaussian_eps=zi, squeeze_factor=encoder.hyperparams.squeeze_factor, sampling=sampling) rev_x = out rev_x_img = make_uint8(rev_x.data[0], num_bins_x) subplots[n + 1].imshow(rev_x_img, interpolation="none") plt.pause(.01)
def main(): try: os.mkdir(args.output_directory) except: pass xp = np using_gpu = args.gpu_device >= 0 if using_gpu: cuda.get_device(args.gpu_device).use() xp = cupy dataset = gqn.data.Dataset(args.dataset_path) models = [] snapshot_dirs = os.listdir(args.snapshots_dir_path) for snapshot_dir in snapshot_dirs: snapshot_path = os.path.join(args.snapshots_dir_path, snapshot_dir) hyperparams = HyperParameters(snapshot_directory=snapshot_path) models.append(Model(hyperparams, snapshot_directory=snapshot_path)) if using_gpu: for model in models: model.to_gpu() plt.style.use("dark_background") fig = plt.figure(figsize=(10, 5)) num_views_per_scene = 4 num_generation = 2 # lessened from 4 to 2 (remaining 2 used for original outpu) num_original = 2 total_frames_per_rotation = 24 image_shape = (3, ) + hyperparams.image_size blank_image = make_uint8(np.full(image_shape, 0)) file_number = 1 with chainer.no_backprop_mode(): for subset in dataset: iterator = gqn.data.Iterator(subset, batch_size=1) for data_indices in iterator: snapshot_array = [] observed_image_array = xp.zeros( (num_views_per_scene, ) + image_shape, dtype=np.float32) observed_viewpoint_array = xp.zeros((num_views_per_scene, 7), dtype=np.float32) # shape: (batch, views, height, width, channels) # range: [-1, 1] images, viewpoints, original_images = subset[data_indices] # (batch, views, height, width, channels) -> (batch, views, channels, height, width) images = images.transpose((0, 1, 4, 2, 3)).astype(np.float32) images = images / 255.0 images += np.random.uniform( 0, 1.0 / 256.0, size=images.shape).astype(np.float32) # (batch, views, height, width, channels) -> (batch, views, channels, height, width) original_images = original_images.transpose( (0, 1, 4, 2, 3)).astype(np.float32) original_images = original_images / 255.0 original_images += np.random.uniform( 0, 1.0 / 256.0, size=original_images.shape).astype(np.float32) batch_index = 0 # Generate images without observations r = xp.zeros(( num_generation, hyperparams.representation_channels, ) + hyperparams.chrz_size, dtype=np.float32) angle_rad = 0 current_scene_original_images_cpu = original_images[ batch_index] current_scene_original_images = to_gpu( current_scene_original_images_cpu) for i in range(10): gqn.animator.Snapshot.make_graph( id='kl_div_graph_' + str(i), pos=5 + i, graph_type='plot', frame_in_rotation=total_frames_per_rotation, num_of_data_per_graph=num_views_per_scene + 1, trivial_settings={ 'colors': ['red', 'blue', 'green', 'orange', 'white'], 'markers': ['o', 'o', 'o', 'o', 'o'], 'noXTicks': True, 'noYTicks': True, }) for t in range(total_frames_per_rotation): grid_master = GridSpec(nrows=4, ncols=5, height_ratios=[1, 1, 1, 1]) snapshot = gqn.animator.Snapshot( layout_settings={ 'subplot_count': 14, 'grid_master': grid_master, 'subplots': [{ 'subplot_id': i + 1, 'subplot': GridSpecFromSubplotSpec( nrows=2, ncols=2, subplot_spec=grid_master[i * 2:i * 2 + 2, 0:1]) } for i in range(2)] + [{ 'subplot_id': i + 3, 'subplot': GridSpecFromSubplotSpec( nrows=1, ncols=1, subplot_spec=grid_master[i, 2]) } for i in range(2)] + [{ 'subplot_id': i + 5, 'subplot': GridSpecFromSubplotSpec( nrows=1, ncols=1, subplot_spec=grid_master[i // 2, 3 + i % 2]) } for i in range(4)] + [{ 'subplot_id': i + 9, 'subplot': GridSpecFromSubplotSpec( nrows=1, ncols=1, subplot_spec=grid_master[2 + i // 3, 2 + i % 3]) } for i in range(6)] }) query_viewpoints = rotate_query_viewpoint( angle_rad, num_generation, xp) generated_images_list = [] for model in models: generated_images_list.append( model.generate_image(query_viewpoints, r, xp)) sq_d_list = [] for generated_images in generated_images_list: sq_d_list.append( gqn.math.get_squared_distance( to_cpu(current_scene_original_images[t]), to_cpu(generated_images[0]))[0]) snapshot.add_media(media_position=1, media_type='image', media_data=make_uint8( generated_images[0])) snapshot.add_title(target_media_pos=1, text='Generated') snapshot.add_media(media_position=2, media_type='image', media_data=make_uint8( current_scene_original_images[t])) snapshot.add_title(target_media_pos=2, text='Original') # snapshot.add_media(media_position=3 , media_type='image', media_data=make_uint8(current_scene_original_images[t])) # snapshot.add_title(target_media_pos=3, text='Original') snapshot.add_media(media_position=4, media_type='image', media_data=make_uint8(blank_image)) snapshot.add_title(target_media_pos=4, text='Observed') for i in range(10): gqn.animator.Snapshot.add_graph_data( graph_id='kl_div_graph_' + str(i), data_id='kl_div_data_0', new_data=sq_d_list[i], frame_num=t, ) print('snap') snapshot_array.append(snapshot) angle_rad += 2 * math.pi / total_frames_per_rotation # Generate images with observations for m in range(num_views_per_scene): kl_div_sum = 0 observed_image = images[batch_index, m] observed_viewpoint = viewpoints[batch_index, m] observed_image_array[m] = to_gpu(observed_image) observed_viewpoint_array[m] = to_gpu(observed_viewpoint) r_list = [] for i, model in enumerate(models): r_list.append( model.compute_observation_representation( observed_image_array[None, :m + 1], observed_viewpoint_array[None, :m + 1])) r_list[i] = cf.broadcast_to(r_list[i], (num_generation, ) + r_list[i].shape[1:]) angle_rad = 0 for t in range(total_frames_per_rotation): grid_master = GridSpec(nrows=4, ncols=5, height_ratios=[1, 1, 1, 1]) snapshot = gqn.animator.Snapshot( layout_settings={ 'subplot_count': 14, 'grid_master': grid_master, 'subplots': [{ 'subplot_id': i + 1, 'subplot': GridSpecFromSubplotSpec( nrows=2, ncols=2, subplot_spec=grid_master[i * 2:i * 2 + 2, 0:1]) } for i in range(2)] + [{ 'subplot_id': i + 3, 'subplot': GridSpecFromSubplotSpec( nrows=1, ncols=1, subplot_spec=grid_master[i, 2]) } for i in range(2)] + [{ 'subplot_id': i + 5, 'subplot': GridSpecFromSubplotSpec( nrows=1, ncols=1, subplot_spec=grid_master[i // 2, 3 + i % 2]) } for i in range(4)] + [{ 'subplot_id': i + 9, 'subplot': GridSpecFromSubplotSpec( nrows=1, ncols=1, subplot_spec=grid_master[2 + i // 3, 2 + i % 3]) } for i in range(6)] }) query_viewpoints = rotate_query_viewpoint( angle_rad, num_generation, xp) generated_images_list = [] for model, r in zip(models, r_list): generated_images_list.append( model.generate_image(query_viewpoints, r, xp)) sq_d_list = [] for i, generated_images in enumerate( generated_images_list): sq_d_list.append( gqn.math.get_squared_distance( to_cpu(current_scene_original_images[t]), to_cpu(generated_images[0]))[0]) snapshot.add_media(media_position=1, media_type='image', media_data=make_uint8( generated_images[0])) snapshot.add_title(target_media_pos=1, text='Generated') snapshot.add_media( media_position=2, media_type='image', media_data=make_uint8( current_scene_original_images[t])) snapshot.add_title(target_media_pos=2, text='Original') # snapshot.add_media(media_position=3 , media_type='image', media_data=make_uint8(current_scene_original_images[t])) # snapshot.add_title(target_media_pos=3, text='Original') snapshot.add_media(media_position=4, media_type='image', media_data=make_uint8( observed_image_array[m])) snapshot.add_title(target_media_pos=4, text='Observed') # for i, kl_div in enumerate(kl_div_list): for i in range(10): gqn.animator.Snapshot.add_graph_data( graph_id='kl_div_graph_' + str(i), data_id='kl_div_data_' + str(m + 1), new_data=sq_d_list[i], frame_num=t, ) angle_rad += 2 * math.pi / total_frames_per_rotation # plt.pause(1e-8) print('snap') snapshot_array.append(snapshot) plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0, hspace=0) anim = animation.FuncAnimation( fig, func_anim_upate, fargs=(fig, [snapshot_array]), interval=1 / 24, frames=(num_views_per_scene + 1) * total_frames_per_rotation) anim.save("{}/shepard_matzler_{}.mp4".format( args.output_directory, file_number), writer="ffmpeg", fps=12) file_number += 1
def test_get_device_for_int(self): with testing.assert_warns(DeprecationWarning): device = cuda.get_device(0) assert device == cuda.Device(0)
def main(): try: os.mkdir(args.snapshot_path) except: pass comm = chainermn.create_communicator() device = comm.intra_rank print("device", device, "/", comm.size) cuda.get_device(device).use() xp = cupy dataset = gqn.data.Dataset(args.dataset_path) hyperparams = HyperParameters() hyperparams.generator_share_core = args.generator_share_core hyperparams.generator_share_prior = args.generator_share_prior hyperparams.generator_generation_steps = args.generation_steps hyperparams.inference_share_core = args.inference_share_core hyperparams.inference_share_posterior = args.inference_share_posterior hyperparams.channels_chz = args.channels_chz hyperparams.generator_channels_u = args.channels_u hyperparams.inference_channels_map_x = args.channels_map_x hyperparams.pixel_n = args.pixel_n hyperparams.pixel_sigma_i = args.initial_pixel_sigma hyperparams.pixel_sigma_f = args.final_pixel_sigma if comm.rank == 0: hyperparams.save(args.snapshot_path) hyperparams.print() model = Model(hyperparams, snapshot_directory=args.snapshot_path) model.to_gpu() optimizer = Optimizer( model.parameters, communicator=comm, mu_i=args.initial_lr, mu_f=args.final_lr) if comm.rank == 0: optimizer.print() dataset_mean, dataset_std = dataset.load_mean_and_std() if comm.rank == 0: np.save(os.path.join(args.snapshot_path, "mean.npy"), dataset_mean) np.save(os.path.join(args.snapshot_path, "std.npy"), dataset_std) # avoid division by zero dataset_std += 1e-12 sigma_t = hyperparams.pixel_sigma_i pixel_var = xp.full( (args.batch_size, 3) + hyperparams.image_size, sigma_t**2, dtype="float32") pixel_ln_var = xp.full( (args.batch_size, 3) + hyperparams.image_size, math.log(sigma_t**2), dtype="float32") random.seed(0) subset_indices = list(range(len(dataset.subset_filenames))) current_training_step = 0 for iteration in range(args.training_iterations): mean_kld = 0 mean_nll = 0 total_batch = 0 subset_size_per_gpu = len(subset_indices) // comm.size start_time = time.time() for subset_loop in range(subset_size_per_gpu): random.shuffle(subset_indices) subset_index = subset_indices[comm.rank] subset = dataset.read(subset_index) iterator = gqn.data.Iterator(subset, batch_size=args.batch_size) for batch_index, data_indices in enumerate(iterator): # shape: (batch, views, height, width, channels) # range: [-1, 1] images, viewpoints = subset[data_indices] # preprocessing images = (images - dataset_mean) / dataset_std # (batch, views, height, width, channels) -> (batch, views, channels, height, width) images = images.transpose((0, 1, 4, 2, 3)) total_views = images.shape[1] # sample number of views num_views = random.choice(range(total_views)) query_index = random.choice(range(total_views)) if current_training_step == 0 and num_views == 0: num_views = 1 # avoid OpenMPI error if num_views > 0: r = model.compute_observation_representation( images[:, :num_views], viewpoints[:, :num_views]) else: r = xp.zeros( (args.batch_size, hyperparams.channels_r) + hyperparams.chrz_size, dtype="float32") r = chainer.Variable(r) query_images = images[:, query_index] query_viewpoints = viewpoints[:, query_index] # transfer to gpu query_images = to_gpu(query_images) query_viewpoints = to_gpu(query_viewpoints) h0_gen, c0_gen, u_0, h0_enc, c0_enc = model.generate_initial_state( args.batch_size, xp) loss_kld = 0 hl_enc = h0_enc cl_enc = c0_enc hl_gen = h0_gen cl_gen = c0_gen ul_enc = u_0 xq = model.inference_downsampler.downsample(query_images) for l in range(model.generation_steps): inference_core = model.get_inference_core(l) inference_posterior = model.get_inference_posterior(l) generation_core = model.get_generation_core(l) generation_piror = model.get_generation_prior(l) h_next_enc, c_next_enc = inference_core.forward_onestep( hl_gen, hl_enc, cl_enc, xq, query_viewpoints, r) mean_z_q = inference_posterior.compute_mean_z(hl_enc) ln_var_z_q = inference_posterior.compute_ln_var_z(hl_enc) ze_l = cf.gaussian(mean_z_q, ln_var_z_q) mean_z_p = generation_piror.compute_mean_z(hl_gen) ln_var_z_p = generation_piror.compute_ln_var_z(hl_gen) h_next_gen, c_next_gen, u_next_enc = generation_core.forward_onestep( hl_gen, cl_gen, ul_enc, ze_l, query_viewpoints, r) kld = gqn.nn.chainer.functions.gaussian_kl_divergence( mean_z_q, ln_var_z_q, mean_z_p, ln_var_z_p) loss_kld += cf.sum(kld) hl_gen = h_next_gen cl_gen = c_next_gen ul_enc = u_next_enc hl_enc = h_next_enc cl_enc = c_next_enc mean_x = model.generation_observation.compute_mean_x(ul_enc) negative_log_likelihood = gqn.nn.chainer.functions.gaussian_negative_log_likelihood( query_images, mean_x, pixel_var, pixel_ln_var) loss_nll = cf.sum(negative_log_likelihood) loss_nll /= args.batch_size loss_kld /= args.batch_size loss = loss_nll + loss_kld model.cleargrads() loss.backward() optimizer.update(current_training_step) if comm.rank == 0: printr( "Iteration {}: Subset {} / {}: Batch {} / {} - loss: nll: {:.3f} kld: {:.3f} - lr: {:.4e} - sigma_t: {:.6f}". format(iteration + 1, subset_loop * comm.size + 1, len(dataset), batch_index + 1, len(subset) // args.batch_size, float(loss_nll.data), float(loss_kld.data), optimizer.learning_rate, sigma_t)) sf = hyperparams.pixel_sigma_f si = hyperparams.pixel_sigma_i sigma_t = max( sf + (si - sf) * (1.0 - current_training_step / hyperparams.pixel_n), sf) pixel_var[...] = sigma_t**2 pixel_ln_var[...] = math.log(sigma_t**2) total_batch += 1 current_training_step += comm.size # current_training_step += 1 mean_kld += float(loss_kld.data) mean_nll += float(loss_nll.data) if comm.rank == 0: model.serialize(args.snapshot_path) if comm.rank == 0: elapsed_time = time.time() - start_time print( "\033[2KIteration {} - loss: nll: {:.3f} kld: {:.3f} - lr: {:.4e} - sigma_t: {:.6f} - step: {} - elapsed_time: {:.3f} min". format(iteration + 1, mean_nll / total_batch, mean_kld / total_batch, optimizer.learning_rate, sigma_t, current_training_step, elapsed_time / 60)) model.serialize(args.snapshot_path)
def test_get_device_for_builtin_int(self): # builtins.int is from future package and it is different # from builtin int/long on Python 2. with testing.assert_warns(DeprecationWarning): device = cuda.get_device(builtins.int(0)) assert device == cuda.Device(0)
def test_get_device_for_device(self): device = cuda.get_device_from_id(0) with testing.assert_warns(DeprecationWarning): assert cuda.get_device(device) is device