public void RunningStat_Stdev_Test2()
{
var stat = new RunningStat();
stat.Push(0);
stat.Push(0);
stat.Push(0);
//Assert.AreEqual()
}
public void RunningStat_Average_Test1()
{
foreach (var n in new[] { 1, 2, 3, 10, 100, 1000 })
{
var xs = Randomness.NextRandom().NextSequence(n).Select(x => (double)x).Take(n).ToList();
var stat = new RunningStat();
foreach (var x in xs)
{
stat.Push(x);
}
Assert.AreEqual(xs.Average(), stat.Average, 1d / 1000000);
}
}
public void RunningStat_Stdev_Test1()
{
foreach (var n in new[] { 10, 100, 1000 })
{
var xs = Randomness.NextRandom().NextSequence(n).Select(x => (double)x).Take(n).ToList();
var stat = new RunningStat();
foreach (var x in xs)
{
stat.Push(x);
}
var stdev = xs.Stdev(xs.Average());
var error = stdev - stat.Stdev;
Assert.AreEqual(stdev, stat.Stdev, 0.25, $"e={error}");
}
}
public void TestMeanAndVariacneConsistency()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Poisson poisson = new Poisson();
rs.Clear();
mean = 2000; stdev = Math.Sqrt(2000);
poisson.Lambda = 2000;
for (int i = 0; i < numSamples; ++i)
{
rs.Push(poisson.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("Poisson Discrete", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
public void TestMeanAndVariacneConsistency()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Exponential exponential = new Exponential();
rs.Clear();
mean = 2; stdev = 2;
for (int i = 0; i < numSamples; ++i)
{
exponential.StandardDeviation = 2;
//exponential.Mean = mean;
rs.Push(exponential.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("exponential", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
public void TestMeanAndVariacneConsistency()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Triangular tri = new Triangular();
rs.Clear();
var a = tri.LowerBound; var b = tri.UpperBound; var c = tri.Mode;
mean = (a + b + c) / 3; stdev = Math.Sqrt((a * a + b * b + c * c - a * b - a * c - b * c) / 18);
for (int i = 0; i < numSamples; ++i)
{
rs.Push(tri.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("Triangular", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
public void TestMeanAndVariacneConsistency()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Gamma gamma = new Gamma();
rs.Clear();
mean = 2; stdev = 5;
for (int i = 0; i < numSamples; ++i)
{
gamma.Mean = mean;
gamma.StandardDeviation = stdev;
rs.Push(gamma.Sample(defaultrs)); //yy
}
PrintResult.CompareMeanAndVariance("gamma", mean, stdev * stdev, rs.Mean(), rs.Variance()); // TODO: result not consistent need to fix the bug
}
public void TestMeanAndVariacneConsistency_Std()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Normal normal = new Normal();
rs.Clear();
mean = 2; stdev = 5;
for (int i = 0; i < numSamples; ++i)
{
normal.Mean = mean;
normal.StandardDeviation = stdev;
rs.Push(normal.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("normal", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
public void TestMeanAndVariacneConsistency()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Uniform uniform = new Uniform();
rs.Clear();
var a = uniform.UpperBound;
var b = uniform.LowerBound;
mean = (a + b) / 2; stdev = Math.Sqrt((b - a) * (b - a) / 12);
for (int i = 0; i < numSamples; ++i)
{
rs.Push(uniform.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("uniform", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
/// <summary>
/// Returns null if the test value is below the lower bound of 90% confidence
/// Otherwise returns an ammended testValue, such as testValue*pValue
/// </summary>
protected virtual double?CalculateConfidence(RunningStat statistic, double testValue, double stDevFactor, double stdevMinValue, bool isMacro = true)
{
const StaTest.TPTail pTail = TPTail.P0500; /* 95% CI */
// ciRange is calculated using T value to account for
double ciRange = StaTest.GetCiRangeFromS(Math.Max(0, (int)Math.Ceiling(Math.Sqrt(statistic.Count))), Math.Max(stdevMinValue, statistic.StandardDeviation) * stDevFactor, pTail);
if (isMacro)
{
if (ciRange > statistic.Mean)
{
// this happens when there are too few items in a cluster and the T value is too high
// in that case the constraint is harder on the expected text length or token count
ciRange = Math.Min(ciRange, statistic.Mean * (1 - this.Config.MinClusterAffinity) * stDevFactor);
}
else
{
// macro statistics shouldn't get too tight, so the minimum range is not allowed to shrink even if statistics tell it to.
// the actual minimum range considered depends on the min affinity
// Example: for min affinity 0.8, if the cluster has a mean of 100 tokens and StDev is 2, then ciRange might be 4,
// but the forula below will make it 100*0.2*0.8 = 16
ciRange = Math.Max(ciRange, statistic.Mean * (1 - this.Config.MinClusterAffinity) * this.Config.MinClusterAffinity);
}
}
// if the test statistic is outside the acceptable range [Mean - ciRange, Mean + ciRange] then this is an outlier and will be rejected
if (testValue < statistic.Mean - ciRange || testValue > statistic.Mean + ciRange)
{
return(null);
}
if (testValue > statistic.Mean)
{
return(testValue);
}
double zTest = Math.Abs(testValue - statistic.Mean) / (statistic.StandardDeviation * 2);
double pVal = StaTest.GetPValueFromZ(zTest);
double probWt = 2 * (1 - pVal);
float result = (float)(testValue * probWt);
return(result);
}
public void TestMeanAndVariacneConsistency()
{
List <int> numList = new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9
};
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Uniform <int> uniform = new Uniform <int>();
uniform.Candidates = numList;
rs.Clear();
mean = 50; stdev = 0;
for (int i = 0; i < numSamples; ++i)
{
rs.Push(uniform.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("uniform categorical", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
public void TestMeanAndVariacneConsistency()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Uniform uniform = new Uniform();
rs.Clear();
var a = Convert.ToDouble(uniform.UpperBound);
var b = Convert.ToDouble(uniform.LowerBound);
mean = (a + b) / 2; stdev = Math.Sqrt(0.25);
for (int i = 0; i < numSamples; ++i)
{
rs.Push(uniform.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("uniform", mean, stdev * stdev, rs.Mean(), rs.Variance());
Assert.IsTrue(Math.Abs(mean - rs.Mean()) < 0.1);
Assert.IsTrue(Math.Abs(stdev * stdev - rs.Variance()) < 0.1);
}
public void TestMeanAndVariacneConsistency_MuSigma()
{
const int numSamples = 100000;
double mean, stdev;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
LogNormal logNormal = new LogNormal();
rs.Clear();
mean = 2; stdev = 5;
var muTemp = Math.Log(mean) - 0.5 * Math.Log(1 + stdev * stdev / mean / mean);
var sigmaTemp = Math.Sqrt(Math.Log(1 + stdev * stdev / mean / mean));
for (int i = 0; i < numSamples; ++i)
{
logNormal.Mu = muTemp;
logNormal.Sigma = sigmaTemp;
rs.Push(logNormal.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("logNormal", mean, stdev * stdev, rs.Mean(), rs.Variance());
}
public void TestMeanAndVariacneConsistency_Mean()
{
const int numSamples = 100000;
double mean, variance;
RunningStat rs = new RunningStat();
Random defaultrs = new Random();
Beta beta = new Beta();
rs.Clear();
//double a = 2, b = 70;
//mean = a / (a + b);
//variance = mean * (1 - mean) / (a + b + 1);
mean = 0.1; variance = 0.1 * 0.1;
for (int i = 0; i < numSamples; ++i)
{
beta.Mean = mean;
beta.StandardDeviation = Math.Sqrt(variance);
rs.Push(beta.Sample(defaultrs));
}
PrintResult.CompareMeanAndVariance("Beta", mean, variance, rs.Mean(), rs.Variance());
}
public void Evaluate(MethodInfo method)
{
var action = MakeAction(this, method);
var measure = new Func<int, RunningStat>(samples =>
{
var runningStat = new RunningStat();
var sw = new Stopwatch();
while (samples-- > 0)
{
sw.Restart();
action();
runningStat.Push((decimal)sw.Elapsed.TotalMilliseconds);
}
return runningStat;
});
var initialTime = measure(1);
var baseTime = measure(1);
var warmupSamples = Math.Max(1, (int)Math.Round(this.warmupTargetTime.TotalMilliseconds / (double)baseTime.Mean));
var warmupTime = measure(warmupSamples);
var testSamples = Math.Max(30, (int)Math.Round(this.testTargetTime.TotalMilliseconds / (double)warmupTime.Mean));
var testTime = measure(testSamples);
PublishResults(initialTime.Mean, baseTime.Mean, warmupSamples, warmupTime.Mean, warmupTime.StandardDeviation, testSamples, testTime.Mean, testTime.StandardDeviation);
}
public RunningRegression()
{
x_stats = new RunningStat();
y_stats = new RunningStat();
Clear();
}
static void Main(string[] args)
{
// the demo is based on the work of Dr. James D. McCaffrey
// example from: "How to Do Naive Bayes with Numeric Data Using C#"
// https://visualstudiomagazine.com/articles/2019/11/12/naive-bayes-csharp.aspx
// modification for continuous data
// the code for running mean and variance from John D. Cook
// https://www.johndcook.com/blog/standard_deviation/
Console.WriteLine("\nBegin running numeric naive Bayes demo");
Console.WriteLine("\nData looks like: ");
Console.WriteLine("Height Weight Foot Sex");
Console.WriteLine("=========================");
Console.WriteLine("6.00, 180, 11, 0");
Console.WriteLine("5.30, 120, 7, 1");
Console.WriteLine(" . . .");
double[][] data = new double[9][]; // modified, better example
data[0] = new double[] { 6.00, 180, 11, 0 }; // 0 = male
data[1] = new double[] { 5.90, 190, 9, 0 }; // 0 = male
data[2] = new double[] { 5.70, 170, 8, 0 }; // 0 = male
data[3] = new double[] { 5.60, 140, 10, 0 }; // 0 = male
data[4] = new double[] { 5.80, 120, 9, 1 }; // 1 = female
data[5] = new double[] { 5.50, 150, 6, 1 }; // 1 = female
data[6] = new double[] { 5.30, 120, 7, 1 }; // 1 = female
data[7] = new double[] { 5.00, 100, 5, 1 }; // 1 = female
data[8] = new double[] { 5.60, 150, 8, -1 }; // -1 = unknown
Console.WriteLine("\nItem to predict:");
Console.WriteLine("5.60 150 8");
int N = data.Length; // 8 items + 1 unknown
int nx = 3; // Number predictor variables
int nc = 2; // Number classes
int[] classCts = new int[nc]; // male, female
double[] condProbs = new double[nc * nx];
double[] classProbs = new double[nx];
double[] evidenceTerms = new double[nx];
double[] predictProbs = new double[nx];
RunningStat[] rs = new RunningStat[nx * nc];
for (int i = 0; i < nc * nx; i++)
{
rs[i] = new RunningStat();
}
for (int p = 0; p < N - 1; p++)
{
// 1. compute class counts and add values
++classCts[(int)data[p][nx]];
for (int j = 0, c = (int)data[p][nx] * nx; j < nx; ++j, c++) // ht, wt, foot
{
rs[c].Push(data[p][j]);
}
// 2. compute evidence terms
double sumEvidence = 0.0;
for (int c = 0, k = 0; c < nc; ++c)
{
double evi = Math.Log(classCts[c]); // - MathLog(N); // double evi = (classCts[c] * 1.0) / N;
for (int j = 0; j < nx; ++j, k++) // evi *= ProbDensFunc(rs[k].Mean(), rs[k].Variance(), unk[j]);
{
evi += Math.Log(ProbDensFunc(rs[k].Mean(), rs[k].Variance(), data[p + 1][j]));
}
sumEvidence += evidenceTerms[c] = Math.Exp(evi); //sumEvidence += evidenceTerms[c] = evi;
}
// 3. compute predicted probabilities
for (int c = 0; c < nc; ++c)
{
predictProbs[c] = evidenceTerms[c] / (sumEvidence + 1e-8f);
}
}
// display prediction probabilities for last item
Console.WriteLine("\nPrediction probabilities (male, female):");
for (int c = 0; c < 2; ++c)
{
Console.WriteLine("class: " + c + " " + predictProbs[c].ToString("F6"));
}
Console.WriteLine("\nPrediction class: " + ArgMax(predictProbs));
Console.WriteLine("\nEnd demo");
Console.ReadLine();
}
