Merge remote-tracking branch 'tensorflow/master'

research/gan/mnist_estimator/launch_jobs.sh

+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#!/bin/bash
+#
+# This script performs the following operations:
+# 1. Downloads the MNIST dataset.
+# 2. Trains an unconditional model on the MNIST training set using a
+#    tf.Estimator.
+# 3. Evaluates the models and writes sample images to disk.
+#
+#
+# Usage:
+# cd models/research/gan/mnist_estimator
+# ./launch_jobs.sh ${git_repo}
+set -e
+
+# Location of the git repository.
+git_repo=$1
+if [[ "$git_repo" == "" ]]; then
+  echo "'git_repo' must not be empty."
+  exit
+fi
+
+# Base name for where the evaluation images will be saved to.
+EVAL_DIR=/tmp/mnist-estimator
+
+# Where the dataset is saved to.
+DATASET_DIR=/tmp/mnist-data
+
+export PYTHONPATH=$PYTHONPATH:$git_repo:$git_repo/research:$git_repo/research/gan:$git_repo/research/slim
+
+# A helper function for printing pretty output.
+Banner () {
+  local text=$1
+  local green='\033[0;32m'
+  local nc='\033[0m'  # No color.
+  echo -e "${green}${text}${nc}"
+}
+
+# Download the dataset.
+python "${git_repo}/research/slim/download_and_convert_data.py" \
+  --dataset_name=mnist \
+  --dataset_dir=${DATASET_DIR}
+
+# Run unconditional GAN.
+NUM_STEPS=1600
+Banner "Starting training GANEstimator ${NUM_STEPS} steps..."
+python "${git_repo}/research/gan/mnist_estimator/train.py" \
+  --max_number_of_steps=${NUM_STEPS} \
+  --eval_dir=${EVAL_DIR} \
+  --dataset_dir=${DATASET_DIR} \
+  --alsologtostderr
+Banner "Finished training GANEstimator ${NUM_STEPS} steps. See ${EVAL_DIR} for output images."

research/gan/mnist_estimator/train.py

+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Trains a GANEstimator on MNIST data."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+
+import numpy as np
+import scipy.misc
+import tensorflow as tf
+
+from mnist import data_provider
+from mnist import networks
+
+tfgan = tf.contrib.gan
+flags = tf.flags
+
+flags.DEFINE_integer('batch_size', 32,
+                     'The number of images in each train batch.')
+
+flags.DEFINE_integer('max_number_of_steps', 20000,
+                     'The maximum number of gradient steps.')
+
+flags.DEFINE_integer(
+    'noise_dims', 64, 'Dimensions of the generator noise vector')
+
+flags.DEFINE_string('dataset_dir', None, 'Location of data.')
+
+flags.DEFINE_string('eval_dir', '/tmp/mnist-estimator/',
+                    'Directory where the results are saved to.')
+
+FLAGS = flags.FLAGS
+
+
+def _get_train_input_fn(batch_size, noise_dims, dataset_dir=None,
+                        num_threads=4):
+  def train_input_fn():
+    with tf.device('/cpu:0'):
+      images, _, _ = data_provider.provide_data(
+          'train', batch_size, dataset_dir, num_threads=num_threads)
+    noise = tf.random_normal([batch_size, noise_dims])
+    return noise, images
+  return train_input_fn
+
+
+def _get_predict_input_fn(batch_size, noise_dims):
+  def predict_input_fn():
+    noise = tf.random_normal([batch_size, noise_dims])
+    return noise
+  return predict_input_fn
+
+
+def main(_):
+  # Initialize GANEstimator with options and hyperparameters.
+  gan_estimator = tfgan.estimator.GANEstimator(
+      generator_fn=networks.unconditional_generator,
+      discriminator_fn=networks.unconditional_discriminator,
+      generator_loss_fn=tfgan.losses.wasserstein_generator_loss,
+      discriminator_loss_fn=tfgan.losses.wasserstein_discriminator_loss,
+      generator_optimizer=tf.train.AdamOptimizer(0.001, 0.5),
+      discriminator_optimizer=tf.train.AdamOptimizer(0.0001, 0.5),
+      add_summaries=tfgan.estimator.SummaryType.IMAGES)
+
+  # Train estimator.
+  train_input_fn = _get_train_input_fn(
+      FLAGS.batch_size, FLAGS.noise_dims, FLAGS.dataset_dir)
+  gan_estimator.train(train_input_fn, max_steps=FLAGS.max_number_of_steps)
+
+  # Run inference.
+  predict_input_fn = _get_predict_input_fn(36, FLAGS.noise_dims)
+  prediction_iterable = gan_estimator.predict(predict_input_fn)
+  predictions = [prediction_iterable.next() for _ in xrange(36)]
+
+  # Nicely tile.
+  image_rows = [np.concatenate(predictions[i:i+6], axis=0) for i in
+                range(0, 36, 6)]
+  tiled_image = np.concatenate(image_rows, axis=1)
+
+  # Write to disk.
+  if not tf.gfile.Exists(FLAGS.eval_dir):
+    tf.gfile.MakeDirs(FLAGS.eval_dir)
+  scipy.misc.imsave(os.path.join(FLAGS.eval_dir, 'unconditional_gan.png'),
+                    np.squeeze(tiled_image, axis=2))
+
+
+if __name__ == '__main__':
+  tf.app.run()

