code: def plot_series(
      *series,
      labels=None,
      markers=None,
      colors=None,
      title=None,
      x_label=None,
      y_label=None,
      ax=None,
      pred_interval=None,
  ):
      """Plot one or more time series.
  
      This function allows you to plot one or more
      time series on a single figure via `series`.
      Used for making comparisons between different series.
  
      The resulting figure includes the time series data plotted on a graph with
      x-axis as time by default and can be changed via `x_label` and
      y-axis as value of time series can be renamed via `y_label` and
      labels explaining the meaning of each series via `labels`,
      markers for data points via `markers`.
      You can also specify custom colors via `colors` for each series and
      add a title to the figure via `title`.
      If prediction intervals are available add them using `pred_interval`,
      they can be overlaid on the plot to visualize uncertainty.
  
      Parameters
      ----------
      series : pd.Series or iterable of pd.Series
          One or more time series
      labels : list, default = None
          Names of series, will be displayed in figure legend
      markers: list, default = None
          Markers of data points, if None the marker "o" is used by default.
          The length of the list has to match with the number of series.
      colors: list, default = None
          The colors to use for plotting each series. Must contain one color per series
      title: str, default = None
          The text to use as the figure's suptitle
      pred_interval: pd.DataFrame, default = None
          Output of `forecaster.predict_interval()`. Contains columns for lower
          and upper boundaries of confidence interval.
      ax : matplotlib axes, optional
          Axes to plot on, if None, a new figure is created and returned
  
      Returns
      -------
      fig : plt.Figure
          It manages the final visual appearance and layout.
          Create a new figure, or activate an existing figure.
      ax : plt.Axis
          Axes containing the plot
          If ax was None, a new figure is created and returned
          If ax was not None, the same ax is returned with plot added
  
      Examples
      --------
      >>> from sktime.utils.plotting import plot_series
      >>> from sktime.datasets import load_airline
      >>> y = load_airline()
      >>> fig, ax = plot_series(y)  # doctest: +SKIP
  
      """
      _check_soft_dependencies("matplotlib", "seaborn")
      import matplotlib.pyplot as plt
      import seaborn as sns
      from matplotlib.cbook import flatten
      from matplotlib.ticker import FuncFormatter, MaxNLocator
  
      for y in series:
          check_y(y)
  
      series = list(series)
      series = [convert_to(y, "pd.Series", "Series") for y in series]
  
      n_series = len(series)
      _ax_kwarg_is_none = True if ax is None else False
      # labels
      if labels is not None:
          if n_series != len(labels):
              raise ValueError(
                  """There must be one label for each time series,
                  but found inconsistent numbers of series and
                  labels."""
              )
          legend = True
      else:
          labels = ["" for _ in range(n_series)]
          legend = False
  
      # markers
      if markers is not None:
          if n_series != len(markers):
              raise ValueError(
                  """There must be one marker for each time series,
                  but found inconsistent numbers of series and
                  markers."""
              )
      else:
          markers = ["o" for _ in range(n_series)]
  
      # create combined index
      index = series[0].index
      for y in series[1:]:
          # check index types
          check_consistent_index_type(index, y.index)
          index = index.union(y.index)
  
      # generate integer x-values
      xs = [np.argwhere(index.isin(y.index)).ravel() for y in series]
  
      # create figure if no ax provided for plotting
      if _ax_kwarg_is_none:
          fig, ax = plt.subplots(1, figsize=plt.figaspect(0.25))
  
      # colors
      if colors is None or not _check_colors(colors, n_series):
          colors = sns.color_palette("colorblind", n_colors=n_series)
  
      # plot series
      for x, y, color, label, marker in zip(
          xs, series, colors, labels, markers
      ):
          # scatter if little data is available or index is not complete
          if len(x) <= 3 or not np.array_equal(
              np.arange(x[0], x[-1] + 1), x
          ):
              plot_func = sns.scatterplot
          else:
              plot_func = sns.lineplot
  
          plot_func(
              x=x, y=y, ax=ax, marker=marker, label=label, color=color
          )
  
      # combine data points for all series
      xs_flat = list(flatten(xs))
  
      # set x label of data point to the matching index
      def format_fn(tick_val, tick_pos):
          if int(tick_val) in xs_flat:
              return index[int(tick_val)]
          else:
              return ""
  
      # dynamically set x label ticks and spacing from index labels
      ax.xaxis.set_major_formatter(FuncFormatter(format_fn))
      ax.xaxis.set_major_locator(MaxNLocator(integer=True))
  
      # Set the figure's title
      if title is not None:
          fig.suptitle(title, size="xx-large")
  
      # Label the x and y axes
      if x_label is not None:
          ax.set_xlabel(x_label)
  
      _y_label = y_label if y_label is not None else series[0].name
      ax.set_ylabel(_y_label)
  
      if legend:
          ax.legend()
      if pred_interval is not None:
          check_interval_df(pred_interval, series[-1].index)
          ax = plot_interval(ax, pred_interval, index)
      if _ax_kwarg_is_none:
          return fig, ax
      else:
          return ax
  
file_path: sktime/sktime/utils/plotting.py
imports: import math
  from warnings import simplefilter, warn
  import numpy
  import pandas
  from sktime.datatypes import convert_to
  from sktime.utils.validation._dependencies import _check_soft_dependencies
  from sktime.utils.validation.forecasting import check_interval_df, check_y
  from sktime.utils.validation.series import check_consistent_index_type
label_desc: Use image node_id 1 for calling a global function with example usage: plot_series() and returns: fig,  ax, ax, index, str