code: def _plot_two_pd_num_num(
      exp: Explanation,
      feature: int,
      target_idx: int,
      levels: int = 8,
      ax: Optional["plt.Axes"] = None,
      pd_num_num_kw: Optional[dict] = None,
  ) -> Tuple["plt.Axes", Optional[Tuple[float, float]]]:
      """
      Plots two ways partial dependence curve for two numerical features.
  
      Parameters
      ----------
      exp, feature, pd_num_num_kw
          See :py:meth:`alibi.explainers.partial_dependence.plot_pd` method.
      target_idx
          The target index for which to plot the partial dependence (PD) curves. An integer
          denoting target index in `exp.meta['params']['target_names']`
      ax
          Pre-existing axes for the plot. Otherwise, call `matplotlib.pyplot.gca()` internally.
  
      Returns
      -------
      `matplotlib` axes and ``None``.
      """
      import matplotlib.pyplot as plt
      from matplotlib import transforms
  
      if exp.meta["params"]["kind"] not in [Kind.AVERAGE, Kind.BOTH]:
          raise ValueError(
              "Can only plot partial dependence for `kind` in `['average', 'both']`."
          )
  
      if ax is None:
          ax = plt.gca()
  
      # set contour plot default params
      default_pd_num_num_kw = {"alpha": 0.75}
      pd_num_num_kw = (
          default_pd_num_num_kw
          if pd_num_num_kw is None
          else {**default_pd_num_num_kw, **pd_num_num_kw}
      )
  
      feature_values = exp.data["feature_values"][feature]
      pd_values = exp.data["pd_values"][feature][target_idx]
  
      X, Y = np.meshgrid(feature_values[0], feature_values[1])
      Z, Z_min, Z_max = pd_values.T, pd_values.min(), pd_values.max()
  
      if Z_max > Z_min:
          Z_level = np.linspace(Z_min, Z_max, levels)
      else:
          # this covers the case when `Z_min` equals `Z_max`, for which `Z_level` will be constant.
          # Note that `ax.contourf` accepts only increasing `Z_levels`, otherwise it throws an error.
          Z_level, Z_min, Z_max = None, None, None
  
      CS = ax.contour(
          X, Y, Z, levels=Z_level, linewidths=0.5, colors="k"
      )
      ax.contourf(
          X,
          Y,
          Z,
          levels=Z_level,
          vmax=Z_max,
          vmin=Z_min,
          **pd_num_num_kw,
      )
      ax.clabel(CS, fmt="%2.2f", colors="k", fontsize=10, inline=True)
  
      # create the deciles line for the vertical & horizontal axis
      xlim, ylim = ax.get_xlim(), ax.get_ylim()
  
      # the horizontal lines do not display (same for the sklearn)
      trans = transforms.blended_transform_factory(
          ax.transData, ax.transAxes
      )
      ax.vlines(
          exp.data["feature_deciles"][feature][0][1:-1],
          0,
          0.05,
          transform=trans,
      )
      trans = transforms.blended_transform_factory(
          ax.transAxes, ax.transData
      )
      ax.hlines(
          exp.data["feature_deciles"][feature][1][1:-1],
          0,
          0.05,
          transform=trans,
      )
  
      # reset xlim and ylim since they are overwritten by hlines and vlines
      ax.set_xlim(xlim)
      ax.set_ylim(ylim)
  
      # set x & y labels
      ax.set_xlabel(exp.data["feature_names"][feature][0])
      ax.set_ylabel(exp.data["feature_names"][feature][1])
      return ax, None
  
imports: import copy
  import logging
  import math
  import numbers
  import sys
  from abc import ABC, abstractmethod
  from enum import Enum
  from typing import Callable, Dict, Iterable, List, Optional, Tuple, Union, no_type_check
  import matplotlib.pyplot
  import numpy
  from scipy.stats.mstats import mquantiles
  from sklearn.base import BaseEstimator, is_classifier, is_regressor
  from sklearn.ensemble import RandomForestRegressor
  from sklearn.ensemble._gb import BaseGradientBoosting
  from sklearn.ensemble._hist_gradient_boosting.gradient_boosting import BaseHistGradientBoosting
  from sklearn.tree import DecisionTreeRegressor
  from sklearn.utils.extmath import cartesian
  from sklearn.utils.validation import check_is_fitted
  from tqdm import tqdm
  from alibi.api.defaults import DEFAULT_DATA_PD, DEFAULT_META_PD
  from alibi.api.interfaces import Explainer, Explanation
  from alibi.explainers.ale import get_quantiles
  from alibi.utils import _get_options_string
label_desc: Use image node_id 6 for calling a global function with example usage: _plot_two_pd_num_num(exp, feature, target_idx, levels, ax, pd_num_num_kw) and returns: ax,  None