public void eLn_XisZero_NaNReturned() { var x = 0; var result = LogExtention.eLn(x); Assert.AreEqual(double.NaN, result); }
public void eLn_XisGreaterThanZero_LogXReturned() { var x = 1d; var result = LogExtention.eLn(x); Assert.AreEqual(0, result); }
public void eLnSum_YGreaterThanX_eLnSumReturned() { var x = 1d; var y = 2d; var result = LogExtention.eLnSum(x, y); Assert.AreEqual(y + LogExtention.eLn(1 + Math.Exp(x - y)), result); }
public void eLnSum_XGreaterThanY_eLnSumReturned() { var x = 2d; var y = 1d; var result = LogExtention.eLnSum(x, y); Assert.AreEqual(x + LogExtention.eLn(1 + Math.Exp(y - x)), result); }
private double GetWeightValue(int t, decimal[] weights) { var weight = 0.0; if (weights != null) { weight = (_parameters.Model.Normalized) ? LogExtention.eLn((double)weights[t]) : (double)weights[t]; } else { weight = (_parameters.Model.Normalized) ? 0 : 1; } return(weight); }
public double[][] Estimate(BasicEstimationParameters <TDistribution> parameters) { if (_alpha != null) { return(_alpha); } _alpha = new double[parameters.Observations.Count][]; _alpha[0] = new double[parameters.Model.N]; // Initialize for (var i = 0; i < parameters.Model.N; i++) { var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[i], parameters.Observations, 0); _alpha[0][i] = (parameters.Normalized) ? LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.Pi[i]), LogExtention.eLn(o)) : parameters.Model.Pi[i] * o; } // Induction for (var t = 1; t < parameters.Observations.Count; t++) { _alpha[t] = new double[parameters.Model.N]; for (var j = 0; j < parameters.Model.N; j++) { var sum = (parameters.Normalized) ? double.NaN : 0d; for (var i = 0; i < parameters.Model.N; i++) { if (parameters.Normalized) { sum = LogExtention.eLnSum(sum, LogExtention.eLnProduct(_alpha[t - 1][i], LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]))); } else { sum += _alpha[t - 1][i] * parameters.Model.TransitionProbabilityMatrix[i][j]; } } var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t); if (parameters.Normalized) { _alpha[t][j] = LogExtention.eLnProduct(sum, LogExtention.eLn(o)); } else { _alpha[t][j] = sum * o; } } } return(_alpha); }
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); }
public double[][,] Estimate(MixtureAdvancedEstimationParameters <TDistribution> parameters) { if (_gammaComponents != null) { return(_gammaComponents); } try { _gammaComponents = new double[parameters.Observations.Count][, ]; for (var t = 0; t < parameters.Observations.Count; t++) { _gammaComponents[t] = new double[parameters.Model.N, parameters.L]; for (var i = 0; i < parameters.Model.N; i++) { var d = parameters.Model.Emission[i] as Mixture <IMultivariateDistribution>; if (d != null) { for (var l = 0; l < parameters.L; l++) { //Emmision in our case are Mixture<T> var p = d.ProbabilityDensityFunction(l, parameters.Observations[t].Value); if (parameters.Normalized) { _gammaComponents[t][i, l] = LogExtention.eLnProduct(_gammaEstimator.Estimate(parameters)[t][i], LogExtention.eLn(p)); } else { _gammaComponents[t][i, l] = _gammaEstimator.Estimate(parameters)[t][i] * p; } } } } } } catch (Exception) { for (var t = 0; t < parameters.Observations.Count; t++) { if (Math.Round(_gammaComponents[t].Sum(), 5) > 1) { Debug.WriteLine("Mixture Gamma Components [{0}] : {1}", t, new Matrix(_gammaComponents[t])); throw new ApplicationException(string.Format("Mixture Sigma is greater than 1. [{0}] : {1} : {2}", t, new Matrix(_gammaComponents[t]), Math.Round(_gammaComponents[t].Sum(), 5))); } } throw; } return(_gammaComponents); }
public double[][] Estimate(BasicEstimationParameters <TDistribution> parameters) { if (_beta != null) { return(_beta); } var T = parameters.Observations.Count; try { _beta = new double[T][]; _beta[T - 1] = new double[parameters.Model.N]; for (var i = 0; i < parameters.Model.N; i++) { _beta[T - 1][i] = (parameters.Normalized) ? 0d : 1d; } for (var t = T - 2; t >= 0; t--) { _beta[t] = new double[parameters.Model.N]; for (var i = 0; i < parameters.Model.N; i++) { _beta[t][i] = (parameters.Normalized) ? double.NaN : 0d; for (var j = 0; j < parameters.Model.N; j++) { var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t + 1); if (parameters.Normalized) { _beta[t][i] = LogExtention.eLnSum(_beta[t][i], LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]), LogExtention.eLnProduct(LogExtention.eLn(o), _beta[t + 1][j]))); } else { _beta[t][i] += parameters.Model.TransitionProbabilityMatrix[i][j] * o * _beta[t + 1][j]; } } } } } catch (Exception) { for (var t = T - 2; t >= 0; t--) { for (var i = 0; i < parameters.Model.N; i++) { for (var j = 0; j < parameters.Model.N; j++) { Debug.WriteLine("[{0}][{1}] : beta : {2}", t, i, _beta[t][i]); } } } throw; } return(_beta); }
public double[][,] Estimate(AdvancedEstimationParameters <TDistribution> parameters) { if (_ksi != null) { return(_ksi); } var denominator = new double[parameters.Observations.Count]; for (var t = 0; t < parameters.Observations.Count - 1; t++) { denominator[t] = (parameters.Normalized) ? double.NaN : 0d; for (var i = 0; i < parameters.Model.N; i++) { for (var j = 0; j < parameters.Model.N; j++) { var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t + 1); if (parameters.Normalized) { denominator[t] = LogExtention.eLnSum(denominator[t], LogExtention.eLnProduct(parameters.Alpha[t][i], LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]), LogExtention.eLnProduct(parameters.Beta[t + 1][j], LogExtention.eLn(o))))); } else { denominator[t] += parameters.Alpha[t][i] * parameters.Model.TransitionProbabilityMatrix[i][j] * parameters.Beta[t + 1][j] * o; } } } } _ksi = new double[parameters.Observations.Count][, ]; for (var t = 0; t < parameters.Observations.Count - 1; t++) { _ksi[t] = new double[parameters.Model.N, parameters.Model.N]; for (var i = 0; i < parameters.Model.N; i++) { for (var j = 0; j < parameters.Model.N; j++) { var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t + 1); if (parameters.Normalized) { var nominator = LogExtention.eLnProduct(parameters.Alpha[t][i], LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]), LogExtention.eLnProduct(parameters.Beta[t + 1][j], LogExtention.eLn(o)))); _ksi[t][i, j] = LogExtention.eLnProduct(nominator, -denominator[t]); } else { var nominator = parameters.Alpha[t][i] * parameters.Model.TransitionProbabilityMatrix[i][j] * parameters.Beta[t + 1][j] * o; _ksi[t][i, j] = nominator / denominator[t]; } } } } return(_ksi); }
public List <IState> Run(IList <IObservation> observations, IList <IState> states, double[] startDistribution, double[][] transitionProbabilityMatrix, double[][] distributionWeights, IDistribution[][] distributions) { var N = states.Count; var T = observations.Count; var K = distributionWeights[0].Length; ComputationPath = new double[T][]; ReproducePath = new int[T][]; var mpp = new List <IState>(states.Count); // Initialize for the first observation ComputationPath[0] = new double[N]; ReproducePath[0] = new int[N]; mpp.Add(new State()); for (var i = 0; i < N; i++) { var sum = (Normalized) ? double.NaN : 0d; for (int k = 0; k < K; k++) { if (Normalized) { sum = LogExtention.eLnSum(sum, LogExtention.eLnProduct(LogExtention.eLn(distributionWeights[i][k]), LogExtention.eLn(GetProbability(distributions[i][k], observations, 0)))); } else { sum += distributionWeights[i][k] * GetProbability(distributions[i][k], observations, 0); } } if (Normalized) { ComputationPath[0][i] = LogExtention.eLnProduct(LogExtention.eLn(startDistribution[i]), sum); } else { ComputationPath[0][i] = startDistribution[i] * sum; } ReproducePath[0][i] = -1; } // Induction for (var t = 1; t < T; t++) { ComputationPath[t] = new double[N]; ReproducePath[t] = new int[N]; mpp.Add(new State()); for (var j = 0; j < N; j++) { // argmax + max var max = double.NegativeInfinity; //0; for (var i = 0; i < N; i++) { var value = (Normalized) ? LogExtention.eLnProduct(ComputationPath[t - 1][i], LogExtention.eLn(transitionProbabilityMatrix[i][j])) : ComputationPath[t - 1][i] * transitionProbabilityMatrix[i][j]; if (value > max) { max = value; ReproducePath[t][j] = i; } } var sum = (Normalized) ? double.NaN : 0d; for (var k = 0; k < K; k++) { if (Normalized) { sum = LogExtention.eLnSum(sum, LogExtention.eLnProduct(LogExtention.eLn(distributionWeights[j][k]), LogExtention.eLn(GetProbability(distributions[j][k], observations, 0)))); } else { sum += distributionWeights[j][k] * GetProbability(distributions[j][k], observations, 0); } } if (Normalized) { ComputationPath[t][j] = LogExtention.eLnProduct(max, sum); } else { ComputationPath[t][j] = max * sum; } } } // Calculate results (from first observation) mpp[T - 1] = states[GetMaximumDeltaValueStateIndex(ComputationPath[T - 1])]; for (var i = T - 2; i >= 0; i--) { mpp[i] = states[ReproducePath[i + 1][mpp[i + 1].Index]]; } return(mpp); }
public double[][] Estimate(AlphaBetaTransitionProbabiltyMatrixParameters <TDistribution> parameters) { if (_estimatedTransitionProbabilityMatrix != null) { return(_estimatedTransitionProbabilityMatrix); } var T = parameters.Observations.Length; _estimatedTransitionProbabilityMatrix = new double[parameters.Model.N][]; for (var i = 0; i < parameters.Model.N; i++) { _estimatedTransitionProbabilityMatrix[i] = new double[parameters.Model.N]; for (var j = 0; j < parameters.Model.N; j++) { double nominator = (parameters.Normalized) ? double.NaN : 0.0d, denominator = (parameters.Normalized) ? double.NaN : 0.0d; for (var t = 0; t < T - 1; t++) { var probability = parameters.Model.Emission[j].ProbabilityDensityFunction(parameters.Observations[t + 1]); if (parameters.Normalized) { nominator = LogExtention.eLnSum(nominator, LogExtention.eLnProduct(parameters.Weights[t], LogExtention.eLnProduct(parameters.Alpha[t][i], LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]), LogExtention.eLnProduct(LogExtention.eLn(probability), parameters.Beta[t + 1][j]))))); denominator = LogExtention.eLnSum(denominator, LogExtention.eLnProduct(parameters.Weights[t], LogExtention.eLnProduct(parameters.Alpha[t][i], parameters.Beta[t][j]))); } else { nominator += parameters.Weights[t] * parameters.Alpha[t][i] * parameters.Model.TransitionProbabilityMatrix[i][j] * probability * parameters.Beta[t + 1][j]; denominator += parameters.Weights[t] * parameters.Alpha[t][i] * parameters.Beta[t][j]; } } _estimatedTransitionProbabilityMatrix[i][j] = CalculateTransitionProbabilityMatrixEntry(nominator, denominator, parameters.Normalized); } } return(_estimatedTransitionProbabilityMatrix); }