/// <summary> /// Run a simulation and store the results for later use by <see cref="GetIndices(MarketObservable, List{Date})"/> /// </summary> /// <param name="simNumber"></param> public override void RunSimulation(int simNumber) { simulation = new Dictionary <int, double[]>(); acculatedDivi = new Dictionary <int, double[]>(); var simPrices = prices.Copy(); double oldDF = 1; double newDF; for (var timeCounter = 0; timeCounter < allRequiredDates.Count; timeCounter++) { double dt = timeCounter > 0 ? allRequiredDates[timeCounter] - allRequiredDates[timeCounter - 1] : allRequiredDates[timeCounter] - anchorDate.value; newDF = discountCurve.GetDF(allRequiredDates[timeCounter]); var rateDrift = oldDF / newDF; oldDF = newDF; dt = dt / 365.0; var sdt = Math.Sqrt(dt); var dW = normal.Generate(); acculatedDivi[allRequiredDates[timeCounter]] = Vector.Zeros(shares.Length); for (var s = 0; s < shares.Length; s++) { acculatedDivi[allRequiredDates[timeCounter]][s] = simPrices[s] * divYields[s] * dt; simPrices[s] = simPrices[s] * rateDrift * Math.Exp((-divYields[s] - 0.5 * vols[s] * vols[s]) *dt + vols[s] *sdt *dW[s]); } simulation[allRequiredDates[timeCounter]] = simPrices.Copy(); } }
private void DoCreateData() { // Generate data with n Gaussian distributions var data = new double[this.k][][]; for (var i = 0; i < this.k; i++) { // Create random centroid to place the Gaussian distribution var mean = Matrix.Random(2, -6.0, +6.0); // Create random covariance matrix for the distribution var covariance = Accord.Statistics.Tools.RandomCovariance(2, -5, 5); // Create the Gaussian distribution var gaussian = new MultivariateNormalDistribution(mean, covariance); var samples = Tools.Random.Next(150, 250); data[i] = gaussian.Generate(samples); } // Join the generated data this.mixture = Matrix.Stack(data); // Update the scatter plot CreateScatterplot(this.PlotModel, Colors, this.mixture, this.k); // Forget previous initialization this.kmeans = null; this.canInitializeOrFit = true; this.ChangeCanExecute(); }
public void GenerateTest2() { Accord.Math.Tools.SetupGenerator(0); var normal = new MultivariateNormalDistribution( new double[] { 2, 6 }, new double[, ] { { 2, 1 }, { 1, 5 } }); double[][] sample = new double[1000000][]; for (int i = 0; i < sample.Length; i++) { sample[i] = normal.Generate(); } double[] mean = sample.Mean(); double[,] cov = sample.Covariance(); Assert.AreEqual(2, mean[0], 1e-2); Assert.AreEqual(6, mean[1], 1e-2); Assert.AreEqual(2, cov[0, 0], 1e-2); Assert.AreEqual(1, cov[0, 1], 1e-2); Assert.AreEqual(1, cov[1, 0], 1e-2); Assert.AreEqual(5, cov[1, 1], 2e-2); }
/// <summary> /// Creates the initial scatter plot graphs containing some random /// data. This data is generated by sampling Gaussian distributions. /// </summary> /// private void btnGenerateRandom_Click(object sender, EventArgs e) { k = (int)numClusters.Value; // Generate data with n Gaussian distributions double[][][] data = new double[k][][]; for (int i = 0; i < k; i++) { // Create random centroid to place the Gaussian distribution double[] mean = Vector.Random(2, -6.0, +6.0); // Create random covariance matrix for the distribution double[,] covariance = Accord.Statistics.Tools.RandomCovariance(2, -5, 5); // Create the Gaussian distribution var gaussian = new MultivariateNormalDistribution(mean, covariance); int samples = Accord.Math.Random.Generator.Random.Next(150, 250); data[i] = gaussian.Generate(samples); } // Join the generated data observations = Matrix.Stack(data); // Update the scatter plot CreateScatterplot(graph, observations, k); // Forget previous initialization kmeans = null; }
public void MultivariateNormalGenerateTest() { // mean vector double[] mu = { 2.0, 6.0 }; // covariance double[,] cov = { { 2, 1 }, { 1, 5 } }; // Create a multivariate Normal distribution var normal = new MultivariateNormalDistribution(mu, cov); // Generate 1000000 samples from it double[][] samples = normal.Generate(1000000); // Try to estimate a new Normal distribution from // generated samples to check if they indeed match var actual = MultivariateNormalDistribution.Estimate(samples); Assert.IsTrue(mu.IsEqual(actual.Mean, 0.1)); Assert.IsTrue(cov.IsEqual(actual.Covariance, 0.1)); }
public void GenerateTest1() { Accord.Math.Tools.SetupGenerator(0); double[] mean = { 2, 6 }; double[,] cov = { { 2, 1 }, { 1, 5 } }; var normal = new MultivariateNormalDistribution(mean, cov); double[][] source = normal.Generate(10000000); var target = new MultivariateEmpiricalDistribution(source); Assert.IsTrue(mean.IsEqual(target.Mean, 0.001)); Assert.IsTrue(cov.IsEqual(target.Covariance, 0.003)); double[][] samples = target.Generate(10000000); double[] sampleMean = samples.Mean(); double[,] sampleCov = samples.Covariance(); Assert.AreEqual(2, sampleMean[0], 1e-2); Assert.AreEqual(6, sampleMean[1], 1e-2); Assert.AreEqual(2, sampleCov[0, 0], 1e-2); Assert.AreEqual(1, sampleCov[0, 1], 1e-2); Assert.AreEqual(1, sampleCov[1, 0], 1e-2); Assert.AreEqual(5, sampleCov[1, 1], 2e-2); }
public override void RunSimulation(int simNumber) { foreach (var simulator in _ccySimMap.Values) { simulator.RunSimulation(simNumber); } _simulation = new Dictionary <int, double[]>(); var simPrices = _spots.Copy(); var oldDrifts = Vector.Ones(simPrices.Length); for (var timeCounter = 0; timeCounter < _allRequiredDates.Count; timeCounter++) { double dt = timeCounter > 0 ? _allRequiredDates[timeCounter] - _allRequiredDates[timeCounter - 1] : _allRequiredDates[timeCounter] - _anchorDate.value; dt = dt / 365.0; var sdt = Math.Sqrt(dt); var dW = _normal.Generate(); for (var s = 0; s < _currencyPairs.Length; s++) { var drift = _ccySimMap[_currencyPairs[s].CounterCurrency.ToString()] .Numeraire(_allRequiredDates[timeCounter]) / _ccySimMap[_currencyPairs[s].BaseCurrency.ToString()] .Numeraire(_allRequiredDates[timeCounter]); simPrices[s] = simPrices[s] * drift / oldDrifts[s] * Math.Exp(-0.5 * _vols[s] * _vols[s] * dt + _vols[s] * sdt * dW[s]); oldDrifts[s] = drift; } _simulation[_allRequiredDates[timeCounter]] = simPrices.Copy(); } }
public override void RunSimulation(int simNumber) { foreach (HullWhite1F simulator in rateSimulators) { simulator.RunSimulation(simNumber); } simulation = new Dictionary <int, double[]>(); double[] simPrices = spots.Copy(); double[] oldDrifts = Vector.Ones(simPrices.Length); for (int timeCounter = 0; timeCounter < allRequiredDates.Count; timeCounter++) { double dt = timeCounter > 0 ? allRequiredDates[timeCounter] - allRequiredDates[timeCounter - 1] : allRequiredDates[timeCounter] - anchorDate.value; dt = dt / 365.0; double sdt = Math.Sqrt(dt); double[] dW = normal.Generate(); for (int s = 0; s < currencyPairs.Length; s++) { double drift = ccySimMap[currencyPairs[s].counterCurrency].Numeraire(allRequiredDates[timeCounter]) / ccySimMap[currencyPairs[s].baseCurrency].Numeraire(allRequiredDates[timeCounter]); simPrices[s] = simPrices[s] * drift / oldDrifts[s] * Math.Exp((-0.5 * vols[s] * vols[s]) * dt + vols[s] * sdt * dW[s]); oldDrifts[s] = drift; } simulation[allRequiredDates[timeCounter]] = simPrices.Copy(); } }
private static void Create(int n1, int n2, int k, out double[][] inputs, out NaiveKNearestNeighbors naive, out KNearestNeighbors <double[]> normal, out KNearestNeighbors target) { int n = n1 + n2; double[][] gauss1 = MultivariateNormalDistribution.Generate(n1, mean: new double[] { 2, 1 }, covariance: new double[, ] { { 1, 0 }, { 0, 1 }, }); double[][] gauss2 = MultivariateNormalDistribution.Generate(n2, mean: new double[] { -1, 4 }, covariance: new double[, ] { { 2, 1 }, { 0, 3 }, }); inputs = gauss1.Stack(gauss2); int[] outputs = Matrix.Vector(n1, 0).Concatenate(Matrix.Vector(n2, +1)); var idx = Vector.Sample(n1 + n2); inputs = inputs.Submatrix(idx); outputs = outputs.Submatrix(idx); naive = new NaiveKNearestNeighbors(k, inputs, outputs); normal = new KNearestNeighbors <double[]>(k, inputs, outputs, new Euclidean()); target = new KNearestNeighbors(k, inputs, outputs); }
public Class GenerateClassByGaussian(int vectorSize, double expectationX, double expectationY, double[,] covarian) { var vector = new double[vectorSize, 2]; var distribution = new MultivariateNormalDistribution(new[] { expectationX, expectationY }, covarian); var generatedPoints = distribution.Generate(vectorSize); for (int i = 0; i < vectorSize; i++) { vector[i, 0] = generatedPoints[i][0]; vector[i, 1] = generatedPoints[i][1]; } return(new Class(vector, expectationX, expectationY)); }
// Update is called once per frame void Update() { // Move the sphere to its current destination position sphere.transform.position += Time.smoothDeltaTime * destination; // Increase the frame counter numberOfFramesPassed++; // Change destination every 10 frames if (numberOfFramesPassed % 10 == 0) { // 10 frames have passed, change destination: float[] random = normal.Generate().ToSingle(); destination = new Vector3(random[0], random[1], random[2]); } }
public IEnumerable <Point> GenerateNegativePointsFromPositivesDistribution(double quantile, int count = 100) { for (var i = 0; i < count; i++) { double[] point; do { point = _multivariateNormalDistribution.Generate(); } while (_multivariateNormalDistribution.Mahalanobis(point) < CalculateThreshold(quantile)); yield return(new Point(point) { Label = false }); } }
private double[][] GetSamples(int howMany, List <BooleanStatistic> statistics) { var disitrubtion = new NormalDistribution(0, Math.Sqrt(1)); var mean = new double[CovarianceMatrix.GetLength(0)]; for (int i = 0; i < CovarianceMatrix.GetLength(0); i++) { mean[i] = disitrubtion.InverseDistributionFunction(GetMean(i, statistics)); } var mnormaldist = new MultivariateNormalDistribution(mean, CovarianceMatrix); var samples = mnormaldist.Generate(howMany); samples = Booleanize(samples); return(samples); }
public static List <double[, ]> StockPathSimulator(double spot, double vol, double divYield, double rate, double timeToExpiry, int numOfSims, int timeSteps, double bump) { double dt = (double)timeToExpiry / timeSteps; var sdt = Math.Sqrt(dt); // Create an instance of the multivariate normal distribution double[,] correlations = { { 1.0 } }; var normal = new MultivariateNormalDistribution(Vector.Zeros(1), correlations); double[,] stockpaths = new double[numOfSims, timeSteps]; double[,] stockpaths_up = new double[numOfSims, timeSteps]; double[,] stockpaths_down = new double[numOfSims, timeSteps]; for (int sim = 0; sim < numOfSims; sim++) { double S_t = spot; double S_t_up = spot + bump; double S_t_down = spot - bump; for (int t = 0; t < timeSteps; t++) { double dW = normal.Generate()[0]; S_t = S_t * Math.Pow(Math.E, ((rate - divYield - Math.Pow(vol, 2) / 2) * dt + vol * dW * sdt)); stockpaths[sim, t] = S_t; S_t_up = S_t_up * Math.Pow(Math.E, ((rate - divYield - Math.Pow(vol, 2) / 2) * dt + vol * dW * sdt)); stockpaths_up[sim, t] = S_t_up; S_t_down = S_t_down * Math.Pow(Math.E, ((rate - divYield - Math.Pow(vol, 2) / 2) * dt + vol * dW * sdt)); stockpaths_down[sim, t] = S_t_down; } } var paths = new List <double[, ]>(); paths.Add(stockpaths); paths.Add(stockpaths_up); paths.Add(stockpaths_down); return(paths); }
//generate Gaussian distributed 2d array public static double[,] NormalDistributionSamples(int numberOfSamples, int sampleSize) { var temp = new MultivariateNormalDistribution(dimension: sampleSize); // mean vector double[] mu = temp.Generate(); // covariance double[,] cov = { { 2, 1 }, { 1, 5 } }; // Create a multivariate Normal distribution var normal = new MultivariateNormalDistribution(mu); // Generate samples from it double[][] samples = normal.Generate(numberOfSamples); // Convert jagged array to 2D array try { int firstDim = samples.Length; int secondDim = samples.GroupBy(row => row.Length).Single().Key; // throws InvalidOperationException if source is not rectangular var result = new double[firstDim, secondDim]; for (int i = 0; i < firstDim; ++i) { for (int j = 0; j < secondDim; ++j) { result[i, j] = samples[i][j]; } } return(result); } catch (InvalidOperationException) { throw new InvalidOperationException("The given jagged array is not rectangular."); } }
public void TestMultivariateNormalSim() { double[,] correlations = { { 1.0, 0.4, 0.5 }, { 0.4, 1.0, 0.6 }, { 0.5, 0.6, 1.0 } }; MultivariateNormalDistribution normal = new MultivariateNormalDistribution(Vector.Zeros(3), correlations); int N = 10000; double[,] X = new double[N, 3]; for (int i = 0; i < N; i++) { double[] dW = normal.Generate(); X[i, 0] = dW[0]; X[i, 1] = dW[1]; X[i, 2] = dW[2]; } double[,] corr = X.Correlation(); Assert.AreEqual(corr[1, 0], 0.4, 0.05); Assert.AreEqual(corr[2, 0], 0.5, 0.05); Assert.AreEqual(corr[2, 1], 0.6, 0.05); }
public static void GenerateValues2(int howMany, double meanA, double meanB, double meanC, double[,] R) { var disitrubtion = new NormalDistribution(0, Math.Sqrt(1)); var mean = new double[] { disitrubtion.InverseDistributionFunction(meanA), disitrubtion.InverseDistributionFunction(meanB), disitrubtion.InverseDistributionFunction(meanC) }; var mnormaldist = new MultivariateNormalDistribution(mean, R); var samples = mnormaldist.Generate(howMany); var aSamples = new double[howMany]; var bSamples = new double[howMany]; var cSamples = new double[howMany]; for (int i = 0; i < samples.Length; i++) { aSamples[i] = samples[i][0] > 0 ? 1 : 0; bSamples[i] = samples[i][1] > 0 ? 1 : 0; cSamples[i] = samples[i][2] > 0 ? 1 : 0; } var resultCorrAb = CalculateCorrelation(aSamples, bSamples); var resultCorrAc = CalculateCorrelation(aSamples, cSamples); var resultCorrBc = CalculateCorrelation(bSamples, cSamples); }
private void btnGenerateRandom_Click(object sender, EventArgs e) { k = (int)numClusters.Value; // Generate data with n Gaussian distributions double[][][] data = new double[k][][]; for (int i = 0; i < k; i++) { // Create random centroid to place the Gaussian distribution var mean = Matrix.Random(2, -6.0, +6.0); // Create random covariance matrix for the distribution double[,] covariance; do { covariance = Matrix.Random(2, true, 0.0, 3.0); }while (!covariance.IsPositiveDefinite()); // Create the Gaussian distribution var gaussian = new MultivariateNormalDistribution(mean, covariance); int samples = Accord.Math.Tools.Random.Next(150, 250); data[i] = gaussian.Generate(samples); } // Join the generated data mixture = Matrix.Stack(data); // Update the scatterplot CreateScatterplot(graph, mixture, k); // Forget previous initialization kmeans = null; }
public void sequence_parsing_test() { #region doc_learn_fraud_analysis // Ensure results are reproducible Accord.Math.Random.Generator.Seed = 0; // Let's say we have the following data about credit card transactions, // where the data is organized in order of transaction, per credit card // holder. Everytime the "Time" column starts at zero, denotes that the // sequence of observations follow will correspond to transactions of the // same person: double[,] data = { // "Time", "V1", "V2", "V3", "V4", "V5", "Amount", "Fraud" { 0, 0.521, 0.124, 0.622, 15.2, 25.6, 2.70, 0 }, // first person, ok { 1, 0.121, 0.124, 0.822, 12.2, 25.6, 42.0, 0 }, // first person, ok { 0, 0.551, 0.124, 0.422, 17.5, 25.6, 20.0, 0 }, // second person, ok { 1, 0.136, 0.154, 0.322, 15.3, 25.6, 50.0, 0 }, // second person, ok { 2, 0.721, 0.240, 0.422, 12.2, 25.6, 100.0, 1 }, // second person, fraud! { 3, 0.222, 0.126, 0.722, 18.1, 25.8, 10.0, 0 }, // second person, ok }; // Transform the above data into a jagged matrix double[][][] input; int[][] states; transform(data, out input, out states); // Determine here the number of dimensions in the observations (in this case, 6) int observationDimensions = 6; // 6 columns: "V1", "V2", "V3", "V4", "V5", "Amount" // Create some prior distributions to help initialize our parameters var priorC = new WishartDistribution(dimension: observationDimensions, degreesOfFreedom: 10); // this 10 is just some random number, you might have to tune as if it was a hyperparameter var priorM = new MultivariateNormalDistribution(dimension: observationDimensions); // Configure the learning algorithms to train the sequence classifier var teacher = new MaximumLikelihoodLearning <MultivariateNormalDistribution, double[]>() { // Their emissions will be multivariate Normal distributions initialized using the prior distributions Emissions = (j) => new MultivariateNormalDistribution(mean: priorM.Generate(), covariance: priorC.Generate()), // We will prevent our covariance matrices from becoming degenerate by adding a small // regularization value to their diagonal until they become positive-definite again: FittingOptions = new NormalOptions() { Regularization = 1e-6 }, }; // Use the teacher to learn a new HMM var hmm = teacher.Learn(input, states); // Use the HMM to predict whether the transations were fradulent or not: int[] firstPerson = hmm.Decide(input[0]); // predict the first person, output should be: 0, 0 int[] secondPerson = hmm.Decide(input[1]); // predict the second person, output should be: 0, 0, 1, 0 #endregion Assert.AreEqual(new[] { 0, 0 }, firstPerson); Assert.AreEqual(new[] { 0, 0, 1, 0 }, secondPerson); }
/// <summary> /// Generates a random vector of observations from a distribution with the given parameters. /// </summary> /// /// <param name="samples">The number of samples to generate.</param> /// <param name="mean">The mean vector μ (mu) for the distribution.</param> /// <param name="covariance">The covariance matrix Σ (sigma) for the distribution.</param> /// /// <returns>A random vector of observations drawn from this distribution.</returns> /// public static double[][] Generate(int samples, double[] mean, double[,] covariance) { var normal = new MultivariateNormalDistribution(mean, covariance); return(normal.Generate(samples)); }
public void learn_pendigits_normalization() { #region doc_learn_pendigits // Ensure we get reproducible results Accord.Math.Random.Generator.Seed = 0; // Download the PENDIGITS dataset from UCI ML repository var pendigits = new Pendigits(path: Path.GetTempPath()); // Get and pre-process the training set double[][][] trainInputs = pendigits.Training.Item1; int[] trainOutputs = pendigits.Training.Item2; // Pre-process the digits so each of them is centered and scaled trainInputs = trainInputs.Apply(Accord.Statistics.Tools.ZScores); trainInputs = trainInputs.Apply((x) => x.Subtract(x.Min())); // make them positive // Create some prior distributions to help initialize our parameters var priorC = new WishartDistribution(dimension: 2, degreesOfFreedom: 5); var priorM = new MultivariateNormalDistribution(dimension: 2); // Create a template Markov classifier that we can use as a base for the HCRF var hmmc = new HiddenMarkovClassifier <MultivariateNormalDistribution, double[]>( classes: pendigits.NumberOfClasses, topology: new Forward(5), initial: (i, j) => new MultivariateNormalDistribution(mean: priorM.Generate(), covariance: priorC.Generate())); // Create a new learning algorithm for creating HCRFs var teacher = new HiddenQuasiNewtonLearning <double[]>() { Function = new MarkovMultivariateFunction(hmmc), MaxIterations = 10 }; // The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism) // Use the learning algorithm to create a classifier var hcrf = teacher.Learn(trainInputs, trainOutputs); // Compute predictions for the training set int[] trainPredicted = hcrf.Decide(trainInputs); // Check the performance of the classifier by comparing with the ground-truth: var m1 = new ConfusionMatrix(predicted: trainPredicted, expected: trainOutputs); double trainAcc = m1.Accuracy; // should be 0.89594053744997137 // Prepare the testing set double[][][] testInputs = pendigits.Testing.Item1; int[] testOutputs = pendigits.Testing.Item2; // Apply the same normalizations testInputs = testInputs.Apply(Accord.Statistics.Tools.ZScores); testInputs = testInputs.Apply((x) => x.Subtract(x.Min())); // make them positive // Compute predictions for the test set int[] testPredicted = hcrf.Decide(testInputs); // Check the performance of the classifier by comparing with the ground-truth: var m2 = new ConfusionMatrix(predicted: testPredicted, expected: testOutputs); double testAcc = m2.Accuracy; // should be 0.89594053744997137 #endregion Assert.AreEqual(0.89594053744997137, trainAcc, 1e-10); Assert.AreEqual(0.896050173472111, testAcc, 1e-10); }
public void learn_pendigits_normalization() { Console.WriteLine("Starting NormalQuasiNewtonHiddenLearningTest.learn_pendigits_normalization"); using (var travis = new KeepTravisAlive()) { #region doc_learn_pendigits // Ensure we get reproducible results Accord.Math.Random.Generator.Seed = 0; // Download the PENDIGITS dataset from UCI ML repository var pendigits = new Pendigits(path: Path.GetTempPath()); // Get and pre-process the training set double[][][] trainInputs = pendigits.Training.Item1; int[] trainOutputs = pendigits.Training.Item2; // Pre-process the digits so each of them is centered and scaled trainInputs = trainInputs.Apply(Accord.Statistics.Tools.ZScores); trainInputs = trainInputs.Apply((x) => x.Subtract(x.Min())); // make them positive // Create some prior distributions to help initialize our parameters var priorC = new WishartDistribution(dimension: 2, degreesOfFreedom: 5); var priorM = new MultivariateNormalDistribution(dimension: 2); // Create a new learning algorithm for creating continuous hidden Markov model classifiers var teacher1 = new HiddenMarkovClassifierLearning <MultivariateNormalDistribution, double[]>() { // This tells the generative algorithm how to train each of the component models. Note: The learning // algorithm is more efficient if all generic parameters are specified, including the fitting options Learner = (i) => new BaumWelchLearning <MultivariateNormalDistribution, double[], NormalOptions>() { Topology = new Forward(5), // Each model will have a forward topology with 5 states // Their emissions will be multivariate Normal distributions initialized using the prior distributions Emissions = (j) => new MultivariateNormalDistribution(mean: priorM.Generate(), covariance: priorC.Generate()), // We will train until the relative change in the average log-likelihood is less than 1e-6 between iterations Tolerance = 1e-6, MaxIterations = 1000, // or until we perform 1000 iterations (which is unlikely for this dataset) // We will prevent our covariance matrices from becoming degenerate by adding a small // regularization value to their diagonal until they become positive-definite again: FittingOptions = new NormalOptions() { Regularization = 1e-6 } } }; // The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization teacher1.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism) // Use the learning algorithm to create a classifier var hmmc = teacher1.Learn(trainInputs, trainOutputs); // Create a new learning algorithm for creating HCRFs var teacher2 = new HiddenQuasiNewtonLearning <double[]>() { Function = new MarkovMultivariateFunction(hmmc), MaxIterations = 10 }; // The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization teacher2.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism) // Use the learning algorithm to create a classifier var hcrf = teacher2.Learn(trainInputs, trainOutputs); // Compute predictions for the training set int[] trainPredicted = hcrf.Decide(trainInputs); // Check the performance of the classifier by comparing with the ground-truth: var m1 = new GeneralConfusionMatrix(predicted: trainPredicted, expected: trainOutputs); double trainAcc = m1.Accuracy; // should be 0.66523727844482561 // Prepare the testing set double[][][] testInputs = pendigits.Testing.Item1; int[] testOutputs = pendigits.Testing.Item2; // Apply the same normalizations testInputs = testInputs.Apply(Accord.Statistics.Tools.ZScores); testInputs = testInputs.Apply((x) => x.Subtract(x.Min())); // make them positive // Compute predictions for the test set int[] testPredicted = hcrf.Decide(testInputs); // Check the performance of the classifier by comparing with the ground-truth: var m2 = new GeneralConfusionMatrix(predicted: testPredicted, expected: testOutputs); double testAcc = m2.Accuracy; // should be 0.66506538564184681 #endregion Assert.AreEqual(0.66523727844482561, trainAcc, 1e-10); Assert.AreEqual(0.66506538564184681, testAcc, 1e-10); } }