Deprecate tf.select since it is getting replaced by tf.where.

tensorflower-gardener · tensorflower-gardener · commit fe558b0b0ca3 · 2016-11-30T12:04:17.000-08:00
Change: 140632089
diff --git a/RELEASE.md b/RELEASE.md
@@ -24,6 +24,7 @@ BUS_ANY was used.
   `Saver` a list of variable renames.  Examples of variable scope changes
   include `RNN` -> `rnn` in `tf.nn.rnn`, `tf.nn.dynamic_rnn` and moving from
   `Linear/Matrix` -> `weights` and `Linear/Bias` -> `biases` in most RNN cells.
+* Deprecated tf.select op. tf.where should be used instead.
 
 # Release 0.11.0
 
diff --git a/tensorflow/contrib/bayesflow/python/ops/special_math.py b/tensorflow/contrib/bayesflow/python/ops/special_math.py
@@ -23,6 +23,7 @@
 
 from tensorflow.python.framework import constant_op
 from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
 from tensorflow.python.ops import math_ops
 
 __all__ = [
@@ -90,9 +91,9 @@ def _ndtr(x):
       0.5 * math.sqrt(2.), dtype=x.dtype, name="half_sqrt_2")
   w = x * half_sqrt_2
   z = math_ops.abs(w)
