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)