chore: import upstream snapshot with attribution

tensorflow/python/kernel_tests/summary_ops/BUILD

@@ -0,0 +1,98 @@
+# Tests of TensorFlow kernels written using the Python API.
+
+load("//tensorflow:tensorflow.default.bzl", "cuda_py_strict_test", "tf_py_strict_test")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
+    licenses = ["notice"],
+)
+
+cuda_py_strict_test(
+    name = "summary_ops_test",
+    size = "medium",
+    srcs = ["summary_ops_test.py"],
+    deps = [
+        "//tensorflow/core:protos_all_py",
+        "//tensorflow/python/eager:context",
+        "//tensorflow/python/eager:def_function",
+        "//tensorflow/python/framework:constant_op",
+        "//tensorflow/python/framework:dtypes",
+        "//tensorflow/python/framework:errors",
+        "//tensorflow/python/framework:ops",
+        "//tensorflow/python/framework:tensor_spec",
+        "//tensorflow/python/framework:tensor_util",
+        "//tensorflow/python/framework:test_lib",
+        "//tensorflow/python/lib/io:tf_record",
+        "//tensorflow/python/module",
+        "//tensorflow/python/ops:math_ops",
+        "//tensorflow/python/ops:summary_ops_v2",
+        "//tensorflow/python/ops:variables",
+        "//tensorflow/python/platform:client_testlib",
+        "//tensorflow/python/platform:gfile",
+        "//tensorflow/python/platform:tf_logging",
+        "//tensorflow/python/saved_model:load",
+        "//tensorflow/python/saved_model:loader",
+        "//tensorflow/python/saved_model:save",
+        "//tensorflow/python/saved_model:tag_constants",
+    ],
+)
+
+cuda_py_strict_test(
+    name = "summary_v1_audio_op_test",
+    size = "small",
+    srcs = ["summary_v1_audio_op_test.py"],
+    deps = [
+        "//tensorflow/core:protos_all_py",
+        "//tensorflow/python/framework:for_generated_wrappers",
+        "//tensorflow/python/platform:client_testlib",
+        "//tensorflow/python/summary:summary_py",
+        "//third_party/py/numpy",
+    ],
+)
+
+cuda_py_strict_test(
+    name = "summary_v1_image_op_test",
+    size = "small",
+    srcs = ["summary_v1_image_op_test.py"],
+    deps = [
+        "//tensorflow/core:protos_all_py",
+        "//tensorflow/python/framework:for_generated_wrappers",
+        "//tensorflow/python/framework:test_lib",
+        "//tensorflow/python/ops:image_ops",
+        "//tensorflow/python/ops:nn_grad",
+        "//tensorflow/python/platform:client_testlib",
+        "//tensorflow/python/summary:summary_py",
+        "//third_party/py/numpy",
+    ],
+)
+
+tf_py_strict_test(
+    name = "summary_v1_ops_test",
+    size = "small",
+    srcs = ["summary_v1_ops_test.py"],
+    deps = [
+        "//tensorflow/core:protos_all_py",
+        "//tensorflow/python/framework:constant_op",
+        "//tensorflow/python/framework:for_generated_wrappers",
+        "//tensorflow/python/framework:test_lib",
+        "//tensorflow/python/ops:logging_ops",
+        "//tensorflow/python/platform:client_testlib",
+        "//tensorflow/python/summary:summary_py",
+    ],
+)
+
+tf_py_strict_test(
+    name = "summary_v1_tensor_op_test",
+    size = "small",
+    srcs = ["summary_v1_tensor_op_test.py"],
+    deps = [
+        "//tensorflow/core:protos_all_py",
+        "//tensorflow/python/framework:constant_op",
+        "//tensorflow/python/framework:for_generated_wrappers",
+        "//tensorflow/python/framework:tensor_util",
+        "//tensorflow/python/ops:array_ops",
+        "//tensorflow/python/platform:client_testlib",
+        "//tensorflow/python/summary:summary_py",
+        "//third_party/py/numpy",
+    ],
+)

