Admin: Created page with " '''Viterbi algorithm''' is a dynamic programming algorithm for finding the most likely sequence of hidden states—called the '''Vit..."

2019-08-23T10:18:29Z

Created page with "<amp/> '''Viterbi algorithm''' is a dynamic programming algorithm for finding the most likely sequence of hidden states—called the '''Vit..."

New page

<amp/>
'''Viterbi algorithm''' is a [[dynamic programming]] [[algorithm]] for finding the most [[likelihood function|likely]] sequence of hidden states—called the '''Viterbi path'''—that results in a sequence of observed events, especially in the context of [[Markov information source]]s and [[hidden Markov model]]s.

The algorithm has found universal application in decoding the [[convolutional code]]s used in both [[CDMA]] and [[GSM]] digital cellular, [[dial-up]] modems, satellite, deep-space communications, and [[802.11]] wireless LANs. It is now also commonly used in [[speech recognition]], [[speech synthesis]], [[diarization]], [[keyword spotting]], [[computational linguistics]], and [[bioinformatics]]. For example, in [[speech-to-text]] (speech recognition), the acoustic signal is treated as the observed sequence of events, and a string of text is considered to be the "hidden cause" of the acoustic signal. The Viterbi algorithm finds the most likely string of text given the acoustic signal.

==History==
The Viterbi algorithm is named after [[Andrew Viterbi]], who proposed it in 1967 as a decoding algorithm for [[Convolution code|convolutional codes]] over noisy digital communication links. It has, however, a history of [[multiple invention]], with at least seven independent discoveries, including those by Viterbi, [[Needleman–Wunsch algorithm|Needleman and Wunsch]], and [[Wagner–Fischer algorithm|Wagner and Fischer]].

"Viterbi path" and "Viterbi algorithm" have become standard terms for the application of dynamic programming algorithms to maximization problems involving probabilities.

==Extensions==
A generalization of the Viterbi algorithm, termed the ''max-sum algorithm'' (or ''max-product algorithm'') can be used to find the most likely assignment of all or some subset of [[latent variable]]s in a large number of [[graphical model]]s, e.g. [[Bayesian network]]s, [[Markov random field]]s and [[conditional random field]]s. The latent variables need in general to be connected in a way somewhat similar to an HMM, with a limited number of connections between variables and some type of linear structure among the variables. The general algorithm involves ''message passing'' and is substantially similar to the [[belief propagation]] algorithm (which is the generalization of the [[forward-backward algorithm]]).

With the algorithm called [[iterative Viterbi decoding]] one can find the subsequence of an observation that matches best (on average) to a given [[hidden Markov model]]. This algorithm is proposed by Qi Wang et al. to deal with [[turbo code]]. Iterative Viterbi decoding works by iteratively invoking a modified Viterbi algorithm, reestimating the score for a filler until convergence.

An alternative algorithm, the [[Lazy Viterbi algorithm]], has been proposed recently. For many codes of practical interest, under reasonable noise conditions, the lazy
decoder (using Lazy Viterbi algorithm) is much faster than the original [[Viterbi decoder]] (using Viterbi algorithm). This algorithm works by not expanding any nodes until it really needs to, and usually manages to get away with doing a lot less work (in software) than the ordinary Viterbi algorithm for the same result—however, it is not so easy to parallelize in hardware.

==Pseudocode==
This algorithm generates a path <math> X=(x_1,x_2,\ldots,x_T) </math>, which is a sequence of states <math>x_n \in S=\{s_1,s_2,\dots,s_K\}</math> that generate the observations <math> Y=(y_1,y_2,\ldots, y_T) \in \{1,2,\dots,N\}^T</math> (<math>N</math> being the count of observations (observation space, see below)).

Two 2-dimensional tables of size <math>K \times T</math> are constructed:

* Each element <math>T_1[i,j]</math> of <math>T_1</math> stores the probability of the most likely path so far <math> \hat{X}=(\hat{x}_1,\hat{x}_2,\ldots,\hat{x}_j) </math> with <math>\hat{x}_j=s_i </math> that generates <math> Y=(y_1,y_2,\ldots, y_j)</math>.
* Each element <math>T_2[i,j] </math> of <math>T_2 </math> stores <math>\hat{x}_{j-1} </math> of the most likely path so far <math> \hat{X}=(\hat{x}_1,\hat{x}_2,\ldots,\hat{x}_{j-1},\hat{x}_j = s_i)</math> for <math>\forall j, 2\leq j \leq T </math>

The table entries <math> T_1[i,j],T_2[i,j]</math> are filled by increasing order of <math>K\cdot j+i </math>.

