numpy.std

numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>, mean=<no value>, correction=<no value>)[source]

Вычисление стандартного отклонения по указанной оси.

Возвращает стандартное отклонение, мера разброса распределения, элементов массива. Стандартное отклонение вычисляется для уплощенного массива по умолчанию, в противном случае по указанной оси.

Параметры:

aarray_like

Вычислить стандартное отклонение этих значений.

axisNone или int или кортеж из целых чисел, необязательно

Ось или оси, по которым вычисляется стандартное отклонение. По умолчанию вычисляется стандартное отклонение уплощенного массива.

Введено в версии 1.7.0.

Если это кортеж целых чисел, то вычисляется стандартное отклонение по нескольким осям, а не по одной оси или по всем осям, как раньше.

dtypedtype, необязательно

Тип, используемый при вычислении стандартного отклонения. Для массивов целого типа по умолчанию используется float64, для массивов плавающей точки — такой же, как тип массива.

outndarray, необязательно

Альтернативный выходной массив, в который следует поместить результат. Он должен иметь такую же форму, как ожидаемый результат, но тип (вычисленных значений) будет преобразован при необходимости. Подробнее см. Определение типа выходных данных.

ddof{int, float}, необязательно

Означает Delta Degrees of Freedom. Делитель, используемый в расчетах, равен N - ddof, где N — количество элементов. По умолчанию ddof равно нулю. Подробности о применении ddof см. в примечаниях.

keepdimsbool, необязательно

Если значение равно True, оси, по которым происходит уменьшение, остаются в результате в качестве измерений с размером один. С этим параметром результат будет корректно транслироваться в отношении входного массива.

Если передано значение по умолчанию, то keepdims не будет передаваться в метод std подклассов ndarray, однако любое отличное от значения по умолчанию будет. Если метод подкласса не реализует keepdims, будут вызваны исключения.

wherearray_like of bool, необязательно

Элементы, которые следует включать в стандартное отклонение. Подробнее см. reduce.

Введено в версии 1.20.0.

meanarray_like, необязательно

Предоставьте среднее значение, чтобы избежать его перерасчета. Среднее значение должно иметь форму, как если бы оно было вычислено с помощью keepdims=True. Ось для вычисления среднего значения должна быть такой же, как и в вызове функции std.

Введено в версии 1.26.0.

correction{int, float}, необязательно

Название параметра ddof совместимое с API массивов. Одновременно можно указать только один из них.

Введено в версии 2.0.0.

Возвращаемые значения:

standard_deviationndarray, см. параметр dtype выше.

Если out равно None, возвращается новый массив, содержащий стандартное отклонение, в противном случае возвращается ссылка на выходной массив.

См. также

var, mean, nanmean, nanstd, nanvar

Определение типа выходных данных

Примечания

Существует несколько распространенных вариантов вычисления стандартного отклонения массива. Предполагая, что входной a является одномерным массивом NumPy и mean либо предоставлен в качестве аргумента, либо вычислен как a.mean(), NumPy вычисляет стандартное отклонение массива как:

N = len(a)
d2 = abs(a - mean)**2  # abs is for complex `a`
var = d2.sum() / (N - ddof)  # note use of `ddof`
std = var**0.5

Разные значения аргумента ddof полезны в разных контекстах. По умолчанию NumPy ddof=0 соответствует выражению:

\[\sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N}}\]

иногда называемое в статистике «стандартным отклонением генеральной совокупности», потому что оно применяет определение стандартного отклонения к a так, как будто a представляла собой полную совокупность возможных наблюдений.

Во многих других библиотеках стандартное отклонение массива определяется по-другому, например:

\[\sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N - 1}}\]

В статистике полученное значение иногда называется «стандартным отклонением выборки», потому что если a — это случайная выборка из большей генеральной совокупности, это вычисление даёт квадратный корень из несмещенной оценки дисперсии генеральной совокупности. Использование \(N-1\) в знаменателе часто называется «поправкой Бесселя», потому что она корректирует смещение (к меньшим значениям) в оценке дисперсии, возникающее, когда выборочное среднее значение a используется вместо истинного среднего значения генеральной совокупности. Полученная оценка стандартного отклонения все равно является смещённой, но меньше, чем она была бы без коррекции. Для этого значения используйте ddof=1.

Обратите внимание, что для комплексных чисел std берёт абсолютное значение до возведения в квадрат, так что результат всегда вещественный и неотрицательный.

Для чисел с плавающей точкой стандартное отклонение вычисляется с той же точностью, что и входные данные. В зависимости от входных данных это может привести к неточным результатам, особенно для float32 (см. пример ниже). Использование аккумулятора с большей точностью с помощью параметра dtype может устранить эту проблему.

Примеры

>>> a = np.array([[1, 2], [3, 4]])
>>> np.std(a)
1.1180339887498949 # may vary
>>> np.std(a, axis=0)
array([1.,  1.])
>>> np.std(a, axis=1)
array([0.5,  0.5])

В одинарной точности std() может быть неточным:

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.std(a)
0.45000005

Вычисление стандартного отклонения в формате float64 более точно:

>>> np.std(a, dtype=np.float64)
0.44999999925494177 # may vary

Указание аргумента where:

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.std(a)
2.614064523559687 # may vary
>>> np.std(a, where=[[True], [True], [False]])
2.0

Использование ключевого слова mean для экономии времени вычислений:

>>> import numpy as np
>>> from timeit import timeit
>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> mean = np.mean(a, axis=1, keepdims=True)
>>>
>>> g = globals()
>>> n = 10000
>>> t1 = timeit("std = np.std(a, axis=1, mean=mean)", globals=g, number=n)
>>> t2 = timeit("std = np.std(a, axis=1)", globals=g, number=n)
>>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%')

Percentage execution time saved 30%