public void Predict_HMMMultivariateAndFTSESeriesLength20_Predicted20Days()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var test = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18));
var model = (HiddenMarkovModelMultivariateGaussianDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <IMultivariateDistribution>()
{
NumberOfStates = _NumberOfStates
});
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
var pred = new ViterbiBasedPredictor();
var request = new PredictionRequest {
TrainingSet = series, NumberOfDays = 20, TestSet = test
};
pred.NumberOfIterations = _NumberOfIterations;
pred.LikelihoodTolerance = _LikelihoodTolerance;
var predictions = pred.Predict(model, request);
Assert.AreEqual(20, predictions.Predicted.Length);
}
public void Initialize()
{
var util = new TestDataUtils();
// Create 2 Distributions
// Stock + Ema7, Stock + Ema28 => Data : Stock + Index
_observations = util.GetSvcData(util.MSFTFilePath, new DateTime(2011, 10, 7), new DateTime(2012, 3, 1));//SecurityDailyDataManager.GetRange("MSFT", new DateTime(2011, 10, 7), new DateTime(2012, 3, 1));
_observed = util.GetSvcData(util.MSFTFilePath, new DateTime(2012, 3, 2), new DateTime(2012, 3, 29));
var trainData1 = util.GetSvcData(util.MSFTFilePath, new DateTime(2010, 1, 1), new DateTime(2011, 1, 1));
var trainData2 = util.GetSvcData(util.MSFTFilePath, new DateTime(2009, 1, 1), new DateTime(2010, 1, 1));
var d0 = new NormalDistribution(4);
var likelihood0 = 0.0d;
_distributions[0] = (NormalDistribution)d0.Evaluate(trainData1, out likelihood0);
var d1 = new NormalDistribution(4);
var likelihood1 = 0.0d;
_distributions[1] = (NormalDistribution)d1.Evaluate(trainData2, out likelihood1);
for (var k = 0; k < K; k++)
{
_coefficients[k] = 1d / K;
}
}
public void Initialize()
{
var util = new TestDataUtils();
var msftData = util.GetSvcData(util.MSFTFilePath, new DateTime(2011, 10, 7), new DateTime(2012, 3, 1));
var intlData = util.GetSvcData(util.INTLFilePath, new DateTime(2011, 10, 7), new DateTime(2012, 3, 1));
//var msftData = SecurityDailyDataManager.GetRange("MSFT", new DateTime(2011, 10, 7), new DateTime(2012, 3, 1));
//var nasdaqData = SecurityDailyDataManager.GetRange("^IXIC", new DateTime(2011, 10, 7), new DateTime(2012, 3, 1));
_observations = new List <IObservation>();
_startDistribution = new double[K];
_tpm = new double[K][];
_mixtures = new Mixture <IMultivariateDistribution> [K];
_distributions = new NormalDistribution[K];
_states = new List <IState> {
new State(0, "Stock1"), new State(1, "Stock2")
};
for (var j = 0; j < K; j++)
{
_startDistribution[j] = 1d / K;
}
for (var j = 0; j < K; j++)
{
_tpm[j] = (double[])_startDistribution.Clone();
}
var x = new double[N][];
var y = new double[N][];
for (var i = 0; i < N; i++)
{
_observations.Add(new Observation(msftData[i], i.ToString()));
x[i] = msftData[i]; //new double[] { msftData[i].Open, msftData[i].Low, msftData[i].High, msftData[i].Close };
y[i] = intlData[i]; //new double[] { nasdaqData[i].Open, nasdaqData[i].Low, nasdaqData[i].High, nasdaqData[i].Close };
}
var likelihood = 0.0d;
var d = new NormalDistribution(4);
_distributions[0] = (NormalDistribution)d.Evaluate(x, out likelihood);
_distributions[1] = (NormalDistribution)d.Evaluate(y, out likelihood);
var m = new Mixture <NormalDistribution>(_startDistribution, _distributions);
_mixtures[0] = (Mixture <IMultivariateDistribution>)m.Evaluate(x, out likelihood);
_mixtures[1] = (Mixture <IMultivariateDistribution>)m.Evaluate(x, out likelihood);
}
public void Beta_ErgodicLogNormalized_BetaCalculated()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates, Emissions = CreateEmissions(observations, numberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStates, CreateEmissions(observations, numberOfStates)) { LogNormalized = true };
model.Normalized = true;
var estimator = new BetaEstimator <NormalDistribution>();
var beta = estimator.Estimate(new BasicEstimationParameters <NormalDistribution>()
{
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
});
Assert.IsNotNull(beta);
for (int i = 0; i < observations.Length - 1; i++)
{
for (int j = 0; j < numberOfStates; j++)
{
Assert.IsTrue(beta[i][j] < 0, string.Format("Failed Beta [{0}][{1}] : {2}", i, j, beta[i][j]));
}
}
// Last observation has probability == 1
Assert.IsTrue(beta[observations.Length - 1][0] == 0);
Assert.IsTrue(beta[observations.Length - 1][1] == 0);
}
public void Alpha_ErgodicAndNotNormalized_AlphaCalculated()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates, Emissions = CreateEmissions(observations, numberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStates, CreateEmissions(observations, numberOfStates)) { LogNormalized = true };
model.Normalized = false;
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
});
Assert.IsNotNull(alpha);
for (int i = 0; i < observations.Length; i++)
{
for (int j = 0; j < numberOfStates; j++)
{
Assert.IsTrue(alpha[i][j] > 0 && alpha[i][j] < 1, string.Format("Failed Alpha [{0}][{1}] : {2}", i, j, alpha[i][j]));
}
}
}
public void GammaComponents_ErgodicNotNormalized_EachEntryMatrixIsSummedToOne()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var estimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureAdvancedEstimationParameters <Mixture <IMultivariateDistribution> >
{
Alpha = alpha,
Beta = beta,
L = model.Emission[0].Components.Length,
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
var gammaComponents = estimator.Estimate(@params);
for (int t = 0; t < observations.Length; t++)
{
Assert.AreEqual(1.0d, Math.Round(gammaComponents[t].Sum(), 5), string.Format("Failed Gamma Components {0} at time {1}", new Matrix(gammaComponents[t]), t));
}
}
public void MixtureGammaEstimator_Parameters_MixtureGammaComponentsAndGammaInitialized()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var gamma = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureAdvancedEstimationParameters <Mixture <IMultivariateDistribution> >
{
Alpha = alpha,
Beta = beta,
L = model.Emission[0].Components.Length,
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
Assert.IsNotNull(gamma.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >));
Assert.IsNotNull(gamma.Estimate(@params));
}
public void Ksi_ErgodicNotNormalized_EachEntryMatrixIsSummedToOne()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
Model = model,
Normalized = model.Normalized
};
var estimator = new KsiEstimator <NormalDistribution>();
for (int t = 0; t < observations.Length - 1; t++)
{
Assert.AreEqual(1.0d, Math.Round(estimator.Estimate(@params)[t].Sum(), 5), string.Format("Failed Ksi [{1}] :{0}", new Matrix(estimator.Estimate(@params)[t]), t));
}
}
public void Search_OneNodeAndKis3AndNis10_3Nodes()
{
var util = new TestDataUtils();
var crf = new ChangeRatioFinder();
var search = new BeamLikeSearch();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var ratios = crf.GetMaximumChangeRatios(series);
var population = new double[1][]
{
series[series.Length]
};
var k = 3;
var n = 10;
var numberOfIterations = 10;
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfComponents = _NumberOfComponents, NumberOfStates = _NumberOfStates
});
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
var result = search.Search(population, k, n, numberOfIterations, ratios, model);
Assert.IsNull(result);
}
private void InitializeWeightsAndDistributionsMultivariate()
{
_distributionWeights = new double[_NumberOfStates][];
for (var i = 0; i < _NumberOfStates; i++)
{
_distributionWeights[i] = new double[_NumberOfDistributionsInState];
_distributionWeights[i][0] = 0.5;
_distributionWeights[i][1] = 0.5;
}
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var distributions = CreateEmissions(series, _NumberOfStates * _NumberOfDistributionsInState);
_distributions = new IMultivariateDistribution[_NumberOfStates][];
var index = 0;
for (int i = 0; i < _NumberOfStates; i++)
{
_distributions[i] = new IMultivariateDistribution[_NumberOfDistributionsInState];
for (int k = 0; k < _NumberOfDistributionsInState; k++)
{
_distributions[i][k] = distributions[index];
index++;
}
}
}
public void Gamma_RightLeftNotNormalized_EachEntryMatrixIsSummedToOne()
{
var delta = 3;
var numberOfStatesRightLeft = 4;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, numberOfStatesRightLeft)
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStatesRightLeft, delta, CreateEmissions(observations, numberOfStatesRightLeft)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
Model = model,
Normalized = model.Normalized
};
var estimator = new GammaEstimator <NormalDistribution>();
for (int i = 0; i < observations.Length; i++)
{
Assert.AreEqual(1.0d, Math.Round(estimator.Estimate(@params)[i].Sum(), 5), string.Format("Failed Gamma Component [{1}] : {0}", estimator.Estimate(@params)[i], i));
}
}
private void InitializeWeightsAndDistributionsMixture()
{
_distributionWeights = new double[_NumberOfStates][];
for (var i = 0; i < _NumberOfStates; i++)
{
_distributionWeights[i] = new double[_NumberOfDistributionsInState];
_distributionWeights[i][0] = 0.5;
_distributionWeights[i][1] = 0.5;
}
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var distributions = CreateEmissions(series, _NumberOfStates * _NumberOfComponents * _NumberOfDistributionsInState);
_distributions = new Mixture <IMultivariateDistribution> [_NumberOfStates][];
var index = 0;
for (int i = 0; i < _NumberOfStates; i++)
{
_distributions[i] = new Mixture <IMultivariateDistribution> [_NumberOfDistributionsInState];
for (int k = 0; k < _NumberOfDistributionsInState; k++)
{
_distributions[i][k] = new Mixture <IMultivariateDistribution>(_NumberOfComponents, series[0].Length);
for (int j = 0; j < _NumberOfComponents; j++)
{
((Mixture <IMultivariateDistribution>)_distributions[i][k]).Components[j] = distributions[index];
index++;
}
}
}
}
public void HiddenMarkovModelMultivariateGaussianDistribution_ModelState_ModelCreated()
{
var pi = new double[NumberOfStates] {
0.5, 0.5
};
var tpm = new double[NumberOfStates][] { new [] { 0.5, 0.5 }, new [] { 0.5, 0.5 } };
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var emissions = CreateEmissions(series, NumberOfStates);
var model = HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <IMultivariateDistribution>()
{
Pi = pi, TransitionProbabilityMatrix = tpm, Emissions = emissions
}); //new HiddenMarkovModelMultivariateGaussianDistribution(pi, tpm, emissions);
Assert.AreEqual(ModelType.Ergodic, model.Type);
Assert.AreEqual(NumberOfStates, model.N);
Assert.IsFalse(model.Normalized);
for (int n = 0; n < NumberOfStates; n++)
{
Assert.AreEqual(0.5, model.Pi[n]);
Assert.IsNotNull(model.Emission[n]);
Assert.IsInstanceOfType(model.Emission[n], typeof(NormalDistribution));
for (int i = 0; i < NumberOfStates; i++)
{
Assert.AreEqual(0.5, model.TransitionProbabilityMatrix[n][i]);
}
}
}
public void Predict_FTSESeriesAndRightLeftModelAnd20DaysTestSequence_PredictionResult()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var test = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18));
var model = (HiddenMarkovModelMultivariateGaussianDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <IMultivariateDistribution>()
{
NumberOfStates = NumberOfStatesRightLeft, Delta = Delta
}); //new HiddenMarkovModelMultivariateGaussianDistribution(NumberOfStatesRightLeft, Delta) { LogNormalized = true };
model.Normalized = true;
model.Train(series, NumberOfIterations, LikelihoodTolerance);
var result = model.Predict(PredictorType.HmmLikelihood, series, test, null, 20);
Assert.IsNotNull(result);
Assert.AreEqual(20, result.Predicted.Length);
}
public static void Initializer(TestContext context)
{
if (_trainingSet == null)
{
var util = new TestDataUtils();
_trainingSet = util.GetSvcData(util.GOOGFilePath, new DateTime(2011, 01, 01), new DateTime(2012, 01, 01));
_testSet = util.GetSvcData(util.GOOGFilePath, new DateTime(2012, 01, 01), new DateTime(2013, 04, 05));
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, NumberOfComponents = NumberOfComponents
}); //new HiddenMarkovModelMixtureDistribution(NumberOfComponents, NumberOfStates) { LogNormalized = true };
model.Normalized = true;
model.Train(_trainingSet, NumberOfIterations, LikelihoodTolerance);
var result = model.Predict(PredictorType.HmmLikelihood, _trainingSet, _testSet, _testSet.Length, NumberOfIterations, LikelihoodTolerance);
_predictionSet = result.Predicted;
}
}
public void Predict_EURUSDSeriesAndErgodicModelAnd31DaysTestSequence_PredictionResult()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.EURUSDFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var test = util.GetSvcData(util.EURUSDFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18));
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfComponents = _NumberOfComponents, NumberOfStates = _NumberOfStates
});
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
var result = model.Predict(PredictorType.HmmLikelihood, series, test, 31, _NumberOfIterations, _LikelihoodTolerance);
Assert.IsNotNull(result);
Assert.AreEqual(31, result.Predicted.Length);
}
public void EvaluatePrediction_FTSESeriesAndRightLeftModelAnd20DaysTestSequence_PredictionEvaluated()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var test = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18));
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfComponents = _NumberOfComponents, NumberOfStates = _NumberOfStatesRightLeft, Delta = _Delta
}); //new HiddenMarkovModelMixtureDistribution(NumberOfComponents, NumberOfStatesRightLeft, Delta) { LogNormalized = true };
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
var result = model.Predict(PredictorType.HmmLikelihood, series, test, 20, _NumberOfIterations, _LikelihoodTolerance);
var mape = model.EvaluatePrediction(result, test);
Assert.IsNotNull(mape);
Assert.AreEqual(4, mape.MeanAbsolutePercentError.Length);
}
public void TestInitialized()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = true;
}
public void Sigma_ErgodicAndObservationAndLogNormalized_SigmaCalculated()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var sequence = Helper.Convert(observations);
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = sequence, Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = sequence,
Model = model
};
var gammaEstimator = new GammaEstimator <NormalDistribution>();
var muEstimator = new MuMultivariateEstimator <NormalDistribution>();
var estimator = new SigmaMultivariateEstimator <NormalDistribution>();
var muParams = new MuEstimationParameters <NormalDistribution>
{
Gamma = gammaEstimator.Estimate(@params),
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
Assert.IsNotNull(estimator);
var sigma = estimator.Estimate(new SigmaEstimationParameters <NormalDistribution, double[][]>(muParams)
{
Mean = muEstimator.Estimate(muParams)
});
for (int n = 0; n < NumberOfStates; n++)
{
for (int i = 0; i < sequence[0].Dimention; i++)
{
for (int j = 0; j < sequence[0].Dimention; j++)
{
Assert.IsTrue(sigma[n][i, j] > 0, string.Format("Failed Sigma {0}", sigma[n][i, j]));
}
}
}
}
public void Solve_InitialPopulationFromTimeSeriesAndTrainedHmmEvaluator_SolvedPopulation()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.GOOGFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var test = util.GetSvcData(util.GOOGFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18));
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfComponents = NumberOfComponents, NumberOfStates = NumberOfStates
});
model.Normalized = true;
model.Train(series, NumberOfIterations, LikelihoodTolerance);
var selectionMethod = new TournamentSelection(TournamentSize);
var crossoverAlgorithm = new Crossover(CrossoverProbability);
var mutationAlgorithm = new Mutator(MutationProbability);
var evaluator = new HmmEvaluator <Mixture <IMultivariateDistribution> >(model, new ForwardBackward(true));
var parameters = new GeneticSolverParameters
{
CrossOverProbability = CrossoverProbability,
MutationProbability = MutationProbability,
NumberOfGenerations = 10,
PopulationSize = PopulationSize,
TournamentSize = TournamentSize
};
var populationInitializer = new FromTimeSeriesRandomInitializer(series);
var population = populationInitializer.Initialize <decimal>(parameters.PopulationSize, test.Length, MutationProbability);
for (int i = 0; i < population.Count; i++)
{
var chromosome = population[i];
population[i].FintnessValue = evaluator.Evaluate(chromosome);
}
var solver = new GeneticSolver(parameters, mutationAlgorithm, crossoverAlgorithm, evaluator, selectionMethod);
var result = solver.Solve(population);
Assert.AreEqual(result.Count, parameters.PopulationSize);
}
public void Evaluate_HMMMultivariateAndFTSESeriesLength20_ErrorEstimatorCalculated()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var test = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18));
var model = (HiddenMarkovModelMultivariateGaussianDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <IMultivariateDistribution>()
{
NumberOfStates = _NumberOfStates
});
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
var pred = new ViterbiBasedPredictor();
var request = new PredictionRequest {
TrainingSet = series, NumberOfDays = 20, TestSet = test
};
pred.NumberOfIterations = _NumberOfIterations;
pred.LikelihoodTolerance = _LikelihoodTolerance;
var predictions = pred.Predict(model, request);
var errorRequest = new EvaluationRequest
{
EstimatorType = ErrorEstimatorType.Value,
PredictionParameters = request,
PredictionToEvaluate = predictions
};
var errorEstimation = pred.Evaluate(errorRequest);
for (int i = 0; i < series[0].Length; i++)
{
Assert.IsTrue(errorEstimation.CumulativeForecastError[i] > 0);
Assert.IsTrue(errorEstimation.MeanAbsoluteDeviation[i] > 0);
Assert.IsTrue(errorEstimation.MeanAbsolutePercentError[i] > 0);
Assert.IsTrue(errorEstimation.MeanError[i] > 0);
Assert.IsTrue(errorEstimation.MeanSquaredError[i] > 0);
Assert.IsTrue(errorEstimation.RootMeanSquaredError[i] > 0);
}
}
public void Sigma_RightLeftAndParametersAnnNotNormalized_SigmaCalculated()
{
var delta = 3;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, NumberOfStatesRightLeft, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStatesRightLeft, delta, CreateEmissions(observations, NumberOfStatesRightLeft, NumberOfComponents)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var parameters = new ParameterEstimations <Mixture <IMultivariateDistribution> >(model, Helper.Convert(observations), alpha, beta);
var sigma = new MixtureSigmaEstimator <Mixture <IMultivariateDistribution> >();
var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var mixtureMuEstimator = new MixtureMuEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureSigmaEstimationParameters <Mixture <IMultivariateDistribution> >
{
Model = model,
Normalized = model.Normalized,
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
L = model.Emission[0].Components.Length
};
var gamma = mixtureGammaEstimator.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >);
var gammaComponens = mixtureGammaEstimator.Estimate(@params);
@params.Gamma = gamma;
@params.GammaComponents = gammaComponens;
@params.Mu = mixtureMuEstimator.Estimate(@params);
for (int i = 0; i < NumberOfStatesRightLeft; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
for (int rows = 0; rows < parameters.Observation[0].Dimention; rows++)
{
for (int cols = 0; cols < parameters.Observation[0].Dimention; cols++)
{
Assert.IsTrue(sigma.Estimate(@params)[i, l][rows, cols] > 0, string.Format("Failed Sigma {0}", sigma.Estimate(@params)[i, l][rows, cols]));
}
}
}
}
}
public void Estimate_KsiGammaParameters_TransitionProbabilityMatrixCalculatedAndReturned()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates, Emissions = CreateEmissions(observations, numberOfStates)
});
model.Normalized = true;
var observationsList = new List <IObservation>();
for (var i = 0; i < observations.Length; i++)
{
observationsList.Add(new Observation(observations[i], i.ToString()));
}
var baseEstimator = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseEstimator);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseEstimator);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = observationsList,
Model = model,
Normalized = model.Normalized
};
var gammaEstimator = new GammaEstimator <NormalDistribution>();
var ksiEstimator = new KsiEstimator <NormalDistribution>();
var gamma = gammaEstimator.Estimate(@params);
var ksi = ksiEstimator.Estimate(@params);
var estimator = new TransitionProbabilityEstimator <NormalDistribution>();
var parameters = new KsiGammaTransitionProbabilityMatrixParameters <NormalDistribution>
{
Model = model,
Ksi = ksi,
Gamma = gamma,
T = observations.Length,
Normalized = model.Normalized
};
var estimatedTransitionProbabilityMatrix = estimator.Estimate(parameters);
Assert.AreEqual(1d, Math.Round(estimatedTransitionProbabilityMatrix[0][0] + estimatedTransitionProbabilityMatrix[0][1], 5));
Assert.AreEqual(1d, Math.Round(estimatedTransitionProbabilityMatrix[1][0] + estimatedTransitionProbabilityMatrix[1][1], 5));
}
public void Denormalized_NormalizedEstimator_SigmaDenormalized()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var parameters = new ParameterEstimations <Mixture <IMultivariateDistribution> >(model, Helper.Convert(observations), alpha, beta);
var coefficients = new MixtureCoefficientsEstimator <Mixture <IMultivariateDistribution> >();
var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureCoefficientEstimationParameters <Mixture <IMultivariateDistribution> >
{
Model = model,
Normalized = model.Normalized,
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
L = model.Emission[0].Components.Length
};
var gamma = mixtureGammaEstimator.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >);
var gammaComponens = mixtureGammaEstimator.Estimate(@params);
@params.Gamma = gamma;
@params.GammaComponents = gammaComponens;
for (int i = 0; i < NumberOfStates; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
Assert.IsTrue(coefficients.Estimate(@params)[i][l] < 0, string.Format("Failed Coefficients {0}", coefficients.Estimate(@params)[i][l]));
}
}
coefficients.Denormalize();
for (int i = 0; i < NumberOfStates; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
Assert.IsTrue(coefficients.Estimate(@params)[i][l] > 0 && coefficients.Estimate(@params)[i][l] < 1, string.Format("Failed Coefficients {0}", coefficients.Estimate(@params)[i][l]));
}
}
}
public void Initialize()
{
var util = new TestDataUtils();
var up = util.GetSvcData(util.Sp500FilePath, new DateTime(2009, 9, 1), new DateTime(2010, 1, 1));
var down = util.GetSvcData(util.Sp500FilePath, new DateTime(2010, 4, 20), new DateTime(2010, 7, 1));
var treading = util.GetSvcData(util.Sp500FilePath, new DateTime(2011, 3, 1), new DateTime(2011, 6, 1));
_startDistribution = new double[K];
_tpm = new double[K][];
_emissions = new IMultivariateDistribution[K];
// Train Distribution
var trainer = new NormalDistribution(4);
double likelihood;
_emissions[0] = (NormalDistribution)trainer.Evaluate(up, out likelihood);
_emissions[1] = (NormalDistribution)trainer.Evaluate(down, out likelihood);
_emissions[2] = (NormalDistribution)trainer.Evaluate(treading, out likelihood);
// Train Start Distribution
for (var j = 0; j < K; j++)
{
_startDistribution[j] = 1d / K;
}
// Train Transition Probability Matrix
for (var j = 0; j < K; j++)
{
_tpm[j] = (double[])_startDistribution.Clone();
}
var arr = util.GetSvcData(util.Sp500FilePath, new DateTime(2012, 1, 1), new DateTime(2012, 2, 1));
_observations = new List <IObservation>();
for (var i = 0; i < N; i++)
{
_observations.Add(new Observation(arr[i], i.ToString()));
}
}
public void SigmaEstimator_ModelAndObservations_SigmaEstimatorCreated()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = true;
var estimator = new SigmaMultivariateEstimator <NormalDistribution>();
Assert.IsNotNull(estimator);
}
public void CreateClusters_FTSEObservations_4Clusters()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var algo = new KMeans();
algo.CreateClusters(series, 4, 200, InitialClusterSelectionMethod.Random);
Assert.AreEqual(4, algo.Clusters.Count);
for (int i = 0; i < algo.Clusters.Count; i++)
{
Assert.IsTrue(algo.Clusters[i].Length > 0);
}
}
public void Mu_MultivariateAndRightLeftAndNotNormalized_MuCalculated()
{
var delta = 3;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var sequence = Helper.Convert(observations);
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, NumberOfStatesRightLeft)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStatesRightLeft, delta, CreateEmissions(observations, NumberOfStatesRightLeft)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = sequence, Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = sequence,
Model = model
};
var gammaEstimator = new GammaEstimator <NormalDistribution>();
var estimator = new MuMultivariateEstimator <NormalDistribution>();
var muParams = new MuEstimationParameters <NormalDistribution>
{
Gamma = gammaEstimator.Estimate(@params),
Model = model,
Normalized = model.Normalized,
Observations = sequence
};
Assert.IsNotNull(estimator);
var mu = estimator.Estimate(muParams);
for (int i = 0; i < NumberOfStatesRightLeft; i++)
{
for (int j = 0; j < sequence[0].Dimention; j++)
{
Assert.IsTrue(mu[i][j] > 0, string.Format("Failed Mu {0}", mu[i][j]));
}
}
}
public void Train_FTSESeriesAndRightLeftAndLogNormalized_TrainedModel()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfComponents = _NumberOfComponents, NumberOfStates = _NumberOfStatesRightLeft, Delta = _Delta
}); //new HiddenMarkovModelMixtureDistribution(NumberOfComponents, NumberOfStatesRightLeft, Delta);
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
Assert.AreEqual(ModelType.LeftRight, model.Type);
Assert.AreEqual(_NumberOfStatesRightLeft, model.Emission.Length);
}
public void Predict_FTSESeriesAndLeftRightModel_PredictionResult()
{
var util = new TestDataUtils();
var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var model = (HiddenMarkovModelMixtureDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfComponents = _NumberOfComponents, NumberOfStates = _NumberOfStatesRightLeft, Delta = _Delta
}); //new HiddenMarkovModelMixtureDistribution(NumberOfComponents, NumberOfStatesRightLeft, Delta) { LogNormalized = true };
model.Normalized = true;
model.Train(series, _NumberOfIterations, _LikelihoodTolerance);
var result = model.Predict(PredictorType.HmmLikelihood, series, _NumberOfIterations, _LikelihoodTolerance);
Assert.IsNotNull(result);
}
