FindHiddenMarkovStates

FindHiddenMarkovStates[data,hmm]

放出 data に対応するHiddenMarkovProcess hmm の最も可能性が高い隠れ状態を求める．

FindHiddenMarkovStates[data,hmm,crit]

与えられた基準 crit を使って隠れ状態を求める．

詳細

FindHiddenMarkovStatesは，隠れ状態デコーディングおよびViterbiデコーディングとしても知られている．
放出 data は，リストあるいはTemporalDataオブジェクトでよい．
FindHiddenMarkovStatesは，放出 data と同じ形式で隠れ状態経路を返す．data に複数の経路がある場合は，複数の状態経路が返される．
基準 crit の可能な値
"ViterbiDecoding" 隠れ状態列の最大尤度（デフォルト）

"PosteriorDecoding" 各時点における隠れ状態についての最大尤度
放出列を与えられると，"ViterbiDecoding"は状態列全体としての確率 $TemplateBox[{Probability, paclet:ref/Probability}, RefLink, BaseStyle -> {InlineFormula}][x(0)=i_0∧...∧x(n)=i_(n){y(0)=y_0,...,y(n)=y_(n)},...]$ を最大化する．これに対し，"PosteriorDecoding"は各時点における状態値の確率 $TemplateBox[{Probability, paclet:ref/Probability}, RefLink, BaseStyle -> {InlineFormula}][x(t)=i{y(0)=y_0,...,y(n)=y_(n)},...]$ を最大化する．

例題

すべて開くすべて閉じる

例 (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"]

連続放出の隠れマルコフ(Markov)過程を定義する：

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)

常にではないが不正直なカジノが，表が裏の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 -> {"状態1", "状態2"}]

おもちゃのロボットが，壁が灰色の正方形で表された4×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は硬出力，すなわち1つの経路のみを返す：

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]

この場合は，同程度の確率の2つの経路がある：

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)

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

その他のラーニングリソース

テクニカルサポート

Wolframソリューション

教育のためのWolframソリューション

使い始める

Grow Your Skills

Wolframと繋がる

大人用の教育プログラム

若者のための教育プログラム

読む

FindHiddenMarkovStates

詳細

例題

例 (1)

スコープ (7)

アプリケーション (3)

特性と関係 (3)

考えられる問題 (2)

テキスト

CMS

APA

BibTeX

BibLaTeX

	"ViterbiDecoding"	隠れ状態列の最大尤度（デフォルト）
	"PosteriorDecoding"	各時点における隠れ状態についての最大尤度

FindHiddenMarkovStates

詳細

例題

例 (1)

スコープ (7)

アプリケーション (3)

特性と関係 (3)

考えられる問題 (2)

関連項目

関連するガイド

履歴

テキスト

CMS

APA

BibTeX

BibLaTeX