code: def _multiple_metric_traces(
      model: ModelBridge,
      metric_x: str,
      metric_y: str,
      generator_runs_dict: TNullableGeneratorRunsDict,
      rel_x: bool,
      rel_y: bool,
      fixed_features: Optional[ObservationFeatures] = None,
      data_selector: Optional[Callable[[Observation], bool]] = None,
      color_parameter: Optional[str] = None,
      color_metric: Optional[str] = None,
  ) -> Traces:
      """Plot traces for multiple metrics given a model and metrics.
  
      Args:
          model: model to draw predictions from.
          metric_x: metric to plot on the x-axis.
          metric_y: metric to plot on the y-axis.
          generator_runs_dict: a mapping from
              generator run name to generator run.
          rel_x: if True, use relative effects on metric_x.
          rel_y: if True, use relative effects on metric_y.
          fixed_features: Fixed features to use when making model predictions.
          data_selector: Function for selecting observations for plotting.
          color_parameter: color points according to the specified parameter,
              cannot be used together with color_metric.
          color_metric: color points according to the specified metric,
              cannot be used together with color_parameter.
      """
      metric_names = {metric_x, metric_y}
      if color_metric is not None:
          metric_names.add(color_metric)
  
      plot_data, _, _ = get_plot_data(
          model,
          generator_runs_dict
          if generator_runs_dict is not None
          else {},
          metric_names,
          fixed_features=fixed_features,
          data_selector=data_selector,
      )
  
      status_quo_arm = (
          None
          if plot_data.status_quo_name is None
          else plot_data.in_sample.get(plot_data.status_quo_name)
      )
  
      traces = [
          _error_scatter_trace(
              list(plot_data.in_sample.values()),
              x_axis_var=PlotMetric(metric_x, pred=False, rel=rel_x),
              y_axis_var=PlotMetric(metric_y, pred=False, rel=rel_y),
              status_quo_arm=status_quo_arm,
              visible=False,
              color_parameter=color_parameter,
              color_metric=color_metric,
          ),
          _error_scatter_trace(
              list(plot_data.in_sample.values()),
              x_axis_var=PlotMetric(metric_x, pred=True, rel=rel_x),
              y_axis_var=PlotMetric(metric_y, pred=True, rel=rel_y),
              status_quo_arm=status_quo_arm,
              visible=True,
              color_parameter=color_parameter,
              color_metric=color_metric,
          ),
      ]
  
      # TODO: Figure out if there's a better way to color code out-of-sample points
      for i, (generator_run_name, cand_arms) in enumerate(
          (plot_data.out_of_sample or {}).items(), start=1
      ):
          traces.append(
              _error_scatter_trace(
                  list(cand_arms.values()),
                  x_axis_var=PlotMetric(metric_x, pred=True, rel=rel_x),
                  y_axis_var=PlotMetric(metric_y, pred=True, rel=rel_y),
                  status_quo_arm=status_quo_arm,
                  name=generator_run_name,
                  color=DISCRETE_COLOR_SCALE[i],
              )
          )
      return traces
  
imports: import numbers
  import warnings
  from collections import OrderedDict
  from logging import Logger
  from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
  import numpy
  import plotly.graph_objs
  from ax.core.data import Data
  from ax.core.experiment import Experiment
  from ax.core.observation import Observation, ObservationFeatures
  from ax.modelbridge.base import ModelBridge
  from ax.modelbridge.registry import Models
  from ax.plot.base import AxPlotConfig, AxPlotTypes, CI_OPACITY, DECIMALS, PlotInSampleArm, PlotMetric, PlotOutOfSampleArm, Z
  from ax.plot.color import BLUE_SCALE, COLORS, DISCRETE_COLOR_SCALE, rgba
  from ax.plot.helper import _format_CI, _format_dict, _wrap_metric, arm_name_to_sort_key, arm_name_to_tuple, get_plot_data, infer_is_relative, resize_subtitles, TNullableGeneratorRunsDict
  from ax.utils.common.logger import get_logger
  from ax.utils.common.typeutils import checked_cast_optional
  from ax.utils.stats.statstools import relativize
  from plotly import subplots
label_desc: Use image node_id 3 for calling a global function with example usage: _multiple_metric_traces(model, metric_x, metric_y, generator_runs_dict, rel_x, rel_y, fixed_features, data_selector, color_parameter, color_metric) and returns: traces