code: def plot_regression_continuous(
      X,
      *,
      target_col,
      types=None,
      scatter_alpha="auto",
      scatter_size="auto",
      drop_outliers=True,
      correlation="spearman",
      prune_correlations_threshold=0.95,
      find_scatter_categoricals=True,
      jitter_ordinal=True,
      **kwargs,
  ):
      """Plots for continuous features in regression.
  
      Creates plots of all the continuous features vs the target.
      Relevant features are determined using F statistics.
  
      Parameters
      ----------
      X : dataframe
          Input data including features and target.
      target_col : str or int
          Identifier of the target column in X.
      types : dataframe of types, optional
          Output of detect_types on X. Can be used to avoid recomputing the
          types.
      scatter_alpha : float, default='auto'
          Alpha values for scatter plots. 'auto' is dirty hacks.
      scatter_size : float, default='auto'
          Marker size for scatter plots. 'auto' is dirty hacks.
      drop_outliers : bool, default=True
          Whether to drop outliers (in the target column) when plotting.
      correlation : str, default="spearman"
          Correlation to use for ranking plots, passed to
          ``pd.DataFrame.corrwith``.
          Valid values are `'pearson'`, `'kendall'`, `'spearman'`.
      jitter_ordinal : bool, default=True
          Whether to add jitter, i.e. apply noise, to ordinal features, to reduce overlap.
      prune_correlations_threshold : float, default=.95
          Whether to prune highly correlated features from the plot.
          Set to 0 to disable pruning.
      find_scatter_categoricals : boolean, default=True
          Whether to find categorical features to use as hue in scatter plots.
  
      """
      X = X.copy()
      X.columns = X.columns.astype(str)
      if types is not None:
          types = types.copy()
          types.index = types.index.astype(str)
  
      types = _check_X_target_col(
          X, target_col, types, task="regression"
      )
  
      if np.isnan(X[target_col]).any():
          X = X.dropna(subset=[target_col])
          warn(
              "Missing values in target_col have been removed for regression",
              UserWarning,
          )
  
      if drop_outliers:
          inliers = _find_inliers(X.loc[:, target_col])
          X = X.loc[inliers, :]
  
      features = X.loc[:, types.continuous + types.low_card_int_ordinal]
      if target_col in features.columns:
          features = features.drop(target_col, axis=1)
      if features.shape[1] == 0:
          return
  
      target = X[target_col]
  
      correlations = features.corrwith(target, method=correlation)
      corrs = correlations.abs().sort_values().dropna().index[::-1]
      if prune_correlations_threshold > 0:
          top_k = []
          for col in corrs:
              corr = features[top_k].corrwith(
                  features[col], method="spearman"
              )
              corr = corr.abs()
              if (
                  not len(top_k)
                  or corr.max() < prune_correlations_threshold
              ):
                  top_k.append(col)
              else:
                  warn(
                      f"Not plotting highly correlated ({corr.max()})"
                      f" feature {col}. Set prune_correlations_threshold=0 to"
                      f" keep."
                  )
              if len(top_k) > 20:
                  warn("Showing only top 10 continuous features.")
                  top_k = top_k[:10]
                  break
  
      else:
          show_top = _get_n_top(features, "continuous")
  
          top_k = corrs[:show_top]
  
      for cat_col in X.columns[types.categorical]:
          X[cat_col] = _prune_categories(X[cat_col])
  
      if find_scatter_categoricals:
          best_categorical = _find_categorical_for_regression(
              X, types, target_col, top_cont=top_k, random_state=None
          )
      else:
          best_categorical = []
  
      fig, axes = _make_subplots(n_plots=len(top_k), sharey=True)
  
      # FIXME this could be a function or maybe using seaborn
      plt.suptitle("Continuous Feature vs Target")
      scatter_alpha = _get_scatter_alpha(scatter_alpha, X[target_col])
      scatter_size = _get_scatter_size(scatter_size, X[target_col])
      for i, (col, ax) in enumerate(zip(top_k, axes.ravel())):
          if i % axes.shape[1] == 0:
              ax.set_ylabel(_shortname(target_col))
          c = (
              X.loc[:, best_categorical[col]]
              if len(best_categorical)
              and best_categorical[col] is not None
              else None
          )
          values = features.loc[:, col]
          col_name = _shortname(col, maxlen=50)
          jitter_x = jitter_ordinal and (
              types.low_card_int_ordinal[col] or X[col].nunique() < 20
          )
          discrete_scatter(
              values,
              target,
              c=c,
              clip_outliers=drop_outliers,
              alpha=scatter_alpha,
              s=scatter_size,
              ax=ax,
              legend=True,
              jitter_x=jitter_x,
              **kwargs,
          )
          ax.set_xlabel(
              f"{col_name} (jittered)" if jitter_x else col_name
          )
          ax.set_title("F={:.2E}".format(correlations[col]))
          _apply_eng_formatter(ax, which="y")
  
      for j in range(i + 1, axes.size):
          # turn off axis if we didn't fill last row
          axes.ravel()[j].set_axis_off()
      return axes
  
imports: import warnings
  import numpy
  import matplotlib.pyplot
  import matplotlib
  import seaborn
  import pandas
  from sklearn.feature_selection import mutual_info_regression, mutual_info_classif, f_classif
  from sklearn.impute import SimpleImputer
  from sklearn.preprocessing import scale
  from sklearn.decomposition import PCA
  from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  from sklearn.metrics import recall_score
  from ..preprocessing import detect_types, clean
  from .utils import _check_X_target_col, _get_n_top, _make_subplots, _short_tick_names, _shortname, _prune_category_make_X, find_pretty_grid, _find_scatter_plots_classification, class_hists, discrete_scatter, mosaic_plot, _find_inliers, pairplot, _get_scatter_alpha, _get_scatter_size, _find_categorical_for_regression, _prune_categories, _apply_eng_formatter
  from .sankey import plot_sankey
  from warnings import warn
label_desc: Use image node_id 1 for calling a global function with example usage: plot_regression_continuous(X) and returns: axes