code: def hold_keys(dsk, dependencies):
      """Find keys to avoid fusion
  
      We don't want to fuse data present in the graph because it is easier to
      serialize as a raw value.
  
      We don't want to fuse chains after getitem/GETTERS because we want to
      move around only small pieces of data, rather than the underlying arrays.
      """
      dependents = reverse_dict(dependencies)
      data = {k for k, v in dsk.items() if type(v) not in (tuple, str)}
  
      hold_keys = list(data)
      for dat in data:
          deps = dependents[dat]
          for dep in deps:
              task = dsk[dep]
              # If the task is a get* function, we walk up the chain, and stop
              # when there's either more than one dependent, or the dependent is
              # no longer a get* function or an alias. We then add the final
              # key to the list of keys not to fuse.
              if _is_getter_task(task):
                  try:
                      while len(dependents[dep]) == 1:
                          new_dep = next(iter(dependents[dep]))
                          new_task = dsk[new_dep]
                          # If the task is a get* or an alias, continue up the
                          # linear chain
                          if (
                              _is_getter_task(new_task)
                              or new_task in dsk
                          ):
                              dep = new_dep
                          else:
                              break
                  except (IndexError, TypeError):
                      pass
                  hold_keys.append(dep)
      return hold_keys
  
imports: from __future__ import annotations
  from collections.abc import Callable
  from itertools import zip_longest
  from numbers import Integral
  from typing import Any
  import numpy
  from dask import config
  from dask.array.chunk import getitem
  from dask.array.core import getter, getter_inline, getter_nofancy
  from dask.blockwise import fuse_roots, optimize_blockwise
  from dask.core import flatten, reverse_dict
  from dask.highlevelgraph import HighLevelGraph
  from dask.optimization import SubgraphCallable, fuse, inline_functions
  from dask.utils import ensure_dict
label_desc: Use image node_id 2 for calling a global function with example usage: hold_keys(dsk, dependencies) and returns: hold_keys