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
