public void TwoSampleKolmogorovSmirnovTestConstructorTest() { Accord.Math.Tools.SetupGenerator(0); // Create a K-S test to verify if two samples have been // drawn from different populations. In this example, we // will first generate a number of samples from different // distributions, and then check if the K-S test can indeed // see the difference: // Generate 15 points from a Normal distribution with mean 5 and sigma 2 double[] sample1 = new NormalDistribution(mean: 5, stdDev: 1).Generate(25); // Generate 15 points from an uniform distribution from 0 to 10 double[] sample2 = new UniformContinuousDistribution(a: 0, b: 10).Generate(25); // Now we can create a K-S test and test the unequal hypothesis: var test = new TwoSampleKolmogorovSmirnovTest(sample1, sample2, TwoSampleKolmogorovSmirnovTestHypothesis.SamplesDistributionsAreUnequal); bool significant = test.Significant; // outputs true Assert.IsTrue(test.Significant); Assert.AreEqual(0.44, test.Statistic, 1e-15); Assert.IsFalse(Double.IsNaN(test.Statistic)); Assert.AreEqual(0.00826, test.PValue, 1e-5); }
/// <summary> /// Creates a new Shapiro-Wilk distribution. /// </summary> /// /// <param name="samples">The number of samples.</param> /// public ShapiroWilkDistribution(int samples) { if (samples < 4) { throw new ArgumentOutOfRangeException("samples", "The number of samples must be higher than 3."); } this.NumberOfSamples = samples; if (samples <= 11) { double n = samples; double n2 = n * n; double n3 = n2 * n; this.g = w => -Math.Log(0.459 * n - 2.273 - Math.Log(1 - w)); double mean = -0.0006714 * n3 + 0.0250540 * n2 - 0.39978 * n + 0.54400; double sigma = Math.Exp(-0.0020322 * n3 + 0.0627670 * n2 - 0.77857 * n + 1.38220); this.normal = new NormalDistribution(mean, sigma); } else { double u = Math.Log(samples); double u2 = u * u; double u3 = u2 * u; this.g = w => Math.Log(1.0 - w); double mean = 0.00389150 * u3 - 0.083751 * u2 - 0.31082 * u - 1.5861; // 1.5861? double sigma = Math.Exp(0.00303020 * u2 - 0.082676 * u - 0.48030); this.normal = new NormalDistribution(mean, sigma); } }
public static HiddenMarkovClassifier<NormalDistribution> CreateModel1() { // Create a Continuous density Hidden Markov Model Sequence Classifier // to detect a univariate sequence and the same sequence backwards. double[][] sequences = new double[][] { new double[] { 0,1,2,3,4 }, // This is the first sequence with label = 0 new double[] { 4,3,2,1,0 }, // This is the second sequence with label = 1 }; // Labels for the sequences int[] labels = { 0, 1 }; // Creates a sequence classifier containing 2 hidden Markov Models // with 2 states and an underlying Normal distribution as density. NormalDistribution density = new NormalDistribution(); var classifier = new HiddenMarkovClassifier<NormalDistribution>(2, new Ergodic(2), density); // Configure the learning algorithms to train the sequence classifier var teacher = new HiddenMarkovClassifierLearning<NormalDistribution>(classifier, // Train each model until the log-likelihood changes less than 0.001 modelIndex => new BaumWelchLearning<NormalDistribution>(classifier.Models[modelIndex]) { Tolerance = 0.0001, Iterations = 0 } ); // Train the sequence classifier using the algorithm double logLikelihood = teacher.Run(sequences, labels); return classifier; }
public ObservationGenerationModel(NormalDistribution foveaPeripheryOperatingCharacteristic, int fixation, int location) { _foveaPeripheryOperatingCharacteristic = foveaPeripheryOperatingCharacteristic; _fixation = fixation; _location = location; }
public void Initialise() { State = new double[7]; for (var i = 0; i < State.Length; i++) { State[i] = 1d/7d; } ; _foveaPeripheryOperatingCharacteristic = NormalDistribution.Standard; }
private double[] GenerateObservations(int fixation, int[] visualArray) { _observationValues = new double[visualArray.Length]; for (var location = 0; location < visualArray.Length; location++) { if (visualArray[location] == 0) { _observationValues[location] = _standardDistribution.Generate(); } else { //discriminability is explained in Butko and Movellan (2008) and is determined using FPOC and eceentricity from fixation. var discriminability = new ObservationGenerationModel(_standardDistribution, fixation, location) .GenerateDiscriminabilityValue(); _observationValues[location] = new NormalDistribution(discriminability, 1.0).Generate(); } } return _observationValues; }
/// <summary> /// Generates a random vector of observations from the /// Inverse Gaussian distribution with the given parameters. /// </summary> /// /// <param name="mean">The mean parameter mu.</param> /// <param name="shape">The shape parameter lambda.</param> /// <param name="samples">The number of samples to generate.</param> /// <param name="result">The location where to store the samples.</param> /// <param name="source">The random number generator to use as a source of randomness. /// Default is to use <see cref="Accord.Math.Random.Generator.Random"/>.</param> /// /// <returns>An array of double values sampled from the inverse Gaussian distribution.</returns> /// public static double[] Random(double mean, double shape, int samples, double[] result, Random source) { NormalDistribution.Random(samples, result, source); for (int i = 0; i < result.Length; i++) { double v = result[i]; double y = v * v; double x = mean + (mean * mean * y) / (2 * shape) - (mean / (2 * shape)) * Math.Sqrt(4 * mean * shape * y + mean * mean * y * y); double t = source.NextDouble(); if (t <= (mean) / (mean + x)) { result[i] = x; } else { result[i] = (mean * mean) / x; } } return(result); }
private void init(int n, double[] ranks, bool?exact) { if (n <= 0) { throw new ArgumentOutOfRangeException("n", "The number of samples must be positive."); } this.n = n; double mean = n * (n + 1.0) / 4.0; double stdDev = Math.Sqrt((n * (n + 1.0) * (2.0 * n + 1.0)) / 24.0); bool hasVectors = ranks != null; // For small samples (< 12) the distribution can be exact this.exact = hasVectors && (n <= 12); if (exact.HasValue) { if (exact.Value && !hasVectors) { throw new ArgumentException("exact", "Cannot use exact method if rank vectors are not specified."); } this.exact = exact.Value; // force } if (hasVectors) { if (this.exact) { initExactMethod(ranks); } } this.approximation = new NormalDistribution(mean, stdDev); }
private void init(int n1, int n2, double[] ranks, bool?exact) { if (n1 <= 0) { throw new ArgumentOutOfRangeException("n1", "The number of observations in the first sample (n1) must be higher than zero."); } if (n2 <= 0) { throw new ArgumentOutOfRangeException("n2", "The number of observations in the second sample (n2) must be higher than zero."); } if (n1 > n2) { Trace.TraceWarning("Creating a MannWhitneyDistribution where the first sample is larger than the second sample. If possible, please re-organize your samples such that the first sample is smaller than the second sample."); } if (ranks != null) { if (ranks.Length <= 1) { throw new ArgumentOutOfRangeException("ranks", "The rank vector must contain a minimum of 2 elements."); } for (int i = 0; i < ranks.Length; i++) { if (ranks[i] < 0) { throw new ArgumentOutOfRangeException("The rank values cannot be negative."); } } } int n = n1 + n2; this.n1 = n1; this.n2 = n2; // From https://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test: For large samples, U // is approximately normally distributed. In that case, the standardized value is given // by z = (U - mean) / stdDev where: double mean = ((double)n1 * n2) / 2.0; double stdDev = Math.Sqrt(((double)n1 * n2 * (n + 1)) / 12.0); bool hasVectors = ranks != null; // For small samples (< 30) the distribution can be exact this.exact = hasVectors && (n1 <= 30 && n2 <= 30); if (exact.HasValue) { if (exact.Value && !hasVectors) { throw new ArgumentException("exact", "Cannot use exact method if rank vectors are not specified."); } this.exact = exact.Value; // force } if (hasVectors) { // Apply correction to the variance double correction = MannWhitneyDistribution.correction(ranks); double a = ((double)n1 * n2) / 12.0; double b = (n + 1.0) - correction; stdDev = Math.Sqrt(a * b); if (this.exact) { initExactMethod(ranks); } } this.approximation = new NormalDistribution(mean, stdDev); }
public static double BaumWelchLearning(double[][] data) { // Specify a initial normal distribution for the samples. NormalDistribution density = new NormalDistribution(); // Creates a continuous hidden Markov Model with two states organized in a forward // topology and an underlying univariate Normal distribution as probability density. var model = new HiddenMarkovModel<NormalDistribution>(new Ergodic(2), density); // Configure the learning algorithms to train the sequence classifier until the // difference in the average log-likelihood changes only by as little as 0.0001 var teacher = new BaumWelchLearning<NormalDistribution>(model) { Tolerance = 0.001, Iterations = 0, }; // Fit the model double likelihood = teacher.Run(data); // See the log-probability of the sequences learned double a1 = model.Evaluate(new[] { 0.999999999999928, 0 , 0.999999999999988 , 0 , 0.999999999999988 }); // -0.12799388666109757 return a1; }
public void NormalTest() { var target = GeneralizedNormalDistribution.Normal(mean: 0.42, stdDev: 4.2); var normal = new NormalDistribution(mean: 0.42, stdDev: 4.2); test(target, normal); }
public static Bitmap AWGNNoise(Bitmap bmp, int intensity) { Bitmap img = new Bitmap(bmp.Width, bmp.Height); var normal = new NormalDistribution(mean: 0, stdDev: 1); double[] noise = normal.Generate(img.Width*img.Height); int l = 0; for (int i = 0; i < bmp.Height; i++) { for(int j = 0; j < bmp.Width; j++) { Color c = bmp.GetPixel(j, i); int c1 = c.R + ((int)Math.Ceiling(noise[l]) * intensity);//(int)noise + intensity;//(int)Math.Sqrt(noise() * 255) + intensity; int c2 = c.G + ((int)Math.Ceiling(noise[l]) * intensity);//(int)Math.Sqrt(noise() * 255) + intensity; int c3 = c.B + ((int)Math.Ceiling(noise[l]) * intensity);//(int)Math.Sqrt(noise() * 255) + intensity; c1 = c1 > 255 ? 255 : c1; c1 = c1 < 0 ? 0 : c1; c2 = c2 > 255 ? 255 : c2; c2 = c2 < 0 ? 0 : c2; c3 = c3 > 255 ? 255 : c3; c3 = c3 < 0 ? 0 : c3; Color newC = Color.FromArgb(c1, c2, c3); img.SetPixel(j, i, newC); l++; } } return img; }
public void DistributionFunctionPerComponent() { NormalDistribution[] components = new NormalDistribution[2]; components[0] = new NormalDistribution(2, 1); components[1] = new NormalDistribution(5, 1); double[] coefficients = { 0.4, 0.5 }; var mixture = new Mixture<NormalDistribution>(coefficients, components); double expected = mixture.DistributionFunction(0, 0.42) + mixture.DistributionFunction(1, 0.42); double actual = mixture.DistributionFunction(0.42); Assert.AreEqual(expected, actual); }
public void ProbabilityDensityFunctionTest2() { double expected, actual; // Test for small variance NormalDistribution target = new NormalDistribution(4.2, double.Epsilon); expected = 0; actual = target.ProbabilityDensityFunction(0); Assert.AreEqual(expected, actual); expected = double.PositiveInfinity; actual = target.ProbabilityDensityFunction(4.2); Assert.AreEqual(expected, actual); }
public void FitTest() { double[] coefficients = { 0.50, 0.50 }; NormalDistribution[] components = new NormalDistribution[2]; components[0] = new NormalDistribution(2, 1); components[1] = new NormalDistribution(5, 1); var target = new Mixture<NormalDistribution>(coefficients, components); double[] values = { 0, 1, 1, 0, 1, 6, 6, 5, 7, 5 }; double[] part1 = values.Submatrix(0, 4); double[] part2 = values.Submatrix(5, 9); MixtureOptions options = new MixtureOptions() { Threshold = 1e-10 }; target.Fit(values, options); var actual = target; var mean1 = Accord.Statistics.Tools.Mean(part1); var var1 = Accord.Statistics.Tools.Variance(part1); Assert.AreEqual(mean1, actual.Components[0].Mean, 1e-6); Assert.AreEqual(var1, actual.Components[0].Variance, 1e-6); var mean2 = Accord.Statistics.Tools.Mean(part2); var var2 = Accord.Statistics.Tools.Variance(part2); Assert.AreEqual(mean2, actual.Components[1].Mean, 1e-6); Assert.AreEqual(var2, actual.Components[1].Variance, 1e-5); var expectedMean = Accord.Statistics.Tools.Mean(values); var actualMean = actual.Mean; Assert.AreEqual(expectedMean, actualMean, 1e-7); var expectedVar = Accord.Statistics.Tools.Variance(values, false); var actualVar = actual.Variance; Assert.AreEqual(expectedVar, actualVar, 0.15); }
public void LogProbabilityDensityFunction() { NormalDistribution[] components = new NormalDistribution[2]; components[0] = new NormalDistribution(2, 1); components[1] = new NormalDistribution(5, 1); double[] coefficients = { 0.4, 0.5 }; var mixture = new Mixture<NormalDistribution>(coefficients, components); double expected = System.Math.Log( 0.4 * components[0].ProbabilityDensityFunction(0.42) + 0.5 * components[1].ProbabilityDensityFunction(0.42)); double actual = mixture.LogProbabilityDensityFunction(0.42); Assert.AreEqual(expected, actual); }
public void LogProbabilityDensityFunctionTest() { double x = 3; double mean = 7; double dev = 5; NormalDistribution target = new NormalDistribution(mean, dev); double expected = System.Math.Log(0.0579383105522966); double actual = target.LogProbabilityDensityFunction(x); Assert.IsFalse(double.IsNaN(actual)); Assert.AreEqual(expected, actual, 1e-15); }
public void ConstructorTest0() { var original = new NormalDistribution(mean: 4, stdDev: 4.2); var normal = new GeneralContinuousDistribution( original.Support, original.ProbabilityDensityFunction, original.DistributionFunction); testNormal(normal, 1); }
public void DistributionFunctionTest() { double x = 3; double mean = 7; double dev = 5; NormalDistribution target = new NormalDistribution(mean, dev); double expected = 0.211855398583397; double actual = target.DistributionFunction(x); Assert.IsFalse(double.IsNaN(actual)); Assert.AreEqual(expected, actual, 1e-15); }
public void MixtureFitTest() { var samples1 = new NormalDistribution(mean: -2, stdDev: 0.5).Generate(100000); var samples2 = new NormalDistribution(mean: +4, stdDev: 0.5).Generate(100000); // Mix the samples from both distributions var samples = samples1.Concatenate(samples2); // Create a new mixture distribution with two Normal components var mixture = new Mixture<NormalDistribution>(new[] { 0.2, 0.8 }, new NormalDistribution(-1), new NormalDistribution(+1)); // Estimate the distribution mixture.Fit(samples, new MixtureOptions { Iterations = 50, Threshold = 0 }); var result = mixture.ToString("N2", System.Globalization.CultureInfo.InvariantCulture); Assert.AreEqual("Mixture(x; 0.50*N(x; μ = -2.00, σ² = 0.25) + 0.50*N(x; μ = 4.00, σ² = 0.25))", result); }
public void DistributionFunctionTest3() { double expected, actual; // Test small variance NormalDistribution target = new NormalDistribution(1.0, double.Epsilon); expected = 0; actual = target.DistributionFunction(0); Assert.AreEqual(expected, actual); expected = 0.5; actual = target.DistributionFunction(1.0); Assert.AreEqual(expected, actual); expected = 1.0; actual = target.DistributionFunction(1.0 + 1e-15); Assert.AreEqual(expected, actual); expected = 0.0; actual = target.DistributionFunction(1.0 - 1e-15); Assert.AreEqual(expected, actual); }
public void DistributionFunctionTest1() { var target = GeneralizedNormalDistribution.Normal(mean: 0.42, stdDev: 4.2); var normal = new NormalDistribution(mean: 0.42, stdDev: 4.2); for (double x = -10; x < 10; x += 0.0001) { double actual = target.DistributionFunction(x); double expected = normal.DistributionFunction(x); Assert.AreEqual(expected, actual, 1e-10); Assert.IsFalse(Double.IsNaN(actual)); } }
public void ZScoreTest() { double x = 5; double mean = 3; double dev = 6; NormalDistribution target = new NormalDistribution(mean, dev); double expected = (x - 3) / 6; double actual = target.ZScore(x); Assert.AreEqual(expected, actual); }
public void NormalTest2() { var target = GeneralizedNormalDistribution.Normal(mean: 0.0, stdDev: 2 / Constants.Sqrt2); var normal = new NormalDistribution(mean: 0.0, stdDev: 2 / Constants.Sqrt2); test(target, normal); var support = target.Support; Assert.AreEqual(normal.Support.Min, support.Min); Assert.AreEqual(normal.Support.Max, support.Max); for (double i = 0.01; i <= 1; i += 0.01) { var actual = normal.GetRange(i); var expected = normal.GetRange(i); Assert.AreEqual(expected.Min, actual.Min); Assert.AreEqual(expected.Max, actual.Max); } }
public void CloneTest() { NormalDistribution target = new NormalDistribution(0.5, 4.2); NormalDistribution clone = (NormalDistribution)target.Clone(); Assert.AreNotSame(target, clone); Assert.AreEqual(target.Entropy, clone.Entropy); Assert.AreEqual(target.Mean, clone.Mean); Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation); Assert.AreEqual(target.Variance, clone.Variance); }
public Activation(NormalDistribution standardDistribution) { _standardDistribution = standardDistribution; }
public void FitTest() { double expectedMean = 1.125; double expectedSigma = 1.01775897605147; NormalDistribution target; target = new NormalDistribution(); double[] observations = { 0.10, 0.40, 2.00, 2.00 }; double[] weights = { 0.25, 0.25, 0.25, 0.25 }; target.Fit(observations, weights); Assert.AreEqual(expectedMean, target.Mean); Assert.AreEqual(expectedSigma, target.StandardDeviation, 1e-6); target = new NormalDistribution(); double[] observations2 = { 0.10, 0.10, 0.40, 2.00 }; double[] weights2 = { 0.125, 0.125, 0.25, 0.50 }; target.Fit(observations2, weights2); Assert.AreEqual(expectedMean, target.Mean); // Assert.AreEqual(expectedSigma, target.StandardDeviation, 1e-6); }
/// <summary> /// Generates a random observation from the /// Lognormal distribution with the given parameters. /// </summary> /// /// <param name="location">The distribution's location value.</param> /// <param name="shape">The distribution's shape deviation.</param> /// <param name="source">The random number generator to use as a source of randomness. /// Default is to use <see cref="Accord.Math.Random.Generator.Random"/>.</param> /// /// <returns>A random double value sampled from the specified Lognormal distribution.</returns> /// public static double Random(double location, double shape, Random source) { return(Math.Exp(location + shape * NormalDistribution.Random(source))); }
public void ConstructorTest2() { var original = new NormalDistribution(mean: 4, stdDev: 4.2); var normal = GeneralContinuousDistribution.FromDensityFunction( original.Support, original.ProbabilityDensityFunction); for (double i = -10; i < +10; i += 0.1) { double expected = original.DistributionFunction(i); double actual = normal.DistributionFunction(i); double diff = Math.Abs(expected - actual) / expected; Assert.IsTrue(diff < 1e-7); } testNormal(normal, 1); }
public void ConstructorTest1() { NormalDistribution[] components = new NormalDistribution[2]; components[0] = new NormalDistribution(2, 1); components[1] = new NormalDistribution(5, 1); var mixture = new Mixture<NormalDistribution>(components); double[] expected = { 0.5, 0.5 }; Assert.IsTrue(expected.IsEqual(mixture.Coefficients)); Assert.AreEqual(components, mixture.Components); }
public void InverseDistributionFunctionTest() { double[] expected = { Double.NegativeInfinity, -4.38252, -2.53481, -1.20248, -0.0640578, 1.0, 2.06406, 3.20248, 4.53481, 6.38252, Double.PositiveInfinity }; NormalDistribution original = new NormalDistribution(1.0, 4.2); var target = GeneralContinuousDistribution.FromDistributionFunction( original.Support, original.DistributionFunction); for (int i = 0; i < expected.Length; i++) { double x = i / 10.0; double actual = target.InverseDistributionFunction(x); Assert.AreEqual(expected[i], actual, 1e-5); Assert.IsFalse(Double.IsNaN(actual)); } }
public void FitTest2() { double[] coefficients = { 0.50, 0.50 }; NormalDistribution[] components = new NormalDistribution[2]; components[0] = new NormalDistribution(2, 1); components[1] = new NormalDistribution(5, 1); var target = new Mixture<NormalDistribution>(coefficients, components); double[] values = { 12512, 1, 1, 0, 1, 6, 6, 5, 7, 5 }; double[] weights = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; weights = weights.Divide(weights.Sum()); double[] part1 = values.Submatrix(1, 4); double[] part2 = values.Submatrix(5, 9); MixtureOptions opt = new MixtureOptions() { Threshold = 0.000001 }; target.Fit(values, weights, opt); var mean1 = Accord.Statistics.Tools.Mean(part1); var var1 = Accord.Statistics.Tools.Variance(part1); Assert.AreEqual(mean1, target.Components[0].Mean, 1e-5); Assert.AreEqual(var1, target.Components[0].Variance, 1e-5); var mean2 = Accord.Statistics.Tools.Mean(part2); var var2 = Accord.Statistics.Tools.Variance(part2); Assert.AreEqual(mean2, target.Components[1].Mean, 1e-5); Assert.AreEqual(var2, target.Components[1].Variance, 1e-5); var expectedMean = Accord.Statistics.Tools.WeightedMean(values, weights); var actualMean = target.Mean; Assert.AreEqual(expectedMean, actualMean, 1e-5); }
public void MedianTest2() { NormalDistribution original = new NormalDistribution(0.4, 2.2); var target = GeneralContinuousDistribution.FromDistributionFunction( original.Support, original.DistributionFunction); Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5)); Assert.AreEqual(target.Median, original.Median, 1e-10); target = GeneralContinuousDistribution.FromDensityFunction( original.Support, original.ProbabilityDensityFunction); Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5), 1e-10); Assert.AreEqual(target.Median, original.Median, 1e-10); }
public void MixtureWeightsFitTest() { // Randomly initialize some mixture components NormalDistribution[] components = new NormalDistribution[2]; components[0] = new NormalDistribution(2, 1); components[1] = new NormalDistribution(5, 1); // Create an initial mixture Mixture<NormalDistribution> mixture = new Mixture<NormalDistribution>(components); // Now, suppose we have a weighted data // set. Those will be the input points: double[] points = { 0, 3, 1, 7, 3, 5, 1, 2, -1, 2, 7, 6, 8, 6 }; // (14 points) // And those are their respective unormalized weights: double[] weights = { 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 2, 3, 1, 1 }; // (14 weights) // Let's normalize the weights so they sum up to one: weights = weights.Divide(weights.Sum()); // Now we can fit our model to the data: mixture.Fit(points, weights); // done! // Our model will be: double mean1 = mixture.Components[0].Mean; // 1.41126 double mean2 = mixture.Components[1].Mean; // 6.53301 // If we need the GaussianMixtureModel functionality, we can // use the estimated mixture to initialize a new model: GaussianMixtureModel gmm = new GaussianMixtureModel(mixture); Assert.AreEqual(mean1, gmm.Gaussians[0].Mean[0]); Assert.AreEqual(mean2, gmm.Gaussians[1].Mean[0]); Assert.AreEqual(mean1, 1.4112610766836404, 1e-15); Assert.AreEqual(mean2, 6.5330177004151082, 1e-14); Assert.AreEqual(mixture.Coefficients[0], gmm.Gaussians[0].Proportion); Assert.AreEqual(mixture.Coefficients[1], gmm.Gaussians[1].Proportion); }
static void Main(string[] args) { Process _process = Process.GetCurrentProcess(); bool _takearguments = false; // How many arguments have been stored in the game. if (args.Length > 0) { Console.WriteLine("Arguments found."); _takearguments = true; HandleArguments(args); } string HostName = "localhost"; if (!_takearguments) { Console.WriteLine("Host name:"); HostName = Console.ReadLine(); Console.Clear(); Console.WriteLine("How many games do you wish to simulate?"); string _count = Console.ReadLine(); int _result = 0; // Determine that the value that has been inputted is // in fact valid. while (!int.TryParse(_count, out _result)) { Console.Clear(); Console.WriteLine("Please try again: "); _count = Console.ReadLine(); } // Set the new count of games that we want to simulate. gamesToPlay = _result; Console.Clear(); string _consoleoutput = ""; while (_consoleoutput != "n" && _consoleoutput != "y") { // Determine if we want to log output to be silence while we do this Console.WriteLine("Silence output?"); _consoleoutput = Console.ReadLine(); } if (_consoleoutput == "n") { m_RemainQuiet = false; } else if (_consoleoutput == "y") { m_RemainQuiet = true; } } //RunGamesParallel(); //return; // Get some strange invocation error here. // tryLoadController(_agentName); gs = new GameState(125); gs.GameOver += new EventHandler(GameOverHandler); gs.StartPlay(); BasePacman controller = new LucPacScripted(); Console.WriteLine("Choose an AI agent to control Pacman:"); Console.WriteLine(" 1 - LucPacScripted"); Console.WriteLine(" 2 - LucPac (MCTS)"); Console.WriteLine(" 3 - MMLocPac (Evolved Neural Network) from .nn file"); Console.WriteLine(" 5 - SimRandom"); int Selection = int.Parse(Console.ReadKey().KeyChar.ToString()); switch (Selection) { case 1: controller = new LucPacScripted(); break; case 2: controller = new LucPac(); break; case 3: controller = new MMPac.MMLocPac("NeuralNetworkLocPac.nn"); break; default: controller = new RandomPac(); break; } var GR = new GameRunner(); var Base = new double[9] { 3.0, 2.8, 2.8, 2.8, 2.8, 1.5, 1.5, 1.5, 1.5 }; var Params = new double[9] { 0.07, 0.01, 0.02, -0.16, 0.06, -0.05, 0, 0.06, -0.09 }; //var Params = new double[9] { -0.17, 0.01, 0.02, -0.16, 0.06, -0.05, 0, 0.06, -0.09 }; // Params = Params.Add(Base); string TestAgent = "PacmanAI.UncertainAgent,PacmanAI"; var GRR = GR.RunGamesOnline(HostName, gamesToPlay, controller.GetType().Name //TestAgent , new Random().Next(), //null new List <double>(Params) ); var NewScores = new List <double>(); NewScores.AddRange(GRR.scores); for (int i = 0; i < NewScores.Count; i++) { NewScores[i] += 9000; } NewScores.AddRange(GRR.scores); var ZeroScores = new List <double>(); for (int i = 0; i < 100; i++) { ZeroScores.Add(0); } Console.WriteLine("Done - " + GRR.scores.Average() + " " + GRR.gamesPlayed); Console.WriteLine("Scores over 1600: " + GRR.scores.Where(s => s >= 1600).Count()); Console.WriteLine("Done (Altered) - " + NewScores.Average() + " " + GRR.gamesPlayed); Console.WriteLine("Scores over 1500 (Altered): " + NewScores.Where(s => s >= 1500).Count()); /*Console.WriteLine("Evaluation score via distribution evaluation: " + new DistributionWeightEvaluation(null).CalculateFitnessScore(GRR.scores, 5000, 1)); * Console.WriteLine("Evaluation score via average evaluation: " + new AccurateThresholdEvaluation(null).CalculateFitnessScore(GRR.scores, 5000, 1)); * * * Console.WriteLine("Evaluation score via distribution evaluation (All zeroes): " + new DistributionWeightEvaluation(null).CalculateFitnessScore(ZeroScores, 1500, 1)); * Console.WriteLine("Evaluation score via average evaluation (All zeroes): " + new AccurateThresholdEvaluation(null).CalculateFitnessScore(ZeroScores, 1500, 1)); * * Console.WriteLine("Evaluation score via distribution evaluation (Altered scores): " + new DistributionWeightEvaluation(null).CalculateFitnessScore(NewScores, 5000, 1)); * Console.WriteLine("Evaluation score via average evaluation (Altered scores): " + new AccurateThresholdEvaluation(null).CalculateFitnessScore(NewScores, 5000, 1)); * * var gaussianDist = new Accord.Statistics.Distributions.Univariate.NormalDistribution(2000, 10); * * Console.WriteLine("Evaluation score via distribution evaluation (Gaussian scores): " + new DistributionWeightEvaluation(null).CalculateFitnessScore(gaussianDist.Generate(100).ToList(), 2000, 1)); * Console.WriteLine("Evaluation score via average evaluation (Gaussian scores): " + new AccurateThresholdEvaluation(null).CalculateFitnessScore(gaussianDist.Generate(100).ToList(), 2000, 1)); */ Accord.Statistics.Distributions.Univariate.EmpiricalDistribution rdb = new Accord.Statistics.Distributions.Univariate.EmpiricalDistribution(GRR.scores.ToArray(), 25); Accord.Controls.DataSeriesBox.Show("Pacman score distribution", rdb.ProbabilityDensityFunction, new Accord.DoubleRange(-2000, 12000)); Accord.Statistics.Distributions.Univariate.EmpiricalDistribution rdb2 = new Accord.Statistics.Distributions.Univariate.EmpiricalDistribution(NewScores.ToArray()); Accord.Controls.DataSeriesBox.Show("Pacman score distribution (Altered)", rdb2.ProbabilityDensityFunction, new Accord.DoubleRange(-2000, 12000)); double[] coef = { 4, 1 }; var skewNormal = new Mixture <NormalDistribution>(coef, new NormalDistribution(2000, 1500), new NormalDistribution(7000, 1500));// new SkewNormalDistribution(4500, 3000, 7.2); Accord.Controls.DataSeriesBox.Show("Skew Normal", skewNormal.ProbabilityDensityFunction, new Accord.DoubleRange(-2000, 12000)); Console.ReadKey(); return; // DEFINE CONTROLLER // //BasePacman controller = new MMMCTSCode.MMMCTS(); //BasePacman controller = new RandomPac(); //BasePacman controller = new LucPacScripted(); //BasePacman controller = new LucPac(); //BasePacman controller = new MMPac.MMPac("NeuralNetwork.nn"); //BasePacman controller = new MMPac.MMPac(Weights); //BasePacman controller = new MMPac.MMLocPac("NeuralNetworkLocPac.nn"); // Turn off the logging if (controller.GetType() == typeof(LucPac) && m_RemainQuiet) { LucPac.REMAIN_QUIET = true; } if (controller.GetType() == typeof(LucPacScripted) && m_RemainQuiet) { LucPacScripted.REMAIN_QUIET = true; } //BasePacman controller = new SmartDijkstraPac(); gs.Controller = controller; Stopwatch watch = new Stopwatch(); int percentage = -1; int lastUpdate = 0; watch.Start(); while (gamesPlayed < gamesToPlay) { int newPercentage = (int)Math.Floor(((float)gamesPlayed / gamesToPlay) * 100); if (newPercentage != percentage || gamesPlayed - lastUpdate >= 100) { lastUpdate = gamesPlayed; percentage = newPercentage; Console.Clear(); Console.WriteLine("Simulating ... " + percentage + "% (" + gamesPlayed + " : " + gamesToPlay + ")"); Console.WriteLine(" - Elapsed: " + (watch.ElapsedMilliseconds / 1000.0) + "ms"); Console.WriteLine(" - Current best: " + highestScore); Console.WriteLine(" - Current worst: " + lowestScore); if (gamesPlayed > 0) { Console.WriteLine(" - Current avg.: " + (totalScore / gamesPlayed)); } } // update gamestate Direction direction = controller.Think(gs); gs.Pacman.SetDirection(direction); // update game gs.Update(); ms += GameState.MSPF; } watch.Stop(); // shut down controller controller.SimulationFinished(); // output results Console.Clear(); long seconds = ms / 1000; Console.WriteLine("Games played: " + gamesPlayed); Console.WriteLine("Avg. score: " + (totalScore / gamesPlayed)); Console.WriteLine("Highest score: " + highestScore + " points"); Console.WriteLine("Lowest score: " + lowestScore + " points"); Console.WriteLine("Max Pills Eaten: " + maxPillsEaten); Console.WriteLine("Min Pills Eaten: " + minPillsEaten); Console.WriteLine("Average Pills Eaten: " + pillsEatenTotal / gamesPlayed); Console.WriteLine("Max Ghosts Eaten: " + maxGhostsEaten); Console.WriteLine("Min Ghosts Eaten: " + minGhostsEaten); Console.WriteLine("Average Ghosts Eaten: " + totalGhostsEaten / gamesPlayed); Console.WriteLine("Longest game: " + ((float)longestGame / 1000.0f) + " seconds"); Console.WriteLine("Total simulated time: " + (seconds / 60 / 60 / 24) + "d " + ((seconds / 60 / 60) % 24) + "h " + ((seconds / 60) % 60) + "m " + (seconds % 60) + "s"); Console.WriteLine("Avg. simulated time pr. game: " + ((float)ms / 1000.0f / gamesPlayed) + " seconds"); Console.WriteLine("Simulation took: " + (watch.ElapsedMilliseconds / 1000.0f) + " seconds"); Console.WriteLine("Speed: " + (ms / watch.ElapsedMilliseconds) + " (" + ((ms / watch.ElapsedMilliseconds) / 60) + "m " + ((ms / watch.ElapsedMilliseconds) % 60) + " s) simulated seconds pr. second"); Console.WriteLine("For a total of: " + gamesPlayed / (watch.ElapsedMilliseconds / 1000.0f) + " games pr. second"); Console.WriteLine(); //Calculate standard deviation double mean = totalScore / gamesPlayed; double totalsqdif = 0; foreach (var val in scores) { totalsqdif += (val - mean) * (val - mean); } double variance = totalsqdif / gamesPlayed; double stddev = Math.Sqrt(variance); Console.WriteLine("Standard deviation of: " + stddev); Console.WriteLine("Standard deviation of (Accord): " + scores.ToArray().StandardDeviation()); //Generates a distribution from existing data Accord.Statistics.Distributions.Univariate.EmpiricalDistribution db = new Accord.Statistics.Distributions.Univariate.EmpiricalDistribution(scores.ToArray()); //Calculates standard deviation Console.WriteLine("Standard deviation of (Accord 2): " + db.StandardDeviation); double[] sample = //{ 1000, 960, 1000, 960, 1000, 600, 100, 1000, 1500}; { 2000, 2500, 2100, 9000, 1900, 2000, 150, 2100 }; //{ 60000, 70000, 80000, 90000, 40000, 100000, 200000, 15000, 500000, 44444 }; //scores.Take(20).ToArray(); double[] sample2 = scores.Take(100).ToArray(); //Shapiro Wilk test to see if distribution is normal var swT = new Accord.Statistics.Testing.ShapiroWilkTest(scores.ToArray()); Console.WriteLine("Shapiro Wilk Test on all scores: Statistic - " + swT.Statistic + " , PValue - " + swT.PValue + " , Significant - " + swT.Significant); var normalDist = new Accord.Statistics.Distributions.Univariate.NormalDistribution(950, 1200); var swT2 = new Accord.Statistics.Testing.ShapiroWilkTest(normalDist.Generate(1000)); Console.WriteLine("Shapiro Wilk Test on normal dist: Statistic - " + swT2.Statistic + " , PValue - " + swT2.PValue + " , Significant - " + swT2.Significant); //Accord.Statistics.Testing.KolmogorovSmirnovTest ks = new Accord.Statistics.Testing.KolmogorovSmirnovTest(sample, db); //Console.WriteLine("KS Test: Statistic - " + ks.Statistic + " , PValue - " + ks.PValue + " , Significant - " + ks.Significant); //Probability that the given scores were sampled from the previous distribution Accord.Statistics.Testing.ZTest ts = new Accord.Statistics.Testing.ZTest(sample, totalScore / gamesPlayed); /*sample.Average(), * db.StandardDeviation, * sample.Length, * totalScore / gamesPlayed); */ Console.WriteLine("Z Test: Statistic - " + ts.Statistic + " , PValue - " + ts.PValue + " , Significant - " + ts.Significant); Accord.Statistics.Testing.ZTest ts2 = new Accord.Statistics.Testing.ZTest(sample2, totalScore / gamesPlayed); /*sample2.Average(), * //Accord.Statistics.Tools.StandardDeviation(sample2.ToArray()), * db.StandardDeviation, * sample2.Length, * totalScore / gamesPlayed); */ Console.WriteLine("Z Test 2: Statistic - " + ts2.Statistic + " , PValue - " + ts2.PValue + " , Significant - " + ts2.Significant); //% of values that are between given ranges Console.WriteLine("Distribution function 0 - 1000: " + db.DistributionFunction(0, 1000)); Console.WriteLine("Distribution function 1000 - 11000: " + db.DistributionFunction(1000, 11000)); Console.WriteLine("Distribution function 0 - 500: " + db.DistributionFunction(0, 500)); Console.WriteLine("Distribution function 1500 - 11000: " + db.DistributionFunction(1500, 11000)); //MannWhitneyWilcoxon test on whether 2 samples are from the same distribution - high P value = likely same distribution Accord.Statistics.Testing.MannWhitneyWilcoxonTest mwTest = new Accord.Statistics.Testing.MannWhitneyWilcoxonTest(scores.ToArray(), sample2); Console.WriteLine("MWW Test: Statistic - " + mwTest.Statistic + " , PValue - " + mwTest.PValue + " , Significant - " + mwTest.Significant); Accord.Statistics.Testing.MannWhitneyWilcoxonTest mwTest2 = new Accord.Statistics.Testing.MannWhitneyWilcoxonTest(normalDist.Generate(1000), scores.ToArray()); Console.WriteLine("MWW Test 2 (actual scores versus normal dist): Statistic - " + mwTest2.Statistic + " , PValue - " + mwTest2.PValue + " , Significant - " + mwTest2.Significant); //Accord.Controls.HistogramBox.Show(scores.ToArray()); //Guess what distribution this is var analysis = new Accord.Statistics.Analysis.DistributionAnalysis(scores.ToArray()); // Compute the analysis analysis.Compute(); // Get the most likely distribution (first) var mostLikely = analysis.GoodnessOfFit[0]; var result = mostLikely.Distribution.ToString(); Console.WriteLine(result); //Plots the distributions Accord.Controls.DataSeriesBox.Show("Pacman score distribution", db.ProbabilityDensityFunction, new Accord.DoubleRange(-2000, highestScore)); Accord.Controls.DataSeriesBox.Show("Normal distribution", normalDist.ProbabilityDensityFunction, new Accord.DoubleRange(-2000, highestScore)); Accord.Controls.DataSeriesBox.Show("Gamma distribution", mostLikely.Distribution.ProbabilityFunction, new Accord.DoubleRange(-2000, highestScore)); //Calculate some CDF related malarkey //top 20 scores - 1 empirical //next 20 scores - 2nd empirical //calculate cdf of both //calculate cdf of cumulative int games1 = 80; int games2 = 20; Accord.Statistics.Distributions.Univariate.EmpiricalDistribution edb = new Accord.Statistics.Distributions.Univariate.EmpiricalDistribution(scores.GetRange(0, games1).ToArray()); Accord.Statistics.Distributions.Univariate.EmpiricalDistribution edb2 = new Accord.Statistics.Distributions.Univariate.EmpiricalDistribution(scores.GetRange(games1, games2).ToArray()); Accord.Statistics.Distributions.Univariate.EmpiricalDistribution edbC = new Accord.Statistics.Distributions.Univariate.EmpiricalDistribution(scores.GetRange(0, games1 + games2).ToArray()); var cdf1 = edb.DistributionFunction(800); var cdf2 = edb2.DistributionFunction(800); var cdfC = edbC.DistributionFunction(800); Console.WriteLine("CDF1 = " + cdf1 + ", CDF2 = " + cdf2 + ", Guess = " + (cdf1 * games1 + cdf2 * games2) / (games1 + games2) + ", Actual = " + cdfC); //Convolution var ScoresA = scores.GetRange(0, games1).ToArray(); var ScoresB = scores.GetRange(games1, games1).ToArray(); //var Convolution = ScoresA.Convolve(ScoresB); double[] Convolution = new double[games1]; Accord.Math.Transforms.FourierTransform2.Convolve(ScoresA, ScoresB, Convolution); Console.ReadLine(); }