Merge branch 'master' of github.com:bousmalis/models

README.md

@@ -9,9 +9,9 @@ To propose a model for inclusion please submit a pull request.
 
 ## Models
 - [autoencoder](autoencoder): various autoencoders.
-- [domain_adaptation](domain_adaptation): Domain Separation Networks.
 - [compression](compression): compressing and decompressing images using a pre-trained Residual GRU network.
 - [differential_privacy](differential_privacy): privacy-preserving student models from multiple teachers.
+- [domain_adaptation](domain_adaptation): domain separation networks.
 - [im2txt](im2txt): image-to-text neural network for image captioning.
 - [inception](inception): deep convolutional networks for computer vision.
 - [learning_to_remember_rare_events](learning_to_remember_rare_events):  a large-scale life-long memory module for use in deep learning.

domain_adaptation/domain_separation/README.md → domain_adaptation/README.md

-# Domain Seperation Networks
+# Domain Separation Networks
 
 
 ## Introduction
@@ -25,14 +25,20 @@ Twitter @bousmalis.
 In order to run the MNIST to MNIST-M experiments with DANNs and/or DANNs with
 domain separation (DSNs) you will need to set the directory you used to download
 MNIST and MNIST-M:\
+
+```
 $ export DSN_DATA_DIR=/your/dir
+```
 
 Then you need to build the binaries with Bazel:
 
+```
 $ bazel build -c opt domain_adaptation/domain_separation/...
+```
 
 You can then train with the following command:
 
+```
 $ ./bazel-bin/domain_adaptation/domain_separation/dsn_train  \
       --similarity_loss=dann_loss  \
       --basic_tower=dann_mnist  \
@@ -46,55 +52,13 @@ $ ./bazel-bin/domain_adaptation/domain_separation/dsn_train  \
       --master=""  \
       --dataset_dir=${DSN_DATA_DIR}  \
       -v --use_logging
+```
+
 
+Evaluation can be invoked with the following command:
 
-Evaluation can be invoked with the following command:\
+```
 $ ./bazel-bin/domain_adaptation/domain_separation/dsn_eval  \
     -v --dataset mnist_m --split test --num_examples=9001  \
     --dataset_dir=${DSN_DATA_DIR}
-# Domain Seperation Networks
-
-## Introduction
-This code is the code used for the "Domain Separation Networks" paper
-by Bousmalis K., Trigeorgis G., et al. which was presented at NIPS 2016. The
-paper can be found here: https://arxiv.org/abs/1608.06019
-
-## Contact
-This code was open-sourced by Konstantinos Bousmalis (konstantinos@google.com, github:bousmalis)
-
-## Installation
-You will need to have the following installed on your machine before trying out the DSN code.
-
-*  Tensorflow: https://www.tensorflow.org/install/
-*  Bazel: https://bazel.build/
-
-## Running the code for adapting MNIST to MNIST-M
-In order to run the MNIST to MNIST-M experiments with DANNs and/or DANNs with
-domain separation (DSNs) you will need to set the directory you used to download
-MNIST and MNIST-M:\
-$ export DSN_DATA_DIR=/your/dir
-
-Then you need to build the binaries with Bazel:
-
-$ bazel build -c opt domain_adaptation/domain_separation/...
-
-Add models and models/slim to your $PYTHONPATH:
-
-$ export PYTHONPATH=$PYTHONPATH:$PWD/slim\
-$ export PYTHONPATH=$PYTHONPATH:$PWD
-
-You can then train with the following command:
-
-$ ./bazel-bin/domain_adaptation/domain_separation/dsn_train \
-      --similarity_loss=dann_loss  \
-      --basic_tower=dann_mnist  \
-      --source_dataset=mnist  \
-      --target_dataset=mnist_m  \
-      --learning_rate=0.0117249  \
-      --gamma_weight=0.251175  \
-      --weight_decay=1e-6  \
-      --layers_to_regularize=fc3  \
-      --nouse_separation  \
-      --master=""  \
-      --dataset_dir=${DSN_DATA_DIR}  \
-      -v --use_logging
+```

domain_adaptation/domain_separation/dsn.py

