code: def test_hashes_stay_the_same_with_numpy_objects():
      # Note: joblib used to test numpy objects hashing by comparing the produced
      # hash of an object with some hard-coded target value to guarantee that
      # hashing remains the same across joblib versions. However, since numpy
      # 1.20 and joblib 1.0, joblib relies on potentially unstable implementation
      # details of numpy to hash np.dtype objects, which makes the stability of
      # hash values across different environments hard to guarantee and to test.
      # As a result, hashing stability across joblib versions becomes best-effort
      # only, and we only test the consistency within a single environment by
      # making sure:
      # - the hash of two copies of the same objects is the same
      # - hashing some object in two different python processes produces the same
      #   value. This should be viewed as a proxy for testing hash consistency
      #   through time between Python sessions (provided no change in the
      #   environment was done between sessions).
  
      def create_objects_to_hash():
          rng = np.random.RandomState(42)
          # Being explicit about dtypes in order to avoid
          # architecture-related differences. Also using 'f4' rather than
          # 'f8' for float arrays because 'f8' arrays generated by
          # rng.random.randn don't seem to be bit-identical on 32bit and
          # 64bit machines.
          to_hash_list = [
              rng.randint(-1000, high=1000, size=50).astype("<i8"),
              tuple(rng.randn(3).astype("<f4") for _ in range(5)),
              [rng.randn(3).astype("<f4") for _ in range(5)],
              {
                  -3333: rng.randn(3, 5).astype("<f4"),
                  0: [
                      rng.randint(10, size=20).astype("<i8"),
                      rng.randn(10).astype("<f4"),
                  ],
              },
              # Non regression cases for
              # https://github.com/joblib/joblib/issues/308
              np.arange(100, dtype="<i8").reshape((10, 10)),
              # Fortran contiguous array
              np.asfortranarray(
                  np.arange(100, dtype="<i8").reshape((10, 10))
              ),
              # Non contiguous array
              np.arange(100, dtype="<i8").reshape((10, 10))[:, :2],
          ]
          return to_hash_list
  
      # Create two lists containing copies of the same objects.  joblib.hash
      # should return the same hash for to_hash_list_one[i] and
      # to_hash_list_two[i]
      to_hash_list_one = create_objects_to_hash()
      to_hash_list_two = create_objects_to_hash()
  
      e1 = ProcessPoolExecutor(max_workers=1)
      e2 = ProcessPoolExecutor(max_workers=1)
  
      try:
          for obj_1, obj_2 in zip(to_hash_list_one, to_hash_list_two):
              # testing consistency of hashes across python processes
              hash_1 = e1.submit(hash, obj_1).result()
              hash_2 = e2.submit(hash, obj_1).result()
              assert hash_1 == hash_2
  
              # testing consistency when hashing two copies of the same objects.
              hash_3 = e1.submit(hash, obj_2).result()
              assert hash_1 == hash_3
  
      finally:
          e1.shutdown()
          e2.shutdown()
  
imports: import gc
  import itertools
  import pickle
  import sys
  import time
  from concurrent.futures import ProcessPoolExecutor
  import numpy
  import pandas
  import pytest
  from sklearn.base import BaseEstimator
  from xxhash import xxh128
  from pycaret.datasets import get_data
  from pycaret.internal.memory import fast_hash
  from pycaret.regression import RegressionExperiment
label_desc: Use image node_id 20 for calling a global function with example usage: test_hashes_stay_the_same_with_numpy_objects() and returns: to_hash_list