public IPredictionResult Predict <TDistribution>(IHiddenMarkovModel <TDistribution> model, IPredictionRequest request) where TDistribution : IDistribution { if (!request.ValidateAlgorithmSpecificParameters()) { return(null); } var n = Convert.ToInt32(request.AlgorithmSpecificParameters["NumberOfSamplePoints"]); var k = Convert.ToInt32(request.AlgorithmSpecificParameters["NumberOfWinningPoints"]); //var ratios = GetMaximumChangeRatios(request.TrainingSet); //var candidates = CreateStartingPool(request.TestSet[0], n, ratios); /* do * { * //var winningCandidate = CalculateWinningCandidates(k, candidates, model); * //candidates = CreateCandidatePoolFromArray(winningCandidate, n, ratios); * } while (Continue(request, candidates));*/ var result = new PredictionResult() { Predicted = new double[1][] }; //result.Predicted[0] = GetBestProbabilityCandidate(candidates); return(result); }
public double RunForward <TEmmisionType>(IList <IObservation> observations, IHiddenMarkovModel <TEmmisionType> model) where TEmmisionType : IDistribution { var alphaEstimator = new AlphaEstimator <TEmmisionType>(); _alpha = alphaEstimator.Estimate(new BasicEstimationParameters <TEmmisionType> { Model = model, Observations = observations, Normalized = Normalized }); var T = observations.Count; var result = (Normalized) ? double.NaN : 0d; // Calculate results for (var i = 0; i < model.N; i++) { if (Normalized) { result = LogExtention.eLnSum(result, _alpha[T - 1][i]); } else { result += _alpha[T - 1][i]; } } return(result); }
public BaumWelch(IList <IObservation> observations, IHiddenMarkovModel <DiscreteDistribution> model, IList <IObservation> symbols) : base(model) { _currentModel = model; _observations = observations; _discreteSymbols = new double[_currentModel.M]; _discreteObservations = new double[_observations.Count]; for (var i = 0; i < _currentModel.M; i++) { _discreteSymbols[i] = symbols[i].Value[0]; } for (var i = 0; i < _observations.Count; i++) { _discreteObservations[i] = observations[i].Value[0]; } _estimatedEmissions = new DiscreteDistribution[_currentModel.N]; for (var i = 0; i < _currentModel.N; i++) { _estimatedEmissions[i] = new DiscreteDistribution(_discreteSymbols, _discreteObservations); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<DiscreteDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions); Normalized = model.Normalized; }
private double[] PredictNextValue <TDistribution>(IHiddenMarkovModel <TDistribution> model, IPredictionRequest request, double[][] trainingSet) where TDistribution : IDistribution { var N = trainingSet.Length; var K = trainingSet[0].Length; var result = new double[K]; var yesterday = trainingSet[N - 1]; var forwardBackward = new ForwardBackward(model.Normalized); var yesterdayLikelihood = forwardBackward.RunForward(Helper.Convert(new[] { yesterday }), model); Debug.WriteLine("Yesterday Likelihood : " + new Vector(yesterday) + " : " + yesterdayLikelihood + " "); var guessess = FindMostSimilarObservations(model, trainingSet, yesterdayLikelihood, request.Tolerance); var bestGuessPlace = FindBestGuess(request, guessess); var tomorrow = trainingSet[bestGuessPlace.PlaceInSequence + 1]; var mostSimilar = trainingSet[bestGuessPlace.PlaceInSequence]; for (var k = 0; k < K; k++) { if (bestGuessPlace.PlaceInSequence != trainingSet.Length) { result[k] = yesterday[k] + (tomorrow[k] - mostSimilar[k]); } } Debug.WriteLine("Predicted (for day " + N + ") : " + new Vector(result) + " : " + forwardBackward.RunForward(Helper.Convert(result), model)); return(result); }
/// <summary> /// Viterbi based prediction algorithm. For each observation in test set we perform following action : /// 1. Run Viterbi and find best state that generated last day observation /// 2. Prediction for next day is weighted average of means of predicting state emissions /// 3. Re-Train the model with new value added from training set /// 4. Return to step 1 /// </summary> /// <typeparam name="TDistribution"></typeparam> /// <param name="model"></param> /// <param name="request"></param> /// <returns></returns> public IPredictionResult Predict <TDistribution>(IHiddenMarkovModel <TDistribution> model, IPredictionRequest request) where TDistribution : IDistribution { NumberOfIterations = request.NumberOfTrainingIterations; LikelihoodTolerance = request.TrainingLikelihoodTolerance; var predictions = new PredictionResult { Predicted = new double[request.NumberOfDays][] }; var trainingSet = (double[][])request.TrainingSet.Clone(); for (int i = 0; i < request.NumberOfDays; i++) { var prediction = PredictNextValue(model, trainingSet); if (request.NumberOfDays > 1) { trainingSet = new double[request.TrainingSet.Length + i + 1][]; request.TrainingSet.CopyTo(trainingSet, 0); for (var j = 0; j < i + 1; j++) { trainingSet[request.TrainingSet.Length + j] = request.TestSet[j]; } var iterations = NumberOfIterations; ((IMachineLearningMultivariateModel)model).Train(trainingSet, iterations, LikelihoodTolerance); } predictions.Predicted[i] = prediction; } return(predictions); }
public IPredictionResult Predict <TDistribution>(IHiddenMarkovModel <TDistribution> model, IPredictionRequest request) where TDistribution : IDistribution { var trainingSet = (double[][])request.TrainingSet.Clone(); var predictions = new PredictionResult { Predicted = new double[request.NumberOfDays][] }; for (int i = 0; i < request.NumberOfDays; i++) { var prediction = PredictNextValue(model, request, trainingSet); if (request.NumberOfDays > 1) { trainingSet = new double[request.TrainingSet.Length + i + 1][]; request.TrainingSet.CopyTo(trainingSet, 0); for (var j = 0; j < i + 1; j++) { trainingSet[request.TrainingSet.Length + j] = request.TestSet[j]; } } predictions.Predicted[i] = prediction; } return(predictions); }
public ParameterEstimations(IHiddenMarkovModel <TDistribution> model, IList <IObservation> observations, double[][] alpha, double[][] beta) { _model = model; _observations = observations; _alpha = alpha; _beta = beta; }
public bool Equals(IHiddenMarkovModel <TDistribution> other) { if (!(VectorExtentions.EqualsTo(Pi, other.Pi) && TransitionProbabilityMatrix.EqualsTo(other.TransitionProbabilityMatrix) && N == other.N && M == other.M && Likelihood == other.Likelihood)) { return(false); } return(!Emission.Where((t, i) => !t.Equals(other.Emission[i])).Any()); }
public ViterbiEngine(IHiddenMarkovModel <S, T> model) { LatestViterbiStates = new List <ViterbiState <S, T> >() { ViterbiState <S, T> .InitialState() }; Model = model; }
public double HeuristicFunction <TDistribution>(double[] node, IHiddenMarkovModel <TDistribution> model) where TDistribution : IDistribution { //var arr = trainingSet.Concat(new []{ node }); var forwardBackward = new ForwardBackward(model.Normalized); var h = forwardBackward.RunForward(Helper.Convert(new[] { node }), model); return(h); }
/// <summary> /// Initializes a new instance of the <see cref="BaseRunningMarkovStatistics"/> class. /// </summary> /// /// <param name="model">The Markov model.</param> /// public BaseRunningMarkovStatistics(IHiddenMarkovModel model) { if (model == null) { throw new ArgumentNullException("model"); } current = new double[model.States]; }
private double[] PredictNextValue <TDistribution>(IHiddenMarkovModel <TDistribution> model, double[][] trainingSet) where TDistribution : IDistribution { var alg = new Viterbi(model.Normalized); var mpp = alg.Run(Helper.Convert(trainingSet), model.GetStates(), model.Pi, model.TransitionProbabilityMatrix, model.GetEmissions()); var emission = model.Emission[mpp[trainingSet.Length - 1].Index]; var prediction = CalculatePredictionValue(emission, trainingSet); return(prediction); }
public static IList <IState> GetStates <TDistribution>(this IHiddenMarkovModel <TDistribution> model) where TDistribution : IDistribution { var result = new List <IState>(); for (int n = 0; n < model.N; n++) { result.Add(new State(n, n.ToString())); } return(result); }
public static IDistribution[] GetEmissions <TDistribution>(this IHiddenMarkovModel <TDistribution> model) where TDistribution : IDistribution { var result = new IDistribution[model.N]; for (int n = 0; n < model.N; n++) { result[n] = model.Emission[n]; } return(result); }
public IHiddenMarkovModel <DiscreteDistribution> Run(int maxIterations, double likelihoodTolerance) { // Initialize responce object var forwardBackward = new ForwardBackward(Normalized); do { maxIterations--; if (!_estimatedModel.Likelihood.EqualsTo(0)) { _currentModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<DiscreteDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions); _currentModel.Normalized = Normalized; _currentModel.Likelihood = _estimatedModel.Likelihood; } // Run Forward-Backward procedure forwardBackward.RunForward(_observations, _currentModel); forwardBackward.RunBackward(_observations, _currentModel); var @params = new AdvancedEstimationParameters <DiscreteDistribution> { Alpha = forwardBackward.Alpha, Beta = forwardBackward.Beta, Observations = _observations, Model = _currentModel, Normalized = _currentModel.Normalized }; _gammaEstimator = new GammaEstimator <DiscreteDistribution>(); _ksiEstimator = new KsiEstimator <DiscreteDistribution>(); // Estimate transition probabilities and start distribution EstimatePi(_gammaEstimator.Estimate(@params)); EstimateTransitionProbabilityMatrix(_gammaEstimator.Estimate(@params), _ksiEstimator.Estimate(@params), null, _observations.Count); // Estimate Emmisions for (var j = 0; j < _currentModel.N; j++) { _estimatedEmissions[j] = (DiscreteDistribution)_estimatedEmissions[j].Evaluate(_discreteObservations, _discreteSymbols, _gammaEstimator.Estimate(@params).GetColumn(j), Normalized); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); _estimatedModel.Normalized = Normalized; _estimatedModel.Likelihood = forwardBackward.RunForward(_observations, _estimatedModel); _likelihoodDelta = Math.Abs(Math.Abs(_currentModel.Likelihood) - Math.Abs(_estimatedModel.Likelihood)); Debug.WriteLine("Iteration {3} , Current {0}, Estimate {1} Likelihood delta {2}", _currentModel.Likelihood, _estimatedModel.Likelihood, _likelihoodDelta, maxIterations); }while (_currentModel != _estimatedModel && maxIterations > 0 && _likelihoodDelta > likelihoodTolerance); return(_estimatedModel); }
public IPredictionResult Predict <TDistribution>(IHiddenMarkovModel <TDistribution> model, IPredictionRequest request) where TDistribution : IDistribution { var selectionMethod = new TournamentSelection(TournamentSize); var crossoverAlgorithm = new Crossover(CrossoverProbability); var mutationAlgorithm = new Mutator(MutationProbability); var evaluator = new HmmEvaluator <TDistribution>(model, new ForwardBackward(true)); var parameters = new GeneticSolverParameters { CrossOverProbability = CrossoverProbability, MutationProbability = MutationProbability, NumberOfGenerations = NumberOfGenerations, PopulationSize = request.NumberOfDays * 10, TournamentSize = TournamentSize }; var predictions = new PredictionResult { Predicted = new double[request.NumberOfDays][] }; var solver = new GeneticSolver(parameters, mutationAlgorithm, crossoverAlgorithm, evaluator, selectionMethod); var populationInitializer = new FromTimeSeriesRandomInitializer(request.TrainingSet); var population = populationInitializer.Initialize <decimal>(parameters.PopulationSize, request.NumberOfDays, MutationProbability); for (int i = 0; i < population.Count; i++) { var chromosome = population[i]; population[i].FintnessValue = evaluator.Evaluate(chromosome); } var result = solver.Solve(population); // Get best fitted chromosome var maximumFitness = result[0].FintnessValue; var solution = result[0]; foreach (var chromosome in result) { if (maximumFitness <= chromosome.FintnessValue) { solution = chromosome; maximumFitness = chromosome.FintnessValue; } } // Convert it to array for (int i = 0; i < solution.Representation.Length; i++) { predictions.Predicted[i] = Array.ConvertAll(solution.Representation[i].Representation, x => (double)Convert.ChangeType(x, typeof(double))); } return(predictions); }
public BaumWelchMultivariateDistribution(IList <IObservation> observations, IHiddenMarkovModel <IMultivariateDistribution> model) : base(model) { _currentModel = model; _observations = observations; _estimatedEmissions = new IMultivariateDistribution[model.N]; for (var i = 0; i < model.N; i++) { _estimatedEmissions[i] = new NormalDistribution(0); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <IMultivariateDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<IMultivariateDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions); Normalized = _estimatedModel.Normalized = model.Normalized; }
public BaumWelchMixtureDistribution(IList <IObservation> observations, IHiddenMarkovModel <Mixture <IMultivariateDistribution> > model) : base(model) { _observations = observations; _currentModel = model; _estimatedEmissions = new Mixture <IMultivariateDistribution> [_currentModel.N]; for (var i = 0; i < model.N; i++) { // BUG : Update emmisions from model. Don't create new ones. _estimatedEmissions[i] = new Mixture <IMultivariateDistribution>(model.Emission[0].Components.Length, model.Emission[0].Dimension); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> > { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions); Normalized = _estimatedModel.Normalized = model.Normalized; }
public double RunBackward <TEmmisionType>(IList <IObservation> observations, IHiddenMarkovModel <TEmmisionType> model) where TEmmisionType : IDistribution { var betaEstimator = new BetaEstimator <TEmmisionType>(); _beta = betaEstimator.Estimate(new BasicEstimationParameters <TEmmisionType> { Model = model, Observations = observations, Normalized = Normalized }); var result = (Normalized) ? double.NaN : 0d; for (var j = 0; j < model.N; j++) { if (Normalized) { result = LogExtention.eLnSum(result, LogExtention.eLnProduct(LogExtention.eLn(model.Pi[j]), _beta[1][j])); } else { result += model.Pi[j] * _beta[1][j]; } } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="BaseBaumWelchLearning"/> class. /// </summary> /// protected BaseBaumWelchLearning(IHiddenMarkovModel model) { this.convergence = new AbsoluteConvergence(); this.model = model; }
/// <summary> /// Initializes a new instance of the <see cref="BaseBaumWelchLearning"/> class. /// </summary> /// protected BaseBaumWelchLearning(IHiddenMarkovModel model) { this.model = model; }
public IHiddenMarkovModel <IMultivariateDistribution> Run(int maxIterations, double likelihoodTolerance) { // Initialize responce object var forwardBackward = new ForwardBackward(Normalized); do { maxIterations--; if (!_estimatedModel.Likelihood.EqualsTo(0)) { _currentModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <IMultivariateDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<IMultivariateDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions) { LogNormalized = _estimatedModel.LogNormalized }; _currentModel.Normalized = Normalized; _currentModel.Likelihood = _estimatedModel.Likelihood; } // Run Forward-Backward procedure forwardBackward.RunForward(_observations, _currentModel); forwardBackward.RunBackward(_observations, _currentModel); var @params = new AdvancedEstimationParameters <IMultivariateDistribution> { Alpha = forwardBackward.Alpha, Beta = forwardBackward.Beta, Observations = _observations, Model = _currentModel, Normalized = _currentModel.Normalized }; _gammaEstimator = new GammaEstimator <IMultivariateDistribution>(); _ksiEstimator = new KsiEstimator <IMultivariateDistribution>(); _muEstimator = new MuMultivariateEstimator <IMultivariateDistribution>(); _sigmaEstimator = new SigmaMultivariateEstimator <IMultivariateDistribution>(); EstimatePi(_gammaEstimator.Estimate(@params)); EstimateTransitionProbabilityMatrix(_gammaEstimator.Estimate(@params), _ksiEstimator.Estimate(@params), null, _observations.Count); // Estimate observation probabilities var muParams = new MuEstimationParameters <IMultivariateDistribution> { Gamma = _gammaEstimator.Estimate(@params), Model = _currentModel, Normalized = _currentModel.Normalized, Observations = _observations }; var muVector = _muEstimator.Estimate(muParams); var sigmaVector = _sigmaEstimator.Estimate(new SigmaEstimationParameters <IMultivariateDistribution, double[][]>(muParams) { Mean = muVector }); for (var n = 0; n < _currentModel.N; n++) { _estimatedEmissions[n] = new NormalDistribution(muVector[n], sigmaVector[n]); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <IMultivariateDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); _estimatedModel.Normalized = Normalized; _estimatedModel.Likelihood = forwardBackward.RunForward(_observations, _estimatedModel); _likelihoodDelta = Math.Abs(Math.Abs(_currentModel.Likelihood) - Math.Abs(_estimatedModel.Likelihood)); Debug.WriteLine("Iteration {3} , Current {0}, Estimate {1} Likelihood delta {2}", _currentModel.Likelihood, _estimatedModel.Likelihood, _likelihoodDelta, maxIterations); }while (_currentModel != _estimatedModel && maxIterations > 0 && _likelihoodDelta > likelihoodTolerance); return(_estimatedModel); }
public double[][] Search <TDistribution>(double[][] population, int k, int n, int numberOfIterations, MaximumChangeRatios ratios, IHiddenMarkovModel <TDistribution> model) where TDistribution : IDistribution { var current = ExpandCurrentPopulation(population, n, ratios.Down, ratios.Up);; for (var i = 0; i < numberOfIterations; i++) { var next = GenerateNextStagePopulation(current, k, n, ratios, model); current = next; } return(current); }
/** * Create a Fixed-Lag-Smoothing implementation, that sets up the required * persistent values. * * @param hmm * a hidden Markov model with S * S transition matrix <b>T</b> * @param d * d, the length of the lag for smoothing */ public FixedLagSmoothing(IHiddenMarkovModel hmm, int d) { this.hmm = hmm; this.d = d; initPersistent(); }
public double[][] GenerateNextStagePopulation <TDistribution>(double[][] current, int k, int n, MaximumChangeRatios ratios, IHiddenMarkovModel <TDistribution> model) where TDistribution : IDistribution { var dic = new SortedList <double, double[]>(); for (var j = 0; j < current.Length; j++) { var h = HeuristicFunction(current[j], model); if (dic.Count < k) { dic.Add(h, current[j]); } else { if (dic.Keys[dic.Count] < h) { dic.Remove(dic.Keys[dic.Count]); dic.Add(h, current[j]); } } } current = (from e in dic select e.Value).ToArray(); current = ExpandCurrentPopulation(current, n, ratios.Down, ratios.Up); return(current); }
private IList <ObservationWithLikelihood <double[]> > FindMostSimilarObservations <TDistribution>(IHiddenMarkovModel <TDistribution> model, double[][] trainingSet, double yesterdayLikelihood, double tolerance) where TDistribution : IDistribution { var N = trainingSet.Length; var guessess = new List <ObservationWithLikelihood <double[]> >(); var forwardBackward = new ForwardBackward(model.Normalized); for (var n = N - 2; n > 0; n--) { var x = Helper.Convert(new[] { trainingSet[n] }); var likelihood = forwardBackward.RunForward(x, model); //Debug.Write((new Vector(observations[n])).ToString() + " : " + likelihood + " " + Environment.NewLine); if (Math.Abs(yesterdayLikelihood) - tolerance < Math.Abs(likelihood) && Math.Abs(yesterdayLikelihood) + tolerance > Math.Abs(likelihood)) { guessess.Add(new ObservationWithLikelihood <double[]>() { LogLikelihood = likelihood, Observation = trainingSet[n], PlaceInSequence = n - 1 }); } } return(guessess); }
public IHiddenMarkovModel <Mixture <IMultivariateDistribution> > Run(int maxIterations, double likelihoodTolerance) { // Initialize responce object var forwardBackward = new ForwardBackward(Normalized); do { maxIterations--; if (!_estimatedModel.Likelihood.EqualsTo(0)) { _currentModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> > { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions) { LogNormalized = _estimatedModel.LogNormalized }; _currentModel.Normalized = Normalized; _currentModel.Likelihood = _estimatedModel.Likelihood; } // Run Forward-Backward procedure forwardBackward.RunForward(_observations, _currentModel); forwardBackward.RunBackward(_observations, _currentModel); // Calculate Gamma and Xi var @params = new MixtureSigmaEstimationParameters <Mixture <IMultivariateDistribution> > { Alpha = forwardBackward.Alpha, Beta = forwardBackward.Beta, Observations = _observations, Model = _currentModel, Normalized = _currentModel.Normalized, L = _currentModel.Emission[0].Components.Length }; _gammaEstimator = new GammaEstimator <Mixture <IMultivariateDistribution> >(); _ksiEstimator = new KsiEstimator <Mixture <IMultivariateDistribution> >(); var mixtureCoefficientsEstimator = new MixtureCoefficientsEstimator <Mixture <IMultivariateDistribution> >(); var mixtureMuEstimator = new MixtureMuEstimator <Mixture <IMultivariateDistribution> >(); // Mean var mixtureSigmaEstimator = new MixtureSigmaEstimator <Mixture <IMultivariateDistribution> >(); // Covariance var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >(); @params.Gamma = _gammaEstimator.Estimate(@params); @params.GammaComponents = mixtureGammaEstimator.Estimate(@params); EstimatePi(_gammaEstimator.Estimate(@params)); EstimateTransitionProbabilityMatrix(_gammaEstimator.Estimate(@params), _ksiEstimator.Estimate(@params), null, _observations.Count); for (var n = 0; n < _currentModel.N; n++) { var mixturesComponents = _currentModel.Emission[n].Coefficients.Length; var distributions = new IMultivariateDistribution[mixturesComponents]; // Calculate coefficients for state n var coefficients = mixtureCoefficientsEstimator.Estimate(@params)[n]; if (Normalized) { mixtureCoefficientsEstimator.Denormalize(); } @params.Mu = mixtureMuEstimator.Estimate(@params); for (var l = 0; l < mixturesComponents; l++) { distributions[l] = new NormalDistribution(mixtureMuEstimator.Estimate(@params)[n, l], mixtureSigmaEstimator.Estimate(@params)[n, l]); } _estimatedEmissions[n] = new Mixture <IMultivariateDistribution>(coefficients, distributions); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> > { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); _estimatedModel.Normalized = Normalized; _estimatedModel.Likelihood = forwardBackward.RunForward(_observations, _estimatedModel); _likelihoodDelta = Math.Abs(Math.Abs(_currentModel.Likelihood) - Math.Abs(_estimatedModel.Likelihood)); Debug.WriteLine("Iteration {3} , Current {0}, Estimate {1} Likelihood delta {2}", _currentModel.Likelihood, _estimatedModel.Likelihood, _likelihoodDelta, maxIterations); }while (_currentModel != _estimatedModel && maxIterations > 0 && _likelihoodDelta > likelihoodTolerance); return(_estimatedModel); }
public HmmEvaluator(IHiddenMarkovModel <TEmmisionType> model, IForwardBackward fitnessClaculator) { _fitnessClaculator = fitnessClaculator; _model = model; }
public HMMForwardBackward(IHiddenMarkovModel hmm) { this.hmm = hmm; }
public HMMForwardBackwardConstantSpace(IHiddenMarkovModel hmm) : base(hmm) { }
/// <summary> /// Initializes a new instance of the <see cref="BaumWelchLearningBase"/> class. /// </summary> /// protected BaumWelchLearningBase(IHiddenMarkovModel model) { this.model = model; }
/// <summary> /// Initializes a new instance of the <see cref="BaseBaumWelchLearning"/> class. /// </summary> /// protected BaseBaumWelchLearning(IHiddenMarkovModel model) { this.convergence = new AbsoluteConvergence(); this.model = model; }
/// <summary> /// Initializes a new instance of the <see cref="BaseRunningMarkovStatistics"/> class. /// </summary> /// /// <param name="model">The Markov model.</param> /// public BaseRunningMarkovStatistics(IHiddenMarkovModel model) { if (model == null) throw new ArgumentNullException("model"); current = new double[model.States]; }