code: def pack_nbrs(
      labeled_examples_path,
      unlabeled_examples_path,
      graph_path,
      output_training_data_path,
      add_undirected_edges=False,
      max_nbrs=None,
      id_feature_name="id",
  ):
      """Prepares input for graph-based Neural Structured Learning and persists it.
  
      In particular, this function merges into each labeled training example the
      features from its out-edge neighbor examples according to a supplied
      similarity graph, and persists the resulting (augmented) training data.
  
      Each `tf.train.Example` read from the files identified by
      `labeled_examples_path` and `unlabeled_examples_path` is expected to have a
      feature that contains its ID (represented as a singleton `bytes_list` value);
      the name of this feature is specified by the value of `id_feature_name`.
  
      Each edge in the graph specified by `graph_path` is identified by a source
      instance ID, a target instance ID, and an optional edge weight. These edges
      are specified by TSV lines of the following form:
  
      ```
      source_id<TAB>target_id[<TAB>edge_weight]
      ```
  
      If no `edge_weight` is specified, it defaults to 1.0. If the input graph is
      not symmetric and if `add_undirected_edges` is `True`, then all edges will be
      treated as bi-directional. To build a graph based on the similarity of
      instances' dense embeddings, see `nsl.tools.build_graph`.
  
      This function merges into each labeled example the features of that example's
      out-edge neighbors according to that instance's in-edges in the graph. If a
      value is specified for `max_nbrs`, then at most that many neighbors' features
      are merged into each labeled instance (based on which neighbors have the
      largest edge weights, with ties broken using instance IDs).
  
      Here's how the merging process works. For each labeled example, the features
      of its `i`'th out-edge neighbor will be prefixed by `NL_nbr_<i>_`, with
      indexes `i` in the half-open interval `[0, K)`, where K is the minimum of
      `max_nbrs` and the number of the labeled example's out-edges in the graph. A
      feature named `NL_nbr_<i>_weight` will also be merged into the labeled example
      whose value will be the neighbor's corresponding edge weight. The top
      neighbors to use in this process are selected by consulting the input graph
      and selecting the labeled example's out-edge neighbors with the largest edge
      weight; ties are broken by preferring neighbor IDs with larger lexicographic
      order. Finally, a feature named `NL_num_nbrs` is set on the result (a
      singleton `int64_list`) denoting the number of neighbors `K` merged into the
      labeled example.
  
      Finally, the merged examples are written to a TFRecord file named by
      `output_training_data_path`.
  
      Args:
        labeled_examples_path: Names a TFRecord file containing labeled
          `tf.train.Example` instances.
        unlabeled_examples_path: Names a TFRecord file containing unlabeled
          `tf.train.Example` instances. This can be an empty string if there are no
          unlabeled examples.
        graph_path: Names a TSV file that specifies a graph as a set of edges
          representing similarity relationships.
        output_training_data_path: Path to a file where the resulting augmented
          training data in the form of `tf.train.Example` instances will be
          persisted in the TFRecord format.
        add_undirected_edges: `Boolean` indicating whether or not to treat adges as
          bi-directional.
        max_nbrs: The maximum number of neighbors to use to generate the augmented
          training data for downstream training.
        id_feature_name: The name of the feature in the input labeled and unlabeled
          `tf.train.Example` objects representing the ID of examples.
      """
      start_time = time.time()
  
      # Read seed and neighbor TFRecord input files.
      seed_exs = _read_tfrecord_examples(
          labeled_examples_path, id_feature_name
      )
      # Unlabeled neighbor input instances are optional. If not provided, all
      # neighbors used will be labeled instances.
      nbr_exs = (
          _read_tfrecord_examples(
              unlabeled_examples_path, id_feature_name
          )
          if unlabeled_examples_path
          else {}
      )
  
      # Read the input graph in TSV format, and conditionally reverse all its edges.
      graph = graph_utils.read_tsv_graph(graph_path)
      if add_undirected_edges:
          graph_utils.add_undirected_edges(graph)
  
      # Join the edges with the seed and neighbor Examples, and write out the
      # results to the output TFRecord file.
      with tf.io.TFRecordWriter(output_training_data_path) as writer:
          for merged_ex in _join_examples(
              seed_exs, nbr_exs, graph, max_nbrs
          ):
              writer.write(merged_ex.SerializeToString())
      logging.info(
          "Output written to TFRecord file: %s.",
          output_training_data_path,
      )
      logging.info(
          "Total running time: %.2f minutes.",
          (time.time() - start_time) / 60.0,
      )
  
file_path: neural-structured-learning/neural_structured_learning/tools/pack_nbrs.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import collections
  import time
  from absl import app
  from absl import flags
  from absl import logging
  from neural_structured_learning.tools import graph_utils
  import six
  import tensorflow
label_desc: Use image node_id 3 for calling a global function with example usage: pack_nbrs(labeled_examples_path, unlabeled_examples_path, graph_path, output_training_data_path, add_undirected_edges, max_nbrs, id_feature_name) without return types