Мне нужно знать, находится ли число по сравнению с набором чисел вне 1 stddev из среднего и т.д.
Как определить стандартное отклонение (stddev) набора значений?
Ответ 1
В то время как алгоритм суммы квадратов работает отлично в большинстве случаев, это может вызвать большие проблемы, если вы имеете дело с очень большими числами. В основном вы можете получить отрицательную дисперсию...
Плюс, никогда, никогда, никогда не вычисляйте a ^ 2 как pow (a, 2), a * a почти наверняка быстрее.
На сегодняшний день лучшим способом вычисления стандартного отклонения является метод Welford. Мой C очень ржавый, но он может выглядеть примерно так:
public static double StandardDeviation(List<double> valueList)
{
double M = 0.0;
double S = 0.0;
int k = 1;
foreach (double value in valueList)
{
double tmpM = M;
M += (value - tmpM) / k;
S += (value - tmpM) * (value - M);
k++;
}
return Math.Sqrt(S / (k-2));
}
Если у вас есть целая популяция (в отличие от выборочной совокупности), используйте return Math.Sqrt(S / (k-1));.
EDIT: Я обновил код в соответствии с замечаниями Джейсона...
EDIT: Я также обновил код в соответствии с замечаниями Алекса...
Ответ 2
в 10 раз быстрее, чем у Jaime, но знать, что, как отметил Хайме:
"В то время как алгоритм суммы квадратов отлично работает отлично, он может вызвать большие проблемы, если вы имеете дело с очень большими цифрами. Вы в основном может закончиться отрицательной дисперсией"
Если вы думаете, что имеете дело с очень большими числами или с очень большим количеством чисел, вы должны рассчитать, используя оба метода, если результаты равны, вы точно знаете, что вы можете использовать "мой" метод для вас.
public static double StandardDeviation(double[] data)
{
double stdDev = 0;
double sumAll = 0;
double sumAllQ = 0;
//Sum of x and sum of x²
for (int i = 0; i < data.Length; i++)
{
double x = data[i];
sumAll += x;
sumAllQ += x * x;
}
//Mean (not used here)
//double mean = 0;
//mean = sumAll / (double)data.Length;
//Standard deviation
stdDev = System.Math.Sqrt(
(sumAllQ -
(sumAll * sumAll) / data.Length) *
(1.0d / (data.Length - 1))
);
return stdDev;
}
Ответ 3
Принятый ответ Хайме замечательный, за исключением того, что вам нужно разделить на k-2 в последней строке (вам нужно разделить на "number_of_elements-1" ). Еще лучше, запустите k при 0:
public static double StandardDeviation(List<double> valueList)
{
double M = 0.0;
double S = 0.0;
int k = 0;
foreach (double value in valueList)
{
k++;
double tmpM = M;
M += (value - tmpM) / k;
S += (value - tmpM) * (value - M);
}
return Math.Sqrt(S / (k-1));
}
Ответ 4
Библиотека Math.NET предоставляет это для вас из коробки.
PM> Инсталляционный пакет MathNet.Numerics
var populationStdDev = new List<double>(1d, 2d, 3d, 4d, 5d).PopulationStandardDeviation();
var sampleStdDev = new List<double>(2d, 3d, 4d).StandardDeviation();
Посмотрите PopulationStandardDeviation для получения дополнительной информации.
Ответ 5
Вы можете избежать двух проходов над данными, скопив средний и средний квадрат
cnt = 0
mean = 0
meansqr = 0
loop over array
cnt++
mean += value
meansqr += value*value
mean /= cnt
meansqr /= cnt
и формирование
sigma = sqrt(meansqr - mean^2)
Часто также подходит фактор cnt/(cnt-1).
BTW-- Первый проход по данным в ответах Demi и McWafflestix скрыт в вызовах до Average. Такого рода вещи, конечно, тривиальны в небольшом списке, но если список превышает размер кеша или даже рабочего набора, это становится сделкой с предложением.
Ответ 6
Фрагмент кода:
public static double StandardDeviation(List<double> valueList)
{
if (valueList.Count < 2) return 0.0;
double sumOfSquares = 0.0;
double average = valueList.Average(); //.NET 3.0
foreach (double value in valueList)
{
sumOfSquares += Math.Pow((value - average), 2);
}
return Math.Sqrt(sumOfSquares / (valueList.Count - 1));
}
Ответ 7
Я обнаружил, что полезный ответ Роба не совсем соответствовал тому, что я видел, используя excel. Чтобы соответствовать excel, я передал значение Average для valueList в вычисление StandardDeviation.
Вот мои два цента... и ясно, что вы могли бы вычислить скользящее среднее (ma) из valueList внутри функции - но я, случается, уже нуждался в стандартном событии.
public double StandardDeviation(List<double> valueList, double ma)
{
double xMinusMovAvg = 0.0;
double Sigma = 0.0;
int k = valueList.Count;
foreach (double value in valueList){
xMinusMovAvg = value - ma;
Sigma = Sigma + (xMinusMovAvg * xMinusMovAvg);
}
return Math.Sqrt(Sigma / (k - 1));
}
Ответ 8
С помощью методов расширения.
using System;
using System.Collections.Generic;
namespace SampleApp
{
internal class Program
{
private static void Main()
{
List<double> data = new List<double> {1, 2, 3, 4, 5, 6};
double mean = data.Mean();
double variance = data.Variance();
double sd = data.StandardDeviation();
Console.WriteLine("Mean: {0}, Variance: {1}, SD: {2}", mean, variance, sd);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
public static class MyListExtensions
{
public static double Mean(this List<double> values)
{
return values.Count == 0 ? 0 : values.Mean(0, values.Count);
}
public static double Mean(this List<double> values, int start, int end)
{
double s = 0;
for (int i = start; i < end; i++)
{
s += values[i];
}
return s / (end - start);
}
public static double Variance(this List<double> values)
{
return values.Variance(values.Mean(), 0, values.Count);
}
public static double Variance(this List<double> values, double mean)
{
return values.Variance(mean, 0, values.Count);
}
public static double Variance(this List<double> values, double mean, int start, int end)
{
double variance = 0;
for (int i = start; i < end; i++)
{
variance += Math.Pow((values[i] - mean), 2);
}
int n = end - start;
if (start > 0) n -= 1;
return variance / (n);
}
public static double StandardDeviation(this List<double> values)
{
return values.Count == 0 ? 0 : values.StandardDeviation(0, values.Count);
}
public static double StandardDeviation(this List<double> values, int start, int end)
{
double mean = values.Mean(start, end);
double variance = values.Variance(mean, start, end);
return Math.Sqrt(variance);
}
}
}
Ответ 9
/// <summary>
/// Calculates standard deviation, same as MATLAB std(X,0) function
/// <seealso cref="http://www.mathworks.co.uk/help/techdoc/ref/std.html"/>
/// </summary>
/// <param name="values">enumumerable data</param>
/// <returns>Standard deviation</returns>
public static double GetStandardDeviation(this IEnumerable<double> values)
{
//validation
if (values == null)
throw new ArgumentNullException();
int lenght = values.Count();
//saves from devision by 0
if (lenght == 0 || lenght == 1)
return 0;
double sum = 0.0, sum2 = 0.0;
for (int i = 0; i < lenght; i++)
{
double item = values.ElementAt(i);
sum += item;
sum2 += item * item;
}
return Math.Sqrt((sum2 - sum * sum / lenght) / (lenght - 1));
}
Ответ 10
Проблема со всеми другими ответами заключается в том, что они предполагают, что у вас есть данных в большом массиве. Если ваши данные поступают "на лету", это будет лучший подход. Этот класс работает независимо от того, как и когда вы храните свои данные. Он также дает вам выбор метода Вальдорфа или метода суммы квадратов. Оба метода работают с использованием одного прохода.
public final class StatMeasure {
private StatMeasure() {}
public interface Stats1D {
/** Add a value to the population */
void addValue(double value);
/** Get the mean of all the added values */
double getMean();
/** Get the standard deviation from a sample of the population. */
double getStDevSample();
/** Gets the standard deviation for the entire population. */
double getStDevPopulation();
}
private static class WaldorfPopulation implements Stats1D {
private double mean = 0.0;
private double sSum = 0.0;
private int count = 0;
@Override
public void addValue(double value) {
double tmpMean = mean;
double delta = value - tmpMean;
mean += delta / ++count;
sSum += delta * (value - mean);
}
@Override
public double getMean() { return mean; }
@Override
public double getStDevSample() { return Math.sqrt(sSum / (count - 1)); }
@Override
public double getStDevPopulation() { return Math.sqrt(sSum / (count)); }
}
private static class StandardPopulation implements Stats1D {
private double sum = 0.0;
private double sumOfSquares = 0.0;
private int count = 0;
@Override
public void addValue(double value) {
sum += value;
sumOfSquares += value * value;
count++;
}
@Override
public double getMean() { return sum / count; }
@Override
public double getStDevSample() {
return (float) Math.sqrt((sumOfSquares - ((sum * sum) / count)) / (count - 1));
}
@Override
public double getStDevPopulation() {
return (float) Math.sqrt((sumOfSquares - ((sum * sum) / count)) / count);
}
}
/**
* Returns a way to measure a population of data using Waldorf method.
* This method is better if your population or values are so large that
* the sum of x-squared may overflow. It also probably faster if you
* need to recalculate the mean and standard deviation continuously,
* for example, if you are continually updating a graphic of the data as
* it flows in.
*
* @return A Stats1D object that uses Waldorf method.
*/
public static Stats1D getWaldorfStats() { return new WaldorfPopulation(); }
/**
* Return a way to measure the population of data using the sum-of-squares
* method. This is probably faster than Waldorf method, but runs the
* risk of data overflow.
*
* @return A Stats1D object that uses the sum-of-squares method
*/
public static Stats1D getSumOfSquaresStats() { return new StandardPopulation(); }
}
Ответ 11
Возможно, мы сможем использовать модуль статистики в Python. Он имеет команды stedev() и pstdev() для вычисления стандартного отклонения выборки и совокупности соответственно.
Подробности здесь: https://www.geeksforgeeks.org/python-statistics-stdev/
импортировать статистику как st print (st.ptdev(dataframe ['имя столбца']))
Ответ 12
Это стандартное отклонение населения
private double calculateStdDev(List<double> values)
{
double average = values.Average();
return Math.Sqrt((values.Select(val => (val - average) * (val - average)).Sum()) / values.Count);
}
Для образца стандартного отклонения просто измените [values.Count] на [values.Count -1] в приведенном выше коде.
Убедитесь, что в вашем наборе нет только одной точки данных.