code: def split_as_data_parameters(
      parameter: p.Parameter,
  ) -> tp.List[tp.Tuple[str, p.Data]]:
      """List all the instances involved as parameter (not as subparameter/
      endogeneous parameter) ordered as in standardized data space
  
      Parameter
      ---------
      parameter: Parameter
          the parameter to split
  
      Returns
      -------
      list
          the list and subparameters ordered as in data space
  
      Note
      ----
      This function is experimental, its output will probably evolve before converging.
      """
      err_msg = (
          f"Could not figure out the data order for: {parameter} "
          "(please open an issue on nevergrad github repository)"
      )
      copied = parameter.copy()
      ref = parameter.copy()
      flatp, flatc, flatref = (
          {
              x: y
              for x, y in helpers.flatten(pa)
              if isinstance(y, p.Data)
          }
          for pa in (parameter, copied, ref)
      )
      keys = list(flatp.keys())
      random.shuffle(keys)  # makes it safer to test!
      # remove transforms for both ref and copied parameters and set index
      for k, key in enumerate(keys):
          for not_ref, flat in enumerate((flatref, flatc)):
              param = flat[key]
              param._layers = param._layers[
                  :1
              ]  # force remove the bound to avoid weird clipping etc
              param.set_mutation(
                  sigma=1.0
              )  # force mutation sigma to 1 to avoid rounding
              if not_ref:
                  param.set_standardized_data(
                      k * np.ones((param.dimension))
                  )
      # analyze results
      data = copied.get_standardized_data(reference=ref)
      order: tp.List[int] = []
      for val, _ in itertools.groupby(data):
          num = int(np.round(val))
          if num in order:
              if order[-1] != num:
                  raise RuntimeError(err_msg)
          else:
              order.append(num)
      if len(order) != len(flatp):
          raise RuntimeError(err_msg)
      # create output and check it
      ordered_keys = [keys[num] for num in order]
      ordered_arrays = [(k, flatp[k]) for k in ordered_keys]
      # print(f"DEBUGGING:\nkeys={keys}\ndata={data}\norder={order}\nordered_key={ordered_keys}")
      if (
          sum(pa.dimension for _, pa in ordered_arrays)
          != parameter.dimension
      ):
          raise RuntimeError(err_msg)
      return ordered_arrays
  
imports: import sys
  import time
  import random
  import itertools
  import contextlib
  import typing
  from pathlib import Path
  import numpy
  import pytest
  from nevergrad.common import testing
  from .None import transforms
  from .None import parameter
  from .None import utils
  from .None import helpers
label_desc: Use image node_id 8 for calling a global function with example usage: split_as_data_parameters(parameter) and returns: ordered_arrays