chore: import upstream snapshot with attribution

tensorflow/python/layers/BUILD

@@ -0,0 +1,76 @@
+# python/layers package
+
+load("@xla//third_party/rules_python/python:py_library.bzl", "py_library")
+
+visibility = [
+    "//tensorflow:__subpackages__",
+]
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
+    default_visibility = visibility,
+    licenses = ["notice"],
+)
+
+py_library(
+    name = "layers_base",
+    srcs = [
+        "__init__.py",
+        "base.py",
+    ],
+    strict_deps = True,
+    visibility = visibility + [
+        "//tensorflow:internal",
+        "//tensorflow_models:__subpackages__",
+    ],
+    deps = [
+        "//tensorflow/python/keras/legacy_tf_layers:layers_base",
+    ],
+)
+
+py_library(
+    name = "layers_util",
+    srcs = [
+        "utils.py",
+    ],
+    strict_deps = True,
+    visibility = ["//tensorflow:internal"],
+    deps = [
+        "//tensorflow/python/framework:smart_cond",
+        "//tensorflow/python/ops:cond",
+        "//tensorflow/python/ops:variables",
+    ],
+)
+
+py_library(
+    name = "layers",
+    srcs = [
+        "convolutional.py",
+        "core.py",
+        "layers.py",
+        "normalization.py",
+        "pooling.py",
+    ],
+    strict_deps = True,
+    # copybara:uncomment_begin(google-only)
+    # visibility = [
+    # "//third_party/cloud_tpu/convergence_tools:__subpackages__",
+    # "//third_party/py/tf_slim:__subpackages__",
+    # "//tensorflow:internal",
+    # ],
+    # copybara:uncomment_end_and_comment_begin
+    visibility = [
+        "//visibility:public",
+    ],
+    # copybara:comment_end
+    deps = [
+        ":layers_base",
+        "//tensorflow/python/keras/legacy_tf_layers:convolutional",
+        "//tensorflow/python/keras/legacy_tf_layers:core",
+        "//tensorflow/python/keras/legacy_tf_layers:pooling",
+        "//tensorflow/python/util:lazy_loader",
+        # Normalization layer will need //third_party/py/tf_keras/legacy_tf_layers:normalization
+        # Client lib should import that, since this target can't import it due to
+        # circular dependency.
+    ],
+)

tensorflow/python/layers/base.py

@@ -0,0 +1,22 @@
+# Copyright 2015 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.
+# =============================================================================
+"""Contains the base Layer class, from which all layers inherit."""
+from tensorflow.python.keras.legacy_tf_layers import base
+
+InputSpec = base.InputSpec
+
+keras_style_scope = base.keras_style_scope
+set_keras_style = base.set_keras_style
+Layer = base.Layer

tensorflow/python/layers/convolutional.py

@@ -0,0 +1,48 @@
+# Copyright 2015 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.
+# =============================================================================
+
+"""Contains the convolutional layer classes and their functional aliases.
+"""
+from tensorflow.python.keras.legacy_tf_layers import convolutional
+
+Conv1D = convolutional.Conv1D
+conv1d = convolutional.conv1d
+Conv2D = convolutional.Conv2D
+conv2d = convolutional.conv2d
+Conv3D = convolutional.Conv3D
+conv3d = convolutional.conv3d
+SeparableConv1D = convolutional.SeparableConv1D
+SeparableConv2D = convolutional.SeparableConv2D
+separable_conv1d = convolutional.separable_conv1d
+separable_conv2d = convolutional.separable_conv2d
+Conv2DTranspose = convolutional.Conv2DTranspose
+conv2d_transpose = convolutional.conv2d_transpose
+Conv3DTranspose = convolutional.Conv3DTranspose
+conv3d_transpose = convolutional.conv3d_transpose
+
+# Aliases
+
+Convolution1D = Conv1D
+Convolution2D = Conv2D
+Convolution3D = Conv3D
+SeparableConvolution2D = SeparableConv2D
+Convolution2DTranspose = Deconvolution2D = Deconv2D = Conv2DTranspose
+Convolution3DTranspose = Deconvolution3D = Deconv3D = Conv3DTranspose
+convolution1d = conv1d
+convolution2d = conv2d
+convolution3d = conv3d
+separable_convolution2d = separable_conv2d
+convolution2d_transpose = deconvolution2d = deconv2d = conv2d_transpose
+convolution3d_transpose = deconvolution3d = deconv3d = conv3d_transpose