research/gan/mnist_estimator/train_test.py

+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for mnist_estimator.train."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import numpy as np
+
+import tensorflow as tf
+
+import train
+
+FLAGS = tf.flags.FLAGS
+mock = tf.test.mock
+
+
+class TrainTest(tf.test.TestCase):
+
+  @mock.patch.object(train, 'data_provider', autospec=True)
+  def test_full_flow(self, mock_data_provider):
+    FLAGS.eval_dir = self.get_temp_dir()
+    FLAGS.batch_size = 16
+    FLAGS.max_number_of_steps = 2
+    FLAGS.noise_dims = 3
+
+    # Construct mock inputs.
+    mock_imgs = np.zeros([FLAGS.batch_size, 28, 28, 1], dtype=np.float32)
+    mock_lbls = np.concatenate(
+        (np.ones([FLAGS.batch_size, 1], dtype=np.int32),
+         np.zeros([FLAGS.batch_size, 9], dtype=np.int32)), axis=1)
+    mock_data_provider.provide_data.return_value = (mock_imgs, mock_lbls, None)
+
+    train.main(None)
+
+
+if __name__ == '__main__':
+  tf.test.main()

research/gan/pix2pix/launch_jobs.sh

+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#!/bin/bash
+#
+# This script performs the following operations:
+# 1. Downloads the Imagenet dataset.
+# 2. Trains image compression model on patches from Imagenet.
+# 3. Evaluates the models and writes sample images to disk.
+#
+# Usage:
+# cd models/research/gan/image_compression
+# ./launch_jobs.sh ${weight_factor} ${git_repo}
+set -e
+
+# Weight of the adversarial loss.
+weight_factor=$1
+if [[ "$weight_factor" == "" ]]; then
+  echo "'weight_factor' must not be empty."
+  exit
+fi
+
+# Location of the git repository.
+git_repo=$2
+if [[ "$git_repo" == "" ]]; then
+  echo "'git_repo' must not be empty."
+  exit
+fi
+
+# Base name for where the checkpoint and logs will be saved to.
+TRAIN_DIR=/tmp/compression-model
+
+# Base name for where the evaluation images will be saved to.
+EVAL_DIR=/tmp/compression-model/eval
+
+# Where the dataset is saved to.
+DATASET_DIR=/tmp/imagenet-data
+
+export PYTHONPATH=$PYTHONPATH:$git_repo:$git_repo/research:$git_repo/research/slim:$git_repo/research/slim/nets
+
+# A helper function for printing pretty output.
+Banner () {
+  local text=$1
+  local green='\033[0;32m'
+  local nc='\033[0m'  # No color.
+  echo -e "${green}${text}${nc}"
+}
+
+# Download the dataset.
+bazel build "${git_repo}/research/slim:download_and_convert_imagenet"
+"./bazel-bin/download_and_convert_imagenet" ${DATASET_DIR}
+
+# Run the pix2pix model.
+NUM_STEPS=10000
+MODEL_TRAIN_DIR="${TRAIN_DIR}/wt${weight_factor}"
+Banner "Starting training an image compression model for ${NUM_STEPS} steps..."
+python "${git_repo}/research/gan/image_compression/train.py" \
+  --train_log_dir=${MODEL_TRAIN_DIR} \
+  --dataset_dir=${DATASET_DIR} \
+  --max_number_of_steps=${NUM_STEPS} \
+  --weight_factor=${weight_factor} \
+  --alsologtostderr
+Banner "Finished training pix2pix model ${NUM_STEPS} steps."

research/gan/pix2pix/networks.py

