code: def geom_smooth(
      mapping=None,
      *,
      data=None,
      stat=None,
      position=None,
      show_legend=None,
      sampling=None,
      tooltips=None,
      orientation=None,
      method=None,
      n=None,
      se=None,
      level=None,
      span=None,
      deg=None,
      seed=None,
      max_n=None,
      color_by=None,
      fill_by=None,
      **other_args,
  ):
      """
      Add a smoothed conditional mean.
  
      Parameters
      ----------
      mapping : `FeatureSpec`
          Set of aesthetic mappings created by `aes()` function.
          Aesthetic mappings describe the way that variables in the data are
          mapped to plot "aesthetics".
      data : dict or Pandas or Polars `DataFrame`
          The data to be displayed in this layer. If None, the default, the data
          is inherited from the plot data as specified in the call to ggplot.
      stat : str, default='smooth'
          The statistical transformation to use on the data for this layer, as a string.
          Supported transformations: 'identity' (leaves the data unchanged),
          'count' (counts number of points with same x-axis coordinate),
          'bin' (counts number of points with x-axis coordinate in the same bin),
          'smooth' (performs smoothing - linear default),
          'density' (computes and draws kernel density estimate).
      position : str or `FeatureSpec`, default='identity'
          Position adjustment, either as a string ('identity', 'stack', 'dodge', ...),
          or the result of a call to a position adjustment function.
      show_legend : bool, default=True
          False - do not show legend for this layer.
      sampling : `FeatureSpec`
          Result of the call to the `sampling_xxx()` function.
          To prevent any sampling for this layer pass value "none" (string "none").
      tooltips : `layer_tooltips`
          Result of the call to the `layer_tooltips()` function.
          Specify appearance, style and content.
      orientation : str, default='x'
          Specify the axis that the layer's stat and geom should run along.
          Possible values: 'x', 'y'.
      method : str, default='lm'
          Smoothing method: 'lm' (Linear Model) or 'loess' (Locally Estimated Scatterplot Smoothing).
          If value of `deg` parameter is greater than 1 then linear model becomes polynomial of the given degree.
      n : int
          Number of points to evaluate smoother at.
      se : bool, default=True
          Display confidence interval around smooth.
      level : float, default=0.95
          Level of confidence interval to use.
      span : float, default=0.5
          Only for 'loess' method. The fraction of source points closest
          to the current point is taken into account for computing a least-squares regression.
          A sensible value is usually 0.25 to 0.5.
      deg : int, default=1
          Degree of polynomial for linear regression model.
      seed : int
          Random seed for 'loess' sampling.
      max_n : int, default=1000
          Maximum number of data-points for 'loess' method.
          If this quantity exceeded random sampling is applied to data.
      color_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='color'
          Define the color aesthetic for the geometry.
      fill_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='fill'
          Define the fill aesthetic for the geometry.
      other_args
          Other arguments passed on to the layer.
          These are often aesthetics settings used to set an aesthetic to a fixed value,
          like color='red', fill='blue', size=3 or shape=21.
          They may also be parameters to the paired geom/stat.
  
      Returns
      -------
      `LayerSpec`
          Geom object specification.
  
      Notes
      -----
      `geom_smooth()` aids the eye in seeing patterns in the presence of overplotting.
  
      Computed variables:
  
      - ..y.. : predicted (smoothed) value.
      - ..ymin.. : lower pointwise confidence interval around the mean.
      - ..ymax.. : upper pointwise confidence interval around the mean.
      - ..se.. : standard error.
  
      `geom_smooth()` understands the following aesthetics mappings:
  
      - x : x-axis value.
      - y : y-axis value.
      - alpha : transparency level of a layer. Accept values between 0 and 1.
      - color (colour) : color of the geometry. String in the following formats: RGB/RGBA (e.g. "rgb(0, 0, 255)"); HEX (e.g. "#0000FF"); color name (e.g. "red"); role name ("pen", "paper" or "brush").
      - fill : fill color for the confidence interval around the line. String in the following formats: RGB/RGBA (e.g. "rgb(0, 0, 255)"); HEX (e.g. "#0000FF"); color name (e.g. "red"); role name ("pen", "paper" or "brush").
      - linetype : type of the line of conditional mean line. Codes and names: 0 = 'blank', 1 = 'solid', 2 = 'dashed', 3 = 'dotted', 4 = 'dotdash', 5 = 'longdash', 6 = 'twodash.
      - size : line width. Define line width for conditional mean and confidence bounds lines.
  
      Examples
      --------
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 9
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          n = 50
          x = np.arange(n)
          y = x + np.random.normal(scale=10, size=n)
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
              geom_point() + geom_smooth()
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 9
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          n = 100
          x = np.linspace(-2, 2, n)
          y = x ** 2 + np.random.normal(size=n)
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
              geom_point() + geom_smooth(color='red', deg=2, se=False)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 14-15
  
          import numpy as np
          import pandas as pd
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          t = np.linspace(0, 1, 100)
          mean = 1 + np.zeros(2)
          cov = np.eye(2)
          x, y = np.random.multivariate_normal(mean, cov, t.size).T
          df = pd.DataFrame({'t': t, 'x': x, 'y': y})
          df = df.melt(id_vars=['t'], value_vars=['x', 'y'])
          ggplot(df, aes(x='t', y='value', group='variable')) + \\
              geom_point(aes(color='variable'), size=3, alpha=.5) + \\
              geom_smooth(aes(color='variable'), size=1, \\
                          method='loess', span=.3, level=.7, seed=42)
  
      """
      return _geom(
          "smooth",
          mapping=mapping,
          data=data,
          stat=stat,
          position=position,
          show_legend=show_legend,
          sampling=sampling,
          tooltips=tooltips,
          orientation=orientation,
          method=method,
          n=n,
          se=se,
          level=level,
          span=span,
          deg=deg,
          seed=seed,
          max_n=max_n,
          color_by=color_by,
          fill_by=fill_by,
          **other_args,
      )
  
imports: from lets_plot.geo_data_internals.utils import is_geocoder
  from .core import FeatureSpec, LayerSpec
  from .util import as_annotated_data, is_geo_data_frame, geo_data_frame_to_crs, get_geo_data_frame_meta
label_desc: Use image node_id 4 for calling a global function with example usage: geom_smooth(mapping) and returns: _geom