Python Seaborn: Wie werden Fehlerbalken in Barplots berechnet?

Ich verwende die Seaborn-Bibliothek, um Balkendiagramme in Python zu erstellen. Ich frage mich, welche Statistiken zur Berechnung der Fehlerbalken verwendet werden, kann aber in der Barplot-Dokumentation des Seaborn keinen Hinweis darauf finden .

Ich weiß, dass die Balkenwerte in meinem Fall basierend auf dem Mittelwert berechnet werden (die Standardoption), und ich gehe davon aus, dass die Fehlerbalken basierend auf einem 95% -Konfidenzintervall der Normalverteilung berechnet werden, aber ich möchte sicher sein.

Wenn wir uns die Quelle ansehen (seaborn / seaborn / categoryical.py, Zeile 2166), finden wir

def barplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None,
        estimator=np.mean, ci=95, n_boot=1000, units=None,
        orient=None, color=None, palette=None, saturation=.75,
        errcolor=".26", ax=None, **kwargs):

Der Standardwert ist also tatsächlich 0,95, wie Sie vermutet haben.

EDIT: Wie CI berechnet wird: barplotAnrufe, utils.ci()die hat

seaborn / seaborn / utils.py

def ci(a, which=95, axis=None):
    """Return a percentile range from an array of values."""
    p = 50 - which / 2, 50 + which / 2
    return percentiles(a, p, axis)

und dieser Aufruf an percentiles()ruft:

def percentiles(a, pcts, axis=None):
    """Like scoreatpercentile but can take and return array of percentiles.
    Parameters
    ----------
    a : array
        data
    pcts : sequence of percentile values
        percentile or percentiles to find score at
    axis : int or None
        if not None, computes scores over this axis
    Returns
    -------
    scores: array
        array of scores at requested percentiles
        first dimension is length of object passed to ``pcts``
    """
    scores = []
    try:
        n = len(pcts)
    except TypeError:
        pcts = [pcts]
        n = 0
    for i, p in enumerate(pcts):
        if axis is None:
            score = stats.scoreatpercentile(a.ravel(), p)
        else:
            score = np.apply_along_axis(stats.scoreatpercentile, axis, a, p)
        scores.append(score)
    scores = np.asarray(scores)
    if not n:
        scores = scores.squeeze()
    return scores

axis=Nonealso score = stats.scoreatpercentile(a.ravel(), p)was ist

scipy.stats.scoreatpercentile(a, per, limit=(), interpolation_method='fraction', axis=None)[source]
Calculate the score at a given percentile of the input sequence.

Zum Beispiel ist die Punktzahl bei per = 50 der Median. Wenn das gewünschte Quantil zwischen zwei Datenpunkten liegt, interpolieren wir zwischen ihnen entsprechend dem Wert der Interpolation. Wenn die Parametergrenze angegeben ist, sollte es sich um ein Tupel (unteres, oberes) von zwei Werten handeln.

Parameters: 
a : array_like
A 1-D array of values from which to extract score.
per : array_like
Percentile(s) at which to extract score. Values should be in range [0,100].
limit : tuple, optional
Tuple of two scalars, the lower and upper limits within which to compute the percentile. Values of a outside this (closed) interval will be ignored.
interpolation_method : {‘fraction’, ‘lower’, ‘higher’}, optional
This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points i and j
fraction: i + (j - i) * fraction where fraction is the fractional part of the index surrounded by i and j.
lower: i.
higher: j.
axis : int, optional
Axis along which the percentiles are computed. Default is None. If None, compute over the whole array a.
Returns:    
score : float or ndarray
Score at percentile(s).

und wenn wir in der Quelle nach scipy.stats.stats.py suchen , sehen wir die Signatur

def scoreatpercentile(a, per, limit=(), interpolation_method='fraction',
                      axis=None):

Also, da Seaboard es ohne Parameter aufruft interpolation, wird es verwendet fraction.

Nebenbei bemerkt gibt es eine Warnung vor künftiger Veralterung in stats.scoreatpercentile(), nämlich

Diese Funktion wird in Zukunft veraltet sein. Für Numpy 1.9 und höher bietet numpy.percentile alle Funktionen, die scoreatpercentile bietet. Und es ist deutlich schneller. Daher wird empfohlen, numpy.percentile für Benutzer mit numpy> = 1.9 zu verwenden.