+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Networks for GAN Pix2Pix example using TFGAN."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from slim.nets import cyclegan
+from slim.nets import pix2pix
+
+
+def generator(input_images):
+  """Thin wrapper around CycleGAN generator to conform to the TFGAN API.
+
+  Args:
+    input_images: A batch of images to translate. Images should be normalized
+      already. Shape is [batch, height, width, channels].
+
+  Returns:
+    Returns generated image batch.
+  """
+  input_images.shape.assert_has_rank(4)
+  with tf.contrib.framework.arg_scope(cyclegan.cyclegan_arg_scope()):
+    output_images, _ = cyclegan.cyclegan_generator_resnet(input_images)
+  return output_images
+
+
+def discriminator(image_batch, unused_conditioning=None):
+  """A thin wrapper around the Pix2Pix discriminator to conform to TFGAN API."""
+  with tf.contrib.framework.arg_scope(pix2pix.pix2pix_arg_scope()):
+    logits_4d, _ = pix2pix.pix2pix_discriminator(
+        image_batch, num_filters=[64, 128, 256, 512])
+    logits_4d.shape.assert_has_rank(4)
+  # Output of logits is 4D. Reshape to 2D, for TFGAN.
+  logits_2d = tf.contrib.layers.flatten(logits_4d)
+
+  return logits_2d

research/gan/pix2pix/networks_test.py

+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for tfgan.examples.networks.networks."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+from google3.third_party.tensorflow_models.gan.pix2pix import networks
+
+
+class Pix2PixTest(tf.test.TestCase):
+
+  def test_generator_run(self):
+    img_batch = tf.zeros([3, 128, 128, 3])
+    model_output = networks.generator(img_batch)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      sess.run(model_output)
+
+  def test_generator_graph(self):
+    for shape in ([4, 32, 32], [3, 128, 128], [2, 80, 400]):
+      tf.reset_default_graph()
+      img = tf.ones(shape + [3])
+      output_imgs = networks.generator(img)
+
+      self.assertAllEqual(shape + [3], output_imgs.shape.as_list())
+
+  def test_generator_graph_unknown_batch_dim(self):
+    img = tf.placeholder(tf.float32, shape=[None, 32, 32, 3])
+    output_imgs = networks.generator(img)
+
+    self.assertAllEqual([None, 32, 32, 3], output_imgs.shape.as_list())
+
+  def test_generator_invalid_input(self):
+    with self.assertRaisesRegexp(ValueError, 'must have rank 4'):
+      networks.generator(tf.zeros([28, 28, 3]))
+
+  def test_discriminator_run(self):
+    img_batch = tf.zeros([3, 70, 70, 3])
+    disc_output = networks.discriminator(img_batch)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      sess.run(disc_output)
+
+  def test_discriminator_graph(self):
+    # Check graph construction for a number of image size/depths and batch
+    # sizes.
+    for batch_size, patch_size in zip([3, 6], [70, 128]):
+      tf.reset_default_graph()
+      img = tf.ones([batch_size, patch_size, patch_size, 3])
+      disc_output = networks.discriminator(img)
+
+      self.assertEqual(2, disc_output.shape.ndims)
+      self.assertEqual(batch_size, disc_output.shape.as_list()[0])
+
+  def test_discriminator_invalid_input(self):
+    with self.assertRaisesRegexp(ValueError, 'Shape must be rank 4'):
+      networks.discriminator(tf.zeros([28, 28, 3]))
+
+
+if __name__ == '__main__':
+  tf.test.main()

research/gan/pix2pix/train.py