tensorflow/python/layers/core.py

@@ -0,0 +1,33 @@
+# Copyright 2015 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.
+# =============================================================================
+
+"""Contains the core layers: Dense, Dropout.
+
+Also contains their functional aliases.
+"""
+from tensorflow.python.keras.legacy_tf_layers import core
+
+
+Dense = core.Dense
+dense = core.dense
+Dropout = core.Dropout
+dropout = core.dropout
+Flatten = core.Flatten
+flatten = core.flatten
+
+# Aliases
+
+FullyConnected = Dense
+fully_connected = dense

tensorflow/python/layers/layers.py

@@ -0,0 +1,71 @@
+# Copyright 2015 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.
+# ==============================================================================
+
+# pylint: disable=line-too-long
+"""This library provides a set of high-level neural networks layers."""
+
+# pylint: disable=g-bad-import-order,unused-import
+
+# Base objects.
+from tensorflow.python.layers.base import Layer
+
+# Core layers.
+from tensorflow.python.layers.core import Dense
+from tensorflow.python.layers.core import Dropout
+from tensorflow.python.layers.core import Flatten
+
+from tensorflow.python.layers.core import dense
+from tensorflow.python.layers.core import dropout
+from tensorflow.python.layers.core import flatten
+
+# Convolutional layers.
+from tensorflow.python.layers.convolutional import SeparableConv1D
+from tensorflow.python.layers.convolutional import SeparableConv2D
+from tensorflow.python.layers.convolutional import SeparableConvolution2D
+from tensorflow.python.layers.convolutional import Conv2DTranspose
+from tensorflow.python.layers.convolutional import Convolution2DTranspose
+from tensorflow.python.layers.convolutional import Conv3DTranspose
+from tensorflow.python.layers.convolutional import Convolution3DTranspose
+from tensorflow.python.layers.convolutional import Conv1D
+from tensorflow.python.layers.convolutional import Convolution1D
+from tensorflow.python.layers.convolutional import Conv2D
+from tensorflow.python.layers.convolutional import Convolution2D
+from tensorflow.python.layers.convolutional import Conv3D
+from tensorflow.python.layers.convolutional import Convolution3D
+
+from tensorflow.python.layers.convolutional import separable_conv1d
+from tensorflow.python.layers.convolutional import separable_conv2d
+from tensorflow.python.layers.convolutional import conv2d_transpose
+from tensorflow.python.layers.convolutional import conv3d_transpose
+from tensorflow.python.layers.convolutional import conv1d
+from tensorflow.python.layers.convolutional import conv2d
+from tensorflow.python.layers.convolutional import conv3d
+
+# Pooling layers.
+from tensorflow.python.layers.pooling import AveragePooling1D
+from tensorflow.python.layers.pooling import MaxPooling1D
+from tensorflow.python.layers.pooling import AveragePooling2D
+from tensorflow.python.layers.pooling import MaxPooling2D
+from tensorflow.python.layers.pooling import AveragePooling3D
+from tensorflow.python.layers.pooling import MaxPooling3D
+
+from tensorflow.python.layers.pooling import average_pooling1d
+from tensorflow.python.layers.pooling import max_pooling1d
+from tensorflow.python.layers.pooling import average_pooling2d
+from tensorflow.python.layers.pooling import max_pooling2d
+from tensorflow.python.layers.pooling import average_pooling3d
+from tensorflow.python.layers.pooling import max_pooling3d
+
+# pylint: enable=g-bad-import-order,unused-import

tensorflow/python/layers/normalization.py

@@ -0,0 +1,34 @@
+# Copyright 2015 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.
+# =============================================================================
+
+"""Contains the normalization layer classes and their functional aliases.
+"""
+
+from tensorflow.python.util import lazy_loader
+
+normalization = lazy_loader.LazyLoader(
+    'normalization', globals(),
+    'tf_keras.legacy_tf_layers.normalization')
+
+
+# pylint: disable=invalid-name
+# lazy load all the attributes until they are accessed for the first time
+def __getattr__(name):
+  if name in ['BatchNormalization', 'BatchNorm']:
+    return normalization.BatchNormalization
+  elif name in ['batch_normalization', 'batch_norm']:
+    return normalization.batch_normalization
+  else:
+    raise AttributeError(f'module {__name__} doesn\'t have attribute {name}')

