class_docstr: A graph block that applies models to the graph elements independently.
  
  The inputs and outputs are graphs. The corresponding models are applied to
  each element of the graph (edges, nodes and globals) in parallel and
  independently of the other elements. It can be used to encode or
  decode the elements of a graph.
docstr: Initializes the GraphIndependent module.
  
  Args:
    edge_model_fn: A callable that returns an edge model function. The
      callable must return a Sonnet module (or equivalent). If passed `None`,
      will pass through inputs (the default).
    node_model_fn: A callable that returns a node model function. The callable
      must return a Sonnet module (or equivalent). If passed `None`, will pass
      through inputs (the default).
    global_model_fn: A callable that returns a global model function. The
      callable must return a Sonnet module (or equivalent). If passed `None`,
      will pass through inputs (the default).
    name: The module name.
code: def __init__(
      self,
      edge_model_fn=None,
      node_model_fn=None,
      global_model_fn=None,
      name="graph_independent",
  ):
      """Initializes the GraphIndependent module.
  
      Args:
        edge_model_fn: A callable that returns an edge model function. The
          callable must return a Sonnet module (or equivalent). If passed `None`,
          will pass through inputs (the default).
        node_model_fn: A callable that returns a node model function. The callable
          must return a Sonnet module (or equivalent). If passed `None`, will pass
          through inputs (the default).
        global_model_fn: A callable that returns a global model function. The
          callable must return a Sonnet module (or equivalent). If passed `None`,
          will pass through inputs (the default).
        name: The module name.
      """
      super(GraphIndependent, self).__init__(name=name)
  
      with self._enter_variable_scope():
          # The use of snt.Module below is to ensure the ops and variables that
          # result from the edge/node/global_model_fns are scoped analogous to how
          # the Edge/Node/GlobalBlock classes do.
          if edge_model_fn is None:
              self._edge_model = lambda x: x
          else:
              self._edge_model = _base.WrappedModelFnModule(
                  edge_model_fn, name="edge_model"
              )
          if node_model_fn is None:
              self._node_model = lambda x: x
          else:
              self._node_model = _base.WrappedModelFnModule(
                  node_model_fn, name="node_model"
              )
          if global_model_fn is None:
              self._global_model = lambda x: x
          else:
              self._global_model = _base.WrappedModelFnModule(
                  global_model_fn, name="global_model"
              )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from graph_nets import _base
  from graph_nets import blocks
  import tensorflow
label_desc: Use image node_id 1 to create a new GraphIndependent object from inherited base classes: _base with example: obj = GraphIndependent(edge_model_fn, node_model_fn, global_model_fn, name)