class_docstr: Plot a group of elements in a grid layout based on a GridSpace element
  object.
code: def _create_subplots(self, layout, axis, ranges, create_axes):
      norm_opts = self._traverse_options(
          layout, "norm", ["axiswise"], [Element]
      )
      axiswise = all(norm_opts.get("axiswise", []))
      if not ranges:
          self.handles["fig"].set_size_inches(self.fig_inches)
      subplots, subaxes = {}, {}
      frame_ranges = self.compute_ranges(layout, None, ranges)
      keys = self.keys[:1] if self.dynamic else self.keys
      frame_ranges = dict(
          [
              (key, self.compute_ranges(layout, key, frame_ranges))
              for key in keys
          ]
      )
      collapsed_layout = layout.clone(shared_data=False, id=layout.id)
      r, c = (0, 0)
      for coord in layout.keys(full_grid=True):
          if not isinstance(coord, tuple):
              coord = (coord,)
          view = layout.data.get(coord, None)
          # Create subplot
          if type(view) in (Layout, NdLayout):
              raise SkipRendering("Cannot plot nested Layouts.")
          if not displayable(view):
              view = collate(view)
          if view is not None:
              vtype = (
                  view.type
                  if isinstance(view, HoloMap)
                  else view.__class__
              )
              opts = self.lookup_options(view, "plot").options
          else:
              vtype = None
  
          # Create axes
          kwargs = {}
          if create_axes:
              projection = self._get_projection(view) if vtype else None
              subax = plt.subplot(
                  self._layoutspec[r, c], projection=projection
              )
              if (
                  not axiswise
                  and self.shared_xaxis
                  and self.xaxis is not None
              ):
                  self.xaxis = "top"
              if (
                  not axiswise
                  and self.shared_yaxis
                  and self.yaxis is not None
              ):
                  self.yaxis = "right"
  
              # Disable subplot axes depending on shared axis options
              # and the position in the grid
              if (
                  self.shared_xaxis or self.shared_yaxis
              ) and not axiswise:
                  if c == 0 and r != 0:
                      subax.xaxis.set_ticks_position("none")
                      kwargs["xaxis"] = "bottom-bare"
                  if c != 0 and r == 0 and not layout.ndims == 1:
                      subax.yaxis.set_ticks_position("none")
                      kwargs["yaxis"] = "left-bare"
                  if r != 0 and c != 0:
                      kwargs["xaxis"] = "bottom-bare"
                      kwargs["yaxis"] = "left-bare"
                  if not self.shared_xaxis:
                      kwargs["xaxis"] = "bottom-bare"
                  if not self.shared_yaxis:
                      kwargs["yaxis"] = "left-bare"
              else:
                  kwargs["xaxis"] = "bottom-bare"
                  kwargs["yaxis"] = "left-bare"
              subaxes[(r, c)] = subax
          else:
              subax = None
          if (
              vtype
              and issubclass(vtype, CompositeOverlay)
              and (c == self.cols - 1 and r == self.rows // 2)
          ):
              kwargs["show_legend"] = self.show_legend
              kwargs["legend_position"] = "right"
          if not isinstance(self.layout, GridMatrix) and not (
              (c == self.cols // 2 and r == 0)
              or (c == 0 and r == self.rows // 2)
          ):
              kwargs["labelled"] = []
  
          # Create subplot
          if view is not None:
              params = dict(
                  fig=self.handles["fig"],
                  axis=subax,
                  dimensions=self.dimensions,
                  show_title=False,
                  subplot=not create_axes,
                  ranges=frame_ranges,
                  uniform=self.uniform,
                  keys=self.keys,
                  show_legend=False,
                  renderer=self.renderer,
              )
              plotting_class = Store.registry["matplotlib"][vtype]
              subplot = plotting_class(
                  view, **dict(opts, **dict(params, **kwargs))
              )
              collapsed_layout[coord] = (
                  subplot.layout
                  if isinstance(subplot, CompositePlot)
                  else subplot.hmap
              )
              subplots[(r, c)] = subplot
          elif subax is not None:
              subax.set_visible(False)
          if r != self.rows - 1:
              r += 1
          else:
              r = 0
              c += 1
      if create_axes:
          self.handles["axis"] = self._layout_axis(layout, axis)
          self._adjust_subplots(self.handles["axis"], subaxes)
  
      return subplots, subaxes, collapsed_layout
  
imports: from contextlib import contextmanager
  from itertools import chain
  import matplotlib
  import numpy
  import param
  from matplotlib import animation, gridspec, pyplot, rcParams
  from matplotlib.font_manager import font_scalings
  from mpl_toolkits.mplot3d import Axes3D
  from ...core import AdjointLayout, Collator, CompositeOverlay, Element, Empty, GridMatrix, GridSpace, HoloMap, Layout, NdLayout
  from ...core.options import SkipRendering, Store
  from ...core.util import int_to_alpha, int_to_roman, wrap_tuple_streams
  from ..plot import DimensionedPlot, GenericAdjointLayoutPlot, GenericCompositePlot, GenericElementPlot, GenericLayoutPlot
  from ..util import attach_streams, collate, displayable
  from .util import compute_ratios, fix_aspect, get_old_rcparams
label_desc: Use image node_id 3 for calling the GridPlot obj's underlying member method code with example usage: obj._create_subplots(layout, axis, ranges, create_axes) and returns: subplots,  subaxes,  collapsed_layout