tensorflow/python/kernel_tests/summary_ops/summary_v1_audio_op_test.py

@@ -0,0 +1,67 @@
+# 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 summary V1 audio op."""
+
+import numpy as np
+
+from tensorflow.core.framework import summary_pb2
+from tensorflow.python.framework import ops
+from tensorflow.python.platform import test
+from tensorflow.python.summary import summary
+
+
+class SummaryV1AudioOpTest(test.TestCase):
+
+  def _AsSummary(self, s):
+    summ = summary_pb2.Summary()
+    summ.ParseFromString(s)
+    return summ
+
+  def _CheckProto(self, audio_summ, sample_rate, num_channels, length_frames):
+    """Verify that the non-audio parts of the audio_summ proto match shape."""
+    # Only the first 3 sounds are returned.
+    for v in audio_summ.value:
+      v.audio.ClearField("encoded_audio_string")
+    expected = "\n".join("""
+        value {
+          tag: "snd/audio/%d"
+          audio { content_type: "audio/wav" sample_rate: %d
+                  num_channels: %d length_frames: %d }
+        }""" % (i, sample_rate, num_channels, length_frames) for i in range(3))
+    self.assertProtoEquals(expected, audio_summ)
+
+  def testAudioSummary(self):
+    np.random.seed(7)
+    for channels in (1, 2, 5, 8):
+      with self.session(graph=ops.Graph()) as sess:
+        num_frames = 7
+        shape = (4, num_frames, channels)
+        # Generate random audio in the range [-1.0, 1.0).
+        const = 2.0 * np.random.random(shape) - 1.0
+
+        # Summarize
+        sample_rate = 8000
+        summ = summary.audio(
+            "snd", const, max_outputs=3, sample_rate=sample_rate)
+        value = self.evaluate(summ)
+        self.assertEqual([], summ.get_shape())
+        audio_summ = self._AsSummary(value)
+
+        # Check the rest of the proto
+        self._CheckProto(audio_summ, sample_rate, channels, num_frames)
+
+
+if __name__ == "__main__":
+  test.main()

tensorflow/python/kernel_tests/summary_ops/summary_v1_image_op_test.py

