sample entropy

Like approximate entropy (ApEn), Sample entropy (SampEn) is a measure of complexity. But it does not include self-similar patterns as ApEn does. For a given embedding dimension $m$, tolerance $r$ and number of data points $N$, SampEn is the negative natural logarithm of the probability that if two sets of simultaneous data points of length $m$ have distance then two sets of simultaneous data points of length $m+1$ also have distance . And we represent it by $SampEn(m,r,N)$ (or by $SampEn(m,r,\backslash tau,N)$ including sampling time $\backslash tau$).

Now assume we have a time-series data set of length $N\; =\; \{\; \backslash \{\; x\_1\; ,\; x\_2\; ,\; x\_3\; ,\; .\; .\; .\; ,\; x\_N\; \backslash \}\; \}$ with a constant time interval $\backslash tau$. We define a template vector of length $m$, such that $X\_m\; (i)=\{\; \backslash \{\; x\_i\; ,\; x\_\{i+1\}\; ,\; x\_\{i+2\}\; ,\; .\; .\; .\; ,\; x\_\{i+m-1\}\; \backslash \}\; \}$ and the distance function $d[X\_m(i),X\_m(j)]$ (i≠j) is to be the Chebyshev distance (but it could be any distance function, including Euclidean distance). We define the sample entropy to be

:$$

SampEn=-\ln {A \over B}

Where

$A$ = number of template vector pairs having

$B$ = number of template vector pairs having

It is clear from the definition that $A$ will always have a value smaller or equal to $B$. Therefore, $SampEn(m,r,\backslash tau)$ will be always either be zero or positive value. A smaller value of $SampEn$ also indicates more self-similarity in data set or less noise.

Generally we take the value of $m$ to be $2$ and the value of $r$ to be $0.2\; \backslash times\; std$.

Where std stands for standard deviation which should be taken over a very large dataset. For instance, the r value of 6 ms is appropriate for sample entropy calculations of heart rate intervals, since this corresponds to $0.2\; \backslash times\; std$ for a very large population.

The definition mentioned above is a special case of multi scale sampEn with $\backslash delta=1$, where $\backslash delta$ is called skipping parameter. In multiscale SampEn template vectors are defined with a certain interval between its elements, specified by the value of $\backslash delta$. And modified template vector is defined as

X_{m,\delta}(i)={x_i,x_{i+\delta},x_{i+2\times\delta},...,x_{i+(m-1)\times\delta} }

and sampEn can be written as

SampEn \left ( m,r,\delta \right )=-\ln { A_\delta \over B_\delta }

And we calculate $A\_\backslash delta$ and $B\_\backslash delta$ like before.

Sample entropy can be implemented easily in many different programming languages. Below lies an example written in Python.

from itertools import combinations

from math import log

def construct_templates(timeseries_data: list, m: int = 2):

num_windows = len(timeseries_data) - m + 1

return [timeseries_data[x : x + m] for x in range(0, num_windows)]

def get_matches(templates: list, r: float):

return len(

list(filter(lambda x: is_match(x[0], x[1], r), combinations(templates, 2)))

)

def is_match(template_1: list, template_2: list, r: float):

return all([abs(x - y) < r for (x, y) in zip(template_1, template_2)])

def sample_entropy(timeseries_data: list, window_size: int, r: float):

B = get_matches(construct_templates(timeseries_data, window_size), r)

A = get_matches(construct_templates(timeseries_data, window_size + 1), r)

return -log(A / B)

{{Excessive examples|date=July 2024}}

An equivalent example in numerical Python.

import numpy

def construct_templates(timeseries_data, m):

num_windows = len(timeseries_data) - m + 1

return numpy.array([timeseries_data[x : x + m] for x in range(0, num_windows)])

def get_matches(templates, r):

return len(

list(filter(lambda x: is_match(x[0], x[1], r), combinations(templates)))

)

def combinations(x):

idx = numpy.stack(numpy.triu_indices(len(x), k=1), axis=-1)

return x[idx]

def is_match(template_1, template_2, r):

return numpy.all([abs(x - y) < r for (x, y) in zip(template_1, template_2)])

def sample_entropy(timeseries_data, window_size, r):

B = get_matches(construct_templates(timeseries_data, window_size), r)

A = get_matches(construct_templates(timeseries_data, window_size + 1), r)

return -numpy.log(A / B)

An example written in other languages can be found:

• [http://www.mathworks.com/matlabcentral/fileexchange/35784-sample-entropy Matlab]
• [https://cran.r-project.org/web/packages/nonlinearTseries/ R].
• [https://github.com/RyanDoesMath/sample_entropy Rust]

• Kolmogorov complexity
• Approximate entropy

{{reflist}}

Category:Statistical signal processing

Category:Entropy

Category:Articles with example Python (programming language) code