Wolfram 语言与系统参考资料中心

FindHiddenMarkovStates

FindHiddenMarkovStates[data,hmm]

找出输出数据 data 对应的隐马尔可夫过程（HiddenMarkovProcess）hmm 的最大似然隐状态.

FindHiddenMarkovStates[data,hmm,crit]

按给定的准则 crit 来找出隐状态.

范例

打开所有单元关闭所有单元

基本范例 (1)

假设我们观察一枚公平硬币（状态 1）和一枚不公平硬币（状态 2）的输出：

Wolfram Language code: hmm = HiddenMarkovProcess[{0.8, 0.2}, {{0.8, 0.2}, {0.3, 0.7}}, {{0.5, 0.5}, {0.1, 0.9}}];

Wolfram Language code:

tosses = TemporalData[Automatic, {{{1, 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2}}, 
  {{0, 20, 1}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, 
  {ValueDimensions -> 1, MetaInformation -> {}}}, False, 10.];

从观察数据中找出硬币变化的最大似然序列：

Wolfram Language code: FindHiddenMarkovStates[tosses, hmm]

Wolfram Language code: BarChart[%, Ticks -> {Automatic, {{1, "Fair"}, {2, "Unfair"}}}]

范围 (7)

输入为列表时，FindHiddenMarkovStates 也把隐状态序列输出为列表：

Wolfram Language code:

hmm = HiddenMarkovProcess[{0.8, 0.2}, {{0.8, 0.2}, {0.3, 0.7}}, {ExponentialDistribution[1.1], ExponentialDistribution[0.3]}];

Wolfram Language code: FindHiddenMarkovStates[{0.3, 3.8, 3.2, 1.2, 0.8}, hmm]

对 TemporalData 形式的输入，输出也是和输入有同样类型的时间序列对象：

Wolfram Language code: ts = TimeSeries[{0.3, 3.8, 3.2, 1.2, 0.8}];

Wolfram Language code: FindHiddenMarkovStates[ts, hmm]

FindHiddenMarkovStates 映射到独立的路径上：

Wolfram Language code:

𝒫 = HiddenMarkovProcess[{0.3, 0.7}, {{0.5, 0.5}, {0.3, 0.7}}, {NormalDistribution[-0.1, 0.03], NormalDistribution[0.4, 0.05]}];

Wolfram Language code:

em1 = {0.3, -0.2, 0.1};
em2 = {0.1, 0.2, 0.3};

每个隐状态路径都是独立找到的：

Wolfram Language code: FindHiddenMarkovStates[{em1, em2}, 𝒫]

Wolfram Language code: {FindHiddenMarkovStates[em1, 𝒫], FindHiddenMarkovStates[em2, 𝒫]}

在一些输出结果含有未知数据时破译状态序列：

Wolfram Language code:

𝒫 = HiddenMarkovProcess[{1 / 2, 1 / 2}, {{0.7, 0.3}, {0.2, 0.8}}, {{1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6}, {1 / 10, 1 / 10, 1 / 10, 1 / 10, 1 / 10, 1 / 2}}];

Wolfram Language code: data = {6, 6, 6, 3, Missing[], Missing[], 5, 1, Missing[], 5, 4};

Wolfram Language code: FindHiddenMarkovStates[data, 𝒫]

为给定的观察序列破译隐状态：

Wolfram Language code:

hmm = HiddenMarkovProcess[{0.4, 0.3, 0.3}, {{0, 0.5, 0.5}, {0.4, 0, 0.6}, {0.55, 0.45, 0}}, {{0.7, 0.2, 0.1}, {0.2, 0.6, 0.2}, {0, 0.3, 0.7}}];

Wolfram Language code: obs = {1, 3, 2, 3, 3, 2, 2, 3, 2, 1, 2, 2, 3, 1, 2, 2};

用 Viterbi 破译来找出最大可能的序列：

Wolfram Language code: FindHiddenMarkovStates[obs, hmm, "ViterbiDecoding"]

用后验破译来找出独立的最大似然状态的序列：

Wolfram Language code: FindHiddenMarkovStates[obs, hmm, "PosteriorDecoding"]

用连续输出定义隐马尔可夫过程：

Wolfram Language code:

𝒫 = HiddenMarkovProcess[{0.3, 0.7}, {{0.5, 0.5}, {0.3, 0.7}}, {NormalDistribution[-1.2, 0.3], NormalDistribution[2.3, 0.5]}];

模拟这个过程，包括隐状态的值：

Wolfram Language code: data = RandomFunction[𝒫, {0, 20}, Method -> {"IncludeHiddenStates" -> True}]

对给定输出找出最大似然状态序列：

Wolfram Language code: stateseq = FindHiddenMarkovStates[data, 𝒫]

比较破译的状态和实际状态：

Wolfram Language code:

actualstates = data["HiddenStates"];
ArrayPlot[{stateseq["Values"], actualstates["Values"]}, Mesh -> All, ColorRules -> {1 -> White, 2 -> Black}]

给定多变量的输出，找出最大似然状态序列：

Wolfram Language code:

emdists = {BinormalDistribution[{1, 0}, {0.45, 0.45}, -0.4], BinormalDistribution[{0, -1}, {0.45, 0.45}, 0.4], BinormalDistribution[{-1, 0}, {0.45, 0.45}, -0.4], BinormalDistribution[{0, 1}, {0.45, 0.45}, 0.4]};

Wolfram Language code:

𝒫 = HiddenMarkovProcess[{0.25, 0.25, 0.25, 0.25}, {{0.4, 0.6, 0, 0}, {0.4, 0, 0.6, 0}, {0.4, 0, 0, 0.6}, {0, 0.9, 0.1, 0}}, emdists];

模拟它：

Wolfram Language code: data = RandomFunction[𝒫, {0, 23}, Method -> {Automatic, "IncludeHiddenStates" -> True}];

破译最大似然状态序列：

Wolfram Language code: estates = FindHiddenMarkovStates[data, 𝒫]

把结果和真实状态序列做比较：

Wolfram Language code:

actualstates = data["HiddenStates"];
ArrayPlot[{estates["Values"], actualstates["Values"]}, Mesh -> All]

定义隐状态和输出的联合对数似然：

Wolfram Language code:

jointLogLikelihood[states_, obs_] := LogLikelihood[DiscreteMarkovProcess[𝒫], states] + Sum[LogLikelihood[emdists[[k]], Pick[obs, states, k]], {k, 4}]

Viterbi 破译的状态序列有着和实际序列相等或更高的对数似然：

Wolfram Language code: jointLogLikelihood[estates["Values"], data["Values"]]

Wolfram Language code: jointLogLikelihood[actualstates["Values"], data["Values"]]

对有静默状态的过程破译状态序列：

Wolfram Language code:

tm = SparseArray[{{1, 2} -> 0.2, {1, 3} -> 0.8, {2, 3} -> 0.8, {2, 4} -> 0.1, {2, 2} -> 0.1, {3, 2} -> 0.3, {3, 4} -> 0.7, {4, 2} -> 0.9, {4, 5} -> 0.1, {5, 5} -> 1.}, {5, 5}];

Wolfram Language code: hmm = HiddenMarkovProcess[1, tm, {None, {0.4, 0.6, 0}, {0, 0, 0}, None, {0, 0, 1}}];

找出最大似然状态序列：

Wolfram Language code: FindHiddenMarkovStates[{1, 2, 1, 2, 2, 1, 3}, hmm]

突出显示序列中的输出状态：

Wolfram Language code: % /. {es : (2 | 5) :> Framed[es]}

应用 (3)

一个偶尔不诚实的赌场提供了一种硬币博彩游戏，用一枚正面朝上概率三倍于反面朝上的偏差硬币来进行不公平的欺诈行为. 已知赌场庄家会以 10% 的概率在公平与偏差硬币之间秘密的切换：

Wolfram Language code:

{fair, biased} = {1, 2};
tm = SparseArray[{{fair, fair} -> 9 / 10, {fair, biased} -> 1 / 10, {biased, fair} -> 1 / 10, {biased, biased} -> 9 / 10}];

得到正面或反面的概率：

Wolfram Language code:

fairCoin = {1 / 2, 1 / 2};
biasedCoin = {3 / 4, 1 / 4};

作为结果的隐马尔可夫过程，假设选哪个作为起始硬币的概率相等：

Wolfram Language code: UnfairCasinoHMM = HiddenMarkovProcess[{1 / 2, 1 / 2}, tm, {fairCoin, biasedCoin}];

给定一个抛掷结果的序列，猜测在哪些时间点庄家使用了有偏差的硬币：

Wolfram Language code:

tosses = TemporalData[Automatic, {{{1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 2, 
    2, 2, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 
    1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 1}}, {{0, 100, 1}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, 
  {ValueDimensions -> 1, MetaInformation -> {}}}, False, 10.];

Wolfram Language code: probableCoinTypes = FindHiddenMarkovStates[tosses, UnfairCasinoHMM];

Wolfram Language code: ListPlot[probableCoinTypes, Ticks -> {Automatic, {{1, "Fair"}, {2, "Biased"}}}]

可视化输出并颜色编码来显示隐状态序列：

Wolfram Language code:

emissions = {1.47, 1.94, 1.51, 1.97, 2.2, 2.4, 2.43, -1.37, 2.71, -0.69, 1.64, 2., 2.83, -1.45, -1.28, -1.67, -0.89, -1.16, -0.83, -1.55, -0.87};

定义随机过程并破译给定观察下的隐状态：

Wolfram Language code:

hmm = HiddenMarkovProcess[{0.3, 0.7}, {{0.5, 0.5}, {0.3, 0.7}}, {NormalDistribution[-1.2, 0.3], NormalDistribution[2.3, 0.5]}];

Wolfram Language code: states = FindHiddenMarkovStates[emissions, hmm]

根据破译的状态值对有时间标记的输出分组：

Wolfram Language code: empath = Normal[TimeSeries[emissions]];

Wolfram Language code:

ListPlot[{Pick[empath, states, 1], Pick[empath, states, 2]}, Filling -> Axis, PlotStyle -> PointSize[Medium], PlotLegends -> {"state 1", "state 2"}]

一个玩具机器人在一个 4×4 的网格上移动，灰色的方格表示墙而机器人不能离开此地图. 机器人在四个方向中随机选一个然后试图移动. 如果不能按选定的方向移动则它会停留在原来的位置：

Wolfram Language code:

map = {{Gray, Orange, Yellow, White}, {Brown, White, Orange, Gray}, {Orange, Gray, Brown, Yellow}, {Gray, Brown, Yellow, White}};

Wolfram Language code:

colors = DeleteCases[Union[Flatten[map]], Gray];
colorRules = Thread[colors -> Range[Length[colors]]];

找出机器人可以访问的方块：

Wolfram Language code:

v = pos@@@Position[map, Except[Gray | List], {2}];
vCoords = MapThread[Rule, {v, (v /. pos[i_, j_] :> {j - 1 / 2, 4 - i + 1 / 2})}];

计算允许的转移：

Wolfram Language code:

okQ[{from : Repeated[_, {2}], to : Repeated[(1 | 2 | 3 | 4), {2}]}] := Total[Abs[{to} - {from}]] == 1 && FreeQ[{map[[from]], map[[to]]}, Gray]
okQ[_] := False

Wolfram Language code: edges = Select[Tuples[Range[4], 4], okQ] /. {i1_, j1_, i2_, j2_} :> pos[i1, j1]pos[i2, j2];

把机器人的移动编码为一个图并覆盖展示在地图上：

Wolfram Language code: gr = Graph[v, edges, VertexCoordinates -> vCoords, EdgeShapeFunction -> "HalfUnfilledDoubleArrow"];

Wolfram Language code:

backgr = ArrayPlot[map, Mesh -> True, MeshStyle -> Directive[Thick, Black]];
Show[backgr, gr]

为底层的隐状态建立 DiscreteMarkovProcess：

Wolfram Language code:

adjm = AdjacencyMatrix[gr];
tm = adjm / 4 + DiagonalMatrix[1 - Total[adjm, {2}] / 4];
p0 = Normalize[ConstantArray[1, Length[tm]], Total];
dmp = DiscreteMarkovProcess[p0, tm];

机器人的光学感应器的精确度为 90%，当识别失败时会均匀选取用过的颜色：

Wolfram Language code: emPr[i_] := (9/10)UnitVector[4, i] + (1/10)Table[(1/4), {4}]

Wolfram Language code: em = v /. pos[i_, j_] :> emPr[Part[map, i, j] /. colorRules];

用隐马尔可夫过程对机器人光学感应器的读取过程建模：

Wolfram Language code: hmm = HiddenMarkovProcess[dmp, em];

对给定的感应器读取结果序列，用该模型找出机器人在地图上的最大似然动作：

Wolfram Language code:

measurements = {RGBColor[1, 0.5, 0], RGBColor[0.6, 0.4, 0.2], RGBColor[0.6, 0.4, 0.2], RGBColor[0.6, 0.4, 0.2], RGBColor[0.6, 0.4, 0.2], RGBColor[1, 1, 0], RGBColor[1, 1, 0], RGBColor[0.6, 0.4, 0.2], RGBColor[1, 0.5, 0], RGBColor[1, 1, 0], RGBColor[1, 0.5, 0], RGBColor[1, 0.5, 0], RGBColor[1, 0.5, 0], RGBColor[1, 0.5, 0], GrayLevel[1], GrayLevel[1]};

Wolfram Language code: tileseqVt = Part[v, FindHiddenMarkovStates[measurements /. colorRules, hmm]]

Wolfram Language code: tileseqPos = Part[v, FindHiddenMarkovStates[measurements /. colorRules, hmm, "PosteriorDecoding"]]

可视化用 "ViterbiDecoding" 和 "PosteriorDecoding" 准则破译的路径：

Wolfram Language code: {Show[backgr, HighlightGraph[gr, Subgraph[gr, tileseqVt]]], Show[backgr, HighlightGraph[gr, Subgraph[gr, tileseqPos]]]}

属性和关系 (3)

"ViterbiDecoding" 最大化状态和输出的联合对数似然：

Wolfram Language code:

hmm = HiddenMarkovProcess[{0.5, 0.5}, {{0.4, 0.6}, {0.3, 0.7}}, em = {{0.5, 0.5}, {0.2, 0.8}}];
obs = {2, 1, 2};

定义状态和输出的联合对数似然：

Wolfram Language code:

jointLogLikelihood[states_, emissions_] := LogLikelihood[DiscreteMarkovProcess[hmm], states] + Total[Log[MapThread[Part[em, #1, #2]&, {states, emissions}]]]

计算所有可能的状态路径：

Wolfram Language code: statepaths = Tuples[{1, 2}, 3];

计算所有路径组合的联合对数似然：

Wolfram Language code: loglikes = Table[jointLogLikelihood[stseq, obs], {stseq, statepaths}];

FindHiddenMarkovStates 返回有最大联合对数似然的状态路径：

Wolfram Language code: Part[statepaths, First@Ordering[loglikes, -1, Less]]

Wolfram Language code: FindHiddenMarkovStates[obs, hmm, "ViterbiDecoding"]

"PosteriorDecoding" 找出单独每个时间点的最大似然状态的序列：

Wolfram Language code:

dmp = DiscreteMarkovProcess[{0.5, 0.5}, {{0.4, 0.6}, {0.8, 0.2}}];
em = {{0.5, 0.5}, {0.2, 0.8}};

定义在时间点 0、1 和 2 的隐状态值的分布：

Wolfram Language code: slices = {s0, s1, s2}dmp[{0, 1, 2}];

定义给定隐状态值后输出的分布：

Wolfram Language code:

em𝒟s1 = EmpiricalDistribution[em[[1]] -> {1, 2}];
em𝒟s2 = EmpiricalDistribution[em[[2]] -> {1, 2}];

在时间点 0、1 和 2 的条件输出彼此独立：

Wolfram Language code: emConds1 = {e0s1, e1s1, e2s1}ProductDistribution[{em𝒟s1, 3}];

Wolfram Language code: emConds2 = {e0s2, e1s2, e2s2}ProductDistribution[{em𝒟s2, 3}];

定义时间点 0、1 和 2 的输出为状态值及条件输出值的函数：

Wolfram Language code:

emVec = {Boole[s0 == 1]e0s1 + Boole[s0 == 2]e0s2, Boole[s1 == 1]e1s1 + Boole[s1 == 2]e1s2, Boole[s2 == 1]e2s1 + Boole[s2 == 2]e2s2};

定义输出随机变量等于观测值这一条件：

Wolfram Language code: obs = {1, 1, 2};

Wolfram Language code: cond = Thread[emVec == obs];

找出每个时间点的最大似然状态的序列：

Wolfram Language code:

Table[ArgMax[{Probability[sv == kcond, {slices, emConds1, emConds2}], k == 1 || k == 2}, k, Integers], {sv, {s0, s1, s2}}]

与后验破译的结果作比较：

Wolfram Language code: hmm = HiddenMarkovProcess[dmp, em];

Wolfram Language code: FindHiddenMarkovStates[obs, hmm, "PosteriorDecoding"]

FindHiddenMarkovStates 返回确切的输出，即只有一条路径：

Wolfram Language code:

hmm = HiddenMarkovProcess[{33 / 302, 269 / 302}, {{82 / 203, 121 / 203}, {36 / 85, 49 / 85}}, em = {{15 / 17, 2 / 17}, {1893 / 2057, 164 / 2057}}];

Wolfram Language code: 𝒪 = {2, 2, 2};

Wolfram Language code: FindHiddenMarkovStates[𝒪, hmm]

在这种情况下存在两条等概率的路径：

Wolfram Language code:

ℒ[states_, obs_] := Fold[Times, Likelihood[DiscreteMarkovProcess[hmm], states], MapThread[Part[em, #1, #2]&, {states, obs}]]

Wolfram Language code: {ℒ[{2, 1, 1}, 𝒪], ℒ[{2, 1, 2}, 𝒪]}

完全的搜索表明只有这两条路径：

Wolfram Language code: 𝒮 = Tuples[{1, 2}, 3];

Wolfram Language code: Take[SortBy[{#, N@ℒ[#, 𝒪]}& /@ 𝒮, Last], -3]

可能存在的问题 (2)

若路径和给定的 HMM（隐马尔可夫模型）不一致则 FindHiddenMarkovStates 不求值：

Wolfram Language code: hmm = HiddenMarkovProcess[2, {{3 / 7, 4 / 7}, {3 / 8, 5 / 8}}, {GeometricDistribution[.2], PascalDistribution[8, .3]}];

Wolfram Language code: FindHiddenMarkovStates[{1, 2, 3}, hmm]

这个输出序列的似然为零：

Wolfram Language code: Likelihood[hmm, {1, 2, 3}]

"PosteriorDecoding" 的结果状态序列可能和状态拓扑不一致：

Wolfram Language code:

𝒫 = HiddenMarkovProcess[1, {{1 / 2, 0, 1 / 2}, {1 / 3, 1 / 3, 1 / 3}, {2 / 3, 1 / 3, 0}}, {{3 / 4, 1 / 4}, {1 / 3, 2 / 3}, {2 / 5, 3 / 5}}];

下列输出序列和隐马尔可夫过程一致：

Wolfram Language code:

𝒪 = {1, 1, 2, 2, 1, 1};
Likelihood[𝒫, 𝒪]

用后验破译寻找隐状态：

Wolfram Language code: states = FindHiddenMarkovStates[𝒪, 𝒫, "PosteriorDecoding"]

找到的状态序列和状态转移的模型不一致：

Wolfram Language code: Likelihood[DiscreteMarkovProcess[𝒫], states]

Top

更多学习资源

技术支持

数据科学、金融与商业

工程

科学与技术

教育科技

教育举措

开始

提高你的技能

与我们合作

成人教育计划

青少年教育计划

欢迎阅读

FindHiddenMarkovStates

更多信息

范例

基本范例 (1)

范围 (7)

应用 (3)

属性和关系 (3)

可能存在的问题 (2)

文本

CMS

APA

BibTeX

BibLaTeX

	"ViterbiDecoding"	隐状态序列的最大似然（默认）
	"PosteriorDecoding"	每个时间点隐状态的最大似然

FindHiddenMarkovStates

更多信息

范例

基本范例 (1)

范围 (7)

应用 (3)

属性和关系 (3)

可能存在的问题 (2)

参见

相关指南

历史

文本

CMS

APA

BibTeX

BibLaTeX