tensorflow/python/layers/pooling.py

@@ -0,0 +1,39 @@
+# Copyright 2015 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.
+# =============================================================================
+
+"""Contains the pooling layer classes and their functional aliases.
+"""
+from tensorflow.python.keras.legacy_tf_layers import pooling
+
+
+AveragePooling1D = pooling.AveragePooling1D
+average_pooling1d = pooling.average_pooling1d
+MaxPooling1D = pooling.MaxPooling1D
+max_pooling1d = pooling.max_pooling1d
+AveragePooling2D = pooling.AveragePooling2D
+average_pooling2d = pooling.average_pooling2d
+MaxPooling2D = pooling.MaxPooling2D
+max_pooling2d = pooling.max_pooling2d
+AveragePooling3D = pooling.AveragePooling3D
+average_pooling3d = pooling.average_pooling3d
+MaxPooling3D = pooling.MaxPooling3D
+max_pooling3d = pooling.max_pooling3d
+
+# Aliases
+
+AvgPool2D = AveragePooling2D
+MaxPool2D = MaxPooling2D
+max_pool2d = max_pooling2d
+avg_pool2d = average_pooling2d

tensorflow/python/layers/utils.py

@@ -0,0 +1,225 @@
+# Copyright 2015 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.
+# =============================================================================
+
+"""Contains layer utilities for input validation and format conversion."""
+from tensorflow.python.framework import smart_cond as smart_module
+from tensorflow.python.ops import cond
+from tensorflow.python.ops import variables
+
+
+def convert_data_format(data_format, ndim):
+  if data_format == 'channels_last':
+    if ndim == 3:
+      return 'NWC'
+    elif ndim == 4:
+      return 'NHWC'
+    elif ndim == 5:
+      return 'NDHWC'
+    else:
+      raise ValueError(f'Input rank: {ndim} not supported. We only support '
+                       'input rank 3, 4 or 5.')
+  elif data_format == 'channels_first':
+    if ndim == 3:
+      return 'NCW'
+    elif ndim == 4:
+      return 'NCHW'
+    elif ndim == 5:
+      return 'NCDHW'
+    else:
+      raise ValueError(f'Input rank: {ndim} not supported. We only support '
+                       'input rank 3, 4 or 5.')
+  else:
+    raise ValueError(f'Invalid data_format: {data_format}. We only support '
+                     '"channels_first" or "channels_last"')
+
+
+def normalize_tuple(value, n, name):
+  """Transforms a single integer or iterable of integers into an integer tuple.
+
+  Args:
+    value: The value to validate and convert. Could an int, or any iterable
+      of ints.
+    n: The size of the tuple to be returned.
+    name: The name of the argument being validated, e.g. "strides" or
+      "kernel_size". This is only used to format error messages.
+
+  Returns:
+    A tuple of n integers.
+
+  Raises:
+    ValueError: If something else than an int/long or iterable thereof was
+      passed.
+  """
+  if isinstance(value, int):
+    return (value,) * n
+  else:
+    try:
+      value_tuple = tuple(value)
+    except TypeError:
+      raise ValueError(f'Argument `{name}` must be a tuple of {str(n)} '
+                       f'integers. Received: {str(value)}')
+    if len(value_tuple) != n:
+      raise ValueError(f'Argument `{name}` must be a tuple of {str(n)} '
+                       f'integers. Received: {str(value)}')
+    for single_value in value_tuple:
+      try:
+        int(single_value)
+      except (ValueError, TypeError):
+        raise ValueError(f'Argument `{name}` must be a tuple of {str(n)} '
+                         f'integers. Received: {str(value)} including element '
+                         f'{str(single_value)} of type '
+                         f'{str(type(single_value))}')
+    return value_tuple
+
+
+def normalize_data_format(value):
+  data_format = value.lower()
+  if data_format not in {'channels_first', 'channels_last'}:
+    raise ValueError('The `data_format` argument must be one of '
+                     '"channels_first", "channels_last". Received: '
+                     f'{str(value)}.')
+  return data_format
+
+
+def normalize_padding(value):
+  padding = value.lower()
+  if padding not in {'valid', 'same'}:
+    raise ValueError('The `padding` argument must be one of "valid", "same". '
+                     f'Received: {str(padding)}.')
+  return padding
+
+
+def conv_output_length(input_length, filter_size, padding, stride, dilation=1):
+  """Determines output length of a convolution given input length.
+
+  Args:
+      input_length: integer.
+      filter_size: integer.
+      padding: one of "same", "valid", "full".
+      stride: integer.
+      dilation: dilation rate, integer.
+
+  Returns:
+      The output length (integer).
+  """
+  if input_length is None:
+    return None
+  assert padding in {'same', 'valid', 'full'}
+  dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)
+  if padding == 'same':
+    output_length = input_length
+  elif padding == 'valid':
+    output_length = input_length - dilated_filter_size + 1
+  elif padding == 'full':
+    output_length = input_length + dilated_filter_size - 1
+  return (output_length + stride - 1) // stride
+
+
+def conv_input_length(output_length, filter_size, padding, stride):
+  """Determines input length of a convolution given output length.
+
+  Args:
+      output_length: integer.
+      filter_size: integer.
+      padding: one of "same", "valid", "full".
+      stride: integer.
+
+  Returns:
+      The input length (integer).
+  """
+  if output_length is None:
+    return None
+  assert padding in {'same', 'valid', 'full'}
+  if padding == 'same':
+    pad = filter_size // 2
+  elif padding == 'valid':
+    pad = 0
+  elif padding == 'full':
+    pad = filter_size - 1
+  return (output_length - 1) * stride - 2 * pad + filter_size
+
+
+def deconv_output_length(input_length, filter_size, padding, stride):
+  """Determines output length of a transposed convolution given input length.
+
+  Args:
+      input_length: integer.
+      filter_size: integer.
+      padding: one of "same", "valid", "full".
+      stride: integer.
+
+  Returns:
+      The output length (integer).
+  """
+  if input_length is None:
+    return None
+  input_length *= stride
+  if padding == 'valid':
+    input_length += max(filter_size - stride, 0)
+  elif padding == 'full':
+    input_length -= (stride + filter_size - 2)
+  return input_length
+
+
+def smart_cond(pred, true_fn=None, false_fn=None, name=None):
+  """Return either `true_fn()` if predicate `pred` is true else `false_fn()`.
+
+  If `pred` is a bool or has a constant value, we return either `true_fn()`
+  or `false_fn()`, otherwise we use `tf.cond` to dynamically route to both.
+
+  Args:
+    pred: A scalar determining whether to return the result of `true_fn` or
+      `false_fn`.
+    true_fn: The callable to be performed if pred is true.
+    false_fn: The callable to be performed if pred is false.
+    name: Optional name prefix when using `tf.cond`.
+
+  Returns:
+    Tensors returned by the call to either `true_fn` or `false_fn`.
+
+  Raises:
+    TypeError: If `true_fn` or `false_fn` is not callable.
+  """
+  if isinstance(pred, variables.Variable):
+    return cond.cond(
+        pred, true_fn=true_fn, false_fn=false_fn, name=name)
+  return smart_module.smart_cond(
+      pred, true_fn=true_fn, false_fn=false_fn, name=name)
+
+
+def constant_value(pred):
+  """Return the bool value for `pred`, or None if `pred` had a dynamic value.
+
+    Args:
+      pred: A scalar, either a Python bool or a TensorFlow boolean variable
+        or tensor, or the Python integer 1 or 0.
+
+    Returns:
+      True or False if `pred` has a constant boolean value, None otherwise.
+
+    Raises:
+      TypeError: If `pred` is not a Variable, Tensor or bool, or Python
+        integer 1 or 0.
+    """
+  # Allow integer booleans.
+  if isinstance(pred, int):
+    if pred == 1:
+      pred = True
+    elif pred == 0:
+      pred = False
+
+  if isinstance(pred, variables.Variable):
+    return None
+  return smart_module.smart_constant_value(pred)

