code: def plot_regressions(
      ytrue,
      ypred,
      samples=None,
      ids=None,
      labels=None,
      sizes=None,
      classes=None,
      gt_field=None,
      pred_field=None,
      backend="plotly",
      **kwargs,
  ):
      """Plots the given regression results.
  
      If IDs are provided and you are working in a notebook environment with the
      default plotly backend, this method returns an interactive
      :class:`fiftyone.core.plots.plotly.InteractiveScatter` that you can attach
      to an App session via its :attr:`fiftyone.core.session.Session.plots`
      attribute, which will automatically sync the session's view with the
      currently selected points in the plot.
  
      Args:
          ytrue: an array-like of ground truth values
          ypred: an array-like of predicted values
          samples (None): the :class:`fiftyone.core.collections.SampleCollection`
              for which the results were generated. Only used by the "plotly"
              backend when IDs are provided
          ids (None): an array-like of sample or frame IDs corresponding to the
              regressions. If not provided but ``samples`` are provided, the
              appropriate IDs will be extracted from the samples
          labels (None): data to use to color the points. Can be any of the
              following:
  
              -   the name of a sample field or ``embedded.field.name`` of
                  ``samples`` from which to extract numeric or string values
              -   a :class:`fiftyone.core.expressions.ViewExpression` defining
                  numeric or string values to compute from ``samples`` via
                  :meth:`fiftyone.core.collections.SampleCollection.values`
              -   an array-like of numeric or string values
              -   a list of array-likes of numeric or string values, if
                  ``link_field`` refers to frames
          sizes (None): data to use to scale the sizes of the points. Can be any
              of the following:
  
              -   the name of a sample field or ``embedded.field.name`` of
                  ``samples`` from which to extract numeric values
              -   a :class:`fiftyone.core.expressions.ViewExpression` defining
                  numeric values to compute from ``samples`` via
                  :meth:`fiftyone.core.collections.SampleCollection.values`
              -   an array-like of numeric values
              -   a list of array-likes of numeric or string values, if
                  ``link_field`` refers to frames
          classes (None): a list of classes whose points to plot. Only applicable
              when ``labels`` contains strings
          gt_field (None): the name of the ground truth field
          pred_field (None): the name of the predictions field
          backend ("plotly"): the plotting backend to use. Supported values are
              ``("plotly", "matplotlib")``
          **kwargs: keyword arguments for the backend plotting method:
  
              -   "plotly" backend: :meth:`fiftyone.core.plots.plotly.plot_confusion_matrix`
              -   "matplotlib" backend: :meth:`fiftyone.core.plots.matplotlib.plot_confusion_matrix`
  
      Returns:
          one of the following
  
          -   a :class:`fiftyone.core.plots.plotly.InteractiveScatter`, if IDs
              are available and the plotly backend is used
          -   a :class:`fiftyone.core.plots.plotly.PlotlyNotebookPlot`, if no IDs
              are available but you are working in a Jupyter notebook with the
              plotly backend
          -   a plotly or matplotlib figure, otherwise
      """
      backend = _parse_backend(backend)
  
      if backend == "matplotlib":
          from .matplotlib import plot_regressions as _plot_regressions
      else:
          from .plotly import plot_regressions as _plot_regressions
  
      return _plot_regressions(
          ytrue,
          ypred,
          samples=samples,
          ids=ids,
          labels=labels,
          sizes=sizes,
          classes=classes,
          gt_field=gt_field,
          pred_field=pred_field,
          **kwargs,
      )
  
imports: import logging
  import fiftyone.core.context
  import fiftyone.core.labels
  import fiftyone.core.patches
  import fiftyone.core.video
label_desc: Use image node_id 2 for calling a global function with example usage: plot_regressions(ytrue, ypred, samples, ids, labels, sizes, classes, gt_field, pred_field, backend) and returns: _plot_regressions