code: def pairwise_kernels(
      X, Y=None, metric="linear", filter_params=False, n_jobs=1, **kwds
  ):
      """Compute the kernel between arrays X and optional array Y.
  
      This method takes either a vector array or a kernel matrix, and returns
      a kernel matrix. If the input is a vector array, the kernels are
      computed. If the input is a kernel matrix, it is returned instead.
  
      This method provides a safe way to take a kernel matrix as input, while
      preserving compatibility with many other algorithms that take a vector
      array.
  
      If Y is given (default is None), then the returned matrix is the pairwise
      kernel between the arrays from both X and Y.
  
      Valid values for metric are::
          ['rbf', 'sigmoid', 'polynomial', 'poly', 'linear', 'cosine']
  
      Read more in the :ref:`User Guide <metrics>`.
  
      Parameters
      ----------
      X : array [n_samples_a, n_samples_a] if metric == "precomputed", or, \
               [n_samples_a, n_features] otherwise
          Array of pairwise kernels between samples, or a feature array.
  
      Y : array [n_samples_b, n_features]
          A second feature array only if X has shape [n_samples_a, n_features].
  
      metric : string, or callable
          The metric to use when calculating kernel between instances in a
          feature array. If metric is a string, it must be one of the metrics
          in pairwise.PAIRWISE_KERNEL_FUNCTIONS.
          If metric is "precomputed", X is assumed to be a kernel matrix.
          Alternatively, if metric is a callable function, it is called on each
          pair of instances (rows) and the resulting value recorded. The callable
          should take two arrays from X as input and return a value indicating
          the distance between them.
  
      n_jobs : int
          The number of jobs to use for the computation. This works by breaking
          down the pairwise matrix into n_jobs even slices and computing them in
          parallel.
  
          If -1 all CPUs are used. If 1 is given, no parallel computing code is
          used at all, which is useful for debugging. For n_jobs below -1,
          (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all CPUs but one
          are used.
  
      filter_params : boolean
          Whether to filter invalid parameters or not.
  
      `**kwds` : optional keyword parameters
          Any further parameters are passed directly to the kernel function.
  
      Returns
      -------
      K : array [n_samples_a, n_samples_a] or [n_samples_a, n_samples_b]
          A kernel matrix K such that K_{i, j} is the kernel between the
          ith and jth vectors of the given matrix X, if Y is None.
          If Y is not None, then K_{i, j} is the kernel between the ith array
          from X and the jth array from Y.
  
      Notes
      -----
      If metric is 'precomputed', Y is ignored and X is returned.
  
      """
      # import GPKernel locally to prevent circular imports
      from ..gaussian_process.kernels import Kernel as GPKernel
  
      if metric == "precomputed":
          X, _ = check_pairwise_arrays(X, Y, precomputed=True)
          return X
      elif isinstance(metric, GPKernel):
          func = metric.__call__
      elif metric in PAIRWISE_KERNEL_FUNCTIONS:
          if filter_params:
              kwds = dict(
                  (k, kwds[k])
                  for k in kwds
                  if k in KERNEL_PARAMS[metric]
              )
          func = PAIRWISE_KERNEL_FUNCTIONS[metric]
      elif callable(metric):
          func = partial(_pairwise_callable, metric=metric, **kwds)
      else:
          raise ValueError("Unknown kernel %r" % metric)
  
      return _parallel_pairwise(X, Y, func, n_jobs, **kwds)
  
imports: import itertools
  import numpy
  from scipy.spatial import distance
  from scipy.sparse import csr_matrix
  from scipy.sparse import issparse
  from ..utils import check_array
  from ..utils import gen_even_slices
  from ..utils import gen_batches
  from ..utils.fixes import partial
  from ..utils.extmath import row_norms, safe_sparse_dot
  from ..preprocessing import normalize
  from ..externals.joblib import Parallel
  from ..externals.joblib import delayed
  from ..externals.joblib import cpu_count
  from .pairwise_fast import _chi2_kernel_fast, _sparse_manhattan
label_desc: Use image node_id 26 for calling a global function with example usage: pairwise_kernels(X, Y, metric, filter_params, n_jobs) and returns: _parallel_pairwise, X