def main(args, model, x, t, valid_rate=0.2): print('Start a training script using multiple nodes.') comm = chainermn.create_communicator(args.communicator) device = comm.intra_rank assert device >= 0, 'invalid device ID: {}'.format(device) if comm.mpi_comm.rank == 0: print('==========================================') print('Num process (COMM_WORLD): {}'.format(MPI.COMM_WORLD.Get_size())) print('Using GPUs') print('Using {} communicator'.format(args.communicator)) print('Num Minibatch-size: {}'.format(args.batchsize)) print('Num epoch: {}'.format(args.epoch)) print('==========================================') if comm.rank == 0: threshold = int(len(t) * (1 - valid_rate)) train = datasets.tuple_dataset.TupleDataset(x[0:threshold], t[0:threshold]) valid = datasets.tuple_dataset.TupleDataset(x[threshold:], t[threshold:]) datasize = len(train) * args.epoch else: train, valid = None, None train = chainermn.scatter_dataset(train, comm, shuffle=True) valid = chainermn.scatter_dataset(valid, comm, shuffle=True) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) valid_iter = chainer.iterators.SerialIterator(valid, args.batchsize, repeat=False, shuffle=False) if device >= 0: cuda.get_device_from_id(device).use() model.to_gpu() optimizer = chainermn.create_multi_node_optimizer( chainer.optimizers.SGD(lr=2e-4), comm) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(1e-2)) updater = training.StandardUpdater(train_iter, optimizer, device=device) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) evaluator = extensions.Evaluator(valid_iter, model, device=device) evaluator = chainermn.create_multi_node_evaluator(evaluator, comm) prepare_extensions(trainer, evaluator, args, comm) trainer.run() if comm.rank == 0: throughput = datasize / trainer.elapsed_time print('Throughput: {} [images/sec.] ({} / {})'.format( throughput, datasize, trainer.elapsed_time)) model_filepath = os.path.join(args.out, 'trained.model') chainer.serializers.save_npz(model_filepath, model)
def load_model(model, trained_model="result/trained.model", gpu_id=0): model = L.Classifier(model) serializers.load_npz(trained_model, model) if gpu_id > -1: chainer.cuda.get_device_from_id(gpu_id).use() model.to_gpu() # Copy the model to the GPU return model
def train_using_gpu(args, model, x, t, valid_rate=0.1): if args.n_gpus == 1: print('Start a training script using single GPU.') else: multiprocessing.set_start_method('forkserver') print('Start a training script using multiple GPUs.') # Set up a dataset and prepare train/valid data iterator. threshold = int(len(t)*(1-valid_rate)) train = datasets.tuple_dataset.TupleDataset(x[0:threshold], t[0:threshold]) valid = datasets.tuple_dataset.TupleDataset(x[threshold:], t[threshold:]) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) valid_iter = chainer.iterators.SerialIterator(valid, args.batchsize, repeat=False, shuffle=False) # Make a specified GPU current master_gpu_id = 0 if args.n_gpus == 1: cuda.get_device_from_id(master_gpu_id).use() model.to_gpu() # Copy the model to the GPU else: cuda.get_device_from_id(master_gpu_id).use() # Make optimizer. optimizer = chainer.optimizers.Adam(alpha=2e-5) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(1e-3)) #optimizer.add_hook(chainer.optimizer.Lasso(1e-5)) # Set up a trainer if args.n_gpus == 1: updater = training.StandardUpdater(train_iter, optimizer, device=0) else: devices_list = {'main': master_gpu_id} devices_list.update({'gpu{}'.format(i): i for i in range(1, args.n_gpus)}) print(devices_list) updater = training.updaters.ParallelUpdater(train_iter, optimizer, devices=devices_list) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) evaluator = extensions.Evaluator(valid_iter, model, device=master_gpu_id) # Set some extension modules to a trainer. prepare_extensions(trainer, evaluator, args) # Run the training trainer.run() # Show real throughput. datasize = len(train) * args.epoch throughput = datasize / trainer.elapsed_time print('Throughput: {} [images/sec.] ({} / {})'.format( throughput, datasize, trainer.elapsed_time)) # Save trained model. model_filepath = os.path.join(args.out, 'trained.model') chainer.serializers.save_npz(model_filepath, model)
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 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(): try: os.mkdir(args.ckpt) except: pass 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 num_pixels = 3 * hyperparams.image_size[0] * hyperparams.image_size[1] encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() # Load picture x = np.array(Image.open(args.img)).astype('float32') x = preprocess(x, hyperparams.num_bits_x) x = to_gpu(xp.expand_dims(x, axis=0)) x += xp.random.uniform(0, 1.0 / num_bins_x, size=x.shape) if True: # Print this image info: b = xp.zeros((1, 3, 128, 128)) z, fw_ldt = encoder.forward_step(x, b) fw_ldt -= math.log(num_bins_x) * num_pixels logpZ = 0 ez = [] factor_z = [] for (zi, mean, ln_var) in z: factor_z.append(zi.data) logpZ += cf.gaussian_nll(zi, mean, ln_var) ez.append(zi.data.reshape(-1, )) ez = np.concatenate(ez) logpZ2 = cf.gaussian_nll(ez, xp.zeros(ez.shape), xp.zeros(ez.shape)).data print(fw_ldt, logpZ, logpZ2) with encoder.reverse() as decoder: rx, _ = decoder.reverse_step(factor_z) rx_img = make_uint8(rx.data[0], num_bins_x) rx_img = Image.fromarray(rx_img) rx_img.save(args.t + 'ori_revx.png') np.save(args.t + 'ori_z.npy', ez.get()) # Construct epsilon class eps(chainer.Chain): def __init__(self, shape, glow_encoder): super().__init__() self.encoder = glow_encoder with self.init_scope(): self.b = chainer.Parameter(initializers.Zero(), (1, 3, 128, 128)) self.m = chainer.Parameter(initializers.One(), (3, 8, 8)) def forward(self, x): # b = cf.tanh(self.b) * 0.5 b = self.b # Not sure if implementation is wrong m = cf.softplus(self.m) # m = cf.repeat(m, 8, axis=2) # m = cf.repeat(m, 8, axis=1) # m = cf.repeat(m, 16, axis=2) # m = cf.repeat(m, 16, axis=1) # b = b * m # cur_x = cf.add(x, b) # cur_x = cf.clip(cur_x, -0.5,0.5) z = [] zs, logdet = self.encoder.forward_step(x, b) for (zi, mean, ln_var) in zs: z.append(zi) z = merge_factorized_z(z) # return z, zs, logdet, cf.batch_l2_norm_squared(b), xp.tanh(self.b.data*1), cur_x, m return z, zs, logdet, xp.sum(xp.abs(b.data)), self.b.data * 1, m, x def save(self, path): filename = 'loss_model.hdf5' self.save_parameter(path, filename, self) def save_parameter(self, path, filename, params): tmp_filename = str(uuid.uuid4()) tmp_filepath = os.path.join(path, tmp_filename) save_hdf5(tmp_filepath, params) os.rename(tmp_filepath, os.path.join(path, filename)) epsilon = eps(x.shape, encoder) if using_gpu: epsilon.to_gpu() # optimizer = Optimizer(epsilon) optimizer = optimizers.Adam().setup(epsilon) # optimizer = optimizers.SGD().setup(epsilon) epsilon.b.update_rule.hyperparam.lr = 0.01 epsilon.m.update_rule.hyperparam.lr = 0.1 print('init finish') training_step = 0 z_s = [] b_s = [] loss_s = [] logpZ_s = [] logDet_s = [] m_s = [] j = 0 for iteration in range(args.total_iteration): epsilon.cleargrads() z, zs, fw_ldt, b_norm, b, m, cur_x = epsilon.forward(x) fw_ldt -= math.log(num_bins_x) * num_pixels logpZ1 = 0 factor_z = [] for (zi, mean, ln_var) in zs: factor_z.append(zi.data) logpZ1 += cf.gaussian_nll(zi, mean, ln_var) logpZ2 = cf.gaussian_nll(z, xp.zeros(z.shape), xp.zeros(z.shape)).data # logpZ2 = cf.gaussian_nll(z, np.mean(z), np.log(np.var(z))).data logpZ = (logpZ2 + logpZ1) / 2 loss = b_norm + (logpZ - fw_ldt) loss.backward() optimizer.update() training_step += 1 z_s.append(z.get()) b_s.append(cupy.asnumpy(b)) m_s.append(cupy.asnumpy(m.data)) loss_s.append(_float(loss)) logpZ_s.append(_float(logpZ)) logDet_s.append(_float(fw_ldt)) printr( "Iteration {}: loss: {:.6f} - b_norm: {:.6f} - logpZ: {:.6f} - logpZ1: {:.6f} - logpZ2: {:.6f} - log_det: {:.6f} - logpX: {:.6f}\n" .format(iteration + 1, _float(loss), _float(b_norm), _float(logpZ), _float(logpZ1), _float(logpZ2), _float(fw_ldt), _float(logpZ) - _float(fw_ldt))) if iteration % 100 == 99: np.save(args.ckpt + '/' + str(j) + 'z.npy', z_s) np.save(args.ckpt + '/' + str(j) + 'b.npy', b_s) np.save(args.ckpt + '/' + str(j) + 'loss.npy', loss_s) np.save(args.ckpt + '/' + str(j) + 'logpZ.npy', logpZ_s) np.save(args.ckpt + '/' + str(j) + 'logDet.npy', logDet_s) # cur_x = make_uint8(cur_x[0].data, num_bins_x) # np.save(args.ckpt + '/'+str(j)+'image.npy', cur_x) np.save(args.ckpt + '/' + str(j) + 'm.npy', m_s) with encoder.reverse() as decoder: rx, _ = decoder.reverse_step(factor_z) rx_img = make_uint8(rx.data[0], num_bins_x) np.save(args.ckpt + '/' + str(j) + 'res.npy', rx_img) z_s = [] b_s = [] loss_s = [] logpZ_s = [] logDet_s = [] m_s = [] j += 1 epsilon.save(args.ckpt)
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=2) print(tabulate([["#image", len(dataset)]])) encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() total = args.num_steps + 2 fig = plt.figure(figsize=(4 * total, 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: 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) z = encoder.merge_factorized_z(factorized_z) z_start = z[0] z_end = z[1] z_batch = [z_start] for n in range(args.num_steps): ratio = n / (args.num_steps - 1) z_interp = ratio * z_end + (1.0 - ratio) * z_start z_batch.append(args.temperature * z_interp) z_batch.append(z_end) z_batch = xp.stack(z_batch) rev_x_batch, _ = decoder.reverse_step(z_batch) for n in range(args.num_steps): rev_x_img = make_uint8(rev_x_batch.data[n + 1], num_bins_x) subplots[n + 1].imshow(rev_x_img, interpolation="none") x_start_img = make_uint8(x[0], num_bins_x) subplots[0].imshow(x_start_img, interpolation="none") x_end_img = make_uint8(x[-1], num_bins_x) subplots[-1].imshow(x_end_img, interpolation="none") plt.pause(.01)
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 num_pixels = 3 * hyperparams.image_size[0] * hyperparams.image_size[1] # Get Dataset: if True: 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() ori_x = [] enc_z = [] rev_x = [] fw_logdet = [] logpZ = [] logpZ2 = [] i = 0 with chainer.no_backprop_mode() and encoder.reverse() as decoder: for data_indices in iterator: i += 1 x = to_gpu(dataset[data_indices]) # 1x3x64x64 x += xp.random.uniform(0, 1.0 / num_bins_x, size=x.shape) x_img = make_uint8(x[0], num_bins_x) ori_x.append(x_img) factorized_z_distribution, fw_ldt = encoder.forward_step(x) fw_ldt -= math.log(num_bins_x) * num_pixels fw_logdet.append(cupy.asnumpy(fw_ldt.data)) factor_z = [] ez = [] nll = 0 for (zi, mean, ln_var) in factorized_z_distribution: nll += cf.gaussian_nll(zi, mean, ln_var) factor_z.append(zi.data) ez.append(zi.data.reshape(-1, )) ez = np.concatenate(ez) enc_z.append(ez.get()) logpZ.append(cupy.asnumpy(nll.data)) logpZ2.append( cupy.asnumpy( cf.gaussian_nll(ez, np.mean(ez), np.log(np.var(ez))).data)) rx, _ = decoder.reverse_step(factor_z) rx_img = make_uint8(rx.data[0], num_bins_x) rev_x.append(rx_img) if i % 100 == 0: np.save(str(i) + '/ori_x.npy', ori_x) fw_logdet = np.array(fw_logdet) np.save(str(i) + '/fw_logdet.npy', fw_logdet) np.save(str(i) + '/enc_z.npy', enc_z) logpZ = np.array(logpZ) np.save(str(i) + '/logpZ.npy', logpZ) logpZ2 = np.array(logpZ2) np.save(str(i) + '/logpZ2.npy', logpZ2) np.save(str(i) + '/rev_x.npy', rev_x) ori_x = [] enc_z = [] rev_x = [] fw_logdet = [] logpZ = [] logpZ2 = [] return
import argparse import preprocessing import model import train from torch.utils.data import DataLoader import torch # Parsing script arguments parser = argparse.ArgumentParser(description='Process input') parser.add_argument('input_folder', type=str, help='Input folder path, containing images') args = parser.parse_args() model_weights_path = 'models/final_model.pkl' net = model.MaskDetector(None) net.load_state_dict(torch.load(model_weights_path, map_location=lambda storage, loc: storage)) net = model.to_gpu(net) test_dataset = preprocessing.FaceMaskDataset(args.input_folder, []) test_loader = DataLoader(test_dataset, batch_size=256, shuffle=False, num_workers=4) prediction_df = train.predict(net, test_loader) f1, roc_auc = train.calculate_scores(prediction_df) print('F1:', f1, 'ROC_AUC:', roc_auc) prediction_df[['id', 'pred']].to_csv("prediction.csv", index=False, header=False)
def load_trainer(path, gpu: int = -1) -> training.Trainer: """ :param path: 設定ファイルのあるディレクトリ :return: """ with open(os.path.join(path, "solver.yaml")) as f: solver_yaml = yaml.load(f) id_from_dir = os.path.basename(path) id_from_solver_yaml = str(solver_yaml["id"]) if id_from_dir != id_from_solver_yaml: warnings.warn( f"training id from directory name and solver.yaml mismatch: {id_from_dir} != {id_from_solver_yaml}") with open(os.path.join(path, "dataset.yaml")) as f: dataset_yaml = yaml.load(f) with open(os.path.join(path, "model.yaml")) as f: model_yaml = yaml.load(f) # pythonファイルをコピー code_dir = os.path.join(path, "code") os.makedirs(code_dir, exist_ok=True) code_src_dir = os.path.dirname(__file__) shutil.copy(os.path.join(code_src_dir, dataset_yaml["dataset_code"]), os.path.join(code_dir, "dataset.py")) shutil.copy(os.path.join(code_src_dir, model_yaml["model_code"]), os.path.join(code_dir, "model.py")) # pythonファイルをimport sys.path.insert(0, code_dir) import dataset import model # データセットローダーを生成 dataset_loaders = {} for phase in ["train", "val"]: dataset_class = getattr(dataset, dataset_yaml[phase]["class"]) dataset_loaders[phase] = dataset_class(**dataset_yaml[phase].get("kwargs", {})) # モデルを生成 model_class = getattr(model, model_yaml["class"]) model = model_class(**model_yaml.get("kwargs", {})) initmodel_path = solver_yaml.get("initmodel", None) if initmodel_path: chainer.serializers.load_npz(initmodel_path, model) if gpu >= 0: model.to_gpu() train_iter = chainer.iterators.SerialIterator( dataset_loaders["train"], solver_yaml["batchsize"], repeat=True, shuffle=False ) val_iter = chainer.iterators.SerialIterator( dataset_loaders["val"], solver_yaml["val_batchsize"], repeat=False, shuffle=False ) optimizer_class = {"MomentumSGD": chainer.optimizers.MomentumSGD}[solver_yaml["optimizer"]] optimizer = optimizer_class(**solver_yaml.get("optimizer_kwargs", {})) optimizer.setup(model) updater = training.StandardUpdater(train_iter, optimizer, device=gpu) weight_out_dir = os.path.join(path, "weight") trainer = training.Trainer(updater, (solver_yaml["epoch"], 'epoch'), weight_out_dir) if "val_interval_iteration" in solver_yaml: val_interval = solver_yaml["val_interval_iteration"], "iteration" else: val_interval = 1, 'epoch' log_interval = 100, 'iteration' trainer.extend(extensions.Evaluator(val_iter, model, device=gpu), trigger=val_interval) trainer.extend(extensions.dump_graph('main/loss')) trainer.extend(extensions.snapshot(), trigger=val_interval) trainer.extend(extensions.snapshot_object( model, 'model_iter_{.updater.iteration}'), trigger=val_interval) # Be careful to pass the interval directly to LogReport # (it determines when to emit log rather than when to read observations) trainer.extend(extensions.LogReport(trigger=log_interval)) trainer.extend(extensions.observe_lr(), trigger=log_interval) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'main/loss', 'validation/main/loss', 'main/loss_move', 'validation/main/loss_move', 'main/loss_value', 'validation/main/loss_value', 'main/accuracy', 'validation/main/accuracy', 'lr' ]), trigger=log_interval) if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'iteration', val_interval, file_name='loss.png')) trainer.extend( extensions.PlotReport(['main/loss_move', 'validation/main/loss_move'], 'iteration', val_interval, file_name='loss_move.png')) trainer.extend( extensions.PlotReport(['main/loss_value', 'validation/main/loss_value'], 'iteration', val_interval, file_name='loss_value.png')) trainer.extend( extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'iteration', val_interval, file_name='accuracy.png')) trainer.extend(extensions.ProgressBar(update_interval=10)) return trainer
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) _, test = chainer.datasets.mnist.get_mnist() images = [] labels = [] for entity in test: image, label = entity images.append(image) labels.append(label) labels = np.asarray(labels) 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) # images = images[:200] # labels = labels[:200] sections = len(images) // 100 dataset_image = np.split(images, sections) encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() fig = plt.figure(figsize=(8, 8)) t_sne_inputs = [] with chainer.no_backprop_mode(): for n, image_batch in enumerate(dataset_image): x = to_gpu(image_batch) 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) z = encoder.merge_factorized_z(factorized_z, factor=hyperparams.squeeze_factor) z = z.reshape((-1, hyperparams.num_image_channels * 28 * 28)) z = to_cpu(z) t_sne_inputs.append(z) t_sne_inputs = np.asanyarray(t_sne_inputs).reshape( (-1, hyperparams.num_image_channels * 28 * 28)) print(t_sne_inputs.shape) z_reduced = TSNE(n_components=2, random_state=0).fit_transform(t_sne_inputs) print(z_reduced.shape) plt.scatter(z_reduced[:, 0], z_reduced[:, 1], c=labels, s=1, cmap="Spectral") plt.colorbar() plt.savefig("scatter.png")
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=2) print(tabulate([["#image", len(dataset)]])) encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() total = args.num_steps + 2 fig = plt.figure(figsize=(4 * total, 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: 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) z = encoder.merge_factorized_z(factorized_z) z_start = z[0] z_end = z[1] z_batch = [args.temperature * z_start] for n in range(args.num_steps): ratio = n / (args.num_steps - 1) z_interp = ratio * z_end + (1.0 - ratio) * z_start z_batch.append(args.temperature * z_interp) z_batch.append(args.temperature * z_end) for z, subplot in zip(z_batch, subplots): z = z[None, ...] rev_x, _ = decoder.reverse_step(z) rev_x_img = make_uint8(rev_x.data[0], num_bins_x) subplot.imshow(rev_x_img, interpolation="none") plt.pause(.01)
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) print( tabulate([ ["levels", hyperparams.levels], ["depth_per_level", hyperparams.depth_per_level], ["nn_hidden_channels", hyperparams.nn_hidden_channels], ["image_size", hyperparams.image_size], ["lu_decomposition", hyperparams.lu_decomposition], ["num_bits_x", hyperparams.num_bits_x], ])) 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) break 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.png.Dataset(images) iterator = glow.dataset.png.Iterator(dataset, batch_size=1) print(tabulate([["#image", len(dataset)]])) encoder = InferenceModel(hyperparams, hdf5_path=args.snapshot_path) decoder = encoder.reverse() if using_gpu: encoder.to_gpu() decoder.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(): 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, _ = forward_blocks(x, encoder, decoder) rev_x, _ = decoder(factorized_z) print(xp.mean(x), xp.var(x), " ->", xp.mean(rev_x.data), xp.var(rev_x.data)) 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 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() 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) 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)
parser.add_argument('--val_batchsize', '-b', type=int, default=64, help='Validation minibatch size') parser.add_argument('--test', action='store_true') parser.set_defaults(test=False) args = parser.parse_args() model = archs[args.arch]() if args.initmodel: print('[ PREPROCESS ] Load model from', args.initmodel) chainer.serializers.load_npz(args.initmodel, model) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() # Make the GPU current model.to_gpu() print("[ PREPROCESS ] Load image-label list file.") with open(args.train, "rb") as rf: train_tuples = pickle.load(rf) with open(args.val, "rb") as rf: val_tuples = pickle.load(rf) num_of_image_data = len(train_tuples) + len(val_tuples) print("{:15}All: {}, Train: {}, Val: {}".format("", num_of_image_data, len(train_tuples), len(val_tuples))) # Load the datasets and mean file print("[ PREPROCESS ] Load the datasets and mean file.") mean = np.load(args.mean)
def main(): try: os.mkdir(args.ckpt) except: pass 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 num_pixels = 3 * hyperparams.image_size[0] * hyperparams.image_size[1] encoder = Glow(hyperparams, hdf5_path=args.snapshot_path) if using_gpu: encoder.to_gpu() # Load picture x = np.array(Image.open(args.img)).astype('float32') x = preprocess(x, hyperparams.num_bits_x) x = to_gpu(xp.expand_dims(x, axis=0)) x += xp.random.uniform(0, 1.0 / num_bins_x, size=x.shape) # Construct epsilon class eps(chainer.Chain): def __init__(self, shape, glow_encoder): super().__init__() self.encoder = glow_encoder with self.init_scope(): self.b = chainer.Parameter(initializers.Zero(), shape) self.m = chainer.Parameter(initializers.One(), shape) def modify_mask(self): mask = self.m.data for i_idx in range(8): for j_idx in range(8): mean = xp.mean((xp.sum(mask[:, :, i_idx * 8:i_idx * 8 + 8, j_idx * 8:j_idx * 8 + 8]))) mask[:, :, i_idx * 8:i_idx * 8 + 8, j_idx * 8:j_idx * 8 + 8] = mean mask = xp.abs(mask) print(type(mask), type(self.m), type(self.m.data)) self.m.data = mask def forward(self, x): # b_ = cf.tanh(self.b) b_ = self.b # Not sure if implementation is wrong self.modify_mask() # m = cf.repeat(m, 8, axis=2) # m = cf.repeat(m, 8, axis=1) # m = cf.repeat(m, 16, axis=2) # m = cf.repeat(m, 16, axis=1) # b = b * m x_ = cf.add(x, b_) x_ = cf.clip(x_, -0.5, 0.5) z = [] zs, logdet = self.encoder.forward_step(x_) for (zi, mean, ln_var) in zs: z.append(zi) z = merge_factorized_z(z) # return z, zs, logdet, cf.batch_l2_norm_squared(b), xp.tanh(self.b.data*1), cur_x, m return z, zs, logdet, xp.sum(xp.abs(b_.data)), xp.tanh( self.b.data * 1), self.m, x_ def save(self, path): filename = 'loss_model.hdf5' self.save_parameter(path, filename, self) def save_parameter(self, path, filename, params): tmp_filename = str(uuid.uuid4()) tmp_filepath = os.path.join(path, tmp_filename) save_hdf5(tmp_filepath, params) os.rename(tmp_filepath, os.path.join(path, filename)) epsilon = eps(x.shape, encoder) if using_gpu: epsilon.to_gpu() # optimizer = Optimizer(epsilon) # optimizer = optimizers.Adam(alpha=0.0005).setup(epsilon) optimizer = optimizers.SGD().setup(epsilon) epsilon.b.update_rule.hyperparam.lr = 0.0001 epsilon.m.update_rule.hyperparam.lr = 0.1 print('init finish') training_step = 0 z_s = [] b_s = [] loss_s = [] logpZ_s = [] logDet_s = [] m_s = [] j = 0 for iteration in range(args.total_iteration): # z, zs, logdet, xp.sum(xp.abs(b_.data)), xp.tanh(self.b.data * 1), self.m, x_ z, zs, fw_ldt, b_norm, b, m, cur_x = epsilon.forward(x) epsilon.cleargrads() fw_ldt -= math.log(num_bins_x) * num_pixels logpZ1 = 0 factor_z = [] for (zi, mean, ln_var) in zs: factor_z.append(zi.data.reshape(zi.shape[0], -1)) logpZ1 += cf.gaussian_nll(zi, mean, ln_var) factor_z = xp.concatenate(factor_z, axis=1) logpZ2 = cf.gaussian_nll(z, xp.zeros(z.shape), xp.zeros(z.shape)).data # logpZ2 = cf.gaussian_nll(z, np.mean(z), np.log(np.var(z))).data logpZ = (logpZ2 * 1 + logpZ1 * 1) loss = 10 * b_norm + (logpZ - fw_ldt) loss.backward() optimizer.update() training_step += 1 z_s.append(z.get()) b_s.append(cupy.asnumpy(b)) m_s.append(cupy.asnumpy(m.data)) loss_s.append(_float(loss)) logpZ_s.append(_float(logpZ)) logDet_s.append(_float(fw_ldt)) printr( "Iteration {}: loss: {:.6f} - b_norm: {:.6f} - logpZ: {:.6f} - logpZ1: {:.6f} - logpZ2: {:.6f} - log_det: {:.6f} - logpX: {:.6f}\n" .format(iteration + 1, _float(loss), _float(b_norm), _float(logpZ), _float(logpZ1), _float(logpZ2), _float(fw_ldt), _float(logpZ) - _float(fw_ldt))) if iteration % 100 == 99: print(cur_x.shape) np.save(args.ckpt + '/' + str(j) + 'z.npy', z_s) np.save(args.ckpt + '/' + str(j) + 'b.npy', b_s) np.save(args.ckpt + '/' + str(j) + 'loss.npy', loss_s) np.save(args.ckpt + '/' + str(j) + 'logpZ.npy', logpZ_s) np.save(args.ckpt + '/' + str(j) + 'logDet.npy', logDet_s) cur_x = make_uint8(cur_x[0].data, num_bins_x) np.save(args.ckpt + '/' + str(j) + 'image.npy', cur_x) x_PIL = Image.fromarray(cur_x) x_PIL.save("./mask_imgs/trained.jpg") np.save(args.ckpt + '/' + str(j) + 'm.npy', m_s) # with encoder.reverse() as decoder: # rx, _ = decoder.reverse_step(factor_z) # rx_img = make_uint8(rx.data[0], num_bins_x) # np.save(args.ckpt + '/'+str(j)+'res.npy', rx_img) z_s = [] b_s = [] loss_s = [] logpZ_s = [] logDet_s = [] m_s = [] j += 1 epsilon.save(args.ckpt)
# Loop on splits of text entry for ipart_txt in range(len(parts)-1): if ipart_txt: # exclude first split # Copy 2 first lines at the bottom of the spectrum 0.3*hps.fe_data times ? for i in range(int(0.3*hps.fe_data)): spe_out_postnet=np.concatenate((spe_out_postnet,spe_out_postnet[0:1,:])) # text split prefixed by last character (punctuation) of previous split, no effects on first split all_text_in[parts[ipart_txt]]=c_prec c_prec=all_text_in[parts[ipart_txt+1]-1] # Get the text in the current split text_in=all_text_in[parts[ipart_txt]:parts[ipart_txt+1]] tensor_text_in=torch.Tensor(text_in)[None, :] tensor_text_in=to_gpu(tensor_text_in).long() # Synthesis of the split by the model (_, part_spe_out_postnet, _, part_alignement, part_encoder_out) = model.inference(tensor_text_in, hps.seed) # ----------- Save encoder embeddings of each chunk ---------------- if hps.save_embeddings: # write split embedding in emb_mat emb_mat = part_encoder_out.cpu().data.numpy()[0].transpose() if ipart_txt: nm_emb='{}/{}_{}_emb_{}.mat'.format(args.output_directory,nms_data[data_test[i_syn][0]],suffix,ipart_txt) # Output filename else: nm_emb='{}/{}_{}_emb.mat'.format(args.output_directory,nms_data[data_test[i_syn][0]],suffix) # Output filename # save alignment in .mat format