code: def load_dict(
      network,
      data,
      ignore_missing=False,
      load_by="names_or_order",
      skip_validation=True,
  ):
      """
      Load network networks from dictionary.
  
      Parameters
      ----------
      network : network, list of layer or network
  
      data : dict
          Dictionary that stores network parameters.
  
      ignore_missing : bool
          ``False`` means that error will be triggered in case
          if some of the layers doesn't have storage parameters
          in the specified source. Defaults to ``False``.
  
      load_by : {``names``, ``order``, ``names_or_order``}
          Defines strategy that will be used during parameter loading
  
          - ``names`` - Matches layers using their names.
  
          - ``order`` - Matches layers using their relative position.
  
          - ``names_or_order`` - First, method tries to match layers using
            their names. If that doesn't work, then layer's relative position
            will be used.
  
          Defaults to ``names_or_order``.
  
      skip_validation : bool
          When set to ``False`` validation will be applied per each layer in
          order to make sure that there were no changes between created
          and stored models. Defaults to ``True``
  
      Raises
      ------
      ValueError
          Happens in case if `ignore_missing=False` and there is no
          parameters for some of the layers.
      """
      if load_by not in ("names", "order", "names_or_order"):
          raise ValueError(
              "Invalid value for the `load_by` argument: {}. Should be "
              "one of the following values: names, order, names_or_order."
              "".format(load_by)
          )
  
      if not skip_validation:
          validate_data_structure(data)
  
      network = extract_network(network)
  
      # We need to initialize network, to make sure
      # that each layer will generate shared variables
      network.create_variables()
  
      # We are only interested in layers that has parameters
      layers = data["layers"]
      layers_data = [l for l in layers if l["parameters"]]
      layers_conn = [l for l in network if l.variables]
  
      if not ignore_missing and len(layers_data) != len(layers_conn):
          raise ParameterLoaderError(
              "Couldn't load parameters from the dictionary. Connection "
              "has {} layers with parameters whether stored data has {}"
              "".format(len(layers_data), len(layers_conn))
          )
  
      if load_by == "names":
          load_dict_by_names(layers_conn, layers_data, ignore_missing)
  
      elif load_by == "order":
          load_dict_sequentially(layers_conn, layers_data)
  
      else:
          try:
              # First we try to load parameters using there names as
              # identifiers. Names are more reliable identifiers than
              # order of layers in the network
              load_dict_by_names(
                  layers_conn, layers_data, ignore_missing
              )
  
          except ParameterLoaderError:
              # If we couldn't load data using layer names we will try to
              # compare layers in sequence one by one. Even if names are
              # different networks can be the same and order of parameters
              # should also be the same
              load_dict_sequentially(layers_conn, layers_data)
  
imports: import json
  from time import gmtime, strftime
  import six
  import h5py
  import numpy
  import tensorflow
  from six.moves import cPickle
  import neupy
  from neupy.core.docs import shared_docs
  from neupy.layers.graph import LayerGraph
  from neupy.algorithms.base import BaseNetwork
  from neupy.utils import asfloat, tf_utils
label_desc: Use image node_id 6 for calling a global function with example usage: load_dict(network, data, ignore_missing, load_by, skip_validation) without return types