如何在c#中更新隐马尔可夫模型的概率值？

using System;
using System.Collections.Generic;
using System.Linq;

namespace HMMExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 定义隐马尔可夫模型
            var states = new List<string> { "S1", "S2" };
            var observations = new List<string> { "O1", "O2", "O3" };
            var initialProbabilities = new Dictionary<string, double>
            {
                { "S1", 0.6 },
                { "S2", 0.4 }
            };
            var transitionProbabilities = new Dictionary<string, Dictionary<string, double>>
            {
                { "S1", new Dictionary<string, double> { { "S1", 0.7 }, { "S2", 0.3 } } },
                { "S2", new Dictionary<string, double> { { "S1", 0.4 }, { "S2", 0.6 } } }
            };
            var observationProbabilities = new Dictionary<string, Dictionary<string, double>>
            {
                { "S1", new Dictionary<string, double> { { "O1", 0.3 }, { "O2", 0.4 }, { "O3", 0.3 } } },
                { "S2", new Dictionary<string, double> { { "O1", 0.2 }, { "O2", 0.5 }, { "O3", 0.3 } } }
            };

            // 更新概率值
            var observationsSequence = new List<string> { "O1", "O2", "O3" };
            UpdateProbabilities(observationsSequence, states, observations, initialProbabilities, transitionProbabilities, observationProbabilities);

            // 输出更新后的概率值
            Console.WriteLine("Updated Initial Probabilities:");
            foreach (var state in initialProbabilities.Keys)
            {
                Console.WriteLine($"{state}: {initialProbabilities[state]}");
            }

            Console.WriteLine("Updated Transition Probabilities:");
            foreach (var state in transitionProbabilities.Keys)
            {
                foreach (var nextState in transitionProbabilities[state].Keys)
                {
                    Console.WriteLine($"{state} -> {nextState}: {transitionProbabilities[state][nextState]}");
                }
            }

            Console.WriteLine("Updated Observation Probabilities:");
            foreach (var state in observationProbabilities.Keys)
            {
                foreach (var observation in observationProbabilities[state].Keys)
                {
                    Console.WriteLine($"{state} -> {observation}: {observationProbabilities[state][observation]}");
                }
            }
        }

        static void UpdateProbabilities(List<string> observationsSequence, List<string> states, List<string> observations,
            Dictionary<string, double> initialProbabilities, Dictionary<string, Dictionary<string, double>> transitionProbabilities,
            Dictionary<string, Dictionary<string, double>> observationProbabilities)
        {
            // 计算前向概率
            var forwardProbabilities = new Dictionary<int, Dictionary<string, double>>();
            forwardProbabilities[0] = new Dictionary<string, double>();
            foreach (var state in states)
            {
                forwardProbabilities[0][state] = initialProbabilities[state] * observationProbabilities[state][observationsSequence[0]];
            }

            for (int t = 1; t < observationsSequence.Count; t++)
            {
                forwardProbabilities[t] = new Dictionary<string, double>();
                foreach (var state in states)
                {
                    forwardProbabilities[t][state] = observationsSequence.Select((_, i) =>
                        forwardProbabilities[t - 1][states[i]] * transitionProbabilities[states[i]][state])
                        .Sum() * observationProbabilities[state][observationsSequence[t]];
                }
            }

            // 计算后向概率
            var backwardProbabilities = new Dictionary<int, Dictionary<string, double>>();
            backwardProbabilities[observationsSequence.Count - 1] = new Dictionary<string, double>();
            foreach (var state in states)
            {
                backwardProbabilities[observationsSequence.Count - 1][state] = 1.0;
            }

            for (int t = observationsSequence.Count - 2; t >= 0; t--)
            {
                backwardProbabilities[t] = new Dictionary<string, double>();
                foreach (var state in states)
                {
                    backwardProbabilities[t][state] = states.Select((_, i) =>
                        transitionProbabilities[state][states[i]] * observationProbabilities[states[i]][observationsSequence[t + 1]] *
                        backwardProbabilities[t + 1][states[i]])
                        .Sum();
                }
            }

            // 计算每个时刻的状态概率
            var stateProbabilities = new Dictionary<int, Dictionary<string, double>>();
            for (int t = 0; t < observationsSequence.Count; t++)
            {
                stateProbabilities[t] = new Dictionary<string, double>();
                var denominator = states.Select((_, i) =>
                    forwardProbabilities[t][states[i]] * backwardProbabilities[t][states[i]])
                    .Sum();

                foreach (var state in states)
                {
                    stateProbabilities[t][state] = forwardProbabilities[t][state] * backwardProbabilities[t][state] / denominator;
                }
            }

            // 更新模型的初始概率、状态转移概率和观测概率
            foreach (var state in states)
            {
                initialProbabilities[state] = stateProbabilities[0][state];
            }

            for (int t = 0; t < observationsSequence.Count - 1; t++)
            {
                foreach (var state in states)
                {
                    foreach (var nextState in states)
                    {
                        var numerator = forwardProbabilities[t][state] * transitionProbabilities[state][nextState] *
                            observationProbabilities[nextState][observationsSequence[t + 1]] * backwardProbabilities[t + 1][nextState];
                        var denominator = states.Select((_, i) =>
                            forwardProbabilities[t][states[i]] * backwardProbabilities[t][states[i]])
                            .Sum();

                        transitionProbabilities[state][nextState] = numerator / denominator;
                    }
                }
            }

            for (int t = 0; t < observationsSequence.Count; t++)
            {
                foreach (var state in states)
                {
                    var numerator = forwardProbabilities[t][state] * backwardProbabilities[t][state];
                    var denominator = states.Select((_, i) =>
                        forwardProbabilities[t][states[i]] * backwardProbabilities[t][states[i]])
                        .Sum();

                    observationProbabilities[state][observationsSequence[t]] = numerator / denominator;
                }
            }
        }
    }
}