:<math>T_1[i,j]=\max_{k}{(T_1[k,j-1]\cdot A_{ki}\cdot B_{iy_j})} </math>, and
:<math> T_2[i,j]=\operatorname{argmax}_{k}{(T_1[k,j-1]\cdot A_{ki}\cdot B_{iy_j})} </math>,

with <math>A_{ki}</math> and <math>B_{iy_j}</math> as defined below. Note that <math>B_{iy_j}</math> does not need to appear in the latter expression, as it's non-negative and independent of <math>k</math> and thus does not affect the argmax.

;INPUT:
* The [[observation space]] <math> O=\{o_1,o_2,\dots,o_N\}</math>
* the [[state space]] <math> S=\{s_1,s_2,\dots,s_K\} </math>
* an array of initial probabilities <math> \Pi = (\pi_1,\pi_2,\dots,\pi_K)</math> such that <math> \pi_i </math> stores the probability that <math> x_1 == s_i </math>
* a sequence of observations <math> Y=(y_1,y_2,\ldots, y_T) </math> such that <math> y_t==i </math> if the observation at time <math> t </math> is <math> o_i </math>
* [[transition matrix]] <math> A </math> of size <math> K\times K </math> such that <math> A_{ij} </math> stores the [[transition probability]] of transiting from state <math> s_i </math> to state <math> s_j </math>
* [[emission matrix]] <math> B </math> of size <math> K\times N </math> such that <math> B_{ij} </math> stores the probability of observing <math> o_j </math> from state <math> s_i </math>
;OUTPUT:
*The most likely hidden state sequence <math> X=(x_1,x_2,\ldots,x_N) </math>
'''function''' ''VITERBI''<math>(O,S,\Pi,Y,A,B):X</math>
'''for''' each state <math>i \in \{1,2,\ldots,K\}</math> '''do'''

'''end for'''
'''for''' each observation <math>i = 2,3,\ldots,T</math> '''do'''
'''for''' each state <math>j \in \{1,2,\ldots,K\}</math> '''do'''

'''end for'''
'''end for'''

'''for''' '''do'''

'''end for'''
'''return'''
'''end function'''

;EXPLANATION:
Suppose we are given a [[hidden Markov model]] (HMM) with state space <math>S</math>, initial probabilities <math>\pi_i</math> of being in state <math>i</math> and transition probabilities <math>a_{i,j}</math> of transitioning from state <math>i</math> to state <math>j</math>. Say we observe outputs <math>y_1,\dots, y_T</math>. The most likely state sequence <math>x_1,\dots,x_T</math> that produces the observations is given by the recurrence relations:

:<math>
\begin{array}{rcl}
V_{1,k} &=& \mathrm{P}\big( y_1 \ | \ k \big) \cdot \pi_k \\
V_{t,k} &=& \max_{x \in S} \left( \mathrm{P}\big( y_t \ | \ k \big) \cdot a_{x,k} \cdot V_{t-1,x}\right)
\end{array}
</math>

Here <math>V_{t,k}</math> is the probability of the most probable state sequence <math>\mathrm{P}\big(x_1,\dots,x_T,y_1,\dots, y_T\big)</math> responsible for the first <math>t</math> observations that have <math>k</math> as its final state. The Viterbi path can be retrieved by saving back pointers that remember which state <math>x</math> was used in the second equation. Let <math>\mathrm{Ptr}(k,t)</math> be the function that returns the value of <math>x</math> used to compute <math>V_{t,k}</math> if <math>t > 1</math>, or <math>k</math> if <math>t=1</math>. Then:

:<math>
\begin{array}{rcl}
x_T &=& \arg\max_{x \in S} (V_{T,x}) \\
x_{t-1} &=& \mathrm{Ptr}(x_t,t)
\end{array}
</math>
Here we're using the standard definition of [[arg max]].<br>
The complexity of this algorithm is <math>O(T\times\left|{S}\right|^2)</math>.

==Example==
Consider a village where all villagers are either healthy or have a fever and only the village doctor can determine whether each has a fever. The doctor diagnoses fever by asking patients how they feel. The villagers may only answer that they feel normal, dizzy, or cold.

The doctor believes that the health condition of his patients operate as a discrete [[Markov chain]]. There are two states, "Healthy" and "Fever", but the doctor cannot observe them directly; they are ''hidden'' from him. On each day, there is a certain chance that the patient will tell the doctor he/she is "normal", "cold", or "dizzy", depending on their health condition.