@@ -0,0 +1,113 @@
+# 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 summary V1 image op."""
+
+import numpy as np
+
+from tensorflow.core.framework import summary_pb2
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import test_util
+from tensorflow.python.ops import image_ops
+import tensorflow.python.ops.nn_grad  # pylint: disable=unused-import
+from tensorflow.python.platform import test
+from tensorflow.python.summary import summary
+
+
+class SummaryV1ImageOpTest(test.TestCase):
+
+  def _AsSummary(self, s):
+    summ = summary_pb2.Summary()
+    summ.ParseFromString(s)
+    return summ
+
+  def _CheckProto(self, image_summ, shape):
+    """Verify that the non-image parts of the image_summ proto match shape."""
+    # Only the first 3 images are returned.
+    for v in image_summ.value:
+      v.image.ClearField("encoded_image_string")
+    expected = "\n".join("""
+        value {
+          tag: "img/image/%d"
+          image { height: %d width: %d colorspace: %d }
+        }""" % ((i,) + shape[1:]) for i in range(3))
+    self.assertProtoEquals(expected, image_summ)
+
+  @test_util.run_deprecated_v1
+  def testImageSummary(self):
+    for depth in (1, 3, 4):
+      for positive in False, True:
+        with self.session(graph=ops.Graph()) as sess:
+          shape = (4, 5, 7) + (depth,)
+          bad_color = [255, 0, 0, 255][:depth]
+          # Build a mostly random image with one nan
+          const = np.random.randn(*shape).astype(np.float32)
+          const[0, 1, 2] = 0  # Make the nan entry not the max
+          if positive:
+            const = 1 + np.maximum(const, 0)
+            scale = 255 / const.reshape(4, -1).max(axis=1)
+            offset = 0
+          else:
+            scale = 127 / np.abs(const.reshape(4, -1)).max(axis=1)
+            offset = 128
+          adjusted = np.floor(scale[:, None, None, None] * const + offset)
+          const[0, 1, 2, depth // 2] = np.nan
+
+          # Summarize
+          summ = summary.image("img", const)
+          value = self.evaluate(summ)
+          self.assertEqual([], summ.get_shape())
+          image_summ = self._AsSummary(value)
+
+          # Decode the first image and check consistency
+          image = image_ops.decode_png(image_summ.value[0]
+                                       .image.encoded_image_string).eval()
+          self.assertAllEqual(image[1, 2], bad_color)
+          image[1, 2] = adjusted[0, 1, 2]
+          self.assertAllClose(image, adjusted[0], rtol=2e-5, atol=2e-5)
+
+          # Check the rest of the proto
+          self._CheckProto(image_summ, shape)
+
+  @test_util.run_deprecated_v1
+  def testImageSummaryUint8(self):
+    np.random.seed(7)
+    for depth in (1, 3, 4):
+      with self.session(graph=ops.Graph()) as sess:
+        shape = (4, 5, 7) + (depth,)
+
+        # Build a random uint8 image
+        images = np.random.randint(256, size=shape).astype(np.uint8)
+        tf_images = ops.convert_to_tensor(images)
+        self.assertEqual(tf_images.dtype, dtypes.uint8)
+
+        # Summarize
+        summ = summary.image("img", tf_images)
+        value = self.evaluate(summ)
+        self.assertEqual([], summ.get_shape())
+        image_summ = self._AsSummary(value)
+
+        # Decode the first image and check consistency.
+        # Since we're uint8, everything should be exact.
+        image = image_ops.decode_png(image_summ.value[0]
+                                     .image.encoded_image_string).eval()
+        self.assertAllEqual(image, images[0])
+
+        # Check the rest of the proto
+        self._CheckProto(image_summ, shape)
+
+
+if __name__ == "__main__":
+  test.main()

tensorflow/python/kernel_tests/summary_ops/summary_v1_ops_test.py

@@ -0,0 +1,108 @@
+# 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 the actual serialized proto output of the V1 tf.summary ops.
+
+The tensor, audio, and image ops have dedicated tests in adjacent files. The
+overall tf.summary API surface also has its own tests in summary_test.py that
+check calling the API methods but not the exact serialized proto output.
+"""
+
+from tensorflow.core.framework import summary_pb2
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import test_util
+from tensorflow.python.ops import logging_ops
+from tensorflow.python.platform import test
+from tensorflow.python.summary import summary
+
+
+class SummaryV1OpsTest(test.TestCase):
+
+  def _AsSummary(self, s):
+    summ = summary_pb2.Summary()
+    summ.ParseFromString(s)
+    return summ
+
+  def testScalarSummary(self):
+    with self.cached_session() as sess:
+      const = constant_op.constant([10.0, 20.0])
+      summ = logging_ops.scalar_summary(["c1", "c2"], const, name="mysumm")
+      value = self.evaluate(summ)
+    self.assertEqual([], summ.get_shape())
+    self.assertProtoEquals("""
+      value { tag: "c1" simple_value: 10.0 }
+      value { tag: "c2" simple_value: 20.0 }
+      """, self._AsSummary(value))
+
+  def testScalarSummaryDefaultName(self):
+    with self.cached_session() as sess:
+      const = constant_op.constant([10.0, 20.0])
+      summ = logging_ops.scalar_summary(["c1", "c2"], const)
+      value = self.evaluate(summ)
+    self.assertEqual([], summ.get_shape())
+    self.assertProtoEquals("""
+      value { tag: "c1" simple_value: 10.0 }
+      value { tag: "c2" simple_value: 20.0 }
+      """, self._AsSummary(value))
+
+  @test_util.run_deprecated_v1
+  def testMergeSummary(self):
+    with self.cached_session() as sess:
+      const = constant_op.constant(10.0)
+      summ1 = summary.histogram("h", const)
+      summ2 = logging_ops.scalar_summary("c", const)
+      merge = summary.merge([summ1, summ2])
+      value = self.evaluate(merge)
+    self.assertEqual([], merge.get_shape())
+    self.assertProtoEquals("""
+      value {
+        tag: "h"
+        histo {
+          min: 10.0
+          max: 10.0
+          num: 1.0
+          sum: 10.0
+          sum_squares: 100.0
+          bucket_limit: 9.93809490288
+          bucket_limit: 10.9319043932
+          bucket_limit: 1.7976931348623157e+308
+          bucket: 0.0
+          bucket: 1.0
+          bucket: 0.0
+        }
+      }
+      value { tag: "c" simple_value: 10.0 }
+    """, self._AsSummary(value))
+
+  def testMergeAllSummaries(self):
+    with ops.Graph().as_default():
+      const = constant_op.constant(10.0)
+      summ1 = summary.histogram("h", const)
+      summ2 = summary.scalar("o", const, collections=["foo_key"])
+      summ3 = summary.scalar("c", const)
+      merge = summary.merge_all()
+      self.assertEqual("MergeSummary", merge.op.type)
+      self.assertEqual(2, len(merge.op.inputs))
+      self.assertEqual(summ1, merge.op.inputs[0])
+      self.assertEqual(summ3, merge.op.inputs[1])
+      merge = summary.merge_all("foo_key")
+      self.assertEqual("MergeSummary", merge.op.type)
+      self.assertEqual(1, len(merge.op.inputs))
+      self.assertEqual(summ2, merge.op.inputs[0])
+      self.assertTrue(summary.merge_all("bar_key") is None)
+
+
+if __name__ == "__main__":
+  test.main()

tensorflow/python/kernel_tests/summary_ops/summary_v1_tensor_op_test.py

@@ -0,0 +1,165 @@
+# 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" BAvSIS,
+# 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 summary V1 tensor op."""
+
+import numpy as np
+
+from tensorflow.core.framework import summary_pb2
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.ops import array_ops
+from tensorflow.python.platform import test
+from tensorflow.python.summary import summary as summary_lib
+
+
+class SummaryV1TensorOpTest(test.TestCase):
+
+  def _SummarySingleValue(self, s):
+    summ = summary_pb2.Summary()
+    summ.ParseFromString(s)
+    self.assertEqual(len(summ.value), 1)
+    return summ.value[0]
+
+  def _AssertNumpyEq(self, actual, expected):
+    self.assertTrue(np.array_equal(actual, expected))
+
+  def testTags(self):
+    with self.cached_session() as sess:
+      c = constant_op.constant(1)
+      s1 = summary_lib.tensor_summary("s1", c)
+      with ops.name_scope("foo", skip_on_eager=False):
+        s2 = summary_lib.tensor_summary("s2", c)
+        with ops.name_scope("zod", skip_on_eager=False):
+          s3 = summary_lib.tensor_summary("s3", c)
+          s4 = summary_lib.tensor_summary("TensorSummary", c)
+      summ1, summ2, summ3, summ4 = self.evaluate([s1, s2, s3, s4])
+
+    v1 = self._SummarySingleValue(summ1)
+    self.assertEqual(v1.tag, "s1")
+
+    v2 = self._SummarySingleValue(summ2)
+    self.assertEqual(v2.tag, "foo/s2")
+
+    v3 = self._SummarySingleValue(summ3)
+    self.assertEqual(v3.tag, "foo/zod/s3")
+
+    v4 = self._SummarySingleValue(summ4)
+    self.assertEqual(v4.tag, "foo/zod/TensorSummary")
+
+  def testScalarSummary(self):
+    with self.cached_session() as sess:
+      const = constant_op.constant(10.0)
+      summ = summary_lib.tensor_summary("foo", const)
+      result = self.evaluate(summ)
+
+    value = self._SummarySingleValue(result)
+    n = tensor_util.MakeNdarray(value.tensor)
+    self._AssertNumpyEq(n, 10)
+
+  def testStringSummary(self):
+    s = b"foobar"
+    with self.cached_session() as sess:
+      const = constant_op.constant(s)
+      summ = summary_lib.tensor_summary("foo", const)
+      result = self.evaluate(summ)
+
+    value = self._SummarySingleValue(result)
+    n = tensor_util.MakeNdarray(value.tensor)
+    self._AssertNumpyEq(n, s)
+
+  def testManyScalarSummary(self):
+    with self.cached_session() as sess:
+      const = array_ops.ones([5, 5, 5])
+      summ = summary_lib.tensor_summary("foo", const)
+      result = self.evaluate(summ)
+    value = self._SummarySingleValue(result)
+    n = tensor_util.MakeNdarray(value.tensor)
+    self._AssertNumpyEq(n, np.ones([5, 5, 5]))
+
+  def testManyStringSummary(self):
+    strings = [[b"foo bar", b"baz"], [b"zoink", b"zod"]]
+    with self.cached_session() as sess:
+      const = constant_op.constant(strings)
+      summ = summary_lib.tensor_summary("foo", const)
+      result = self.evaluate(summ)
+    value = self._SummarySingleValue(result)
+    n = tensor_util.MakeNdarray(value.tensor)
+    self._AssertNumpyEq(n, strings)
+
+  def testManyBools(self):
+    bools = [True, True, True, False, False, False]
+    with self.cached_session() as sess:
+      const = constant_op.constant(bools)
+      summ = summary_lib.tensor_summary("foo", const)
+      result = self.evaluate(summ)
+
+    value = self._SummarySingleValue(result)
+    n = tensor_util.MakeNdarray(value.tensor)
+    self._AssertNumpyEq(n, bools)
+
+  def testSummaryDescriptionAndDisplayName(self):
+    with self.cached_session() as sess:
+
+      def get_description(summary_op):
+        summ_str = self.evaluate(summary_op)
+        summ = summary_pb2.Summary()
+        summ.ParseFromString(summ_str)
+        return summ.value[0].metadata
+
+      const = constant_op.constant(1)
+      # Default case; no description or display name
+      simple_summary = summary_lib.tensor_summary("simple", const)
+
+      descr = get_description(simple_summary)
+      self.assertEqual(descr.display_name, "")
+      self.assertEqual(descr.summary_description, "")
+
+      # Values are provided via function args
+      with_values = summary_lib.tensor_summary(
+          "simple",
+          const,
+          display_name="my name",
+          summary_description="my description")
+
+      descr = get_description(with_values)
+      self.assertEqual(descr.display_name, "my name")
+      self.assertEqual(descr.summary_description, "my description")
+
+      # Values are provided via the SummaryMetadata arg
+      metadata = summary_pb2.SummaryMetadata()
+      metadata.display_name = "my name"
+      metadata.summary_description = "my description"
+
+      with_metadata = summary_lib.tensor_summary(
+          "simple", const, summary_metadata=metadata)
+      descr = get_description(with_metadata)
+      self.assertEqual(descr.display_name, "my name")
+      self.assertEqual(descr.summary_description, "my description")
+
+      # If both SummaryMetadata and explicit args are provided, the args win
+      overwrite = summary_lib.tensor_summary(
+          "simple",
+          const,
+          summary_metadata=metadata,
+          display_name="overwritten",
+          summary_description="overwritten")
+      descr = get_description(overwrite)
+      self.assertEqual(descr.display_name, "overwritten")
+      self.assertEqual(descr.summary_description, "overwritten")
+
+
+if __name__ == "__main__":
+  test.main()