-  y = math_ops.select(math_ops.less(z, half_sqrt_2),
+  y = array_ops.where(math_ops.less(z, half_sqrt_2),
                       1. + math_ops.erf(w),
-                      math_ops.select(math_ops.greater(w, 0.),
+                      array_ops.where(math_ops.greater(w, 0.),
                                       2. - math_ops.erfc(z),
                                       math_ops.erfc(z)))
   return 0.5 * y
@@ -180,10 +181,10 @@ def log_ndtr(x, series_order=3, name="log_ndtr"):
     #   the gradient of a select involves the calculation 1*dy+0*(-inf)=nan
     #   regardless of whether dy is finite. Note that the minimum is a NOP if
     #   the branch is chosen.
-    return math_ops.select(
+    return array_ops.where(
         math_ops.greater(x, upper_segment),
         -_ndtr(-x),  # log(1-x) ~= -x, x << 1
-        math_ops.select(math_ops.greater(x, lower_segment),
+        array_ops.where(math_ops.greater(x, lower_segment),
                         math_ops.log(_ndtr(math_ops.maximum(x, lower_segment))),
                         _log_ndtr_lower(math_ops.minimum(x, lower_segment),
                                         series_order)))
diff --git a/tensorflow/contrib/distributions/python/ops/beta.py b/tensorflow/contrib/distributions/python/ops/beta.py
@@ -252,7 +252,7 @@ def _mode(self):
     mode = (self.a - 1.)/ (self.a_b_sum - 2.)
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
-      return math_ops.select(
+      return array_ops.where(
           math_ops.logical_and(
               math_ops.greater(self.a, 1.),
               math_ops.greater(self.b, 1.)),
diff --git a/tensorflow/contrib/distributions/python/ops/bijector.py b/tensorflow/contrib/distributions/python/ops/bijector.py
@@ -1468,7 +1468,7 @@ def _process_scale(self, scale, event_ndims):
       batch_ndims: `Tensor` (0D, `int32`).  The ndims of the `batch` portion.
     """
     ndims = array_ops.rank(scale)
-    left = math_ops.select(
+    left = array_ops.where(
         math_ops.reduce_any([
             math_ops.reduce_all([
                 math_ops.equal(ndims, 0),
@@ -1478,7 +1478,7 @@ def _process_scale(self, scale, event_ndims):
                 math_ops.equal(ndims, 2),
                 math_ops.equal(event_ndims, 1)
             ])]), 1, 0)
-    right = math_ops.select(math_ops.equal(event_ndims, 0), 2, 0)
+    right = array_ops.where(math_ops.equal(event_ndims, 0), 2, 0)
     pad = array_ops.concat(0, (
         array_ops.ones([left], dtype=dtypes.int32),
         array_ops.shape(scale),
diff --git a/tensorflow/contrib/distributions/python/ops/dirichlet.py b/tensorflow/contrib/distributions/python/ops/dirichlet.py
@@ -239,7 +239,7 @@ def _mode(self):
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
       shape = array_ops.concat(0, (self.batch_shape(), self.event_shape()))
-      return math_ops.select(
+      return array_ops.where(
           math_ops.greater(self.alpha, 1.),
           mode,
           array_ops.fill(shape, nan, name="nan"))
diff --git a/tensorflow/contrib/distributions/python/ops/distribution_util.py b/tensorflow/contrib/distributions/python/ops/distribution_util.py
@@ -335,7 +335,7 @@ def rotate_transpose(x, shift, name="rotate_transpose"):
       # Finally, we transform shift by modulo length so it can be specified
       # independently from the array upon which it operates (like python).
       ndims = array_ops.rank(x)
-      shift = math_ops.select(math_ops.less(shift, 0),
+      shift = array_ops.where(math_ops.less(shift, 0),
                               math_ops.mod(-shift, ndims),
                               ndims - math_ops.mod(shift, ndims))
       first = math_ops.range(0, shift)
@@ -396,8 +396,8 @@ def pick_vector(cond,
              false_vector.name, false_vector.dtype))
     n = array_ops.shape(true_vector)[0]
     return array_ops.slice(array_ops.concat(0, (true_vector, false_vector)),
-                           [math_ops.select(cond, 0, n)],
-                           [math_ops.select(cond, n, -1)])
+                           [array_ops.where(cond, 0, n)],
+                           [array_ops.where(cond, n, -1)])
 
 
 def gen_new_seed(seed, salt):
diff --git a/tensorflow/contrib/distributions/python/ops/gamma.py b/tensorflow/contrib/distributions/python/ops/gamma.py
@@ -208,7 +208,7 @@ def _mode(self):
     mode = (self.alpha - 1.) / self.beta
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
-      return math_ops.select(
+      return array_ops.where(
           self.alpha >= 1.,
           mode,
           array_ops.fill(self.batch_shape(), nan, name="nan"))
diff --git a/tensorflow/contrib/distributions/python/ops/inverse_gamma.py b/tensorflow/contrib/distributions/python/ops/inverse_gamma.py
@@ -185,7 +185,7 @@ def _mean(self):
     mean = self.beta / (self.alpha - 1.)
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
-      return math_ops.select(
+      return array_ops.where(
           self.alpha > 1., mean,
           array_ops.fill(self.batch_shape(), nan, name="nan"))
     else:
@@ -204,7 +204,7 @@ def _variance(self):
            (math_ops.square(self.alpha - 1.) * (self.alpha - 2.)))
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
-      return math_ops.select(
+      return array_ops.where(
           self.alpha > 2., var,
           array_ops.fill(self.batch_shape(), nan, name="nan"))
     else:
diff --git a/tensorflow/contrib/distributions/python/ops/quantized_distribution.py b/tensorflow/contrib/distributions/python/ops/quantized_distribution.py
@@ -284,11 +284,11 @@ def _sample_n(self, n, seed=None):
       result_so_far = math_ops.ceil(x_samps)
 
       if lower_cutoff is not None:
-        result_so_far = math_ops.select(result_so_far < lower_cutoff,
+        result_so_far = array_ops.where(result_so_far < lower_cutoff,
                                         lower_cutoff * ones, result_so_far)
 
       if upper_cutoff is not None:
-        result_so_far = math_ops.select(result_so_far > upper_cutoff,
+        result_so_far = array_ops.where(result_so_far > upper_cutoff,
                                         upper_cutoff * ones, result_so_far)
 
       return result_so_far
@@ -327,8 +327,8 @@ def _log_prob_with_logsf_and_logcdf(self, y):
     # In either case, we are doing Log[ exp{big} - exp{small} ]
     # We want to use the sf items precisely when we are on the right side of the
     # median, which occurs when logsf_y < logcdf_y.
-    big = math_ops.select(logsf_y < logcdf_y, logsf_y_minus_1, logcdf_y)
-    small = math_ops.select(logsf_y < logcdf_y, logsf_y, logcdf_y_minus_1)
+    big = array_ops.where(logsf_y < logcdf_y, logsf_y_minus_1, logcdf_y)
+    small = array_ops.where(logsf_y < logcdf_y, logsf_y, logcdf_y_minus_1)
 
     return _logsum_expbig_minus_expsmall(big, small)
 
@@ -357,7 +357,7 @@ def _prob_with_sf_and_cdf(self, y):
     cdf_y_minus_1 = self.cdf(y - 1)
 
     # sf_prob has greater precision iff we're on the right side of the median.
-    return math_ops.select(
+    return array_ops.where(
         sf_y < cdf_y,  # True iff we're on the right side of the median.
         sf_y_minus_1 - sf_y,
         cdf_y - cdf_y_minus_1)
@@ -386,9 +386,9 @@ def _log_cdf(self, y):
     # Re-define values at the cutoffs.
     if lower_cutoff is not None:
       neg_inf = -np.inf * array_ops.ones_like(result_so_far)
-      result_so_far = math_ops.select(j < lower_cutoff, neg_inf, result_so_far)
+      result_so_far = array_ops.where(j < lower_cutoff, neg_inf, result_so_far)
     if upper_cutoff is not None:
-      result_so_far = math_ops.select(j >= upper_cutoff,
+      result_so_far = array_ops.where(j >= upper_cutoff,
                                       array_ops.zeros_like(result_so_far),
                                       result_so_far)
 
@@ -418,11 +418,11 @@ def _cdf(self, y):
 
     # Re-define values at the cutoffs.
     if lower_cutoff is not None:
-      result_so_far = math_ops.select(j < lower_cutoff,
+      result_so_far = array_ops.where(j < lower_cutoff,
                                       array_ops.zeros_like(result_so_far),
                                       result_so_far)
     if upper_cutoff is not None:
-      result_so_far = math_ops.select(j >= upper_cutoff,
+      result_so_far = array_ops.where(j >= upper_cutoff,
                                       array_ops.ones_like(result_so_far),
                                       result_so_far)
 
@@ -452,12 +452,12 @@ def _log_survival_function(self, y):
 
     # Re-define values at the cutoffs.
     if lower_cutoff is not None:
-      result_so_far = math_ops.select(j < lower_cutoff,
+      result_so_far = array_ops.where(j < lower_cutoff,
                                       array_ops.zeros_like(result_so_far),
                                       result_so_far)
     if upper_cutoff is not None:
       neg_inf = -np.inf * array_ops.ones_like(result_so_far)
-      result_so_far = math_ops.select(j >= upper_cutoff, neg_inf, result_so_far)
+      result_so_far = array_ops.where(j >= upper_cutoff, neg_inf, result_so_far)
 
     return result_so_far
 
@@ -485,11 +485,11 @@ def _survival_function(self, y):
 
     # Re-define values at the cutoffs.
     if lower_cutoff is not None:
-      result_so_far = math_ops.select(j < lower_cutoff,
+      result_so_far = array_ops.where(j < lower_cutoff,
                                       array_ops.ones_like(result_so_far),
                                       result_so_far)
     if upper_cutoff is not None:
-      result_so_far = math_ops.select(j >= upper_cutoff,
+      result_so_far = array_ops.where(j >= upper_cutoff,
                                       array_ops.zeros_like(result_so_far),
                                       result_so_far)
 
diff --git a/tensorflow/contrib/distributions/python/ops/shape.py b/tensorflow/contrib/distributions/python/ops/shape.py
@@ -422,7 +422,7 @@ def undo_make_batch_of_event_sample_matrices(
         batch_shape = array_ops.slice(s, (1,), (self.batch_ndims,))
         # Since sample_dims=1 and is left-most, we add 1 to the number of
         # batch_ndims to get the event start dim.
-        event_start = math_ops.select(
+        event_start = array_ops.where(
             self._batch_ndims_is_0, 2, 1 + self.batch_ndims)
         event_shape = array_ops.slice(s, (event_start,), (self.event_ndims,))
       new_shape = array_ops.concat(0, (sample_shape, batch_shape, event_shape))
diff --git a/tensorflow/contrib/distributions/python/ops/student_t.py b/tensorflow/contrib/distributions/python/ops/student_t.py
@@ -230,7 +230,7 @@ def _mean(self):
     mean = self.mu * self._ones()
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
-      return math_ops.select(
+      return array_ops.where(
           math_ops.greater(self.df, self._ones()), mean,
           array_ops.fill(self.batch_shape(), nan, name="nan"))
     else:
@@ -255,14 +255,14 @@ def _variance(self):
            math_ops.square(self.sigma) * self.df / (self.df - 2))
     # When 1 < df <= 2, variance is infinite.
     inf = np.array(np.inf, dtype=self.dtype.as_numpy_dtype())
-    result_where_defined = math_ops.select(
+    result_where_defined = array_ops.where(
         math_ops.greater(self.df, array_ops.fill(self.batch_shape(), 2.)),
         var,
         array_ops.fill(self.batch_shape(), inf, name="inf"))
 
     if self.allow_nan_stats:
       nan = np.array(np.nan, dtype=self.dtype.as_numpy_dtype())
-      return math_ops.select(
+      return array_ops.where(
           math_ops.greater(self.df, self._ones()),
           result_where_defined,
           array_ops.fill(self.batch_shape(), nan, name="nan"))
diff --git a/tensorflow/contrib/distributions/python/ops/uniform.py b/tensorflow/contrib/distributions/python/ops/uniform.py
@@ -148,10 +148,10 @@ def _log_prob(self, x):
 
   def _prob(self, x):
     broadcasted_x = x * array_ops.ones(self.batch_shape())
-    return math_ops.select(
+    return array_ops.where(
         math_ops.is_nan(broadcasted_x),
         broadcasted_x,
-        math_ops.select(
+        array_ops.where(
             math_ops.logical_or(broadcasted_x < self.a,
                                 broadcasted_x > self.b),
             array_ops.zeros_like(broadcasted_x),
@@ -164,9 +164,9 @@ def _cdf(self, x):
     broadcasted_x = x * array_ops.ones(self.batch_shape())
     zeros = array_ops.zeros_like(x + self.a + self.b, dtype=self.dtype)
     ones = array_ops.ones_like(x + self.a + self.b, dtype=self.dtype)
-    result_if_not_big = math_ops.select(
+    result_if_not_big = array_ops.where(
         x < self.a, zeros, (broadcasted_x - self.a) / self.range())
-    return math_ops.select(x >= self.b, ones, result_if_not_big)
+    return array_ops.where(x >= self.b, ones, result_if_not_big)
 
   def _entropy(self):
     return math_ops.log(self.range())
diff --git a/tensorflow/contrib/distributions/python/ops/wishart.py b/tensorflow/contrib/distributions/python/ops/wishart.py
@@ -367,7 +367,7 @@ def _std(self):
 
   def _mode(self):
     s = self.df - self.dimension - 1.
-    s = math_ops.select(
+    s = array_ops.where(
         math_ops.less(s, 0.),
         constant_op.constant(float("NaN"), dtype=self.dtype, name="nan"),
         s)
diff --git a/tensorflow/contrib/layers/python/layers/embedding_ops.py b/tensorflow/contrib/layers/python/layers/embedding_ops.py
@@ -150,7 +150,7 @@ def safe_embedding_lookup_sparse(embedding_weights,
           array_ops.reshape(is_row_empty, [-1, 1]),
           array_ops.pack([1, array_ops.shape(result)[1]]))
 
-      result = math_ops.select(is_row_empty,
+      result = array_ops.where(is_row_empty,
                                array_ops.zeros_like(result),
                                result,
                                name=scope)
diff --git a/tensorflow/contrib/layers/python/layers/optimizers.py b/tensorflow/contrib/layers/python/layers/optimizers.py
@@ -360,7 +360,7 @@ def gradient_clipping(grads_and_vars):
       summary.scalar("global_norm/adaptive_max_gradient_norm", max_norm)
 
     # factor will be 1. if norm is smaller than max_norm
-    factor = math_ops.select(norm < max_norm,
+    factor = array_ops.where(norm < max_norm,
                              array_ops.ones_like(norm),
                              math_ops.exp(log_mean) / norm)
 
diff --git a/tensorflow/contrib/losses/python/losses/loss_ops.py b/tensorflow/contrib/losses/python/losses/loss_ops.py
@@ -117,9 +117,9 @@ def _safe_div(numerator, denominator, name="value"):
   Returns:
     The element-wise value of the numerator divided by the denominator.
   """
-  return math_ops.select(
+  return array_ops.where(
       math_ops.greater(denominator, 0),
-      math_ops.div(numerator, math_ops.select(
+      math_ops.div(numerator, array_ops.where(
           math_ops.equal(denominator, 0),
           array_ops.ones_like(denominator), denominator)),
       array_ops.zeros_like(numerator),
@@ -213,7 +213,7 @@ def _num_present(losses, weights, per_batch=False):
                                                    [0], [1]), [])
     num_per_batch = math_ops.div(math_ops.to_float(array_ops.size(losses)),
                                  math_ops.to_float(batch_size))
-    num_per_batch = math_ops.select(math_ops.equal(weights, 0),
+    num_per_batch = array_ops.where(math_ops.equal(weights, 0),
                                     0.0, num_per_batch)
     num_per_batch = math_ops.mul(array_ops.ones(
         array_ops.reshape(batch_size, [1])), num_per_batch)
@@ -683,7 +683,7 @@ def mean_pairwise_squared_error(
 
     loss = _scale_losses(term1 - term2, weights)
 
-    mean_loss = math_ops.select(math_ops.reduce_sum(num_present_per_batch) > 0,
+    mean_loss = array_ops.where(math_ops.reduce_sum(num_present_per_batch) > 0,
                                 loss,
                                 array_ops.zeros_like(loss),
                                 name="value")
diff --git a/tensorflow/contrib/metrics/python/ops/metric_ops.py b/tensorflow/contrib/metrics/python/ops/metric_ops.py
@@ -52,7 +52,7 @@ def _safe_div(numerator, denominator, name):
   Returns:
     0 if `denominator` <= 0, else `numerator` / `denominator`
   """
-  return math_ops.select(
+  return array_ops.where(
       math_ops.greater(denominator, 0),
       math_ops.truediv(numerator, denominator),
       0,
@@ -587,7 +587,7 @@ def streaming_precision(predictions, labels, weights=None,
         updates_collections=None, name=None)
 
     def compute_precision(name):
-      return math_ops.select(
+      return array_ops.where(
           math_ops.greater(true_positives + false_positives, 0),
           math_ops.div(true_positives, true_positives + false_positives),
           0,
@@ -661,7 +661,7 @@ def streaming_recall(predictions, labels, weights=None,
         updates_collections=None, name=None)
 
     def compute_recall(true_positives, false_negatives, name):
-      return math_ops.select(
+      return array_ops.where(
           math_ops.greater(true_positives + false_negatives, 0),
           math_ops.div(true_positives, true_positives + false_negatives),
           0,
@@ -2388,7 +2388,7 @@ def streaming_mean_relative_error(predictions, labels, normalizer, weights=None,
   predictions, normalizer = tensor_util.remove_squeezable_dimensions(
       predictions, normalizer)
   predictions.get_shape().assert_is_compatible_with(normalizer.get_shape())
-  relative_errors = math_ops.select(
+  relative_errors = array_ops.where(
       math_ops.equal(normalizer, 0.0),
       array_ops.zeros_like(labels),
       math_ops.div(math_ops.abs(labels - predictions), normalizer))
@@ -2923,7 +2923,7 @@ def compute_mean_iou(name):
 
       # If the value of the denominator is 0, set it to 1 to avoid
       # zero division.
-      denominator = math_ops.select(
+      denominator = array_ops.where(
           math_ops.greater(denominator, 0),
           denominator,
           array_ops.ones_like(denominator))
diff --git a/tensorflow/contrib/training/python/training/sampling_ops.py b/tensorflow/contrib/training/python/training/sampling_ops.py
@@ -387,7 +387,7 @@ def _calculate_acceptance_probabilities(init_probs, target_probs):
   ratio_l = target_probs / init_probs
 
   # Replace NaNs with 0s.
-  ratio_l = math_ops.select(math_ops.is_nan(ratio_l),
+  ratio_l = array_ops.where(math_ops.is_nan(ratio_l),
                             array_ops.zeros_like(ratio_l),
                             ratio_l)
 
diff --git a/tensorflow/python/kernel_tests/cwise_ops_test.py b/tensorflow/python/kernel_tests/cwise_ops_test.py
diff --git a/tensorflow/python/ops/array_ops.py b/tensorflow/python/ops/array_ops.py
diff --git a/tensorflow/python/ops/hidden_ops.txt b/tensorflow/python/ops/hidden_ops.txt
diff --git a/tensorflow/python/ops/math_grad.py b/tensorflow/python/ops/math_grad.py
diff --git a/tensorflow/python/ops/math_ops.py b/tensorflow/python/ops/math_ops.py
diff --git a/tensorflow/python/ops/nn_grad.py b/tensorflow/python/ops/nn_grad.py
diff --git a/tensorflow/python/ops/nn_impl.py b/tensorflow/python/ops/nn_impl.py
diff --git a/tensorflow/python/ops/rnn.py b/tensorflow/python/ops/rnn.py
