in python-package/lets_plot/plot/geom.py [0:0]
def geom_smooth(mapping=None, *, data=None, stat=None, position=None, show_legend=None, inherit_aes=None,
manual_key=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,
labels=None,
label_x=None,
label_y=None,
**other_args):
"""
Add a smoothed conditional mean.
Parameters
----------
mapping : ``FeatureSpec``
Set of aesthetic mappings created by `aes() <https://lets-plot.org/python/pages/api/lets_plot.aes.html>`__ 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 the same x-axis coordinate),
'bin' (counts number of points with the 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 a position adjustment name: 'dodge', 'jitter', 'nudge', 'jitterdodge', 'fill',
'stack' or 'identity', or the result of calling a position adjustment function (e.g., `position_dodge() <https://lets-plot.org/python/pages/api/lets_plot.position_dodge.html>`__ etc.).
show_legend : bool, default=True
False - do not show legend for this layer.
inherit_aes : bool, default=True
False - do not combine the layer aesthetic mappings with the plot shared mappings.
manual_key : str or ``layer_key``
The key to show in the manual legend.
Specify text for the legend label or advanced settings using the `layer_key() <https://lets-plot.org/python/pages/api/lets_plot.layer_key.html>`__ function.
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() <https://lets-plot.org/python/pages/api/lets_plot.layer_tooltips.html>`__ function.
Specify appearance, style and content.
Set tooltips='none' to hide tooltips from the layer.
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 the value of the ``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. For more info see `Color and Fill <https://lets-plot.org/python/pages/aesthetics.html#color-and-fill>`__.
- fill : fill color for the confidence interval around the line. For more info see `Color and Fill <https://lets-plot.org/python/pages/aesthetics.html#color-and-fill>`__.
- linetype : type of the line for conditional mean. Accept codes or names (0 = 'blank', 1 = 'solid', 2 = 'dashed', 3 = 'dotted', 4 = 'dotdash', 5 = 'longdash', 6 = 'twodash'), a hex string (up to 8 digits for dash-gap lengths), or a list pattern [offset, [dash, gap, ...]] / [dash, gap, ...]. For more info see `Line Types <https://lets-plot.org/python/pages/aesthetics.html#line-types>`__.
- size : line width. Define line width for conditional mean and confidence bounds lines.
----
To hide axis tooltips, set 'blank' or the result of `element_blank() <https://lets-plot.org/python/pages/api/lets_plot.element_blank.html>`__
to the ``axis_tooltip`` or ``axis_tooltip_x`` parameter of the `theme() <https://lets-plot.org/python/pages/api/lets_plot.theme.html>`__.
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)
"""
# todo: docs
smooth_layer = _geom('smooth',
mapping=mapping,
data=data,
stat=stat,
position=position,
show_legend=show_legend,
inherit_aes=inherit_aes,
manual_key=manual_key,
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)
if labels is not None:
smooth_layer += _geom('stat_r2',
mapping=mapping,
data=data,
stat=stat,
position=position,
show_legend=show_legend,
inherit_aes=inherit_aes,
manual_key=manual_key,
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,
labels=labels,
label_x=label_x,
label_y=label_y,
**other_args)
return smooth_layer