tensorbored 2.21.0rc1769983804__py3-none-any.whl

tensorbored/data/server_ingester.py

@@ -0,0 +1,301 @@
+# Copyright 2020 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.
+# ==============================================================================
+"""Provides data ingestion logic backed by a gRPC server."""
+
+import errno
+import logging
+import os
+import subprocess
+import tempfile
+import time
+
+import grpc
+import pkg_resources
+
+from tensorbored.data import grpc_provider
+from tensorbored.data import ingester
+from tensorbored.data.proto import data_provider_pb2
+from tensorbored.util import tb_logging
+
+logger = tb_logging.get_logger()
+
+# If this environment variable is non-empty, it will be used as the path to the
+# data server binary rather than using a bundled version.
+_ENV_DATA_SERVER_BINARY = "TENSORBOARD_DATA_SERVER_BINARY"
+
+
+class ExistingServerDataIngester(ingester.DataIngester):
+    """Connect to an already running gRPC server."""
+
+    def __init__(self, address, *, channel_creds_type):
+        """Initializes an ingester with the given configuration.
+
+        Args:
+          address: String, as passed to `--grpc_data_provider`.
+          channel_creds_type: `grpc_util.ChannelCredsType`, as passed to
+            `--grpc_creds_type`.
+        """
+        stub = _make_stub(address, channel_creds_type)
+        self._data_provider = grpc_provider.GrpcDataProvider(address, stub)
+
+    @property
+    def data_provider(self):
+        return self._data_provider
+
+    def start(self):
+        pass
+
+
+class SubprocessServerDataIngester(ingester.DataIngester):
+    """Start a new data server as a subprocess."""
+
+    def __init__(
+        self,
+        server_binary,
+        logdir,
+        *,
+        reload_interval,
+        channel_creds_type,
+        samples_per_plugin=None,
+        extra_flags=None,
+    ):
+        """Initializes an ingester with the given configuration.
+
+        Args:
+          server_binary: `ServerBinary` to launch.
+          logdir: String, as passed to `--logdir`.
+          reload_interval: Number, as passed to `--reload_interval`.
+          channel_creds_type: `grpc_util.ChannelCredsType`, as passed to
+            `--grpc_creds_type`.
+          samples_per_plugin: Dict[String, Int], as parsed from
+            `--samples_per_plugin`.
+          extra_flags: List of extra string flags to be passed to the
+            data server without further interpretation.
+        """
+        self._server_binary = server_binary
+        self._data_provider = None
+        self._logdir = logdir
+        self._reload_interval = reload_interval
+        self._channel_creds_type = channel_creds_type
+        self._samples_per_plugin = samples_per_plugin or {}
+        self._extra_flags = list(extra_flags or [])
+
+    @property
+    def data_provider(self):
+        if self._data_provider is None:
+            raise RuntimeError("Must call `start` first")
+        return self._data_provider
+
+    def start(self):
+        if self._data_provider:
+            return
+
+        tmpdir = tempfile.TemporaryDirectory(prefix="tensorboard_data_server_")
+        port_file_path = os.path.join(tmpdir.name, "port")
+        error_file_path = os.path.join(tmpdir.name, "startup_error")
+
+        if self._reload_interval <= 0:
+            reload = "once"
+        else:
+            reload = str(int(self._reload_interval))
+
+        sample_hint_pairs = [
+            "%s=%s" % (k, "all" if v == 0 else v)
+            for k, v in self._samples_per_plugin.items()
+        ]
+        samples_per_plugin = ",".join(sample_hint_pairs)
+
+        args = [
+            self._server_binary.path,
+            "--logdir=%s" % os.path.expanduser(self._logdir),
+            "--reload=%s" % reload,
+            "--samples-per-plugin=%s" % samples_per_plugin,
+            "--port=0",
+            "--port-file=%s" % (port_file_path,),
+            "--die-after-stdin",
+        ]
+        if self._server_binary.at_least_version("0.5.0a0"):
+            args.append("--error-file=%s" % (error_file_path,))
+        if logger.isEnabledFor(logging.INFO):
+            args.append("--verbose")
+        if logger.isEnabledFor(logging.DEBUG):
+            args.append("--verbose")  # Repeat arg to increase verbosity.
+        args.extend(self._extra_flags)
+
+        logger.info("Spawning data server: %r", args)
+        popen = subprocess.Popen(args, stdin=subprocess.PIPE)
+        # Stash stdin to avoid calling its destructor: on Windows, this
+        # is a `subprocess.Handle` that closes itself in `__del__`,
+        # which would cause the data server to shut down. (This is not
+        # documented; you have to read CPython source to figure it out.)
+        # We want that to happen at end of process, but not before.
+        self._stdin_handle = popen.stdin  # stash to avoid stdin being closed
+
+        port = None
+        # The server only needs about 10 microseconds to spawn on my machine,
+        # but give a few orders of magnitude of padding, and then poll.
+        time.sleep(0.01)
+        for i in range(20):
+            if popen.poll() is not None:
+                msg = (_maybe_read_file(error_file_path) or "").strip()
+                if not msg:
+                    msg = (
+                        "exited with %d; check stderr for details"
+                        % popen.poll()
+                    )
+                raise DataServerStartupError(msg)
+            logger.info("Polling for data server port (attempt %d)", i)
+            port_file_contents = _maybe_read_file(port_file_path)
+            logger.info("Port file contents: %r", port_file_contents)
+            if (port_file_contents or "").endswith("\n"):
+                port = int(port_file_contents)
+                break
+            # Else, not done writing yet.
+            time.sleep(0.5)
+        if port is None:
+            raise DataServerStartupError(
+                "Timed out while waiting for data server to start. "
+                "It may still be running as pid %d." % popen.pid
+            )
+
+        addr = "localhost:%d" % port
+        stub = _make_stub(addr, self._channel_creds_type)
+        logger.info(
+            "Opened channel to data server at pid %d via %s",
+            popen.pid,
+            addr,
+        )
+
+        req = data_provider_pb2.GetExperimentRequest()
+        try:
+            stub.GetExperiment(req, timeout=5)  # should be near-instant
+        except grpc.RpcError as e:
+            msg = "Failed to communicate with data server at %s: %s" % (addr, e)
+            logging.warning("%s", msg)
+            raise DataServerStartupError(msg) from e
+        logger.info("Got valid response from data server")
+        self._data_provider = grpc_provider.GrpcDataProvider(addr, stub)
+
+
+def _maybe_read_file(path):
+    """Read a file, or return `None` on ENOENT specifically."""
+    try:
+        with open(path) as infile:
+            return infile.read()
+    except OSError as e:
+        if e.errno == errno.ENOENT:
+            return None
+        raise
+
+
+def _make_stub(addr, channel_creds_type):
+    creds, options = channel_creds_type.channel_config()
+    options.append(("grpc.max_receive_message_length", 1024 * 1024 * 256))
+    channel = grpc.secure_channel(addr, creds, options=options)
+    return grpc_provider.make_stub(channel)
+
+
+class NoDataServerError(RuntimeError):
+    pass
+
+
+class DataServerStartupError(RuntimeError):
+    pass
+
+
+class ServerBinary:
+    """Information about a data server binary."""
+
+    def __init__(self, path, version):
+        """Initializes a `ServerBinary`.
+
+        Args:
+          path: String path to executable on disk.
+          version: PEP 396-compliant version string, or `None` if
+            unknown or not applicable. Binaries at unknown versions are
+            assumed to be bleeding-edge: if you bring your own binary,
+            it's on you to make sure that it's up to date.
+        """
+        self._path = path
+        self._version = (
+            pkg_resources.parse_version(version)
+            if version is not None
+            else version
+        )
+
+    @property
+    def path(self):
+        return self._path
+
+    def at_least_version(self, required_version):
+        """Test whether the binary's version is at least the given one.
+
+        Useful for gating features that are available in the latest data
+        server builds from head, but not yet released to PyPI. For
+        example, if v0.4.0 is the latest published version, you can
+        check `at_least_version("0.5.0a0")` to include both prereleases
+        at head and the eventual final release of v0.5.0.
+
+        If this binary's version was set to `None` at construction time,
+        this method always returns `True`.
+
+        Args:
+          required_version: PEP 396-compliant version string.
+
+        Returns:
+          Boolean.
+        """
+        if self._version is None:
+            return True
+        return self._version >= pkg_resources.parse_version(required_version)
+
+
+def get_server_binary():
+    """Get `ServerBinary` info or raise `NoDataServerError`."""
+    env_result = os.environ.get(_ENV_DATA_SERVER_BINARY)
+    if env_result:
+        logging.info("Server binary (from env): %s", env_result)
+        if not os.path.isfile(env_result):
+            raise NoDataServerError(
+                "Found environment variable %s=%s, but no such file exists."
+                % (_ENV_DATA_SERVER_BINARY, env_result)
+            )
+        return ServerBinary(env_result, version=None)
+
+    bundle_result = os.path.join(os.path.dirname(__file__), "server", "server")
+    if os.path.exists(bundle_result):
+        logging.info("Server binary (from bundle): %s", bundle_result)
+        return ServerBinary(bundle_result, version=None)
+
+    try:
+        import tensorboard_data_server
+    except ImportError:
+        pass
+    else:
+        pkg_result = tensorboard_data_server.server_binary()
+        version = tensorboard_data_server.__version__
+        logging.info(
+            "Server binary (from Python package v%s): %s", version, pkg_result
+        )
+        if pkg_result is None:
+            raise NoDataServerError(
+                "TensorBoard data server not supported on this platform."
+            )
+        return ServerBinary(pkg_result, version)
+
+    raise NoDataServerError(
+        "TensorBoard data server not found. This mode is experimental. "
+        "If building from source, pass --define=link_data_server=true."
+    )

