Python Seaborn: bagaimana error bar dihitung dalam barplots?

Saya menggunakan perpustakaan seaborn untuk menghasilkan plot bar dengan python. Saya ingin tahu statistik apa yang digunakan untuk menghitung bar kesalahan, tetapi tidak dapat menemukan referensi untuk ini dalam dokumentasi barplot seaborn .

Saya tahu nilai bar dihitung berdasarkan rata-rata dalam kasus saya (opsi default), dan saya menganggap bar kesalahan dihitung berdasarkan interval kepercayaan 95% distribusi normal, tapi saya ingin memastikan.

Melihat sumbernya (seaborn / seaborn /ategical.py, baris 2166), kami temukan

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):

jadi nilai default adalah, memang, 0,95, seperti yang Anda duga.

EDIT: Bagaimana CI dihitung: barplotpanggilan utils.ci()yang memiliki

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)

dan panggilan ini untuk percentiles()menelepon:

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=Nonejadi score = stats.scoreatpercentile(a.ravel(), p)yang mana

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

Misalnya, skor per = 50 adalah median. Jika kuantil yang diinginkan terletak di antara dua titik data, kami menyisipkan di antara mereka, sesuai dengan nilai interpolasi. Jika batas parameter diberikan, itu harus berupa tuple (lebih rendah, atas) dari dua nilai.

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).

dan mencari sumber scipy.stats.stats.py kita melihat tanda tangannya

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

jadi karena pesisir menyebutnya tanpa param untuk interpolationmenggunakan fraction.

Di samping catatan, ada peringatan usang di masa depan stats.scoreatpercentile(), yaitu

Fungsi ini akan menjadi usang di masa depan. Untuk Numpy 1.9 dan lebih tinggi, numpy.percentile menyediakan semua fungsi yang disediakan oleh scoreatpercentile. Dan secara signifikan lebih cepat. Karenanya disarankan untuk menggunakan numpy.percentile untuk pengguna yang memiliki numpy> = 1.9.