+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Trains an image-to-image translation network with an adversarial loss."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+
+import tensorflow as tf
+
+import data_provider
+from google3.third_party.tensorflow_models.gan.pix2pix import networks
+
+flags = tf.flags
+tfgan = tf.contrib.gan
+
+
+flags.DEFINE_integer('batch_size', 10, 'The number of images in each batch.')
+
+flags.DEFINE_integer('patch_size', 32, 'The size of the patches to train on.')
+
+flags.DEFINE_string('master', '', 'Name of the TensorFlow master to use.')
+
+flags.DEFINE_string('train_log_dir', '/tmp/pix2pix/',
+                    'Directory where to write event logs.')
+
+flags.DEFINE_float('generator_lr', 0.00001,
+                   'The compression model learning rate.')
+
+flags.DEFINE_float('discriminator_lr', 0.00001,
+                   'The discriminator learning rate.')
+
+flags.DEFINE_integer('max_number_of_steps', 2000000,
+                     'The maximum number of gradient steps.')
+
+flags.DEFINE_integer(
+    'ps_tasks', 0,
+    'The number of parameter servers. If the value is 0, then the parameters '
+    'are handled locally by the worker.')
+
+flags.DEFINE_integer(
+    'task', 0,
+    'The Task ID. This value is used when training with multiple workers to '
+    'identify each worker.')
+
+flags.DEFINE_float(
+    'weight_factor', 0.0,
+    'How much to weight the adversarial loss relative to pixel loss.')
+
+flags.DEFINE_string('dataset_dir', None, 'Location of data.')
+
+
+FLAGS = flags.FLAGS
+
+
+def main(_):
+  if not tf.gfile.Exists(FLAGS.train_log_dir):
+    tf.gfile.MakeDirs(FLAGS.train_log_dir)
+
+  with tf.device(tf.train.replica_device_setter(FLAGS.ps_tasks)):
+    # Get real and distorted images.
+    with tf.device('/cpu:0'), tf.name_scope('inputs'):
+      real_images = data_provider.provide_data(
+          'train', FLAGS.batch_size, dataset_dir=FLAGS.dataset_dir,
+          patch_size=FLAGS.patch_size)
+    distorted_images = _distort_images(
+        real_images, downscale_size=int(FLAGS.patch_size / 2),
+        upscale_size=FLAGS.patch_size)
+
+    # Create a GANModel tuple.
+    gan_model = tfgan.gan_model(
+        generator_fn=networks.generator,
+        discriminator_fn=networks.discriminator,
+        real_data=real_images,
+        generator_inputs=distorted_images)
+    tfgan.eval.add_image_comparison_summaries(
+        gan_model, num_comparisons=3, display_diffs=True)
+    tfgan.eval.add_gan_model_image_summaries(gan_model, grid_size=3)
+
+    # Define the GANLoss tuple using standard library functions.
+    with tf.name_scope('losses'):
+      gan_loss = tfgan.gan_loss(
+          gan_model,
+          generator_loss_fn=tfgan.losses.least_squares_generator_loss,
+          discriminator_loss_fn=tfgan.losses.least_squares_discriminator_loss)
+
+      # Define the standard L1 pixel loss.
+      l1_pixel_loss = tf.norm(gan_model.real_data - gan_model.generated_data,
+                              ord=1) / FLAGS.patch_size ** 2
+
+      # Modify the loss tuple to include the pixel loss. Add summaries as well.
+      gan_loss = tfgan.losses.combine_adversarial_loss(
+          gan_loss, gan_model, l1_pixel_loss,
+          weight_factor=FLAGS.weight_factor)
+
+    with tf.name_scope('train_ops'):
+      # Get the GANTrain ops using the custom optimizers and optional
+      # discriminator weight clipping.
+      gen_lr, dis_lr = _lr(FLAGS.generator_lr, FLAGS.discriminator_lr)
+      gen_opt, dis_opt = _optimizer(gen_lr, dis_lr)
+      train_ops = tfgan.gan_train_ops(
+          gan_model,
+          gan_loss,
+          generator_optimizer=gen_opt,
+          discriminator_optimizer=dis_opt,
+          summarize_gradients=True,
+          colocate_gradients_with_ops=True,
+          aggregation_method=tf.AggregationMethod.EXPERIMENTAL_ACCUMULATE_N,
+          transform_grads_fn=tf.contrib.training.clip_gradient_norms_fn(1e3))
+      tf.summary.scalar('generator_lr', gen_lr)
+      tf.summary.scalar('discriminator_lr', dis_lr)
+
+    # Use GAN train step function if using adversarial loss, otherwise
+    # only train the generator.
+    train_steps = tfgan.GANTrainSteps(
+        generator_train_steps=1,
+        discriminator_train_steps=int(FLAGS.weight_factor > 0))
+
+    # Run the alternating training loop. Skip it if no steps should be taken
+    # (used for graph construction tests).
+    status_message = tf.string_join(
+        ['Starting train step: ',
+         tf.as_string(tf.train.get_or_create_global_step())],
+        name='status_message')
+    if FLAGS.max_number_of_steps == 0: return
+    tfgan.gan_train(
+        train_ops,
+        FLAGS.train_log_dir,
+        get_hooks_fn=tfgan.get_sequential_train_hooks(train_steps),
+        hooks=[tf.train.StopAtStepHook(num_steps=FLAGS.max_number_of_steps),
+               tf.train.LoggingTensorHook([status_message], every_n_iter=10)],
+        master=FLAGS.master,
+        is_chief=FLAGS.task == 0)
+
+
+def _optimizer(gen_lr, dis_lr):
+  kwargs = {'beta1': 0.5, 'beta2': 0.999}
+  generator_opt = tf.train.AdamOptimizer(gen_lr, **kwargs)
+  discriminator_opt = tf.train.AdamOptimizer(dis_lr, **kwargs)
+  return generator_opt, discriminator_opt
+
+
+def _lr(gen_lr_base, dis_lr_base):
+  """Return the generator and discriminator learning rates."""
+  gen_lr = tf.train.exponential_decay(
+      learning_rate=gen_lr_base,
+      global_step=tf.train.get_or_create_global_step(),
+      decay_steps=100000,
+      decay_rate=0.8,
+      staircase=True,)
+  dis_lr = dis_lr_base
+
+  return gen_lr, dis_lr
+
+
+def _distort_images(images, downscale_size, upscale_size):
+  downscaled = tf.image.resize_area(images, [downscale_size] * 2)
+  upscaled = tf.image.resize_area(downscaled, [upscale_size] * 2)
+  return upscaled
+
+
+if __name__ == '__main__':
+  tf.app.run()
+

