def _test_img2img_transformer(self, net):
batch_size = 3
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = ""
p_hparams = registry.problem("image_celeba").get_hparams(hparams)
inputs = np.random.randint(256, size=(batch_size, 4, 4, 3))
targets = np.random.randint(256, size=(batch_size, 8, 8, 3))
with self.test_session() as session:
features = {
"inputs": tf.constant(inputs, dtype=tf.int32),
"targets": tf.constant(targets, dtype=tf.int32),
"target_space_id": tf.constant(1, dtype=tf.int32),
}
model = net(hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
logits, _ = model(features)
session.run(tf.global_variables_initializer())
res = session.run(logits)
self.assertEqual(res.shape, (batch_size, 8, 8, 3, 256))
def _testImg2imgTransformer(self, net):
batch_size = 3
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = ""
p_hparams = registry.problem("image_celeba").get_hparams(hparams)
inputs = np.random.random_integers(0, high=255, size=(3, 4, 4, 3))
targets = np.random.random_integers(0, high=255, size=(3, 8, 8, 3))
with self.test_session() as session:
features = {
"inputs": tf.constant(inputs, dtype=tf.int32),
"targets": tf.constant(targets, dtype=tf.int32),
"target_space_id": tf.constant(1, dtype=tf.int32),
}
model = net(hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
logits, _ = model(features)
session.run(tf.global_variables_initializer())
res = session.run(logits)
self.assertEqual(res.shape, (batch_size, 8, 8, 3, 256))
def img2img_transformer_2d_adversarial():
"""Basic parameters for an adversarial_transformer."""
hparams = img2img_transformer2d_tiny()
hparams.label_smoothing = 0.0
hparams.hidden_size = 128
hparams.batch_size = 64
hparams.add_hparam("z_size", 64)
hparams.add_hparam("c_dim", 1)
hparams.add_hparam("height", 28)
hparams.add_hparam("width", 28)
hparams.add_hparam("discriminator_batchnorm", int(True))
hparams.add_hparam("l2_multiplier", 0.1)
hparams.add_hparam("loss_variant", "vanilla_gan")
hparams.add_hparam("gan_loss_multiplier", 2)
hparams.add_hparam("num_compress_steps", 3)
hparams.add_hparam("num_sliced_vecs", 4096)
hparams.add_hparam("discriminator_num_filters", 64)
hparams.add_hparam("discriminator_tanh_output", False)
hparams.add_hparam("label_smoothing_factor", 0.0)
hparams.learning_rate_warmup_steps = 2000
return hparams
def test_transformer2d_single_step_e2e(self):
"""Minimal end-to-end test of training and eval on allen_brain_image2image.
Notes:
* Runs problem generate_data
* Runs a single step of training
* Runs model in eval mode to obtain a prediction and confirms the
resulting shape.
* TODO: Running this in predict mode crashes in my environment.
Separately have seen predict mode not produce the right shape
output tensors, as if .infer is still a wip.
"""
problem_object = allen_brain.Img2imgAllenBrainDim8to32()
with TemporaryDirectory() as tmp_dir:
mock_raw_data(tmp_dir, raw_dim=256, num_images=100)
with TemporaryDirectory() as data_dir:
problem_object.generate_data(data_dir, tmp_dir)
input_xy_dim = problem_object.input_dim
target_xy_dim = problem_object.output_dim
num_channels = problem_object.num_channels
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = data_dir
p_hparams = problem_object.get_hparams(hparams)
model = image_transformer_2d.Img2imgTransformer(
hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
@tfe.implicit_value_and_gradients
def loss_fn(features):
_, losses = model(features)
return losses["training"]
batch_size = 1
train_dataset = problem_object.dataset(Modes.TRAIN, data_dir)
train_dataset = train_dataset.repeat(None).batch(batch_size)
optimizer = tf.train.AdamOptimizer()
example = tfe.Iterator(train_dataset).next()
example["targets"] = tf.reshape(
example["targets"],
[batch_size, target_xy_dim, target_xy_dim, num_channels])
_, gv = loss_fn(example)
optimizer.apply_gradients(gv)
model.set_mode(Modes.EVAL)
dataset = problem_object.dataset(Modes.EVAL, data_dir)
example = tfe.Iterator(dataset).next()
example["inputs"] = tf.reshape(
example["inputs"],
[1, input_xy_dim, input_xy_dim, num_channels])
example["targets"] = tf.reshape(
example["targets"],
[1, target_xy_dim, target_xy_dim, num_channels])
predictions, _ = model(example)
self.assertEqual(
predictions.numpy().shape,
(1, target_xy_dim, target_xy_dim, num_channels, 256))
def test_transformer2d_single_step_e2e(self):
"""Minimal end-to-end test of training and eval on allen_brain_image2image.
Notes:
* Runs problem generate_data
* Runs a single step of training
* Runs model in eval mode to obtain a prediction and confirms the
resulting shape.
* TODO: Running this in predict mode crashes in my environment.
Separately have seen predict mode not produce the right shape
output tensors, as if .infer is still a wip.
"""
problem_object = allen_brain.Img2imgAllenBrainDim8to32()
with TemporaryDirectory() as tmp_dir:
mock_raw_data(tmp_dir, raw_dim=256, num_images=100)
with TemporaryDirectory() as data_dir:
problem_object.generate_data(data_dir, tmp_dir)
input_xy_dim = problem_object.input_dim
target_xy_dim = problem_object.output_dim
num_channels = problem_object.num_channels
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = data_dir
p_hparams = problem_object.get_hparams(hparams)
model = image_transformer_2d.Img2imgTransformer(
hparams, tf.estimator.ModeKeys.TRAIN, p_hparams
)
@tfe.implicit_value_and_gradients
def loss_fn(features):
_, losses = model(features)
return losses["training"]
batch_size = 1
train_dataset = problem_object.dataset(Modes.TRAIN, data_dir)
train_dataset = train_dataset.repeat(None).batch(batch_size)
optimizer = tf.train.AdamOptimizer()
example = tfe.Iterator(train_dataset).next()
example["targets"] = tf.reshape(example["targets"],
[batch_size,
target_xy_dim,
target_xy_dim,
num_channels])
_, gv = loss_fn(example)
optimizer.apply_gradients(gv)
model.set_mode(Modes.EVAL)
dataset = problem_object.dataset(Modes.EVAL, data_dir)
example = tfe.Iterator(dataset).next()
example["inputs"] = tf.reshape(example["inputs"],
[1,
input_xy_dim,
input_xy_dim,
num_channels])
example["targets"] = tf.reshape(example["targets"],
[1,
target_xy_dim,
target_xy_dim,
num_channels])
predictions, _ = model(example)
self.assertEqual(predictions.numpy().shape,
(1,
target_xy_dim,
target_xy_dim,
num_channels,
256))
def _build_layers_v2(self, input_dict, num_outputs, options):
inputs = input_dict["obs"]
filters = options.get("conv_filters")
if not filters:
filters = _get_filter_config(inputs.shape.as_list()[1:])
activation = get_activation_fn(options.get("conv_activation"))
inputs = slim.conv2d(inputs,
16, (3, 3),
1,
activation_fn=activation,
scope="conv_trans_in")
tf.layers.max_pooling2d(
inputs,
(2, 2),
strides=1,
padding='same',
# data_format='channels_last',
name="pooling")
""" Begin Transformer"""
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = ""
hparams.img_len = IMAGE
hparams.num_channels = 16
hparams.hidden_size = 8
p_hparams = Img2imgCeleba().get_hparams(hparams)
p_hparams.modality = {
"inputs": modalities.ModalityType.IMAGE,
"targets": modalities.ModalityType.IMAGE,
}
p_hparams.vocab_size = {
"inputs": IMAGE,
"targets": IMAGE,
}
features = {
"inputs": inputs,
#"targets": target,
#"target_space_id": tf.constant(1, dtype=tf.int32),
}
#model = image_transformer_2d.Img2imgTransformer(hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
model = ImgEncTransformer(hparams, tf.estimator.ModeKeys.TRAIN,
p_hparams)
trans_logits, trans_losses = model(features)
print("trans_logits", trans_logits)
print("inputs", inputs)
""" End Transformer"""
#inputs = trans_logits
## TAKE CARE! Normalization?!
inputs = tf.contrib.layers.batch_norm(
trans_logits,
data_format=
'NHWC', # Matching the "cnn" tensor which has shape (?, 480, 640, 128).
center=True,
scale=True,
#is_training=training,
scope='cnn-batch_norm')
with tf.name_scope("vision_net"):
for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
inputs = slim.conv2d(inputs,
out_size,
kernel,
stride,
activation_fn=activation,
scope="conv{}".format(i))
print(i, inputs)
out_size, kernel, stride = filters[-1]
fc1 = slim.conv2d(inputs,
out_size,
kernel,
stride,
activation_fn=activation,
padding="VALID",
scope="fc1")
fc2 = slim.conv2d(fc1,
num_outputs, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope="fc2")
print(fc1, fc2)
print(flatten(fc1), flatten(fc2))
# exit(123)
return flatten(fc2), flatten(fc1)
# model = net(hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
# logits, _ = model(features)
# session.run(tf.global_variables_initializer())
# res = session.run(logits)
# self.assertEqual(res.shape, (batch_size, size, size, 3, vocab_size))
#
# def testImagetransformer2d(self):
# self._test_imagetransformer_2d(image_transformer_2d.Imagetransformer2d)
if __name__ == "__main__":
#tf.test.main()
net = image_transformer_2d.Img2imgTransformer
dic = get_feature1()
batch_size = 5
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = ""
# p_hparams = registry.problem("image_celeba").get_hparams(hparams)
p_hparams = registry.problem("img2img_celeba").get_hparams(hparams)
inputs = np.random.randint(256, size=(batch_size, 4, 4, 3))
targets = np.random.randint(256, size=(batch_size, 8, 8, 3))
with tf.Session() as session:
features = {
"inputs": tf.constant(inputs, dtype=tf.int32),
"targets": tf.constant(targets, dtype=tf.int32),
"target_space_id": tf.constant(1, dtype=tf.int32),
}
model = net(hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
logits, _ = model(features)
rst = model.body(dic)
rst = model.model_fn(features)
