A Hidden Markov Model (HMM) is a statistical model widely used in scenarios where the observed data are generated by an underlying, unobserved (hidden) sequence of states that follow a Markov process. It’s extensively applied in fields like finance, biology, speech recognition, and economics.

The key concepts related to HMMs are listed in the table below. We will explain each concept as we walk through a simplified stock market example.

Concept	Explanation
Hidden States	Unobserved conditions (e.g., “Bull Market”, “Bear Market”) that evolve over time
Observations(O)	The data we see (e.g., stock price movements) generated from hidden states
Transition Probabilities (A)	Probability of moving from one hidden state to another
Emission Probabilities (B)	Probability of observing a specific output from a given hidden state
Initial State Probabilities	Probabilities of starting in each hidden state

Our simplified stock market example begins by specifying the hidden states (S), observable outputs, and the observation sequence (O), as follows:

• 2 hidden states:
  • Bull market
  • Bear market
• 2 observable outputs:
  • Up day (stock price rises)
  • Down day (stock price falls)
• Observation sequence (based on 3 days of market movement):
  • Day 1: Up
  • Day 2: Down
  • Day 3: Up
    (So: O = [Up, Down, Up])

The model parameters are initialized as follows (with explanations provided below the data matrices):

The initial probabilities above assume a 60% chance that the market is in a Bull state and a 40% chance that it is in a Bear state.

The transition matrix indicates that the probability of a Bull market remaining Bull is 80%, transitioning from Bull to Bear is 20%, from Bear to Bull is 30%, and from Bear to Bear is 70%.

The emission matrix shows that, given the market is in a Bull state, the probability of observing “Up” is 90% and “Down” is 10%. If the market is in a Bear state, the probability of observing “Up” is 20% and “Down” is 80%.

The implementation of an HMM involves three key types of derived probabilities: forward probabilities, backward probabilities, and posterior (or state) probabilities

While forward probabilities asked:

“Given what we’ve already seen (past days), what’s the chance we’re in a certain state today?”

Backward probabilities ask:

“Given where we are today, what’s the chance that the future observations will happen if we start from each possible state?”

Posterior probabilities combine both perspectives:

“Given the entire sequence of observations—past, present, and future—what’s the probability we were in a certain state at a specific time?”

---

First, we calculate the forward probabilities (α).

Next, we calculate the backward probabilities (β).

Finally, we calculate the posterior probabilities.

These are optional:

updating transition probabilities and updating Parameters

Summary of Updated Parameters:

The example above can be implemented in Python as follows:

import numpy as np
import pandas as pd

# Observations: Up=0, Down=1, Up=0
observations = np.array([0, 1, 0])
T = len(observations)
N = 2  # Hidden states: Bull, Bear
M = 2  # Observation symbols: Up, Down

# Initial model parameters
pi = np.array([0.6, 0.4])
A = np.array([
    [0.8, 0.2],  # Bull to Bull, Bull to Bear
    [0.3, 0.7]   # Bear to Bull, Bear to Bear
])
B = np.array([
    [0.9, 0.1],  # Bull emits Up, Down
    [0.2, 0.8]   # Bear emits Up, Down
])

# Step 1: Forward algorithm (alpha)
alpha = np.zeros((T, N))
alpha[0] = pi * B[:, observations[0]]
for t in range(1, T):
    for j in range(N):
        alpha[t, j] = np.sum(alpha[t-1] * A[:, j]) * B[j, observations[t]]

# Step 2: Backward algorithm (beta)
beta = np.zeros((T, N))
beta[T-1] = 1
for t in range(T-2, -1, -1):
    for i in range(N):
        beta[t, i] = np.sum(A[i] * B[:, observations[t+1]] * beta[t+1])

# Step 3: Compute gamma (posterior probabilities)
P_obs = np.sum(alpha[T-1])
gamma = (alpha * beta) / P_obs

# Step 4: Compute xi (expected transitions)
xi = np.zeros((T-1, N, N))
for t in range(T-1):
    denom = 0
    for i in range(N):
        for j in range(N):
            denom += alpha[t, i] * A[i, j] * B[j, observations[t+1]] * beta[t+1, j]
    for i in range(N):
        for j in range(N):
            xi[t, i, j] = (alpha[t, i] * A[i, j] * B[j, observations[t+1]] * beta[t+1, j]) / denom

# Step 5: Update transition matrix A'
A_new = np.zeros((N, N))
for i in range(N):
    for j in range(N):
        A_new[i, j] = np.sum(xi[:, i, j]) / np.sum(gamma[:-1, i])

# Step 6: Update emission matrix B'
B_new = np.zeros((N, M))
for j in range(N):
    for k in range(M):
        mask = (observations == k)
        B_new[j, k] = np.sum(gamma[mask, j]) / np.sum(gamma[:, j])

# Step 7: Update initial probabilities
pi_new = gamma[0]

# Output all updated parameters
print("Updated Initial Probabilities (pi'):\n", pi_new)
print("\nUpdated Transition Matrix (A'):\n", A_new)
print("\nUpdated Emission Matrix (B'):\n", B_new)

print("\nPosterior Probabilities (gamma):\n", gamma)
print("\nExpected Transitions (xi):\n", xi)

You can prompt the program to display the output for a given day. The code also supports calendar-based input. For example:

#Get Posterior Probabilities for Day 2 (index = 1)
day = 1  # Indexing starts at 0, so Day 2 is index 1
print(f"Posterior on Day {day+1}: Bull = {gamma[day, 0]}, Bear = {gamma[day, 1]}")

#To get the posterior probabilities for a specific date within your observation window:
print_posterior_by_date(gamma, "2024-05-01")  # Day 1
print_posterior_by_date(gamma, "2024-05-02")  # Day 2
print_posterior_by_date(gamma, "2024-05-03")  # Day 3

To be continued in Part 2.

Like (0)