The ''observations'' (normal, cold, dizzy) along with a ''hidden'' state (healthy, fever) form a hidden Markov model (HMM), and can be represented as follows in the [[Python (programming language)|Python programming language]]:
<source lang="python">
obs = ('normal', 'cold', 'dizzy')
states = ('Healthy', 'Fever')
start_p = {'Healthy': 0.6, 'Fever': 0.4}
trans_p = {
'Healthy' : {'Healthy': 0.7, 'Fever': 0.3},
'Fever' : {'Healthy': 0.4, 'Fever': 0.6}
}
emit_p = {
'Healthy' : {'normal': 0.5, 'cold': 0.4, 'dizzy': 0.1},
'Fever' : {'normal': 0.1, 'cold': 0.3, 'dizzy': 0.6}
}
</source>
In this piece of code, <code>start_probability</code> represents the doctor's belief about which state the HMM is in when the patient first visits (all he knows is that the patient tends to be healthy). The particular probability distribution used here is not the equilibrium one, which is (given the transition probabilities) approximately <code>{'Healthy': 0.57, 'Fever': 0.43}</code>. The <code>transition_probability</code> represents the change of the health condition in the underlying Markov chain. In this example, there is only a 30% chance that tomorrow the patient will have a fever if he is healthy today. The <code>emission_probability</code> represents how likely the patient is to feel on each day. If he is healthy, there is a 50% chance that he feels normal; if he has a fever, there is a 60% chance that he feels dizzy.

The patient visits three days in a row and the doctor discovers that on the first day he feels normal, on the second day he feels cold, on the third day he feels dizzy. The doctor has a question: what is the most likely sequence of health conditions of the patient that would explain these observations? This is answered by the Viterbi algorithm.

<source lang="python" line="1">
def viterbi(obs, states, start_p, trans_p, emit_p):
V = [{}]
for st in states:
V[0][st] = {"prob": start_p[st] * emit_p[st][obs[0]], "prev": None}
# Run Viterbi when t > 0
for t in range(1, len(obs)):
V.append({})
for st in states:
max_tr_prob = max(V[t-1][prev_st]["prob"]*trans_p[prev_st][st] for prev_st in states)
for prev_st in states:
if V[t-1][prev_st]["prob"] * trans_p[prev_st][st] == max_tr_prob:
max_prob = max_tr_prob * emit_p[st][obs[t]]
V[t][st] = {"prob": max_prob, "prev": prev_st}
break
for line in dptable(V):
print line
opt = []
# The highest probability
max_prob = max(value["prob"] for value in V[-1].values())
previous = None
# Get most probable state and its backtrack
for st, data in V[-1].items():
if data["prob"] == max_prob:
opt.append(st)
previous = st
break
# Follow the backtrack till the first observation
for t in range(len(V) - 2, -1, -1):
opt.insert(0, V[t + 1][previous]["prev"])
previous = V[t + 1][previous]["prev"]

print 'The steps of states are ' + ' '.join(opt) + ' with highest probability of %s' % max_prob

def dptable(V):
# Print a table of steps from dictionary
yield " ".join(("%12d" % i) for i in range(len(V)))
for state in V[0]:
yield "%.7s: " % state + " ".join("%.7s" % ("%f" % v[state]["prob"]) for v in V)
</source>
The function <code>viterbi</code> takes the following arguments: <code>obs</code> is the sequence of observations, e.g. <code>['normal', 'cold', 'dizzy']</code>; <code>states</code> is the set of hidden states; <code>start_p</code> is the start probability; <code>trans_p</code> are the transition probabilities; and <code>emit_p</code> are the emission probabilities. For simplicity of code, we assume that the observation sequence <code>obs</code> is non-empty and that <code>trans_p[i][j]</code> and <code>emit_p[i][j]</code> is defined for all states i,j.

In the running example, the forward/Viterbi algorithm is used as follows:

<source lang="python">
viterbi(obs,
states,
start_p,
trans_p,
emit_p)

</source>

The output of the script is

<source lang="console">
$ python viterbi_example.py
0 1 2
Healthy: 0.30000 0.08400 0.00588
Fever: 0.04000 0.02700 0.01512
The steps of states are Healthy Healthy Fever with highest probability of 0.01512
</source>

This reveals that the observations <code>['normal', 'cold', 'dizzy']</code> were most likely generated by states <code>['Healthy', 'Healthy', 'Fever']</code>. In other words, given the observed activities, the patient was most likely to have been healthy both on the first day when he felt normal as well as on the second day when he felt cold, and then he contracted a fever the third day.

The operation of Viterbi's algorithm can be visualized by means of a
[[Trellis diagram#Trellis diagram|trellis diagram]]. The Viterbi path is essentially the shortest
path through this trellis. The trellis for the clinic example is shown below; the corresponding

==See also==
* [[Soft output Viterbi algorithm]]
* [[Viterbi decoder]]

==Notes==
<references />

==Source==

[http://wikipedia.org/ http://wikipedia.org/]

[[Category:Cryptographic algorithms]]

Viterbi algorithm - Revision history

Admin: Created page with " '''Viterbi algorithm''' is a dynamic programming algorithm for finding the most likely sequence of hidden states—called the '''Vit..."