tensorflow/python/layers/utils_test.py

@@ -0,0 +1,115 @@
+# Copyright 2015 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 tf.layers.utils."""
+
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import test_util
+from tensorflow.python.layers import utils
+from tensorflow.python.ops import array_ops
+from tensorflow.python.platform import test
+
+
+class ConvUtilsTest(test.TestCase):
+
+  def testConvertDataFormat(self):
+    self.assertEqual('NCDHW', utils.convert_data_format('channels_first', 5))
+    self.assertEqual('NCHW', utils.convert_data_format('channels_first', 4))
+    self.assertEqual('NCW', utils.convert_data_format('channels_first', 3))
+    self.assertEqual('NHWC', utils.convert_data_format('channels_last', 4))
+    self.assertEqual('NWC', utils.convert_data_format('channels_last', 3))
+    self.assertEqual('NDHWC', utils.convert_data_format('channels_last', 5))
+
+    with self.assertRaises(ValueError):
+      utils.convert_data_format('invalid', 2)
+
+  def testNormalizeTuple(self):
+    self.assertEqual((2, 2, 2), utils.normalize_tuple(2, n=3, name='strides'))
+    self.assertEqual(
+        (2, 1, 2), utils.normalize_tuple((2, 1, 2), n=3, name='strides'))
+
+    with self.assertRaises(ValueError):
+      utils.normalize_tuple((2, 1), n=3, name='strides')
+
+    with self.assertRaises(ValueError):
+      utils.normalize_tuple(None, n=3, name='strides')
+
+  def testNormalizeDataFormat(self):
+    self.assertEqual(
+        'channels_last', utils.normalize_data_format('Channels_Last'))
+    self.assertEqual(
+        'channels_first', utils.normalize_data_format('CHANNELS_FIRST'))
+
+    with self.assertRaises(ValueError):
+      utils.normalize_data_format('invalid')
+
+  def testNormalizePadding(self):
+    self.assertEqual('same', utils.normalize_padding('SAME'))
+    self.assertEqual('valid', utils.normalize_padding('VALID'))
+
+    with self.assertRaises(ValueError):
+      utils.normalize_padding('invalid')
+
+  def testConvOutputLength(self):
+    self.assertEqual(4, utils.conv_output_length(4, 2, 'same', 1, 1))
+    self.assertEqual(2, utils.conv_output_length(4, 2, 'same', 2, 1))
+    self.assertEqual(3, utils.conv_output_length(4, 2, 'valid', 1, 1))
+    self.assertEqual(2, utils.conv_output_length(4, 2, 'valid', 2, 1))
+    self.assertEqual(5, utils.conv_output_length(4, 2, 'full', 1, 1))
+    self.assertEqual(3, utils.conv_output_length(4, 2, 'full', 2, 1))
+    self.assertEqual(2, utils.conv_output_length(5, 2, 'valid', 2, 2))
+
+  def testConvInputLength(self):
+    self.assertEqual(3, utils.conv_input_length(4, 2, 'same', 1))
+    self.assertEqual(2, utils.conv_input_length(2, 2, 'same', 2))
+    self.assertEqual(4, utils.conv_input_length(3, 2, 'valid', 1))
+    self.assertEqual(4, utils.conv_input_length(2, 2, 'valid', 2))
+    self.assertEqual(3, utils.conv_input_length(4, 2, 'full', 1))
+    self.assertEqual(4, utils.conv_input_length(3, 2, 'full', 2))
+
+  def testDeconvOutputLength(self):
+    self.assertEqual(4, utils.deconv_output_length(4, 2, 'same', 1))
+    self.assertEqual(8, utils.deconv_output_length(4, 2, 'same', 2))
+    self.assertEqual(5, utils.deconv_output_length(4, 2, 'valid', 1))
+    self.assertEqual(8, utils.deconv_output_length(4, 2, 'valid', 2))
+    self.assertEqual(3, utils.deconv_output_length(4, 2, 'full', 1))
+    self.assertEqual(6, utils.deconv_output_length(4, 2, 'full', 2))
+
+
+class ConstantValueTest(test.TestCase):
+
+  @test_util.run_deprecated_v1
+  def testConstantValue(self):
+    f1 = lambda: constant_op.constant(5)
+    f2 = lambda: constant_op.constant(32)
+
+    # Boolean pred
+    self.assertEqual(5, utils.constant_value(utils.smart_cond(True, f1, f2)))
+    self.assertEqual(32, utils.constant_value(utils.smart_cond(False, f1, f2)))
+
+    # Integer pred
+    self.assertEqual(5, utils.constant_value(utils.smart_cond(1, f1, f2)))
+    self.assertEqual(32, utils.constant_value(utils.smart_cond(0, f1, f2)))
+
+    # Unknown pred
+    pred = array_ops.placeholder_with_default(True, shape=())
+    self.assertIsNone(utils.constant_value(utils.smart_cond(pred, f1, f2)))
+
+    #Error case
+    with self.assertRaises(TypeError):
+      utils.constant_value(5)
+
+
+if __name__ == '__main__':
+  test.main()