research/gan/pix2pix/train_test.py

+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for pix2pix.train."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import numpy as np
+import tensorflow as tf
+from google3.third_party.tensorflow_models.gan.pix2pix import train
+
+FLAGS = tf.flags.FLAGS
+mock = tf.test.mock
+
+
+class TrainTest(tf.test.TestCase):
+
+  def _test_build_graph_helper(self, weight_factor):
+    FLAGS.max_number_of_steps = 0
+    FLAGS.weight_factor = weight_factor
+    FLAGS.batch_size = 9
+    FLAGS.patch_size = 32
+
+    mock_imgs = np.zeros(
+        [FLAGS.batch_size, FLAGS.patch_size, FLAGS.patch_size, 3],
+        dtype=np.float32)
+    with mock.patch.object(train, 'data_provider') as mock_data_provider:
+      mock_data_provider.provide_data.return_value = mock_imgs
+      train.main(None)
+
+  def test_build_graph_noadversarialloss(self):
+    self._test_build_graph_helper(0.0)
+
+  def test_build_graph_adversarialloss(self):
+    self._test_build_graph_helper(1.0)
+
+if __name__ == '__main__':
+  tf.test.main()
+

research/inception/README.md

-**NOTE**: For the most part, you will find a newer version of this code at [models/research/slim](https://github.com/tensorflow/models/tree/master/research/slim). In particular:
+**NOTE: For the most part, you will find a newer version of this code at [models/research/slim](https://github.com/tensorflow/models/tree/master/research/slim).** In particular:
 
 *   `inception_train.py` and `imagenet_train.py` should no longer be used. The slim editions for running on multiple GPUs are the current best examples.
 *   `inception_distributed_train.py` and `imagenet_distributed_train.py` are still valid examples of distributed training.
 
 For performance benchmarking, please see https://www.tensorflow.org/performance/benchmarks.
 
+---
+
 # Inception in TensorFlow
 
 [ImageNet](http://www.image-net.org/) is a common academic data set in machine

research/object_detection/dataset_tools/create_pet_tf_record.py

@@ -160,8 +160,6 @@ def dict_to_tf_example(data,
     if not faces_only:
       mask_remapped = mask_np != 2
       masks.append(mask_remapped)
-    mask_stack = np.stack(masks).astype(np.float32)
-    masks_flattened = np.reshape(mask_stack, [-1])
 
   feature_dict = {
       'image/height': dataset_util.int64_feature(height),
@@ -184,8 +182,11 @@ def dict_to_tf_example(data,
       'image/object/view': dataset_util.bytes_list_feature(poses),
   }
   if not faces_only:
+    mask_stack = np.stack(masks).astype(np.float32)
+    masks_flattened = np.reshape(mask_stack, [-1])
     feature_dict['image/object/mask'] = (
         dataset_util.float_list_feature(masks_flattened.tolist()))
+
   example = tf.train.Example(features=tf.train.Features(feature=feature_dict))
   return example
 

research/object_detection/eval.py

@@ -103,7 +103,10 @@ def main(unused_argv):
 
   model_config = configs['model']
   eval_config = configs['eval_config']
-  input_config = configs['eval_input_config']
+  if FLAGS.eval_training_data:
+    input_config = configs['train_input_config']
+  else:
+    input_config = configs['eval_input_config']
 
   model_fn = functools.partial(
       model_builder.build,

research/object_detection/g3doc/exporting_models.md

@@ -8,7 +8,7 @@ graph proto. A checkpoint will typically consist of three files:
 * model.ckpt-${CHECKPOINT_NUMBER}.meta
 
 After you've identified a candidate checkpoint to export, run the following
-command from tensorflow/models/research/object_detection:
+command from tensorflow/models/research/:
 
 ``` bash
 # From tensorflow/models/research/

research/object_detection/g3doc/running_pets.md

@@ -81,7 +81,7 @@ Oxford-IIIT Pet dataset into TFRecords. Run the following commands from the
 
 ``` bash
 # From tensorflow/models/research/
-python object_detection/create_pet_tf_record.py \
+python object_detection/dataset_tools/create_pet_tf_record.py \
     --label_map_path=object_detection/data/pet_label_map.pbtxt \
     --data_dir=`pwd` \
     --output_dir=`pwd`

research/object_detection/object_detection_tutorial.ipynb

@@ -36,8 +36,8 @@
     "from matplotlib import pyplot as plt\n",
     "from PIL import Image\n",
     "\n",
-    "if tf.__version__ != '1.4.0':\n",
-    "  raise ImportError('Please upgrade your tensorflow installation to v1.4.0!')\n"
+    "if tf.__version__ < '1.4.0':\n",
+    "  raise ImportError('Please upgrade your tensorflow installation to v1.4.* or later!')\n"
    ]
   },
   {

research/ptn/eval_rotator.py

@@ -64,7 +64,7 @@ flags.DEFINE_float('clip_gradient_norm', 0, '')
 flags.DEFINE_integer('save_summaries_secs', 15, '')
 flags.DEFINE_integer('eval_interval_secs', 60 * 5, '')
 # Scheduling
-flags.DEFINE_string('master', 'local', '')
+flags.DEFINE_string('master', '', '')
 
 FLAGS = flags.FLAGS
 

research/ptn/train_ptn.py

@@ -44,7 +44,7 @@ flags.DEFINE_integer('image_size', 64,
                      'Input images dimension (pixels) - width & height.')
 flags.DEFINE_integer('vox_size', 32, 'Voxel prediction dimension.')
 flags.DEFINE_integer('step_size', 24, 'Steps to take in rotation to fetch viewpoints.')
-flags.DEFINE_integer('batch_size', 1, 'Batch size while training.')
+flags.DEFINE_integer('batch_size', 6, 'Batch size while training.')
 flags.DEFINE_float('focal_length', 0.866, 'Focal length parameter used in perspective projection.')
 flags.DEFINE_float('focal_range', 1.732, 'Focal length parameter used in perspective projection.')
 flags.DEFINE_string('encoder_name', 'ptn_encoder',

research/slim/datasets/download_and_convert_imagenet.sh

@@ -45,7 +45,9 @@
 # downloading the raw images.
 #
 # usage:
-#  ./download_and_convert_imagenet.sh [data-dir]
+#  cd research/slim
+#  bazel build :download_and_convert_imagenet
+#  ./bazel-bin/download_and_convert_imagenet.sh [data-dir]
 set -e
 
 if [ -z "$1" ]; then
@@ -58,7 +60,7 @@ DATA_DIR="${1%/}"
 SCRATCH_DIR="${DATA_DIR}/raw-data/"
 mkdir -p "${DATA_DIR}"
 mkdir -p "${SCRATCH_DIR}"
-WORK_DIR="$0.runfiles/third_party/tensorflow_models/research/slim"
+WORK_DIR="$0.runfiles/__main__"
 
 # Download the ImageNet data.
 LABELS_FILE="${WORK_DIR}/datasets/imagenet_lsvrc_2015_synsets.txt"

research/slim/datasets/download_imagenet.sh

@@ -49,7 +49,7 @@ mkdir -p "${BBOX_DIR}"
 cd "${OUTDIR}"
 
 # Download and process all of the ImageNet bounding boxes.
-BASE_URL="http://www.image-net.org/challenges/LSVRC/2012/nonpub"
+BASE_URL="http://www.image-net.org/challenges/LSVRC/2012/nnoupb"
 
 # See here for details: http://www.image-net.org/download-bboxes
 BOUNDING_BOX_ANNOTATIONS="${BASE_URL}/ILSVRC2012_bbox_train_v2.tar.gz"

research/slim/nets/cyclegan.py

@@ -17,7 +17,6 @@ from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
-import google3
 import numpy as np
 
 import tensorflow as tf