Awesome Open Source
Awesome Open Source

AntroPy is a Python 3 package providing several time-efficient algorithms for computing the complexity of time-series. It can be used for example to extract features from EEG signals.

## Installation

```pip install antropy
```

Dependencies

## Functions

Entropy

```import numpy as np
import antropy as ant
np.random.seed(1234567)
x = np.random.normal(size=3000)
# Permutation entropy
print(ant.perm_entropy(x, normalize=True))
# Spectral entropy
print(ant.spectral_entropy(x, sf=100, method='welch', normalize=True))
# Singular value decomposition entropy
print(ant.svd_entropy(x, normalize=True))
# Approximate entropy
print(ant.app_entropy(x))
# Sample entropy
print(ant.sample_entropy(x))
# Hjorth mobility and complexity
print(ant.hjorth_params(x))
# Number of zero-crossings
print(ant.num_zerocross(x))
# Lempel-Ziv complexity
print(ant.lziv_complexity('01111000011001', normalize=True))
```
```0.9995371694290871
0.9940882825422431
0.9999110978316078
2.015221318528564
2.198595813245399
(1.4313385010057378, 1.215335712274099)
1531
1.3597696150205727
```

Fractal dimension

```# Petrosian fractal dimension
print(ant.petrosian_fd(x))
# Katz fractal dimension
print(ant.katz_fd(x))
# Higuchi fractal dimension
print(ant.higuchi_fd(x))
# Detrended fluctuation analysis
print(ant.detrended_fluctuation(x))
```
```1.0310643385753608
5.954272156665926
2.005040632258251
0.47903505674073327
```

### Execution time

Here are some benchmarks computed on a MacBook Pro (2020).

```import numpy as np
import antropy as ant
np.random.seed(1234567)
x = np.random.rand(1000)
# Entropy
%timeit ant.perm_entropy(x)
%timeit ant.spectral_entropy(x, sf=100)
%timeit ant.svd_entropy(x)
%timeit ant.app_entropy(x)  # Slow
%timeit ant.sample_entropy(x)  # Numba
# Fractal dimension
%timeit ant.petrosian_fd(x)
%timeit ant.katz_fd(x)
%timeit ant.higuchi_fd(x) # Numba
%timeit ant.detrended_fluctuation(x) # Numba
```
```106 s  5.49 s per loop (mean  std. dev. of 7 runs, 10000 loops each)
138 s  3.53 s per loop (mean  std. dev. of 7 runs, 10000 loops each)
40.7 s  303 ns per loop (mean  std. dev. of 7 runs, 10000 loops each)
2.44 ms  134 s per loop (mean  std. dev. of 7 runs, 100 loops each)
2.21 ms  35.4 s per loop (mean  std. dev. of 7 runs, 100 loops each)
23.5 s  695 ns per loop (mean  std. dev. of 7 runs, 10000 loops each)
40.1 s  2.09 s per loop (mean  std. dev. of 7 runs, 10000 loops each)
13.7 s  251 ns per loop (mean  std. dev. of 7 runs, 100000 loops each)
315 s  10.7 s per loop (mean  std. dev. of 7 runs, 1000 loops each)
```

## Development

AntroPy was created and is maintained by Raphael Vallat. Contributions are more than welcome so feel free to contact me, open an issue or submit a pull request!

To see the code or report a bug, please visit the GitHub repository.

Note that this program is provided with NO WARRANTY OF ANY KIND. Always double check the results.

## Acknowledgement

Several functions of AntroPy were adapted from:

All the credit goes to the author of these excellent packages.

Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
Python (1,140,932
Machine Learning (31,673
Algorithms (10,905
Signal Processing (858
Neuroscience (669
Feature Extraction (544
Signal (494
Eeg (425
Entropy (221
Complexity (179
Numba (133
Fractal Dimension (15
Related Projects