Unlocking Fraud Detection: Build a Hidden Markov Model with Python

Hidden Markov Model (HMM) is a powerful statistical tool for modeling sequential data, widely used in speech recognition, natural language processing, bioinformatics, and financial analysis.

This article introduces HMM's basic concepts, mathematical foundations, and practical applications, and demonstrates how to build and solve an HMM for credit‑card fraud detection using Python.

Basic Concepts of Hidden Markov Model

Markov Chain

A Markov chain is a random process with the memoryless property : the future state depends only on the current state, not on past states. Let S be the set of possible states; transition probabilities are expressed as a matrix where each entry represents the probability of moving from one state to another.

Hidden Markov Model

HMM assumes that the system's true states are hidden and can only be inferred indirectly through observable emissions.

An HMM consists of five components:

State set (S) : the hidden states of the model.

Observation set (V) : the possible observable symbols.

Initial state distribution (π): probability distribution over states at time zero.

State transition probability matrix (A) : probabilities of moving between hidden states.

Observation probability matrix (B) : probabilities of emitting each observation from a given hidden state.

Fundamental Problems of HMM

HMM addresses three core problems:

Evaluation : given model parameters and an observation sequence, compute the probability of the observation sequence.

Decoding : given an observation sequence and model parameters, find the most likely hidden state sequence.

Learning : given an observation sequence, estimate the model parameters.

Case Study: Credit‑Card Fraud Detection

In this case, each transaction’s status (e.g., normal or fraudulent) is treated as a hidden state, while features such as amount, time, and location serve as observations.

Key features of the synthetic dataset include:

Transaction amount (Amount)

Transaction time (Time)

Transaction location (Location)

Transaction category (Category)

Data preprocessing steps:

Data cleaning: handle missing and outlier values.

Feature selection: choose the most influential features for fraud detection.

Feature scaling: standardize numeric features.

We define the HMM parameters for two hidden states (normal and fraudulent): initial state distribution, transition matrix, and observation matrix.

Python implementation using the hmmlearn library begins with generating a synthetic transaction dataset:

<code>import numpy as np
import pandas as pd

# Generate synthetic credit‑card transaction data
np.random.seed(42)

def generate_transaction_data(n_transactions):
    data = []
    for _ in range(n_transactions):
        amount = np.random.uniform(1, 500)  # transaction amount
        time = np.random.randint(0, 24)    # hour of transaction
        location = np.random.choice(['Store_A', 'Store_B', 'Store_C'])
        is_fraud = np.random.choice([0, 1], p=[0.95, 0.05])  # 5% fraud
        data.append([amount, time, location, is_fraud])
    return pd.DataFrame(data, columns=['Amount', 'Time', 'Location', 'IsFraud'])

transactions = generate_transaction_data(1000)
print(transactions.head())</code>

Preprocess the data by normalizing the amount and encoding categorical features:

<code>from sklearn.preprocessing import StandardScaler, LabelEncoder

# Normalize transaction amount
scaler = StandardScaler()
transactions['Amount'] = scaler.fit_transform(transactions[['Amount']])

# Encode time and location
label_encoder_time = LabelEncoder()
transactions['Time'] = label_encoder_time.fit_transform(transactions['Time'])

label_encoder_location = LabelEncoder()
transactions['Location'] = label_encoder_location.fit_transform(transactions['Location'])

features = transactions[['Amount', 'Time', 'Location']].values
labels = transactions['IsFraud'].values</code>

Build and train the HMM:

<code>from hmmlearn import hmm

# Convert labels to observation sequence
observations = labels.reshape(-1, 1)

# Define and train Gaussian HMM
model = hmm.GaussianHMM(n_components=2, covariance_type="diag", n_iter=1000)
model.fit(features)

print("Initial state distribution:", model.startprob_)
print("Transition matrix:", model.transmat_)
print("Means:", model.means_)
print("Variances:", model.covars_)</code>

The transition matrix shows a relatively high probability of moving from a non‑fraudulent state to a fraudulent state, reflecting the continuity of fraudulent behavior in the synthetic data.

Mean values indicate that state 0 corresponds to smaller transaction amounts and dispersed times, while state 1 has larger amounts and concentrated times, suggesting fraudulent patterns.

Predict hidden states and evaluate accuracy:

<code># Predict hidden states
hidden_states = model.predict(features)

# Compare predictions with actual labels
results = pd.DataFrame({'Actual': labels, 'Predicted': hidden_states})
print(results.head())

# Compute accuracy
accuracy = np.mean(results['Actual'] == results['Predicted'])
print(f"Model accuracy: {accuracy:.2f}")</code>

By constructing and training an HMM, we capture latent patterns in transaction behavior, enabling the identification of anomalous (potentially fraudulent) transactions.