@@ -282,15 +282,17 @@ def add_autoencoders(source_data, source_shared, target_data, target_shared,
 
   # Add summaries
   source_reconstructions = tf.concat(
-      map(normalize_images, [
+      axis=2,
+      values=map(normalize_images, [
           source_data, source_recons, source_shared_recons,
           source_private_recons
-      ]), 2)
+      ]))
   target_reconstructions = tf.concat(
-      map(normalize_images, [
+      axis=2,
+      values=map(normalize_images, [
           target_data, target_recons, target_shared_recons,
           target_private_recons
-      ]), 2)
+      ]))
   tf.summary.image(
       'Source Images:Recons:RGB',
       source_reconstructions[:, :, :, :3],

domain_adaptation/domain_separation/dsn_test.py

@@ -26,7 +26,7 @@ class HelperFunctionsTest(tf.test.TestCase):
     with self.test_session() as sess:
       # Test for when global_step < domain_separation_startpoint
       step = tf.contrib.slim.get_or_create_global_step()
-      sess.run(tf.initialize_all_variables())  # global_step = 0
+      sess.run(tf.global_variables_initializer())  # global_step = 0
       params = {'domain_separation_startpoint': 2}
       weight = dsn.dsn_loss_coefficient(params)
       weight_np = sess.run(weight)

domain_adaptation/domain_separation/dsn_train.py

@@ -70,7 +70,7 @@ tf.app.flags.DEFINE_string('train_log_dir', '/tmp/da/',
 
 tf.app.flags.DEFINE_string(
     'layers_to_regularize', 'fc3',
-    'Comma-seperated list of layer names to use MMD regularization on.')
+    'Comma-separated list of layer names to use MMD regularization on.')
 
 tf.app.flags.DEFINE_float('learning_rate', .01, 'The learning rate')
 

domain_adaptation/domain_separation/losses.py

@@ -100,7 +100,7 @@ def mmd_loss(source_samples, target_samples, weight, scope=None):
     tag = 'MMD Loss'
     if scope:
       tag = scope + tag
-    tf.contrib.deprecated.scalar_summary(tag, loss_value)
+    tf.summary.scalar(tag, loss_value)
     tf.losses.add_loss(loss_value)
 
   return loss_value
@@ -135,7 +135,7 @@ def correlation_loss(source_samples, target_samples, weight, scope=None):
     tag = 'Correlation Loss'
     if scope:
       tag = scope + tag
-    tf.contrib.deprecated.scalar_summary(tag, corr_loss)
+    tf.summary.scalar(tag, corr_loss)
     tf.losses.add_loss(corr_loss)
 
   return corr_loss
@@ -155,11 +155,11 @@ def dann_loss(source_samples, target_samples, weight, scope=None):
   """
   with tf.variable_scope('dann'):
     batch_size = tf.shape(source_samples)[0]
-    samples = tf.concat([source_samples, target_samples], 0)
+    samples = tf.concat(axis=0, values=[source_samples, target_samples])
     samples = slim.flatten(samples)
 
     domain_selection_mask = tf.concat(
-        [tf.zeros((batch_size, 1)), tf.ones((batch_size, 1))], 0)
+        axis=0, values=[tf.zeros((batch_size, 1)), tf.ones((batch_size, 1))])
 
     # Perform the gradient reversal and be careful with the shape.
     grl = grl_ops.gradient_reversal(samples)
@@ -184,9 +184,9 @@ def dann_loss(source_samples, target_samples, weight, scope=None):
       tag_loss = scope + tag_loss
       tag_accuracy = scope + tag_accuracy
 
-    tf.contrib.deprecated.scalar_summary(
+    tf.summary.scalar(
         tag_loss, domain_loss, name='domain_loss_summary')
-    tf.contrib.deprecated.scalar_summary(
+    tf.summary.scalar(
         tag_accuracy, domain_accuracy, name='domain_accuracy_summary')
 
   return domain_loss
@@ -216,7 +216,7 @@ def difference_loss(private_samples, shared_samples, weight=1.0, name=''):
   cost = tf.reduce_mean(tf.square(correlation_matrix)) * weight
   cost = tf.where(cost > 0, cost, 0, name='value')
 
-  tf.contrib.deprecated.scalar_summary('losses/Difference Loss {}'.format(name),
+  tf.summary.scalar('losses/Difference Loss {}'.format(name),
                                        cost)
   assert_op = tf.Assert(tf.is_finite(cost), [cost])
   with tf.control_dependencies([assert_op]):

domain_adaptation/domain_separation/models_test.py

@@ -115,7 +115,7 @@ class DecoderTest(tf.test.TestCase):
           width=width,
           channels=channels,
           batch_norm_params=batch_norm_params)
-      sess.run(tf.initialize_all_variables())
+      sess.run(tf.global_variables_initializer())
       output_np = sess.run(output)
     self.assertEqual(output_np.shape, (32, height, width, channels))
     self.assertTrue(np.any(output_np))

domain_adaptation/domain_separation/utils.py

@@ -75,15 +75,15 @@ def reshape_feature_maps(features_tensor):
       num_filters)
   num_filters_sqrt = int(num_filters_sqrt)
   conv_summary = tf.unstack(features_tensor, axis=3)
-  conv_one_row = tf.concat(conv_summary[0:num_filters_sqrt], 2)
+  conv_one_row = tf.concat(axis=2, values=conv_summary[0:num_filters_sqrt])
   ind = 1
   conv_final = conv_one_row
   for ind in range(1, num_filters_sqrt):
-    conv_one_row = tf.concat(conv_summary[
-        ind * num_filters_sqrt + 0:ind * num_filters_sqrt + num_filters_sqrt],
-                             2)
+    conv_one_row = tf.concat(axis=2,
+                             values=conv_summary[
+        ind * num_filters_sqrt + 0:ind * num_filters_sqrt + num_filters_sqrt])
     conv_final = tf.concat(
-        [tf.squeeze(conv_final), tf.squeeze(conv_one_row)], 1)
+        axis=1, values=[tf.squeeze(conv_final), tf.squeeze(conv_one_row)])
     conv_final = tf.expand_dims(conv_final, -1)
   return conv_final