tensorbored/data_compat.py

@@ -0,0 +1,159 @@
+# 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.
+# ==============================================================================
+"""Utilities to migrate legacy protos to their modern equivalents."""
+
+import numpy as np
+
+from tensorbored.compat.proto import event_pb2
+from tensorbored.compat.proto import summary_pb2
+from tensorbored.plugins.audio import metadata as audio_metadata
+from tensorbored.plugins.histogram import metadata as histogram_metadata
+from tensorbored.plugins.image import metadata as image_metadata
+from tensorbored.plugins.scalar import metadata as scalar_metadata
+from tensorbored.util import tensor_util
+
+
+def migrate_event(event):
+    if not event.HasField("summary"):
+        return event
+    old_values = event.summary.value
+    new_values = [migrate_value(value) for value in old_values]
+    # Optimization: Don't create a new event if there were no changes.
+    if len(old_values) == len(new_values) and all(
+        x is y for (x, y) in zip(old_values, new_values)
+    ):
+        return event
+    result = event_pb2.Event()
+    result.CopyFrom(event)
+    del result.summary.value[:]
+    result.summary.value.extend(new_values)
+    return result
+
+
+def migrate_value(value):
+    """Convert `value` to a new-style value, if necessary and possible.
+
+    An "old-style" value is a value that uses any `value` field other than
+    the `tensor` field. A "new-style" value is a value that uses the
+    `tensor` field. TensorBoard continues to support old-style values on
+    disk; this method converts them to new-style values so that further
+    code need only deal with one data format.
+
+    Arguments:
+      value: A `Summary.Value` object. This argument is not modified.
+
+    Returns:
+      If the `value` is an old-style value for which there is a new-style
+      equivalent, the result is the new-style value. Otherwise---if the
+      value is already new-style or does not yet have a new-style
+      equivalent---the value will be returned unchanged.
+
+    :type value: Summary.Value
+    :rtype: Summary.Value
+    """
+    handler = {
+        "histo": _migrate_histogram_value,
+        "image": _migrate_image_value,
+        "audio": _migrate_audio_value,
+        "simple_value": _migrate_scalar_value,
+    }.get(value.WhichOneof("value"))
+    return handler(value) if handler else value
+
+
+def make_summary(tag, metadata, data):
+    tensor_proto = tensor_util.make_tensor_proto(data)
+    return summary_pb2.Summary.Value(
+        tag=tag, metadata=metadata, tensor=tensor_proto
+    )
+
+
+def _migrate_histogram_value(value):
+    """Convert `old-style` histogram value to `new-style`.
+
+    The "old-style" format can have outermost bucket limits of -DBL_MAX and
+    DBL_MAX, which are problematic for visualization. We replace those here
+    with the actual min and max values seen in the input data, but then in
+    order to avoid introducing "backwards" buckets (where left edge > right
+    edge), we first must drop all empty buckets on the left and right ends.
+    """
+    histogram_value = value.histo
+    bucket_counts = histogram_value.bucket
+    # Find the indices of the leftmost and rightmost non-empty buckets.
+    n = len(bucket_counts)
+    start = next((i for i in range(n) if bucket_counts[i] > 0), n)
+    end = next((i for i in reversed(range(n)) if bucket_counts[i] > 0), -1)
+    if start > end:
+        # If all input buckets were empty, treat it as a zero-bucket
+        # new-style histogram.
+        buckets = np.zeros([0, 3], dtype=np.float32)
+    else:
+        # Discard empty buckets on both ends, and keep only the "inner"
+        # edges from the remaining buckets. Note that bucket indices range
+        # from `start` to `end` inclusive, but bucket_limit indices are
+        # exclusive of `end` - this is because bucket_limit[i] is the
+        # right-hand edge for bucket[i].
+        bucket_counts = bucket_counts[start : end + 1]
+        inner_edges = histogram_value.bucket_limit[start:end]
+        # Use min as the left-hand limit for the first non-empty bucket.
+        bucket_lefts = [histogram_value.min] + inner_edges
+        # Use max as the right-hand limit for the last non-empty bucket.
+        bucket_rights = inner_edges + [histogram_value.max]
+        buckets = np.array(
+            [bucket_lefts, bucket_rights, bucket_counts], dtype=np.float32
+        ).transpose()
+
+    summary_metadata = histogram_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+    )
+
+    return make_summary(value.tag, summary_metadata, buckets)
+
+
+def _migrate_image_value(value):
+    image_value = value.image
+    data = [
+        str(image_value.width).encode("ascii"),
+        str(image_value.height).encode("ascii"),
+        image_value.encoded_image_string,
+    ]
+
+    summary_metadata = image_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+        converted_to_tensor=True,
+    )
+    return make_summary(value.tag, summary_metadata, data)
+
+
+def _migrate_audio_value(value):
+    audio_value = value.audio
+    data = [[audio_value.encoded_audio_string, b""]]  # empty label
+    summary_metadata = audio_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+        encoding=audio_metadata.Encoding.Value("WAV"),
+        converted_to_tensor=True,
+    )
+    return make_summary(value.tag, summary_metadata, data)
+
+
+def _migrate_scalar_value(value):
+    scalar_value = value.simple_value
+    summary_metadata = scalar_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+    )
+    return make_summary(value.tag, summary_metadata, scalar_value)

