def test_unconditional_forward():
""" checking gradient leaking along batch axis """
width = 5
height = 7
z_size = 2
batch_size = 3
model = CPPN(
ModelConfig(width=width,
height=height,
n_units_xyrz=3,
n_hidden_units=[5, 5],
z_size=z_size))
model.zerograds()
# create inputs: inputs is dict whose key is batch index, and value is tuple of (x, z) for each index
x, z, inputs = gen_input_batch(batch_size, width, height, z_size)
# forward prop
y = model.forward(x, z)
# taking loss at only first image
t = get_dammy_output(batch_size, width, height)
loss = F.mean_squared_error(y[0], t[0])
# check gradient leaking
assert sum([g.data.sum()
for g in chainer.grad((loss, ), inputs[0])]) != 0.0
assert sum([g.data.sum()
for g in chainer.grad((loss, ), inputs[1])]) == 0.0
assert sum([g.data.sum()
for g in chainer.grad((loss, ), inputs[2])]) == 0.0
def start_train():
parser = argparse.ArgumentParser(description="Training CPPN model")
parser.add_argument('log_dir_path', type=Path)
parser.add_argument('--train_config_path', type=Path, default='./conf/train.yaml')
parser.add_argument('--model_config_path', type=Path, default='./conf/model.yaml')
parser.add_argument('--load', type=Path)
parser.add_argument('--device', type=int, default=0)
parser.add_argument('--overwrite', action='store_true')
args = parser.parse_args()
# init log_dir
args.log_dir_path.mkdir(parents=False, exist_ok=args.overwrite)
# load train config
train_config = TrainConfig.load(args.train_config_path)
# load model config
model_config = ModelConfig.load(args.model_config_path)
# check load
if args.load:
assert args.load.exists()
# store execution info to log_dir
trainer_util.snap_exec_info(args.log_dir_path, args)
# copy configs to log dir
shutil.copyfile(args.train_config_path, args.log_dir_path / args.train_config_path.name)
shutil.copyfile(args.model_config_path, args.log_dir_path / args.model_config_path.name)
# start train
train(args.log_dir_path, train_config, model_config, args.load, args.device)
def gen_images():
parser = argparse.ArgumentParser(description="multiple images as single image")
parser.add_argument('--out', type=Path, default=Path('./tmp/out.png'))
parser.add_argument('--n_rows', type=int, default=5)
parser.add_argument('--n_cols', type=int, default=5)
parser.add_argument('--model_config_path', type=Path, default=Path('./conf/model.yaml'))
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--load', type=Path)
parser.add_argument('--size', type=int)
args = parser.parse_args()
batch_size = args.n_rows * args.n_cols
# init model
model_config = ModelConfig.load(args.model_config_path)
model = CPPN(model_config)
# override size of output
if args.size:
model_config.width = args.size
model_config.height = args.size
if args.load:
assert args.load.exists()
print(f"load model from {args.load}")
chainer.serializers.load_npz(args.load, model)
# model to gpu
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# init x and z
input_data = InputData(width=model_config.width, height=model_config.height, z_size=model_config.z_size)
x, z = [], []
for _ in range(batch_size):
_x, _z = input_data.as_batch()
x.append(_x)
z.append(_z)
x = numpy.concatenate(x)
z = numpy.concatenate(z)
# to device
xp = model.xp
x = chainer.Variable(xp.asarray(x))
z = chainer.Variable(xp.asarray(z))
y = model.forward(x, z)
y = chainer.cuda.to_cpu(y.data)
# chainer variable [B, 1, W, H], float [0, 1] -> numpy array uint8 [0, 255]
y = post_process_output(y)
y = y.reshape((args.n_rows, args.n_cols, 1, input_data.height, input_data.width))
y = y.transpose((0, 3, 1, 4, 2))
y = y.reshape((args.n_rows * input_data.height, args.n_cols * input_data.width))
Image.fromarray(y).save(args.out)
def test_train():
with tempfile.TemporaryDirectory() as tmp_dir:
train_config = train.TrainConfig(
train_image_dir_path=(Path(__file__).parent /
'dammy_image_data').resolve(),
max_iter=2,
batch_size=5,
snapshot_iter_interval=2,
display_iter_interval=1,
n_discriminator_update=3,
evaluation_iter_interval=1)
model_config = ModelConfig(width=64,
height=64,
n_units_xyrz=10,
n_hidden_units=[10, 10],
z_size=2)
train.train(Path(tmp_dir), train_config, model_config)
def test_unconditional_forward():
width = 5
height = 7
z_size = 2
batch_size = 3
model = CPPN(ModelConfig(width=width, height=height, n_units_xyrz=3, n_hidden_units=[5, 5], z_size=z_size))
x, z = [], []
for _ in range(batch_size):
_x, _z = InputData(width=width, height=height, z_size=z_size).as_batch()
x.append(_x)
z.append(_z)
x = numpy.concatenate(x, axis=0)
z = numpy.concatenate(z, axis=0)
y = model.forward(x, z)
assert y.shape == (batch_size, 1, width, height)
def interp_movie():
parser = argparse.ArgumentParser(description="Gen gif movie")
parser.add_argument('--out', type=Path, default=Path('./tmp/out.gif'))
parser.add_argument('--frames', type=int, default=10)
parser.add_argument('--z_points', type=int, default=10)
parser.add_argument('--batch_size', type=int, default=50)
parser.add_argument('--model_config_path',
type=Path,
default=Path('./conf/model.yaml'))
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--load', type=Path)
parser.add_argument('--size', type=int)
args = parser.parse_args()
# create directory to put result
args.out.parent.mkdir(exist_ok=True)
# init model
model_config = ModelConfig.load(args.model_config_path)
# override size of output
if args.size:
model_config.width = args.size
model_config.height = args.size
model = CPPN(model_config)
if args.load:
assert args.load.exists()
print(f"load model from {args.load}")
chainer.serializers.load_npz(args.load, model)
# model to gpu
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# init x and z
input_data = InputData(width=model_config.width,
height=model_config.height,
z_size=model_config.z_size)
# gen frames
images = []
zs = []
for _ in range(args.z_points):
zs.extend(
interp_z(sample_z(model_config.z_size),
sample_z(model_config.z_size), args.frames))
for i in range(0, len(zs), args.batch_size):
begin_idx = i
end_idx = min(i + args.batch_size, len(zs) - 1)
print(f"{begin_idx} -> {end_idx}")
# make input batch
x = []
z = []
for _z in zs[begin_idx:end_idx]:
_x, _z = input_data.as_batch(z=_z)
x.append(_x)
z.append(_z)
if len(x) == 0:
break
x = numpy.concatenate(x)
z = numpy.concatenate(z)
# to device
xp = model.xp
x = chainer.Variable(xp.asarray(x))
z = chainer.Variable(xp.asarray(z))
y = model.forward(x, z)
y = chainer.cuda.to_cpu(y.data)
# chainer variable [B, 1, W, H], float [0, 1] -> numpy array uint8 [0, 255]
y = post_process_output(y)
for _y in y:
images.append(Image.fromarray(_y[0]))
# save as gif
images[0].save(str(args.out), save_all=True, append_images=images)