tensorbored/dataclass_compat.py

@@ -0,0 +1,224 @@
+# Copyright 2020 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.
+# ==============================================================================
+"""Utilities to migrate legacy summaries/events to generic data form.
+
+For legacy summaries, this populates the `SummaryMetadata.data_class`
+field and makes any necessary transformations to the tensor value. For
+`graph_def` events, this creates a new summary event.
+
+This should be effected after the `data_compat` transformation.
+"""
+
+from tensorbored.compat.proto import event_pb2
+from tensorbored.compat.proto import summary_pb2
+from tensorbored.plugins.audio import metadata as audio_metadata
+from tensorbored.plugins.custom_scalar import (
+    metadata as custom_scalars_metadata,
+)
+from tensorbored.plugins.graph import metadata as graphs_metadata
+from tensorbored.plugins.histogram import metadata as histograms_metadata
+from tensorbored.plugins.hparams import metadata as hparams_metadata
+from tensorbored.plugins.image import metadata as images_metadata
+from tensorbored.plugins.mesh import metadata as mesh_metadata
+from tensorbored.plugins.pr_curve import metadata as pr_curves_metadata
+from tensorbored.plugins.scalar import metadata as scalars_metadata
+from tensorbored.plugins.text import metadata as text_metadata
+from tensorbored.util import tensor_util
+
+
+def migrate_event(event, initial_metadata):
+    """Migrate an event to a sequence of events.
+
+    Args:
+      event: An `event_pb2.Event`. The caller transfers ownership of the
+        event to this method; the event may be mutated, and may or may
+        not appear in the returned sequence.
+      initial_metadata: Map from tag name (string) to `SummaryMetadata`
+        proto for the initial occurrence of the given tag within the
+        enclosing run. While loading a given run, the caller should
+        always pass the same dictionary here, initially `{}`; this
+        function will mutate it and reuse it for future calls.
+
+    Returns:
+      A sequence of `event_pb2.Event`s to use instead of `event`.
+    """
+    what = event.WhichOneof("what")
+    if what == "graph_def":
+        return _migrate_graph_event(event)
+    if what == "tagged_run_metadata":
+        return _migrate_tagged_run_metadata_event(event)
+    if what == "summary":
+        return _migrate_summary_event(event, initial_metadata)
+    return (event,)
+
+
+def _migrate_graph_event(old_event):
+    result = event_pb2.Event()
+    result.wall_time = old_event.wall_time
+    result.step = old_event.step
+    value = result.summary.value.add(tag=graphs_metadata.RUN_GRAPH_NAME)
+    graph_bytes = old_event.graph_def
+    value.tensor.CopyFrom(tensor_util.make_tensor_proto([graph_bytes]))
+    value.metadata.plugin_data.plugin_name = graphs_metadata.PLUGIN_NAME
+    # `value.metadata.plugin_data.content` left empty
+    value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    # As long as the graphs plugin still reads the old format, keep both
+    # the old event and the new event to maintain compatibility.
+    return (old_event, result)
+
+
+def _migrate_tagged_run_metadata_event(old_event):
+    result = event_pb2.Event()
+    result.wall_time = old_event.wall_time
+    result.step = old_event.step
+    trm = old_event.tagged_run_metadata
+    value = result.summary.value.add(tag=trm.tag)
+    value.tensor.CopyFrom(tensor_util.make_tensor_proto([trm.run_metadata]))
+    value.metadata.plugin_data.plugin_name = (
+        graphs_metadata.PLUGIN_NAME_TAGGED_RUN_METADATA
+    )
+    # `value.metadata.plugin_data.content` left empty
+    value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    return (result,)
+
+
+def _migrate_summary_event(event, initial_metadata):
+    values = event.summary.value
+    new_values = [
+        new for old in values for new in _migrate_value(old, initial_metadata)
+    ]
+    # Optimization: Don't create a new event if there were no shallow
+    # changes (there may still have been in-place changes).
+    if len(values) == len(new_values) and all(
+        x is y for (x, y) in zip(values, new_values)
+    ):
+        return (event,)
+    del event.summary.value[:]
+    event.summary.value.extend(new_values)
+    return (event,)
+
+
+def _migrate_value(value, initial_metadata):
+    """Convert an old value to a stream of new values. May mutate."""
+    metadata = initial_metadata.get(value.tag)
+    initial = False
+    if metadata is None:
+        initial = True
+        # Retain a copy of the initial metadata, so that even after we
+        # update its data class we know whether to also transform later
+        # events in this time series.
+        metadata = summary_pb2.SummaryMetadata()
+        metadata.CopyFrom(value.metadata)
+        initial_metadata[value.tag] = metadata
+    if metadata.data_class != summary_pb2.DATA_CLASS_UNKNOWN:
+        return (value,)
+    plugin_name = metadata.plugin_data.plugin_name
+    if plugin_name == histograms_metadata.PLUGIN_NAME:
+        return _migrate_histogram_value(value)
+    if plugin_name == images_metadata.PLUGIN_NAME:
+        return _migrate_image_value(value)
+    if plugin_name == audio_metadata.PLUGIN_NAME:
+        return _migrate_audio_value(value)
+    if plugin_name == scalars_metadata.PLUGIN_NAME:
+        return _migrate_scalar_value(value)
+    if plugin_name == text_metadata.PLUGIN_NAME:
+        return _migrate_text_value(value)
+    if plugin_name == hparams_metadata.PLUGIN_NAME:
+        return _migrate_hparams_value(value)
+    if plugin_name == pr_curves_metadata.PLUGIN_NAME:
+        return _migrate_pr_curve_value(value)
+    if plugin_name == mesh_metadata.PLUGIN_NAME:
+        return _migrate_mesh_value(value)
+    if plugin_name == custom_scalars_metadata.PLUGIN_NAME:
+        return _migrate_custom_scalars_value(value)
+    if plugin_name in [
+        graphs_metadata.PLUGIN_NAME_RUN_METADATA,
+        graphs_metadata.PLUGIN_NAME_RUN_METADATA_WITH_GRAPH,
+        graphs_metadata.PLUGIN_NAME_KERAS_MODEL,
+    ]:
+        return _migrate_graph_sub_plugin_value(value)
+    return (value,)
+
+
+def _migrate_scalar_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_SCALAR
+    return (value,)
+
+
+def _migrate_histogram_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_image_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    return (value,)
+
+
+def _migrate_text_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_audio_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    tensor = value.tensor
+    # Project out just the first axis: actual audio clips.
+    stride = 1
+    while len(tensor.tensor_shape.dim) > 1:
+        stride *= tensor.tensor_shape.dim.pop().size
+    if stride != 1:
+        tensor.string_val[:] = tensor.string_val[::stride]
+    return (value,)
+
+
+def _migrate_hparams_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    if not value.HasField("tensor"):
+        value.tensor.CopyFrom(hparams_metadata.NULL_TENSOR)
+    return (value,)
+
+
+def _migrate_pr_curve_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_mesh_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_custom_scalars_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_graph_sub_plugin_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    shape = value.tensor.tensor_shape.dim
+    if not shape:
+        shape.add(size=1)
+    return (value,)