Documentation

Welcome to NeuroKit’s documentation. Here you can find information and learn about Python, NeuroKit, Physiological Signals and more.

You can navigate to the different sections using the left panel. We would recommend checking out the guides and examples, where you can find tutorials and hands-on walkthroughs.

Introduction

The Python Toolbox for Neurophysiological Signal Processing

This package is the continuation of NeuroKit 1. It’s a user-friendly package providing easy access to advanced biosignal processing routines. Researchers and clinicians without extensive knowledge of programming or biomedical signal processing can analyze physiological data with only two lines of code.

Quick Example

import neurokit2 as nk

# Download example data
data = nk.data("bio_eventrelated_100hz")

# Preprocess the data (filter, find peaks, etc.)
processed_data, info = nk.bio_process(ecg=data["ECG"], rsp=data["RSP"], eda=data["EDA"], sampling_rate=100)

# Compute relevant features
results = nk.bio_analyze(processed_data, sampling_rate=100)

And boom 💥 your analysis is done 😎

Installation

To install NeuroKit2, run this command in your terminal:

pip install neurokit2

If you’re not sure how/what to do, be sure to read our installation guide.

Contributing

NeuroKit2 is a collaborative project with a community of contributors with all levels of development expertise. Thus, if you have some ideas for improvement, new features, or just want to learn Python and do something useful at the same time, do not hesitate and check out the following guides:

• Understanding NeuroKit

• Contributing guide

• Ideas for first contributions

Documentation

Click on the links above and check out our tutorials:

General

• Get familiar with Python in 10 minutes

• Recording good quality signals

• What software for physiological signal processing

• Install Python and NeuroKit

• Included datasets

• Additional Resources

Examples

• Simulate Artificial Physiological Signals

• Customize your Processing Pipeline

• Event-related Analysis

• Interval-related Analysis

• Analyze Electrodermal Activity (EDA)

• Analyze Respiratory Rate Variability (RRV)

• Extract and Visualize Individual Heartbeats

• Locate P, Q, S and T waves in ECG

• Complexity Analysis of Physiological Signals

• Analyze Electrooculography EOG data

• Fit a function to a signal

You can try out these examples directly in your browser.

Don’t know which tutorial is suited for your case? Follow this flowchart:

Citation

nk.cite()

You can cite NeuroKit2 as follows:

- Makowski, D., Pham, T., Lau, Z. J., Brammer, J. C., Lesspinasse, F., Pham, H.,
  Schölzel, C., & S H Chen, A. (2020). NeuroKit2: A Python Toolbox for Neurophysiological
  Signal Processing. Retrieved March 28, 2020, from https://github.com/neuropsychology/NeuroKit

Full bibtex reference:

@misc{neurokit2,
  doi = {10.5281/ZENODO.3597887},
  url = {https://github.com/neuropsychology/NeuroKit},
  author = {Makowski, Dominique and Pham, Tam and Lau, Zen J. and Brammer, Jan C. and Lespinasse, Fran\c{c}ois and Pham, Hung and Schölzel, Christopher and S H Chen, Annabel},
  title = {NeuroKit2: A Python Toolbox for Neurophysiological Signal Processing},
  publisher = {Zenodo},
  year = {2020},
}

Physiological Data Preprocessing

Simulate physiological signals

import numpy as np
import pandas as pd
import neurokit2 as nk

# Generate synthetic signals
ecg = nk.ecg_simulate(duration=10, heart_rate=70)
ppg = nk.ppg_simulate(duration=10, heart_rate=70)
rsp = nk.rsp_simulate(duration=10, respiratory_rate=15)
eda = nk.eda_simulate(duration=10, scr_number=3)
emg = nk.emg_simulate(duration=10, burst_number=2)

# Visualise biosignals
data = pd.DataFrame({"ECG": ecg,
                     "PPG": ppg,
                     "RSP": rsp,
                     "EDA": eda,
                     "EMG": emg})
nk.signal_plot(data, subplots=True)

Electrodermal Activity (EDA/GSR)

# Generate 10 seconds of EDA signal (recorded at 250 samples / second) with 2 SCR peaks
eda = nk.eda_simulate(duration=10, sampling_rate=250, scr_number=2, drift=0.01)

# Process it
signals, info = nk.eda_process(eda, sampling_rate=250)

# Visualise the processing
nk.eda_plot(signals, sampling_rate=250)

Cardiac activity (ECG)

# Generate 15 seconds of ECG signal (recorded at 250 samples / second)
ecg = nk.ecg_simulate(duration=15, sampling_rate=250, heart_rate=70)

# Process it
signals, info = nk.ecg_process(ecg, sampling_rate=250)

# Visualise the processing
nk.ecg_plot(signals, sampling_rate=250)

Respiration (RSP)

# Generate one minute of respiratory (RSP) signal (recorded at 250 samples / second)
rsp = nk.rsp_simulate(duration=60, sampling_rate=250, respiratory_rate=15)

# Process it
signals, info = nk.rsp_process(rsp, sampling_rate=250)

# Visualise the processing
nk.rsp_plot(signals, sampling_rate=250)

Electromyography (EMG)

# Generate 10 seconds of EMG signal (recorded at 250 samples / second)
emg = nk.emg_simulate(duration=10, sampling_rate=250, burst_number=3)

# Process it
signal, info = nk.emg_process(emg, sampling_rate=250)

# Visualise the processing
nk.emg_plot(signals, sampling_rate=250)

Photoplethysmography (PPG/BVP)

# Generate 15 seconds of PPG signal (recorded at 250 samples / second)
ppg = nk.ppg_simulate(duration=15, sampling_rate=250, heart_rate=70)

# Process it
signals, info = nk.ppg_process(ppg, sampling_rate=250)

# Visualize the processing
nk.ppg_plot(signals, sampling_rate=250)

Electrooculography (EOG)

# Import EOG data
eog_signal = nk.data("eog_100hz")

# Process it
signals, info = nk.eog_process(eog_signal, sampling_rate=100)

# Plot
plot = nk.eog_plot(signals, sampling_rate=100)

Electrogastrography (EGG)

Consider helping us develop it!

Physiological Data Analysis

The analysis of physiological data usually comes in two types, event-related or interval-related.

Event-related

This type of analysis refers to physiological changes immediately occurring in response to an event. For instance, physiological changes following the presentation of a stimulus (e.g., an emotional stimulus) indicated by the dotted lines in the figure above. In this situation the analysis is epoch-based. An epoch is a short chunk of the physiological signal (usually < 10 seconds), that is locked to a specific stimulus and hence the physiological signals of interest are time-segmented accordingly. This is represented by the orange boxes in the figure above. In this case, using bio_analyze() will compute features like rate changes, peak characteristics and phase characteristics.

• Event-related example

Interval-related

This type of analysis refers to the physiological characteristics and features that occur over longer periods of time (from a few seconds to days of activity). Typical use cases are either periods of resting-state, in which the activity is recorded for several minutes while the participant is at rest, or during different conditions in which there is no specific time-locked event (e.g., watching movies, listening to music, engaging in physical activity, etc.). For instance, this type of analysis is used when people want to compare the physiological activity under different intensities of physical exercise, different types of movies, or different intensities of stress. To compare event-related and interval-related analysis, we can refer to the example figure above. For example, a participant might be watching a 20s-long short film where particular stimuli of interest in the movie appears at certain time points (marked by the dotted lines). While event-related analysis pertains to the segments of signals within the orange boxes (to understand the physiological changes pertaining to the appearance of stimuli), interval-related analysis can be applied on the entire 20s duration to investigate how physiology fluctuates in general. In this case, using bio_analyze() will compute features such as rate characteristics (in particular, variability metrices) and peak characteristics.

• Interval-related example

Miscellaneous

Heart Rate Variability (HRV)

• Compute HRV indices

  • Time domain: RMSSD, MeanNN, SDNN, SDSD, CVNN etc.

  • Frequency domain: Spectral power density in various frequency bands (Ultra low/ULF, Very low/VLF, Low/LF, High/HF, Very high/VHF), Ratio of LF to HF power, Normalized LF (LFn) and HF (HFn), Log transformed HF (LnHF).

  • Nonlinear domain: Spread of RR intervals (SD1, SD2, ratio between SD2 to SD1), Cardiac Sympathetic Index (CSI), Cardial Vagal Index (CVI), Modified CSI, Sample Entropy (SampEn).

# Download data
data = nk.data("bio_resting_8min_100hz")

# Find peaks
peaks, info = nk.ecg_peaks(data["ECG"], sampling_rate=100)

# Compute HRV indices
nk.hrv(peaks, sampling_rate=100, show=True)
>>>    HRV_RMSSD  HRV_MeanNN   HRV_SDNN  ...   HRV_CVI  HRV_CSI_Modified  HRV_SampEn
>>> 0  69.697983  696.395349  62.135891  ...  4.829101        592.095372    1.259931

ECG Delineation

• Delineate the QRS complex of an electrocardiac signal (ECG) including P-peaks, T-peaks, as well as their onsets and offsets.

# Download data
ecg_signal = nk.data(dataset="ecg_3000hz")['ECG']

# Extract R-peaks locations
_, rpeaks = nk.ecg_peaks(ecg_signal, sampling_rate=3000)

# Delineate
signal, waves = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="dwt", show=True, show_type='all')

Signal Processing

• Signal processing functionalities

  • Filtering: Using different methods.

  • Detrending: Remove the baseline drift or trend.

  • Distorting: Add noise and artifacts.

# Generate original signal
original = nk.signal_simulate(duration=6, frequency=1)

# Distort the signal (add noise, linear trend, artifacts etc.)
distorted = nk.signal_distort(original,
                              noise_amplitude=0.1,
                              noise_frequency=[5, 10, 20],
                              powerline_amplitude=0.05,
                              artifacts_amplitude=0.3,
                              artifacts_number=3,
                              linear_drift=0.5)

# Clean (filter and detrend)
cleaned = nk.signal_detrend(distorted)
cleaned = nk.signal_filter(cleaned, lowcut=0.5, highcut=1.5)

# Compare the 3 signals
plot = nk.signal_plot([original, distorted, cleaned])

Complexity (Entropy, Fractal Dimensions, …)

• Optimize complexity parameters (delay tau, dimension m, tolerance r)

# Generate signal
signal = nk.signal_simulate(frequency=[1, 3], noise=0.01, sampling_rate=100)

# Find optimal time delay, embedding dimension and r
parameters = nk.complexity_optimize(signal, show=True)

• Compute complexity features

  • Entropy: Sample Entropy (SampEn), Approximate Entropy (ApEn), Fuzzy Entropy (FuzzEn), Multiscale Entropy (MSE), Shannon Entropy (ShEn)

  • Fractal dimensions: Correlation Dimension D2, …

  • Detrended Fluctuation Analysis

nk.entropy_sample(signal)
nk.entropy_approximate(signal)

Signal Decomposition

# Create complex signal
signal = nk.signal_simulate(duration=10, frequency=1)  # High freq
signal += 3 * nk.signal_simulate(duration=10, frequency=3)  # Higher freq
signal += 3 * np.linspace(0, 2, len(signal))  # Add baseline and linear trend
signal += 2 * nk.signal_simulate(duration=10, frequency=0.1, noise=0)  # Non-linear trend
signal += np.random.normal(0, 0.02, len(signal))  # Add noise

# Decompose signal using Empirical Mode Decomposition (EMD)
components = nk.signal_decompose(signal, method='emd')
nk.signal_plot(components)  # Visualize components

# Recompose merging correlated components
recomposed = nk.signal_recompose(components, threshold=0.99)
nk.signal_plot(recomposed)  # Visualize components

Signal Power Spectrum Density (PSD)

# Generate signal with frequencies of 5, 20 and 30
    signal = nk.signal_simulate(frequency=5) + 0.5*nk.signal_simulate(frequency=20) + nk.signal_simulate(frequency=30)

    # Find Power Spectrum Density with different methods
    # Mutlitaper
    multitaper = nk.signal_psd(signal, method="multitapers", show=False, max_frequency=100)
    # Welch
    welch = nk.signal_psd(signal, method="welch", min_frequency=1, show=False, max_frequency=100)
    # Burg
    burg = nk.signal_psd(signal, method="burg", min_frequency=1, show=False, ar_order=15, max_frequency=100)

    # Visualize the different methods together
    fig, ax = plt.subplots()

    ax.plot(welch["Frequency"], welch["Power"], label="Welch", color="#CFD8DC", linewidth=2)
    ax.plot(multitaper["Frequency"], multitaper["Power"], label="Multitaper", color="#00695C", linewidth=2)
    ax.plot(burg["Frequency"], burg["Power"], label="Burg", color="#0097AC", linewidth=2)

    ax.set_title("Power Spectrum Density (PSD)")
    ax.set_yscale('log')
    ax.set_xlabel("Frequency (Hz)")
    ax.set_ylabel("PSD (ms^2/Hz)")
    ax.legend(loc="upper right")

    # Plot 3 frequencies of generated signal
    ax.axvline(5, color="#689F38", linewidth=3, ymax=0.95, linestyle="--")
    ax.axvline(20, color="#689F38", linewidth=3, ymax=0.95, linestyle="--")
    ax.axvline(30, color="#689F38", linewidth=3, ymax=0.95, linestyle="--")

Statistics

• Highest Density Interval (HDI)

x = np.random.normal(loc=0, scale=1, size=100000)

ci_min, ci_max = nk.hdi(x, ci=0.95, show=True)

Popularity

Notes

The authors do not provide any warranty. If this software causes your keyboard to blow up, your brain to liquify, your toilet to clog or a zombie plague to break loose, the authors CANNOT IN ANY WAY be held responsible.

Authors

Hint

Want to be a part of the project? Read how to contribute and join us!

Core team

• Dominique Makowski (Nanyang Technological University, Singapore)

• Tam Pham (Nanyang Technological University, Singapore)

• Zen Juen Lau (Nanyang Technological University, Singapore)

• Jan C. Brammer (Radboud University, Netherlands)

• François Lespinasse (Université de Montréal, Canada)

Contributors

• Hung Pham (Eureka Robotics, Singapore)

• Christopher Schölzel (THM University of Applied Sciences, Germany)

• Duy Le (Hubble, Singapore)

• Stavros Avramidis

• Tiago Rodrigues (IST, Lisbon)

• Mitchell Bishop (NINDS, USA)

• Robert Richer (FAU Erlangen-Nürnberg, Germany)

• Russell Anderson (La Trobe Institute for Molecular Science, Australia)

Thanks also to Gansheng Tan, Chuan-Peng Hu, @ucohen, Anthony Gatti, Julien Lamour, @renatosc, Nicolas Beaudoin-Gagnon and @rubinovitz for their contribution in NeuroKit 1.

More details here.

Installation

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing (see these guides).

1. Python

Windows

Winpython

The advantage of Winpython is its portability (i.e., works out of a folder) and default setup (convenient for science).

1. Download a non-zero version of Winpython

2. Install it somewhere (the desktop is a good place). It creates a folder called WPyXX-xxxx

3. In the WPyXX-xxxx folder, open WinPython Command Prompt.exe

4. Run pip install https://github.com/neuropsychology/NeuroKit/zipball/master

5. Start Spyder.exe

Miniconda or Anaconda

The difference between the two is straightforward, miniconda is recommended if you don’t have much storage space and you know what you want to install. Similar to Winpython, Anaconda comes with a base environment, meaning you have basic packages pre-installed.

1. Download and install Miniconda or Anaconda (make sure the Anaconda3 directory is similar to this: C:\Users\<username>\anaconda3\)

2. Open the Anaconda Prompt (search for it on your computer)

3. Run conda help to see your options

Note

There should be a name in parentheses before your user’s directory, e.g. (base) C:\Users\<yourusername>. That is the name of your computing environment. By default, you have a base environment. We don’t want that, so create an environment.

4. Run conda env create <yourenvname>; activate it every time you open up conda by running conda activate <yourenvname>

5. Is pip (package installer for python) installed in this env? Prompt Anaconda using pip list it’ll show you all the packages installed in that conda env

Mac OS

1. Install Anaconda

2. Open the terminal

3. Run source activate root

4. Run pip install neurokit2

5. Start Spyder.exe

2. NeuroKit

If you already have python, you can install NeuroKit by running this command in your terminal:

pip install neurokit2

This is the preferred method to install NeuroKit, as it will always install the most stable release. It is also possible to install it directly from github:

pip install https://github.com/neuropsychology/neurokit/zipball/master

Hint

Enjoy living on the edge? You can always install the latest dev branch to access some work-in-progress features using pip install https://github.com/neuropsychology/neurokit/zipball/dev

If you don’t have pip installed, this Python installation guide can guide you through the process.

Get Started

Contents:

Get familiar with Python in 10 minutes

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing (see these guides).

You have no experience in computer science? You are afraid of code? You feel betrayed because you didn’t expect to do programming in psychology studies? Relax! We got you covered.

This tutorial will provide you with all you need to know to dive into the wonderful world of scientific programming. The goal here is not become a programmer, or a software designer, but rather to be able to use the power of programming to get scientific results.

Setup

The first thing you will need is to install Python on your computer (we have a tutorial for that). In fact, this includes two things, installing Python (the language), and an environment to be able to use it. For this tutorial, we will assume you have something that looks like Spyder (called an IDE). But you can use jupyter notebooks, or anything else, it doesn’t really matter.

There is one important concept to understand here: the difference between the CONSOLE and the EDITOR. The editor is like a cooking table where you prepare your ingredients to make a dish, whereas the console is like the oven, you only open it to put the dish in it and get the result.

Most of the code that you will write, you will write it in the editor. It’s basically a text editor (such as notepad), except that it automatically highlights the code. Importantly, you can directly execute a line of code (which is equivalent to copy it and paste it the console).

For instance, try writing 1+1 somewhere in the file in the editor pane. Now if select the piece of code you just wrote, and press F9 (or CTRL + ENTER), it will execute it.

As a result, you should see in the console the order that you gave and, below, its output (which is 2).

Now that the distinction between where we write the code and where the output appears is clear, take some time to explore the settings and turn the editor background to BLACK. Why? Because it’s more comfortable for the eyes, but most importantly, because it’s cool 😎.

Congrats, you’ve become a programmer, a wizard of the modern times.

You can now save the file (CTRL + S), which will be saved with a .py extension (i.e., a Python script). Try closing everything and reopening this file with the editor.

Variables

The most important concept of programming is variables, which is a fancy name for something that you already know. Do you remember, from your mathematics classes, the famous x, this placeholder for any value? Well, x was a variable, i.e., the name refering to some other thing.

Hint

Despite to what I just said, a variable in programming is not equivalent to a variable in statistics, in which it refers to some specific data (for instance, age is variable and contains multiple observations). In programming, a variable is simply the name that we give to some entity, that could be anything.

We can assign a value to a variable using the = sign, for instance:

x = 2
y = 3

Once we execute these two lines, Python will know that x refers to 2, and y to 3. We can now write:

print(x + y)

Which will print in the console the correct result.

We can also store the output in a third variable:

x = 2
y = 3
anothervariable = x * y
print(anothervariable)

Variables and data types

The next important thing to have in mind is that variables have types. Basic types include integers (numbers without decimals), floats (numbers with decimals), strings (character text) and booleans (True and False). Depending on their type, the variables will not behave in the same way. For example, try:

print(1 + 2)
print("1" + "2")

What happened here? Well, quotations ("I am quoted") are used to represent strings (i.e., text). So in the second line, the numbers that we added were not numbers, but text. And when you add strings together in Python, it concatenates them.

One can change the type of a variable with the following:

int(1.0)  # transform the input to an integer
float(1)  # transform the input to a float
str(1)  # transform the input into text

Also, here I used the hashtag symbol to make comments, i.e., writing stuff that won’t be executed by Python. This is super useful to annotate each line of your code to remember what you do - and why you do it.

Types are often the source of many errors as they usually are incompatible between them. For instance, you cannot add a number (int or float) with a character string. For instance, try running 3 + "a", it will throw a TypeError.

Lists and dictionnaries

Two other important types are lists and dictionnaries. You can think of them as containers, as they contain multiple variables. The main difference between them is that in a list, you access the individual elements that it contains by its order (for instance, “give me the third one”), whereas in a dictionary, you access an element by its name (also known as key), for example “give me the element named A”.

A list is created using square brackets, and a dictionary using curly brackets. Importantly, in a dictionary, you must specify a name to each element. Here’s what it looks like:

mylist = [1, 2, 3]
mydict = {"A": 1, "B": 2, "C": 3}

Keep in mind that there are more types of containers, such as arrays and dataframes, that we will talk about later.

Basic indexing

There’s no point in storing elements in containers if we cannot access them later on. As mentioned earlier, we can access elements from a dictionary by its key within square brackets (note that here the square brackets don’t mean list, just mean within the previous container).

mydict = {"A": 1, "B": 2, "C": 3}
x = mydict["B"]
print(x)

Exercice time! If you have followed this tutorial so far, you should be able to guess what the following code will output:

mydict = {"1": 0, "2": 42, "x": 7}
x = str(1 + 1)
y = mydict[x]
print(y)

Answer: If you guessed 42, you’re right, congrats! If you guessed 7, you have likely confused the variable named x (which represents 1+1 converted to a character), with the character "x". And if you guessed 0… what is wrong with you?

Indexing starts from 0

As mentioned earliers, one can access elements from a list by its order. However, and there is very important to remember (the source of many beginner errors), in Python, the order starts from 0. That means that the first element is the 0th.

So if we want the 2nd element of the list, we have to ask for the 1th:

mylist = [1, 2, 3]
x = mylist[1]
print(x)

Control flow (if and else)

One important notion in programming is control flow. You want the code to do something different depending on a condition. For instance, if x is lower than 3, print “lower than 3”. In Python, this is done as follows:

x = 2
if x < 3:
    print("lower than 3")

One very important thing to notice is that the if statement corresponds to a “chunk” of code, as signified by the colon :. The chunk is usually written below, and has to be indented (you can ident a line or a chunk of code by pressing the TAB key).

What is identation?

this
    is
        indentation

This identation must be consistent: usually one level of identation corresponds to 4 spaces. Make sure you respect that throughout your script, as this is very important in Python. If you break the rule, it will throw an error. Try running the following:

if 2 < 3:
print("lower than 3")

Finally, if statements can be followed by else statements, which takes care of what happens if the condition is not fullfilled:

x = 5
if x < 3:
    print("lower")
else:
    print("higher")

Again, note the indentation and how the else statement creates a new idented chunk.

For loops

One of the most used concept is loops, and in particular for loops. Loops are chunks of code that will be run several times, until a condition is complete.

The for loops create a variable that will successively take all the values of a list (or other iterable types). Let’s look at the code below:

for var in [1, 2, 3]:
    print(var)

Here, the for loop creates a variable (that we named var), that will successively take all the values of the provided list.

Functions

Now that you know what a variable is, as well as the purpose of little things like if, else, for, etc., the last most common thing that you will find in code are function calls. In fact, we have already used some of them! Indeed, things like print(), str() and int() were functions. And in fact, you’ve probably encountered them in secondary school mathematics! Remember f(x)?

One important thing about functions is that most of the time (not always though), it takes something in, and returns something out. It’s like a factory, you give it some raw material and it outputs some transformed stuff.

For instance, let’s say we want to transform a variable containing an integer into a character string:

x = 3
x = str(x)
print(x)

As we can see, our str() function takes x as an input, and outputs the transformed version, that we can collect using the equal sign = and store in the x variable to replace its content.

Another useful function is range(), that creates a sequence of integers, and is often used in combination with for loops. Remember our previous loop:

mylist = [1, 2, 3]
for var in mylist:
    print(var)

We can re-write it using the range() function, to create a sequence of length 3 (which will be from 0 to 2; remember that Python indexing starts from 0!), and extracting and printing all of the elements in the list:

mylist = [1, 2, 3]
for i in range(3):
    print(mylist[i])

It’s a bit more complicated than the previous version, it’s true. But that’s the beauty of programming, all things can be done in a near-infinite amount of ways, allowing for your creativity to be expressed.

Exercice time! Can you try making a loop so that we add :code: 1 to each element of the list?

Answer:

mylist = [1, 2, 3]
for i in range(3):
    mylist[i] = mylist[i] + 1
print(mylist)

If you understand what happened here, in this combination of lists, functions, loops and indexing, great! You are ready to move on.

Packages

Interestingly, Python alone does not include a lot of functions. And that’s also its strength, because it allows to easily use functions developped by other people, that are stored in packages (or modules). A package is a collection of functions that can be downloaded and used in your code.

One of the most popular package is numpy (for NUM*rical *PY*thon), including a lot of functions for maths and scientific programming. It is likely that this package is already **installed* on your Python distribution. However, installing a package doesn’t mean you can use it. In order to use a package, you have to import it (load it) in your script, before using it. This usually happens at the top of a Python file, like this:

import numpy

Once you have imported it (you have to run that line), you can use its functions. For instance, let’s use the function to compute square roots included in this package:

x = numpy.sqrt(9)
print(x)

You will notice that we have to first write the package name, and then a dot, and then the sqrt() function. Why is it like that? Imagine you load two packages, both having a function named sqrt(). How would the program know which one to use? Here, it knows that it has to look for the sqrt() function in the numpy package.

You might think, it’s annoying to write the name of the package everytime, especially if the package name is long. And this is why we sometimes use aliases. For instance, numpy is often loaded under the shortcut np, which makes it shorter to use:

import numpy as np

x = np.sqrt(9)
print(x)

Lists vs. vectors (arrays)

Packages can also add new types. One important type avalable through numpy is arrays.

In short, an array is a container, similar to a list. However, it can only contain one type of things inside (for instance, only floats, only strings, etc.) and can be multidimensional (imagine a 3D cube made of little cubes containing a value). If an array is one-dimensional (like a list, i.e., a sequence of elements), we can call it a vector.

A list can be converted to a vector using the array() function from the numpy package:

mylist = [1, 2, 3]
myvector = np.array(mylist)
print(myvector)

In signal processing, vectors are often used instead of lists to store the signal values, because they are more efficient and allow to do some cool stuff with it. For instance, remember our exercice above? In which we had to add :code:`1`to each element of the list? Well using vectors, you can do this directly like this:

myvector = np.array([1, 2, 3])
myvector = myvector + 1
print(myvector)

Indeed, vectors allow for vectorized operations, which means that any operation is propagated on each element of the vector. And that’s very useful for signal processing :)

Conditional indexing

Arrays can also be transformed in arrays of booleans (True or False) using a condition, for instance:

myvector = np.array([1, 2, 3, 2, 1])
vector_of_bools = myvector <= 2  # <= means inferior OR equal
print(vector_of_bools)

This returns a vector of the same length but filled with True (if the condition is respected) or False otherwise. And this new vector can be used as a mask to index and subset the original vector. For instance, we can select all the elements of the array that fulfills this condition:

myvector = np.array([1, 2, 3, 2, 1])
mask = myvector <= 2
subset = myvector[mask]
print(subset)

Additionaly, we can also modify a subset of values on the fly:

myvector = np.array([1, 2, 3, 2, 1])
myvector[myvector <= 2] = 6
print(myvector)

Here we assigned a new value 6 to all elements of the vector that respected the condition (were inferior or equal to 2).

Dataframes

If you’ve followed everything until now, congrats! You’re almost there. The last important type that we are going to see is dataframes. A dataframe is essentially a table with rows and columns. Often, the rows represent different observations and the columns different variables.

Dataframes are available in Python through the pandas package, another very used package, usually imported under the shortcut pd. A dataframe can be constructed from a dictionnay: the key will become the variable naùe, and the list or vector associated will become the variable values.

import pandas as pd

# Create variables
var1 = [1, 2, 3]
var2 = [5, 6, 7]

# Put them in a dict
data = {"Variable1": var1, "Variable2": var2}

# Convert this dict to a dataframe
data = pd.DataFrame.from_dict(data)

print(data)

This creates a dataframe with 3 rows (the observations) and 2 columns (the variables). One can access the variables by their name:

print(data["Variable1"])

Note that Python cares about the case: tHiS is not equivalent to ThIs. And pd.DataFrame has to be written with the D and F in capital letters. This is another common source of beginner errors, so make sure you put capital letters at the right place.

Reading data

Now that you know how to create a dataframe in Python, note that you also use pandas to read data from a file (.csv, excel, etc.) by its path:

import pandas as pd

data = pd.read_excel("C:/Users/Dumbledore/Desktop/myfile.xlsx")  # this is an example
print(data)

Additionally, this can also read data directly from the internet! Try running the following:

import pandas as pd

data = pd.read_csv("https://raw.githubusercontent.com/neuropsychology/NeuroKit/master/data/bio_eventrelated_100hz.csv")
print(data)

Next steps

Now that you know the basis, and that you can distinguish between the different elements of Python code (functions calls, variables, etc.), we recommend that you dive in and try to follow our other examples and tutorials, that will show you some usages of Python to get something out of it.

Where to start

Hint

This page is under construction. Consider helping us developing it by contributing.

Here are a few examples that a good for starting with NeuroKit.

• Event-related Analysis

Examples

The notebooks in this repo are meant to illustrate what you can do with NeuroKit. It is supposed to reveal how easy it has become to use cutting-edge methods, and still retain the liberty to change a myriad of parameters. These notebooks are organized in different sections that correspond to NeuroKit’s modules.

Try the examples in your browser

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing (see this tutorial).

The notebooks in this repo are meant to illustrate what you can do with NeuroKit. It is supposed to reveal how easy it has become to use cutting-edge methods, and still retain the liberty to change a myriad of parameters. These notebooks are organized in different sections that correspond to NeuroKit’s modules.

You are free to click on the link below to run everything… without having to install anything! There you’ll find a Jupyterlab with notebooks ready to fire up. If you need help figuring out the interface. (The secret is shift+enter).

1. Analysis Paradigm

Examples dedicated to specific analysis pipelines, such as for event related paradigms and resting state.

Ideas of examples to be implemented: > Preprocessing feature signals for machine learning Analysis > EEG + physiological activity during resting state > Comparing interval related activity from different “mental states” (e.g. meditation, induced emotion vs. neutral)

a) Event-related paradigm

eventrelated.ipynb

Description

This notebook guides you through the initialization of events and epochs creation. It shows you how easy it is to compare measures you’ve extracted from different conditions.

b) Interval-related paradigm

intervalrelated.ipynb

Description

Breaks down the step to extract characteristics of physiological activity for epochs of a minimum of a couple minutes

2. Biosignal Processing

Examples dedicated to processing pipelines, and measure extraction of multiple signals at a time. What’s your thing ? How do you do it ?

Ideas of examples to be implemented:

> Batch preprocessing of multiple recordings
> PPG processing for respiration and temperature
> EMG overview (so many muscles to investigate)
> add yours...

a) Custom processing pipeline

custom.ipynb

Description

This notebook breaks down the default NeuroKit pipeline used in _process() functions. It guides you in creating your own pipeline with the parameters best suited for your signals.

3. Heart rate and heart cycles

Examples dedicated to the analysis of ECG, PPG and HRV time series. Are you a fan of the Neurovisceral integration model? How would you infer a cognitive or affective process with HRV ? How do you investigate the asymmetry of cardiac cycles ?

Ideas of examples to be implemented:

> Benchmark different peak detection methods
> resting state analysis of HRV
> Comparing resting state and movie watching
> add yours

a) Detecting components of the cardiac cycle

ecg_delineation.ipynb

Description

This notebook illustrate how reliable the peak detection is by analyzing the morphology of each cardiac cycles. It shows you how P-QRS-T components are extracted.

b) Looking closer at heart beats

heartbeats.ipynb

Description

This notebook gives hints for a thorough investigation of ECG signals by visualizing individual heart beats, interactively.

4. Electrodermal activity

Examples dedicated to the analysis of EDA signals.

Ideas of examples to be implemented:

> Pain experiments
> Temperature
> add yours

a) Extracting information in EDA

eda.ipynb

Description

This notebook goes at the heart of the complexity of EDA analysis by break down how Tonic and Phasic components are extracted from the signal.

5. Respiration rate and respiration cycles

Examples dedicated to the analysis of respiratory signals, i.e. as given by a belt, or eventually, with PPG.

Ideas of examples to be implemented:

> Meditation experiments
> Stress regulation
> add yours

a) Extracting Respiration Rate Variability metrics

rrv.ipynb

Description

This notebook breaks down the extraction of variability metrics done by rsp_rrv()

6. Muscle activity

Examples dedicated to the analysis of EMG signals.

Ideas of examples to be implemented:

> Suggestion and muscle activation
> Sleep data analysis
>... nothing yet!

Simulate Artificial Physiological Signals

Neurokit’s core signal processing functions surround electrocardiogram (ECG), respiratory (RSP), electrodermal activity (EDA), and electromyography (EMG) data. Hence, this example shows how to use Neurokit to simulate these physiological signals with customized parametric control.

import warnings
warnings.filterwarnings('ignore')

# Load NeuroKit and other useful packages
import neurokit2 as nk
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [10, 6]  # Bigger images

Cardiac Activity (ECG)

With ecg_simulate(), you can generate an artificial ECG signal of a desired length (in this case here, duration=10), noise, and heart rate. As you can see in the plot below, ecg50 has about half the number of heart beats than ecg100, and ecg50 also has more noise in the signal than the latter.

# Alternate heart rate and noise levels
ecg50 = nk.ecg_simulate(duration=10, noise=0.05, heart_rate=50)
ecg100 = nk.ecg_simulate(duration=10, noise=0.01, heart_rate=100)

# Visualize
ecg_df = pd.DataFrame({"ECG_100": ecg100,
                       "ECG_50": ecg50})

nk.signal_plot(ecg_df, subplots=True)

You can also choose to generate the default, simple simulation based on Daubechies wavelets, which roughly approximates one cardiac cycle, or a more complex one by specifiying method="ecgsyn".

# Alternate methods
ecg_sim = nk.ecg_simulate(duration=10, method="simple")
ecg_com = nk.ecg_simulate(duration=10, method="ecgsyn")

# Visualize
methods = pd.DataFrame({"ECG_Simple": ecg_sim,
              "ECG_Complex": ecg_com})
nk.signal_plot(methods, subplots=True)

Respiration (RSP)

To simulate a synthetic respiratory signal, you can use rsp_simulate() and choose a specific duration and breathing rate. In this example below, you can see that rsp7 has a lower breathing rate than rsp15. You can also decide which model you want to generate the signal. The simple rsp15 signal incorporates method = "sinusoidal" which approximates a respiratory cycle based on the trigonometric sine wave. On the other hand, the complex rsp15 signal specifies method = "breathmetrics" which uses a more advanced model by interpolating inhalation and exhalation pauses between each respiratory cycle.

# Simulate
rsp15_sim = nk.rsp_simulate(duration=20, respiratory_rate=15, method="sinusoidal")
rsp15_com = nk.rsp_simulate(duration=20, respiratory_rate=15, method="breathmetrics")
rsp7 = nk.rsp_simulate(duration=20, respiratory_rate=7, method="breathmetrics")

# Visualize respiration rate
rsp_df = pd.DataFrame({"RSP7": rsp7,
                       "RSP15_simple": rsp15_sim,
                       "RSP15_complex": rsp15_com})
nk.signal_plot(rsp_df, subplots=True)

Electromyography (EMG)

Now, we come to generating an artificial EMG signal using emg_simulate(). Here, you can specify the number of bursts of muscular activity (n_bursts) in the signal as well as the duration of the bursts (duration_bursts). As you can see the active muscle periods in EMG2_Longer are greater in duration than that of EMG2, and EMG5 contains more bursts than the former two.

# Simulate
emg2 = nk.emg_simulate(duration=10, burst_number=2, burst_duration=1.0)
emg2_long = nk.emg_simulate(duration=10, burst_number=2, burst_duration=1.5)
emg5 = nk.emg_simulate(duration=10, burst_number=5, burst_duration=1.0)

# Visualize
emg_df = pd.DataFrame({"EMG2": emg2,
                       "EMG2_Longer": emg2_long,
                       "EMG5": emg5})
nk.signal_plot(emg_df,subplots=True)

Electrodermal Activity (EDA)

Finally, eda_simulate() can be used to generate a synthetic EDA signal of a given duration, specifying the number of skin conductance responses or activity ‘peaks’ (n_scr) and the drift of the signal. You can also modify the noise level of the signal.

# Simulate
eda1 = nk.eda_simulate(duration=10, scr_number=1, drift=-0.01, noise=0.05)
eda3 = nk.eda_simulate(duration=10, scr_number=3, drift=-0.01, noise=0.01)
eda3_long = nk.eda_simulate(duration=10, scr_number=3, drift=-0.1, noise=0.01)

# Visualize
eda_df = pd.DataFrame({"EDA1": eda1,
                       "EDA3": eda3,
                       "EDA3_Longer": eda3_long})
nk.signal_plot(eda_df, subplots=True)

Customize your Processing Pipeline

While NeuroKit is designed to be beginner-friendly, experts who desire to have more control over their own processing pipeline are also offered the possibility to tune functions to their specific usage. This example shows how to use NeuroKit to customize your own processing pipeline for advanced users taking ECG processing as an example.

# Load NeuroKit and other useful packages
import neurokit2 as nk
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
%matplotlib notebook

plt.rcParams['figure.figsize'] = [15, 9]  # Bigger images

The Default NeuroKit processing pipeline

NeuroKit provides a very useful set of functions, *_process() (e.g. ecg_process(), eda_process(), emg_process(), …), which are all-in-one functions that cleans, preprocesses and processes the signals. It includes good and sensible defaults that should be suited for most of users and typical use-cases. That being said, in some cases, you might want to have more control over the processing pipeline.

This is how ecg_process() is typically used:

# Simulate ecg signal (you can use your own one)
ecg = nk.ecg_simulate(duration=15, sampling_rate=1000, heart_rate=80)

# Default processing pipeline
signals, info = nk.ecg_process(ecg, sampling_rate=1000)

# Visualize
plot = nk.ecg_plot(signals)

Building your own process() function

Now, if you look at the code of `ecg_process() <https://github.com/neuropsychology/NeuroKit/blob/master/neurokit2/ecg/ecg_process.py#L49>`__ (see here for how to explore the code), you can see that it is in fact very simple.

It uses what can be referred to as “mid-level functions”, such as ecg_clean(), ecg_peaks(), ecg_rate() etc.

This means that you can basically re-create the ecg_process() function very easily by calling these mid-level functions:

# Define a new function
def my_processing(ecg_signal):
    # Do processing
    ecg_cleaned = nk.ecg_clean(ecg, sampling_rate=1000)
    instant_peaks, rpeaks, = nk.ecg_peaks(ecg_cleaned, sampling_rate=1000)
    rate = nk.ecg_rate(rpeaks, sampling_rate=1000, desired_length=len(ecg_cleaned))
    quality = nk.ecg_quality(ecg_cleaned, sampling_rate=1000)


    # Prepare output
    signals = pd.DataFrame({"ECG_Raw": ecg_signal,
                            "ECG_Clean": ecg_cleaned,
                            "ECG_Rate": rate,
                            "ECG_Quality": quality})
    signals = pd.concat([signals, instant_peaks], axis=1)
    info = rpeaks

    return signals, info

You can now use this function as you would do with ecg_process().

# Process the signal using previously defined function
signals, info = my_processing(ecg)

# Visualize
plot = nk.ecg_plot(signals)

Changing the processing parameters

Now, you might want to ask, why would you re-create the processing function? Well, it allows you to change the parameters of the inside as you please. Let’s say you want to use a specific cleaning method.

First, let’s look at the documentation for ``ecg_clean()` <https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_clean>`__, you can see that they are several different methods for cleaning which can be specified. The default is the Neurokit method, however depending on the quality of your signal (and several other factors), other methods may be more appropriate. It is up to you to make this decision.

You can now change the methods as you please for each function in your custom processing function that you have written above:

# Define a new function
def my_processing(ecg_signal):
    # Do processing
    ecg_cleaned = nk.ecg_clean(ecg, sampling_rate=1000, method="engzeemod2012")
    instant_peaks, rpeaks, = nk.ecg_peaks(ecg_cleaned, sampling_rate=1000)
    rate = nk.ecg_rate(rpeaks, sampling_rate=1000, desired_length=len(ecg_cleaned))
    quality = nk.ecg_quality(ecg_cleaned, sampling_rate=1000)

    # Prepare output
    signals = pd.DataFrame({"ECG_Raw": ecg_signal,
                            "ECG_Clean": ecg_cleaned,
                            "ECG_Rate": rate,
                            "ECG_Quality": quality})
    signals = pd.concat([signals, instant_peaks], axis=1)
    info = rpeaks

    return signals, info

Similarly, you can select a different method for the peak detection.

Customize even more!

It is possible that none of these methods suit your needs, or that you want to test a new method. Rejoice yourself, as NeuroKit allows you to do that by providing what can be referred to as “low-level” functions.

For instance, you can rewrite the cleaning procedure by using the signal processsing tools offered by NeuroKit:

def my_cleaning(ecg_signal, sampling_rate):
    detrended = nk.signal_detrend(ecg_signal, order=1)
    cleaned = nk.signal_filter(detrended, sampling_rate=sampling_rate, lowcut=2, highcut=9, method='butterworth')
    return cleaned

You can use this function inside your custom processing written above:

# Define a new function
def my_processing(ecg_signal):
    # Do processing
    ecg_cleaned = my_cleaning(ecg, sampling_rate=1000)
    instant_peaks, rpeaks, = nk.ecg_peaks(ecg_cleaned, sampling_rate=1000)
    rate = nk.ecg_rate(rpeaks, sampling_rate=1000, desired_length=len(ecg_cleaned))
    quality = nk.ecg_quality(ecg_cleaned, sampling_rate=1000)

    # Prepare output
    signals = pd.DataFrame({"ECG_Raw": ecg_signal,
                            "ECG_Clean": ecg_cleaned,
                            "ECG_Rate": rate,
                            "ECG_Quality": quality})

    signals = pd.concat([signals, instant_peaks], axis=1)
    info = rpeaks

    return signals, info

Congrats, you have created your own processing pipeline! Let’s see how it performs:

signals, info = my_processing(ecg)
plot = nk.ecg_plot(signals)

This doesn’t look bad :) Can you do better?

Event-related Analysis

This example shows how to use Neurokit to extract epochs from data based on events localisation and its corresponding physiological signals. That way, you can compare experimental conditions with one another.

# Load NeuroKit and other useful packages
import neurokit2 as nk
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [15, 5]  # Bigger images
plt.rcParams['font.size']= 14

The Dataset

Use the nk.data() function to load the dataset located on Neurokit data folder.

It contains 2.5 minutes of biosignals recorded at a frequency of 100Hz (2.5 x 60 x 100 = 15000 data points).

Biosignals : ECG, RSP, EDA + Photosensor (event signal)

# Get data
data = nk.data("bio_eventrelated_100hz")

This is the data from 1 participant to whom was presented 4 images (emotional stimuli, IAPS-like emotional faces), which we will refer to as events.

Importantly, the images were marked by a small black rectangle on the screen, which led to the photosensor signal to go down (and then up again after the image). This is what will allow us to retrieve the location of these events.

They were 2 types (the condition) of images that were shown to the participant: “Negative” vs. “Neutral” in terms of emotion. Each picture was presented for 3 seconds. The following list is the condition order.

condition_list = ["Negative", "Neutral", "Neutral", "Negative"]

Find Events

These events can be localized and extracted using events_find().

Note that you should also specify whether to select events that are higher or below the threshold using the ``threshold_keep`` argument.

# Find events
events = nk.events_find(data["Photosensor"], threshold_keep='below', event_conditions=condition_list)
events

{'onset': array([ 1024,  4957,  9224, 12984]),
 'duration': array([300, 300, 300, 300]),
 'label': array(['1', '2', '3', '4'], dtype='<U11'),
 'condition': ['Negative', 'Neutral', 'Neutral', 'Negative']}

As we can see, events_find() returns a dict containing onsets and durations for each corresponding event, based on the label for event identifiers and each event condition. Each event here lasts for 300 data points (equivalent to 3 seconds sampled at 100Hz).

# Plot the location of event with the signals
plot = nk.events_plot(events, data)

The output of events_plot() shows the corresponding events in the signal, with the blue dashed line representing a Negative event and red dashed line representing a Neutral event.

Process the Signals

Now that we have the events location, we can go ahead and process the data.

Biosignals processing can be done quite easily using NeuroKit with the bio_process() function. Simply provide the appropriate biosignal channels and additional channels that you want to keep (for example, the photosensor), and bio_process() will take care of the rest. It will return a dataframe containing processed signals and a dictionary containing useful information.

# Process the signal
df, info = nk.bio_process(ecg=data["ECG"], rsp=data["RSP"], eda=data["EDA"], sampling_rate=100)

# Visualize
df.plot()
                                            # theres is a ton of features now, but not in epochs

<matplotlib.axes._subplots.AxesSubplot at 0x1c6b9b8c898>

Create Epochs

We now have to transform this dataframe into epochs, i.e. segments (chunks) of data around the events using epochs_create().

1. We want it to start *1 second before the event onset*

2. and end *6 seconds* afterwards

These are passed into the epochs_start and epochs_end arguments, respectively.

Our epochs will then cover the region from -1 s to +6 s (i.e., 700 data points since the signal is sampled at 100Hz).

# Build and plot epochs
epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-1, epochs_end=6)

Let’s plot some of the signals of the first epoch (and transform them to the same scale for visualization purposes).

for i, epoch in enumerate (epochs):
    epoch = epochs[epoch]  # iterate epochs",

    epoch = epoch[['ECG_Clean', 'ECG_Rate', 'RSP_Rate',
                   'RSP_Phase', 'EDA_Phasic', 'EDA_Tonic']]  # Select relevant columns",

    title = events['condition'][i] # get title from condition list",

    nk.standardize(epoch).plot(title=title, legend=True)  # Plot scaled signals"

Extract Event Related Features

With these segments, we are able to compare how the physiological signals vary across the different events. We do this by: 1. Iterating through our object epochs

2. Storing the mean value of :math:`X` feature of each condition in a new dictionary

3. Saving the results in a readable format

We can call them epochs-dictionary, the mean-dictionary and our results-dataframe.

df = {}  # Initialize an empty dict,

for epoch_index in epochs:
    df[epoch_index] = {}  # then Initialize an empty dict inside of it with the iterative

    # Save a temp var with dictionary called <epoch_index> in epochs-dictionary
    epoch = epochs[epoch_index]

    # We want its features:

    # Feature 1 ECG
    ecg_baseline = epoch["ECG_Rate"].loc[-100:0].mean()  # Baseline
    ecg_mean = epoch["ECG_Rate"].loc[0:400].mean()  # Mean heart rate in the 0-4 seconds
    # Store ECG in df
    df[epoch_index]["ECG_Rate"] = ecg_mean - ecg_baseline  # Correct for baseline


    # Feature 2 EDA - SCR
    scr_max = epoch["SCR_Amplitude"].loc[0:600].max()  # Maximum SCR peak
    # If no SCR, consider the magnitude, i.e.  that the value is 0
    if np.isnan(scr_max):
        scr_max = 0
    # Store SCR in df
    df[epoch_index]["SCR_Magnitude"] = scr_max

    # Feature 3 RSP
    rsp_baseline = epoch["RSP_Rate"].loc[-100:0].mean()  # Baseline
    rsp_rate = epoch["RSP_Rate"].loc[0:600].mean()
    # Store RSP in df
    df[epoch_index]["RSP_Rate"] = rsp_rate - rsp_baseline  # Correct for baseline


df = pd.DataFrame.from_dict(df, orient="index")  # Convert to a dataframe
df["Condition"] = condition_list  # Add the conditions
df  # Print DataFrame

	ECG_Rate	SCR_Magnitude	RSP_Rate	Condition
1	-4.286137	3.114808	2.729480	Negative
2	-5.387987	0.000000	2.094437	Neutral
3	-1.400696	0.000000	-0.062720	Neutral
4	-3.804883	1.675922	-1.674218	Negative

Plot Event Related Features

You can now plot and compare how these features differ according to the event of interest.

sns.boxplot(x="Condition", y="ECG_Rate", data=df)

<matplotlib.axes._subplots.AxesSubplot at 0x1c6bd25e828>

sns.boxplot(x="Condition", y="RSP_Rate", data=df)

<matplotlib.axes._subplots.AxesSubplot at 0x1c6bd673c50>

sns.boxplot(x="Condition", y="SCR_Magnitude", data=df)

<matplotlib.axes._subplots.AxesSubplot at 0x1c6a621a160>

Then interpret : As we can see, there seems to be a difference between the negative and the neutral pictures. Negative stimuli, as compared to neutral stimuli, were related to a stronger cardiac deceleration (i.e., higher heart rate variability), an accelerated breathing rate, and higher SCR magnitude.

Important remarks:

You can’t break anything if you’re on Binder, so have fun. Keep in mind that this is for illustration purposes only.

Data size limits on Github force us to downsample and have only one participant (sample rate would have to be >250 Hz, and you can’t do stats with 4 observations in 1 subjects).

We invite you to read on reporting guidelines for biosignal measures. For ECG-PPG/HRV : Quintana, Alvarez & Heathers, 2016 - GRAPH

Interval-related Analysis

This example shows how to use Neurokit to analyze longer periods of data (i.e., greater than 10 seconds) such as resting state data. If you are looking to perform event-related analysis on epochs, you can refer to this Neurokit example here.

# Load NeuroKit and other useful packages
import neurokit2 as nk
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [15, 9]  # Bigger images
plt.rcParams['font.size']= 13

The Dataset

First, download the dataset located on the GitHub repository.

It contains 5 minutes of physiological signals recorded at a frequency of 100Hz (5 x 60 x 100 = 30000 data points).

It contains the following signals : ECG, PPG, RSP

# Get data
data = pd.read_csv("https://raw.githubusercontent.com/neuropsychology/NeuroKit/master/data/bio_resting_5min_100hz.csv")

This is the resting state data from 1 participant who was asked to close his/her eyes for 8 minutes, trying not to think of anything as well as not to fall asleep.

Process the Signals

In this analysis here, we will focus on extracting ECG and RSP features. To process the respective physiological signals, you can use ecg_process() and rsp_process(). You can then then visualize these signals using ecg_plot() and rsp_plot(). For the purposes of these example, we will select just 3000 datapoints (or 30s) to visualize.

Note: Do remember to specify the correct sampling_rate (in this case, to 100Hz) in which the signals were generated, in all the relevant functions.

# Process ecg
ecg_signals, info = nk.ecg_process(data["ECG"], sampling_rate=100)
plot = nk.ecg_plot(ecg_signals[:3000], sampling_rate=100)

# Process rsp
rsp_signals, info = nk.rsp_process(data["RSP"], sampling_rate=100)
plot = nk.rsp_plot(rsp_signals[:3000], sampling_rate=100)

Extract Features

Now that we have the processed signals, we can now perform the analysis using ecg_intervalrelated() and rsp_intervalrelated(). Simply provide the processed dataframe and these functions will return a dataframe of the features pertaining to the specific signal.

These features will be quite different from event-related features (See Event-related analysis example) as these signals were generated over a longer period of time. Hence, apart from the mean signal rate, variability metrices pertaining to heart rate variability (HRV) and respiratory rate variability (RRV) are also extracted here.

nk.ecg_intervalrelated(ecg_signals)

	ECG_Rate_Mean	HRV_RMSSD	HRV_MeanNN	HRV_SDNN	HRV_SDSD	HRV_CVNN	HRV_CVSD	HRV_MedianNN	HRV_MadNN	HRV_MCVNN	...	HRV_LFn	HRV_HFn	HRV_LnHF	HRV_SD1	HRV_SD2	HRV_SD2SD1	HRV_CSI	HRV_CVI	HRV_CSI_Modified	HRV_SampEn
0	86.394304	3.883777	69.475638	4.903604	3.888256	0.07058	0.055901	69.0	4.4478	0.064461	...	NaN	0.885628	1.137604	2.749412	4.762122	1.732051	1.732051	2.32116	32.992946	1.978637

1 rows × 30 columns

nk.rsp_intervalrelated(rsp_signals)

	RSP_Rate_Mean	RSP_Amplitude_Mean	RRV_SDBB	RRV_RMSSD	RRV_SDSD	RRV_VLF	RRV_LF	RRV_HF	RRV_LFHF	RRV_LFn	RRV_HFn	RRV_SD1	RRV_SD2	RRV_SD2SD1	RRV_ApEn	RRV_SampEn	RRV_DFA_2
0	15.744233	0.397941	100.662988	119.691326	120.504248	NaN	NaN	793512.619536	NaN	NaN	NaN	85.209371	114.041384	1.338367	0.717675	1.504077	0.618535

Optional: Segmenting the Data

If you want to segment your data for analysis, such as analyzing two separate portions of your resting state data, you can simply do so by splitting the ecg_signals dataframe into epochs using epochs_create(). Using this example dataset, let’s say you want to analyze the first half and the second half of the ECG data. This means that each halved data would last for 60 x 2.5s = 150s.

In this function, we would also specify the onset of events to be at the 0th (for the first half of the data) and the 15000th datapoint (for the second half of the data), since there are 30000 data points in total.

# Half the data
epochs = nk.epochs_create(ecg_signals, events=[0, 15000], sampling_rate=100, epochs_start=0, epochs_end=150)

This returns a dictionary of 2 processed ECG dataframes, which you can then enter into ecg_intervalrelated().

# Analyze
nk.ecg_intervalrelated(epochs)

	ECG_Rate_Mean	HRV_RMSSD	HRV_MeanNN	HRV_SDNN	HRV_SDSD	HRV_CVNN	HRV_CVSD	HRV_MedianNN	HRV_MadNN	HRV_MCVNN	...	HRV_LFn	HRV_HFn	HRV_LnHF	HRV_SD1	HRV_SD2	HRV_SD2SD1	HRV_CSI	HRV_CVI	HRV_CSI_Modified	HRV_SampEn
1	86.377089	3.638450	69.497674	5.167181	3.645389	0.074350	0.052354	69.0	4.4478	0.064461	...	NaN	NaN	NaN	2.577680	4.464672	1.732051	1.732051	2.265138	30.932155	1.252763
2	86.411519	4.032578	69.460465	4.648090	4.042033	0.066917	0.058056	69.0	4.4478	0.064461	...	NaN	NaN	NaN	2.858149	4.950459	1.732051	1.732051	2.354850	34.297785	1.881786

2 rows × 30 columns

This then returns a dataframe of the analyzed features, with the rows representing the respective segmented signals. Try doing this with your own signals!

Analyze Electrodermal Activity (EDA)

This example shows how to use NeuroKit2 to extract the features from Electrodermal Activity (EDA) .

# Load the NeuroKit package and other useful packages
import neurokit2 as nk
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [15, 5]  # Bigger images

Extract the cleaned EDA signal

In this example, we will use a simulated EDA signal. However, you can use any signal you have generated (for instance, extracted from the dataframe using read_acqknowledge().

# Simulate 10 seconds of EDA Signal (recorded at 250 samples / second)
eda_signal = nk.eda_simulate(duration=10, sampling_rate=250, scr_number=3, drift=0.01)

Once you have a raw EDA signal in the shape of a vector (i.e., a one-dimensional array), or a list, you can use eda_process() to process it.

# Process the raw EDA signal
signals, info = nk.eda_process(eda_signal, sampling_rate=250)

Note: It is critical that you specify the correct sampling rate of your signal throughout many processing functions, as this allows NeuroKit to have a time reference.

This function outputs two elements, a dataframe containing the different signals (e.g., the raw signal, clean signal, SCR samples marking the different features etc.), and a dictionary containing information about the Skin Conductance Response (SCR) peaks (e.g., onsets, peak amplitude etc.).

Locate Skin Conductance Response (SCR) features

The processing function does two important things for our purpose: Firstly, it cleans the signal. Secondly, it detects the location of 1) peak onsets, 2) peak amplitude, and 3) half-recovery time. Let’s extract these from the output.

# Extract clean EDA and SCR features
cleaned = signals["EDA_Clean"]
features = [info["SCR_Onsets"], info["SCR_Peaks"], info["SCR_Recovery"]]

We can now visualize the location of the peak onsets, the peak amplitude, as well as the half-recovery time points in the cleaned EDA signal, respectively marked by the red dashed line, blue dashed line, and orange dashed line.

# Visualize SCR features in cleaned EDA signal
plot = nk.events_plot(features, cleaned, color=['red', 'blue', 'orange'])

Decompose EDA into Phasic and Tonic components

We can also decompose the EDA signal into its phasic and tonic components, or more specifically, the Phasic Skin Conductance Response (SCR) and the Tonic Skin Conductance Level (SCL) respectively. The SCR represents the stimulus-dependent fast changing signal whereas the SCL is slow-changing and continuous. Separating these two signals helps to provide a more accurate estimation of the true SCR amplitude.

# Filter phasic and tonic components
data = nk.eda_phasic(nk.standardize(eda_signal), sampling_rate=250)

Note: here westandardizedthe raw EDA signal before the decomposition, which can be useful in the presence of high inter-individual variations.

We can now add the raw signal to the dataframe containing the two signals, and plot them!

data["EDA_Raw"] = eda_signal  # Add raw signal
data.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x29adaa05358>

Quick Plot

You can obtain all of these features by using the eda_plot() function on the dataframe of processed EDA.

# Plot EDA signal
plot = nk.eda_plot(signals)

Analyze Respiratory Rate Variability (RRV)

Respiratory Rate Variability (RRV), or variations in respiratory rhythm, are crucial indices of general health and respiratory complications. This example shows how to use NeuroKit to perform RRV analysis.

Download Data and Extract Relevant Signals

# Load NeuroKit and other useful packages
import neurokit2 as nk
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = 15, 5  # Bigger images

In this example, we will download a dataset that contains electrocardiogram, respiratory, and electrodermal activity signals, and extract only the respiratory (RSP) signal.

# Get data
data = pd.read_csv("https://raw.githubusercontent.com/neuropsychology/NeuroKit/master/data/bio_eventrelated_100hz.csv")
rsp = data["RSP"]
nk.signal_plot(rsp, sampling_rate=100) # Visualize

You now have the raw RSP signal in the shape of a vector (i.e., a one-dimensional array). You can then clean it using rsp_clean() and extract the inhalation peaks of the signal using rsp_peaks(). This will output 1) a dataframe indicating the occurrences of inhalation peaks and exhalation troughs (“1” marked in a list of zeros), and 2) a dictionary showing the samples of peaks and troughs.

Note: As the dataset has a frequency of 100Hz, make sure the ``sampling_rate`` is also set to 100Hz. It is critical that you specify the correct sampling rate of your signal throughout all the processing functions.

# Clean signal
cleaned = nk.rsp_clean(rsp, sampling_rate=100)

# Extract peaks
df, peaks_dict = nk.rsp_peaks(cleaned)
info = nk.rsp_fixpeaks(peaks_dict)
formatted = nk.signal_formatpeaks(info, desired_length=len(cleaned),peak_indices=info["RSP_Peaks"])

nk.signal_plot(pd.DataFrame({"RSP_Raw": rsp, "RSP_Clean": cleaned}), sampling_rate=100, subplots=True)

candidate_peaks = nk.events_plot(peaks_dict['RSP_Peaks'], cleaned)

fixed_peaks = nk.events_plot(info['RSP_Peaks'], cleaned)

# Extract rate
rsp_rate = nk.rsp_rate(formatted, desired_length=None, sampling_rate=100) # Note: You can also replace info with peaks dictionary

# Visualize
nk.signal_plot(rsp_rate, sampling_rate=100)
plt.ylabel('BPM')

Text(0, 0.5, 'BPM')

Analyse RRV

Now that we have extracted the respiratory rate signal and the peaks dictionary, you can then input these into rsp_rrv(). This outputs a variety of RRV indices including time domain, frequency domain, and nonlinear features. Examples of time domain features include RMSSD (root-mean-squared standard deviation) or SDBB (standard deviation of the breath-to-breath intervals). Power spectral analyses (e.g., LF, HF, LFHF) and entropy measures (e.g., sample entropy, SampEn where smaller values indicate that respiratory rate is regular and predictable) are also examples of frequency domain and nonlinear features respectively.

A Poincaré plot is also shown when setting show=True, plotting each breath-to-breath interval against the next successive one. It shows the distribution of successive respiratory rates.

rrv = nk.rsp_rrv(rsp_rate, info, sampling_rate=100, show=True)
rrv

Neurokit warning: signal_psd(): The duration of recording is too short to support a sufficiently long window for high frequency resolution. Consider using a longer recording or increasing the `min_frequency`

	RRV_SDBB	RRV_RMSSD	RRV_SDSD	RRV_VLF	RRV_LF	RRV_HF	RRV_LFHF	RRV_LFn	RRV_HFn	RRV_SD1	RRV_SD2	RRV_SD2SD1	RRV_ApEn	RRV_SampEn	RRV_DFA
0	1030.411296	1269.625397	1286.590811	0.0	203.846501	2000.465169	0.1019	0.092476	0.907524	909.757087	1138.34833	1.251266	0.496939	0.693147	0.755783

This is a simple visualization tool for short-term (SD1) and long-term variability (SD2) in respiratory rhythm.

See documentation for full reference

RRV method taken from : Soni et al. 2019

ECG-Derived Respiration (EDR) Analysis

ECG-derived respiration (EDR) is the extraction of respiratory information from ECG and is a noninvasive method to monitor respiration activity under instances when respiratory signals are not recorded. In clinical settings, this presents convenience as it allows the monitoring of cardiac and respiratory signals simultaneously from a recorded ECG signal. This example shows how to use Neurokit to perform EDR analysis.

# Load NeuroKit and other useful packages
import neurokit2 as nk
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [15, 5]  # Bigger images

Download ECG Data

In this example, we will download a dataset containing an ECG signal sampled at 1000 Hz.

# Get data
ecg = np.array(pd.read_csv("https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/ecg_1000hz.csv"))[:, 1]

# Visualize signal
nk.signal_plot(ecg)

Extraction of ECG Features

Now you can extract the R peaks of the signal using ecg_peaks() and compute the heart period using ecg_rate().

Note: As the dataset has a frequency of 1000Hz, make sure the ``sampling_rate`` is also set to 1000Hz. It is critical that you specify the correct sampling rate of your signal throughout all the processing functions.

# Extract peaks
rpeaks, info = nk.ecg_peaks(ecg, sampling_rate=1000)

# Compute rate
ecg_rate = nk.ecg_rate(rpeaks, sampling_rate=1000, desired_length=len(ecg))

Analyse EDR

Now that we have an array of the heart period, we can then input this into ecg_rsp() to extract the EDR.

Default method is by Van Gent et al. 2019 ; see the full reference in documentation (run : nk.ecg_rsp?)

edr = nk.ecg_rsp(ecg_rate, sampling_rate=1000)

# Visual comparison
nk.signal_plot(edr)

The function ecg_rsp() incorporates different methods to compute EDR. For a visual comparison of the different methods, we can create a dataframe of EDR columns each of which are produced by different methods, and then plot it, like so:

edr_df = pd.DataFrame({"Van Gent et al.": nk.ecg_rsp(ecg_rate, sampling_rate=1000),
           "Charlton et al." : nk.ecg_rsp(ecg_rate, sampling_rate=1000, method="charlton2016"),
           "Soni et al.": nk.ecg_rsp(ecg_rate, sampling_rate=1000, method="soni2019"),
           "Sarkar et al.": nk.ecg_rsp(ecg_rate, sampling_rate=1000, method="sarkar2015")})

nk.signal_plot(edr_df, subplots=True)

Extract and Visualize Individual Heartbeats

This example shows how to use NeuroKit to extract and visualize the QRS complexes (individual heartbeats) from an electrocardiogram (ECG).

# Load NeuroKit and other useful packages
import neurokit2 as nk
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [15, 9]  # Bigger images

Extract the cleaned ECG signal

In this example, we will use a simulated ECG signal. However, you can use any of your signal (for instance, extracted from the dataframe using the read_acqknowledge().

# Simulate 30 seconds of ECG Signal (recorded at 250 samples / second)
ecg_signal = nk.ecg_simulate(duration=30, sampling_rate=250)

Once you have a raw ECG signal in the shape of a vector (i.e., a one-dimensional array), or a list, you can use ecg_process() to process it.

Note: It is critical that you specify the correct sampling rate of your signal throughout many processing functions, as this allows NeuroKit to have a time reference.

# Automatically process the (raw) ECG signal
signals, info = nk.ecg_process(ecg_signal, sampling_rate=250)

This function outputs two elements, a dataframe containing the different signals (raw, cleaned, etc.) and a dictionary containing various additional information (peaks location, …).

Extract R-peaks location

The processing function does two important things for our purpose: 1) it cleans the signal and 2) it detects the location of the R-peaks. Let’s extract these from the output.

# Extract clean ECG and R-peaks location
rpeaks = info["ECG_R_Peaks"]
cleaned_ecg = signals["ECG_Clean"]

Great. We can visualize the R-peaks location in the signal to make sure it got detected correctly by marking their location in the signal.

# Visualize R-peaks in ECG signal
plot = nk.events_plot(rpeaks, cleaned_ecg)

Once that we know where the R-peaks are located, we can create windows of signal around them (of a length of for instance 1 second, ranging from 400 ms before the R-peak), which we can refer to as epochs.

Segment the signal around the heart beats

You can now epoch all these individual heart beats, synchronized by their R peaks with the ecg_segment() function.

# Plotting all the heart beats
epochs = nk.ecg_segment(cleaned_ecg, rpeaks=None, sampling_rate=250, show=True)

This create a dictionary of dataframes for each ‘epoch’ (in this case, each heart beat).

Advanced Plotting

This section is written for a more advanced purpose of plotting and visualizing all the heartbeats segments. The code below uses packages other than NeuroKit2 to manually set the colour gradient of the signals and to create a more interactive experience for the user - by hovering your cursor over each signal, an annotation of the signal corresponding to the heart beat index is shown.

Custom colors and legend

Here, we define a function to create the epochs. It takes in cleaned as the cleaned signal dataframe, and peaks as the array of R-peaks locations.

%matplotlib notebook
plt.rcParams['figure.figsize'] = [10, 6]  # resize

# Define a function to create epochs
def plot_heartbeats(cleaned, peaks, sampling_rate=None):
    heartbeats = nk.epochs_create(cleaned, events=peaks, epochs_start=-0.3, epochs_end=0.4, sampling_rate=sampling_rate)
    heartbeats = nk.epochs_to_df(heartbeats)
    return heartbeats
heartbeats = plot_heartbeats(cleaned_ecg, peaks=rpeaks, sampling_rate=250)
heartbeats.head()

	Signal	Index	Label	Time
0	-0.188295	141	1	-0.300000
1	-0.182860	142	1	-0.295977
2	-0.177281	143	1	-0.291954
3	-0.171530	144	1	-0.287931
4	-0.165576	145	1	-0.283908

We then pivot the dataframe so that each column corresponds to the signal values of one channel, or Label.

heartbeats_pivoted = heartbeats.pivot(index='Time', columns='Label', values='Signal')
heartbeats_pivoted.head()

Label	1	10	11	12	13	14	15	16	17	18	...	32	33	34	35	4	5	6	7	8	9
Time
-0.300000	-0.188295	-0.130393	-0.133485	-0.142082	-0.129604	-0.128826	-0.134212	-0.126986	-0.128488	-0.122148	...	-0.129433	-0.155517	-0.097891	-0.186199	-0.115438	-0.133537	-0.136313	-0.137583	-0.137964	-0.129776
-0.295977	-0.182860	-0.129565	-0.132160	-0.141467	-0.128912	-0.128071	-0.132954	-0.125978	-0.127522	-0.121446	...	-0.128514	-0.154457	-0.096876	-0.190515	-0.114778	-0.132642	-0.134961	-0.136883	-0.137485	-0.128841
-0.291954	-0.177281	-0.128556	-0.130639	-0.140687	-0.128097	-0.127219	-0.131499	-0.124859	-0.126416	-0.120663	...	-0.127415	-0.153226	-0.095801	-0.194216	-0.113998	-0.131618	-0.133385	-0.136045	-0.136902	-0.127814
-0.287931	-0.171530	-0.127327	-0.128864	-0.139683	-0.127114	-0.126234	-0.129797	-0.123588	-0.125143	-0.119759	...	-0.126073	-0.151793	-0.094629	-0.197353	-0.113073	-0.130441	-0.131522	-0.135024	-0.136184	-0.126646
-0.283908	-0.165576	-0.125839	-0.126767	-0.138381	-0.125906	-0.125059	-0.127774	-0.122108	-0.123664	-0.118693	...	-0.124416	-0.150128	-0.093312	-0.199973	-0.111967	-0.129071	-0.129285	-0.133753	-0.135299	-0.125278

5 rows × 35 columns

# Import dependencies
import matplotlib.pyplot as plt

# Prepare figure
fig, ax = plt.subplots()
plt.close(fig)
ax.set_title("Individual Heart Beats")
ax.set_xlabel("Time (seconds)")

# Aesthetics
labels = list(heartbeats_pivoted)
labels = ['Channel ' + x for x in labels] # Set labels for each signal
cmap = iter(plt.cm.YlOrRd(np.linspace(0,1, int(heartbeats["Label"].nunique())))) # Get color map
lines = [] # Create empty list to contain the plot of each signal

for i, x, color in zip(labels, heartbeats_pivoted, cmap):
    line, = ax.plot(heartbeats_pivoted[x], label='%s' % i, color=color)
    lines.append(line)

# Show figure
fig

Interactivity

This section of the code incorporates the aesthetics and interactivity of the plot produced. Unfortunately, the interactivity is not active in this example but it should work in your console! As you hover your cursor over each signal, annotation of the channel that produced it is shown. The below figure that you see is a standstill image.

Note: you need to install the ``mplcursors`` package for the interactive part (``pip install mplcursors``)

# Import packages
import ipywidgets as widgets
from ipywidgets import interact, interact_manual

import mplcursors

# Obtain hover cursor
mplcursors.cursor(lines, hover=True, highlight=True).connect("add", lambda sel: sel.annotation.set_text(sel.artist.get_label()))
# Return figure
fig

{

“cells”: [

{

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“# Locate P, Q, S and T waves in ECG”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“This example shows how to use Neurokit to delineate the ECG peaks in Python using NeuroKit. This means detecting and locating all components of the QRS complex, including P-peaks and T-peaks, as well their onsets and offsets from an ECG signal.”

]

}, {

“cell_type”: “code”, “execution_count”: 4, “metadata”: {}, “outputs”: [], “source”: [

“# Load NeuroKit and other useful packagesn”, “import neurokit2 as nkn”, “import numpy as npn”, “import pandas as pdn”, “import matplotlib.pyplot as pltn”, “import seaborn as snsn”, “%matplotlib inlinen”,, “plt.rcParams[‘figure.figsize’] = [8, 5] # Bigger images”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“In this example, we will use a short segment of ECG signal with sampling rate of 3000 Hz. “

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“## Find the R peaks”

]

}, {

“cell_type”: “code”, “execution_count”: 5, “metadata”: {}, “outputs”: [], “source”: [

“# Retrieve ECG data from data folder (sampling rate= 1000 Hz)n”, “ecg_signal = nk.data(dataset="ecg_3000hz")[‘ECG’]n”, “# Extract R-peaks locationsn”, “_, rpeaks = nk.ecg_peaks(ecg_signal, sampling_rate=3000)”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“The [ecg_peaks()](https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_peaks>) function will return a dictionary contains the samples at which R-peaks are located. “

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“Let’s visualize the R-peaks location in the signal to make sure it got detected correctly.”

]

}, {

“cell_type”: “code”, “execution_count”: 6, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}, {

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize R-peaks in ECG signaln”, “plot = nk.events_plot(rpeaks[‘ECG_R_Peaks’], ecg_signal)n”, “n”, “# Zooming into the first 5 R-peaksn”, “plot = nk.events_plot(rpeaks[‘ECG_R_Peaks’][:5], ecg_signal[:20000])”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“Visually, the R-peaks seem to have been correctly identified. You can also explore searching for R-peaks using different methods provided by Neurokit [ecg_peaks()](https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_peaks>).”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“## Locate other waves (P, Q, S, T) and their onset and offset”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“In [ecg_delineate()](https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_delineate>), Neurokit implements different methods to segment the QRS complexes. There are the derivative method and the other methods that make use of Wavelet to delineate the complexes. “

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“### Peak method”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“First, let’s take a look at the ‘peak’ method and its output.”

]

}, {

“cell_type”: “code”, “execution_count”: 7, “metadata”: {}, “outputs”: [], “source”: [

“# Delineate the ECG signaln”, “_, waves_peak = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000)”

]

}, {

“cell_type”: “code”, “execution_count”: 8, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}, {

“data”: {

“image/png”: “iVBORw0KGgoAAAANSUhEUgAAAewAAAEvCAYAAACHVvJ6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd3wcxfn/33NFvVmS5SYb27hgG4MBg+kYMMWmB0INiYEEQkkIhISS8E3yggRCSAL5pVACIYUSQgndBIPpxcbGGBdkG1fZ6pbVy93t/P7Y27076U6629s7aaV5v1730mnL7NgfzTw7M8/zjJBSolAoFAqFYnDjGugKKBQKhUKh6B9lsBUKhUKhcADKYCsUCoVC4QCUwVYoFAqFwgEog61QKBQKhQNQBluhUCgUCgfgGegK9EVpaamcOHHiQFdDAWzz+QCY6PUmdF+XrwGATG9J75MVFfrP6dOTqltPGoLFlthbrOOwXbMU6QVKs1hY1RDSr6PS0B5WrlxZL6UcGe3coDbYEydO5NNPPx3oaiiA3+/ZA8ANxcUJ3VezZykAo4oX9D556636z7vuSqpuPVkaLHaBvcU6Dts1S5FeoDSLhVUNIf06Kg3tQQixPea5wZw4Ze7cuVIZbIVCoVAMF4QQK6WUc6OdU2vYCoVCoVA4AGWwFXFxfXU111dXJ3zfjuqn2VH9dPST556rf2zm6XP1z3DHds1SpBcozWJhVUNIv45Kw9QzqNewFYOHJk2zdF9Aa499sqHBYm36pj01xToO2zVLkV6gNIuFVQ0h/TrGq6HP56OyspLOzs6U1MMpZGVlUV5ejjcBh0JlsBUKhUKRNiorK8nPz2fixIkIIQa6OgOClJKGhgYqKyuZNGlS3PepKXGFQqFQpI3Ozk5KSkqGrbEGEEJQUlKS8CyDMtgKhUKhSCvD2VgbWPk/UFPiiriYl51t6b7c7D6me0480WJt+mZSaop1HLZrliK9QGkWC6saQvp1dJqGv/zlL3niiSdwu924XC4efPBBHn74YW688UZmzpxp67Py8vJobW1NuhwVh61QKBSKtLFhwwZmzJgxoHX46KOPuPHGG3n77bfJzMykvr6e7u5uxo4dm5LnxTLY0f4vVBy2QqFQDGM++qqB1i7/QFdj0FBVVUVpaSmZmZkAlJaWMnbsWObPn29m13zkkUeYNm0a8+fP5zvf+Q7XXXcdAIsXL+b73/8+Rx55JJMnT+aZZ54BoLW1lRNPPJGDDz6Y2bNn88ILL9heb2WwFXFxVVUVV1VVJXzf9qrH2V71ePSTCxfqH5t5fKH+Ge7YrlmK9AKlWSysagghHdu6/Fz08Mdc8/gq/YRqd5x88sns3LmTadOmcc011/DOO+9EnN+9ezd33HEHH3/8MW+88QZffvllxPmqqiref/99Xn75ZW655RZAD9N6/vnnWbVqFcuWLeOHP/whds9gqzVsRVx0WfzD06Qv9smODou16Rtfaop1HHZoFtAk7d1+8rO8KdMLlGaxsKohhHTc26H/XL+7ST8xiNrdL15ax/rdzbbWY+bYAn52xqw+r8nLy2PlypW89957LFu2jAsuuIC7777bPL98+XKOO+44ioM53L/+9a+zceNG8/zZZ5+Ny+Vi5syZ1NTUAHqo1m233ca7776Ly+Vi165d1NTUMHr0aNv+bcpgKxSKmPzm9QoeeOcrtvxqkZqOcyjdfiP5ivLMDsftdjN//nzmz5/P7Nmz+fvf/26e629kbEylh1/7+OOPU1dXx8qVK/F6vUycONH25DDKYCsUipg88M5XAHT5Naz7KysGkoCmGxR/ElnTUkV/I+FUUVFRgcvlYurUqQCsXr2affbZh7Vr1wJw2GGHccMNN9DY2Eh+fj7PPvsss2fP7rPMpqYmysrK8Hq9LFu2jO3bY266ZRllsBUKRb90+QPKYDsUYwToDwzeiKB009rayve+9z327t2Lx+NhypQpPPTQQ5x33nkAjBs3jttuu4158+YxduxYZs6cSWFhYZ9lXnLJJZxxxhnMnTuXOXPmsN9++9leb2WwFXFxXE6Opfvyc6bFPnn66RZr0zfTUlOs47BTsy6/ljK9QGkWC6saQkjH+k7dUPsCwRG2ancccsghfPjhh72Ov/322+b3iy++mCuvvBK/388555zDySefDMBjjz0WcY8RrlVaWspHH30U9Xl2xGCDMtiKOLmsqMjSfaVFR8Y+edNNFmvTN0empljHYadmfk2mTC9QmsXCqoYQ0rE26NTlD06Nq3YXHz//+c9ZunQpnZ2dnHzyyZx99tkDXSVlsBUKRf9omppOdSpacEo8oDRMiHvvvXegq9ALZbAVcbF4924AHkswE9DW3Y8BMGns4t4n58/Xf4ZNQ9nBY8FiF9tbrOOwUzNNypTpBUqzWFjVEEI6alIfGZqpq1W7cywqUkOhUPSLGpw5FzWyHjoog61IG03tPlZs2zPQ1VBYQBvEew4o+kbZ66GDMtiKtPHD/6zm6w98RFNHH9nPFIOSwbxJkKJv1MvW0EEZbEXaWBf0Vm3pVAbbaQQGX84NRZwYDoMqz1kkS5YsYfr06UyZMiUiLelgRjmdKeLilNxcS/cV5oYyGXnd+vthpy/Y+59/ftL1isas1BTrOOzQzECTMmV6gdIsFlY1hJCOVR09Rtiq3REIBLj22mt54403KC8v59BDD+XMM8+0fR9su1EGWxEXF/WT5ScWxYWHmt/dLv0d30zgcM01SdcrGoempljHYYdmBpqUKdMLlGaxsKohhHSUdfWRJ1S7Y/ny5UyZMoXJkycDcOGFF/LCCy8MeoNty5S4EOJRIUStEGJtjPNCCPEHIcRmIcQaIcTBdjxXkT46NI0OC7mINc2HpulT4EF7HdqMoL1d/9iMr13/DHfs0Cx0jJTpBUqzWFjVEEI69vISV+2OXbt2MX78ePP38vJydu3aNYA1ig+7RtiPAX8E/hHj/EJgavAzD/hL8KfCIVxdXQ0kHg+6vVrfV3nS2MXmCLvbGGEvWqT/tDke9PFgscM9HtQOzQw0KVOmFyjNYmFVQwjpqMlFkScGWbsz4rfDmXW+PmL3tYfKDWfOYv3TXg9Pnxd5Lp7nR3OiFGLwr/LbMsKWUr4L9BWvcxbwD6nzMVAkhBhjx7MVzsEVbBCh7f4UTkF5GjsXpV1vysvL2blzp/l7ZWUlYy28FKWbdK1hjwN2hv1eGTxWlabnKwYBvUbYCsegOn3nMgh31YygrxGxN6fv8zml1mZlDj30UDZt2sTWrVsZN24cTz31FE888UTiBaWZdBnsaHMNUXsAIcSVwJUAEyZMSGWdFGnGNNhqhO04VPIN5xIIvmw5Yco3XXg8Hv74xz9yyimnEAgEuPzyy5k1a2D25k6EdBnsSmB82O/lwO5oF0opHwIeApg7d67qJoYQxiBNbSThPJRmzkUlvYnOokWLWLQoygL5ICZdBvtF4DohxFPozmZNUko1He4gzsrPt3RfUf6cXseMN34WL06iRrGZk5piHYftmqVIL1CaxcKqhhDSMdAjqku1O+dii8EWQjwJzAdKhRCVwM8AL4CU8gHgVWARsBloBy6z47mK9HGOxY5jRFjnL+mxzZ/qOFKKHZoZSIky2AOAVQ0hpKMme0xmqnbnWGwx2FLKi/o5L4Fr7XiWYmBoDAQAGOF2J3SfP6AHZnrcOaEpceNLffDVv7TUljoatAeLzbG3WMdhh2YGmpQp0wuUZrGwqiGEdDTam7mCrdqdY1GZzhRxcUNNDZB4POjOmqcBPabXsNOmk/h5wQBKm+NBjbjM4R7Ta4dmBpokZXqB0iwWVjWEkI6aXBB5QrU7x6I2/1CkDcP1RYUIOQ/ldOZcVBTl0EEZbEXaMLxVVefvPNRLlnNR2g0dlMFWpJ2A6kAch3rHci7m9poqDNvk8ssvp6ysjP3333+gq5IQymAr0o4aYTuPXhtIKByDkq43ixcvZsmSJQNdjYRRTmeKuLigoMDSfcUFc83vIaez4Jerr062WlGZm5piHYcdmhlIKVOmFyjNYmFVQwjp2GtKXLU7jj32WLZt2zbQ1UgYZbAVcbEwL8/SfYV5oSknMw7b6D8uuCDZakVl/9QU6zjs0MxAk6RML1CaxcKqhhDSUZPbIk+odudYlMFWxEWV3w/AGE9ifzI+fxMAXk9h79Skxm4548dHudM6TcFiC+0t1nHYoZlBQMqU6QVKs1hY1RBCOvZaghpk7W7x7t5Zqk/JzeWiwkI6NM3cYjScs/LzOSc/n8ZAwAx9M7ASAucUlMFWxMWttbVA4o2hsvZ5IDKm13Q6u/RS/afN8aDPB4sd7vGgdmompUyZXqA0i4VVDSGkY0AeF3lCtTvHogy2Im0Y7/nKgcl5qNAg5yLNTGeD0028r5eRbJerz/Mj3O4hPaLuifISV6QNFYftXFTyDeeiXpB7c9FFF3HEEUdQUVFBeXk5jzzyyEBXKS7UCFuRNkKZzga0GgoLqBG2c1HtrTdPPvnkQFfBEmqErUgbZliX6vwdh9pT2bmol62hgxphK+LiW4WF/V8UhdLCI8zvxtScOSX+wx8mXa9oHJGaYh2HHZoZBDRSphcozWJhVUMI6dhrCUq1O8eiDLYiLo7PzbV0X37udPO7YbDNEfYZZyRdr2hMT02xjsMOzQw0KVOmFyjNYmFVQwjpGJAbI0+odudYlMFWxMXW7m4AJmVkJHRfV7e+SW5mRil+TfdcMt/4Kyr0n9N7G4hkqA8WW2pvsY7DDs0MpJQp0wuUZrGwqiGEdDSam5G4SLU756IMtiIufhHc9D7REIrd9S8Dekyv4Wlseq1edZX+0+Z40JeDxQ73eFA7NDPQJCnTC5RmsbCqIYR01LTg1LgxM67anWNRTmeKtBEIjrCV05nzUKFBzsVwOlPOZ85HGWxF2vD3dDpTOAbV2TsX4wVZSuXtb7Bz506OP/54ZsyYwaxZs7j//vsHukpxoabEFWmjl9OZwjEoyZxLuHaaBPfAVWXQ4PF4+O1vf8vBBx9MS0sLhxxyCCeddBIzZ84c6Kr1iRphK9KGabBV1ixHED4aUy9ZziV8OUPNlOiMGTOGgw8+GID8/HxmzJjBrl27BrhW/aNG2Iq4uKqoyNJ9I4uONb8bHYdpCH7606TrFY1jU1Os40hWMy1iZCZTphcozWJhVUMI17HDPBbQJF7V7iLYtm0bn332GfPmzRvoqvSLLQZbCHEqcD/6bMtfpZR39zhfCPwLmBB85r1Syr/Z8WxFejgiJ8fSfXk5k83vfnOEHbQECxYkXa9oTE5NsY4jWc26/aGpEClJmV6gNIuFVQ0hpKOmrTWPpVJHqxpu3f1Yr2OFubMoLjwUTfOxvfrxXueL8ucwIn8O/kA7O2uejjgXHt3QH62trZx77rncd999FBQUJFr1tJO0wRZCuIE/AScBlcAKIcSLUsr1YZddC6yXUp4hhBgJVAghHpdSdif7fEV62NDVBcCMzMyE7uvo0veyzcoYZR4zp1dXr9Z/zpmTfAXDqA4WO9reYh1HspoJ10jzWECTKdMLlGaxsKohhHTsNVOi2h0APp+Pc889l0suuYSvfe1rA12duLBjhH0YsFlKuQVACPEUcBYQbrAlkC+EEEAesAfw2/BsRZr4dUMDkHg8aHXDEgAmjP6Wecz0Ev/BD/SfNseDLgkWO9zjQZPVbFTpN8xjmpQp0wuUZrGwqiGEdAzIQ8xjqdTRqoZ9jYhdLm+f5z3unIRG1AZSSq644gpmzJjBjTfemPD9A4UdTmfjgJ1hv1cGj4XzR2AGsBv4ArheSqlcj4YRWoQD0wBWRBE3kc5KA1gRRVKEOw9qqtcF4IMPPuCf//wnb731FnPmzGHOnDm8+uqrA12tfrFjhB1tV/SezfsUYDVwArAv8IYQ4j0pZXOvwoS4ErgSYMKECTZUTzEY0CI6DdX7O4GIqVSlmWNRXuK9Ofroox0Zk27HCLsSGB/2ezn6SDqcy4DnpM5mYCuwX7TCpJQPSSnnSinnjhw5MtolCgcS/mavsmY5A0119EOCXmvYCsdih8FeAUwVQkwSQmQAFwIv9rhmB3AigBBiFDAd2GLDsxUOQVMxvY4jYlZESeZYwl+8VNtzNklPiUsp/UKI64DX0cO6HpVSrhNCfDd4/gHgDuAxIcQX6FPoN0sp65N9tiJ9XF9cbOm+UcUnApEdhdmB/OpXSdcrGiempljHkaxmrb6QZlLKlOkFSrNYWNUQQjpqYV2tlKh252BsicOWUr4KvNrj2ANh33cDJ9vxLMXAcFBWlqX7crL01ZKmDp95zDTeRx6ZdL2iMT41xTqOZDVr7uo0jwU0mTK9QGkWC6saQkjHQJjB1mTqdFQaph6V6UwRF5916p13oh1Ie6ceQCBlKA7bnKH78EP9p80dyM5gscO9A0lWM02G9sPWJCnTC5RmsbCqIYTr2GNpQ7U7x6IMtiIu7t+zB0g8HrRmz5sAFBZebB4zp8Rvu03/aXM86JvBYod7TG+ymnmyzjePaVKmTC9QmsXCqoYQ0lHTZpvHNC11OioNU4/a/EORFiKczpQHkyOQyrt4SBA5wlY6AnR2dnLYYYdx4IEHMmvWLH72s58NdJXiQo2wFWlBeYk7j4Dq6IcE4bvjqXdlnczMTN566y3y8vLw+XwcffTRLFy4kMMPP3ygq9YnaoStSAsRozXVazgClelsaCDVi1cvhBDk5eUBek5xn8+Hnjl7cKMMtiItqBG285AqO92QQGUZjE4gEGDOnDmUlZVx0kknDZ/tNRVDn5tLSizdN7rkVAD2hLbkDXUa992XbLWicmpqinUcyWq2vbHHyCxFeoHSLBZWNYSQjgG5wzymSQZfu5s/v/ex88+Ha66B9nZYtKj3+cWL9U99PZx3XuS5OJ3p3G43q1evZu/evZxzzjmsXbuW/fffP8HKpxdlsBVxYWV7P4DszNEAaG3t5jFzhJ2CbRrBOdv7pZqkNdNCqf41Scr0AqVZLKxqCCEdpdxuHtOkVO2uB0VFRcyfP58lS5Yog60YGnzUrhvcI3JyErqvtV3PQCvlaPOY6QSzdKn+c8GCpOsXzpZgsZPtLdZxJKuZJkOjO02TKdMLlGaxsKohhHQM90UIpFBHyxr2NSLOyen7fGmppfC0uro6vF4vRUVFdHR0sHTpUm6++eaEy0k3ymAr4uLBvXuBxDuOur3vAiAyvm4eM6fE77xT/2lzx/FusNjh3vknq5kmzzaPaVKmTC9QmsXCqoYQruN085iUqHYHVFVV8a1vfYtAIICmaZx//vmcfvrpA12tflEGW5EWlNOZ81Be4kMDLSKsSwkJcMABB/DZZ58NdDUSRnmJK9KC2uLPeaiXrKGBSpwydFAGW5EWjBAht0uo0BKHEC6TVB29Y1EJcIYOymAr0oLR+XtcQo3WHELElLjWx4WKQY0m9XZnfFc4F7WGrYiLn5WW9n9RFMaW6o4cWxr0nsLrdoU6/wcftKNqvTg9NcU6jmQ1q9rZY2SWIr1AaRYLqxpCSEdN+xKPW+DXpD67NQjanZTSEZnFUomVWStlsBVxMSkjw9J9mRl6h6PJJgA8bhEauU2fHuu2pChNTbGOI2nNtB77KKdIL1CaxcKqhhDe9iRel4tONH12a4DbXVZWFg0NDZSUlAxboy2lpKGhgawEt01VBlsRF8va2gA4Pjc3ofta2iqAUBy2x+UKTYm/9JL+84wz7KlkkIpgsdPtLdZxJKtZQBabxzRJyvQCpVksrGoIYTpqEo9bN4wyhTrGq2F5eTmVlZXU1dXZ+nynkZWVRXl5eUL3KIOtiIu/N+kj5EQ7jvqmj4BQTK/XLej2B+fEf/tb/afNHcdHwWKHe+efvGahlJCalCnTC5RmsbCqIYR0lHIybpfurpRKHePV0Ov1MmnSJFufPVxQTmeKtGA6nbmV05lTMLz53S6h9jB3MAEp8bqV09lQQBlsRVowwkm8Lpfq/B1CuGe/esdyLpoMTYmrkEpnowy2Ii0YHpEet4rDdgrGi5XHJVT8roPRNN3pDFQcttNRBluRFgwb7Xa51LScQwi9ZKlZESejSX1Zw/iucC62OJ0JIU4F7gfcwF+llHdHuWY+cB/gBeqllMfZ8WxFerirrMzSfeVl5wBQu8MP6E5n5hr2P/9pS916ck5qinUcyWq2rl73UPa6g1PiKdILlGaxsKohhHQMaCvxuF3B71K1OweTtMEWQriBPwEnAZXACiHEi1LK9WHXFAF/Bk6VUu4QQlj/K1QMCGM81v5UvJ5CADTZAASnV43X/PHjbalbTwpTU6zjSFazgNYK6KF4mpQp0wuUZrGwqiGEdJRhTmcyhToqDVOPHSPsw4DNUsotAEKIp4CzgPVh11wMPCel3AEgpay14bmKNPJaq955L8zLS+i+pta1QFgctjssDvvf/9Z/XnCBPZUMsjZY7P72Fus4ktdsBBDm2Z8ivUBpFgurGkJIx4CUkalJVbtzLHYY7HHAzrDfK4F5Pa6ZBniFEG8D+cD9Usp/2PBsRZr4d3MzkHjHsaf5UwA0qadJNKZXpZSIv/xFv8jmjuPTYLHDveNIVrOApm9s7HUH/Q5SpBcozWJhVUMIb3vleMKdzlS7cyx2GOxoueV6ujZ4gEOAE4Fs4CMhxMdSyo29ChPiSuBKgAkTJthQPcVgwPBONTqOgCZV1p5BTkgzoXbrcjBaWKYz5SXubOzwEq8EwlcvyoHdUa5ZIqVsk1LWA+8CB0YrTEr5kJRyrpRy7siRI22onmIwYMZhBzsOlTxl8GNo5lZhXY5Gj8NWYV1DATsM9gpgqhBikhAiA7gQeLHHNS8AxwghPEKIHPQp8w02PFvhEIx+wpyaU9s1DnoCQY28bpf5XeE8AlrYGrbS0dEkPSsppfQLIa4DXkcP63pUSrlOCPHd4PkHpJQbhBBLgDWAhh76tTbZZyucgxaWOAXUCNsJhGvmUxbbsciw/bBVu3M2tiwjSilfBV7tceyBHr//BviNHc9TpJ/fjxpl6b7xo84HYPPeFkAfrUEwHvSZZ+ypXA/OT02xjiNZzbTtejCH1+WiTfpTphcozWJhVUMI6RiQ75rtTkrV7pyM8vtRxMUIt9vSfR53DgCa1L1djYxLUkooLbWncj3ISU2xjiNpzbTQCDugpU4vUJrFwqqGEN72wp3OUO3OwSiDrYiL51v0EfI5+fkJ3dfYshoAKfWRgul0pkl47DH9osWLbamjwepgsXPsLdZxJKtZQOqJNzxul+6DkCK9QGkWC6saQkhHTQtPTaranZNRBlsRFy9Y7Dj2Gp2GPAUIC+tSHUfKSVYzKY8FwGt4iSuDnXasagjhba8stPmHelF2NGrzD0Va6Ol0prxVBz+B8Clx5azkWHpNiSscizLYirRgdBSm05kyAIOegPmS5VIvWA5Gk6F2p+KwnY0y2Iq0IMOyZgFqT2wHYPTtXpXpzLmY+Q/CfEcUjkUZbEVa0MJGa6A6DicQmhJ3qRkRh2Ko5jHDugauLorkUU5nirj4y+jRlu7bZ/QlAKysqgEgIzxxyquvxrwvGS5JTbGOI1nNtPVbAd2zX5OkTC9QmsXCqoag69jlDwBvhu3Wpdqdk1EGWxEX2S5rkzEulxfoPcLWNAk5OfZUrgfe1BTrOJLWLDjCdonglHiK9AKlWSysagiGjvr9ERkGVbtzLMpgK+LiyaYmAC4qLEzovj1NKwDQND0OOyJF4p//rF90zTU21VJnRbDYQ+0t1nEkq1lA5uN2CVwiOMJOkV6gNIuFVQ1B11EfYYfanUyhjkrD1KPWsBVx8XpbG6+3tSV8X1PbOpra1vXyEtc04Omn9Y/NrHta/wx37NDMJfRPQJMp0wuUZrGwqiHoOrZ16HssecJTk6p251iUwVakBcNpSYWXOAdNk7iEwKW213QssoeXuPL1dDbKYCvSguyROEV5iQ9+NCnNKXFlr51NhNOZwrEog61IC4aBzlCJUxxDQNMdzswpcYXjkMHALrcaYQ8JlMFWpAWjowilJlU9x2BHk1Jfw1ZT4s4lKJvLpb94qQQ4zkZ5iSvi4rGxYy3dN2nsYgC0zVuAHvthv/22HVXrxeLUFOs4ktZMrg129MEp8RTpBUqzWFjVEHQdq5s6gTeDMyXBFy/V7hyLGmEr0oJmOp2FhXUpBjUBTeI2psSVXo7E0M0twsLzFI5FjbAVcfG3vXsBuKyoKKH76vd+CEBAlgE9wrruvVe/6Kab7KlkkA+DxR5pb7GOI1nNNJmPyyVwGyOzFOkFSrNYWNUQdB072rsBEEL/pFJHpWHqUSNsRVy8097OO+3tCd/X0r6RlvaNYeElYU5nL7+sf2xm48v6Z7iTrGZ6WBeI4JS4TJFeoDSLhVUNQdfR5/sKwJwSlxLV7hyMMtiKtGB4GXuV05lj0KQ0p1IVzsYddDpT7c7ZKIOtSAu9comrNdFBT0BKRHANGwht/aRwDEYzEwK1hj0EUAZbkRbMsC61L69j0LRg4hQjD/UA10dhHbdLhNawFY7FFoMthDhVCFEhhNgshLilj+sOFUIEhBDn2fFcRfrIFIJMC1OjLuHFJbzmeqgxvapJCdnZ+sdmvNn6Z7iTtGYy1NEDyOyslOgFSrNYWNUQdB1l0K/YSDErVbtzNEl7iQsh3MCfgJOASmCFEOJFKeX6KNf9Gng92Wcq0s+DY8ZYum+fMcG9lT//ErdLmBmXAhrw2mt2VS+CS1JTrONIVrOAXGVOpQJ0v/gK2Rlu2+oXjtIsOlY1BF3H9bubgffC4rBR7c7B2DHCPgzYLKXcIqXsBp4Czopy3feAZ4FaG56pcBjGemhwCVvF9ToAKUNx2KCmU52IoZmx65rS0NnYEYc9DtgZ9nslMC/8AiHEOOAc4ATgUBueqUgzf2lsBODqESMSuq+28R0ApCyL8DjWNAl33KFfdPvt9lUUeCdY7HH2Fus4ktUsoOXiEgKBrpnnV3eCx227XqA0i4VVDUHXUfo7AWNpIzjCVu3Osdgxwo62wNLzNe4+4GYpZaDfwoS4UgjxqRDi07q6Ohuqp7CDTzo6+KSjI+H72jq20taxlUBwDdsd7nT25pv6x2a2vql/hjvJa6bnoDaWUN3LlqVEL1CaxcKqhqDrSEAfSxmbuNFO0jIAACAASURBVEip2p2TsWOEXQmMD/u9HNjd45q5wFNCb/mlwCIhhF9K+d+ehUkpHwIeApg7d66avxkiaFKaealBTYk7ASkjHQUVzsVoe2pK3NnYYbBXAFOFEJOAXcCFwMXhF0gpJxnfhRCPAS9HM9aKoYvuJR5yOlMJHAY/AXM/bP131dc7D0My48VLNTtnk7TBllL6hRDXoXt/u4FHpZTrhBDfDZ5/INlnKJyPESJkTomr3n/Qo8lQOJCOJPoKmGLwEtr8Q8VhOx9bNv+QUr4KvNrjWFRDLaVcbMczFeml0GXN3cHtygF0A+0KbkAAwUQqJSU21S6SnNQU6ziS1Sw8lziAVlwCntTkWlKaRceqhqDrqMkugGDGumAucdXuHIvarUsRF/ePHm3pvgmjzwdAyjX6lHi4l/izz9pWv3DOT02xjiNZzTT5ccSUeNM/n6SsIMuu6kWgNIuOVQ1B13Hn5nrgk1AucananZNRqUkVaSHQYw1bpSYd/AQ0aY7MALX+6UCMdmbMlCgNnY0aYSvi4vd79gBwQ3FxQvfV7FkKQEAbGZGXWpMSbr1Vv+iuu+yrKLA0WOwCe4t1HMlqpskcPC6XOcLO/fntkOWxXS9QmsXCqoag65gt2gG3GZ6n2p2zUQZbERefd3Zauq+9sxIATZbqTmcibIT90Ue21S+cytQU6ziS12yamXADIGPFJylbw1aaRceqhqDr6BE+YKyZmhSJancORk2JK9KCX5N4lJe4o9CnxENx2Eox5yHDvMRValLnowy2Ii0ENC3o+KLisJ2C7BGHrQKxHUiv/bCVhk5GGWxFWvAHZO/duhSDGj0UT6gRtoMxNIvIJa5wLGoNWxEXozzW/lS8ngJAn171uEOjtYCUUF5uV/UiKEhNsY4jec30UZkRO+8fM053OksBSrPoWNUQdB39Us9DHpFLXLU7x6IMtiIufl1WZum+8rKvAeDXluN2uYJhQsEp8X/9y84qmnwtNcU6jmQ1k/LdiFziNX9+mPyyfNvqF47SLDpWNQRdx8+qdgOfRaYmVe3OsagpcUVaCGgSd3CkptbSnEFAk5F+B0oyx2Huh+1STmdDATXCVsTFXfX1ANxaWprQfVX1SwDwa4V4gmkWXS6hT4n/4Af6RffdZ19FgSXBYk+1t1jHkaxmmswyO3qA0p/eDLkZtusFSrNYWNUQdB1LMluB7ODSRnCErdqdY1EGWxEXFd3dlu7r7K4GQNMKTYcztxD6lPjq1bbVL5zq1BTrOJLWTE40O3qAzHVfQIbbtvqFozSLjlUNQdcx09UFlJthXVKqdudk1JS4Ii34NQ1PcE7c7RLKS9wBaFJfxlBhXc7FUEyFdQ0NlMFWpAVjPRRQa2kOwcj/rsK6nI/hi6CpF2VHowy2Ii0Ymc7AGGGr7n+wo2lSX8NWvYRjMd6LjfA89aLsbNQatiIu9vF6Ld2X6dU3yQ0fYbsNp7Np02yrXzglqSnWcSSrmSZ1fwNjDbtz0r7k5WXaVr9wlGbRsaoh6Dp2BloBcLl0ox3QVLtzMspgK+LiFyNHWrpv7MgzAPBr74S8xA2ns4cesq1+4ZyRmmIdR7KaBeRSs6MH2H7XfZTuM8K2+oWjNIuOVQ1B13Hp5m3AOn1pwwW+gGp3TkZNdinSQq8RtpoSH/RIMzVp6HeFszBy9ruDvghqStzZqBG2Ii5+VlcHJP7Gv7vuJQD8Wq65hu0SwSnxK6/UL7L5jf+lYLHD/Y0/Wc0CWmaE09mEW2+A/MyUjNCUZtGxqiHoOk4oaAEKI+OwVbtzLMpgK+Jiu89n6b4uXwMAgUBOyEvcFXSG2bjRrupF0JCaYh1H0pppY4KbRujHs7Zuhizra6p9oTSLjlUNQdcxy9MJFAaXNoJOZ6rdORY1Ja5IC/7g5h+gT8+pKfHBj5RE7oetJHMeRmpSIVS7GwIog61IC0ZML4SlJlUMaoxQPEM3hfMI317TpXxHHI8tBlsIcaoQokIIsVkIcUuU85cIIdYEPx8KIQ6047kK5xARh214iSsGNXp2OlfI6Wxgq6NIAiGC7U69KDuapNewhRBu4E/ASUAlsEII8aKUcn3YZVuB46SUjUKIhcBDwLxkn61IH9MzMizdl5UxGtC9Vd3BsC7TS3zOHNvqF87o1BTrOJLVzBcI4HW7zDjs1v32p2hEtm31C0dpFh2rGoKuY1NXIwBel0u1uyGAHU5nhwGbpZRbAIQQTwFnAabBllJ+GHb9x4Da6txhWNktCGBM6akA+LUl5hq2GV6Sgl2fQO0WZJCMZr6ABryGN2y3rk233UH5dOv7M/eF0iw6VjUEXccnVlUgxOZgxrqgl7hqd47FjinxccDOsN8rg8dicQXwmg3PVTgIFYftLPwBXR+vxxXmdKY0cxp+TeI1ZrYEqt05HDtG2NE8UqL+VQghjkc32EfHLEyIK4ErASZMmGBD9RR2cHNtLQC/LktshFVZ+xwAfi0zFIftEgQk8I1v6Bf961+21RPguWCxX7O3WMeRjGY+vwZkRzidzfjRtVCYZbteoDSLhVUNQdfxwFFNuF1jAEJOZ6rdORY7DHYlMD7s93Jgd8+LhBAHAH8FFkopG2IVJqV8CH2Nm7lz56rXwUFCjd9v6T6fvxkkaHJk2H7YwQxMlZV2VtGkOTXFOo5kNNOnxLODa9j68czq3dBifU21L5Rm0bGqIeg6ZnnaI509pWp3TsaOKfEVwFQhxCQhRAZwIfBi+AVCiAnAc8ClUkoVXj/MMN661G5dzsGY/fa6XSqsy8FISY996FW7czJJj7CllH4hxHXA64AbeFRKuU4I8d3g+QeA/wNKgD8HPU79Usq5yT5b4Qxk0GS7wzf/UOuhgxpDHo9bmB2+Usx5SMLanUu1O6djS2pSKeWrwKs9jj0Q9v3bwLfteJbCeZidf1gucb+mDWCNFP1hvGRluNPldCaJ7g6jSAYpQ/kPPC6BX42wHY3KJa6IiwOzsizdl5NVTpdPA3wRXuJdfglHHGFjDUOUp6ZYx5GMZp2BbkBPJ2vo1nDAIZSOyrexhjr/+XQnL3V1ATDhy3xO2G+U7c9wKlY1BF3HmtbaiHDKgKbanZNRBlsRFzcUF1u6b1TxAhpau4ClYZt/BL3E77rLvgqGsSA1xTqOZDSr72wC3sfjcuEOjrC/uPYWph9ibwqFrfVt/OiZNXCc/vuflo1QBjsMqxqCruMnOz/D49oL6C/KmiZT0u527+3g2/ItACb+JodlN803E+4o7EPlElekHMPRpZeXeApo6/Lz7b9/yqWPfMJLn/cKVlDEiRGHneERBJdAU6LZfUs3kpfp4cNbTuCqYyezpnIvHd0B258zXPEHeuQ/SNGyxj1LvjS/b2toZ0NVS0qeM9xRBlsRF9dXV3N9dXXC9+2ofpq9zc8DUbzEzz1X/9iEpkm+/sBHBH41Ds89E/j5i+vo9g/ftfJkNBO+lwH0EXZQtyN+fKWtejV3+liytpoz54zl/Suyyb9vEr6AZO3uJtue4XSsagi6jidPXYEn3NlTw/Z2V1Hdwguf7+by947hzg0LEQKWbqixrXxFCGWwkyCgSR77YCvvb6of6KqknCZNo8mCo1hAa0cLdAChEbbpJd7QoH9s4tEPtrK+qplR5DK7oJiGtm42VDXbVr7TSEYzKXXNPG5hTolnNDXaqtf7m+rp8mucPWcc7Q3gbdf32t5U02rbM5yOVQ1B1zHT0x0W1oU+wra53f17xU68bhdj3Xn4m1zsN7qAT7baV74ihDLYFglokn1ve5Wfv7SebzzyCUvXqzfKWBgex6mOB/3lqxsAmD46n5wM3T1jOBvsZDDUyXC7cLlSE9b15oZa8rM8HDyhSH+Wx4XXLdixp93mJw1fJEQkTrG73UkpeWNDNUftW2KO5OdNKmbl9sZg8h2FnSiDbZGnVuwwv+dlenhmpUrzEwtj2Sw8HtTutbTalk6khPMOKUcIQZbXRW6GWxlsixghXB53yOnMTsk0TfLWlzUsmDEKj1v/uxAIxhVls7NRGWy7kFJGOHuCvS9eFTUt7NzTwUkzR5vH9h9XSKdPo7Kxw8YnKUAZbEt0+zX++NZmSnIz2HrXIs44cAwfbK5Xb5Qx6JXpLAX7Yb9TUQfAZUdNDB4RTB+dr5xfLBLKdCbMjt5ONtW20tju44h9SyKOjy/OoVKNsG1DSn3mAkjJi9efln0FwIKZoVznE4pzANjW0GbfgxSACuuyxP/WV1PV1Mmji+cihGDepBKeXL6TbfVtTE1BnOpgYF62tX2Qc7Mn0e7vomcctiaBE0+0rX5vV9RRlp/JzDEF1AeLnTGmgBc/342UcliGmCSj2a4m/UXH6w45nVUefARjJloPMwrHWOM8fJJusCcFNSsfkcPru605WQ1FrGoIuo6b6neQ4XEDoRF24PjjcbntGautqdxLToabsvwsU8OJJbrBViNs+1EG2wLPrqykNC+DY6eOBGB8sd6odu3tGLIG++oRIyzdVzbiOKrb9gIfmCNsYWzzd/vtttTNF9B4d1Mdi/YfgxCC44LFbvswn5ZOP7UtXYwqsJ6Awqkko9mH23YBq/G4Qk5nn156HYfO39eWun2yZQ9jCrPMtmNotnppFnvauun2a+bIcDhjVUPQdXy94j3GFQVH2MH257vtJ3gzku/6dzS0s72hnZ+eNgMIaegP6BvE6PkXFHaiWkSC7NzTzrKKOs6fO95cextbpHc6u/d2DmTVBi3+XnHY9uY0XrW9kZZOP8fvNzLi+JhC3UhXNyldEqU7uLzjdbtCcdg2aSal5JOtDcybVNxr5qMkT+/sG9u7bXnWcKfLHyDTGzklbpfj2StfVAFw0szIRDcet4sROV4aWpWGdqMMdoL84qV1AJx90DjzWFl+Fm6XYPfeoTsFdFVVFVdVVSV83/aqx/H4/wtgepGaXuILF+qfJFlWUYfXLThqSikAjy/UP2MK9Rep6ubhabCT0Wx83utAcEo82NGfdvPltui1qbaV+tZuDp8cWr82NCvJNUZnqrMH6xqCruNVh68h0x1y9gTIOvMMm9pdLTPHFLBPSS4Q0hCgJC+TejXCth01JZ4AUkqWbtA3lJ8WNvXtdglGF2QNaYPdZXF0pUkfUup7+hojNXPXoI7k/7+klCxZW8Vhk4rJz9LjeH3BYkcVZgJQM0wNdjKaCXTNvGG5xN1dXdCR/Dv+W1/qbei46aEZEUOzkjxds4Y21dmDdQ1B19HjCoQ5nQVPdHSE/WKNlk4fq7Y38p1jJ5vHfGHNuTQvQ710pQA1wk6AbQ269+qVYX+kBmOLstg1hA12MoS8xENTc3ZNy22tb2NbQzun7j+m17nS3Ew8LqGmxC1gyONxuxBC4BLY5l68ZG01M8YUmDMg4RQHR9h72lRnbwcakOmJXMOWNgR2vV1Rh1+TnLBfWdTzJXmZ1KuXLttRBjsB3qnQRwbfmLdPr3Nji7LZ3TR0DXZNcyeb66xloArFYdufOOXdjXo413FTR/Y653IJyvIzh63B3lLfxk6LnrpGHLY3LNmNHYqt2LaH1Tv3ctrs0VHPqynxSHY2trMxicxvUpOhEbYxxWWDkP9bX0NpXgYHT4juFFeam0F9izLYdqOmxBPgrYo6JpfmMiEYthDO2KJsXv2iioAWSlQwlNhar8dU7t7bYTrZxU8wCUdEalJ76vXOxjomxdAEYHRh1rBcw27t8lMb/Hdb+ZsMxWGH8lDbIdmTy/WEQxdHeekFKMz24naJYT8lfu/rFWRnuNnl1V+4aps7KbMQ6aARFodtk73u8gdY9mUtpx8wJubfVWleJs2dfuXtbzPKYMdJe7efj7c08M3Do3c0Y4uy8QUk9a1DK4Topc938/MX1+HfNw+A5bl7Ihzu+iM/ZxpVLS2AP2yEHfRUPf30pOpW39rF+5vr+eYREyOOTwsrdnRhFl9WD5/kKZomuejhj2nq8OEv09f0d+zXzqTS3LjLyM+ZRm2lPnMRvmHLprnHsc9M61tf7m3v5rlVu7h43gRz6tvA0MzlEozIyRjWU+LNnT7+uGwzAJ4D9Lj3daXNCRvs3KypLN/+JRNHBeOwg86DHSefSmZORl+39slrX1TT2uXv5R0e3u4MX4Q9bd2MLhw6/eFAowx2nDy7ahfdfo0TZ0TvsMYV6X+Uu/Z2DBmDLaXk5mfX0N4dgDV7ANhUklhcaGnRkazYWQWsMnOJm6lJb7opqfr997Nd+AKSiw4bH3H8yLBiRxVk8e7Gob85i8FnO/fyyVZdK4L5R3bOTcxglxYdyeY9X+J1bzHDrtxC8ME5i1lwxizLdbvpP58DcNaBY3udC9dsuDssrdsVSqfrD7a77ftEX0Loi7y8eTy3Zi+3LIxcw957zfUUJfD30JMXg9vWHtNjGSpcQyM8r761SxlsG1FzFXHgD2jc/t+1jCvKZt6k6JmeQrHYQ2cd+6u6Vt1YA1cdN5l9R+Za2knJiOkNdzpLNjWpP6Bx5ysbmD2ukCllsZPVlOZl0trlp9M3PPZY/mxHo/ndGMVa2UzDF9BMvSDo2Z+EZp2+gBlhcViMNmRQnJtBwzAeYa+p3AvA4ZOLueOsWeRkuNluQUNja9kMd6TBTiaPv56HopZrj9+3z6nu0jCDrbAPZbDj4JrHVwFwxdGTYuZVHooG2xiZvvfj46k4sJCOE8Yk7Hi2dfdjjMnW91bO8obtyyslzJ+vfyzw8HtbAfjG4RN6nXtsvv6BUMcxXAzA+qpmyvIz+fKOU5l9+Uyyz9iHnQl29lt3P8aRE5aZMyKgd/aLf3KZZb2M0fVvzjsgaprYcM2Kc4f3lPiGqmbGFmbx1JVH8OY+GWSdvg87GhI32LX1/+Ku0780E6cYU+JjzlpoWcff/q8CKaP7IES2u2B43jCeKUkFymD3wx0vr+d/wa0zQxtL9KYgy0t+pmdIZTtbVlHLviNzGR9M5p+d4WZ7Q7v55h4vRoasLG8op7EmrTu/vLuxjl8v+ZKxhVmcP3d8n9eW5Bodx/B406+obmH66HyyvG6EEGR6XJZ2v5IyNDKD5JzOWjp9vLxGT/5x3iHl/V5fOsyTblTUtDJtdGjWKNPrsjTCNiZEeo6wrbJzTzv/Xb2bKWV5jOvH8VTF06cGZbD74Ku6Vh55Xx/Jrfzpgn43kBhblD1kYrFrmjt5b1N9RNhGttdNQJMJ78LT02C7k9iIwx/Q+OajywH422WH9atJyTCammvu9FFR3cKssYXmsUyv/pKVKFLSY4RtPQz7+qdWA/CHiw6KaxOW4twMWoIexsONhtYuNtW0MGtsgXksy+tmx572hJckjHZnTF0bI2wrcdhSSi57bAUAd39tdr/X52a4yfS4qFcjbFtRTmcxaO/2c+Jv3wHg7Zvmm2+MfTG2aOhkO3vo3S0AXHhYaMo5O2hwN9W0RmR66w8t2O9m9QwvkfpGIIlgGOsfLJjK9NH91yE0wh76Hcd/Pq3Er0lOCtvqMMvjYsee9oR3LJNIM6QLjJesxDv6LXWtvPVlLfuPK+DMKM5m0QjPJz5UHDjj5fqnVuPXJGfNCUViZHlcdPs1qps7EwqpNF6wMoO7dZmJUyy8eD396U4217Zyw4JpzI1jxzYhhKNnSj78qp5fvLieTK+LQycW87WDx7Hf6IIBD9m1xWALIU4F7gfcwF+llHf3OC+C5xcB7cBiKeUqO56dKm5+9gsArj9xKhPj9KgcVZDF2t3N/V84iNA0iRDwxvoacjI8zBpbwPOf7eKR97dyyqxRHLJP2Ag7w40QsLk2sXVsTUo8LmFulhLyA5BA/A1g5fZGPvxK35bx+ydMjeueYoeuYde3dnHDv1dzyD4jKMvPYsGMMkryMnEJIgxvQJP4NY2mDh93vLyeDLcrYlYky+umpdNPY7uvVyhVX0hJhMF2uYSljv5nL+q5939//py47zGSpwyVEEkpJX5N4hKCb/99BfuU5DJ7XCHHTCvlpc+rWLF1D1XNndQ1d7K7qZMZYwoiXogzgy/K2xvaEzLYxgg7s8eLcqI0tfu4/QVdx+tOmBL3fU7w9tc0fb4hoEnuem0Df/tgW69r1lQ2mTOttyzcz5xp1KTktAPGRM3YlyqSNthCCDfwJ+AkoBJYIYR4UUq5PuyyhcDU4Gce8Jfgz0FHlz/AHS+v56XPdzOuKJsbTpoW970j8zNpaO1yRPKUT7ft4a7XvmTl9saY1/xk0Uzz+ym5+kvLthE5bKqNP665MHcWH2ypMqfDITQl7jv3PPPtvz+klJz7lw8BWPGTBTGd/wBmnR/6npvhJsPjotEBBru1y8+V//jUfCkBeG+T7vh32/OR1x4ztZRMj5ulG2oijv/41OmmQT8lN5eNbZIK9Jes/ryzDQpzZ7GxfocZgw366Oyzw09iSj8+A+E8/elO3ttUz5kHju1329lwzYpzQzG8g53alk5W79hLXWsXL6zezfKte5g9rpBpo/JNA/naF9W0dPnD7qqLWtaps0ZTmt/BP68IdY2n5ObSKHysRk9edMS+JVHvjUY3U3h/y1YuHh05Jb7ntLPJK46eaCgad76ynoAmeeX7R/fZr4VrCPo69mDM49/S6ePNDbXc9doGappjzwC89+PjGV+cw38/28WNT69Gk3D3a19GXHPnKxv4v9NncvnRk1JdbcCeEfZhwGYp5RYAIcRTwFlAuME+C/iH1PMdfiyEKBJCjJFSWtuGJoX88OnPTQeZf1xxWEL3jszPRJN6RzMyv/8p9FTQ1uXnwXe+ItOrryEdv18Znb4Av15SwY7g2rOEiHXNktwMSvMyqWnp5Lrjp5CT4eGoKSUR2cMuKtTXRd8oy0tohF1ceCjr674g01NtHjMafdeV3yUzuGFHf9y9RG8o3z1u337/bw+9JvRdCEHJIPA6/nhLA+9vqqe6uZOPtzSQ4XaR4XFRkOVldnkhHpfgweAyhMH3TpjCvEklPPrBVqaNyicnw011cyf/W1fNjj3tZnrXbxw+gXFFORTleLkobAnjosJCdga8/A2oqGmJ22AXFx7KZ7vA6w51tm4heGfB1/n6xQfHVUZzp49bn/uCnAw3v4pjzTNcM2NKfLCMznwBjdP/8D4VNfqL6n6j82nu8BGQMmqH/8WuJjbWtJgzGpleN7PLC5k3qYSWTh8Xz5vAmsomXvx8N/uPLeDMOWMZXZhNXmbv7viiwkK0fMmfMtxsqEps9q49MItX1rdx2bGRTmc137icCXFMawO8t6mO/6ys5Jr5+0b4RkQjXEPQR9jrB3jGUdMklY0drNrRyO/e2EhTh4+mDl/ENZcfNYmiHC+leZlceOh4qpo7KcnNMAcZZx80jrMPGkdtcydC6JvhuISeB+KjLQ3MmVCUtn+PHQZ7HLAz7PdKeo+eo10zDuhlsIUQVwJXAkyY0DtkJ5X89b0tvLymiilleSy98biE7x8ZXOeubelMq8F+Y30NTy7fQWuXn+VG0owgd76ywfx+2KRic4/oCcU5XHbURE7YL77MVR3BheipZXm8v7kef0Azp7h7smtvBzc/s4aCbA/3nDsTX6ArYoRtvOlrrW2gZUBO32/7O/e08+A7ujH70SnT+62rL/gu4g0WOyInI637K6/c3siKbXvo9AVYub2RupauiGxrLgEL9x9Dhy/Asopalm/bY+bs/voh5dx97gERI5mjp5ZGlP+rc/o3gKBrVlyQSUGWh7WVTXHXX9P0Hda8PcK6XB0d0N7er14AP3thHQFNcv+FB0U1RD0J18zMJz7AL1nVTZ383wtrzSgRA0PL8+eWo0nY2+5jUmkO3zpyIjv2tHPkvqXRiotg8si8uDIGGu1uzoQiPtrSkJAvQpevi0x3+G5dwTXstjZoz+pXx7YuP5c+spzJpbl8/8T+l6B6truSvEwa2roS9p+wAykln1c2cfafPuh17msHjSPD4+KmU6ab4WfhxPKA75lpbvFRk1h8VHpG1gZ2GOxoSvRc7YrnGv2glA8BDwHMnTvXpozT/fP4J9tN4/aPyxMbWRsYRrq2pQvr+aCic+/rFTy5fAdHTSnljfU1dPgCTC3LY1PYaLckN4ODJxRxQHkRN548jTtfXs/Tn1by09NmMGd8UVzOIrG4ulofIV+0zwgefHcLU37ymnlu612LzAbZ1O7jqLvfMs9dcdhKTtq3m5Xb9zePGcYo95wz9YW1t9+O+dz2bj/nP/gRAK9+/5i4lhoeX6T/XBwstiQvPYk4nltVyY1Pf97r+Nx9RnDM1FJ+fe4B5guT8f8V0CQC+pzit4qh2WGTSnhvUx2aJuN6zvbqxzl3djN/WzHXPOZ2Ca699/vwz/w+9QJ9NuH5z3Zx4n5lvdJXxiJcs4IsPZ/4ngEICWps6+Y3/6vgiU929Dq36ZcLcQtBl18jy+uKaoTKR8Q/1RwPhoaLZo/hJ8+v5S/vfMWxU0ey/7jI0e6StVU8/N5W1u5qosuvcdPJ0zhi/DJ+vrCFDM98IPQ3Nv3yCyHb26+Ov39jIwA3L9wv4oU7Fr3aXW4GvoCkudNPYXZ8M2lW+d+6aj78qoGygkyeW7UrYhZwxpgCvnnEPhw7bWS/4WiDHTsMdiUQvrBVDuy2cM2AsXNPOz95fi0Ay39yImX51hxdDAeZuj7WRRLBH9D489tf8f7menPk/M7GOjqCWbvCjfUz3z2CA8cXRTgK3XPegdxz3oG21MXguGm9d8X6f29t5pr5+/LOxjq+/Y9PAbjq2Mk8+sFW2rr8aFKSFbZWbXQc/b2N+QMaC+9/j6qmTq46bjIzw0JdEmFEToalbF990dblxxfQ2FjTyv97axMbqprNEJbJpblcc/wUDigvZGReJiP6cPZKh6/DGQeOYemGGibf9ipLbzy2V2Y4IwXt059WAvDm9yQBTZKdEeoeXELE5STe6Qtw23O6w+Zvz7f2t+dyCT3bWQqnxGuaO/nJ81+wdEMtj397Hpf89ZNe15TmZXDDSdM475DyCF+L7Iz4/C7s5MwDuSc74wAAIABJREFUx3L7f9dyz5IK7llSwTFTS8217sc+2MrPX1ofcf0zKyuZV244nfXwEo/jeV9WN/PX97cyZ3wRp8xKPC0qhAYw9a1dthnsxrZuXvx8Nw+/twVfQCPb66atO0Bdj53B9hudz8mzRnPQ+CKOj7EFqBOxw2CvAKYKISYBu4ALgYt7XPMicF1wfXse0DSY1q9/9ao+sn782/MsG2sIH2Hb42gRPooFePdHx8fclSpdZHnd/O2yQ3n0/a38/bLDOOiON/jdGxv5XfBtHOCX5+zPJfP2YVlFLR2+AAFNkpcV3vnH96zjfvM2u/Z2MLogi1sXzrBc5xIbvVWllFz+2AqWVfR2HFp85ERuPHkaBXGuy6eLU/cPdbgLfvcut58+kyuCTjL//WwXd7/2ZcSOZnvbfWhSku0NC+uKc3vN+b95m+rmTu6/cA5FSWwwUWJzetIPv6rnR/9Zw4wxBXyxa2/E2nO4sT5oQhFnHDA2bU5E8ZKf5eX/XXQw33tyFZrUnRG/qmvFH5CmsV5+24mUFWTxi5fW8eTyHWbcds847P6E9AU0Tr3vPUD3irZKeEjlvr3f8xPmbx9s5Rc9XkzOmjMWt0tQuaeD/ztjpvlycFCMbT+dTtIGW0rpF0JcB7yOHtb1qJRynRDiu8HzDwCvood0bUYP67os2efaxcdbGnhtbTXXnziVo6b0v/bUF1leNwVZHmqT3Ad2Y00L54StvXz60wWU5GakfR0oFsdPL+P46fpb60OXHsIFD32M1y1YMGMUvzxntulsM6ogi26/hoSIdUxzLa2PjuOeJV+aSWg+uvWEpOpblp9Fa5ef9m4/ORnW/+RfXrOb6574zPz9uuOnUJybwUETipgzvmjQ6NOTTI+b/157FPcs+ZIPv2rgjpfX09jWzRPLd5jOePuNzue/1x7FfrcvobXLT0Aj4v/KFYfBXruriermTkrzMiLiiK1Qkmefo+CPn/ncnD0IaJK8TA81dHHPuQcwdVQeK7c3Upjt5YwDx8Y19TtQnHbAGE474DQqG9s54d53zDwRoOeKMNZYZ4wuoNOn0dkjl7jHHGHHVlJKyeyfvw7oLy+HT47fK70nIefB5Gcc//nxdtNYX3v8vnznmMkUZnsHbZtLFbbEYUspX0U3yuHHHgj7LoFr7XiWnUgpuX/pJgCuOMaeN+qygixqk5gSf2H1LjMzFMCan5886EZs4cybXMK2u0+Lem5ETgb+4Ft+bmZk5w+xX/R3NLTz57e/AvR/f7KNssyY+WjuYmKptT/5/3y6kx89swaAi+dN4BdnzopYfhjszBlfxBPfOZxX1lRx7ROrzO0bRxdkcefZ+7MguNa83+h8OroD+gg7IzwUj34zbhi+Bkt+cGzS9S3OzeSL4CYYyfDwu1tMY/3Ed+ZFdQhz2misfEQOv/rabDM/+58uPjgiV8SooJ+EseGNkUs8nsQpf3hzM50+3dA/890jk6qnXVkG71u6kfuC/fQnt504JGLzrTKsM539b30NH21p4JaF+9lmFMvyMy1Pibd1+U1j/YszZ/GtIyfaUic7OCs//sxmBiNyvLy5sQSPy0Vedu847NYLLyEripfmLc/phvHpq46wpMucxZG/lxWEnAHjTYITzmV/W25Ogf/63NlccGh6oxesEk2z0w4Yw6TSY1i5o5Hjp4/s5SRVVpDFJ9tHUdPSxdjiMM1cgrePOI0Z8/eN+qxlFbW0dwc4ZmppVM/b/uipWbJT4lJK7nh5A49+sBWvW/DBzSckvJ/0YCBWuzvvkPKYedkNx8b3t4yiqqmDc+ZFTonvOut8ist7hyL5Axq/X6ovbW351aKEHSF7ajgiuCSyp83X++I4WVZRaxrrVbeflFDyn6HIsDbY//xoO6V5mVxuo2v+qIIsVmzb0/+FPahr6eLYe5YBcO/XD4xrk4R0co4Vg52bwd8/KibD7eJbR4ZNiQc7guYLLqF0ZF7EPdsb2vjwqwYOLC+MO264J70MdtAvwcqL1O/e2Gga649uPSGtWY2SJZZmM8cWxHTgK87x8r+KUnY3dfC94yND8ZYdsYirFx/R656AJrn6XysBePDSQyzVNZrBbun00+UPxJ1cJ5xwPwOnGmuw1u6M/aef+7yAtu7cXpt/7DjzAmYfMKbXfc+u0mcifrJohqWohZ4aet0uCrI8lkMqN9W0cNnf9Pzlz19z5LA31jCMN/9o7vTx/uZ6zjlobJ/7uiZKWX4mtc167GG8bG9o49BfLqXDF2CfkpxBZ6wBGgMBGgOJ7Sk9IieDgkwfWZ6uqFPi1NfrnzD+vOwrMjwuHv7mXKzSXq9/DMKnxBPhj29t4g9v6m/3635xiqOMNVjTrDg3k5aOZvIzfBSEefa6XYLc5sZeegH8aZk+jXr5UZMs+wj01MxIKdtoYXT2wupdprHe8qtFjjXWYE3D/EwPuRlu3KKTkpyA2d6MFRz3noZeOvoDGg+8s4WCLA/ftrg82FNDsL63eacvwEm/fxeAf195uOOWLVLFsB1hP7dSf5s8NkqYUjKMzM+kO6Dndo7XS/YPb+rriQtmjOKv37JuqFLJDTV68ojHxsa3gQPojfXWk/S16DZ5gHncmBIffcWlkOE240Hbuvy8tGY358wZl1Qn+/R5+k8jHrQox0uG25WQM+AHm+u593/69OCHt5wQ8cLhFKxp5jU1c2eFRstul+CHD/8EXimMiN9t7/bzuzc2kuFxcfvp1j35e2pmehi3dZkjxnjo9mvmstKnP+07ha0TsKKhEILRhVl8e966yHzwwXY396bvQF5mhI5PrdjJ1vo2HvjGIZZ9RnpqCMbe5omvYd/5iu5g9r0TpjAvCce3ocawHWEvD05bHxVHVqJEMAxNvMbh5TW7eXZVJZcdNXHQGmurTCwJrRfnZ4VPies/e85BvPpFFe3dAc4/1N4ZBiEEIxPwLej2a1zzuL43zbNXH5nQhgtOZ9yI0L813H/AJaJv/vHqF3pij9+fP8dWj12r6UnPe0DPN79gxihLa+lDBeNvNnxP876czn76Xz0PxclxJrqJl5K8zIQ17PQF+NfHOxhXlM0PT+4/s+FwYlga7C5/gHc31nPRYRNsfwNPZPq1pdNnhgldHcOZx8lMGhky2BOKQ99D8aCRPcezqyqZVJobsduUXYzMz+yVXCEWz39WSVOHjx+dMj1it7LhwKTSkE9BQXZvv4OevPZFFeUjslm4v7XkGrEw1isTCe2qbGxnTWUTuRluHv6mtbX0ocLo4MDB6+k9wu5przcHN/O5ZF5q+sNENwB54B19huf/zpjZz5XDj2FpsFdsbaS1y8+CGfZnwBlVEL+D04+DYUJ3f212UglbBivhsdfhe1dHy7jU1uXn022NnLr/6JTEVhq+Bf2haZKbn/2CMYVZXDMEX6L6Y1LYrMik0siXrJ4js47uAO9vrmfBjFG2d/SluaEsWfFibIH4wnVHD7v43J4Yywg988FH4+lPK/G4BD9YEP/OhHHXoyCLxnafGWLWHzv3tJte4XaP9ocCw9Jgv7epDo9LJLRVXbyUheUT74umdh+vra1mTGEWFx7mjDAhK0wZmce0UfkRHp7R3vQ/3d6IX5MckaL1qrKC+KbE39+se82ce3D5sOz0C3O8CPRlhHAnO7er98jsoy31dPk1TkhB6seCbA8el4h7hF3f2sWTy3dw3iHlTCnL6/+GIc4h+4zA4xJmaBWET4lHKrl0fQ1HTy1NyYZFRkx4PC/LAU3ynWBq41e+r166ouE8TxobeLuijsMmFSeV9SoWuUEPzf7+QK97Ul8jve+CObbXIRVcUGAtj/e0cUf1OmaMxuouuYz8YFjXiq17cLsEcycmPwU99+rex8ry9Tf9br/WZ1TAD4PJKL534pSk6zHQWNVs9j7H9hqNeVwuXjziDA48PbStzTsVdWR73cybbH1TGYOemgkhgg5L8RnsR97fSpdfG3JLS1Y1nD+9jKbWkyOOGS/KFed8g1FBZ9s9bd1sqW/j6wnscx6LaO3OmJqvaensN63yX9/bwpfVLfzolOn9buU5XBl2Brup3UdFTQs3HWj/9I/BqIIsavoYze1oaOf9zfUUZnsd4wG5MM/aqKUwb/9exwwv8frTzmFyMNZ63e4m9h2Za8tL1P4X9D5mzHzUtXbF3LGnprmTupYuTpo5ylLs72DDqmazxh/a65jLJXjrwBO4/YL55rHVlU0cOL7Qlv+raJoV52aYG6r0xd72bh5+dwunzR7DviOH1ujaqobQu+0ZL2FbTjiNY4O5J1ZtbwSwxVcjmobG1Hx1U9+zW5omuef1CoBhuRQVL8NuSnzNLj3dYSrj+sYWZVPZ2BHz/JMrdiCA164/JmV1sJsqv58qvz/h+3z+Jnz+yL2YXUY8aGUl7NS3Sd9Y08q0UYkniYhG0079E46Z7awPB5hngqF+yWx4MJiwUzO3gJI9NaZevoDGhqpmZo+zZyQUTbOR+ZlxrWHf83oFfk1y7fHOnxXpiVUNobeOxotyVvVuU8dVOxrxuAQHlCevYzQNDZ+e/hzPnllZSUCT3LZoPzUV3gfDzmAb+6SGO0HZzfjibCpjbOfY6Qvw1PIdLJgxylHhQrfW1nJrbW3C91XWPk9l7fMRx4yOY8pNV8Oll9LlD7C7qcO20dHzl+qfcELZzqIbACklz66qZN6k4iEzSrNTM5dLcNtTd8Gl+n/spppWuv1ar32ZrRJNs9EFWVQ1xX7xBb09PfHJDkbkeJkxxtr08WDGqobQW0fjRfnYO39o6rihqpkpZXm2bHoSTcOCLA9Z/7+9Mw+Pq7rv/ud3Z6TRalm2sbzIeAGzmM24CgFcCOAYCJgYsrS8hILz9gW/T5o0pLQsoe1b0j5tSNokpW9DSuAtZCmEUPYQGuJACbsNXmIwssEGvMg2tqzFWkea8/5x70gj6Y4s3TkjzdX9fZ5nnjtzZu5yznfO+Z39V+QcsYX95CbX2/KqswvLS1qhETmD/cHBdioScabmcZu72uoyDrZ109Y1tGb8i00NHGpPFtQ+4WPN4Fniuw51YAzMzaPr0P7ldv4Fx7oPDrH9ozYuPz03L1MTFbeS1T9Z6Z29LQB5HWucObmU/a1dJHtTWX/zzGZ3Hfi3Lft9n4j0zUvImHT27keHWWipZ8sPEWHGpJIB7lsHs+tQO7/ddoDV5y6wuuvkRCRyqfP+wTbmTSvLa7dLejnMjgNtQ757cO2HHHNUOWfnYYZ6WHAGbeDwwUE3nfJpsKdVJCgpcnj/oH/Pxz2/3c7ksiJWLh75jlJRIuYMXNb1YWM7Im5vUr6YVVWCMcN3pz79uwZmTCrJy0z1icbg1RmplGFvc2fWOR22qJlUMqyG6UrXilM17x2J6BnsA23MnTp6j02j4bgat0t1677WAeGHu3p488OmvK01Dguxvri7RUeD1102e3L+DLbjCMdOrxiiCbgVhl+9vY+rzjg6LysHJgKD11nvbOygprIkr5Pz0kNGe5r8C/vm9iTP1e/nwpPsrwOfiMQHVZQPtHWR7DXMmpzfPSBmVA3fwn5sw25OnDmJUyyMo090ImWwe3pT7DrUwbw8tuQA5k4tpygmbN13eED4Y+t305synLvQ7v7lYWPwFolN7a6Dh8ll+fX7fdz0SrYN0gTgJ69+QEyEa86al9f7h5mYyIB12B82th1xmU6upA1JtnHsZ7fsI9lr+MySwnOWU4gMHopq8CpC+XZqM2NSCfuyOESq39vK5t0t/GGdajgSItWcaGzrpidlmJHnP2hRzGHBtIq+cb40T2zcQ2UiTt283NetjjXXVgWr/U6rGuqOMd01t+Pa1UyZO4VDbd2UFsWsTHwBOOtG//CFNZU8sn43zR1JqjxPVM0dSR5cu5MLT6oZlZOJMGBTs5gj3H/mZ6i7agngVrJsblDip1nakGRrYX/32a2UFsU4bQK3zIJqCEN1FBFEYN1nVzHn9Nq+nq2Zlv732fJdzaQSuntSNLUnqR40d+iRN91d1i47TbvDR0KkDHarNwlsUkn+o71k7mR+samBVMrgOMJz9ft5fUcjt37qhKxbBBYy55cHG0aoLB+6eX96tuq+T1wIp8yk6ecbqbbYuj7+Mv/whZ6BeXf/4b51p3c9/x6tnT186byJtyTIqmYiPHfcmXDZRYDrnrbSYj7y06w8EWdSSdy3hX2orZvdTR1ccML0CT28FFRD8NcxJsK2M86Hi0+g4SV3K1dbBjtbvksv7drb0jnAYKdShsc27Oa846czNcKOWkZDpLrEWztdg22zoMlG3dwptHT28M7eVpK9qT5H7GHtdt3R3c2O7tH7te3qPkBX90AnuX3rQbdvg/p6mtq7qRqhK9KRcKDefQ0mvc57mzeOnexN8YP/fo/Zk0utLU8qJKxq5sCcj3ZCvZuwrZ09A7x55Uo2zWZNLmVP01CDnd43/IZPLrT2DIVIUA3BX0fHEap2bof6evY2d5KIOwO2Dc6FbBrO9IY2Bu9Nsfb9Rva1dHHZaTOt3D8KRMxgu2OllRYLmmwsPdZ12/nrLfv4xpOub9fP/14tpcXh3EHr9gMHuH2Q0/uRsOfAU+w58NSAsPQEoVP/9mZYvZpD7UmrLeynVruvwdRWl1KZiLNxl7uZxBMb3LWf//sTC6zdu5Cwrdnf/OJOWL2aZG+K9u5eq/kom2auwR7aJZ7e8/3kCb6FZVANwV/HmAgX3/k3sHo1Bw53M60iYa2HIpuGx9dUIgJv7xk4RPjQul1UJOJcuMiup7eJTLS6xMewhT2jqoQz5k/hO89uBeCU2VV863On5v2+YSA2aHlJU3s3J8zI/6YXjrdX+fP1++n1uuOACe18xRaxjEL9sJePMt1v5ovZk0tZ+34jxpg+w7KzsZ0NO5v4s+XH6ezwURJz+icPNnckmVSa/8ZLeSLO/GnlbN7Tv+taW1cPz2xuYMWps0LbiBkPtIWdR25Y1t9dd++qugk91jYa/GaJV+V5hniaK5a4k20Wf+NX/HbbAW5cfhxFsUhlg0C467BdwVrGMB8dO72C1s6eATvUPbHR7Rn5zBLd5Ga0uFnP07EjSdUYVLrA7QnJbGH/4ncNtHX38nmdHT4qciqpRGSKiDwrItu845ANukVkjog8JyJbROQtEflqLvfMhbFsYQOcfew0/uKi47lx+XET0t91UDJbRQZo6rDbJT4cy090feym/wthnVMw1mQuCUqn3VhM3jxpltvzsnGn6wMglTLc++IOPjavmtrq/C4rm4hkboDT3JG0Og9hOE6aNYndTR0cPOwu77rp4U1UlRZZcToSJXJtWtwCrDHGLATWeJ8H0wPcaIw5ETgT+BMRWZTjfQPR0tmDCFSM4eYYf3L+sXxl2cSeGDNa+rrEjesDtzdlmFyav61iMyktjvHIl86mtrqUZ244Z8xa9mEnU7OWjrFrYZ88u4qimPDGh65XqVd3HKSxrZtLT9GJSkHI7BI/3NUzZr2NH/O88j1f/1HfzmbLF9Vor+MoydVyrQTO897fDzwP3Jz5A2NMA9DgvW8VkS3AbODtHO89alo7k1QUx3XcKwCrJ08OdN5Rk88dEpZe1rVp1ZfdGvYrhvKEvUrUuX85/PdLjq7mxZsvsHa/QsWuZsK/nH0l/76qjpY8jGFn06ykKMZJs6pY975rsB9au5PKknhk5h0E1RCy6CjCbz57HQvOWcDhl3qoSNgbPx4u3y2udeOR9jcP8HeXD3W9qwxPrjmuxjPIGGMaRGTYDX1FZB5wOvBajvcNxOHOHirGqDt8onFWWbDux4qyoTOw0621PXVLOWbhNHjlvym3WHAs+KS1S4Uaq5o5wkvzFtNzwTJaNjUAWO1OHU6zM+ZP4e4XtvPyewd4bMMerjlrrrVNdgqdoBpCdh3rT/44ZtmpHP7NL61WlIfT0HGEa86ay49e+QCAv7jo+MhoaJMjqiUivwb85t3fNpobiUgF8J/ADcaYlmF+dz1wPcDRR9utRbd29ozZ+PVEY0uXO+nnxMToNjjo6HK7v0oT/X+h9HhoVf1bpA67Y5Q29/Deu8E9zlhs7ZKhxKpmIizatx2zfj2tSXfJok2DPZxmKxfP4u4XtnPVD916/heXRscFY1ANwV9HR4SaHe/Qva6H3pTdnq0j5bvbP30SZ8yfwsLplXl1bzyROaJaxpis9SYR2SciM73W9UzA13GriBThGuufGmMeOcL97gbuBqirqxu6+WwOtHYlx2zMZqJxx8GDANw3a3RbCO49+AwA82et6gtLj1t9/M6/dVvW532dMotLO565wT2uet7aJUOJTc0cR/jrNXeTeO9hWv7qhwBWe6uG0+ykWVVcespMtjS0cOUZc/q84UWBoBqCv44xR7j8vm/jPFkGS2+mwqLBPlK+ExH1yJUjuar1BHAt8E3v+PjgH4hbOt8LbDHGfCfH++VEa2ePtV19lOD0zzg2pF0d2zTYin1iGa6UWzt7qEjEx3SL3X/9wpIxu9dEJj3prDfltoVstrCV/JPrLPFvAstFZBuw3PuMiMwSkae93ywF/gi4QEQ2eK9LcrxvINwucW1hjzeZM45T3hoTdWtZ2GRWsmzvI66MHen19L1e32W5VpRDRU65zhhzEFjmE74HuMR7/yJQENOyW7WgKQicjGpiuqavLezCJnNlRWvn2K3fVeySdpOa8vKd7jIWLiK1xVOLTjorCPxa2FpwFDYD12FrPgorjiOQme90pnaoiEyu6+rppbsnpS2DgHx1SjAf3jVThnTA9HWvvvjFr7lLO3baLTiW/b21S4Uam5o5jvCtc6/lrquX0LI12ecy0RaqmT9BNYRseQ8e/uyXuOikGthkt6KsGuafyBjstq5eQMdsgnJ6SbACuqxkzpAwEUEEdi863TXeO7dZNdhzzrZ2qVBjU7OYCG/Wnkjnxz5O66bXOXa63aJDNfMnqIaQXcetx5zCaSfXwqb1mu9CRmQMdkfSNdja9RqM9Z2ui8PRFiDtnTuBoYVHTISazW+SShkS8Wqru8/tfNk9Rr0AsalZzBGW7NpC/NUEHUn7cw5UM3+Cagj+OjqOcMy2jZSZ3UCx1c1LVMP8E5kx7E7PYOvuOsH458ZG/rmxcdTn7Wtcw77GNUPCHUc4577vcs5937VeiVrzdfcVdWxq5jjCTS/cz5S/v53OZC+JuGo2FgTVEPx1jInwuUfuYtG/3gHYLQ9Vw/wTGYPd0a0Gu5CISf/kF534UvjEM1yidiVTJIoiU3RMKBzPW1d60lmJ6hgqIqNWV48a7ELCm6xKyqgmYcDpmyVu6O5NUWK5ha2MDenZ/ilvwyKtLIeLyBjszqT7D9U/aGHgjlkbUsaQiEfmbxha0jP70xtuaCUrnLg7nbn5rjjmEI9p3gsTkVGrv0s8MlEuaGLprrmU0YmAISBdrqc33NBKVjjJ7BLXsjB8RGaWeKd2iefEzVOnBjpvxtSLfcPjjsOTX7yJnY1t1rtXL/6e1cuFFpuaOSJ8Y9n13HrJCfBGt/V8pJr5E1RD8NcxJvDDz/wpx04vp6RTNQwbkTHY6Ra2dokHI4h7Pxjo2i+TRNzhgznHsbW4laMst7Cj7lYzjU3NYo7wds0C9i04Ed7YaL11ppr5E1RDyK7ju7OOxampoHRnUy6PNgTVMP9ExmB39rhj2Dq7NRivtLcDcFZZ2ajOO9y+HYCKsgUDwhNxh3kbXibW2M7hc86z8oxptv/aPS7I6hg2GtjULCbC0vc3UPXSIaDa+rIu1cyfoBqCv46OCKe9s5bpexJsmXGKnYf0UA3zT3QMtrawc+Lfmtza+GgLjo+aXgCGGuziuMOFj95De1cvPz5/6BaKufDC37nHqBccNjVzHOErLz/InHfK4OK/tt7CVs38Caoh+OsYc4Qrn/0RxfEYz3/lTjsP6aEa5p/INDd145TCojju9E9+0UlnBU96lniflyfNR6HEyZzsqb2NoSMyinUke4k5QpEuYygIEnGHlHGXl+ia3sInvQ67N73hhlayQknc8dxrGqONlxASGevVmUxpq6CAKI47pIy7rleXlxQ+feuwtYUdajJ3GNSKcviITEnZkezVGmUBURxz3O5VY6w7klDsk94hq9fbIUvzUjhx+jZOUUdIYSQ6k86SvZQWR6Z+Yp3/M21aoPNmTVvhG56Ix/jGij+lsa2bP0rY/Ruu+DerlwstNjVzHPj6RV/mY/OnQIv9FrZq5k9QDcFfx5gI/7DyBoyBhZZ7tlTD/BMZg93R3avdeDkwv7g40HmJYv8CpzjusLG8hmSJobzY7t9w2vFWLxdabGoWc4TtU2uprq6GlkPW85Jq5k9QDcFfR8cRdkydQ1dPL6eohqEjMga7s0cNdi4819YGwPnl5aM6r7WtHoDK8oG5uTjucG79qwCUJ5ZYeMJ+6p90j8dfZvWyocOmZnFHWPbua9QeKOWNaadSYrm3SjXzJ6iG4K9jzIHf3/KyO0R45v+w85AeqmH+iYzB7ujWMexcuL+5GRh9wXGg+RVgqMFOxB2ue/1RADoTX7bwhP288k/uMeoFh03NHBGue/1REkUxfvwHp1JsebWFauZPUA3BX8eYCF946WF6U4bXV19t5yE9VMP8E5lB3U6ddFZQFGc4j6iwPIat2CdzlnhJUQzxJqEp4cJxpG+mv67OCB85KSYiU0TkWRHZ5h2rh/ltTETWi8hTudwzKB1J7RIvJDK3tixXg13w9K3DThnNRyEmllHR0gZM+Mi1inULsMYYsxBY433OxleBLTneLzAdyV5dxlBAZLawbU86U+yT3nDI6IYboSbTl4LqGD5yNdgrgfu99/cDl/v9SERqgUuBe3K8X2DmVJdRW106XrdXBpHpT7k8oQVHoZPZqtaKb3gpy6gcTyrRinLYyFWxGmNMA4AxpkFEpmf53feAm4DKHO8XmP+47szxuvWE4B+mZ5N2eGqnX+Ebnog7fG3FjQA8Z7lL/IofW71caLGpWUlxv17T8zBH+UqJAAAJVElEQVSEoZr5E1RDyKJjUaxPx28nigJf2w/VMP8cMeeJyK8BP6fGt43kBiKyAthvjHlDRM4bwe+vB64HOProo0dyC2UMmBkPVkgXxat8w4vjDg2TjgIGtrZtUDXH6uVCi03NimMO+6qOImVgQR56RFQzf4JqCP46lhbF+vJdheUWtmqYf46omDEmq7M0EdknIjO91vVMYL/Pz5YCnxaRS4ASYJKI/MQY47umwBhzN3A3QF1dnRlJJJT888vDhwH4VEXFqM5rPrwZgKqKkweEF8ccVmxx3f+JXGrhCfvZ/DP3ePIfWr1s6LCpmYhwxdYX6epJ0b3o8/Ye0kM18yeohuCvY2lxf76rSHzCwhP2oxrmn1yrWE8A1wLf9I6PD/6BMeZW4FYAr4X959mMtVK4/KylBRh9wdHYsg4YarATRQ5Xr3/a+3RHzs+Xybq73GPUCw7bml315tMke1M8dJXdDTdANctGUA3BX8fSolhfvqssud3CE/ajGuafXPsivwksF5FtwHLvMyIyS0SeHvZMJdKop6DwkV7apcvwwkvmzHDd/yB85KSYMeYgsMwnfA9wiU/488DzudxTmRhMn1RCcrwfQhkVjle9V4MdXsqK46T63mulOWzoVjfKuDCzqgSAuOUtLpX8Ibgt7ApdhhdaMpfn6W514UOrysq4UDOphLaKBNMqEuP9KMoIMbhzQLWFHV5Kix3axvshlMCIMYU7Ebuurs6sW7duvB9DAQ719gJQHRtd66qntx2AeKxs6JcHDrjHHHz++tHuXbbM7mVDh23NLr/9cT442Mat15zDH9TZXcOjmvkTVEPw17GhuYNL/sp1urP+zqssPGE/qqEdROQNY0yd33daVVZGRJACA7IY6jSWDXUaLTBcbGu2t6iCQ2VxppQF99GcDdXMn6Aagr+ONZUlNJVXsfQY+wmuGuYfNdjKiHi0tRWAKypHt1ndodYNAFRXLh765X33ucdVq3J4sqFs8C672O5lQ4dtzZa99jRdPSmOqlxq5wEzUM38Caoh+OvoOMIbtbsoNXuBj1t5xjSqYf5Rg62MiMcDFhxNarDHDduaXb/9tzQ0d7DgqG/ZecAMVDN/gmoI2XWc8vMH3DfX/XFuDzcI1TD/qMFWFGVEHD21jFmTSygqsbsHtaIoI0PX1CiKMiKEfjebiqKMPZr7FEVRFCUEqMFWFEVRlBCg67CVEdGRcjc0LHVGV8dLpdwNSB3HZ9yz3V0nStkwS78CkPQuW2T3sqHDumZ50gtUs2wE1RDGXkfV0A66DlvJmSAFBmQx1GnyUPCDFhhprGuWJ71ANctGUA1h7HVUDfOPdokrI+KB5mYeaG4e9XmNzWtpbF7r/+X3v+++LLP2++4r6ljXLE96gWqWjaAawtjrqBrmHzXYyoj4r7Y2/qtt9LsQN7e9RXPbW/5fPvSQ+7LMWw+5r6hjXbM86QWqWTaCaghjr6NqmH/UYCuKoihKCFCDrSiKoighQA22oiiKooQANdiKoiiKEgIKeh22iHwEfGDxktOAAxavF0Y0DTQNQNMANA1A06AQ4z/XGHOU3xcFbbBtIyLrsi1IjwqaBpoGoGkAmgagaRC2+GuXuKIoiqKEADXYiqIoihIComaw7x7vBygANA00DUDTADQNQNMgVPGP1Bi2oiiKooSVqLWwFUVRFCWURMJgi8jFIlIvIu+KyC3j/Tw2EZE5IvKciGwRkbdE5Kte+BQReVZEtnnH6oxzbvXSol5ELsoI/z0R+Z333Z0iIuMRpyCISExE1ovIU97nSMUfQEQmi8jDIvKO9384K0rpICJf8/LAZhF5QERKohB/Efl/IrJfRDZnhFmLt4gkRORnXvhrIjJvLOM3ErKkwbe9vLBJRB4VkckZ34UzDYwxE/oFxID3gAVAMbARWDTez2UxfjOBJd77SmArsAj4FnCLF34LcIf3fpGXBglgvpc2Me+714GzAAF+CXxqvOM3inT4M+A/gKe8z5GKv/f89wP/y3tfDEyOSjoAs4EdQKn3+SFgVRTiD5wLLAE2Z4RZizfwJeAH3vsrgZ+Nd5xHmAYXAnHv/R0TIQ2i0MI+A3jXGLPdGNMNPAisHOdnsoYxpsEY86b3vhXYglt4rcQtwPGOl3vvVwIPGmO6jDE7gHeBM0RkJjDJGPOKcf+VP8o4p6ARkVrgUuCejODIxB9ARCbhFlr3Ahhjuo0xTUQrHeJAqYjEgTJgDxGIvzHmBaBxULDNeGde62FgWaH1OvilgTHmV8aYHu/jq0Ct9z60aRAFgz0b2JnxeZcXNuHwumlOB14DaowxDeAadWC697Ns6THbez84PAx8D7gJSGWERSn+4PYgfQT8uzc0cI+IlBORdDDG7Ab+EfgQaACajTG/IiLx98FmvPvO8QxgMzA1b0+eH/4nbosZQpwGUTDYfrWgCTc1XkQqgP8EbjDGtAz3U58wM0x4QSMiK4D9xpg3RnqKT1ho459BHLdL8C5jzOlAG25XaDYmVDp4Y7Qrcbs4ZwHlInL1cKf4hIU2/qMgSLxDnSYichvQA/w0HeTzs1CkQRQM9i5gTsbnWtyusgmDiBThGuufGmMe8YL3eV08eMf9Xni29NhFf5dRZnihsxT4tIi8jzvccYGI/IToxD/NLmCXMeY17/PDuAY8KunwSWCHMeYjY0wSeAQ4m+jEfzA24913jjfcUMXQLviCRESuBVYAX/C6uSHEaRAFg70WWCgi80WkGHfCwBPj/EzW8MZR7gW2GGO+k/HVE8C13vtrgcczwq/0Zj3OBxYCr3vdZq0icqZ3zWsyzilYjDG3GmNqjTHzcLX9jTHmaiIS/zTGmL3AThE53gtaBrxNdNLhQ+BMESnznnsZ7nyOqMR/MDbjnXmtz+HmsYJvYYvIxcDNwKeNMe0ZX4U3DcZjpttYv4BLcGdPvwfcNt7PYzluv4/bNbMJ2OC9LsEdX1kDbPOOUzLOuc1Li3oyZsACdcBm77v/i7exTlhewHn0zxKPYvwXA+u8/8JjQHWU0gG4HXjHe/Yf484CnvDxBx7AHbdP4rYE/9hmvIES4Oe4k7NeBxaMd5xHmAbv4o47p8vFH4Q9DXSnM0VRFEUJAVHoElcURVGU0KMGW1EURVFCgBpsRVEURQkBarAVRVEUJQSowVYURVGUEKAGW1EURVFCgBpsRVEURQkBarAVRVEUJQT8f9RERBoWPVcAAAAAAElFTkSuQmCCn”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize the T-peaks, P-peaks, Q-peaks and S-peaksn”, “plot = nk.events_plot([waves_peak[‘ECG_T_Peaks’], n”, ” waves_peak[‘ECG_P_Peaks’],n”, ” waves_peak[‘ECG_Q_Peaks’],n”, ” waves_peak[‘ECG_S_Peaks’]], ecg_signal)n”, “n”, “# Zooming into the first 3 R-peaks, with focus on T_peaks, P-peaks, Q-peaks and S-peaksn”, “plot = nk.events_plot([waves_peak[‘ECG_T_Peaks’][:3], n”, ” waves_peak[‘ECG_P_Peaks’][:3],n”, ” waves_peak[‘ECG_Q_Peaks’][:3],n”, ” waves_peak[‘ECG_S_Peaks’][:3]], ecg_signal[:12500])n”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“Visually, the ‘peak’ method seems to have correctly identified the P-peaks, Q-peaks, S-peaks and T-peaks for this signal, at least, for the first few complexes. Well done, peak!n”, “n”, “However, it can be quite tiring to be zooming in to each complex and inspect them one by one. To have a better overview of all complexes at once, you can make use of the show argument in [ecg_delineate()](https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_delineate>) as below.”

]

}, {

“cell_type”: “code”, “execution_count”: 9, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “iVBORw0KGgoAAAANSUhEUgAAAewAAAExCAYAAAC+ipGRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzde5RcZZn4+++7615dfe9OOumEEAKEhNyABEaCUa4BRXDE28ioOCKHGQGH+Q1yVc8gznLWnHFGxSEiCkfEn44ojCN4cIH85CoQNARCyKWTkHTS9+6qrnvVrv2ePyrvTnXS3enqrnR3kuezVq+kqvauvbuqq5793p5Haa0RQgghxPRmTfUJCCGEEOLwJGALIYQQRwEJ2EIIIcRRQAK2EEIIcRSQgC2EEEIcBSRgCyGEEEeBigRspdSPlFLdSqm3Rnj8aqXUxv0/LymlllfiuEIIIcTxolIt7IeAS0d5fCfwPq31MuDrwP0VOq4QQghxXPBW4km01s8ppU4c5fGXSm7+EZgzludtamrSJ5444tMKIYQQx5TXX3+9V2vdPNxjFQnYZfo88NuRHlRKXQdcB3DCCSewfv36yTovIYQQYkoppd4d6bFJnXSmlDqfYsC+daRttNb3a61Xaq1XNjcPe5EhhBBCHHcmrYWtlFoGPABcprXum6zjCiGEEMeCSWlhK6VOAH4FfFprvXUyjimEEEIcSyrSwlZK/W/g/UCTUqod+BrgA9BarwO+CjQC/6mUArC11isrcWwhhBDDy+fztLe3k8lkpvpUxEGCwSBz5szB5/ONeZ9KzRL/q8M8fi1wbSWOJYQQYmza29uprq7mxBNPZH9j6bAcR5MrOPg9FpY1tn1EebTW9PX10d7ezvz588e831TMEhdCCDEJMpnMmIK1XXDY1p3gD1t72N6dcO8/ZUaENac2c8qMCF6PJMasFKUUjY2N9PT0lLWfBGwhhDiGHS5Yd8YyPPjiTnoTWcJ+L7Nrgyil0FrTPpDmged30BQJ8LnV82mpDU7SWR/7xtrjUUoumYQQ4jjVGctw7++3kc4VmFMfpqHK7wYSpRQNVX7m1IdJ5wrc+/ttdMZkLHwqScAWQojjkF1wePDFnVhKUV/lH3Xb+io/llI8+OJO7IIzSWcoDiYBW4gjKJvN4jjyBSemn23dCXoT2cMGa6O+yk9vIsu2kjHusfB4PKxYscL9+eY3vwkUZ7DfdtttnHLKKSxZsoSzzz6b3/62mAQzkUjwt3/7tyxYsIAzzjiDs846ix/84AcjHmPXrl2EQiFWrFjB4sWLuf7660f83JWz7WgeeughbrjhhrL3mwgZwxbiCLFtm87OTiKRCI2NjVN9OkIM8YetPYT95YWAsN/Lc1t7WDSrZsz7hEIhNmzYcMj9X/nKV+jo6OCtt94iEAjQ1dXFH/7wBwCuvfZaTjrpJLZt24ZlWfT09PCjH/1o1OMsWLCADRs2YNs2F1xwAY8//jgf+chHJrztdCItbCGOkGQyya5du2hvb5/qUxFiCMfRbO9OUB8e+xpggPqwj23dCRxHT+j4qVSKH/zgB3z3u98lEAgAMHPmTD7+8Y/T1tbGq6++yj333INlFUNUc3Mzt946YkbrIbxeL+eeey7bt28va9uenh6uuuoqVq1axapVq3jxxRcBePXVVzn33HM544wzOPfcc9myZcshz/PEE0/wnve8h97eXn7xi1+wZMkSli9fzpo1a8b6koztd6voswkhXP39/fT19ZFIJFi2bNm4ZoUKcSTk9o9Dl/s3abbPFRyClmdM+6TTaVasWOHevv3221m0aBEnnHACNTWHttQ3bdrE8uXL3WBdrlQqxTPPPMPdd99d1rZf+tKXuPnmmznvvPPYvXs3a9euZfPmzZx22mk899xzeL1enn76ae644w5++ctfus/x2GOP8a1vfYsnn3yS+vp67r77bp566ilaW1uJRqPj+h1GIgFbiCNkcHCQXC6HbdsUCgW8Xvm4ienBv39Ntda6rKCttR6y/1gM1yW+cePGMe//jW98g1/84hd0d3ezb9++Ebdra2tjxYoVKKW48sorueyyy8ra9rOf/Sxvv/22u83g4CDxeJxYLMZnP/tZtm3bhlKKfD7vbvPss8+yfv16fve737kXH6tXr+aaa67h4x//eMW72eUbRIgjJJFIkM1mUUqRTCapra2d6lMSAgDLUpw8I8LegTQNY5x0BjCQynPKjMiEM6CdfPLJ7N69m3g8TnV19ZDHFi9ezBtvvIHjOFiWxZ133smdd95JJBIZ9TnNuPRYDLet4zi8/PLLhEKhIfffeOONnH/++Tz22GPs2rWL97///e5jJ510Ejt27GDr1q2sXFnMtr1u3TpeeeUVnnjiCVasWMGGDRsqNodFxrCFOELi8TjZbJZ8Pk8qlZrq0xFiiPed2kwqZ5e1Typns+bUiZc9DofDfP7zn+emm24il8sB0NHRwU9+8hNOPvlkVq5cyV133UWhUACKGdtM6/5IueSSS7j33nvd2yagx2IxWltbgeLM8FLz5s3jV7/6FZ/5zGfYtGkTUGy9n3POOdx99900NTWxZ8+eip2jBGwhjpBUKoVSikKhIAFbTDunzIjQFAkwkMyNafuBZI6mSIBTZoze0j2YGcM2P7fddhsA99xzD83NzSxevJglS5bw4Q9/mObm4sXAAw88QF9fHyeffDJnnXUWF110Ef/yL/9S3i9Ypu985zusX7+eZcuWsXjxYtatWwfAl7/8ZW6//XZWr17tXkCUWrhwIY888ggf+9jHaGtr45ZbbmHp0qUsWbKENWvWsHz58oqdozrSVy0TsXLlSr1+/fqpPg0hyqa15mc/+xn5fJ5MJsOqVas444wzpvq0xHFm8+bNLFq0aMTHTaazwyVPGUjmcLTmhgtOkfSkFTTc+6OUen2kapbSwhbiCHAch3w+7y5ZkfKGYjpqqQ1ywwWnEPJ7aB9I0Z/MuV3PWmv6kznaB1KE/B4J1tOATDoT4gjI5/PupBmlFOl0eqpPSYhhtdQGuWXtQrZ1J3hua8+QTGbTrVrXm2++yac//ekh9wUCAV555ZUJbXu0kIAtxBGQyWSwbRulFI7juBNrhJiOvB6LRbNqWDSrBqdQIJfL4PcHsTxjW2s9WZYuXTrmmeDlbHu0kIAtxBGQyWRwHMf9kYAtprWCDT3vwPansXq34nZ8Ny+EBRdC82ngkXAx1eQdEOIIsG2bfD5PLBZzl3YJMS0N7oM/roNkD/iroGYOKAVaQ3QPvPw9qGqGv7geamZP9dke16Z+UEKIY5DpEnccB9u2yWazU31KQhxqcB889/9APgV1J0C4sRisofhvuLF4fz5V3G5w5Exj4siTgC3EEZBOp7FtG4/Hg1JKAraYfgp2sWWtrGJgHk24sbjdH9cV9xNTQgK2EEeAGcP2er1YliVj2GL66Xmn2A1+uGBthBsh2V3crwyTUQ8bikVDLrjgAk499VQWLFjA1772tVHrXD/00EM0Nze7dbEP9/wjueaaa3j00UfHtW+5ZAxbiCPALOtSSqG1HrLMS4hpYfvTxTHrcviqoO0ZaFky5l0mox52Op3miiuu4L777uOSSy4hlUpx1VVX8e1vf5ubb755xP0+8YlPcO+999Ld3c3pp5/OFVdcwcyZM8f8u022inx7KKV+pJTqVkq9NcLjSin1HaXUdqXURqXUmZU4rhDTVTabdSshFQoFCoUCti1diWKacBzo3QqhhvL2CzdCz5bi/hNQ6XrYP/3pT1m9ejWXXHJJ8TTDYe69917+9V//dUznM2PGDBYsWMC7777L66+/zvve9z7OOuss1q5dS0dHBwA/+MEPWLVqFcuXL+eqq64aNt3wV77yFa655hocx+G2225j8eLFLFu2jH/8x38s6/UZSaUu9x8CLh3l8cuAU/b/XAfcV6HjCjEtmYAdCARQSmHbtnSLi+mjsP9vsdwa7UoB+sD+Y3BwLvGf//znbN++vaL1sDdt2sRZZ5015L4FCxaQTqfHVJN6x44d7Nixg3nz5nHjjTfy6KOP8vrrr/M3f/M33HnnnQB85CMf4bXXXuONN95g0aJF/PCHPxzyHF/+8pfp7u7mwQcfJBqN8thjj7Fp0yY2btzIXXfdNebfZTQV6RLXWj+nlDpxlE2uBH6siznv/qiUqlNKzdJad1Ti+EJMN6WTzDwejwRsMb149ucN17q8oK01oA7sPwaTUQ97pLreh6uV8fOf/5wXXniBQCDA97//fXp6enjrrbe4+OKLASgUCsyaNQuAt956i7vuuotoNEoikWDt2rXu83z961/nnHPO4f777wegpqaGYDDItddeywc/+EEuv/zyMf++o5msAbVWoLTGWPv++w6hlLpOKbVeKbW+p6dnUk5OiErL5Yo5mU0rwXEcmSkupg/LgqZTId1f3n6pvmIylQnOxSith32w0nrYAHfeeScbNmxgcHBwxOc7/fTTObhQ1I4dO2hqaqKurm7E/T7xiU+wYcMGXnnlFf7yL/8SrTWnn346GzZsYMOGDbz55pv87ne/A4qTy+69917efPNNvva1rw2pD7Bq1Spef/11+vuLr6fX6+XVV1/lqquu4vHHH+fSS0frgB67yQrYw13CDXvpo7W+X2u9Umu90pRaE+JoY1rTPp8Py7JwHEcKgIjp5eSLIJcsb598spj5bIIqXQ/76quv5oUXXuDpp58Git3wN910E//0T/9U1nktXLiQnp4eXn75ZaA4edTUuY7H48yaNYt8Ps8jjzwyZL9LL72U2267jQ9+8IPE43ESiQSxWIwPfOAD/Md//EfFUqROVsBuB+aW3J4DyAp8ccwyX0KRSASvtzjyJAFbTCvNpxUzmKX6xrZ9qg+qZhT3K8Nk1MMOhUL8+te/5hvf+AannnoqTU1NrF69mquvvrqsc/X7/Tz66KPceuutLF++nBUrVvDSSy8BB7q9L774Yk477dDX4GMf+xhf+MIXuOKKK4jH41x++eUsW7aM973vffz7v/97WecxkorVw94/hv0brfUh8/2VUh8EbgA+AJwDfEdrffbhnlPqYYuj1fe//336+vpYs2YNmzZtore3lw996EMsW7Zsqk9NHEcOVw/bzXR2uOQpqT7QDqz5x6MiPenjjz/OP/zDP/Dss88yb968qT6dEU1JPWyl1P8GXgYWKqXalVKfV0pdr5S6fv8mTwI7gO3AD4C/q8RxhZiuTFdeVVUVPp8PQEpsiumnZnYxCPvCEN0Nyd79E8so/pvshei7xcePkmAN8OEPf9id9X0sqdQs8b86zOMa+GIljiXE0cCsuQ6FQgSDxdpHw63bFGLK1cyGC79azGDW9kxxnTX7Z4NPs2pd46lx/eCDD/Ltb397yH2rV6/me9/73hE5xyNp6t8BIY5BJstZIBAgEAigtZZZ4mL68niL2ctaluAUbPL5JD5fFdY0CNKlxlPj+nOf+xyf+9znjtAZTa7p9W4IcQxwHMftEg8EAlRVFdM/yqQzMV3Zjk1btI0X977IzthO9/6T6k7i3NnnsqBuAV5LwsVUk3dAiAozZTUty8Lv9xMKhQCkhS2mpa5kF49sfoT+TD8hb4iWqhY3B/6+xD4efvthGoINXL3oamZWTd8828cDqUQgRIXl83k385LP5yMcDgMSsMX005Xs4v6N95O208yOzKY+WO9mDFNKUR+sZ3ZkNmk7zf0b76cr2TXFZ3x8k4AtRIXZto3WGo/Hg9frJRKJuPcLMV3Yjs0jmx/BUhb1wfpRt60P1mMpi0c2P4LtyN/xVJGALUSFFQoFNyuT1+slGAyilJJc4mJaaYu20Z/pP2ywNuqD9fRl+miLtpV1nMmoh+04DjfddBNLlixh6dKlrFq1ip07d464/YknnsjSpUtZvnw5l1xyCZ2dnWX9TgC7du1iyZKxlxmtBBnDFqLCcrkcjuPg9XrxeDzuGLa0sMV08uLeFwl5Q2XtE/aGeWnfSyxsWDjmfSajHvbPf/5z9u3bx8aNG7Esi/b2dney50ieffZZmpqauOOOO/jnf/5nvvOd74z5d5oq0sIWosLMbHDLsrAsy21hm5njQkw1RzvsjO2kLjByYYzh1AXq2BHdgaOnVz3sjo4OZs2a5W4/Z84c6uvH1nOwZs0atm/fTqFQ4JZbbmHVqlUsW7aM73//+0CxtX/hhRdy5plnsnTpUv77v//7kOfYsWMHZ5xxBq+99hqbNm3i7LPPZsWKFSxbtoxt27aV9dqMRlrYQlSYqdTl8XjctdiABGwxbeSdPMCwJSlHo5RCo8k7eQKewJj2MbnEjdtvv51FixZVtB72xz/+cc477zyef/55LrzwQv76r/+aM844Y0z7/uY3v2Hp0qX88Ic/pLa2ltdee41sNsvq1au55JJLmDt3Lo899hg1NTX09vbyF3/xF1xxxRXu/lu2bOGTn/wkDz74ICtWrODGG2/kS1/6EldffTW5XK6in3sJ2EJUmGlhm4Dt8/mkhS2mFZ9VTJc7Uh3pkWitUSh3/7GYjHrYc+bMYcuWLfz+97/n97//PRdeeCG/+MUvuPDCkSuLnX/++Xg8HpYtW8Y999zDtddey8aNG3n00UcBiMVibNu2jTlz5nDHHXfw3HPPYVkWe/fupaurOFu+p6eHK6+8kl/+8pecfvrpALznPe/hG9/4Bu3t7XzkIx/hlFNOGfPvejgSsIWosHy+2HrxeDzuv2ZdqxDTgaUs5tfOpyPZMeZJZwDRbJST6k7CUpWrh11dXT3ksdJ62JZlceedd3LnnXe6qy1GEggEuOyyy7jsssuYOXMmjz/++KgB24xhG1prvvvd77J27doh2z300EP09PTw+uuv4/P5OPHEE92L8traWubOncuLL77oBuxPfepTnHPOOTzxxBOsXbuWBx54gAsuuKCs12ckMoYtRIWZLnFT9EMphVIKx5nYuJ8QlbS6dTVpu7yCNCk7xbmzz53wsStdD/tPf/qT2/p2HIeNGzeWXfhj7dq13Hfffe4F99atW0kmk8RiMWbMmIHP5+PZZ5/l3Xffdffx+/08/vjj/PjHP+anP/0pUBzPPumkk7jpppu44ooryupNOBxpYQtRYeYLyARsKLayzReBENPBgroFNAQbGMgMjKmVPZAZoDHYyIK6BWUd5+Ax7EsvvZRvfvOb3HPPPdx1110sXryYYDBIVVUVd999N1Csh33LLbdw8skn09DQQCgUGrUednd3N1/4whfc5ERnn302N9xwQ1nnee2117Jr1y7OPPNMtNY0Nzfz+OOPc/XVV/OhD32IlStXsmLFikNqYVdVVfGb3/yGiy++mKqqKt5++21+8pOf4PP5aGlp4atf/WpZ5zGaitXDPhKkHrY4Gj311FO89tprLFq0iKuuugqAb33rW2QyGW677bayJtMIMRGHq4dtMp0dLnnKQGYARztct+w6SU9aQVNSD1sIcYBpYfv9fvc+j8eD1lrWYotpZWbVTK5bdh0hb4h9iX0MZAbcrmetNQOZAfYm9hLyhiRYTwPSJS5EhZmub1MHG3Bb1fl8fkggF2KqzayayU1n3kRbtI2X9r3EjugONMXZ4NOtWle59bDPOeecQ3L4P/zwwyxduvSIneORNPXvgBDHGBOwS8ewvV4vWmtSqdRhMzAJMdm8lpeFDQtZ2LCQQsEml03hD4TxHOX1sEcK5Eer6fVuCHEMMAHbJEyBYsCG4gQcIaYbbdtk29pIPv882bYd7v2BBQuoeu95BBYsQHklXEw1eQeEqDAzTl0asE03eCqVmpJzEmIk+a4u+n/8MIX+PlQojHfWLDdvQG7fPrIPPYSnoZGGz3wa30wZw55KMulMiAobrkvc/D+ZTE7JOQkxnHxXF733rcNJp/HNbsVbP7Qetre+Ht/sVpx0mt771pHvknrYU0kCthAVZlrYpkoXHAjY0iUupgtt2/T/+GGwLLyHKZThra8Hy6L/xw+jy1zpcKTLa7755pvuczc0NDB//nxWrFjBRRddNOz2u3btIhQKsWLFChYvXsz1118/rqRGDz30UNlrvSdKusSFqDDHcVBKDZkNbgK2SWkoxFTLtrVR6O/DN7t1TNt76+vJ791Ltq2N4MLpU16zdCLaNddcw+WXX85HP/rRUc9pwYIFbNiwAdu2ueCCC3j88cf5yEc+MubfaapUpIWtlLpUKbVFKbVdKXXbMI/XKqX+Ryn1hlJqk1Lqc5U4rhDTUaFQcIt+GGaJlwRsMV0kn38eFQqXtY8KhUg+/8KEj13p8prj5fV6Offcc9m+fTs9PT1cddVVrFq1ilWrVvHiiy8C8Oqrr3LuuedyxhlncO6557Jly5ZDnueJJ57gPe95D729vfziF79gyZIlLF++nDVr1lT2fCf6BEopD/A94GKgHXhNKfVrrfXbJZt9EXhba/0hpVQzsEUp9YjWOjfR4wsx3Zj8x6UtbBOwTVIVIaaSdhyybTvwzppV1n6e+nqybW1ox0GNMWPfZJTXHK9UKsUzzzzD3XffzZe+9CVuvvlmzjvvPHbv3s3atWvZvHkzp512Gs899xxer5enn36aO+64g1/+8pfuczz22GN861vf4sknn6S+vp67776bp556itbWVqLRaEXPtxJd4mcD27XWOwCUUj8DrgRKA7YGqlVxNkME6Ack5ZM4JpmShd6SZTCmFSEBW0wHOj/+ethojc7nUYGx1cOejPKa5Wpra2PFihUopbjyyiu57LLL+OxnP8vbbx8IW4ODg8TjcWKxGJ/97GfZtm0bSqkhNQGeffZZ1q9fz+9+9zv34mP16tVcc801fPzjH694N3slAnYrsKfkdjtwzkHb3Av8GtgHVAOf0FoPO8qvlLoOuA7ghBNOqMDpCTG5TJd4acA2JQQlYIvpQPnGXw8bpdz9x+tIlNcshxnDLuU4Di+//PKQyaIAN954I+effz6PPfYYu3bt4v3vf7/72EknncSOHTvYunUrK1cW03+vW7eOV155hSeeeIIVK1awYcMGGhsbK3LelehzGO7dPriiyFpgAzAbWAHcq5Q6tC8E0Frfr7VeqbVe2dzcXIHTE2LyaK3dGaemHjYcmDEuFbvEdKAsi8CCkyiU2WVbGBgoJlGZYHd1pctrVsIll1zCvffe6942AT0Wi9HaWpyY99BDDw3ZZ968efzqV7/iM5/5DJs2bQKKrfdzzjmHu+++m6amJvbs2UOlVCJgtwNzS27PodiSLvU54Fe6aDuwEzgNIY4xJlhbljWkhR0OFyf3SPEPMV1Uvfe96HR5iXx0Ok3Ve88rax8zhm1+brutOC/5nnvuobm5mcWLF7NkyRI+/OEPYxppDzzwAH19fZx88smcddZZXHTRRaOW16yE73znO6xfv55ly5axePFi1q1bB8CXv/xlbr/9dlavXu1eQJRauHAhjzzyCB/72Mdoa2vjlltuYenSpSxZsoQ1a9awfPnyip3jhMtrKqW8wFbgQmAv8BrwKa31ppJt7gO6tNb/t1JqJvAnYLnWune055bymuJok8/n+bd/+zc8Hg//63/9L3fiTCwW47vf/S719fV88YtfnOKzFMeL0cpratum+9//AyedPuw6bAB7YAArFGLGzX8vaUorZNLLa2qtbeAG4ClgM/BfWutNSqnrlVLX79/s68C5Sqk3gWeAWw8XrIU4GuXzeXdcsHRs0BT8GE+CBiGOBOX10vCZT4PjYA8MjLqtPTAAjkPDZz4twXoKVeSV11o/CTx50H3rSv6/D7ikEscSYjqzbXvYgO3xeFBKDdulJsRU8c2cSdPfXk//jx8mv28vKhjCsz89qdaawsAAOp3G0zg9comXU16z3FKcRwO5VBKigkztXe9BrRATvCVgi+nGN3MmM27++/3Vul4g29YG+2eDT7dqXeWU1yy3FOfRYOrfASGOIaZLfLikD6bVIsRkGsvSLeX1Ely4kODChWjHKa6z9vkmPBtcjGw83wXybghRQWbZ1kgBW8awxWQKBoP09fWVFRyUZWEFAhKsjyCtNX19fW4GxLGSFrYQFZTL5dBaH9IlDsUgLi1sMZnmzJlDe3s7PT09U30q4iDBYJA5c+aUtY8EbCEqyCSBKE2aYsikMzHZfD4f8+fPn+rTEBUifR5CVJCpxjVaC1ta2UKI8ZCALUQFmVnivmFyLZuALePYQojxkIAtRAWZ1KPDtbBNN7kEbCHEeEjAFqKCTJd4aS1sw7SwZRxbCDEeErCFqCDTwg4MUyvYtLqlYpcQYjwkYAtRQWYMe7gWtgnY8Xh8Us9JCHFskIAtRAWZZV2jBWzTbS6EEOWQgC1EBZnx6dECdjKZnNRzEkIcGyRgC1FBZgx7uIBtlnql0+lJPSchxLFBArYQFWS6xIfLEWyCuARsIcR4SMAWooLGMktcxrCFEOMhAVuICjJJUYbrEjdB3MwkF0KIckjAFqKCHMdBKTVql7hphQshRDkkYAtRQbZto5QaNjVpVVUVIC1sIcT4SMAWooJMC3u4gB0KhYADE9OEEKIcErCFqCBTOnO4etjhcBiQ1KRCiPGRgC1EBY3WwpYxbCHERFQkYCulLlVKbVFKbVdK3TbCNu9XSm1QSm1SSv2hEscVYroxs8Qt69CPlukSl2pdQojxOLQZUCallAf4HnAx0A68ppT6tdb67ZJt6oD/BC7VWu9WSs2Y6HGFmG5Md7hSatgu8WAwiFJKArYQYlwq0cI+G9iutd6htc4BPwOuPGibTwG/0lrvBtBad1fguEJMK4VCwe0SV0od8rjpJjetcCGEKEclAnYrsKfkdvv++0qdCtQrpf6PUup1pdRnRnoypdR1Sqn1Sqn1PT09FTg9ISaHaTkP17o291uWJQFbCDEulQjYhzYlQB902wucBXwQWAt8RSl16nBPprW+X2u9Umu9srm5uQKnJ8TkyOfzaK2HbV3DgUAuAVsIMR4THsOm2KKeW3J7DrBvmG16tdZJIKmUeg5YDmytwPGFmBZMQpSRWtimq1xrPWpgF0KI4VSihf0acIpSar5Syg98Evj1Qdv8N/BepZRXKRUGzgE2V+DYQkwbpoU93AxxOBCwHcdxJ6gJIcRYTbiFrbW2lVI3AE8BHuBHWutNSqnr9z++Tmu9WSn1/wEbAQd4QGv91kSPLRrCVHcAACAASURBVMR0YhKijNTCBiRgCyHGrRJd4mitnwSePOi+dQfd/lfgXytxPCGmo0wmg9Z62KQphmVZ2LaN4zijBnYhhDiYZDoTokLMGPbhAjZI8hQhRPkkYAtRIWMJ2KZVLQVAhBDlkoAtRIWYIDxaV7dlWWitJWALIcomAVuICjFB2BT5GI7pEpeALYQolwRsISrEzBL3+XwjbuPz+dBaS4lNIUTZJGALUSHpdBooFvkYiRnfzmQyk3JOQohjhwRsISrETDobLWCb1rcJ7kIIMVYSsIWoENPNPZYWtgnuQggxVhKwhagQE7ADgcCI20iXuBBivCRgC1EhZub3aAHbdInLLHEhRLkkYAtRISZ72WjLusxjMoYthCiXBGwhKsQE7NHGsE3AljFsIUS5JGALUSGFQgGl1JgCtuQSF0KUSwK2EBViAvZoucRNMJcWthCiXBKwhagQU+N6tFziwWAQpRS2bU/WaQkhjhESsIWoENPCHi01qZlBLgFbCFEuCdhCVIjjOMDo5TVNMJcxbCFEuSRgC1EhWmuUUqN2iQcCAZRSErCFEGWTgC1EBTiO4wZspdSI20nAFkKMlwRsISogl8uhtR61OxwOLOsyAV4IIcZKArYQFWDyiFvW6B8pM4attZaALYQoiwRsISogl8vhOM5hA7bH48GyLAqFgjtJTQghxqIiAVspdalSaotSartS6rZRtlullCoopT5aieMKMV2YRCiH6xIvDeiytEsIUY4JB2yllAf4HnAZsBj4K6XU4hG2+xfgqYkeU4jpxgTs0WaIAyilsCwLx3HcbnQhhBiLSrSwzwa2a613aK1zwM+AK4fZ7kbgl0B3BY4pxLRi6luPljQFii1spRRaawnYQoiyVCJgtwJ7Sm6377/PpZRqBf4SWHe4J1NKXaeUWq+UWt/T01OB0xPiyMtkMmOaJW5a2CA1sYUQ5alEwB5u0enB01//A7hVa33Yxada6/u11iu11iubm5srcHpCHHljbWEDErCFEOMyenNgbNqBuSW35wD7DtpmJfCz/QklmoAPKKVsrfXjFTi+EFPOBGyzzno0Xq8XrbVU7BJClKUSAfs14BSl1HxgL/BJ4FOlG2it55v/K6UeAn4jwVocS0zAHq0WtmEmpskscSFEOSYcsLXWtlLqBoqzvz3Aj7TWm5RS1+9//LDj1kIc7UxrORQKHXZbj8cjLWwhRNkq0cJGa/0k8ORB9w0bqLXW11TimEJMJyb4hsPhw25rxrlllrgQohyS6UyICjATyEy969HIGLYQYjwkYAtRAdLCFkIcaRKwhagA27ZRSo1pDNus1ZYWthCiHBKwhagAM+N7rF3iSilpYQshyiIBW4gKKBQKKKXGHLBBusSFEOWRgC1EBZgu8bEkTjHbSKYzIUQ5JGALUQGmtvVYM52BBGwhRHkkYAtRAY7jYFnWYctrgswSF0KMjwRsISYol8uhtUYpxf58+aMyk84kNakQohwSsIWYIFNa0+PxjClgB4NBlFIUCoctXieEEC4J2EJMUDqdHlMtbMPMJC8UCmh9cCVaIYQYngRsISaotIU9FmZimm3b7mQ1IYQ4HAnYQkxQOp0GDkwmO5xAIIBSCq21jGMLIcZMArYQE5RKpdBaj2lJF+COdTuOI0u7hBBjJgFbiAlKJBLA2NKSmu1MC1sCthBirCRgCzFBpkt8LJW6oNh1bmaTS8AWQoyVBGwhJiiZTAJjD9iWZWFZlrSwhRBlkYAtxASZMplVVVVj2t4kTpGALYQohwRsISbIdImPNWCbSWcSsIUQ5ZCALcQEZbNZlFKEQqExbW9yjsuyLiFEOSRgCzFBprTmeMawpQDI0Uk7Dk42i5bEN2ISjS2XohBiWFprNyd4MBgc0z5KKSmxeRTStk22rY3k88+Tbdvh3h9YsICq955HYMEC1BjT0woxHhX561JKXQp8G/AAD2itv3nQ41cDt+6/mQD+Vmv9RiWOLcRUchzHbWGPNWADbhpTaWEfHfJdXfT/+GEK/X2oUBjvrFkAOPk82d3vknlwO97GRho+82l8M2dO8dmKY9WEA7ZSygN8D7gYaAdeU0r9Wmv9dslmO4H3aa0HlFKXAfcD50z02EJMNZMPXCk15kxnIAH7aJLv6qL3vnVgWXhbZpHv7SX9/PPYHR3o/T0kKhDA09BAbs8eZt76ZfytrVN81uJYVIkW9tnAdq31DgCl1M+AKwE3YGutXyrZ/o/AnAocV4gpl8lkcBwHj8cz5mpdIAH7aKFtm/4fP4wGnMFB4k8/TSEaBa1BKVQggAoE0IDd1YXd0UH7F29gzvfulaAtKq4Sk85agT0lt9v33zeSzwO/HelBpdR1Sqn1Sqn1PT09FTg9IY4cU1rT5/ONuVoXIGPYR4nMli1k3nmH+O9/T/y3v6XQ3Q25HOTzkMuhEwmcgQGceBzl96OCQXJ799L59XvId3VN9emLY0wlArYa5r5hi/wqpc6nGLBvHe5xAK31/VrrlVrrlc3NzRU4PSGOnGQy6QbscpiALcu6pq98Vxedd3+d1J//hNPbC/snFw6hdfH+TIZCdzeFRAKUIr1pE30P/b9oeX9FBVUiYLcDc0tuzwH2HbyRUmoZ8ABwpda6rwLHFWLKmYBdTnc4FAO2LOuavvJdXXTf+z2y27dDKg0ly7ccpUhEIsRqasgcXPAllUJnszixGJl33iHb1jbJZy6OZZUI2K8Bpyil5iul/MAngV+XbqCUOgH4FfBprfXWChxTiGlhcHAQGHseccNkOysM12oTU8qMW+c7O9Gp1CGPZ0Ihcj4fCkiFw2SCBwVt2watyW7ZwuCTI47+CVG2CQdsrbUN3AA8BWwG/ktrvUkpdb1S6vr9m30VaAT+Uym1QSm1fqLHFWI6MC3ssWY5M0zAlhb29JNta8Pu7SG3eXOxy7tE3rKIVVdjezw4WpMNBOhuaiJaU03B2v91WiiAUuA4DD7zDI7MUxAVUpF12FrrJ4EnD7pvXcn/rwWurcSxhJhOTC3s6urqsvYzY95mWZhlSdLB6SL5/PM42RyFWIyCUmQDAdLhMOlgkHhVmHQ4TDCVxtIatCYf8DNYXUMkmSScTlM3MIC/UACPB53JkNmyhfDSpVP9a4ljgKTlEWIC0ul0WWlJDROwC4UChUJBAvY0oR2HbNsOMn199EciRGtqSEYipINBCh4PeZ8Pyylg+3x4Cg6KYra7vM9LNuAnlQ6RCodo6uklkkigQiFSf3xFAraoCAnYQkyAqdRVU1NT1n5+v98dw87lcmXPMhdHRj6dphPN7oCfwQUnkfP70YBlF7DQWNohmM6g0Gig4PGigbzXRyYYIhMIkLQj5Lw+Wrs6qc5myWzahHYclFyUiQmSgC3EOJWWxxxPC7s0YI+1NKc4MrTWxGIxNr/9Nls9HjLhKixH489m8OdyBNMZCh4POb8P3/5UtFpDwWNT8HrxZDUZx8H2erE9HtKzWsgHAixMp/Fu346TTuOR91hMkARsIcbJBFulFJFIpKx9TRrTQqEgE8+mmG3b7Nixg02bNjEwMEA2EMBTiBJOJakajONxHGy/n4LfT1U6TVUqSTCTxVMoYBUKaMsiHQoxWB0hHqkm5/eR9fnoapmJJ55gcXc3ud27CS1aNNW/qjjKScAWYpxs28a2bTweT9mzxAOBAEoVcw5JtrOpE41GeeONN9i5cyeZTIZwOEzDvHk4e/bgTaXJBQLYSqEch6pEnPq+fjyA7fGQ93nBW+wS92cy1OXzeHN5og31ePI2qUCAfbW1VPn9NL34kgRsMWESsMUQjqPJFRwsDfFsHq01fq8Hn8ci4PNgWcMltjs+pVIptNZ4PB4CByfQOAzTJe44jrSwp0ChUGD79u1s2rSJ/v5+tNY0NTXR0tKCz+slumUrub5+QskkvmwWS2sKXg/xulo0ChTk/H4cjxdHqWJqR6WKy8A02KEA4VyORDDInlktzG1ro0HGscUEScAW2AWHbd0Jnnm7iz9s62FL5yDxTGFIflmvgpbaIBcumsnHVs7htJYavJ7j+8snHo9TKBTw+XxlVeqCYsC2LGvIOLiYHIODg7z11lu0tbW5rerGxkaam5vJZrMUHIf6C86ne89ucnaeXCCAchy8hQKegl2cHe44ROIJAtks1v4saHmvl1QkQqq6mnwoRMbnw5fPk/L52KRzLMznUWVe2AlRSgL2ca4zluHBF3fyTucgr+7oI20PmwYeW0N7NMPDL7/LM5u7eP/CGdxwwSm01I69BvSxJh6Pj6vwBxRTk0oLe3I5jsO+fft466232LdvHx6Ph5aWFmpqagiFQmQyGSzLwufz4Xi9zPjoR0l+97t4kymC2Sy+XA6vbRerdGldXId9kLpUinw8TjiXY8+cVnJ1dSigUyne3beP+fPnT/4vLo4ZErCPY52xDPf+fhs7exK8tKN/+IotB3EoBu7fvd1FMlfg1ktPO26DdiKRQGtNMFj+728ynWmtyWazR+DsRKlMJsM777zD9u3bicVihEIhmpqaiEQi2LZNNpvF6/Xi9XrxeDzU19czY9EibMeh6+6vo9PpA1nPhgnUAHg84PPhy+VojcfxplLsaZ2DBuI+Hy+99BKzZs0a19+LEFCZXOLiKGQXHB58cSc98eyYg3Wp7niWP7/bxw9f2IFdcA6/wzFoYGAAYFxLsoLBoNslLhW7jhytNfv27ePll1/mrbfeIplM0tTUxPz584lEIiSTSZLJJLlcDq/XSyQS4YQTTmDBggVUV1dTd/nl1Fx+Ob5588DvL45TH0wpN1jj8WBVV+NraWG2hjnhMFX5PFW1tfT19fHmm2+iRwr4QhyGtLCPU9u6E3QNZnh5Z1/ZwdpoH8iwrTvOtu4Ei2aVlzjkWBCPxwHKXtIFDEmUImPYR0YikWDXrl28++679Pb24vF4aG5uprq6mlgshm3bFAoFampqaGlpobGxkYaGhiGV15TXS/MX/44ewO7tIfPWJgrRaLFb3LLA58Py+8HrdctvehoasICqZctoyaSJB4NYM2bQ1dXFli1bOP3008tety8ESMA+bv1haw/9yRzJzPhbd7aGd3tTPLe157gL2FrrcecRh2KXuBn3loBdWYVCgb1797Jz5046OztJpVJEIhEikQhKKfr6+rAsC4/Hw5w5c2htbaWxsXHEbHO+mTNp/uLf0f/jh7H8ftLbtmP39IBloYJBKBTQuRwohae2FiscJrRsGTqfp1bDiRdeyK7eXqLRKH19fezatYvFixdP8qsijgUSsI9DjqPZ3p1gV2+CQknz2sLBg0OVyuHFxk+BND7i2g94KCZnHNol2BlLs60rjuPo42rJlxn3hIkFbJklXjlaa/r7+9m+fTudnZ0MDg5iWRb19fX4/X6y2Swej4dgMEgkEqG5uZl58+aNaUzZN3MmM27+e7JtbST+8BzJV14h+847OPFB8Afw1NbibWnBf8IJoBROLIansZGGz3ya2upqBv/8Z+LxOB0dHWzcuJFFixa56/CFGCsJ2MeRQqFAKpUinc1DNkU0dWCyU5XKESZLnUpTZyUJk8VPgQAF8trLbl1Lt64hpsPYHJgRnbM1+YJDruAQtMqbKX00S6fTZLNZLMuirq6u7P09Ho9b8ENqYk9cLBajra2Nrq4uotEotm3j9/upqqoqFufI54lEIgQCAcLhMLNmzaKlpaWsoivK6yW4cCHBhQtpvPbzOOk02V27SD3/Atldu4qXsvk8gQULqHrveQQWLEB5vfiAlpYWotEovb29dHZ20tHRwezZs4/UyyGOURKwjwOFQoFYLMbu3buJxWLFOwc6ma3zKOXHAmrIELZyVJGlgRQ15ACNA3iVwzwVBUcDFlEdorB/vqKmOGnWf5ytyU4kEm6Ws/FMOivtEpdlXeOXSqXYunUr+/btY3BwENu28Xq9hMNhPB6P+x7V19cTCoUIh8PMnTu37GItB1OWhaeqivDppxM+/XS046DzeZTPN2xylNmzZ9PR0UFDQwMdHR38+c9/loAtyiYB+xiXzWbZvXs3HR0dbhduPB6nNtfDqSrJfA/k8ZLUPgooqlWGIDZpLAr4SOLFowuEVYEWlSRPABtFTIcAhceCRbOqj6vucCi+ho7juMGhXEopaWFPQDabZevWrezZs4eBgQFs23Zbz6ar2bIsQqEQkUiEYDBIfX09ra2tR6QymrKsUZOihEIhGhoaSCQS9PT0sGvXLtLpdNkpbcXxTQL2MSyXy7Fjxw6i0SiO49DX10dPTw/pdBqvowlZefwFB4c8VSqNd//4dAove5xaUgQJkqPKyuElTVDlqSdOFi957SWFn+qQj/efNnOKf9PJF4vFKBQKhMPhca+rlRb26BzHcXuEIpEIPp+PVCrFli1b2L17N9FolHw+7wZlwL0I8ng8VFdXE4lEqK2tpa6ujsbGximtOz579mx6enqorq4mGo3y5ptvcvbZZ0/Z+YijjwTsY5TjOLz77rukUimUUnR1ddHb20s+n6exsZHaujr+2NbHYH4QPzYWmhyKPh3kXaeBPl2DA8y2YihH4bdsqslRr7IkdYqs8pDXHs6cO4NTZpS/rOloF41GgeJ66vG22EzwkHXYhzITyMyEvH379tHb20tXV5c7HGHGqE2aVzMvIBAIUF1dTXNzMzNmzKCqqmpKA7VRU1NDTU0NjY2NRKNR3n77bc4888why8iEGI38pRyDtNZ0dna6a0137txJX18fAKeddhpr1qwhEolwRmeUv173LPlMCo1FnBA5fBRHpout7ZgO4VGahBPAbzkEsKlTafJ48QUC3PnB0467nOImmGit3aVC42GynTmOQy6XKzsf+bEsHo+TSCTcuRfd3d2kUil8Ph+BQICampohFc98Ph/BYJBAIEBzczOzZ88e1+z9I8myLFpaWujv7ycQCDAwMMDWrVtZuHBh2altxfFJAvYxqKOjg+3bt5NKpdxZs5ZlMW/ePC644AK3C3dBSx1f/9h7+Luf/olc6fqukqVbMR0ionIkdYAgNgFsqlSOrJXj/1ozlxnh4ytYQ3GGuOm5qK+vH/fzmJaVSeBxvLJtm0wmQ6FQIJPJ0N3d7SY7yWazFAoFtyJaafpQk8c9HA5TU1NDXV0dLS0tVFVVTdslU01NTVRXV9PU1MS+ffvYsGFDMQ3qjBkStMVhScA+RmiticfjvPPOO3R2djIwMEAymSSTyeDz+Tj55JM5//zzDxlvvej0Fv7z6jO5+b82EM8cGjQcLGI6SKMqMFAIE7JyVPsLXNQaZE64wODgIKFQaFp0OU6WeDxONpudcMAu7Uo/HrvFs9ksfX19RKNRYrEYXV1d9PX1kclksG0bn89HKBSiqqrKDdJQnLBnur1NdjIzsWy6BmrD5/PR3NxMb28vfX19xGIxenp63ElxQozmuAnY/f39OI5DKBTC7/cPad3kcjny+TxKKfx+/4hXuubLwHEc0uk0tm2jtR7SOjKzf71eL8Fg0G0JmAQZ5v/5fN7dT2tNIBBwH4NiUEin026LwpxroVBAKYVt2+75xONxotEo3d3dJJNJ8vk8zv6Sf9XV1SxdupQVK1aMODnqosUt/M+N5/H1/9nMn3f3E0vbQxKqJHSAGpWlKuhl6dy51Oo4igK9vb1UVVUdd182iUSCTCaDUoqGhoZxP495X/P5/HEz8Uxr7fb8mHkVsViMTCZDOp0GikEtEom4f1tmCVwwGKS2tpbm5mbq6+uPigA9nKamJmpra4lEIkSjUTo6OmhqaqKuru6o/H3E5KlIwFZKXQp8G/AAD2itv3nQ42r/4x8AUsA1Wus/VeLYY/XCCy+QTqfdD4T5V2uN4zhuoNRaY1mW+yVqAq7jOCilKBQKbmvS3DbBUSnl/pQWdbAsy73v4B/LstznMPv6/X6UUvh8Pjf4msfNeRYKBfcYtm27j5deLJx44omcfvrpzJ49+7DdbSc2Rvj+p89iW3eC//NOF5s7iqUjUTC/KcK5c4IEclHyuSy7du1icHCQvr4+d9zQTAA6HphlRD6fb0IXKmbM+njIdpbNZkkkEuzdu5e9e/fS09NDJpMhl8u5F6GBQIBQKEQwGBxyYW26vBsbG6mrqzvqq11FIhHq6uqoqalhcHCQjo4OTjzxRJqammQegxjVhAO2UsoDfA+4GGgHXlNK/Vpr/XbJZpcBp+z/OQe4b/+/k8LkfU4mkwBugDNBs7TlXE7XpJmZaoK6CbimJWy+iMyxSi8SzP6l9xvmPEu3hQMXBKWPeb1eLMvC7/e7k3FaWlqYP38+s2fPLusLwOuxWDSrhkWzanAcTa7g4PdYWFbxQmHvXg+9vb3U1dW5X7bd3d3uLN3W1tZR15UWCgW3Z8Dn8x21rQmzTC4UCk1oHa1pYR+rAdu2bXp6etizZw+dnZ309vaSTCbdzx8UL1rMsqu6ujo3YHs8HiKRCNXV1YTD4VF7vo42Sim3K7+np4dkMsmePXvK/ryK408lWthnA9u11jsAlFI/A64ESgP2lcCPdTH6/FEpVaeUmqW17qjA8Q9LKYXX6yUUCuE4jtuCBdwWqdnOtIY9Hs+Q7Uwg93g8buAxXzomqJrHTEAqDUpmuQkULwxMd7jpijfPk81m3Za3x+PB5/MNSWNpjuE4zpC8yGbWbGmRg4mwLDUk1ahSilmzZpFOp6murnaDdSKRYM+ePW5LacaMGdTW1qKUIp1Ok0gk3Ela+Xzebf0Hg0Gqq6srPpPXtm1SqZSbJMa8XuY1heJrnkgkyOfz7kVPXV0dVVVVhEKhUQNDJpMhGo2itaaqqsp9T8fD7/e7PSzHSsC2bZv+/n46OzvZvXs3/f39JBIJ9+/DXFya7u3W1lbq6urc8WrzOTX/P1ov6g6nrq7O/fvv7e2lp6eHWCw27Wa2i+mlEgG7FdhTcrudQ1vPw23TChwSsJVS1wHXAZxwwgkVOL1iIFy4cCGJRML9kjSpCy3LcoNjaYs1l8u53c3mOcwXfi6Xc79gTbe4GZc295lu4tLWZOmYm+ne9vv9blA2V9der9dNsTgWk/XF5vF4OOGEE9wAk8vl6OvrI5lMsnPnTmKxGPPnz6e5uRkoJhfp6+tzX8NwOIxlWSSTSfd1aWxspKmpaczdnKXj/Ob/ZllUOp0mk8mQzWbJ5XLFvOn75xrk8/khFw6lwwiO4xAIBJg7dy4LFy4cNcd0NBollUoBUFtbO6HJduZ9O5pb2GZMuq+vj87OTrq7u+nv7ycajZLL5dwLZK/XS0NDg7sWuaWlhZqaGvdv33SBH4ksZNOR6Q2rr69nYGCAWCzG3r17aW1tPWYvUqbCSLXHD77fNJZMI8z8XZb2hprPaunwZeljk6ESAXu4Mz34VRrLNsU7tb4fuB9g5cqVFav0bmaRmiA83Bdk6eOA280MDFlKYt6gmpqaYd8oy7LcN9UonVgUCATweDxDJpQdbLp+cQUCAebPn4/H43F7Ckxg7Orqoru7e0ivRWkPAuCOdZuLlz179hAKhWhqamL27NnU1tYeUsnKBNxMJkM8Hh8yyS+RSJDNZkmlUu5FhNnWfABNS9ooHQIpneTX399PLBbjggsuOJBr2nGgkAOPHyyLwcFBEokESimampom9EE1F3RaazKZzLifZyoUCgU6OjrYsmULvb29DA4OuhdM5jMSDAbdoNTQ0EBDQwPV1dUEg0G3d+JY6eYul1lhUFtbSygUIpFI0NHRQTKZHFd9dVHkOI772TcX5sMx3xH5fN5d8WHbNvF43I0P5mK/dI6SCdgmBti2zeLFi1m1atWk/H6VCNjtwNyS23OAfePY5ogxrTmzjjMUCh0y+ax0ZrVphZd2Y5duO55W1dE+UaZUIBDgpJNOorq6mj179tDe3g4cmD1d+gdurlTNMEM+n2dgYAC/3+8uB0smk3R1dbFlyxbC4bDbI1E6JGGe03zITHAwM/XNv6XDFCYYmIsfs5bXDDWYizDHcYhGo/T399PW1kZjfR2rT2nE2vEMdL8Djg2WF2Yuoj81l9z+Mo0zZ04sJavpzSntnZnuBgcH2blzJ1u2bCEajbpfaoDbc1VXV0drayszZ850W9Emr/fhhhyOJ6Xd4qlUioGBAbq6uiRgH4ZpKJgLcvMdYXrVzEW7KfwCB4bKEokE/f39Q4K6WelTOq+ptBVderFvtjFB23EcIpHIURWwXwNOUUrNB/YCnwQ+ddA2vwZu2D++fQ4Qm6zxa6NS3euiyOPx0NLSQm1tLbNnz3azUeVyOTcImQueUCjkdp2a2cLZbNZtjZW2qOPxOID7ATLjnuZDUjpj3lwEmIl7lmW5gdjr9br/DwQC7gVb6ePBYNANls3NzezYsYN97e28+cenWfbORmqTbZCNu4nfMm0vEeUcnOxMvFX1NDY2Tug1NJm6pvMYtnnfdu/ezebNm+nq6iKVSrkXSOYCuKqqirq6OubPn09TUxNer9dtRU/X3qKp5vV63bXk/f397us8b948SVd6kFwu535nmB63bDbr5kQww5JQvEA3w2TRaNTtFTMX+4ZpSJihKXMBXfpd4vf73QmP5jPq8/ncXj6fz8eiRYsm7XWY8F+F1tpWSt0APEVxWdePtNablFLX7398HfAkxSVd2yku6/rcRI8rpodQKERrayutra3kcjl6enoYGBgYMokIDrRyk8kkg4ODDAwMEI1G3Q+SqS1dOmvefHBMkIYDvR8m2JmekKqqKncyUzgcJhwOu2t5R5vIEwgEsCyLeDxOQGfo27WJQUezsTPFe+kEfaBLrScbJq4GKVBDdTpDxIkDTeN+7UpbmtOphW0unLq6uti6dSvt7e0MDg66wxter9ddmtTQ0EBraysNDQ1uV7e5WBKH19DQQH9/P1VVVfT19dHV1UUymaS2tnaqT23KFQoFN/lTOp12W7fxeNz9Mbkt0um0O/fIzGExuS7Md4rX63XnUJiJuWaukVme6TgONTU1NDQ0EIvFyOfzhMNh8vk8uVzOEUto6wAAHC9JREFUHc7z+Xzu8Ol4qvWNV0Uu47TWT1IMyqX3rSv5vwa+WIljienL7/fT2trqziYH3Ml0ZhihqakJ27bJZrNut3YqlaK3t5d4PM7g4CCAOxnMdJ2bq91AIOAu+zFjpKbFbIY8xjNkUR0Osaj9UfY4fWzW89nMfFbxZ8xARh4vXTSR1cVAVJvfg//3X4WPPQie8X2MSnNhT4eAbcal3377bXbv3s3g4OCQVkVDQwMzZ85k9uzZNDc3M2vWLCkPOUHV1dVutbFYLEY8Hufdd99lyZIlx1X2QMNxHDcRlOmRMy1rM2HU9LyZHjrzPVJ6QWkmOZrVCI2Nje7frWlZw4GLUzOObS72Afc9SaVSbo/iZAbn4Ui/i6g40+IdTumSt0gkguM4ZLNZdzzYdHeVdkuZK2Ezm/+IdBd2bKBq529YpOtoo5UBatjFbE5jNwUsOmgmQYAMPhSamboHa8sbsP0ZWLh2XIc0v9NUj2E7jsPu3btZv349e/fuHTJUEYlEmDlzJjNmzGDGjBnu+mHpsq0MpRR1dXU0NTXR19dHOp1mz549nHjiiQcmPh4HTPa7WCzmtpBNfvnSsWbbtt3VHmZpq8/nc9fwV1VVuZnkzIV9aYv6YGby8HDMexOJRNyevKkmnzoxpUonI02pl/8TsnHmkqOBKJ3M5E1OYx6dxKihgxloLHIE8GIz13SX//ZWOPnCcbWyS9fpT0Uu8UKhwO7du3n55ZfZt2+fm9kvGAzS0NDA7NmzmTlzJvX1xfH6Y2ni5HTS0NDgTjZLJpNEo1F6e3vdQHGsyufzbmpWM4HRJJyCA4ms0um0m3DHXMhXVVXR0tJCa2srTU1NNDQ0EAgE3G502/7/27v32Miu+7Dj39+9dx4ccjl8Lzkkl0vuMno/okqCIFlwU1lNrRZRCjRFgsYVgiBG2qaJgSCO2gApigSBChiBG6BtIsgGZNhoaidu7RYuDFmWm8SGDCm2LO9qpZWp5YrLJTlDct7vmXv6x/DekLvkLpez5Mxwfh9gwXncmTl7dri/e8495/er7bhU1ox2Ojltn5Yo1SquC++/AhgilJjnEnGGucpJLnCWMkFs6tSxKBOijzzjNMqVkroEq2/D5EO3/LGtCtj1ep3FxUXeeOMNP+mN4zhEo1FmZmaIxWKMjIwwNjbWVGIYtT9ewqNoNMrm5ib5fJ4rV64wOjp6rBKpeDNJxWKRzc1Nrl69ysbGBoVCwa+85l0K8y6ZeYtYvZPIkZERpqamOH369K7rJLzv8XGlAVupagEqjdXpAtzJAj/gXkqEWGWEEZJY1EkwBAjjJAixbVX3G58/UMDevjr+KAK2MYZ4PM7rr7/OwsICxWIR27YZGRnh7NmzTE1N+VPex3lk1468feqrq6v+1qONjY3bkrWw1bz68Wtra2SzWb+SoDdijkQihEIhisUimUzGT80cDAaZmZlhamqKM2fOHKuTl4PSgK1UtcD2PD4DFDjNEu8yzxrDhKmQJ0KGPoKUmeMyNu7fvf6d/w0/9ydwi0Fu+wI5b8XpYU2/pVIpzp07x49+9CPS6TSWZTE0NMS9997L6dOnGR0d1SnvFvKuwfb39/s7KeLxuJ8drhNVKhXW1ta4dOkSm5ubVKtVPzVtNBolEAj4K8BXVlao1+s4jsOpU6eYmZnh7Nmz+p28hgZspdyddcAD1LiXi1xhkgz9fIhgU8UgDJNiivjO11dSUCtB8NZWkHoLWbyta4cRsOv1OktLS7z55pt88MEH1Go1enp6mJub45FHHrlhGlZ1dLwTqKGhIdbX1ymVSmxubrK+vk4kEmmr66i78aa7vQxhV65cIZFIkEqlqFarfo0DYwyRSIRKpcLVq1f9NMV9fX1MTU1x7733Husp7Wa197dAqaNg3OseirHJnbzPZaaxqSFYDJDjbt6nj+L179FEwAZ2LLa5XUqlEhcvXuTNN99kbW3Nr6j22GOPcerUqdYv9FM7DA8Ps7a2Rm9vr7/PeHNz09/v3o4KhYKfR6FcLnP58mUSiYSf8OjEiRP09fX5C7+SySRLS0uUSiUcx2FkZIS5uTnm5+f1+7gPGrCV6h297qEeStzH+wSpkyOCjWGSFSaJ75wO9xRTELm1/1S3Z2rzMjPdrpriuVyOc+fO8cMf/pBUKkUwGOTuu+/mySef1NSXbcrLK+BNi3tFVYaGhohEIm01PexlEfMy3iUSCZaXl6nVavT19RGJRHYUyMhkMmSzWfL5PJZlMT09zdzcHNPT0xqob4EGbKWcIPSMQHF9x8OjJIlwARcLwWBTp4c9inTcYrCGvyv7Cre3JnahUODcuXO89dZbpFIpIpEITz75JPfff3/bT612u5GREX9PtleMIplMEg6HGRsba4t/P+8aO0C5XGZ1ddUvmuHlRvdyeRcKBfL5PMVikUAgwMTEBGfOnGFsbMwP6mr/Wv+vr1Q7eOxfwWt/sOMhAfoo3Py14kDoYAuDvK0styt5Srlc5vz585w7d450Ok1PTw9PPfUU99xzj/7n2AGi0SgDAwOEQiE/b/bGxgb9/f0kk8mmK8Q1o16vk81m/exfmUzGz0ZmjPEXzpVKJfL5vF9zPhAIEIvFuOOOOzh58qQWf2mCBmylAB77dXjtj4ADXEee+nu3vELc4/3n5dXjbYbruly6dInz58/70+CPP/64BusOIiKMjY0xOjq6owpeNpslFAqRTCYZHBw80n9Pb6Sfy+VIJBKk02lEhEqlQiAQIBKJYIwhGAySyWT8qfJwOMz09DTz8/Ntew2+02jAVgog1AdP/T68+h9u7XViwVP/8cAf61UK8nIjN2N9fZ0f//jHbGxsYFkWd911Fw899JAG6w4zODjI2NgYa2tr/uKt1dVVotEopVKJdDrNwMDAobejXq/7o+mNjQ3S6bSfL8Dbv+9Ne1cqFX8aPxQKMTU1xfz8fNMV7dROGrCV8jz+G/DO/4SVt/b5AoEzT8H0wWvheqtnjTFNBexKpcKFCxdYWVnBGMP09DSPPPJIW1zzVLfGsizGxsYYGRlhZWXFr0K1srLC3NycX4zisBKJGGP8FKnpdNoPxMYYQqGQn+jEK9KRTCb9/dUTExPMzs4yMTGhU9+HQH+blfLYDvzSf4ev/AosfZ/tyVSuIzbMPN5ImHLAal3QuIbtbe1q5hr26uoqCwsL/p7Xu+++W0c3HWx0dJTx8XFWV1cpFAoMDw+zvr7OiRMniMViZLPZGxbZOQiv8lUmk+Hy5ctsbGz4QTccDtPX1+d/XxOJBKurq1QqFXp6ehgdHWV2dpbJyUk9STxE2rNKbdcfa5TM/JvPwgf/DzY/ALdCYwkaYAdhcBbmPgof+VTj+CZ4I+x6vX7g9KTlcpl3332XbDaLbdvEYjHOnj3bVLtUa9m2zcTEBMvLy8TjcVzXJRKJcPXqVcLhMMPDw/615GZLPnrT2tls1q/JXSgUEBFqtRoDAwNEo1Ecx/ELxsTjcX8f9ZkzZ5iamrqtJw9qdxqwlbpWfwx+9o8g8S4svAqr56FahEAPjN/TmAYfvbOpkbXHK2AgIgdedBaPx1laWsJ1Xfr6+rjzzjvbas+uOpiRkRFisZif8Wx2dpZ0Os3y8rJfNjKVSmGMueVg6Y2mc7kc6XSazc1Nstmsn9feK7ZRq9VwXddPIXr16lXK5TInTpzg7NmzzM/Pa6A+QhqwldqN7cD4vY0/rgv1SmN0fZvTeG6vUHSQTGe1Ws0v5OGlt5yZmbmtbVSt4SUY2djYYGlpiXg8zujoKOl02q/mNTQ0RDqdplKp0N/ff8PrxtvLVXr7o71FZV7K0GAwSC6Xo6enh0gkQiAQIJvNkkgk/Gx5c3NzPPDAA0SjUV3QeMQ0YCt1M5YF1uGMWL1rgl6ms1uVyWRYXl7GdV1CoRCnTp3SkpjHyPDwMKdOnSKdTpPP5xkYGKCvr49yucza2hqZTIZoNOrvMgiFQoTDYRzHwbZtP21ovV6nWq3iui7FYpFkMkmpVPLrS4fDYUKhEJVKhVAoxNDQENVqlVwux5UrV8jn8wwPD/PAAw8wPT3d6m7pWhqwlWqh7VPXB5kSTyQSZLNZ/71mZ2dvW9tUe5ienmZ9fZ3FxUVSqRSTk5MEg0EqlYq/pWpzcxOASCTC4OAg0BhRez/L5bI/uvbWSjiOg+M4hEIhQqEQwWCQUqmEZVlkMhnW19dJp9MAzM7O8uCDD2oa0RbTgK1UC3lT4oC/dWa/04z1ep3Lly9Tr9exbbuti0SogwuHw5w5c4ZUKkUqlSKXyzE2NkalUvFT2mazWcrlMqlUing8TiAQwBiDZVn+NLlt24RCIX/dhHd/YGAA27ZJJpNks1n/RKBWqxGNRrnjjjuYmZnR6e82oAFbqRYKhUJYlkWtVqNer+O67r73r2azWdbX16nX6wSDQWKxmJbKPKZGRkaYnZ3lnXfeIZFI4DgO4+PjAKytrREKhYjFYogImUwG27YJh8OICL29vX6QTiaT/vfFSyXq7bdeWVkhnU7jOA69vb2cOnWKubk5HVW3EQ3YSrVQKBTaMcL2Rsv7kclkyOVyiAihUIjTp08fYktVK1mWxczMDIVCgYWFBVZXVxERxsfHmZmZoVKp+N+F/v5+v1JWuVwmHo/7I+1wOMzAwACBQIBiscjm5iaZTIZ4PE6hUMBxHObm5piZmWFwcFBPANtMUwFbRIaA/wGcBhaBf26MSV5zzDTwBWAccIEXjTH/uZnPVeq4CAaDfsD2Fp55e7NvZnl5mWq16ifQOIp0lap1enp6OHPmDLVajcXFRVZXVzHGMD8/TywW8xeT5fN5f8eBbds4jkOtVsO2barVKul0GsuyKJVKLC8vUywWqdfrDAwMcNdddxGLxXThYptqdoT9PPCqMeYFEXl+6/7vXnNMDfhtY8wPROQE8Lci8oox5p0mP1upjuet5oVGwN5vtjOvrCE0Rl/Dw8P7DvSqc0WjUebn5xERPvzwQ9bW1igWi4yPjzM+Ps7Y2Bi2bfurwovFIvl83r/Onc/nKZVKpFIpPxVuf38/sViMmZkZzY7X5poN2M8Cf3/r9svAd7gmYBtjVoCVrdtZEbkATAIasFXXs20b27b9vdj5fN5f5XsjXk1iYwyO4zA5OXkErVXtYHBwkLNnzxIIBFheXiaXy7G4uEg8Hqevrw/LsnYUlfGUSiU2Nzf9EXU0GiUWizE+Pq4nfB2i2YB9cisgY4xZEZGxGx0sIqeBnwa+f4NjPgl8EuDUqVNNNk+p9mZZFpZl+dPi+y0AksvlKBaLiAiBQIDR0dHDbKZqM4ODg4TDYXp7e7ly5QrZbJZMJkOxWPQXm3nfq1KpRKlUwnVdgsEgU1NT/jXqSCSiq787yE0Dtoh8i8b152v93q18kIj0AX8JfMoYk9nrOGPMi8CLAA8//PANqi8o1fm80ZAxxt8vux+JRIJ6vY4xhp6eHvr7+w+5pard9PT0cPbsWcbGxlhZWfGnx72TPtd1/e+HlxVteHiYgYEBvUbdoW4asI0xH9vrORFZE5GJrdH1BBDf47gAjWD9JWPMVw/cWqWOGRHxpy+9PbU3Y4whHo/7+2yj0ai/bUd1FxEhGo3617YLhQLlctk/8QsEAkQiET9Bio6mO1uzU+JfB54DXtj6+bVrD5DGN+RzwAVjzB83+XlKHSvelLZnPyPsUqnkX7/2aicr5dXIPqw62ar1mt1k9wLwtIi8Dzy9dR8RiYnIN7aOeQL4BPAPROStrT/PNPm5Sh0b20fY+wnY+XyeQqEANEZQurJXqe7Q1AjbGLMBPLXL41eBZ7Zu/w1+MWGl1LWCwSDGNJZr7Ddge1PnjuPsa1W5UqrzaRobpVpsez7x/VzDTiaTfgGHcDhMX1/fobZPKdUeNGAr1WLbV+yWy2V/tL2XRCLhX7/u7+/X9JFKdQn9TVeqxbzVu8YYvwDIXiqVCplMY1ekZVlanUupLqIBW6kW8wK2iFCr1W4YsIvFop+pynEcXXCmVBfRgK1Ui11bsetGC8/K5TKlUsnfv60LzpTqHhqwlWoxL5Wkl/u5WCzueWw2m6VWqyEihMNh3XOrVBfRgK1Ui3n5nI0xGGP8Pda72dzcpFarYYwhEolohjOluogGbKVaLBQK+YUa6vX6DafEk8kkruti2zbRaFRTTSrVRTRgK9VijuPsqNi115S4t0Lc29Kl16+V6i4asJVqMdu2/YpdwJ5T4pVKhVKphDGGYDCoW7qU6jIasJVqMdu2d1yL3muE7dU1hkZ2tGg0eiTtU0q1Bw3YSrXY9prYlmXteQ27UChQqVSwLItQKERPT88Rt1Qp1UoasJVqMcuydoywK5XKrslTkskk9XodYwy9vb26QlypLqMBW6k24FXssiyLSqVCvV6/7pj19XVc19UFZ0p1KQ3YSrUBrwCIF7Cr1eqO52u1GqlUyk9JqgFbqe6jAVupNtDb2wuAMYZarXbdSvFyuew/FgqFGBkZOfI2KqVaSwO2Um3AS09qWRau614XsL2iH96xWgNbqe6jAVupNuClJ/VSlHolND2FQoFyuYyI0NPTQzgcblFLlVKtogFbqTbQ29vrZzozxpDP53c87y0481KSWpb+6irVbfS3Xqk2EIlEsG3b386Vy+UwxuAal3K9zOrqKrVaDcdxNMOZUl3KaXUDlFKNbV3bk6espFf4/I8+z2JuEWrAAjgVh0AkwOCwrhBXqhvpCFupNhAIBHAch3K9zFJuiXfX3mUls8J47zijwVGCbhAMxGtxvvzhl1nLr7W6yUqpI9ZUwBaRIRF5RUTe3/q556m/iNgi8kMR+T/NfKZSx1EgEMAVl9XMKsYy9Jge+p3+xiK0ssGtuCDQ19dH2Srz4tsvatBWqss0O8J+HnjVGDMPvLp1fy+/BVxo8vOUOpZcXBZLiwA4gcbUeCVfoVqrktpIgQvYIBFhqGcISyy+dOFL1NxaS9utlDo6zQbsZ4GXt26/DPz8bgeJyBTwj4GXmvw8pY6lhdQCJasELqxX1lnNrfLtd7/NS+df4uLiRXLlHBvlDS5WLlKqlRgMD7JR2mAhtdDqpiuljkizAfukMWYFYOvn2B7HfRb4NI1xwg2JyCdF5E0ReTORSDTZPKU6wzcvfZN4NU66miZeiFN364TrYZyaQ2+1FzFCxarwdvltvvDOF3hv8z0iToTvXf1eq5uulDoiNw3YIvItETm3y59n9/MBIvJPgLgx5m/3c7wx5kVjzMPGmIdHR0f38xKlOtpKfoVXLr9CWtJU3ApiBBeXcD3MUHmIcL2RJKUQKFBxKtRNndeWXmMtv8YHqQ9wzU3Pg5VSx8BNt3UZYz6213MisiYiE8aYFRGZAOK7HPYE8HMi8gwQBvpF5IvGmF8+cKuVOiZqbo0vvvNFXONypXaFUUaxjEXdquO4DpFqhIAboEqVVDCFK43gbDD81fJf8fTM01TdKiE71OK/iVLqsDU7Jf514Lmt288BX7v2AGPMvzPGTBljTgO/CHxbg7VSDQupBVKlFJulzcbo2arjiENNatjGJlwJYxkL13ZJ9iR3vLZu6lzcvEjA0rrYSnWDZgP2C8DTIvI+8PTWfUQkJiLfaLZxSh13313+LoVqgVwtR9Wq+oG6bJcJukHGymMIQs7OkQvmrnv9cm4ZSzSdglLdoKlMZ8aYDeCpXR6/Cjyzy+PfAb7TzGcqdVy4xuXc+jn+eumvG/ctl6JTpL/ST8EqEDVReuu9CEI8HKcm12/hqrgVSrUSYUeLgSh13OmpuVItUqwVOZc4R5ly4wGBvJPHwqImNbJ2FkHI2BnifXGQ69/DYEgUdTeFUt1AA7ZSLbKUXSJR2hlsM3YGQyPTWcAEqNgV1vrWKAQKu76HIPQH+4+iuUqpFtOArVSLfHf5u9TMzmnubDhLzarRX+kn7IbJ23kWexd3HV0DOOJwInji8BurlGo5DdhKtYBrXN7beO+6x0tOiZyTI2iCYMHVyFWqweqe73Pf6H266EypLqG/6Uq1QNWtUnJL1z8hsHBigYJTIBlIstK7csP3+c0Hf/OQWqiUajdaD1upFghYASJ2ZNfnCqECbw29hcGAvfd73Dd0Hw+cfOCQWqiUajc6wlaqBSyx+Kmhn0L2uDht7BsHa4DP/MxncCw951aqW2jAVqpFnph8glhv7GCvnXiCWN/BXquU6kwasJVqkTMDZ/jI5Edu+XUWFn/4kT88hBYppdqZBmylWsSxHH7t/l/jwdEH9/0aQfidh3+HkcjIIbZMKdWONGAr1UIne0/ymY9+hkdPPnrTYy0sPv3wp/nle7R2jlLdSAO2Ui12svckf/YP/4zPfexz3Dl0J/Y1q81CVohnTj/Dq7/wqgZrpbqYLjFVqg04lsOjk4/ylcmv4BqXdDnNZmmTid4JIoHdt38ppbqLBmyl2owlFoPhQQbDg61uilKqjeiUuFJKKdUBNGArpZRSHUADtlJKKdUBxBjT6jbsSUQSwOVWt+MYGwHWW92ILqD9fDS0n4+G9vPhmjHGjO72RFsHbHW4RORNY8zDrW7Hcaf9fDS0n4+G9nPr6JS4Ukop1QE0YCullFIdQAN2d3ux1Q3oEtrPR0P7+WhoP7eIXsNWSimlOoCOsJVSSqkOoAFbKaWU6gAasLuEiAyJyCsi8v7Wz+sSVYvItIi8JiIXROS8iPxWK9raiUTkH4nIeyLyExF5fpfnRUT+ZOv5t0XkoVa0s9Pto5//xVb/vi0i3xORB1rRzuPgZn297bhHRKQuIv/sKNvXjTRgd4/ngVeNMfPAq1v3r1UDftsYcxfwGPBvROTuI2xjRxIRG/gvwMeBu4Ff2qXfPg7Mb/35JPDfjrSRx8A++/kS8FFjzP3AH6ALpA5kn33tHfefgG8ebQu7kwbs7vEs8PLW7ZeBn7/2AGPMijHmB1u3s8AFYPLIWti5HgV+Yoz5wBhTAf6cRn9v9yzwBdPwOjAgIhNH3dAOd9N+NsZ8zxiT3Lr7OjB1xG08LvbznQb4t8BfAvGjbFy30oDdPU4aY1agEZiBsRsdLCKngZ8Gvn/oLet8k8DStvtXuP5EZz/HqBu71T78VeD/HmqLjq+b9rWITAL/FPjTI2xXV9N62MeIiHwLGN/lqd+7xffpo3HW/CljTOZ2tO2Yk10eu3a/5H6OUTe27z4UkZ+hEbA/cqgtOr7209efBX7XGFMX2e1wdbtpwD5GjDEf2+s5EVkTkQljzMrWVOyuU1giEqARrL9kjPnqITX1uLkCTG+7PwVcPcAx6sb21Ycicj/wEvBxY8zGEbXtuNlPXz8M/PlWsB4BnhGRmjHmfx1NE7uPTol3j68Dz23dfg742rUHSOM373PABWPMHx9h2zrdG8C8iMyKSBD4RRr9vd3XgX+5tVr8MSDtXaJQ+3bTfhaRU8BXgU8YYy62oI3HxU372hgza4w5bYw5DfwF8K81WB8uHWF3jxeAL4vIrwIfAr8AICIx4CVjzDPAE8AngB+LyFtbr/v3xphvtKLBncIYUxOR36CxUtYGPm+MOS8iv771/J8C3wCeAX4CFIBfaVV7O9U++/n3gWHgv26N/GpaWerW7bOv1RHT1KRKKaVUB9ApcaWUUqoDaMBWSimlOoAGbKWUUqoDaMBWSimlOoAGbKWUUqoDaMBWSimlOoAGbKWUUqoD/H/xqTbwLCoQhAAAAABJRU5ErkJggg==n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Delineate the ECG signal and visualizing all peaks of ECG complexesn”, “_, waves_peak = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, show=True, show_type=’peaks’)”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“The ‘peak’ method is doing a glamorous job with identifying all the ECG peaks for this piece of ECG signal.n”, “n”, “On top of the above peaks, the peak method also identify the wave boundaries, namely the onset of P-peaks and offset of T-peaks. You can vary the argument show_type to specify the information you would like plot.n”, “n”, “Let’s visualize them below:”

]

}, {

“cell_type”: “code”, “execution_count”: 10, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Delineate the ECG signal and visualizing all P-peaks boundariesn”, “signal_peak, waves_peak = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, show=True, show_type=’bounds_P’)”

]

}, {

“cell_type”: “code”, “execution_count”: 11, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Delineate the ECG signal and visualizing all T-peaks boundariesn”, “signal_peaj, waves_peak = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, show=True, show_type=’bounds_T’)”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“Both the onsets of P-peaks and the offsets of T-peaks appears to have been correctly identified here. This information will be used to delineate cardiac phases in [ecg_phase()](https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_phase>).n”, “n”, “Let’s next take a look at the continuous wavelet method.”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“### Continuous Wavelet Method (CWT)”

]

}, {

“cell_type”: “code”, “execution_count”: 12, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Delineate the ECG signaln”, “signal_cwt, waves_cwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="cwt", show=True, show_type=’all’)”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“By specifying ‘all’ in the show_type argument, you can plot all delineated information output by the cwt method. However, it could be hard to evaluate the accuracy of the delineated information with everyhing plotted together. Let’s tease them apart!”

]

}, {

“cell_type”: “code”, “execution_count”: 13, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize P-peaks and T-peaksn”, “signal_cwt, waves_cwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="cwt", show=True, show_type=’peaks’)”

]

}, {

“cell_type”: “code”, “execution_count”: 15, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize T-waves boundariesn”, “signal_cwt, waves_cwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="cwt", show=True, show_type=’bounds_T’)”

]

}, {

“cell_type”: “code”, “execution_count”: 14, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize P-waves boundariesn”, “signal_cwt, waves_cwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="cwt", show=True, show_type=’bounds_P’)”

]

}, {

“cell_type”: “code”, “execution_count”: 15, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize R-waves boundariesn”, “signal_cwt, waves_cwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="cwt", show=True, show_type=’bounds_R’)”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“Unlike the peak method, the continuous wavelet method does not idenfity the Q-peaks and S-peaks. However, it provides more information regarding the boundaries of the wavesn”, “n”, “Visually, except a few exception, CWT method is doing a great job. However, the P-waves boundaries are not very clearly identified here.n”, “n”, “Last but not least, we will look at the third method in Neurokit [ecg_delineate()](https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.ecg_delineate>) function: the discrete wavelet method. “

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“### Discrete Wavelet Method (DWT)”

]

}, {

“cell_type”: “code”, “execution_count”: 16, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “iVBORw0KGgoAAAANSUhEUgAAAewAAAExCAYAAAC+ipGRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXhU9dn4//fnzExmyQIJBCEgyo4hQBBQFksBFVSs0rr0aXGhar1sFW2vBxSL7dcLaat9rPWxqNRay2OrFXdr0epPtIIoKmhYZQsghLBkI9tMZjnn8/tjOGOAkMyQSSbA/bquXDoz5zPnHAJzz2e7b6W1RgghhBAdm5HqCxBCCCFEyyRgCyGEECcBCdhCCCHESUACthBCCHESkIAthBBCnAQkYAshhBAngaQEbKXUM0qpg0qpDcd5fYZSat3hn4+VUsOTcV4hhBDidJGsHvZi4JJmXt8JfFtrPQx4AHgqSecVQgghTgvOZLyJ1nq5UursZl7/uNHDVUCveN63a9eu+uyzj/u2QgghxCllzZo15Vrr3KZeS0rATtDNwNvHe1EpdStwK0Dv3r1ZvXp1e12XEEIIkVJKqa+P91q7LjpTSk0iGrDvOd4xWuuntNajtNajcnOb/JIhhBBCnHbarYetlBoGPA1cqrWuaK/zCiGEEKeCdulhK6V6A68C12utt7bHOYUQQohTSVJ62EqpfwATga5KqRLg/wEuAK31IuBXQBfgCaUUQERrPSoZ5xZCCAHhcJiSkhIaGhpSfSkiDh6Ph169euFyueJuk6xV4j9o4fVbgFuScS4hhBDHKikpITMzk7PPPpvDHaMWWZYmZFqkOQwMI742ovW01lRUVFBSUkKfPn3ibpeKVeJCCCGSrKGhIa5gHTEtth2s48OtZWw/WBd7fkC3DCYMzGVAtwycDkmC2ZaUUnTp0oWysrKE2knAFkKIU0RLwXp/dQN/XbmT8rogvjQneZ08KKXQWlNSFeDpFTvomuHmR+P70L2Tp52u+vQU7yhIY/I1SgghTgP7qxtY+P42AiGTXtk+ctLTYkFDKUVOehq9sn0EQiYL39/G/mqZC+9oJGALIcQpLmJa/HXlTgylyE5Pa/bY7PQ0DKX468qdREyrna5QxEMCthBtKBgMYlnyoSdSa9vBOsrrgi0Ga1t2ehrldUG2NZrjjofD4aCwsDD28+CDDwLRFexz585lwIABFBQUcN555/H229GEl3V1dfzkJz+hX79+jBgxgpEjR/LnP/+5yfdfv3597L1zcnLo06cPhYWFXHTRRU0ev2vXLrxeL4WFheTn53Pbbbed0L/HxYsXc8cddyTcLtlkDluINhKJRNi/fz8ZGRl06dIl1ZcjTmMfbi3Dl5bYx70vzcnyrWWc0yMr7jZer5eioqJjnv/lL3/Jvn372LBhA263mwMHDvDhhx8CcMstt9C3b1+2bduGYRiUlZXxzDPPNPn+Q4cOjb3/zJkzufzyy7n66qubvaZ+/fpRVFREJBJh8uTJvP7663zve9+L+546EulhC9FG6uvr2bVrFyUlJam+FHEasyzN9oN1ZPvi3+8LkO1zse1gHZalW3V+v9/Pn//8Z/74xz/idrsBOOOMM7j22mspLi7ms88+Y8GCBRhGNBzl5uZyzz3HzV59wpxOJ+PGjWP79u2UlZVx1VVXMXr0aEaPHs3KlSsB+Oyzzxg3bhwjRoxg3LhxbNmy5Zj3Wbp0KWPHjqW8vJyXXnqJgoIChg8fzoQJE5J+zcfcQ5ufQYjTVGVlJRUVFdTV1TFs2LATWhUqRGuFDs9DJ/r3zz4+ZFp4DEdcbQKBAIWFhbHH9957L+eccw69e/cmK+vYnvrGjRsZPnx4LFi3Jb/fz7Jly5g/fz533XUXP//5z7ngggvYvXs3U6dO5auvvmLw4MEsX74cp9PJe++9xy9+8QteeeWV2Hu89tprPPLII7z11ltkZ2czf/583nnnHXr27MmhQ4fa/B4kYAvRRmpqagiFQkQiEUzTxOmUf26i/aUd3lOttU4oaGutj2gfj6aGxNetWxd3+1//+te89NJLHDx4kNLS0rjbNae4uJjCwkKUUlx55ZVceuml3HjjjWzatCl2TE1NDbW1tVRXV3PjjTeybds2lFKEw+HYMR988AGrV6/m3XffjX35GD9+PDNnzuTaa69tl2F2+QQRoo3U1dURDAZRSlFfX0+nTp1SfUniNGQYiv7dMthbFSAnzkVnAFX+MAO6ZbQ6A1r//v3ZvXs3tbW1ZGZmHvFafn4+a9euxbIsDMNg3rx5zJs3j4yMjFadszF7Drsxy7L45JNP8Hq9Rzw/a9YsJk2axGuvvcauXbuYOHFi7LW+ffuyY8cOtm7dyqhR0czaixYt4tNPP2Xp0qUUFhZSVFTUputVZA5biDZSW1tLMBgkHA7j9/tTfTniNPbtgbn4Q5GE2vhDESYMbH2JY5/Px80338ydd95JKBQCYN++ffz973+nf//+jBo1ivvuuw/TNIFoxja7d99WpkyZwsKFC2OP7YBeXV1Nz549gejK8MbOOussXn31VW644QY2btwIRHvv559/PvPnz6dr167s2bOnTa9bArYQbcTv96OUwjRNCdgipQZ0y6Brhpuq+lBcx1fVh+ia4WZAt8R6uvYctv0zd+5cABYsWEBubi75+fkUFBQwffp0cnOjXwaefvppKioq6N+/PyNHjuSiiy7ioYceSuwGE/TYY4+xevVqhg0bRn5+PosWLQLg7rvv5t5772X8+PGxLxCNDRo0iOeee45rrrmG4uJi5syZw9ChQykoKGDChAkMHz68Ta9btfU3mdYYNWqUXr16daovQ4iEaa154YUXCIfDNDQ0MHr0aEaMGJHqyxKnsK+++opzzjnnuK/bmc5aSp5SVR/C0po7Jg+Q9KRtrKnfmVJqzfGqWUoPW4g2YFkW4XA4to1FSh6KVOveycMdkwfgTXNQUuWnsj4UG3rWWlNZH6Kkyo83zSHBuoOSRWdCtIFwOBxbSKOUIhAIpPqShKB7Jw9zpg5i28E6lm8tOyKTWUer1rV+/Xquv/76I55zu918+umnrTr2ZCYBW4g20NDQQCQSQSmFZVmxxTZCpJrTYXBOjyzO6ZGFZZqEQg2kpXkwHPHttW4vjbOaJfPYk5kEbCHaQENDA5ZlxX4kYIsOw4xA2WbY/h5G+VZiA9+5g6DfhZA7GBwSGjoi+a0I0QYikQjhcJjq6urY1i4hUq6mFFYtgvoySEuHrF6gFGgNh/bAJ49Dei6MuQ2y8lJ9teIoqZ+oEOIUZA+JW5ZFJBIhGAym+pLE6a6mFJY/DGE/dO4Nvi7RYA3R//q6RJ8P+6PH1SQn05hIHgnYQrSBQCBAJBLB4XCglJKALVLLjER71sqIBubm+LpEj1u1KNpOdBgSsIVoA/YcttPpxDAMmcMWqVW2OToM3lKwtvm6QP3BaLsEdLR62BAtMDJ58mQGDhzIgAEDeOCBB5KeSW3x4sVJy33eHJnDFqIN2Nu6lFJorY/Y5iVEu9v+XnTOOhGudCheBt0L4m7S0ephBwIBrrjiCp588kmmTJmC3+/nqquu4oknnuD222+P+75asnjxYgoKCsjLa9t5/6R8eiilnlFKHVRKbTjO60op9ZhSartSap1S6txknFeIjioYDMaqI5mmiWmaRCIyvChSwLKgfCt4cxJr5+sCZVui7VshlfWwn3/+ecaPH8+UKVOAaF7zhQsXxnr+999/PzfddBMTJ06kb9++PPbYY0C0lv20adMYPnw4BQUFLFmyBIA1a9bw7W9/m5EjRzJ16lT27dvHyy+/zOrVq5kxYwaFhYUEAgHmzp1Lfn4+w4YNY/bs2Um5F0heD3sxsBB49jivXwoMOPxzPvDk4f8KcUqyA7bb7UYpRSQSIRQKkZYWf7UkIZLCPDwdk2g9dqUAHW1vxJf1rKPVw964cSMjR4484rl+/fpRV1dHTU0NAJs3b+aDDz6gtraWQYMG8ZOf/IR///vf5OXlsXTpUiBaFCQcDjNr1izeeOMNcnNzWbJkCfPmzeOZZ55h4cKFPPzww4waNYrKykpee+01Nm/ejFIqqXWykxKwtdbLlVJnN3PIlcCzOjpxsEop1Vkp1UNrvS8Z5xeio2m8yMzhcMQCthDtznH4S6LWiQVtrQH1Tfs4dLR62M3VALefnzZtGm63G7fbTbdu3Thw4ABDhw5l9uzZ3HPPPVx++eV861vfYsOGDWzYsIGLL74YANM06dGjxzHvm5WVhcfj4ZZbbmHatGlcfvnlrb4PW3tNqPUEGtcdKzn83DGUUrcqpVYrpVaXlZW1y8UJkWyhUDRPs91zsCxLVoqL1DAM6DoQApWJtfNXRJOptLL327ge9tEa18MGmDdvHkVFRbHeb2sNGTKEowtI7dixg4yMjFhtbnuYHr75cj1w4EDWrFnD0KFDuffee5k/fz5aa4YMGUJRURFFRUWsX7+ed99995hzOp1OPvvsM6666ipef/11LrnkkqTcC7RfwG7qK06Ty/S01k9prUdprUfZ5deEONnYvWmXy4VhGFiWJQVAROr0vwhC9Ym1CddHM5+1UirrYc+YMYOPPvqI9957D4gO2d95553cfffdzbYrLS3F5/Nx3XXXMXv2bL744gsGDRpEWVkZn3zyCRBdWGrXxc7MzIx9Iamrq6O6uprLLruMRx99NKkpU9trlXgJcGajx70A2ZUvTln2B1NGRgZOZ/SfmQRskTK5g6MZzPwV8W3t8ldAerdouwQcPYd9ySWX8OCDD7JgwQLuu+8+8vPz8Xg8pKenM3/+fCBaD3vOnDn079+fnJwcvF5v0uphe71e3njjDWbNmsXtt9+OaZpcf/313HHHHc22W79+PXPmzMEwDFwuF08++SRpaWm8/PLL3HnnnVRXVxOJRPjZz37GkCFDmDlzJrfddhter5e3336bK6+8MvbF4w9/+ENS7gWSWA/78Bz2v7TWx+wBUEpNA+4ALiO62OwxrfV5Lb2n1MMWJ6s//elPVFRUMGHCBDZu3Eh5eTnf+c53GDZsWKovTZyiWqqHHct01lLyFH8FaAsmzJb0pG0s0XrYSelhK6X+AUwEuiqlSoD/B7gAtNaLgLeIBuvtgB/4UTLOK0RHZQ/vpaen43K5AKTEpkitrLxoEF61CA7tBpfvm/SkWkcDdbg+2rOWXOIdUrJWif+ghdc1kLxd6kJ0cPaea6/Xi8cT3RLj9/tTeUlCRIPwhb+KZjArXhbdZ83h1eAdrFqX1MM+Vup/K0KcguwsZ/Z2Ea21rBIXHYPDGc1e1r0Ay4wQDtfjcqVjdIAg3ZjUwz5Wx/oNCXEKsCwrNiTudrtJT4+mhJRFZ6IjiFgRig8Vs3LvSnZW74w937dzX8bljaNf5344DQkNHZH8VoRIMruspmEYpKWl4fV6AaSHLVLuQP0BnvvqOSobKvE6vXRP7x7Ld19aV8rfNv2NHE8OM86ZwRnpZ6T6csVRpBKBEEkWDodjGZZcLhc+nw+QgC1S60D9AZ5a9xSBSIC8jDyyPdmxbF9KKbI92eRl5BGIBHhq3VMcqD+Q4isWR5OALUSSRSIRtNY4HA6cTicZGRmx54VIhYgV4bmvnsNQBtme7GaPzfZkYyiD5756joglf2c7EgnYQiSZaZqxTE1OpxOPx4NSSnKJi5QpPlRMZUNli8Halu3JpqKhguJDxQmd52Srhx0MBrnooosoLCxkyZIlrFixgiFDhsSqbiXi0UcfbfOdIDKHLUSShUIhLMvC6XTicDhic9jSwxapsnLvSrxOb0JtfE4fH5d+zKCcQXG3OdnqYX/55ZeEw+HYe952223Mnj2bH/0o8VQhjz76KNddd11sCqwtSA9biCSzV4MbhoFhGLEetr1yXIj2ZGmLndU76ezunFC7zu7O7Di0A0ufmvWwDx48yHXXXUdRURGFhYX86U9/4sUXX2T+/PnMmDGDffv2MWHCBAoLCykoKGDFihUAvPvuu4wdO5Zzzz2Xa665hrq6Oh577DFKS0uZNGkSkyZNwjRNZs6cSUFBAUOHDk1aelLpYQuRZHalLofDEduLDUjAFikRtsIAxy0zeTxKKTSasBXG7XC33ICTqx62x+Ph6aef5uGHH+Zf//oXAJ988kms1/773/+eqVOnMm/ePEzTxO/3U15ezoIFC3jvvfdIT0/noYce4pFHHuFXv/oVjzzyCB988AFdu3ZlzZo17N27lw0bNgAkrSa2BGwhkszuYdsB2+VySQ9bpIzLiKbGba42dFO01ihUrH08TsZ62MczevRobrrpJsLhMNOnT6ewsJAPP/yQTZs2MX78eCD65Xzs2LHHtO3bty87duxg1qxZTJs2LdbDby0ZEhciycLhaI/G4XDE/mvvdRWivRnKoE+nPhwKJtbLOxQ8RN/OfTHUqV0P+3gmTJjA8uXL6dmzJ9dffz3PPvssWmsuvvjiWE3sTZs28Ze//OWYttnZ2axdu5aJEyfy+OOPc8sttyTlfiRgC5Fk9pC4XfRDKYVSKvahJER7G99zPIFIYque/RE/4/LGtfrcJ2M9bICvv/6abt268eMf/5ibb76ZL774gjFjxrBy5Uq2b98OROfnt27dChxZE7u8vBzLsrjqqqt44IEH+OKLL5JyPxKwhUgy+0PJDtgQ7WVLD1ukSr/O/cjx5FDVUBXX8VUNVXTxdKFf534Jnceew7Z/5s6dC8CCBQvIzc0lPz+fgoICpk+fTm5uLhCth11RUUH//v0ZOXIkF110UdLrYS9YsIBBgwYxdOhQRo8e3WI9bID//Oc/FBYWMmLECF555RXuuusucnNzWbx4MT/4wQ8YNmwYY8aMYfPmzQDceuutXHrppUyaNIm9e/cyceJECgsLmTlzJr/97W+Tcj9Jq4fdFqQetjgZvfPOO3z++eecc845XHXVVQA88sgjNDQ0MHfu3DZbYCNOby3Vw7YznbWUPKWqoQpLW9w67FZJT9rGEq2HLZ8cQiSZ3cNOS0uLPWf3sGUvtkiVM9LP4NZht+J1eimtK6WqoSo26qO1pqqhir11e/E6vRKsOyhZJS5EktmLzuw62ECsVx0Oh48I5EK0pzPSz+DOc++k+FAxH5d+zI5DO9BEV4N3tGpdUg/7WKn/rQhxirEDduM5bKfTidYav98fK7cpRCo4DSeDcgYxKGcQphkhFPST5vbhkHrYHV7H+g0JcQqwA7adMAWiARtIOD+xEMmmIxGCxcXUr1hBsHhH7Hl3v36kf+sC3P36oZwSGjoi+a0IkWT2PHXjgG0Pg7d1cQAhmhM+cIDKZ/+GWVmB8vpw9ugRyxEQKi0luHgxjpwu5NxwPa4zZA67o5FFZ0IkWVND4vb/19fXp+SahAgfOED5k4uwAgFceT1xZh9ZD9uZnY0rrydWIED5k4sIH5B62B2NBGwhkszuYdtVuuCbgC1D4iIVdCRC5bN/A8PAmd18iU1ndjYYBpXP/g2d4K6Gti6vCbBr1y68Xi+FhYXk5+dz2223HTcpUSLHNmfx4sVx7d1uazIkLkSSWZaFUuqI1eB2wLbzjAvRnoLFxZiVFbjyesZ1vDM7m/DevQSLi/EM6jjlNW39+vWjqKiISCTC5MmTef311/ne977X6mM7uqT0sJVSlyiltiiltiul5jbxeiel1JtKqbVKqY1KqcSLjQpxkjBNM1b0w2Zv8ZKALVKhfsUKlDexOs3K66V+xUetPndbltd0Op2MGzculio03mPLysq46qqrGD16NKNHj2blypUAfPbZZ4wbN44RI0Ywbtw4tmzZcsz7LF26lLFjx1JeXs5LL71EQUEBw4cPZ8KECfH+kZywVvewlVIO4HHgYqAE+Fwp9U+t9aZGh90ObNJaf0cplQtsUUo9p7UOtfb8QnQ0dk7kxj1sO2DbSVWEaC/asggW78DZo0dC7RzZ2QSLi9GWhYozO197l9f0+/0sW7aM+fPnJ3TsXXfdxc9//nMuuOACdu/ezdSpU/nqq68YPHgwy5cvx+l08t577/GLX/yCV155JfYer732Go888ghvvfUW2dnZzJ8/n3feeYeePXsmrYRmc5IxJH4esF1rvQNAKfUCcCXQOGBrIFNFVzhkAJWApHwSpyS7pJ+z0dYYu2chAVu0Nx0+8XrYaI0Oh1Hu+Opht1d5zeLiYgoLC1FKceWVV3LppZcmdOyNN97Ipk3fhKiamhpqa2uprq7mxhtvZNu2bSilYgtIAT744ANWr17Nu+++G/vyMX78eGbOnMm1117bLsPsyQjYPYE9jR6XAOcfdcxC4J9AKZAJfF9r3eTMv1LqVuBWgN69eyfh8oRoX/aQeOOAbZfyk4At2ptynXg9bJSKtT9RjctrHl3SsnF5TcMwmDdvHvPmzSMjI6PZ97TnpePR1LGWZfHJJ58csTAUYNasWUyaNInXXnuNXbt2MXHixNhrdo3rrVu3MmpUNNX3okWL+PTTT1m6dCmFhYUUFRXRpUuXuK7rRCRjDrupvwFHVxSZChQBeUAhsFApdez4CKC1fkprPUprPcqu5iLEyUJrHVuFatfDhm9WjDf+xi5Ee1CGgbtfX8wEh2zNqqpoEpVWFqtJZXnN45kyZQoLFy6MPbYDenV1NT17RhfmLV68+Ig2Z511Fq+++io33HADGzduBKK99/PPP5/58+fTtWtX9uzZQ1tKRsAuAc5s9LgX0Z50Yz8CXtVR24GdwOAknFuIDsUO1oZhHNHD9vmiC36k+IdIhfRvfQsdSCxpjw4ESP/WBQm16WjlNY/nscceY/Xq1QwbNoz8/HwWLVoEwN133829997L+PHjY18gGhs0aBDPPfcc11xzDcXFxcyZM4ehQ4dSUFDAhAkTGD58eJted6vLayqlnMBW4EJgL/A58EOt9cZGxzwJHNBa36+UOgP4AhiutS5v7r2lvKY42YTDYX7/+9/jcDj47//+79himurqav74xz+SnZ3N7bffnuKrFKei5spr6kiEg394FCsQaHEfNkCkqgrD66Xbz38maUrbULuX19RaR4A7gHeAr4AXtdYblVK3KaVuO3zYA8A4pdR6YBlwT0vBWoiTUTgcjs0VNp4vtAt+nEjSBiFaSzmd5NxwPVgWkaqqZo+NVFWBZZFzw/USrDuYpPw2tNZvAW8d9dyiRv9fCkxJxrmE6MgikUiTAdvhcKCUanKYTYj24DrjDLr+5DYqn/0b4dK9KI8Xx+H0pFprzKoqdCCAo0vHyCUu5TWPJV+fhEiiYDAIcMT8NXyzpUYCtkgl1xln0O3nPztcresjgsXFcHg1eEer1iXlNY+V+t+KEKcQe0i8qUQQdk9GiFRSTieeQYPwDBqEFTGJNIRwetIwnI6WG4uUkoAtRBLZ27aOF7BlDlukmmVaVO7zs3tTBVX7vqkel90jnd75Xcjp4cNwSF2ojkgCthBJFAqF0FofMyQO0SAuPWyRSnVVQda9v4dAXQhnmkFGtjs28lNbEWDtst14M9IYNvlMMrLjy24m2o98jRIiiezEEI2Tptikhy1Sqa4qyOq3dxIOmWTmePBmpB1RD9ubkUZmjodwyGT12zupqwqm+IrF0SRgC5FEdjWu5nrY0ssW7c0yLda9v+dwYG4+1ag3w4VSinXv78EyE/uC2dHqYUO0wMjkyZMZOHAgAwYM4IEHHkj6v8HFixc3m/s8WWRIXIgksleJu5rIv2wHbMuymuyBC9FWKvf5CdSFyMzxxHW8N8NFTUUDlfv8dO3VfF7vI9p1sHrYgUCAK664gieffJIpU6bg9/u56qqreOKJJ5KawGjx4sUUFBSQl5eXtPdsivSwhUgiO/VoUz1sO0jLsLhob7s3VeBMS+zj3pVmsHtTRavPncp62M8//zzjx49nypRoGhCfz8fChQtjPf/777+fm266iYkTJ9K3b18ee+wxAOrr65k2bRrDhw+noKCAJUuWALBmzRq+/e1vM3LkSKZOncq+fft4+eWXWb16NTNmzKCwsJBAIMDcuXPJz89n2LBhzJ49+8T/8I6+36S9kxAiNiTeuBa2ze5hm6bZZA9ciLagLU3VvvqEF5F5MlxU7atHWxplxFflq6PVw964cSMjR4484rl+/fpRV1dHTU0NAJs3b+aDDz6gtraWQYMG8ZOf/IR///vf5OXlsXTpUiCaWjgcDjNr1izeeOMNcnNzWbJkCfPmzeOZZ55h4cKFPPzww4waNYrKykpee+01Nm/ejFIqqXWyJWALkUR2D9vdRP1gu9cdDofxeOIbmhSitczD89AnVg872t5pxDeF09HqYTdXUtR+ftq0abjdbtxuN926dePAgQMMHTqU2bNnc88993D55ZfzrW99iw0bNrBhwwYuvvhiIJoEqUePHse8b1ZWFh6Ph1tuuYVp06Zx+eWXx33/LZGALUQS2XPYTfWw7YDdVF1gIdqK4/Ce6hOrh/1N+xOVynrYQ4YMYfny5Uc8t2PHDjIyMmLX0vjLtcPhIBKJMHDgQNasWcNbb73Fvffey5QpU/jud7/LkCFD+OSTT5o9p9Pp5LPPPmPZsmW88MILLFy4kPfff7/Fa42HzGELkUT2tq7mArY9bC5Ee1CGIrtHOg31idVib6gLk90jPe7h8ONJZT3sGTNm8NFHH/Hee+8B0SH7O++8k7vvvrvZdqWlpfh8Pq677jpmz57NF198waBBgygrK4sF7HA4HKuLnZmZSW1tLRBd9V5dXc1ll13Go48+mtSUqdLDFiKJ7A+d5gJ2fX39Ma8J0ZZ653dh7bLdCbUJhyx653dJqM3Rc9iXXHIJDz74IAsWLOC+++4jPz8fj8dDenp6bN756aefZs6cOfTv35+cnBy8Xm/S6mF7vV7eeOMNZs2axe23345pmlx//fXccccdzbZbv349c+bMwTAMXC4XTz75JGlpabz88svceeedVFdXE4lE+NnPfsaQIUOYOXMmt912G16vl7fffpsrr7wy9sXjD3/4Q1LuBZJQD7stST1scbJ59tln2b17N5dddhnnnnvuEa+98MILbN++nSlTpnDeeeel6ArFqaq5etiWabHq9R2EQ2aL+7ABAnVhXGkOxkzvK2lK21C718MWQnzDHvJralGZ3esOBALtek1CGA6DYZPPRGtNoFgrPFcAACAASURBVK75ofFAXbSAzbDJZ0qw7mBkSFyIJIpnlbjMYYtUyMh2M+rSPqx7fw+1lQ04XQaew1nNtNY01IUJhyx8mR0jl7jUwz6WBGwhkshOitLUHLYdxO2V5EK0t4xsN2Om9z2yWpcGVMer1iX1sI8lAVuIJLIsC6VUs0Pidi9ciFQwHAZde2XQtVcGVsQkFAyR5pZ62CcDCdhCJFEkEkEp1WRq0vT0dEB62CK1LNOkomQ3O9euobJkT+z5nF696TP8XLr06o0hue47JAnYQiSR3cNuKmB7vV7gm4VpQrS32spyvnz7TfzVh3C5PWR2zf2mHnbZQdYsfR1fp86MuPQ7ZOZ0TfXliqOkfqJCiFOIvU2yqWpcPp8PiCZcEKK91VaWs+rVJYSDDWTldsOblXVkPeysLLJyuxEONrDq1SXUVpan+IrF0SRgC5FEzfWwZQ5bpIplmnz59psYhoE389giHI15M7MwDIMv334T63AioHidbPWwg8EgF110EYWFhSxZsoQVK1YwZMiQWNWtRDz66KP4/f6E2iQqKQFbKXWJUmqLUmq7UmrucY6ZqJQqUkptVEp9mIzzCtHR2B8cTVUfsofEzQQ/BIVorYqS3firD7UYrG3ezCzqq6uoKEksO5pd/MP+mTs3Gg4a18PesGEDb775ZiyV5y233EJ2djbbtm3jyy+/5N///jeVlZXNnsfOJb5u3To2bdrE66+/3uRxdj3suXPnsnXrVtauXcvHH3/ME088AcCXX35JOBymqKiI73//+zz33HPMnj2boqKi2L/XeJ0UAVsp5QAeBy4F8oEfKKXyjzqmM/AEcIXWeghwTWvPK0RHY39rV0o1OSTu8XhQSknAFu1u59o1uNyJVYhzuT3sXPtFq8/dUethHzx4kOuuu46ioiIKCwv505/+xIsvvsj8+fOZMWMG+/btY8KECRQWFlJQUMCKFSsAePfddxk7diznnnsu11xzDXV1dTz22GOUlpYyadIkJk2ahGmazJw5k4KCAoYOHZq09KTJWHR2HrBda70DQCn1AnAlsKnRMT8EXtVa7wbQWh9MwnmF6FBM08SyLBwOR5NVkexh8uaG74RINm1ZVJbsIbNrbkLtvJlZVJbsRlsWKs561SdTPWyPx8PTTz/Nww8/zL/+9S8APvnkEy6//HKuvvpqfv/73zN16lTmzZuHaZr4/X7Ky8tZsGAB7733Hunp6Tz00EM88sgj/OpXv+KRRx7hgw8+oGvXrqxZs4a9e/eyYcMGgKTVxE5GwO4J7Gn0uAQ4/6hjBgIupdR/gEzgf7XWzzb1ZkqpW4FbAXr37p2EyxOifdg956Z61/bzhmFIwBbtyjy8ZuKE6mEfbu9sIhFQU07GetjHM3r0aG666SbC4TDTp0+nsLCQDz/8kE2bNjF+/HgguuNj7Nixx7Tt27cvO3bsYNasWUybNi3Ww2+tZATspu766IoiTmAkcCHgBT5RSq3SWm89pqHWTwFPQbT4RxKuT4h2EQ6Hm/2AsAO5BGzRnhyHR3ZOqB52o/YnqqPXwz6eCRMmsHz5cpYuXcr111/PnDlzyM7O5uKLL+Yf//hHs22zs7NZu3Yt77zzDo8//jgvvvgizzzzTIvX25JkLDorAc5s9LgXcPRXoxLg31rreq11ObAcGJ6EcwvRYdgJUY7Xw1ZKxfa8duQqeeLUogyDnF5n0nB4kVe8ArU15PTqHfdw+PGcjPWwAb7++mu6devGj3/8Y26++Wa++OILxowZw8qVK2Nz5n6/n61bo/3OxjWxy8vLsSyLq666igceeIAvvmj9WgBITsD+HBiglOqjlEoD/gv451HHvAF8SynlVEr5iA6Zf5WEcwvRYdg97OPNx9kB27IsCdiiXfUZPpJwMLGiM+FgA32Gn9vygY3Yc9j2j71KfMGCBeTm5pKfn09BQQHTp08nNzc6p/70009TUVFB//79GTlyJBdddFHS62EvWLCAQYMGMXToUEaPHt1iPWyA//znPxQWFjJixAheeeUV7rrrLnJzc1m8eDE/+MEPGDZsGGPGjGHz5s0A3HrrrVx66aVMmjSJvXv3MnHiRAoLC5k5cya//e1vk3I/SamHrZS6DHgUcADPaK1/rZS6DUBrvejwMXOAHwEW8LTW+tGW3lfqYYuTyZ49e3j22WfJzs7mpz/9aZPH/O53v8OyLObMmXPcnrgQJ6L5etgmH73wLOFgQ1xbuwK1NbjcHi74rxskTWkbSrQedlJSk2qt3wLeOuq5RUc9/h/gf5JxPiE6Insor6mkKTbDMIhEIrHV5EK0B8PhYMSl32HVq0sI1NY0G7QDtTVYlsWIS78jwbqDkVziQiSJPYfdUsCG6Ipyl8vVLtclBEBmTlfGfO/7fPn2m9SUHcTpduPNzIqtqwjU1hAONpDeKbtD5BKXetjHkoAtRJLEE7DtXnUoFGqyBKcQbSkzpysX/NcNh6t1fUFlo0xmHa1al9TDPpYEbCGSxF4B29xQt2EYaK2lYpdIGcPhIPesPuSe1QcrYmIGwzjcLqmHfRKQgC1EkthBOK2ZJBP2kLgEbJEq2tSED/pp2FpJ5KCfaCoNjbNbOp6B2bi6+VCOxJKsiPYhAVuIJLHLZjY3N+1yudBaS4lNkRJmdZDalXux6sKQ5sDo5I7NYUeqGqhbUYKR4SJzfE8cndypvlxxFCmvKUSS2OX4mpubtue3GxoS2xMrRGuZ1UFq3t+NDlk4sj040l1H1MN2pLtwZHvQIYua93djVgdTfMXiaBKwhUgSe9FZcwHb7n0nWmtXiNbQpqZ25V5QCiO9+d0JRroLlKJ25V60mViejlTUw77hhhtaHLH66KOPOO+88xg8eDCDBw/mqaeeSui+4tEe5TVlSFyIJLE/NOLpYdvBXYj2ED7ox6oL48iOb2eCke7CrGogfNBPWo/0uM/TVPEPOLIettvt5sCBA3z44YdAtB5237592bZtG4ZhUFZW1mLebTuXuGmaXHzxxbz44ovMmDGjyWP379/PD3/4Q15//XXOPfdcysvLmTp1Kj179mTatGlx31tLHn30Ua677jp8Pl/S3vNo0sMWIknsgG3X/G2KDImLVGjYWglpCa4CT3PQsLWq1eduy3rYDoeD8847j7179x73mMcff5yZM2dy7rnRNKtdu3bld7/7Xaz3P3PmTO68807GjRtH3759efnllwFO2XrYQgi+WfndXMC2h8RllbhoL9rSRA76MRJcRGb4nEQO1qMtjTLiWzXe3vWwGxoa+PTTT/nf//3f4x6zceNGbrzxxiOeGzVqFBs3bow93rdvHx999BGbN2/miiuu4Oqrr+b5558/JethCyH4ph52c9u67NdkDlu0G1MD6oTrYWNqiDNgt3c97G3btnH11VczbNiw4x57vLKijZ+bPn06hmGQn5/PgQMHgI5ZD1uGxIVIEjtgNzeHbQdsmcMW7cYR3WedaKGn2PGt3JPduB720RrXwwaYN28eRUVF1NTUNPue9hz29u3bWbVqFf/859EFIr8xZMgQji4itWbNGvLz82OPG4+K2fdt18Pu2bMn119/Pc8++yxaay6++GKKioooKipi06ZN/OUvfznmnHY97IkTJ/L4449zyy23NHs/8ZKALUSSmKaJUiqugG0HdyHamjIUzm4+LH8koXaWP4KzW3rcw+HH05b1sHv06MGDDz7YbPnK22+/ncWLF8d6/hUVFdxzzz0t1sQ+VethCyH4JmA3l0vcDubSwxbtyTMwB0IJfkkMmXgGZifUJBX1sKdPn47f748tCjtajx49+Pvf/86Pf/xjBg8ezLhx47jpppv4zne+0+z7nrL1sNuK1MMWJ5M//OEPBAIBZs2aRWZmZpPHrFu3jjfffJPu3btz8803t/MVilNZc/WwtampfmcnOmS1uA8bwKoPo9IMOk3tI2lK21Ci9bClhy1Ektg97OZSk9pzZZFIYsOTQrSGcigyx/cErbHqm08yYtWHQWsyx/eUYN3ByCpxIZLEXjjT3JC4HcxlDlu0N0cnN1mTe1O7ci9mVUM0l7jPGcslbvkjEDI7TC7xRGtcv/POO8fs3+7Tpw+vvfZam11je5OALUSS2NtHmiuv6XZHiy1IwBap4OjkptPUPoerdVUROVgfe62jVetKtMb11KlTmTp1ahteUepJwBYiCSzLigXs5va7SsAWqaYcirQe6aT1SMcyLcxQBEeaE8MhM6QdnQRsIZIgFAqhtW52/hq+2dbVOMAL0Z5M06SsrIzt27dTXl4eez43N5d+/fqRm5vb7CiRSB0J2EIkgZ1HvKUUi3ZA11pLwBbtrqamhlWrVlFfX09aWhpZWVmxOexDhw7xySefkJ6ezpgxY5pMJSpSS8ZAhEiCUCiEZVktBmyHw4FhGJimGVukJkR7qKmpYfny5YTDYTp37ozP5zuiHrbP56Nz586Ew2GWL1/eYrYx0f6SErCVUpcopbYopbYrpeY2c9xopZSplLo6GecVoqOwE6E0t0IcjuyBy9Yu0V5M02TVqlWxwNwcO5CvWrUq4bUWJ2M97LKyMs4//3xGjBjBihUreOmllzjnnHOYNGlSQvcO8Jvf/CbhNolo9ZC4UsoBPA5cDJQAnyul/qm13tTEcQ8B77T2nEJ0NHbAbmnuTykV62GHw+Fm05gKkSxlZWXU19fTuXPnuI73+XwcOnSIsrIyunfvHvd5TsZ62MuWLWPw4MH83//9HwCXXHIJTzzxxAkH7F/84hcJt4tXMuawzwO2a613ACilXgCuBDYdddws4BVgdBLOKUSHYte3bmnRmWEYsTnDlnoFQiTL9u3bm60i1xSXy0VxcXFCAbspdj3snTt3Hrce9vPPP9/u9bDvv/9+evbsyd133x1Lqfrd736Xjz76iJ07d3LFFVcwc+ZMfvSjH8WmvF555RUGDBjA3//+dx577DFCoRDnn38+TzzxBPPmzYu9z5AhQ3jqqae49tprKSkpwTRNfvnLX/L973+/VX+WyQjYPYE9jR6XAOc3PkAp1RP4LjCZFgK2UupW4FaA3r17J+HyhGh7dsGClobE7R42SE1s0T4sy6K8vDzhRWQ+n4+ysrK41mbYTrZ62IWFhcyfP5/Vq1ezcOFCAD744AMefvhhRo0axaxZs7jrrruYMWMGoVAI0zT56quvWLJkCStXrsTlcvHTn/6U5557jgcffJCFCxfGRhheeeUV8vLyWLp0KQDV1dUndI+NJWMOu6llrkcnKH8UuEdr3eKEiNb6Ka31KK31KDs5vBAdXbw9bEACtmhX9jz0idbDTmQe2x4St38S7VH++te/prCwkLy8vGaPs+thd+nShd69e7e6HvbxjB07lt/85jc89NBDfP3113i9XpYtW8aaNWsYPXo0hYWFLFu2jB07dhzTdujQobz33nvcc889rFixgk6dOrV4vpYkI2CXAGc2etwLOLry+CjgBaXULuBq4Aml1PQknFuIDsEO2PEMOzqdTrTWUrFLtAt7XcWJ1sNu7Z7sk6Ee9vH88Ic/5J///Cder5epU6fy/vvvo7XmxhtvjH0p2bJlC/fff/8xbQcOHMiaNWsYOnQo9957L/Pnz2/xfC1JRsD+HBiglOqjlEoD/gs44k9Pa91Ha3221vps4GXgp1rr15NwbiE6BDtgx7OIzP4AlFXioj0YhkHXrl0JBAIJtfP7/eTm5p7wcLXtZK2HDbBjxw769u3LnXfeyRVXXMG6deu48MILefnllzl48CAAlZWVfP3110B0hM1em1JaWorP5+O6665j9uzZSamJ3eqArbWOAHcQXf39FfCi1nqjUuo2pdRtrX1/IU4Gdm/Z6/W2eKzD4ZAetmhX/fv3T3gKJhwO069fv4TanEr1sAGWLFlCQUEBhYWFbN68mRtuuIH8/HwWLFjAlClTGDZsGBdffDH79u0DojWxhw0bxowZM1i/fj3nnXcehYWF/PrXv+a+++6L+56OR+phC5EES5YsYdu2bVx44YWMHTu22WP/+te/UlpaypQpUxg9WjZNiORorh62aZosW7aMcDjc4j5siPauXS4XF154oaQpbUNSD1uIFLB7L/a2lebIHLZobw6HgzFjxqC1xu/3N3us3+9Ha82YMWMkWHcwkktciCSwg288vRd7JbnswxbtKSsriwkTJrBq1SoOHTqEy+WKZTWzA3k4HO4wucSlHvaxJGALkQSRSASlVFxz2PZebelhi2RrqaBMVlYWF154IWVlZRQXF1NWVhZ7raNV6zrV62GfyHS0BGwhksBe8R3vkLhSSnrYIqk8Hg8VFRV06dKl2aDtcDjo3r073bt3x7IsTNOMFaUR7UNrTUVFRcKpiSVgC5EEpmmilIo7YIMMiYvk6tWrFyUlJUf0mkXH5fF46NWrV0JtJGALkQT2kHg8iVPsYyTTmUgml8tFnz59Un0Zog3JGIgQSWBnaoo30xlIwBZCJEYCthBJYBdIiGexjqwSF0KcCAnYQrRSKBSKrc6Np6CAvehMUpMKIRIhAVuIVrJzHzscjrgCtsfjQSmVUBUkIYSQgC1EKwUCgbhqYdvsleSmaZ7QXkwhxOlJArYQrdS4hx0Pe2FaJBKJLVYTQoiWSMAWopXssoX2YrKWuN3uWDpImccWQsRLArYQrWQXS4hnSxcQm+u2LEu2dgkh4iYBW4hWqqurA+JLS2ofZ/ewJWALIeIlAVuIVrKHxOOp1AXRoXN7NbkEbCFEvCRgC9FK9fX1QPwB2zAMDMOQHrYQIiESsIVoJbtMZnp6elzH24lTJGALIRIhAVuIVrKHxOMN2PaiMwnYQohESMAWopWCwSBKKbxeb1zH2znHZVuXECIRErCFaCW7tOaJzGFLARAhRLwkYAvRClrrWE5wj8cTVxullJTYFEIkLCkBWyl1iVJqi1Jqu1JqbhOvz1BKrTv887FSangyzitEqlmWFethxxuwgVgaU+lhCyHi1eqArZRyAI8DlwL5wA+UUvlHHbYT+LbWehjwAPBUa88rREdg5wNXSsWd6QwkYJ+MIhGLan+ISETyv4vUiK+8UPPOA7ZrrXcAKKVeAK4ENtkHaK0/bnT8KqBXEs4rRMo1NDRgWRYOhyPual0gAftk0RCK8N7mgyz5bDe7KurROjql0S83nWtH9Wby4Fw8acn4GBWiZcn4m9YT2NPocQlwfjPH3wy8fbwXlVK3ArcC9O7dOwmXJ0TbsUtrulyuuKt1ATKH3cFFTIs315ayYOkmDvnDmEdVQS2pCvDZzkrysr38z9XDGdE7OzUXKk4ryZjDVk0812SRX6XUJKIB+57jvZnW+imt9Sit9ajc3NwkXJ4Qbae+vj4WsBNhB2zZ1tXx7K9u4Pbn1jD7pbVU1B8brCH6AecPW2w/WM/1f/mUDzYfaPfrFKefZATsEuDMRo97AaVHH6SUGgY8DVypta5IwnmFSDk7YCcyHA7RgC3bujqe/dUN/PL19fx/Xx1sMlADKDSZqoHOKoCHMHVBk1n/+JJd5XXte7HitJOMgP05MEAp1UcplQb8F/DPxgcopXoDrwLXa623JuGcQnQINTU1QPx5xG12tjN7S5hIvYhp8diyrazcXo51nGAN4FNh0jDRQLoKxYL2f7+0logpC9JE22l1wNZaR4A7gHeAr4AXtdYblVK3KaVuO3zYr4AuwBNKqSKl1OrWnleIjsDuYceb5cxmB2zpYXccm/fXsHJ7OQ3NrAI3MOmEHwcmYOFRIc4waumEn6KvK/hoW3n7XbA47SRleaPW+i3graOeW9To/28BbknGuYToSOxa2JmZmQm1s+e87W1hhiE5jFLt1S/2UhMIHdG7Vlh4iJCuQnhViHRCZKgQfu3AwoEG3Moky+GnVnt44l8fM+rMKWSkJzbiIkQ8ZD+CEK0QCAQSSktqswO2aZqYpikBO8UsS/PZzorYvLXCIpsAnY16sgjhMcI4sEjDJILCpZxYWqGJLkBzKhO3jhCuDvHh52sZX3gOnTt3TuUtiVOQBGwhWsGu1JWVlZVQu7S0tNgcdigUSniVuUiuYNikJhDBqSy6qDq6qxoyjSBpRFCAiYoGaKUIahcW0WFzJxoDSMPEZ0QI6TBrN22nq9dg8ODBdOrUKaX3JU4tErCFOEGNy2OeSA+7ccCOtzSnaBuW1ritAF05SIajBicmFooG7aIBJw3aiVNZpFkmEfXNfvsIFk4sLK1wqQhOLGrratm2bRvBYJCRI0fK71YkjQRsIU6QHWyVUmRkZCTU1k5japqmLDxLsUgkQsnXOxikS4BaIpgESKNOu6nTbiLawK1MXGj8pFGvPQS0ExODCAYGGp8K0UkH6GQ0oI3olr2dO3cCMG7cuIS3/QnRFPlbJMQJikQiRCIRHA5HwqvE3W43SkVzDkm2s9Q5dOgQa9euZefOneQaAUq1wSHtpl67CJKGR0VwKxONolq7qdBewIETCxcmTqLb8gKWk5BKJ6Id9HUqOnfuTHV1NcXFxXTu3Jlhw4al9kbFKUECthAnyO/3o7XG4XDgdrsTamsPiVuWJT3sFDBNk+3bt7Nx40YqKyvRWtO9Ry5f7PATVk4sbWGgCOg0GrQDC4ULi2yCKAVKW7gNEwONcTixo0KDgk7eDEKhEJmZmZSXl7N+/Xp69epFTk5Oiu9anOwkYAtxgmprazFNE5fLlVClLogGbMMwjpgHF+2jpqaGDRs2UFxcTENDAz6fjy5dupDVOZsVJVvwhyPUhAwcaNKUiVtFsLQigoF5+MdSTmosLw04MbVCAR5l0skRpl/vPIyGKurq6vB6vVRXV/PZZ59xySWXpPrWxUlOArZAWxZWMAiAcrnANFEuF0q2GjWrtrb2hAp/QDQ1qfSw25dlWZSWlrJhwwZKS0txOBx0796drKwsvF4voVCIM7I87K8LUx8KEsZBjeUmfHjRWQgHYRwoQKPQR5VRMA1F2GEw9YLz2L+vhA0bNlBXV4dSiq+//pqdO3fSp0+f1Ny8OCVIwD5N6UiEhq1bqX79dfyfr8asqsIKBEBrjC5dcOb1wDfiXLIunIxnwACULJo5Rl1dHVprPB5Pwm3tTGdaa4KHvyyJttPQ0MDmzZvZvn071dXVeL1eunbtSkZGBpFIhGAwiNPppGeXDJxpEfY1ODgQdFOPi6PrGzXOWqoOP3YoRZrTYGjPTmRl+sjMGIDWmg0bNqC1prKyko8//pgePXqc0N8XIUAC9mkptHcvB/7nYfyff4ZV74dgEPQ3H0NWTQ2RnTtpWPkxlYsW4erdm253zyHzggskcDdSVVUFcELbdjweT2xIXCp2nSDLAjMEjjQwjGMfE916t2/fPrZs2cLevXsxTZOuXbvSrVs3tNbU19cTiURIS0vD4/Ew9OzulBb7Gdg/j4PbyslQ4A+ZTeYWVxCdzwayPA58bifXjTk7+ppS9O3bl7q6Onbt2kUgEKCiooL169czatSo2IJDIRIhn76nmcCGDey9Zy6R/fvRoRC0NBwbiRDesYO9s+4kY9JEus+bh+uMM9rnYju42tpagIS3dAFHJEqROewEREKwfz3s/BAqtoNlgr8SrAi43ODJjkbR3EHUdR/HLr+br3fvoby8HIfDQW5uLpmZmVRXVxOJRDBNk6ysLLp3706XLl0Y2qkzqw8Vk9YQJt3tJGxaZGY6CJuaQNgkFNFYh7/cKgUuw8DndpDjc+Fzu5g8+JuSwC6Xiz59+lBTU0MwGOTAgQNs2bKFIUOGJLxvXwiQgH1aCe3dS+m8+zDLytDhcMvBurFwmLoP/sN+y6L7L3952gdtrfUJ5xGH6JC4Pe8tAbsFdpD+6k3Y8jZEGkAf7k03HALz8AiF4QBvZ8wzv8Xe3XvYue4F9ofS8afnkdGpCxkZGSilqKiowDAMHA4HvXr1omfPnnTp0iX2JepH4/uw8P1tjDwrm1U7KghGNN40B26XA611bDDKtKKrwtPTnKAUD0wvwJN25EdqTk4O3bt3p66ujkOHDlFRUcGuXbvIz89vzz9BcYqQgH2a0JEIZQsfx6qrwwqFoIlhWNMwMA2DgM9H0OUknObGHQiQUVuLQykckQj+zz6n/Jm/0n3O7NN6eNye94TWBWxZJX4cZgTKNsP6l2Dj6xCogrAflCMarK0wR84mgzZNKutDbN+8g/2uPtR48jC0SXb9LtK65hAMBnE4HHg8HjIyMsjNzeWss846Zk65eycPd0wewF9X7qQhYrJ29yFqA2GcDgO3U2HqaLC2LPC6HWR5XTwwvYBhvZrOHX7WWWdRWVlJbW0t+/btY926dZxzzjkyLC4Sdvp+4p5mgsXFBLZuoS4SwXS5MLQmLRzGYUVzIvt9Puq9Xmo6ZVHVqRP1Xh9BpxPT48YVjpBXsoduFRV0DgQIbtpEsLgYz6BBKb6r1AkEAgSDQQzDOKEiDw6HI1bwQ2piH6Xya/jg11D6JVTtPByXrcP/jZa1PFo16RRzFgd0Fw6RRSQcIU0fID37DLSlCO/dQMbAC3B7vPh8Pnr06EH37t2PW3SleycPc6YOYtvBOpZ9tZ+PtlWwq6KemmAEl6HwpjkZeEYG3x/Vm8mDc4/pWTfm8/no3r07hw4dory8nP3797Nv3z7y8vKS8aclTiMSsE9y2tJEwtEPfKfLgTKO/dZumiYly5ZR7PFS1707OhTCMCOk+wNk1dSglaImK4uAx0Nduo+qzp2pz8iMfj5qi4jTyd5evUAZqPJyHKWl1K/46LQO2HV1dbEsZyey6KzxkLhs6+KbHvUX/wfrXooOd4cDoAxwOCFiQqw21jf8uNlKH0rpRg2ZRFA4sfBpP46In0gNODr3IltX4zUC+HJ6cuaZZ8ZVrMXpMDinRxbn9MjipxM1IdPC0BCImKSnOXE649/2mJeXx759+8jJyWHfvn18+eWXErBFwiRgn4TMsMmBr2vZtvoA+7cfosEfQSlwe130GNCJwWPz6NozHcNhEAwG2f3112zes4dAejpmVRWBDXijeAAAIABJREFUdB916RmE3Wk4TAt3OITX70eZFtVZmYQ8HpzBBtLCYbwNDZgOB0GPh4quXXCHgrhCYTK3bSPHsk7bvdq1tbVYloXT6TyhBURKKelh22pKYdUiqNwRXUxmRsAMEu1V6yanb4I42crZ7CGPKjoRwYGbBnyHq2uBwtAW3uBBMozOeNJcZPu30XPgZSdUGc0wFB4j+gUrLS2xPfcAXq+XnJwc6urqKCsri60cTzSlrTi9ScA+SVimRcXeOtZ/uJcdRWUE/ZGjOxvUEqR8bx1bVu2n1+AcRl/Zm7KqUqrKysAwqHWnUdUzj1BaGkprtDLAMmlwp1Hr86GdLiwF3kCAvJK9pDcECKa5qU/3YbpcBLw+Kjp3xlNXhz8SQYfDqARTcp4qqqurMU0Tn893wvtqpYdNNFgvfxhC9fD1x9EFZYfnqS0cVJMJWGTgx0UEP2lsoS+76ckhMgnjxIufDBoAdThNqIUDi0wCZBCiU3AnnfMK6RLegZFggptkysvLo6ysjMzMTA4dOsT69es577zzUnY94uQjAfskUFcVZPXbu9i7uYLayiBmpIlNoTYNoYDJjqKD7C7ZycALcvBkOqlQipr0dKxIhIzaWtLr6lFK4fd6CbnTsJSBEQrS6VA1Z+7ZQ25VJcrS7D/j/2/v3oPjyu7Dzn/Pffa7G43GGyTBB8gZihKlMSnNaOS1ZVmSZ5zVxK5kbcuPiZ2tKe3GcbTl2FHixFWpuGqV2koq9pbXqinFtfJaiazIXmvs0kYljT2raKyxR4+R5BkOOcPhkCAINB79ft7XyR+NewcgQRIEQDQe51OFIoC+YB9cdN/fPb9zzu+M9PYANkxa6TT13AA1P6BqmrhSslfDdeAF4ARgaWj3kNoMVSoVoLeeerN7WYc97AO7Dtv3ej1rtw03XupNKtNMCDwkUCKHgwkE3CDPEgWKDNEggYeGhUeSFmavWCg6ARo+Nh5pWgxRYpgKyfYcWuIhqMleql3rT+GSTCZDJpNhcHCQSqXCK6+8wkMPPaR28lI2TL1SdrlGucs3/vQyC1erNKrOnYP1ConE0xu06w2+9/UG+eMBFcsCKZmYm+eB73yHhOPgaxqNZJKOaaL5Pul2m5jjIHmrtlOmXsfXNZItHc+2cCyLSn6A/OgotXqdwqpdp2QQ4HseumHsylR54AR0Xl2m+a0i3flGr9AGYI6kSL97jNgDg2jW3dsdVq6SUkZLhTYjrHYWBAGO49xzPfI9b/FVaC7A8hvQqdJLGfWyPnVSNESMqkxxjTEWKNAijomDjUOGDjZtelW8BSYOMVxsPIYoMc48aVqADr4A3wVEr6hKn2iaxujoKKVSCdu2KZfLXLp0iVOnTt1zaVvlYFIBexcL/IDvPnuN0mwd3/HxurfOjl2Pa9RxzQq+7tBxWjSvdkklEwx3u5ytVWFlGZEeBGTrdbI3/fzq8JOp1Wgmk6QbTRw7hmPbdNIZOmOjVKtVbNOktbTAm3/7EkvX3iTwfXTDZHDiEEfOnGX46HH0TfZAt5Nzvc7SFy4SlDrgrL3pcetVSq9XIWUw+NEHiR+786zvdrtNq9VCCMHAwMCm2xT2rMICHgfO618Fr4vXbdHxDXyZphPEWGCcq4yyJAt0sfABnQCbFgZg4KPjIdEw8UjQJkOTHHVGKZKks7aYqATayzB0KqqA1i+FQoF0Ok2hUODGjRu89NJLDAwMMDw8rIK2clcqYO9ipbkWlYU2QSCpl++8Vlci8UUXJ1bCMxv4oo2vOaB5BK7B+MRx3u1eRJ8+Se3Nq9Bub6gNehCQrtVwBwbIVip0Uknc4RRz9RrL//XPqbx2AWd5gWCdcdjn/8tniSVSTL/7Ec5+6HGGDk/1ZQzRuV5n4f9+GRp3GStueCw//X0yf+comfdN3vawer1Ot9vdcsBenUo/cGnxIKA7f4nlUouKO0LVSVMM0iyTo4OFJwSm9InTJklzJUj3ZokLgpW0d5NBKuSpkKJFjC635DokYMXA68LxD+z873kT0zQZGhpiaWmJ5eVlqtUqi4uLxGKxLb2WlIPhwATsUqlEEATE43Esy1rTu3EcB9d1EUJgWdZt73TD1GcQBLTbbTzPQ0q5pncUzv41DINYLBYVxwgLZISfu64b/ZyUEtu2o8egFxRe/sZVFipNul0fx3AIkCB6vWwpJEICCAKti693cY0GgeYCPmiAAOHZxJxhBjjB2C+9l6Xf+xTJRx+l+eyza+qH30mq2aSRTqMJyKTTzBmC5ux13NISerOFgca6/ZYgoNOo8bfPfZWZl7/HkXe8k/f85E+Rzhc29LzbIXACFv/wwt2D9Sq1P7+CnouRPLN+OxuNBp1OByHElvY4Dl+DrusemIlnUkparRbF2RmKyzZLpSRVkaITuLQxAImJR4oWSTrE6KIToOMTo0uWJkMsM0B1/QC9huhVP0sOQWoEhh7YmV/yLgqFAtlsllQqRaVSYW5ujkKhQC6XU8VUlDvaloAthPgx4LcBHfi0lPKTNz0uVh5/HGgB/0BK+e3teO6N+vrXv0673Y7eENG4q5QEQRAFSiklmqZFF9Ew4AZBgBAC3/ejyULh18HKWKgQIvpYvamDpmnR927+0DQt+j/Cn7UsCyEEtYUuHbeDKwNIBRCs7DSAAALQwgC+EniFXPlUR0gdo5Mm3h3F8NMsvtHC+KlhCv/Lxyj9wf9D8J730P6bv4nGce8kTJ2XfvBRukN56Hp06nUwTKQVQ/g+BD6av34vUQY+leIcwUsBTqfDD370yR0L2s3vLiAr974bVvk/XyD2L9+LHr/15q1cLuN5HqZpbqlXFI5ZH4RqZ91ul0ajwezsLLOzsywuLtIp2ThODl8YCDRsHOK0idElTgeLbm9NNR0y1BikQo46Me7h76lbkD8OD3+st557F0ilUuRyOTKZDLVajbm5OaampigUCgdvHoNyT7b8ChZC6MDvAh8ErgMvCiGekVK+suqwx4DplY/3AL+38u+OCOs+N5tNoNerDoO0lHJNz/leUpNhPeIwqIcBNxyT9H0/mlS0+nnCm4Nwt6ab76rDdjquR0BA1H3V4eat/ggEoPW2+QsMdM/G8FOYbgbLzaBhgACn5eG5PubICMP/28fpXr5M+Y8+T+WLX4SV57sdfXycE7/xL/hvly8hahW68wugGaBpSDveu6FAIjotRHD7sdjq0iK8fokX/+z/5Yd+9hfRd2B2bP3Zq5v7QR8az8+S/dHDtzxUqVSibM1W1tGGPez9GrA9z2NxcZGZmRnm5+dZWlqKdscKggBkHIsOWa1LTmuR8xeJy0avVy1dUqJBWjZJ0MLCQV+nwtn6wk0vNchPwYd/CzK7p0iJEILBwUHy+TyLi4s0m01mZmYYHx9XAVu5o+24Yr4beF1K+QaAEOJzwBPA6oD9BPAHshepXhBC5IQQY1LKuW14/rsSQmAYBvF4nCAIoh4sEKWvw+PC3rCu62uOCwO5ruv4vv/WRYe3AnD4mBAC0zQxTXPN89gra5aDIIjS4WEqPvx/ut1uFMTnXqvRaXs4nV7PWdIro4yQICQCDT2w0AIDEVjo0kTzbTRprsye7dF01twUCMMgduoUY7/5rxj+p79K/Stfofy5P6J7+XJvUxBAJJMkzp9j8MknSZw5w9LsDPqF79BeWkB22wjdRNpxpG4g7SSOECAEutNFuCs9IN0gMEykpiMNA4RGqd3Fuj7Lq999icMnT22qDvedeJ5Hq9Wi2+0SeAGVagVfBEgJWvi3xKeFgy98JGBIjZSMEcMihhkl+OvrBOxOp0OlUkFKSTKZjP6mm2FZVpRh2S8B2/M8SqUS8/PzXLt2jVKpRKPRwHGcKDsVbmWZtbNMzF8gZ/iYpka8sYQhO8S9CnE6GH4HocmVLNBGgzVEwXrqUXjidyF3601Xv+VyOdLpNOl0mqWlJRYXF6lWq9v+flD2l+0I2BPAzKqvr3Nr73m9YyaAWwK2EOIp4CmAw4e3540mpeTUqVM0Go3oIplIJKJ6zmFPWUqJYRhomobjOHieFwXqMH0Nvd2VwgtsmBYPx6XD79m2HQX8MHDHYrE1KXkpJZZlYZpmdIMAvZ6X53l8P3aDN76zQKndJPDvNN6srQnQNzNtHTthYpi3pnf1RILcE0+Qe+IJAs/DbzQQpokej69ZmnXlu99Cej5+ZRnd9cHS8FwXadpgmkgji2PG0Jo1TEMHCb5uEdgxEAIpBMJzEBLK5RKvvPRtPMNkcHCQQqGw4eIjq8f5w8/DZVHtdptOp0O328VxHGrLFZZEER8fV/Q+2sLBI8DDRyKj2jMmBmMyy6FgiEGZ6gXttofv+OirKltVKhVarRYA2Wz2trWoN8IwjOh1sFcDdjgmvby8zPz8PAsLC5RKJSqVCo7jRDfIhmGQz+ejtcijo6NkUknMr38XfeH7xO0MlpnArC30MkoegLGyE5dYKaayXvamd6MYZZ6EAN2GUz8OH/rXu6pnvZpt22QyGQYGBiiXy1SrVWZnZ5mYmFDj2NsovFbc7fthZynshIXX5NXZ0PC9unr4cvVjO2E7AvZ6Lb35LG3kmN43pXwaeBrg3LlzG5sVtQGpVIpYLBYF4fUukKsfh14PKOxBGYYR/QHDP1Amk1n3D6VpWvRHDa2eWGTbNrquYxjGbYsmmKbJsbePsHilSbXYRfr30sNYy7B0xk9k160zvqbdhoG2zkYWMggoXZ+hVasSdLto7XZvwpoQ+JogCDQwDKQdx7ft3raD0MsEoEO0sluCDKhLn4WFBeyrV5mZmSEej1MoFBgfHyebzd6yk5XnebiuS6fToV6vr5nk12g06Ha7tFqt6EYqPLbTaNHRGvgEUWgOz4Bcac9K6KeFQ120qWltzvsnSNK7gfAbDnr+rbR3rVaj0WgghKBQKGzpjRre0Ekp6XQ6m/5/+sH3febm5rh48SJLS0vUarXohil8j8RisSgo5fN58vk86XSaWCwWZSf0x34NPvdRcBYhPgDZw73qZ9BLJ+lur9hJuI4aesE7ewRMC1rL4HZ6wVy3YOAI/Mi/gmM/vGvGrNcTrjDIZrPE43EajQZzc3M0m81N7a+u9ARBEN20u6572yHO8Brhum604sPzPOr1ehQfwonFq+cohQE7jAGe53H69GnOnz+/I7/fdryirwOHVn09CdzYxDH3TdjLtW07So3fPPnMdd3oDxP2wlensVcfu5le1WbKV+bHEuSG4yxfN2m43V46/B4ZMYFlG5x6ePTef3iFvzIbvl2vIjQNTQaIZh3huhBPImJJfF0Hgt5F0hBv7dMg/bfitQ8IjUDTabs+9VoNwzRpNpsUi0UuXrxIIpGIMhKrhyTCv034JguDQzhTP/x39TCFJjRAYqykuHUEljR7+QghMNEQUgcpqWsdarS4IUpcEnOclVO9mQE3xeNSqYTjOOi6zsgW9wQPszmrszO7Xa1W48qVK1y8eJFKpRJd1IAoc5XL5ZiYmGBkZIRMJoNpmmiaFo35r1mFMXAYPvJ/wjP/GBoLYKd6KWyvDa0SOA1AgJmE7ATkjsBDvwCLF2DxYi+oywAK0zD9YRg+vasD9Wqr0+KtVotyuUyxWFQB+y7CIcWwRxxeIxzHiW7cw2AdvtbCobJGo0GpVFoT1MOVPqvnNa3uRa/ujYfHhEE7CAJSqdSeCtgvAtNCiKPALPDTwEdvOuYZ4JdXxrffA1R3avw6tF3p9Z2k6RpnP3CYZrXL5e8sIoN7Tzgk0jbjJwcYnNj8RUA3DGRv8PytGx0kutNGeA5Bp4WIJwjsOFL0AlBvyFEipI8mA5ACaRhIXUPqJj5QrdWQUq7pUdfrdYDoDRSOe4ZvkvAjfDOtnvCnaRqmaUaZC1M3cOckJgYGOlZgoiPQ0dGlhr2ystcjYEC6XBeCJeq8oc9zwhslTRw9+dYkoHD8Otz0Y3BwcNPnFHqZlnBIZbemxMOU97Vr17hw4QLFYpFWqxXdIIU3wMlkklwux9GjRykUChiGEfWi71q6deJd8DP/Cf7yf4eFV6C11Etrx7KQPwp2FswYpMd6s70z43DyQ72xbd/p9ax3YWW9uzEMg3Q6zeDgIKVSKTrPR44cUeVKb+I4Dt1uN7pJD3vGYU2EcFgSetnJcJisUqlEWbHwZj8UVhoMh6bCG+jV1xLLsqKlvuF71DTNKMtnmiYPPvjgjp2HLb8qpJSeEOKXgS/Ty3/+vpTyZSHEx1Ye/xTwJXpLul6nt6zrF7f6vAdFasDmvT85jecFXP3e8l3GstfKDscYOZrj3GNTaPrmL2hC0xg8dIT5y69j2jE69Vr0mBb4aN0WRreFLwTYMXwzhggC8L2VzRhABEGvw22aBJrB+LFjZCYmojdSuLf06lnz4RsnDNLwVvYjDHZhJiSZTEaTmRKJBIlEgmQiSev6FeLlO4zvY6AhaNHF1AxqWosGDq+LOd4Vn14zfr24uBil5NPp9JZ7Qqt7mruphx3eOBWLRS5dusT169ep1WrRBEnDMKKlSfl8nomJCfL5fJTqNgzj3uur51Z62ouvwutfgYVXe+PRQutVKDv+gd466tW9Z03rW13w7ZLP5ymVSiSTSZaXlykWizSbTbLZm+sPHjy+79NsNul0OrTb7ah3W6/Xo4+wtkW73Y7mHoVzWMJaF+E1xTCMaA5FWFI4nGsULs8MgoBMJkM+n6dareK6LolEAtd1cRyHZDIZ7R8QDp9uZre+zdqW2zgp5ZfoBeXV3/vUqs8l8I+247kOotSAzY/9z2e49OICz/+XS3TW2alrNTMmGJ7KMjSZ5uwHDpMa2PoWHcfeeY5L33j+jmO2upTQaaN12m9dWKWEwH9r7NjtYhkGP/j+HyE5NEKn06HVarG0tES9XqdW690MhMvhLMsiHo9Hd7u2bUcFacIx0rBHHQ55rB6yKL9T0PzL63f9/RLYTAVDFEWFq2KRN/Ul3n3+kehx13UpFot0u70Z8NlsdstLcOxVddh3Q8AOx6VfeeUVrl27Rq1WW9OryOfzjIyMMD4+ztDQEGNjY9u7PaRuwOiZ3sce7z1vVDqdJh6Pk0qlqFar1Ot1rl69ypkzZ7Y0oXGvCoKAer0eTe7sdrtRz7rVakVDl77vR/MlwuGx1TeU4STHWCxGNptlcHAwet2GPWt46+Y0HMcOb/aB6G/SarXQdZ3R0dEdDc7rUXmXPULTNR54eJQTDxV447uLfO8vZikXm/hugAx6nZFExmJgLMH49ABHzhTIjyW21LNebXDyMEOHp5i99Aq6ZeM7ty9eIWBldu/6j+WGRzh86kE0XScIArrdbjQeHKa7VqelwjvhcDb/vaQLk+8YpvNaGf/6ndeaA8SxORqMMKuXaGhtShM+I7wVyFZXOBsZGdnyBTX8nfo9hh0EAdeuXeOb3/wms7Oz0YVQ13VSqRQjIyMMDw8zPDwcrR++7ynbfdB73gghBLlcjkKhwPLyMu12m5mZGaampshkMv1u3o5ptVoUi0Wq1WrUQ+50OtFYdTjW7HleVMs/CAJ0Xcc0TXK5XDQ0E1aSC2/sV/eobxZOHl5P+LdJpVJRJq/fVMDeYwzL4OT5MU6eHyPwArodD10XGKZOICW6rt11NvhmaLrOI3//Z/ji//FbJNIZ6suLm/5//oef+6WopvjqyUj3gzmcIH4sR9v18Yt3n4k9LLOkSVA2m/ztxb9lanqKarXK3NxcNGvdMAwOHTp01//rrm1btU6/H7XEfd/n2rVrfOMb3+DGjRtRZb9YLEY+n2d8fJyRkREGBgYYHBzc9L7fyp3l8/loslmz2aRSqbC0tBQFiv3Kdd2oNGs4gTEsOAVvFbJqt9tRwZ3wRj6ZTDI6OsrExASFQoF8Po9t21Ea3fO8NUNlW7Gb5hPsnpYo90wzNOKpt16M9/utnR0a4UMf+xW+/KnfptNs4HY2toFISDMMjj/0bo6e/YH71MJbCV2QfnQC2fXpplp4l2t3PD6mmUy/7STfuvp9bty4wYULF+h2u1FRnG63SyqVYnR087PuQ/crYAdBEI3fhUsIV/N9nzfffJMXX3yRmZmZ6CYkm81y5MgRxsfHKRQKDA8Pb6kwjLIxtm2TSqXIZrOUSiWazSbXr19naGhoXxVSCTNJ7XabUqnEjRs3WF5eptVqIaWM3g9h1q3dbuM4TrREMJ/PUygUmJycZGpqat15EuHreL9SAVu5J6PHpvmJX/tN/v8//H2ufv87dFutDW0iYsUTHDrzDt7/i0/t+I5detYm8yOHqT8/i5ey8MpdvGIDuqvabeuYY0kGfnKamGjyyn96nU6nw/z8PIVCAU3TWFzsZRVGR0e3JZCtnh2/1YAdpu1feOEFrly5EqXuw+Vn58+f59SpU5TLZV544QUuX75Mu91G13UKhQInTpxgcnIySnnv557dbhSuU5+fn4+WHi0vL29pv/XdItw/vlgsUq/XKZfLa3rMiUQC27Zpt9vUarWoNLNlWRw5coTJyUmOHz++r25eNksFbOWeZYaG+fFf+TWuvfw9Xvjj/0xlfo52o05wc9DRNHTDZOjwFBMnH+AH/sef2NGdulbTszbZDx/FXWjRuVTGG4rj+wHCB2MsQeLBAuZwAqELcq7J1NQUr776KsVikVgsRrPZpFarYVkWx44d25a9i1dPkAtnnG4m/ba8vMwzzzzD1au31k33PI9r164xMzMTTeBrtVpomkY+n+fMmTNMTU0xNDSkUt59FI7BZjKZ6LW2sLAQVYfbixzHoVgscuXKFUqlEq7rRqVps9kspmlGM8Dn5ubwfR/DMDh8+DBHjhzhxIkT6jV5ExWwlU3RdJ2pd7yLw297B0vX3uTyt19k7rVXaZZKdFpN7HiCVKHA5AOnOfrOcwxOHu7LXtirCV1gjSWxxpK9Ne2+BF3cMuZvmiZnzpyJljNdu3Yt6gkPDg4yOXn7vbLvRTiRJVy6tpmAfenSJb7whS/cdR13WHrRcRwSiQQnT57k/PnzjI6Oqt70LhDeQOXzeZaWluh0OpRKJZaWlkgkErtqHHU9Ybo7rBB2/fp1FhcXqVQquK5LKpUilUohpSSRSOA4Djdu3KDZbCKEIJVKMTk5yZkzZ/Z1SnurdverQNn1NF1n+Ohxho8eRwYB/spkjyAI0A1jTT3y3URoAu4wOW98fJwHHniAq1evRstAcrkcp0+f3rZKVKtnnq6ebLNR169f5/Of//w9pdPDC+v73//+Pdtz268GBwcpFoskk8lonXGpVIrWu+9GrVYrqqPQ7Xa5evUqi4uLUcGjsF5BOPGrXC4zMzNDp9PBMAwKhQLHjh1jenr6vk083U9UwFa2jdA0jJU35u4M0xsXj8d5+9vfjmVZNBoNdF1nYmKCiYmJbUmHA2sqtYWVmZLJ5IZ+1nVdPve5z21q7NtxHC5dusS5c+fu+WeV+yesKxCmxcNNVfL5PIlEYlelh8MqYmHFu8XFRWZnZ/E8j1QqRSKRWLNBRq1Wo16v02w20TSNQ4cOcezYMQ4dOqQC9T1QAVtRbmNoaIhEIhGVQtV1fVsvLmGRB7j3PbFffPFFGo3Gpp/7ueeeUwF7FyoUCtGa7HAzinK5TCwWY3h4+JbUeCAD3MDF1MyV2vn3XzjGDtDtdpmfn482zQhro4e1vFutFs1mk3a7jWmajI2Ncfz4cYaHh6OgrmycCtiKchvh2Nr9FC5luZfiKb7v87WvfW1Lz9toNPB9f9uyBcr2yGaz5HI5bNuO6mYvLy+TyWQol8sUCgV86XOxdJHnrj3HTG0GQ+/Vwj6WO8Z7x9/L8dxxDG37L+2+71Ov16PqX7VaLapGJqWMJs51Oh2azSaNRgPXdTFNk/HxcU6dOsXIyIh6zW2BCtiK0kfhxSucFLYRxWJxW7bjbDabahx7lxFCMDw8zNDQENev90rqNhoN6vU6whB86c0v8Zk3PkO5W46OtzSL8eQ4DbfBa+XXKMQL/OyDP8tIcmu7yYXCnn6j0WBxcZFqtYoQAsdxME2TRCKBlBLLsqjValGqPBaLcejQIaanp3ftGPxeowK2ovRRuFNQWBt5I1599dVtee52u60C9i40MDDA8PAwxWIR3/cRmuCFiy/w5eaXKQdlHN0hMAI0oaELHc/3eLP2JjONGQ6nDyPygqe/9zRPveOpLQVt3/ej3vTy8jLVajWaMxGu3w/T3o7jRGl827aZnJxkenp6yzvaKWupgK0ofRTOnpVSbihgB0HA0tLStjx3uEORsrtomsbw8DCFQoE3r7/Jy/WXmW/Mo5s6QSzA9E18fDpGB2+lZr+lWUgpebP6Jq50efvg2/nshc/yKw/9yj2nx6WUUYnUarUaBWIpJbZtR4VOwk06yuVytL56bGyMo0ePMjY2plLf94EK2IrSR6ZpRku7NjKGHRaX2KrwAqvsTkNDQ8RyMW68eoNlZ5mm1iTjZGjpLSp2hZgfIxABjt6bqOgEDgKBqZnMNeZIm2kCAi5XLnMqf2pDzxnufFWr1bh69SrLy8tR0I3FYqRSqej1uri4yPz8PI7jEI/HGRoa4ujRo0xMTOz6NeN7mTqzitJHYdD0fX9DS7R0XUfTNAzD2FI509OnT2/6Z5X7TwrJXzf/mobZwGgbSE3S1toMdgfxNI+G0SDh9bZ6DIO2ROIGLrrQWWwvMp4c569u/NVdA3aY1q7X69Ge3K1WCyEEnueRy+XIZrMYhhFtGLOwsBCtoz5+/DiTk5MbXpKobJ4K2IrSR+EGBkKIDU060zSNQqHAyMgIs7Ozm3pOIQSPPfbYpn5W2RmXK5epGTWKVpE4cbJulmKsSDJIku/mCQhoG+11g7YnPardKpVuhTcqbxDI4JYlX2FvutFoUK1WKZVK1Ov1qK59uNmG53kEQRCVEL1x4wbdbpd0Os2JEyeYnp5WgXoHqYCtKH20eoeijVY6O3HiBPPz88zPz99zdTSAD33oQ+oiu8s9P/s8tmEzo80wbA9T6BTIuTnqZp24HydU+g5yAAARQklEQVTv5KnJGk2jScJLYAQGbaONFL0Nbbpel3KnzHBiGDdwsXV7zXaV4frocFJZWDI0LBQUj8dJJBKYpkm9XmdxcZFisYimaRw7doyzZ8+SzWbVOuodpgK2ovRROCYYVjrbiKGhITKZDMeOHeP1119HbmC3tNCHP/xhHnnkkc02V9kBgQy4Ur1Czs5R1suYtknSTWL7Nk2jSVfvYngGWZkl4SVoGk2EIbACC1dzcTWXQAT4gY/sSuqVOrWghuu6BEFAu92mXC5HO7qF21fato3jONi2TT6fx3VdGo0G169fp9lsMjg4yNmzZ7dlL3hlc1TAVpQ+Wl1ucqPrsHVd5+GHH+ZrX/saIyMjFItFgDsG7omJCT760Y+qnvUe4Aa9yYe60JFIlmJLJNwEI50RUl6KJWsJ0zLRAx0rsDA8A9/1QYCjOTT1JgiI1WJMpicpl8p0u92odx3OfTAMA8MwsG0b27axLItOp4OmadRqNZaWlqhWqwAcPXqUd77znaqMaJ+pgK0ofRSmxIFo6cxG0oyZTIZHH32Uz3/+85imieu60c+FldN0XWdsbIyPfOQjDA0N3dffQ9k+ptab17DQXgDA130W44sk/SRJN0nCT1C1qpiid5wmNRJBAtM3SZIkRw5XcxlggKHuEDdu3AB6N3q2bUfzJsKvc7kcuq5TLpep1+s4jkOr1cLzPLLZLKdOneLIkSMq/b0LqICtKH1k2zaapuF5Hr7v93Y52+D61bB0aqvVwrIsMplMr3Sl7zMyMsLJkycZGhpS62H3GE1oHM0e5c8u/1n0vabVZCm2hOVbpN00ru5SM2oITZB1sviaT9ksI5Ek/ASBCBgYHODk4ZNkUpkoSJfLZXzfx7KsqJRouN56bm6OarWKYRgkk0kOHz7MsWPHVK96F1EBW1H6yLbtNT3se6nvXavVaDabGIZBLpfjscceY3BwMFr6pexdj4w/wqe//+noaykky7FlLN9ipD1CrptDSEHNrrEUW8IMTOzABqBjdJBC8sFjH4QAFhYW0DQNXdeJxWLkcjlM06TdblMqlajVaiwsLNBqtTAMg2PHjnHkyBEGBgbU62iX2VLAFkLkgT8CpoA3gf9JSlm+6ZhDwB8Ao0AAPC2l/O2tPK+i7BeWZUUBO5x4ttGCJrOzs7iui6ZpJJNJ8vl81JNS9rbJ9CRBEKz5nqu7LMQX0KVOoV1gwBkAAcVYkUq8guVbJL3e5DRNaqTNNLquR2v2dV3HdV2q1SqaptHpdJidnaXdbuP7PrlcjgcffJDx8XFs2+7Tb67cyVZ72J8AnpVSflII8YmVr//ZTcd4wK9KKb8thEgD3xJCfEVK+coWn1tR9jzDMKIedRAEG96xK9zWEHprswcHB1Xlsn3E0AxSVopmu7nm+x2zQzFRRArJYHuQXDdHzI9RcStUrAo1q4aPj4HB8OQwsSBGs9nEcZxoP+pOp0OlUolK4WYyGcbHxzly5Iiq/b3LbTVgPwH88MrnnwGe46aALaWcA+ZWPq8LIS4AE4AK2MqBp+s6uq5Ha7GbzeaGanyHexJLKTEMg4mJiR1orbJTbN0mZ+cotou3PNYyWyywgCc88u08pm8y2B4k7aZxdAeJRGqS2SuzGKsu8Z1Oh1KpFPWos9ks4+PjjI6Oqhu+PWKrAXtkJSAjpZwTQgzf6WAhxBTwLuCv73DMU8BTAIcPH95i8xRld9M0DU3TorT4RnfsajQatNtthBCYpqlmge8zmtA4N3aOS5VLSG5drtcyWziagyMcBp1BbN8m4SWwfAtPeNiGTaPaQNd0Op0OnU6HIAiwLIvJyclojDqRSKjZ33vIXQO2EOKr9Mafb/Yb9/JEQogU8MfAx6WUtdsdJ6V8Gnga4Ny5cxuvCKEoe1BYF1xKSRAEG16Lvbi4iO/7SCmJx+Nqm8x96CPHP8KfvvanNL3muo97usdCcoF6rE62kyXrZLGkhSUtJmOTNBvN6PUxNDREPp9ncHCQXC6nxqj3qLsGbCnlj97uMSFEUQgxttK7HgMWbnOcSS9Yf1ZK+Sebbq2i7DNCiGhPbCnlhqqdSSlZWFhASommaWSzWTXZbB86OXCSh8ce5i9m/mLdXjYAAtpGm3aqTTEoEgtipLQUv3T+l5gemMY0TRKJRFQgRfWm97atztl/Bnhy5fMngS/efIDovUL+I3BBSvnvt/h8irKvhCnt0EZ62J1OJxq/DvdOVvYfQzP49Xf/OuPJcQQbCLQaiJjgPcffw/tOv4+JiQmGh4dJpVLEYjEVrPeBrQbsTwIfFEK8Bnxw5WuEEONCiC+tHPMo8PPAjwghXlr5eHyLz6so+8bqHvZGAnaz2aTVagG9SmlqZu/+NZ4a59/98L9jMjWJIYx1A7dAYAiDjJXhkfFH+PgPfBxDUyU29qMt/VWllMvAB9b5/g3g8ZXPvw4buT1UlIPJsqyoDvhGA3aYOjcMY0OzypW9622Ft/HpD32a3/nO7/DSwkuUOqU19cbTVprDmcO8bfBtPPm2JxlJjvS5xcr9om7DFKXPVtcT38gYdrlcjjZwiMVipFKp+9o+pf/G0+P81vt+i8uVyzw/+zyXSpfwpY+lW5wYOMF7x9/L8dxx1bPe59RfV1H6bPWM3W63e9cNQBYXF6Px60wmo8pHHhCGZnAqf4pT+VMEMsANXEzNRBPq739QqL+0ovRZOHtXShltAHI7juNQq/VWRWqaRj6f36lmKruIJjRs3VbB+oBRf21F6bMwYAsh8DzvjgG73W5HlaoMw1ATzhTlAFEBW1H67OYdu+408azb7dLpdKL122rCmaIcHCpgK0qfhWtkhRD4vk+73b7tsfV6Hc/zEEIQi8VIp9M72FJFUfpJBWxF6bOwnrOUEilltMZ6PaVSCc/zkFKSSCRUhTNFOUBUwFaUPrNtO9oAxPf9O6bEy+UyQRCg6zrZbFZVr1KUA0QFbEXpM8Mw1uzYdbuUeDhDPFzSpcavFeVgUQFbUfpM1/Voxy7gtilxx3HodDpIKbEsSy3pUpQDRgVsRekzXdfXjEXfrocd7msMvepo2Wx2R9qnKMruoAK2ovTZ6j2xNU277Rh2q9XCcRw0TcO2beLx+A63VFGUflIBW1H6TNO0NT1sx3HWLZ5SLpfxfR8pJclkUs0QV5QDRgVsRdkFwh27NE3DcRx837/lmKWlJYIgUBPOFOWAUgFbUXaBcAOQMGC7rrvmcc/zqFQqUUlSFbAV5eBRAVtRdoFkMgmAlBLP826ZKd7tdqPv2bZNoVDY8TYqitJfKmAryi4QlifVNI0gCG4J2OGmH+Gxag9sRTl4VMBWlF0gLE8aligNt9AMtVotut0uQgji8TixWKxPLVUUpV9UwFaUXSCZTEaVzqSUNJvNNY+HE87CkqSapt66inLQqHe9ouwCiUQCXdej5VyNRiOqfAYwPz+P53kYhqEqnCnKAaUCtqLsApZlRcVTdF2n0+lES7tc16VarQK9CmdDQ0P9bKqiKH2iArai7AKmad4SsMOlXa1Wi2azSRAEpFIptaRLUQ6oLQVsIUReCPEVIcRrK//e9koihNCFEN8RQvz5Vp5TUfYj0zQxTXNNwHYcB4Bms0m73UbTNFKplJpwpigH1FZ72J8AnpVSTgPPrnx9O/8EuLDF51OUfUnTNGKxGL7vY1kWnudFM8UXFhZwXRdd18nlcmrCmaIcUFt95z8BfGbl888Af3e9g4QQk8CPA5/e4vMpyr6VTCaRUkap8XK5DMDs7CxBEGCaJsPDw31upaIo/bLVgD0ipZwDWPn3dleT/wD8OnDrjgY3EUI8JYT4phDim4uLi1tsnqLsHWG1s3AtdrVapd1us7y8TBAEJJNJRkdH+9xKRVH6xbjbAUKIrwLrXSV+YyNPIIT4O8CClPJbQogfvtvxUsqngacBzp07J+9yuKLsG+H66nC9db1e59q1azQaDYQQ5HK5KKgrinLw3DVgSyl/9HaPCSGKQogxKeWcEGIMWFjnsEeBjwghHgdiQEYI8YdSyp/bdKsVZR/KZrMIIaINPlzXpVwu0+l0MAyDkZERDOOub1lFUfaprabEnwGeXPn8SeCLNx8gpfznUspJKeUU8NPAX6hgrSi3SiaTGIYRTTxzXZdKpYKUEtu2mZyc7HcTFUXpo60G7E8CHxRCvAZ8cOVrhBDjQogvbbVxinKQxONxbNvGcRxSqRStVourV6/i+z6ZTEZNOFOUA25L+TUp5TLwgXW+fwN4fJ3vPwc8t5XnVJT9yjRNUqkUS0tLpNNpisVitLTrxIkTWJbV5xYqitJPakGnouwSQggGBgaiJVwDAwNIKRkYGGB6ejraHERRlINJBWxF2UWGhoaQUtJoNOh2u8TjcR544AG14YeiKFtLiSuKsr2Gh4eJxWIsLCzQ6XTIZrOcPXtW9a4VRVE9bEXZTTKZDPl8nm63ixCC06dPk8lk+t0sRVF2ARWwFWUX0TSN8+fPk8vlmJiY4IEHHuh3kxRF2SVUSlxRdplCocDjjz+OEEIVSlEUJaKuBoqyC5mm2e8mKIqyy6iUuKIoiqLsASpgK4qiKMoeoAK2oiiKouwBKmAriqIoyh6gAraiKIqi7AEqYCuKoijKHqACtqIoiqLsASpgK4qiKMoeoAK2oiiKouwBKmAriqIoyh4gpJT9bsNtCSEWgav9bsc+VgCW+t2IA0Cd552hzvPOUOf5/joipRxa74FdHbCV+0sI8U0p5bl+t2O/U+d5Z6jzvDPUee4flRJXFEVRlD1ABWxFURRF2QNUwD7Ynu53Aw4IdZ53hjrPO0Od5z5RY9iKoiiKsgeoHraiKIqi7AEqYCuKoijKHqAC9gEhhMgLIb4ihHht5d+BdY45JIT4SyHEBSHEy0KIf9KPtu5FQogfE0JcFEK8LoT4xDqPCyHE76w8/j0hxEP9aOdet4Hz/LMr5/d7Qoi/EkKc7Uc794O7netVx50XQvhCiL+3k+07iFTAPjg+ATwrpZwGnl35+mYe8KtSygeBh4F/JIQ4vYNt3JOEEDrwu8BjwGngZ9Y5b48B0ysfTwG/t6ON3Ac2eJ6vAD8kpXwH8G9QE6Q2ZYPnOjzu3wJf3tkWHkwqYB8cTwCfWfn8M8DfvfkAKeWclPLbK5/XgQvAxI61cO96N/C6lPINKaUDfI7e+V7tCeAPZM8LQE4IMbbTDd3j7nqepZR/JaUsr3z5AjC5w23cLzbymgb4x8AfAws72biDSgXsg2NESjkHvcAMDN/pYCHEFPAu4K/ve8v2vglgZtXX17n1Rmcjxyh3dq/n8B8C/999bdH+dddzLYSYAH4C+NQOtutAM/rdAGX7CCG+Coyu89Bv3OP/k6J31/xxKWVtO9q2z4l1vnfzesmNHKPc2YbPoRDi/fQC9vvua4v2r42c6/8A/DMppS/Eeocr200F7H1ESvmjt3tMCFEUQoxJKedWUrHrprCEECa9YP1ZKeWf3Kem7jfXgUOrvp4EbmziGOXONnQOhRDvAD4NPCalXN6htu03GznX54DPrQTrAvC4EMKTUv7pzjTx4FEp8YPjGeDJlc+fBL548wGi9877j8AFKeW/38G27XUvAtNCiKNCCAv4aXrne7VngF9YmS3+MFANhyiUDbvreRZCHAb+BPh5KeWlPrRxv7jruZZSHpVSTkkpp4AvAP+rCtb3l+phHxyfBD4vhPiHwDXg7wMIIcaBT0spHwceBX4e+L4Q4qWVn/sXUsov9aPBe4WU0hNC/DK9mbI68PtSypeFEB9befxTwJeAx4HXgRbwi/1q7161wfP8m8Ag8H+t9Pw8tbPUvdvguVZ2mCpNqiiKoih7gEqJK4qiKMoeoAK2oiiKouwBKmAriqIoyh6gAraiKIqi7AEqYCuKoijKHqACtqIoiqLsASpgK4qiKMoe8N8BwBIpxYp+zQ8AAAAASUVORK5CYII=n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Delineate the ECG signaln”, “signal_dwt, waves_dwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="dwt", show=True, show_type=’all’)”

]

}, {

“cell_type”: “code”, “execution_count”: 17, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize P-peaks and T-peaksn”, “signal_dwt, waves_dwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="dwt", show=True, show_type=’peaks’)”

]

}, {

“cell_type”: “code”, “execution_count”: 18, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# visualize T-wave boundariesn”, “signal_dwt, waves_dwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="dwt", show=True, show_type=’bounds_T’)”

]

}, {

“cell_type”: “code”, “execution_count”: 21, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize P-wave boundariesn”, “signal_dwt, waves_dwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="dwt", show=True, show_type=’bounds_P’)”

]

}, {

“cell_type”: “code”, “execution_count”: 19, “metadata”: {}, “outputs”: [

{

“data”: {

“image/png”: “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n”, “text/plain”: [

“<Figure size 576x360 with 1 Axes>”

]

}, “metadata”: {

“needs_background”: “light”

}, “output_type”: “display_data”

}

], “source”: [

“# Visualize R-wave boundariesn”, “signal_dwt, waves_dwt = nk.ecg_delineate(ecg_signal, rpeaks, sampling_rate=3000, method="dwt", show=True, show_type=’bounds_R’)”

]

}, {

“cell_type”: “markdown”, “metadata”: {}, “source”: [

“Visually, from the plots above, the delineated outputs of DWT appear to be more accurate than CWT, especially for the P-peaks and P-wave boundaries.n”, “n”, “Overall, for this signal, the peak and DWT methods seem to be superior to the CWT.”

]

}

], “metadata”: {

“kernelspec”: {

“display_name”: “Python 3”, “language”: “python”, “name”: “python3”

}, “language_info”: {

“codemirror_mode”: {

“name”: “ipython”, “version”: 3

}, “file_extension”: “.py”, “mimetype”: “text/x-python”, “name”: “python”, “nbconvert_exporter”: “python”, “pygments_lexer”: “ipython3”, “version”: “3.7.3”

}

}, “nbformat”: 4, “nbformat_minor”: 2

}

How to create epochs

So, in your experiment, participants undergo a number of trials (events) and these events are possibly of different conditions. And you are wondering how can you locate these events on your signals and perhaps make them into epochs for future analysis?

This example shows how to use Neurokit to extract epochs from data based on events localisation. In case you have multiple data files for each subject, this example also shows you how to create a loop through the subject folders and put the files together in an epoch format for further analysis.

# Load NeuroKit and other useful packages
import neurokit2 as nk
import matplotlib.pyplot as plt
%matplotlib inline

plt.rcParams['figure.figsize'] = [15, 5]  # Bigger images

In this example, we will use a short segment of data which has ECG, EDA and respiration (RSP) signals.

One signal with multiple event markings

# Retrieve ECG data from data folder (sampling rate= 1000 Hz)
data = nk.data("bio_eventrelated_100hz")

Besides the signal channels, this data also has a fourth channel which consists of a string of 0 and 5. This is a binary marking of the Digital Input channel in BIOPAC.

Let’s visualize the event-marking channel below.

# Visualize the event-marking channel
plt.plot(data['Photosensor'])

[<matplotlib.lines.Line2D at 0x2109054b6d8>]

Depends on how you set up your experiment, the onset of the event can either be marked by signal going from 0 to 5 or vice versa. Specific to this data, the onsets of the events are marked where the signal in the event-marking channel goes from 5 to 0 and the offsets of the events are marked where the signal goes from 0 to 5.

As shown in the above figure, there are four times the signal going from 5 to 0, corresponding to the 4 events (4 trials) in this data.

There were 2 types (the condition) of images that were shown to the participant: “Negative” vs. “Neutral” in terms of emotion. Each condition had 2 trials. The following list is the condition order.

condition_list = ["Negative", "Neutral", "Neutral", "Negative"]

Before we can epoch the data, we have to locate the events and extract their related information. This can be done using Neurokit function events_find().

# Find events
events = nk.events_find(event_channel=data["Photosensor"],
                        threshold_keep='below',
                        event_conditions=condition_list)

events

{'onset': array([ 1024,  4957,  9224, 12984]),
 'duration': array([300, 300, 300, 300]),
 'label': array(['1', '2', '3', '4'], dtype='<U11'),
 'condition': ['Negative', 'Neutral', 'Neutral', 'Negative']}

The output of events_find() gives you a dictionary that contains the information of event onsets, event duration, event label and event condition.

As stated, as the event onsets of this data are marked by event channel going from 5 to 0, the threshold_keep is set to below. Depends on your data, you can customize the arguments in events_find() to correctly locate the events.

You can use the events_plot() function to plot the events that have been found together with your event channel to confirm that it is correct.

plot = nk.events_plot(events, data['Photosensor'])

Or you can visualize the events together with the all other signals.

plot = nk.events_plot(events, data)

After you have located the events, you can now create epochs using the NeuroKit epochs_create() function. However, we recommend to process your signal first before cutting them to smaller epochs. You can read more about processing of physiological signals using NeuroKit in Custom your Processing Pipeline Example.

# Process the signal
df, info = nk.bio_process(ecg=data["ECG"], rsp=data["RSP"], eda=data["EDA"], sampling_rate=100)

Now, let’s think about how we want our epochs to be like. For this example, we want:

1. Epochs to start *1 second before the event onset*

2. Epochs to end *6 seconds* afterwards

These are passed into the epochs_start and epochs_end arguments, respectively.

Our epochs will then cover the region from -1 s to +6 s relative to the onsets of events (i.e., 700 data points since the signal is sampled at 100Hz).

# Build and plot epochs
epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-1, epochs_end=6)

And as easy as that, you have created a dictionary of four dataframes, each correspond to an epoch of the event.

Here, in the above example, all your epochs have the same starting time and ending time, specified by epochs_start and epochs_end. Nevertheless, you can also pass a list of different timings to these two arguments to customize the duration of the epochs for each of your events.

One subject with multiple data files

In some experimental designs, instead of having one signal file with multiple events, each subject can have multiples files where each file is the record of one event.

In the following example, we will show you how to create a loop through the subject folders and put the files together in an epoch format for further analysis.

Firstly, let’s say your data is arranged as the following where each subject has a folder and in each folder there are multiple data files corresponding to different events:

[Experiment folder]
|
└── Data
|   |
|   └── Subject_001/
|   |   │   event_1.[csv]
|   |   │   event_2.[csv]
|   |   |__ ......
|   └── Subject_002/
|       │   event_1.[csv]
|       │   event_2.[csv]
|       |__ ......
└── analysis_script.py

The following will illustrate how your analysis script might look like. Try to re-create such data structure and the analysis script in your computer!

Now, in our analysis scripts, let’s load the necessary packages:

# Load packages
import pandas as pd
import os

Assuming that your working directory is now at your analysis script, and you want to read all the data files of Subject_001.

Your analysis script should look something like below:

# Your working directory should be at Experiment folder
participant = 'Subject_001'

sampling_rate=100

# List all data files in Subject_001 folder
all_files = os.listdir('Data/' + participant)

# Create an empty directory to store your files (events)
epochs = {}

# Loop through each file in the subject folder
for i, file in enumerate(all_files):
    # Read the file
    data = pd.read_csv('Data/' + participant + '/' + file)
    # Add a Label column (e.g Label 1 for epoch 1)
    data['Label'] = np.full(len(data), str(i+1))
    # Set index of data to time in seconds
    index = data.index/sampling_rate
    data = data.set_index(pd.Series(index))
    # Append the file into the dictionary
    epochs[str(i + 1)] = data

epochs

And tah dah! You now should have a dictionary called epochs that resembles the output of NeuroKit epochs_create(). Each DataFrame in the epochs corresponds to an event (a trial) that Subject_001 underwent.

The epochs is now ready for further analysis!

Complexity Analysis of Physiological Signals

A complex system, can be loosely defined as one that comprises of many components that interact with each other. In science, this approach is used to investigate how relationships between a system’s parts results in its collective behaviours and how the system interacts and forms relationships with its environment.

In recent years, there has been an increase in the use of complex systems to model physiological systems, such as for medical purposes where the dynamics of physiological systems can distinguish which systems and healthy and which are impaired. One prime example of how complexity exists in physiological systems is heart-rate variability (HRV), where higher complexity (greater HRV) has been shown to be an indicator of health, suggesting enhanced ability to adapt to environmental changes.

Although complexity is an important concept in health science, it is still foreign to many health scientists. This tutorial aims to provide a simple guide to the main tenets of compexity analysis in relation to physiological signals.

Basic Concepts

Definitions

Complex systems are examples of nonlinear dynamical systems.

A dynamical system can be described by a vector of numbers, called its state, which can be represented by a point in a phase space. In terms of physiology, this vector might include values of variables such as lung capacity, heart rate and blood pressure. This state aims to provide a complete description of the system (in this case, health) at some point in time.

The set of all possible states is called the state space and the way in which the system evolves over time (e.g., change in person’s health state over time) can be referred to as trajectory.

After a sufficiently long time, different trajectories may evolve or converge to a common subset of state space called an attractor. The presence and behavior of attractors gives intuition about the underlying dynamical systems. This attractor can be a fixed-point where all trajectories converge to a single point (i.e., homoeostatic equilibrium) or it can be periodic where trajectories follow a regular path (i.e., cyclic path).

Time-delay embedding

Nonlinear time-series analysis is used to understand, characterize and predict dynamical information about human physiological systems. This is based on the concept of state-space reconstruction, which allows one to reconstruct the full dynamics of a nonlinear system from a single time series (a signal).

One standard method for state-space reconstruction is time-delay embedding (or also known as delay-coordinate embedding). It aims to identify the state of a system at a particular point in time by searching the past history of observations for similar states, and by studying how these similar states evolve, in turn predict the future course of the time series.

In conclusion, the purpose of time-delay embeddings is to reconstruct the state and dynamics of an unknown dynamical system from measurements or observations of that system taken over time.

In this gif here, you can see how the phase space is constructed by plotting delayed signals against the original signal (where each time series is an embedded version i.e., delayed version of the original). Each point in the 3D reconstruction can be thought of as a time segment, with different points capturing different segments of history of variable X. Credits go to this short illustration.

Embedding Parameters

For the reconstructed dynamics to be identical to the full dynamics of the system, some basic parameters need to be optimally determined for time-delayed embedding:

• Time delay: tau, τ

  • A measure of time that sets basic delay

  • Generates the respective axes of the reconstruction: x(t), x(t-tau), x(t-2tau)…

  • E.g., if tau=1, the state x(t) would be plotted against its prior self x(t-1)

  • If τ is too small, constructed signals are too much alike and if too large, the reconstructed trajectory

will show connections between states very far in the past and to those far in the future (no relationship), which might make the reconstruction extremely complex

• Embedding dimension, m

  • Number of vectors to be compared (i.e. no. of additional signals of time delayed values of tau)

  • Dictates how many axes will be shown in the reconstruction space i.e. how much of the system’s history is shown

  • Dimensionality must be sufficiently high to generate relevant information and create a rich history of states over time, but also low enough to be easily understandable

• Tolerance threshold, r

  • Tolerance for accepting similar patterns

Visualize Embedding

This is how a typical sinusoidal signal looks like, when embedded in 2D and 3D respectively.

Using NeuroKit

There are different methods to guide the choice of parameters. In NeuroKit, you can use nk.complexity_optimize() to estimate the optimal parameters, including time delay, embedding dimension and tolerance threshold.

import neurokit2 as nk

signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)
parameters = nk.complexity_optimize(signal, show=True)

parameters
>>> {'delay': 13, 'dimension': 6, 'r': 0.014}

In the above example, the optimal time delay is estimated using the Mutual Information method (Fraser & Swinney, 1986), the optimal embedding dimension is estimated using the Average False Nearest Neighbour (Cao, 1997) and the optimal r is obtained using the Maximum Approximate Entropy (Lu et al., 2008). These are the default methods in nk.complexity_optimize(). Nevertheless, you can specify your preferred method via the method arguments.

More of these methods can be read about in this chapter here.

Entropy as measures of Complexity

The complexity of physiological signals can be represented by the entropy of these non-linear, dynamic physiological systems.

Entropy can be defined as the measure of disorder in a signal.

Shannon Entropy (ShEn)

• call nk.entropy_shannon()

Approximate Entropy (ApEn)

• Quantifies the amount of regularity and the unpredictability of fluctuations over time-series data.

• Advantages of ApEn: lower computational demand (can be designed to work for small data samples i.e. less than 50 data points and can be applied in real time) and less sensitive to noise.

• Smaller values indicate that the data is more regular and predictable, and larger values corresponding to more complexity or irregularity in the data.

• call nk.entropy_approximate()

Examples of use

Reference	Signal	Parameters	Findings
Caldirola et al. (2004)	17min breath-by-breath recordings of respiration parameters	m=1, r=0.2	Panic disorder patients showed higher ApEn indexes in baseline RSP patterns (all parameters) than healthy subjects
Burioka et al. (2003)	30 mins of Respiration, 20s recordings of EEG	m=2, r=0.2, τ=1.1s for respiration, 0.09s for EEG	Lower ApEn of respiratory movement and EEG in stage IV sleep than other stages of consciousness
Boettger et al. (2009)	64s recordings of QT and RR intervals	m=2, r=0.2	Higher ratio of ApEn(QT) to ApEn(RR) for higher intensities of exercise, reflecting sympathetic activity
Taghavi et al. (2011)	2mis recordings of EEG	m=2, r=0.1	Higher ApEn of normal subjects than schizophrenic patients particularly in limbic areas of the brain

Sample Entropy (SampEn)

• A modification of approximate entropy

• Advantages over ApEn: data length independence and a relatively trouble-free implementation.

• Large values indicate high complexity whereas smaller values characterize more self-similar and regular signals.

• call nk.entropy_sample()

Examples of use

Reference	Signal	Parameters	Findings
Lake et al. (2002)	25min recordings of RR intervals	m=3, r=0.2	SampEn is lower in the course of neonatal sepsis and sepsislike illness
Lake et al. (2011)	24h recordings of RR intervals	m=1, r=to vary	In patients over 4o years old, SampEn has high degrees of accuracy in distinguishing atrial fibrillation from normal sinus rhythm in 12-beat calculations performed hourly
Estrada et al. (2015)	EMG diaphragm signal	m=1, r=0.3	fSampEn (fixed SampEn) method to extract RSP rate from respiratory EMG signal
Kapidzic et al. (2014)	RR intervals and its corresponding RSP signal	m=2, r=0.2	During paced breathing, significant reduction of SampEn(Resp) and SampEn(RR) with age in male subjects, compared to smaller and nonsignificant SampEn decrease in females
Abásolo et al. (2006)	5min recordings of EEG in 5 second epochs	m=1, r=0.25	Alzheimer’s Disease patients had lower SampEn than controls in parietal and occipital regions

Fuzzy Entropy (FuzzyEn)

• Similar to ApEn and SampEn

• call nk.entropy_fuzzy()

Multiscale Entropy (MSE)

• Expresses different levels of either ApEn or SampEn by means of multiple factors for generating multiple time series

• Captures more useful information than using a scalar value produced by ApEn and SampEn

• call nk.entropy_multiscale()

Detrended Fluctuation Analysis (DFA)

Analyze Electrooculography EOG data (eye blinks, saccades, etc.)

# This is temporary to load the dev version of NK, needs to be removed once it's in master
import os
os.chdir('D:/Dropbox/RECHERCHE/N/NeuroKit/')
# -----------------------
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import neurokit2 as nk

plt.rcParams['figure.figsize'] = [14, 8]  # Increase plot size

Explore the EOG signal

Let’s load the example dataset corresponding to a vertical EOG signal.

eog_signal = pd.read_csv("data/eog_100hz.csv")
eog_signal = nk.as_vector(eog_signal)  # Extract the only column as a vector
nk.signal_plot(eog_signal)

Let’s zoom in to some areas where clear blinks are present.

nk.signal_plot(eog_signal[100:1700])

Clean the signal

We can now filter the signal to remove some noise and trends.

eog_cleaned = nk.eog_clean(eog_signal, sampling_rate=100, method='neurokit')

Let’s visualize the same chunk and compare the clean version with the original signal.

nk.signal_plot([eog_signal[100:1700], eog_cleaned[100:1700]])

Detect and visualize eye blinks

We will nor run a peak detection algorithm to detect peaks location.

blinks = nk.eog_findpeaks(eog_cleaned, sampling_rate=100, method="mne")
blinks

array([  277,   430,   562,   688,   952,  1378,  1520,  1752,  3353,
        3783,  3928,  4031,  4168,  4350,  4723,  4878,  5213,  5365,
        5699,  5904,  6312,  6539,  6714,  7224,  7382,  7553,  7827,
        8014,  8154,  8312,  8626,  8702,  9140,  9425,  9741,  9948,
       10142, 10230, 10368, 10708, 10965, 11256, 11683, 11775],
      dtype=int64)

events = nk.epochs_create(eog_cleaned, blinks, sampling_rate=100, epochs_start=-0.3, epochs_end=0.7)

data = nk.epochs_to_array(events)  # Convert to 2D array
data = nk.standardize(data)  # Rescale so that all the blinks are on the same scale

# Plot with their median (used here as a robust average)
plt.plot(data, linewidth=0.4)
plt.plot(np.median(data, axis=1), linewidth=3, linestyle='--', color="black")

[<matplotlib.lines.Line2D at 0x18fc51f7e50>]

Fit a function to a signal

This small tutorial will show you how to use Python to estimate the best fitting line to some data. This can be used to find the optimal line passing through a signal.

# Load packages
import numpy as np
import pandas as pd
import scipy.optimize
import matplotlib.pyplot as plt
import neurokit2 as nk

plt.rcParams['figure.figsize'] = [14, 8]  # Increase plot size

Fit a linear function

We will start by generating some random data on a scale from 0 to 10 (the x-axis), and then pass them through a function to create its y values.

x = np.random.uniform(0., 10., size=100)
y = 3. * x + 2. + np.random.normal(0., 10., 100)
plt.plot(x, y, '.')

[<matplotlib.lines.Line2D at 0x2137926a4f0>]

No in this case we know that the best fitting line will be a linear function (i.e., a straight line), and we want to find its parameters. A linear function has two parameters, the intercept and the slope.

First, we need to create this function, that takes some x values, the parameters, and return the y value.

def function_linear(x, intercept, slope):
    y =  intercept + slope * x
    return y

Now, using the power of scipy, we can optimize this function based on our data to find the parameters that minimize the least square error. It just needs the function and the data’s x and y values.

params, covariance = scipy.optimize.curve_fit(function_linear, x, y)
params

array([5.16622964, 2.46102004])

So the optimal parameters (in our case, the intercept and the slope) are returned in the params object. We can unpack these parameters (using the star symbol *) into our linear function to use them, and create the predicted y values to our x axis.

fit = function_linear(x, *params)

plt.plot(x, y, '.')
plt.plot(x, fit, '-')

[<matplotlib.lines.Line2D at 0x21379293370>]

Non-linear curves

We can also use that to approximate non-linear curves.

signal = nk.eda_simulate(sampling_rate=50)
nk.signal_plot(signal)

In this example, we will try to approximate this Skin Conductance Response (SCR) using a gamma distribution, which is quite a flexible distribution defined by 3 parameters (a, loc and scale).

On top of these 3 parameters, we will add 2 more, the intercept and a size parameter to give it more flexibility.

def function_gamma(x, intercept, size, a, loc, scale):
    gamma = scipy.stats.gamma.pdf(x, a=a, loc=loc, scale=scale)
    y = intercept + (size * gamma)
    return y

We can start by visualizing the function with a “arbitrary” parameters:

x = np.linspace(0, 20, num=500)
y = function_gamma(x, intercept=1, size=1, a=3, loc=0.5, scale=0.33)

nk.signal_plot(y)

Since these values are already a good start, we will use them as “starting point” (through the p0 argument), to help the estimation algorithm converge (otherwise it could never find the right combination of parameters).

params, covariance = scipy.optimize.curve_fit(function_gamma, x, signal, p0=[1, 1, 3, 0.5, 0.33])
params

array([0.9518406 , 2.21035698, 1.05863983, 2.16432609, 1.97046573])

fit = function_gamma(x, *params)

plt.plot(x, signal, '.')
plt.plot(x, fit, '-')

[<matplotlib.lines.Line2D at 0x2137cf92f40>]

Resources

Contents:

Recording good quality signals

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing (see this tutorial).

This tutorial is a work in progress.

Recording

• Electrocardiogram (ECG) electrodes placement

• Facial EMG electrodes placement

• RSP belt placement

• Best Practices for Collecting Physiological Data

Signal quality

• Improving Data Quality of ECG

• Improving Data Quality of EDA

Artifacts and Anomalies

• Identifying and Handling Cardiac Arrhythmia

What software for physiological signal processing

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing (see this tutorial).

If you’re here, it’s probably that you have (or plan to have) some physiological data (aka biosignals, e.g., ECG for cardiac activity, RSP for respiration, EDA for electrodermal activity, EMG for muscle activity etc.), that you plan to process and analyze these signals and that you don’t know where to start. Whether you are an undergrad, a master or PhD student, a postdoc or a full professor, you’re at the right place.

So let’s discuss a few things to consider to best decide on your options.

Software vs. programming language (packages)

In this context, a software would be a program that you download, install (through some sort of .exe file), and start similarly to most of the other programs installed on our computers.

They are appealing because of their (apparent) simplicity and familiarity of usage: you can click on icons and menus and you can see all the available options, which makes it easy for exploration. In a way, it also feels safe, because you can always close the software, press “do not save the changes”, and start again.

Unfortunately, when it comes to science, this comes with a set of limitations; they are in general quite expensive, are limited to the set of included features (it’s not easy to use one feature from one software, and then another from another one), have a slow pace of updates (and thus often don’t include the most recent and cutting-edge algorithms, but rather well-established ones), and are not open-source (and thus prevent to run fully reproducible analyses).

• Software for biosignals processing

  • AcqKnowledge: General physiological analysis software (ECG, PPG, RSP, EDA, EMG, …).

  • Kubios: Heart-rate variability (HRV).

Unfortunately, it’s the prefered option for many researchers. Why? For PIs, it’s usually because they are established tools backed by some sort of company behind them, with experts, advertisers and sellers that do their job well. The companies also offer some guaranty in terms of training, updates, issues troubleshooting, etc. For younger researchers starting with physiological data analysis, it’s usually because they don’t have much (or any) experience with programming languages. They feel like there is already a lot of things to learn on the theorethical side of physiological signal processing, so they don’t want to add on top of that, learning a programming language.

However, it is important to understand that you don’t necessarily have to know how to code to use some of the packages. Moreover, some of them include a GUI (see below), which makes them very easy to use and a great alternative to the software mentioned above.

Note

TLDR; Closed proprietary software, even though seemlingly appealing, might not a good investement of time or money.

GUI vs. code

TODO.

• Packages with a GUI

  • Ledalab: EDA (Matlab).

  • PsPM: Primarly EDA (Matlab).

  • biopeaks: ECG, PPG (Python).

  • mnelab: EEG (Python).

Note

TLDR; While GUIs can be good alternatives and a first step to dive into programming language-based tools, coding will provide you with more freedom, incredible power and the best fit possible for your data and issues.

Matlab vs. Python vs. R vs. Julia

What is the best programming language for physiological data analysis?

Matlab is the historical main contender. However… TODO.

• Python-based packages

  • NeuroKit2: ECG, PPG, RSP, EDA, EMG.

  • BioSPPy: ECG, RSP, EDA, EMG.

  • PySiology: ECG, EDA, EMG.

  • pyphysio: ECG, PPG, EDA.

  • HeartPy: ECG.

  • hrv: ECG.

  • hrv-analysis: ECG.

  • pyhrv: ECG.

  • py-ecg-detectors: ECG.

  • Systole: PPG.

  • eda-explorer: EDA.

  • Pypsy: EDA.

  • MNE: EEG.

  • tensorpac: EEG.

  • PyGaze: Eye-tracking.

  • PyTrack: Eye-tracking.

• Matlab-based packages

  • BreatheEasyEDA: EDA.

  • EDA: EDA.

  • unfold: EEG.

Additional Resources

Hint

Would like to add something? Join us by contributing (see this tutorial).

General Neuroimaging

• Seven quick tips for analysis scripts in neuroimaging (van Vliet, 2020).

• Neuroimaging tutorials and resources

ECG

• Improving Data Quality: ECG

• Understanding ECG waves

• Analysing a Noisy ECG Signal

• All About HRV Part 4: Respiratory Sinus Arrhythmia

EDA

• Improving Data Quality: EDA

• All About EDA Part 1: Introduction to Electrodermal Activity

• All About EDA Part 2: Components of Skin Conductance

• Skin Conductance Response – What it is and How to Measure it

EEG

• Electroencephalogram (EEG) Recording Protocol (Farrens et al., 2019)

• Compute the average bandpower of an EEG signal

Functions

ECG

Submodule for NeuroKit.

ecg_analyze(data, sampling_rate=1000, method='auto')

Performs ECG analysis on either epochs (event-related analysis) or on longer periods of data such as resting- state data.

Parameters

• data (Union[dict, pd.DataFrame]) – A dictionary of epochs, containing one DataFrame per epoch, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df(). Can also take a DataFrame of processed signals from a longer period of data, typically generated by ecg_process() or bio_process(). Can also take a dict containing sets of separate periods of data.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second). Defaults to 1000Hz.

• method (str) – Can be one of ‘event-related’ for event-related analysis on epochs, or ‘interval-related’ for analysis on longer periods of data. Defaults to ‘auto’ where the right method will be chosen based on the mean duration of the data (‘event-related’ for duration under 10s).

Returns

DataFrame – A dataframe containing the analyzed ECG features. If event-related analysis is conducted, each epoch is indicated by the Label column. See ecg_eventrelated() and ecg_intervalrelated() docstrings for details.

See also

bio_process(), ecg_process(), epochs_create(), ecg_eventrelated(), ecg_intervalrelated()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example 1: Download the data for event-related analysis
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data for event-related analysis
>>> df, info = nk.bio_process(ecg=data["ECG"], sampling_rate=100)
>>> events = nk.events_find(data["Photosensor"], threshold_keep='below',
...                         event_conditions=["Negative", "Neutral",
...                                           "Neutral", "Negative"])
>>> epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-0.1, epochs_end=1.9)
>>>
>>> # Analyze
>>> nk.ecg_analyze(epochs, sampling_rate=100) 
  Label Condition  ...  ECG_Phase_Completion_Ventricular  ECG_Quality_Mean
1     1  Negative  ...                               ...              ...
2     2   Neutral  ...                               ...              ...
3     3   Neutral  ...                               ...              ...
4     4  Negative  ...                               ...              ...

[4 rows x 17 columns] >>> >>> # Example 2: Download the resting-state data >>> data = nk.data(“bio_resting_5min_100hz”) >>> >>> # Process the data >>> df, info = nk.ecg_process(data[“ECG”], sampling_rate=100) >>> >>> # Analyze >>> nk.ecg_analyze(df, sampling_rate=100) #doctest: +ELLIPSIS

ECG_Rate_Mean HRV_RMSSD …

0 …

[1 rows x 37 columns]

ecg_clean(ecg_signal, sampling_rate=1000, method='neurokit')

Clean an ECG signal.

Prepare a raw ECG signal for R-peak detection with the specified method.

Parameters

• ecg_signal (Union[list, np.array, pd.Series]) – The raw ECG channel.

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to 1000.

• method (str) – The processing pipeline to apply. Can be one of ‘neurokit’ (default), ‘biosppy’, ‘pamtompkins1985’, ‘hamilton2002’, ‘elgendi2010’, ‘engzeemod2012’.

Returns

array – Vector containing the cleaned ECG signal.

See also

ecg_findpeaks(), signal_rate(), ecg_process(), ecg_plot()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>> import matplotlib.pyplot as plt
>>>
>>> ecg = nk.ecg_simulate(duration=10, sampling_rate=1000)
>>> signals = pd.DataFrame({"ECG_Raw" : ecg,
...                         "ECG_NeuroKit" : nk.ecg_clean(ecg, sampling_rate=1000, method="neurokit"),
...                         "ECG_BioSPPy" : nk.ecg_clean(ecg, sampling_rate=1000, method="biosppy"),
...                         "ECG_PanTompkins" : nk.ecg_clean(ecg, sampling_rate=1000, method="pantompkins1985"),
...                         "ECG_Hamilton" : nk.ecg_clean(ecg, sampling_rate=1000, method="hamilton2002"),
...                         "ECG_Elgendi" : nk.ecg_clean(ecg, sampling_rate=1000, method="elgendi2010"),
...                         "ECG_EngZeeMod" : nk.ecg_clean(ecg, sampling_rate=1000, method="engzeemod2012")})
 >>> signals.plot() 
 <matplotlib.axes._subplots.AxesSubplot object at ...>

References

• Jiapu Pan and Willis J. Tompkins. A Real-Time QRS Detection Algorithm. In: IEEE Transactions on Biomedical Engineering BME-32.3 (1985), pp. 230–236.

• Hamilton, Open Source ECG Analysis Software Documentation, E.P.Limited, 2002.

ecg_delineate(ecg_cleaned, rpeaks=None, sampling_rate=1000, method='peak', show=False, show_type='peaks', check=False)

Delineate QRS complex.

Function to delineate the QRS complex.

• Cardiac Cycle: A typical ECG heartbeat consists of a P wave, a QRS complex and a T wave. The P wave represents the wave of depolarization that spreads from the SA-node throughout the atria. The QRS complex reflects the rapid depolarization of the right and left ventricles. Since the ventricles are the largest part of the heart, in terms of mass, the QRS complex usually has a much larger amplitude than the P-wave. The T wave represents the ventricular repolarization of the ventricles.On rare occasions, a U wave can be seen following the T wave. The U wave is believed to be related to the last remnants of ventricular repolarization.

Parameters

• ecg_cleaned (Union[list, np.array, pd.Series]) – The cleaned ECG channel as returned by ecg_clean().

• rpeaks (Union[list, np.array, pd.Series]) – The samples at which R-peaks occur. Accessible with the key “ECG_R_Peaks” in the info dictionary returned by ecg_findpeaks().

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to 500.

• method (str) – Can be one of ‘peak’ (default) for a peak-based method, ‘cwt’ for continuous wavelet transform or ‘dwt’ for discrete wavelet transform.

• show (bool) – If True, will return a plot to visualizing the delineated waves information.

• show_type (str) – The type of delineated waves information showed in the plot.

• check (bool) – Defaults to False.

Returns

• waves (dict) – A dictionary containing additional information. For derivative method, the dictionary contains the samples at which P-peaks, Q-peaks, S-peaks, T-peaks, P-onsets and T-offsets occur, accessible with the key “ECG_P_Peaks”, “ECG_Q_Peaks”, “ECG_S_Peaks”, “ECG_T_Peaks”, “ECG_P_Onsets”, “ECG_T_Offsets” respectively.

  For wavelet methods, the dictionary contains the samples at which P-peaks, T-peaks, P-onsets, P-offsets, T-onsets, T-offsets, QRS-onsets and QRS-offsets occur, accessible with the key “ECG_P_Peaks”, “ECG_T_Peaks”, “ECG_P_Onsets”, “ECG_P_Offsets”, “ECG_T_Onsets”, “ECG_T_Offsets”, “ECG_R_Onsets”, “ECG_R_Offsets” respectively.

• signals (DataFrame) – A DataFrame of same length as the input signal in which occurences of peaks, onsets and offsets marked as “1” in a list of zeros.

See also

ecg_clean(), signal_fixpeaks(), ecg_peaks(), signal_rate(), ecg_process(), ecg_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=10, sampling_rate=1000)
>>> cleaned = nk.ecg_clean(ecg, sampling_rate=1000)
>>> _, rpeaks = nk.ecg_peaks(cleaned)
>>> signals, waves = nk.ecg_delineate(cleaned, rpeaks, sampling_rate=1000, method="peak")
>>> nk.events_plot(waves["ECG_P_Peaks"], cleaned) 
<Figure ...>
>>> nk.events_plot(waves["ECG_T_Peaks"], cleaned) 
<Figure ...>

References

• Martínez, J. P., Almeida, R., Olmos, S., Rocha, A. P., & Laguna, P. (2004). A wavelet-based ECG delineator: evaluation on standard databases. IEEE Transactions on biomedical engineering, 51(4), 570-581.

ecg_eventrelated(epochs, silent=False)

Performs event-related ECG analysis on epochs.

Parameters

• epochs (Union[dict, pd.DataFrame]) – A dict containing one DataFrame per event/trial, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df().

• silent (bool) – If True, silence possible warnings.

Returns

DataFrame – A dataframe containing the analyzed ECG features for each epoch, with each epoch indicated by the Label column (if not present, by the Index column). The analyzed features consist of the following:

• ”ECG_Rate_Max”: the maximum heart rate after stimulus onset.

• ”ECG_Rate_Min”: the minimum heart rate after stimulus onset.

• ”ECG_Rate_Mean”: the mean heart rate after stimulus onset.

• ”ECG_Rate_Max_Time”: the time at which maximum heart rate occurs.

• ”ECG_Rate_Min_Time”: the time at which minimum heart rate occurs.

• ”ECG_Phase_Atrial”: indication of whether the onset of the event concurs with respiratory systole (1) or diastole (0).

• ”ECG_Phase_Ventricular”: indication of whether the onset of the event concurs with respiratory systole (1) or diastole (0).

• ”ECG_Phase_Atrial_Completion”: indication of the stage of the current cardiac (atrial) phase (0 to 1) at the onset of the event.

• ”ECG_Phase_Ventricular_Completion”: indication of the stage of the current cardiac (ventricular) phase (0 to 1) at the onset of the event.

We also include the following experimental features related to the parameters of a quadratic model:

• ”ECG_Rate_Trend_Linear”: The parameter corresponding to the linear trend.

• ”ECG_Rate_Trend_Quadratic”: The parameter corresponding to the curvature.

• ”ECG_Rate_Trend_R2”: the quality of the quadratic model. If too low, the parameters might not be reliable or meaningful.

See also

events_find(), epochs_create(), bio_process()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example with simulated data
>>> ecg, info = nk.ecg_process(nk.ecg_simulate(duration=20))
>>>
>>> # Process the data
>>> epochs = nk.epochs_create(ecg, events=[5000, 10000, 15000],
...                           epochs_start=-0.1, epochs_end=1.9)
>>> nk.ecg_eventrelated(epochs) 
  Label  Event_Onset  ...  ECG_Phase_Completion_Ventricular  ECG_Quality_Mean
1     1          ...  ...                               ...               ...
2     2          ...  ...                               ...               ...
3     3          ...  ...                               ...               ...

[3 rows x 16 columns] >>> >>> # Example with real data >>> data = nk.data(“bio_eventrelated_100hz”) >>> >>> # Process the data >>> df, info = nk.bio_process(ecg=data[“ECG”], sampling_rate=100) >>> events = nk.events_find(data[“Photosensor”], … threshold_keep=’below’, … event_conditions=[“Negative”, “Neutral”, … “Neutral”, “Negative”]) >>> epochs = nk.epochs_create(df, events, sampling_rate=100, … epochs_start=-0.1, epochs_end=1.9) >>> nk.ecg_eventrelated(epochs) #doctest: +ELLIPSIS

Label Condition … ECG_Phase_Completion_Ventricular ECG_Quality_Mean

1 1 Negative … … … 2 2 Neutral … … … 3 3 Neutral … … … 4 4 Negative … … …

[4 rows x 17 columns]

ecg_findpeaks(ecg_cleaned, sampling_rate=1000, method='neurokit', show=False)

Find R-peaks in an ECG signal.

Low-level function used by ecg_peaks() to identify R-peaks in an ECG signal using a different set of algorithms. See ecg_peaks() for details.

Parameters

• ecg_cleaned (Union[list, np.array, pd.Series]) – The cleaned ECG channel as returned by ecg_clean().

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to 1000.

• method (string) – The algorithm to be used for R-peak detection. Can be one of ‘neurokit’ (default), ‘pamtompkins1985’, ‘hamilton2002’, ‘christov2004’, ‘gamboa2008’, ‘elgendi2010’, ‘engzeemod2012’, ‘kalidas2017’, ‘martinez2003’, ‘rodrigues2020’ or ‘promac’.

• show (bool) – If True, will return a plot to visualizing the thresholds used in the algorithm. Useful for debugging.

Returns

info (dict) – A dictionary containing additional information, in this case the samples at which R-peaks occur, accessible with the key “ECG_R_Peaks”.

See also

ecg_clean(), signal_fixpeaks(), ecg_peaks(), ecg_rate(), ecg_process(), ecg_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=10, sampling_rate=1000)
>>> cleaned = nk.ecg_clean(ecg, sampling_rate=1000)
>>> info = nk.ecg_findpeaks(cleaned)
>>> nk.events_plot(info["ECG_R_Peaks"], cleaned) 
<Figure ...>

>>>
>>> # Different methods
>>> neurokit = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="neurokit"), method="neurokit")
>>> pantompkins1985 = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="pantompkins1985"), method="pantompkins1985")
>>> hamilton2002 = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="hamilton2002"), method="hamilton2002")
>>> martinez2003 = nk.ecg_findpeaks(cleaned, method="martinez2003")
>>> christov2004 = nk.ecg_findpeaks(cleaned, method="christov2004")
>>> gamboa2008 = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="gamboa2008"), method="gamboa2008")
>>> elgendi2010 = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="elgendi2010"), method="elgendi2010")
>>> engzeemod2012 = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="engzeemod2012"), method="engzeemod2012")
>>> kalidas2017 = nk.ecg_findpeaks(nk.ecg_clean(ecg, method="kalidas2017"), method="kalidas2017")
>>> rodrigues2020 = nk.ecg_findpeaks(cleaned, method="rodrigues2020")
>>>
>>> # Visualize
>>> nk.events_plot([neurokit["ECG_R_Peaks"],
...                       pantompkins1985["ECG_R_Peaks"],
...                       hamilton2002["ECG_R_Peaks"],
...                       christov2004["ECG_R_Peaks"],
...                       gamboa2008["ECG_R_Peaks"],
...                       elgendi2010["ECG_R_Peaks"],
...                       engzeemod2012["ECG_R_Peaks"],
...                       kalidas2017["ECG_R_Peaks"],
...                       martinez2003["ECG_R_Peaks"],
...                       rodrigues2020["ECG_R_Peaks"]], cleaned) 
<Figure ...>
>>>
>>> # Method-agreement
>>> ecg = nk.ecg_simulate(duration=10, sampling_rate=500)
>>> ecg = nk.signal_distort(ecg,
...                         sampling_rate=500,
...                         noise_amplitude=0.2, noise_frequency=[25, 50],
...                         artifacts_amplitude=0.2, artifacts_frequency=50)
>>> nk.ecg_findpeaks(ecg, sampling_rate=1000, method="promac", show=True) 
{'ECG_R_Peaks': array(...)}

References

• Gamboa, H. (2008). Multi-modal behavioral biometrics based on hci and electrophysiology. PhD ThesisUniversidade.

• Zong, W., Heldt, T., Moody, G. B., & Mark, R. G. (2003, September). An open-source algorithm to detect onset of arterial blood pressure pulses. In Computers in Cardiology, 2003 (pp. 259-262). IEEE.

• Hamilton, Open Source ECG Analysis Software Documentation, E.P.Limited, 2002.

• Pan, J., & Tompkins, W. J. (1985). A real-time QRS detection algorithm. IEEE transactions on biomedical engineering, (3), 230-236.

• Engelse, W. A. H., & Zeelenberg, C. (1979). A single scan algorithm for QRS detection and feature extraction IEEE Comput Cardiol. Long Beach: IEEE Computer Society.

• Lourenço, A., Silva, H., Leite, P., Lourenço, R., & Fred, A. L. (2012, February). Real Time Electrocardiogram Segmentation for Finger based ECG Biometrics. In Biosignals (pp. 49-54).

ecg_intervalrelated(data, sampling_rate=1000)

Performs ECG analysis on longer periods of data (typically > 10 seconds), such as resting-state data.

Parameters

• data (Union[dict, pd.DataFrame]) – A DataFrame containing the different processed signal(s) as different columns, typically generated by ecg_process() or bio_process(). Can also take a dict containing sets of separately processed DataFrames.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

Returns

DataFrame – A dataframe containing the analyzed ECG features. The analyzed features consist of the following:

• ”ECG_Rate_Mean”: the mean heart rate.

• ”ECG_HRV”: the different heart rate variability metrices.

See hrv_summary() docstrings for details.

See also

bio_process(), ecg_eventrelated()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Process the data
>>> df, info = nk.ecg_process(data["ECG"], sampling_rate=100)
>>>
>>> # Single dataframe is passed
>>> nk.ecg_intervalrelated(df, sampling_rate=100) 
   ECG_Rate_Mean  HRV_RMSSD  ...
0      ...

[1 rows x 55 columns] >>> >>> epochs = nk.epochs_create(df, events=[0, 15000], sampling_rate=100, … epochs_end=150) >>> nk.ecg_intervalrelated(epochs) #doctest: +ELLIPSIS

ECG_Rate_Mean HRV_RMSSD …

1 …

[2 rows x 55 columns]

ecg_peaks(ecg_cleaned, sampling_rate=1000, method='neurokit', correct_artifacts=False)

Find R-peaks in an ECG signal.

Find R-peaks in an ECG signal using the specified method.

Parameters

• ecg_cleaned (Union[list, np.array, pd.Series]) – The cleaned ECG channel as returned by ecg_clean().

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to 1000.

• method (string) – The algorithm to be used for R-peak detection. Can be one of ‘neurokit’ (default), ‘pamtompkins1985’, ‘hamilton2002’, ‘christov2004’, ‘gamboa2008’, ‘elgendi2010’, ‘engzeemod2012’ or ‘kalidas2017’.

• correct_artifacts (bool) – Whether or not to identify artifacts as defined by Jukka A. Lipponen & Mika P. Tarvainen (2019): A robust algorithm for heart rate variability time series artefact correction using novel beat classification, Journal of Medical Engineering & Technology, DOI: 10.1080/03091902.2019.1640306.

Returns

• signals (DataFrame) – A DataFrame of same length as the input signal in which occurences of R-peaks marked as “1” in a list of zeros with the same length as ecg_cleaned. Accessible with the keys “ECG_R_Peaks”.

• info (dict) – A dictionary containing additional information, in this case the samples at which R-peaks occur, accessible with the key “ECG_R_Peaks”.

See also

ecg_clean(), ecg_findpeaks(), ecg_process(), ecg_plot(), signal_rate(), signal_fixpeaks()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=10, sampling_rate=1000)
>>> cleaned = nk.ecg_clean(ecg, sampling_rate=1000)
>>> signals, info = nk.ecg_peaks(cleaned, correct_artifacts=True)
>>> nk.events_plot(info["ECG_R_Peaks"], cleaned) 
<Figure ...>

References

• Gamboa, H. (2008). Multi-modal behavioral biometrics based on hci and electrophysiology. PhD ThesisUniversidade.

• W. Zong, T. Heldt, G.B. Moody, and R.G. Mark. An open-source algorithm to detect onset of arterial blood pressure pulses. In Computers in Cardiology, 2003, pages 259–262, 2003.

• Hamilton, Open Source ECG Analysis Software Documentation, E.P.Limited, 2002.

• Jiapu Pan and Willis J. Tompkins. A Real-Time QRS Detection Algorithm. In: IEEE Transactions on Biomedical Engineering BME-32.3 (1985), pp. 230–236.

• C. Zeelenberg, A single scan algorithm for QRS detection and feature extraction, IEEE Comp. in Cardiology, vol. 6, pp. 37-42, 1979

• A. Lourenco, H. Silva, P. Leite, R. Lourenco and A. Fred, “Real Time Electrocardiogram Segmentation for Finger Based ECG Biometrics”, BIOSIGNALS 2012, pp. 49-54, 2012.

ecg_phase(ecg_cleaned, rpeaks=None, delineate_info=None, sampling_rate=None)

Compute cardiac phase (for both atrial and ventricular).

Finds the cardiac phase, labelled as 1 for systole and 0 for diastole.

Parameters

• ecg_cleaned (Union[list, np.array, pd.Series]) – The cleaned ECG channel as returned by ecg_clean().

• rpeaks (list or array or DataFrame or Series or dict) – The samples at which the different ECG peaks occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with ecg_findpeaks() or ecg_peaks().

• delineate_info (dict) – A dictionary containing additional information of ecg delineation and can be obtained with ecg_delineate().

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to None.

Returns

signals (DataFrame) – A DataFrame of same length as ecg_signal containing the following columns:

• ”ECG_Phase_Atrial”: cardiac phase, marked by “1” for systole and “0” for diastole.

• ”ECG_Phase_Completion_Atrial”: cardiac phase (atrial) completion, expressed in percentage (from 0 to 1), representing the stage of the current cardiac phase.

• ”ECG_Phase_Ventricular”: cardiac phase, marked by “1” for systole and “0” for diastole.

• ”ECG_Phase_Completion_Ventricular”: cardiac phase (ventricular) completion, expressed in percentage (from 0 to 1), representing the stage of the current cardiac phase.

See also

ecg_clean(), ecg_peaks(), ecg_process(), ecg_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=10, sampling_rate=1000)
>>> cleaned = nk.ecg_clean(ecg, sampling_rate=1000)
>>> _, rpeaks = nk.ecg_peaks(cleaned)
>>> signals, waves = nk.ecg_delineate(cleaned, rpeaks, sampling_rate=1000)
>>>
>>> cardiac_phase = nk.ecg_phase(ecg_cleaned=cleaned, rpeaks=rpeaks,
...                              delineate_info=waves, sampling_rate=1000)
>>> nk.signal_plot([cleaned, cardiac_phase], standardize=True) 

ecg_plot(ecg_signals, rpeaks=None, sampling_rate=None, show_type='default')

Visualize ECG data.

Parameters

• ecg_signals (DataFrame) – DataFrame obtained from ecg_process().

• rpeaks (dict) – The samples at which the R-peak occur. Dict returned by ecg_process(). Defaults to None.

• sampling_rate (int) – The sampling frequency of the ECG (in Hz, i.e., samples/second). Needs to be supplied if the data should be plotted over time in seconds. Otherwise the data is plotted over samples. Defaults to None. Must be specified to plot artifacts.

• show_type (str) – Visualize the ECG data with ‘default’ or visualize artifacts thresholds with ‘artifacts’ produced by ecg_fixpeaks(), or ‘full’ to visualize both.

Returns

fig – Figure representing a plot of the processed ecg signals (and peak artifacts).

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=15, sampling_rate=1000, heart_rate=80)
>>> signals, info = nk.ecg_process(ecg, sampling_rate=1000)
>>> nk.ecg_plot(signals, sampling_rate=1000, show_type='default') 
<Figure ...>

See also

ecg_process()

ecg_process(ecg_signal, sampling_rate=1000, method='neurokit')

Process an ECG signal.

Convenience function that automatically processes an ECG signal.

Parameters

• ecg_signal (Union[list, np.array, pd.Series]) – The raw ECG channel.

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to 1000.

• method (str) – The processing pipeline to apply. Defaults to “neurokit”.

Returns

• signals (DataFrame) – A DataFrame of the same length as the ecg_signal containing the following columns:

  • ”ECG_Raw”: the raw signal.

  • ”ECG_Clean”: the cleaned signal.

  • ”ECG_R_Peaks”: the R-peaks marked as “1” in a list of zeros.

  • ”ECG_Rate”: heart rate interpolated between R-peaks.

  • ”ECG_P_Peaks”: the P-peaks marked as “1” in a list of zeros

  • ”ECG_Q_Peaks”: the Q-peaks marked as “1” in a list of zeros .

  • ”ECG_S_Peaks”: the S-peaks marked as “1” in a list of zeros.

  • ”ECG_T_Peaks”: the T-peaks marked as “1” in a list of zeros.

  • ”ECG_P_Onsets”: the P-onsets marked as “1” in a list of zeros.

  • ”ECG_P_Offsets”: the P-offsets marked as “1” in a list of zeros

    (only when method in ecg_delineate is wavelet).

  • ”ECG_T_Onsets”: the T-onsets marked as “1” in a list of zeros

    (only when method in ecg_delineate is wavelet).

  • ”ECG_T_Offsets”: the T-offsets marked as “1” in a list of zeros.

  • ”ECG_R_Onsets”: the R-onsets marked as “1” in a list of zeros

    (only when method in ecg_delineate is wavelet).

  • ”ECG_R_Offsets”: the R-offsets marked as “1” in a list of zeros

    (only when method in ecg_delineate is wavelet).

  • ”ECG_Phase_Atrial”: cardiac phase, marked by “1” for systole and “0” for diastole.

  • ”ECG_Phase_Ventricular”: cardiac phase, marked by “1” for systole and “0” for diastole.

  • ”ECG_Atrial_PhaseCompletion”: cardiac phase (atrial) completion, expressed in percentage (from 0 to 1), representing the stage of the current cardiac phase.

  • ”ECG_Ventricular_PhaseCompletion”: cardiac phase (ventricular) completion, expressed in percentage (from 0 to 1), representing the stage of the current cardiac phase.

• info (dict) – A dictionary containing the samples at which the R-peaks occur, accessible with the key “ECG_Peaks”.

See also

ecg_clean(), ecg_findpeaks(), ecg_plot(), signal_rate(), signal_fixpeaks()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=15, sampling_rate=1000, heart_rate=80)
>>> signals, info = nk.ecg_process(ecg, sampling_rate=1000)
>>> nk.ecg_plot(signals) 
<Figure ...>

ecg_quality(ecg_cleaned, rpeaks=None, sampling_rate=1000)

Quality of ECG Signal.

Compute a continuous index of quality of the ECG signal, by interpolating the distance of each QRS segment from the average QRS segment present in the data. This index is therefore relative, and 1 corresponds to heartbeats that are the closest to the average sample and 0 corresponds to the most distance heartbeat, from that average sample.

Returns

array – Vector containing the quality index ranging from 0 to 1.

See also

ecg_segment(), ecg_delineate()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=30, sampling_rate=300, noise=0.2)
>>> ecg_cleaned = nk.ecg_clean(ecg, sampling_rate=300)
>>> quality = nk.ecg_quality(ecg_cleaned, sampling_rate=300)
>>>
>>> nk.signal_plot([ecg_cleaned, quality], standardize=True)

ecg_rate(peaks, sampling_rate=1000, desired_length=None, interpolation_method='monotone_cubic')

Calculate signal rate from a series of peaks.

This function can also be called either via ecg_rate(), `ppg_rate() or rsp_rate() (aliases provided for consistency).

Parameters

• peaks (Union[list, np.array, pd.DataFrame, pd.Series, dict]) – The samples at which the peaks occur. If an array is passed in, it is assumed that it was obtained with signal_findpeaks(). If a DataFrame is passed in, it is assumed it is of the same length as the input signal in which occurrences of R-peaks are marked as “1”, with such containers obtained with e.g., ecg_findpeaks() or rsp_findpeaks().

• sampling_rate (int) – The sampling frequency of the signal that contains peaks (in Hz, i.e., samples/second). Defaults to 1000.

• desired_length (int) – If left at the default None, the returned rated will have the same number of elements as peaks. If set to a value larger than the sample at which the last peak occurs in the signal (i.e., peaks[-1]), the returned rate will be interpolated between peaks over desired_length samples. To interpolate the rate over the entire duration of the signal, set desired_length to the number of samples in the signal. Cannot be smaller than or equal to the sample at which the last peak occurs in the signal. Defaults to None.

• interpolation_method (str) – Method used to interpolate the rate between peaks. See signal_interpolate(). ‘monotone_cubic’ is chosen as the default interpolation method since it ensures monotone interpolation between data points (i.e., it prevents physiologically implausible “overshoots” or “undershoots” in the y-direction). In contrast, the widely used cubic spline interpolation does not ensure monotonicity.

Returns

array – A vector containing the rate.

See also

signal_findpeaks(), signal_fixpeaks(), signal_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, sampling_rate=1000, frequency=1)
>>> info = nk.signal_findpeaks(signal)
>>>
>>> rate = nk.signal_rate(peaks=info["Peaks"], desired_length=len(signal))
>>> fig = nk.signal_plot(rate)
>>> fig 

ecg_rsa(ecg_signals, rsp_signals=None, rpeaks=None, sampling_rate=1000, continuous=False)

Respiratory Sinus Arrhythmia (RSA)

Respiratory sinus arrhythmia (RSA), also referred to as ‘cardiac coherence’, is the naturally occurring variation in heart rate during the breathing cycle. Metrics to quantify it are often used as a measure of parasympathetic nervous system activity. Neurophysiology informs us that the functional output of the myelinated vagus originating from the nucleus ambiguus has a respiratory rhythm. Thus, there would a temporal relation between the respiratory rhythm being expressed in the firing of these efferent pathways and the functional effect on the heart rate rhythm manifested as RSA. Importantly, several methods exist to quantify RSA:

• The Peak-to-trough (P2T) algorithm measures the statistical range in milliseconds of the heart

period oscillation associated with synchronous respiration. Operationally, subtracting the shortest heart period during inspiration from the longest heart period during a breath cycle produces an estimate of RSA during each breath. The peak-to-trough method makes no statistical assumption or correction (e.g., adaptive filtering) regarding other sources of variance in the heart period time series that may confound, distort, or interact with the metric such as slower periodicities and baseline trend. Although it has been proposed that the P2T method “acts as a time-domain filter dynamically centered at the exact ongoing respiratory frequency” (Grossman, 1992), the method does not transform the time series in any way, as a filtering process would. Instead the method uses knowledge of the ongoing respiratory cycle to associate segments of the heart period time series with either inhalation or exhalation (Lewis, 2012).

• The Porges-Bohrer (PB) algorithm assumes that heart period time series reflect the sum of several

component time series. Each of these component time series may be mediated by different neural mechanisms and may have different statistical features. The Porges-Bohrer method applies an algorithm that selectively extracts RSA, even when the periodic process representing RSA is superimposed on a complex baseline that may include aperiodic and slow periodic processes. Since the method is designed to remove sources of variance in the heart period time series other than the variance within the frequency band of spontaneous breathing, the method is capable of accurately quantifying RSA when the signal to noise ratio is low.

Parameters

• ecg_signals (DataFrame) – DataFrame obtained from ecg_process(). Should contain columns ECG_Rate and ECG_R_Peaks. Can also take a DataFrame comprising of both ECG and RSP signals, generated by bio_process().

• rsp_signals (DataFrame) – DataFrame obtained from rsp_process(). Should contain columns RSP_Phase and RSP_PhaseCompletion. No impact when a DataFrame comprising of both the ECG and RSP signals are passed as ecg_signals. Defaults to None.

• rpeaks (dict) – The samples at which the R-peaks of the ECG signal occur. Dict returned by ecg_peaks(), ecg_process(), or bio_process(). Defaults to None.

• sampling_rate (int) – The sampling frequency of signals (in Hz, i.e., samples/second).

• continuous (bool) – If False, will return RSA properties computed from the data (one value per index). If True, will return continuous estimations of RSA of the same length as the signal. See below for more details.

Returns

rsa (dict) – A dictionary containing the RSA features, which includes:

• ”RSA_P2T_Values”: the estimate of RSA during each breath cycle, produced by subtracting the shortest heart period (or RR interval) from the longest heart period in ms.

• ”RSA_P2T_Mean”: the mean peak-to-trough across all cycles in ms

• ”RSA_P2T_Mean_log”: the logarithm of the mean of RSA estimates.

• ”RSA_P2T_SD”: the standard deviation of all RSA estimates.

• ”RSA_P2T_NoRSA”: the number of breath cycles from which RSA could not be calculated.

• ”RSA_PorgesBohrer”: the Porges-Bohrer estimate of RSA, optimal when the signal to noise ratio is low, in ln(ms^2).

Example

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data
>>> ecg_signals, info = nk.ecg_process(data["ECG"], sampling_rate=100)
>>> rsp_signals, _ = nk.rsp_process(data["RSP"], sampling_rate=100)
>>>
>>> # Get RSA features
>>> nk.ecg_rsa(ecg_signals, rsp_signals, info, sampling_rate=100, continuous=False) 
{'RSA_P2T_Mean': ...,
 'RSA_P2T_Mean_log': ...,
 'RSA_P2T_SD': ...,
 'RSA_P2T_NoRSA': ...,
 'RSA_PorgesBohrer': ...}
>>>
>>> # Get RSA as a continuous signal
>>> rsa = nk.ecg_rsa(ecg_signals, rsp_signals, info, sampling_rate=100, continuous=True)
>>> rsa 
        RSA_P2T
0      0.09
1      0.09
2      0.09
...    ...

[15000 rows x 1 columns] >>> nk.signal_plot([ecg_signals[“ECG_Rate”], rsp_signals[“RSP_Rate”], rsa], standardize=True)

References

• Servant, D., Logier, R., Mouster, Y., & Goudemand, M. (2009). La variabilité de la fréquence cardiaque. Intérêts en psychiatrie. L’Encéphale, 35(5), 423–428. doi:10.1016/j.encep.2008.06.016

• Lewis, G. F., Furman, S. A., McCool, M. F., & Porges, S. W. (2012). Statistical strategies to quantify respiratory sinus arrhythmia: Are commonly used metrics equivalent?. Biological psychology, 89(2), 349-364.

• Zohar, A. H., Cloninger, C. R., & McCraty, R. (2013). Personality and heart rate variability: exploring pathways from personality to cardiac coherence and health. Open Journal of Social Sciences, 1(06), 32.

ecg_rsp(ecg_rate, sampling_rate=1000, method='vangent2019')

Extract ECG Derived Respiration (EDR).

This implementation is far from being complete, as the information in the related papers prevents me from getting a full understanding of the procedure. Help is required!

Parameters

• ecg_rate (array) – The heart rate signal as obtained via ecg_rate().

• sampling_rate (int) – The sampling frequency of the signal that contains the R-peaks (in Hz, i.e., samples/second). Defaults to 1000Hz.

• method (str) – Can be one of ‘vangent2019’ (default), ‘soni2019’, ‘charlton2016’ or ‘sarkar2015’.

Returns

array – A Numpy array containing the heart rate.

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> # Get heart rate
>>> data = nk.data("bio_eventrelated_100hz")
>>> rpeaks, info = nk.ecg_peaks(data["ECG"], sampling_rate=100)
>>> ecg_rate = nk.signal_rate(rpeaks, sampling_rate=100, desired_length=len(rpeaks))
>>>
>>>
>>> # Get ECG Derived Respiration (EDR)
>>> edr = nk.ecg_rsp(ecg_rate, sampling_rate=100)
>>> nk.standardize(pd.DataFrame({"EDR": edr, "RSP": data["RSP"]})).plot() 
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>>
>>> # Method comparison (the closer to 0 the better)
>>> nk.standardize(pd.DataFrame({"True RSP": data["RSP"],
...                              "vangent2019": nk.ecg_rsp(ecg_rate, sampling_rate=100, method="vangent2019"),
...                              "sarkar2015": nk.ecg_rsp(ecg_rate, sampling_rate=100, method="sarkar2015"),
...                              "charlton2016": nk.ecg_rsp(ecg_rate, sampling_rate=100, method="charlton2016"),
...                              "soni2019": nk.ecg_rsp(ecg_rate, sampling_rate=100,
...                                                     method="soni2019")})).plot() 
<matplotlib.axes._subplots.AxesSubplot object at ...>

References

• van Gent, P., Farah, H., van Nes, N., & van Arem, B. (2019). HeartPy: A novel heart rate algorithm for the analysis of noisy signals. Transportation research part F: traffic psychology and behaviour, 66, 368-378.

• Sarkar, S., Bhattacherjee, S., & Pal, S. (2015). Extraction of respiration signal from ECG for respiratory rate estimation.

• Charlton, P. H., Bonnici, T., Tarassenko, L., Clifton, D. A., Beale, R., & Watkinson, P. J. (2016). An assessment of algorithms to estimate respiratory rate from the electrocardiogram and photoplethysmogram. Physiological measurement, 37(4), 610.

• Soni, R., & Muniyandi, M. (2019). Breath rate variability: a novel measure to study the meditation effects. International Journal of Yoga, 12(1), 45.

ecg_segment(ecg_cleaned, rpeaks=None, sampling_rate=1000, show=False)

Segment an ECG signal into single heartbeats.

Parameters

• ecg_cleaned (Union[list, np.array, pd.Series]) – The cleaned ECG channel as returned by ecg_clean().

• rpeaks (dict) – The samples at which the R-peaks occur. Dict returned by ecg_peaks(). Defaults to None.

• sampling_rate (int) – The sampling frequency of ecg_signal (in Hz, i.e., samples/second). Defaults to 1000.

• show (bool) – If True, will return a plot of heartbeats. Defaults to False.

Returns

dict – A dict containing DataFrames for all segmented heartbeats.

See also

ecg_clean(), ecg_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=15, sampling_rate=1000, heart_rate=80)
>>> ecg_cleaned = nk.ecg_clean(ecg, sampling_rate=1000)
>>> nk.ecg_segment(ecg_cleaned, rpeaks=None, sampling_rate=1000, show=True) 
{'1':              Signal  Index Label
 ...
 '2':              Signal  Index Label
 ...
 '19':              Signal  Index Label
 ...}

ecg_simulate(duration=10, length=None, sampling_rate=1000, noise=0.01, heart_rate=70, method='ecgsyn', random_state=None)

Simulate an ECG/EKG signal.

Generate an artificial (synthetic) ECG signal of a given duration and sampling rate using either the ECGSYN dynamical model (McSharry et al., 2003) or a simpler model based on Daubechies wavelets to roughly approximate cardiac cycles.

Parameters

• duration (int) – Desired recording length in seconds.

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second).

• length (int) – The desired length of the signal (in samples).

• noise (float) – Noise level (amplitude of the laplace noise).

• heart_rate (int) – Desired simulated heart rate (in beats per minute).

• method (str) – The model used to generate the signal. Can be ‘simple’ for a simulation based on Daubechies wavelets that roughly approximates a single cardiac cycle. If ‘ecgsyn’ (default), will use an advanced model desbribed McSharry et al. (2003).

• random_state (int) – Seed for the random number generator.

Returns

array – Vector containing the ECG signal.

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> ecg1 = nk.ecg_simulate(duration=10, method="simple")
>>> ecg2 = nk.ecg_simulate(duration=10, method="ecgsyn")
>>> pd.DataFrame({"ECG_Simple": ecg1,
...               "ECG_Complex": ecg2}).plot(subplots=True) 
array([<matplotlib.axes._subplots.AxesSubplot object at ...>,
   <matplotlib.axes._subplots.AxesSubplot object at ...>],
  dtype=object)

See also

rsp_simulate(), eda_simulate(), ppg_simulate(), emg_simulate()

References

• McSharry, P. E., Clifford, G. D., Tarassenko, L., & Smith, L. A. (2003). A dynamical model for

generating synthetic electrocardiogram signals. IEEE transactions on biomedical engineering, 50(3), 289-294. - https://github.com/diarmaidocualain/ecg_simulation

PPG

Submodule for NeuroKit.

ppg_clean(ppg_signal, sampling_rate=1000, method='elgendi')

Clean a photoplethysmogram (PPG) signal.

Prepare a raw PPG signal for systolic peak detection.

Parameters

• ppg_signal (Union[list, np.array, pd.Series]) – The raw PPG channel.

• sampling_rate (int) – The sampling frequency of the PPG (in Hz, i.e., samples/second). The default is 1000.

• method (str) – The processing pipeline to apply. Can be one of “elgendi”. The default is “elgendi”.

Returns

clean (array) – A vector containing the cleaned PPG.

See also

ppg_simulate(), ppg_findpeaks()

Examples

>>> import neurokit2 as nk
>>> import matplotlib.pyplot as plt
>>>
>>> ppg = nk.ppg_simulate(heart_rate=75, duration=30)
>>> ppg_clean = nk.ppg_clean(ppg)
>>>
>>> plt.plot(ppg, label="raw PPG") 
>>> plt.plot(ppg_clean, label="clean PPG") 
>>> plt.legend() 

ppg_findpeaks(ppg_cleaned, sampling_rate=1000, method='elgendi', show=False)

Find systolic peaks in a photoplethysmogram (PPG) signal.

Parameters

• ppg_cleaned (Union[list, np.array, pd.Series]) – The cleaned PPG channel as returned by ppg_clean().

• sampling_rate (int) – The sampling frequency of the PPG (in Hz, i.e., samples/second). The default is 1000.

• method (str) – The processing pipeline to apply. Can be one of “elgendi”. The default is “elgendi”.

• show (bool) – If True, returns a plot of the thresholds used during peak detection. Useful for debugging. The default is False.

Returns

info (dict) – A dictionary containing additional information, in this case the samples at which systolic peaks occur, accessible with the key “PPG_Peaks”.

See also

ppg_simulate(), ppg_clean()

Examples

>>> import neurokit2 as nk
>>> import matplotlib.pyplot as plt
>>>
>>> ppg = nk.ppg_simulate(heart_rate=75, duration=30)
>>> ppg_clean = nk.ppg_clean(ppg)
>>> info = nk.ppg_findpeaks(ppg_clean)
>>> peaks = info["PPG_Peaks"]
>>>
>>> plt.plot(ppg, label="raw PPG") 
>>> plt.plot(ppg_clean, label="clean PPG") 
>>> plt.scatter(peaks, ppg[peaks], c="r", label="systolic peaks") 
>>> plt.legend() 

References

• Elgendi M, Norton I, Brearley M, Abbott D, Schuurmans D (2013) Systolic Peak Detection in

Acceleration Photoplethysmograms Measured from Emergency Responders in Tropical Conditions. PLoS ONE 8(10): e76585. doi:10.1371/journal.pone.0076585.

ppg_plot(ppg_signals, sampling_rate=None)

Visualize photoplethysmogram (PPG) data.

Parameters

• ppg_signals (DataFrame) – DataFrame obtained from ppg_process().

• sampling_rate (int) – The sampling frequency of the PPG (in Hz, i.e., samples/second). Needs to be supplied if the data should be plotted over time in seconds. Otherwise the data is plotted over samples. Defaults to None.

Returns

fig – Figure representing a plot of the processed PPG signals.

Examples

>>> import neurokit2 as nk
>>>
>>> # Simulate data
>>> ppg = nk.ppg_simulate(duration=10, sampling_rate=1000, heart_rate=70)
>>>
>>> # Process signal
>>> signals, info = nk.ppg_process(ppg, sampling_rate=1000)
>>>
>>> # Plot
>>> nk.ppg_plot(signals) 
<Figure ...>

See also

ppg_process()

ppg_process(ppg_signal, sampling_rate=1000, **kwargs)

Process a photoplethysmogram (PPG) signal.

Convenience function that automatically processes an electromyography signal.

Parameters

• ppg_signal (Union[list, np.array, pd.Series]) – The raw PPG channel.

• sampling_rate (int) – The sampling frequency of emg_signal (in Hz, i.e., samples/second).

Returns

• signals (DataFrame) – A DataFrame of same length as emg_signal containing the following columns: - “PPG_Raw”: the raw signal. - “PPG_Clean”: the cleaned signal. - “PPG_Rate”: the heart rate as measured based on PPG peaks. - “PPG_Peaks”: the PPG peaks marked as “1” in a list of zeros.

• info (dict) – A dictionary containing the information of peaks.

See also

ppg_clean(), ppg_findpeaks()

Examples

>>> import neurokit2 as nk
>>>
>>> ppg = nk.ppg_simulate(duration=10, sampling_rate=1000, heart_rate=70)
>>> signals, info = nk.ppg_process(ppg, sampling_rate=1000)
>>> fig = nk.ppg_plot(signals)
>>> fig 

ppg_rate(peaks, sampling_rate=1000, desired_length=None, interpolation_method='monotone_cubic')

Calculate signal rate from a series of peaks.

This function can also be called either via ecg_rate(), `ppg_rate() or rsp_rate() (aliases provided for consistency).

Parameters

• peaks (Union[list, np.array, pd.DataFrame, pd.Series, dict]) – The samples at which the peaks occur. If an array is passed in, it is assumed that it was obtained with signal_findpeaks(). If a DataFrame is passed in, it is assumed it is of the same length as the input signal in which occurrences of R-peaks are marked as “1”, with such containers obtained with e.g., ecg_findpeaks() or rsp_findpeaks().

• sampling_rate (int) – The sampling frequency of the signal that contains peaks (in Hz, i.e., samples/second). Defaults to 1000.

• desired_length (int) – If left at the default None, the returned rated will have the same number of elements as peaks. If set to a value larger than the sample at which the last peak occurs in the signal (i.e., peaks[-1]), the returned rate will be interpolated between peaks over desired_length samples. To interpolate the rate over the entire duration of the signal, set desired_length to the number of samples in the signal. Cannot be smaller than or equal to the sample at which the last peak occurs in the signal. Defaults to None.

• interpolation_method (str) – Method used to interpolate the rate between peaks. See signal_interpolate(). ‘monotone_cubic’ is chosen as the default interpolation method since it ensures monotone interpolation between data points (i.e., it prevents physiologically implausible “overshoots” or “undershoots” in the y-direction). In contrast, the widely used cubic spline interpolation does not ensure monotonicity.

Returns

array – A vector containing the rate.

See also

signal_findpeaks(), signal_fixpeaks(), signal_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, sampling_rate=1000, frequency=1)
>>> info = nk.signal_findpeaks(signal)
>>>
>>> rate = nk.signal_rate(peaks=info["Peaks"], desired_length=len(signal))
>>> fig = nk.signal_plot(rate)
>>> fig 

ppg_simulate(duration=120, sampling_rate=1000, heart_rate=70, frequency_modulation=0.3, ibi_randomness=0.1, drift=0, motion_amplitude=0.1, powerline_amplitude=0.01, burst_number=0, burst_amplitude=1, random_state=None, show=False)

Simulate a photoplethysmogram (PPG) signal.

Phenomenological approximation of PPG. The PPG wave is described with four landmarks: wave onset, location of the systolic peak, location of the dicrotic notch and location of the diastolic peaks. These landmarks are defined as x and y coordinates (in a time series). These coordinates are then interpolated at the desired sampling rate to obtain the PPG signal.

Parameters

• duration (int) – Desired recording length in seconds. The default is 120.

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second). The default is 1000.

• heart_rate (int) – Desired simulated heart rate (in beats per minute). The default is 70.

• frequency_modulation (float) – Float between 0 and 1. Determines how pronounced respiratory sinus arrythmia (RSA) is (0 corresponds to absence of RSA). The default is 0.3.

• ibi_randomness (float) – Float between 0 and 1. Determines how much random noise there is in the duration of each PPG wave (0 corresponds to absence of variation). The default is 0.1.

• drift (float) – Float between 0 and 1. Determines how pronounced the baseline drift (.05 Hz) is (0 corresponds to absence of baseline drift). The default is 1.

• motion_amplitude (float) – Float between 0 and 1. Determines how pronounced the motion artifact (0.5 Hz) is (0 corresponds to absence of motion artifact). The default is 0.1.

• powerline_amplitude (float) – Float between 0 and 1. Determines how pronounced the powerline artifact (50 Hz) is (0 corresponds to absence of powerline artifact). Note that powerline_amplitude > 0 is only possible if ‘sampling_rate’ is >= 500. The default is 0.1.

• burst_amplitude (float) – Float between 0 and 1. Determines how pronounced high frequency burst artifacts are (0 corresponds to absence of bursts). The default is 1.

• burst_number (int) – Determines how many high frequency burst artifacts occur. The default is 0.

• show (bool) – If true, returns a plot of the landmarks and interpolated PPG. Useful for debugging.

• random_state (int) – Seed for the random number generator. Keep it fixed for reproducible results.

Returns

ppg (array) – A vector containing the PPG.

See also

ecg_simulate(), rsp_simulate(), eda_simulate(), emg_simulate()

Examples

>>> import neurokit2 as nk
>>>
>>> ppg = nk.ppg_simulate(duration=40, sampling_rate=500, heart_rate=75, random_state=42)

HRV

hrv(peaks, sampling_rate=1000, show=False)

Computes indices of Heart Rate Variability (HRV).

Computes HRV indices in the time-, frequency-, and nonlinear domain. Note that a minimum duration of the signal containing the peaks is recommended for some HRV indices to be meaninful. For instance, 1, 2 and 5 minutes of high quality signal are the recomended minima for HF, LF and LF/HF, respectively. See references for details.

Parameters

• peaks (dict) – Samples at which cardiac extrema (i.e., R-peaks, systolic peaks) occur. Dictionary returned by ecg_findpeaks, ecg_peaks, ppg_findpeaks, or ppg_peaks.

• sampling_rate (int, optional) – Sampling rate (Hz) of the continuous cardiac signal in which the peaks occur. Should be at least twice as high as the highest frequency in vhf. By default 1000.

• show (bool, optional) – If True, returns the plots that are generates for each of the domains.

Returns

DataFrame – Contains HRV metrics from three domains: - frequency (see hrv_frequency) - time (see hrv_time) - non-linear (see `hrv_nonlinear <https://neurokit2.readthedocs.io/en/latest/functions.html#neurokit2.hrv.hrv_nonlinear`_)

See also

ecg_peaks(), ppg_peaks(), hrv_time(), hrv_frequency(), hrv_nonlinear()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Find peaks
>>> peaks, info = nk.ecg_peaks(data["ECG"], sampling_rate=100)
>>>
>>> # Compute HRV indices
>>> hrv_indices = nk.hrv(peaks, sampling_rate=100, show=True)
>>> hrv_indices 

References

• Stein, P. K. (2002). Assessing heart rate variability from real-world Holter reports. Cardiac

electrophysiology review, 6(3), 239-244.

• Shaffer, F., & Ginsberg, J. P. (2017). An overview of heart rate variability metrics and norms.

Frontiers in public health, 5, 258.

hrv_frequency(peaks, sampling_rate=1000, ulf=0, 0.0033, vlf=0.0033, 0.04, lf=0.04, 0.15, hf=0.15, 0.4, vhf=0.4, 0.5, psd_method='welch', show=False, silent=True, **kwargs)

Computes frequency-domain indices of Heart Rate Variability (HRV).

Note that a minimum duration of the signal containing the peaks is recommended for some HRV indices to be meaningful. For instance, 1, 2 and 5 minutes of high quality signal are the recomended minima for HF, LF and LF/HF, respectively. See references for details.

Parameters

• peaks (dict) – Samples at which cardiac extrema (i.e., R-peaks, systolic peaks) occur. Dictionary returned by ecg_findpeaks, ecg_peaks, ppg_findpeaks, or ppg_peaks.

• sampling_rate (int, optional) – Sampling rate (Hz) of the continuous cardiac signal in which the peaks occur. Should be at least twice as high as the highest frequency in vhf. By default 1000.

• ulf (tuple, optional) – Upper and lower limit of the ultra-low frequency band. By default (0, 0.0033).

• vlf (tuple, optional) – Upper and lower limit of the very-low frequency band. By default (0.0033, 0.04).

• lf (tuple, optional) – Upper and lower limit of the low frequency band. By default (0.04, 0.15).

• hf (tuple, optional) – Upper and lower limit of the high frequency band. By default (0.15, 0.4).

• vhf (tuple, optional) – Upper and lower limit of the very-high frequency band. By default (0.4, 0.5).

• psd_method (str) – Method used for spectral density estimation. For details see signal.signal_power. By default “welch”.

• silent (bool) – If False, warnings will be printed. Default to True.

• show (bool) – If True, will plot the power in the different frequency bands.

• **kwargs (optional) – Other arguments.

Returns

DataFrame – Contains frequency domain HRV metrics: - ULF: The spectral power density pertaining to ultra low frequency band i.e., .0 to .0033 Hz by default. - VLF: The spectral power density pertaining to very low frequency band i.e., .0033 to .04 Hz by default. - LF: The spectral power density pertaining to low frequency band i.e., .04 to .15 Hz by default. - HF: The spectral power density pertaining to high frequency band i.e., .15 to .4 Hz by default. - VHF: The variability, or signal power, in very high frequency i.e., .4 to .5 Hz by default. - LFn: The normalized low frequency, obtained by dividing the low frequency power by the total power. - HFn: The normalized high frequency, obtained by dividing the low frequency power by the total power. - LnHF: The log transformed HF.

See also

ecg_peaks(), ppg_peaks(), hrv_summary(), hrv_time(), hrv_nonlinear()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Find peaks
>>> peaks, info = nk.ecg_peaks(data["ECG"], sampling_rate=100)
>>>
>>> # Compute HRV indices
>>> hrv = nk.hrv_frequency(peaks, sampling_rate=100, show=True)

References

• Stein, P. K. (2002). Assessing heart rate variability from real-world Holter reports. Cardiac

electrophysiology review, 6(3), 239-244.

• Shaffer, F., & Ginsberg, J. P. (2017). An overview of heart rate variability metrics and norms.

Frontiers in public health, 5, 258.

hrv_nonlinear(peaks, sampling_rate=1000, show=False)

Computes nonlinear indices of Heart Rate Variability (HRV).

See references for details.

Parameters

• peaks (dict) – Samples at which cardiac extrema (i.e., R-peaks, systolic peaks) occur. Dictionary returned by ecg_findpeaks, ecg_peaks, ppg_findpeaks, or ppg_peaks.

• sampling_rate (int, optional) – Sampling rate (Hz) of the continuous cardiac signal in which the peaks occur. Should be at least twice as high as the highest frequency in vhf. By default 1000.

• show (bool, optional) – If True, will return a Poincaré plot, a scattergram, which plots each RR interval against the next successive one. The ellipse centers around the average RR interval. By default False.

Returns

DataFrame – Contains non-linear HRV metrics:

• Characteristics of the Poincaré Plot Geometry:

  • SD1: SD1 is a measure of the spread of RR intervals on the Poincaré plot

  perpendicular to the line of identity. It is an index of short-term RR interval fluctuations, i.e., beat-to-beat variability. It is equivalent (although on another scale) to RMSSD, and therefore it is redundant to report correlations with both (Ciccone, 2017).

  • SD2: SD2 is a measure of the spread of RR intervals on the Poincaré plot along the

  line of identity. It is an index of long-term RR interval fluctuations.

  • SD1SD2: the ratio between short and long term fluctuations of the RR intervals

  (SD1 divided by SD2).

  • S: Area of ellipse described by SD1 and SD2 (pi * SD1 * SD2). It is

  proportional to SD1SD2.

  • CSI: The Cardiac Sympathetic Index (Toichi, 1997), calculated by dividing the

  longitudinal variability of the Poincaré plot (4*SD2) by its transverse variability (4*SD1).

  • CVI: The Cardiac Vagal Index (Toichi, 1997), equal to the logarithm of the product of

  longitudinal (4*SD2) and transverse variability (4*SD1).

  • CSI_Modified: The modified CSI (Jeppesen, 2014) obtained by dividing the square of

  the longitudinal variability by its transverse variability.

• Indices of Heart Rate Asymmetry (HRA), i.e., asymmetry of the Poincaré plot (Yan, 2017):

  • GI: Guzik’s Index, defined as the distance of points above line of identity (LI)

  to LI divided by the distance of all points in Poincaré plot to LI except those that are located on LI.

  • SI: Slope Index, defined as the phase angle of points above LI divided by the

  phase angle of all points in Poincaré plot except those that are located on LI.

  • AI: Area Index, defined as the cumulative area of the sectors corresponding to

  the points that are located above LI divided by the cumulative area of sectors corresponding to all points in the Poincaré plot except those that are located on LI.

  • PI: Porta’s Index, defined as the number of points below LI divided by the total

  number of points in Poincaré plot except those that are located on LI.

  • SD1d and SD1a: short-term variance of contributions of decelerations

  (prolongations of RR intervals) and accelerations (shortenings of RR intervals), respectively (Piskorski, 2011).

  • C1d and C1a: the contributions of heart rate decelerations and accelerations

  to short-term HRV, respectively (Piskorski, 2011).

  • SD2d and SD2a: long-term variance of contributions of decelerations

  (prolongations of RR intervals) and accelerations (shortenings of RR intervals), respectively (Piskorski, 2011).

  • C2d and C2a: the contributions of heart rate decelerations and accelerations

  to long-term HRV, respectively (Piskorski, 2011).

  • SDNNd and SDNNa: total variance of contributions of decelerations

  (prolongations of RR intervals) and accelerations (shortenings of RR intervals), respectively (Piskorski, 2011).

  • Cd and Ca: the total contributions of heart rate decelerations and

  accelerations to HRV.

• Indices of Heart Rate Fragmentation (Costa, 2017):

  • PIP: Percentage of inflection points of the RR intervals series.

  • IALS: Inverse of the average length of the acceleration/deceleration segments.

  • PSS: Percentage of short segments.

  • PAS: IPercentage of NN intervals in alternation segments.

• Indices of Complexity:

  • ApEn: The approximate entropy measure of HRV, calculated by entropy_approximate().

  • SampEn: The sample entropy measure of HRV, calculated by entropy_sample().

See also

ecg_peaks(), ppg_peaks(), hrv_frequency(), hrv_time(), hrv_summary()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Find peaks
>>> peaks, info = nk.ecg_peaks(data["ECG"], sampling_rate=100)
>>>
>>> # Compute HRV indices
>>> hrv = nk.hrv_nonlinear(peaks, sampling_rate=100, show=True)
>>> hrv 

References

• Yan, C., Li, P., Ji, L., Yao, L., Karmakar, C., & Liu, C. (2017). Area asymmetry of heart

rate variability signal. Biomedical engineering online, 16(1), 112.

• Ciccone, A. B., Siedlik, J. A., Wecht, J. M., Deckert, J. A., Nguyen, N. D., & Weir, J. P.

(2017). Reminder: RMSSD and SD1 are identical heart rate variability metrics. Muscle & nerve, 56(4), 674-678.

• Shaffer, F., & Ginsberg, J. P. (2017). An overview of heart rate variability metrics and norms.

Frontiers in public health, 5, 258.

• Costa, M. D., Davis, R. B., & Goldberger, A. L. (2017). Heart rate fragmentation: a new

approach to the analysis of cardiac interbeat interval dynamics. Front. Physiol. 8, 255 (2017).

• Jeppesen, J., Beniczky, S., Johansen, P., Sidenius, P., & Fuglsang-Frederiksen, A. (2014).

Using Lorenz plot and Cardiac Sympathetic Index of heart rate variability for detecting seizures for patients with epilepsy. In 2014 36th Annual International Conference of the IEEE Engineering in Medicine and Biology Society (pp. 4563-4566). IEEE.

• Piskorski, J., & Guzik, P. (2011). Asymmetric properties of long-term and total heart rate

variability. Medical & biological engineering & computing, 49(11), 1289-1297.

• Stein, P. K. (2002). Assessing heart rate variability from real-world Holter reports. Cardiac

electrophysiology review, 6(3), 239-244.

• Brennan, M. et al. (2001). Do Existing Measures of Poincaré Plot Geometry Reflect Nonlinear

Features of Heart Rate Variability?. IEEE Transactions on Biomedical Engineering, 48(11), 1342-1347.

• Toichi, M., Sugiura, T., Murai, T., & Sengoku, A. (1997). A new method of assessing cardiac

autonomic function and its comparison with spectral analysis and coefficient of variation of R–R interval. Journal of the autonomic nervous system, 62(1-2), 79-84.

hrv_time(peaks, sampling_rate=1000, show=False)

Computes time-domain indices of Heart Rate Variability (HRV).

See references for details.

Parameters

• peaks (dict) – Samples at which cardiac extrema (i.e., R-peaks, systolic peaks) occur. Dictionary returned by ecg_findpeaks, ecg_peaks, ppg_findpeaks, or ppg_peaks.

• sampling_rate (int, optional) – Sampling rate (Hz) of the continuous cardiac signal in which the peaks occur. Should be at least twice as high as the highest frequency in vhf. By default 1000.

• show (bool) – If True, will plot the distribution of R-R intervals.

Returns

DataFrame – Contains time domain HRV metrics: - RMSSD: The square root of the mean of the sum of successive differences between adjacent RR intervals. It is equivalent (although on another scale) to SD1, and therefore it is redundant to report correlations with both (Ciccone, 2017). - MeanNN: The mean of the RR intervals. - SDNN: The standard deviation of the RR intervals. - SDSD: The standard deviation of the successive differences between RR intervals. - CVNN: The standard deviation of the RR intervals (SDNN) divided by the mean of the RR intervals (MeanNN). - CVSD: The root mean square of the sum of successive differences (RMSSD) divided by the mean of the RR intervals (MeanNN). - MedianNN: The median of the absolute values of the successive differences between RR intervals. - MadNN: The median absolute deviation of the RR intervals. - HCVNN: The median absolute deviation of the RR intervals (MadNN) divided by the median of the absolute differences of their successive differences (MedianNN). - IQRNN: The interquartile range (IQR) of the RR intervals. - pNN50: The proportion of RR intervals greater than 50ms, out of the total number of RR intervals. - pNN20: The proportion of RR intervals greater than 20ms, out of the total number of RR intervals. - TINN: A geometrical parameter of the HRV, or more specifically, the baseline width of the RR intervals distribution obtained by triangular interpolation, where the error of least squares determines the triangle. It is an approximation of the RR interval distribution. - HTI: The HRV triangular index, measuring the total number of RR intervals divded by the height of the RR intervals histogram.

See also

ecg_peaks(), ppg_peaks(), hrv_frequency(), hrv_summary(), hrv_nonlinear()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Find peaks
>>> peaks, info = nk.ecg_peaks(data["ECG"], sampling_rate=100)
>>>
>>> # Compute HRV indices
>>> hrv = nk.hrv_time(peaks, sampling_rate=100, show=True)

References

• Ciccone, A. B., Siedlik, J. A., Wecht, J. M., Deckert, J. A., Nguyen, N. D., & Weir, J. P.

(2017). Reminder: RMSSD and SD1 are identical heart rate variability metrics. Muscle & nerve, 56(4), 674-678.

• Stein, P. K. (2002). Assessing heart rate variability from real-world Holter reports. Cardiac

electrophysiology review, 6(3), 239-244.

• Shaffer, F., & Ginsberg, J. P. (2017). An overview of heart rate variability metrics and norms.

Frontiers in public health, 5, 258.

RSP

Submodule for NeuroKit.

rsp_amplitude(rsp_cleaned, peaks, troughs=None, interpolation_method='monotone_cubic')

Compute respiratory amplitude.

Compute respiratory amplitude given the raw respiration signal and its extrema.

Parameters

• rsp_cleaned (Union[list, np.array, pd.Series]) – The cleaned respiration channel as returned by rsp_clean().

• peaks (list or array or DataFrame or Series or dict) – The samples at which the inhalation peaks occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with rsp_findpeaks().

• troughs (list or array or DataFrame or Series or dict) – The samples at which the inhalation troughs occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with rsp_findpeaks().

• interpolation_method (str) – Method used to interpolate the amplitude between peaks. See signal_interpolate(). ‘monotone_cubic’ is chosen as the default interpolation method since it ensures monotone interpolation between data points (i.e., it prevents physiologically implausible “overshoots” or “undershoots” in the y-direction). In contrast, the widely used cubic spline interpolation does not ensure monotonicity.

Returns

array – A vector containing the respiratory amplitude.

See also

rsp_clean(), rsp_peaks(), signal_rate(), rsp_process(), rsp_plot()

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> rsp = nk.rsp_simulate(duration=90, respiratory_rate=15)
>>> cleaned = nk.rsp_clean(rsp, sampling_rate=1000)
>>> info, signals = nk.rsp_peaks(cleaned)
>>>
>>> amplitude = nk.rsp_amplitude(cleaned, signals)
>>> fig = nk.signal_plot(pd.DataFrame({"RSP": rsp, "Amplitude": amplitude}), subplots=True)
>>> fig 

rsp_analyze(data, sampling_rate=1000, method='auto')

Performs RSP analysis on either epochs (event-related analysis) or on longer periods of data such as resting- state data.

Parameters

• data (dict or DataFrame) – A dictionary of epochs, containing one DataFrame per epoch, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df(). Can also take a DataFrame of processed signals from a longer period of data, typically generated by rsp_process() or bio_process(). Can also take a dict containing sets of separate periods of data.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second). Defaults to 1000Hz.

• method (str) – Can be one of ‘event-related’ for event-related analysis on epochs, or ‘interval-related’ for analysis on longer periods of data. Defaults to ‘auto’ where the right method will be chosen based on the mean duration of the data (‘event-related’ for duration under 10s).

Returns

DataFrame – A dataframe containing the analyzed RSP features. If event-related analysis is conducted, each epoch is indicated by the Label column. See rsp_eventrelated() and rsp_intervalrelated() docstrings for details.

See also

bio_process(), rsp_process(), epochs_create(), rsp_eventrelated(), rsp_intervalrelated()

Examples

>>> import neurokit2 as nk

>>> # Example 1: Download the data for event-related analysis
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data for event-related analysis
>>> df, info = nk.bio_process(rsp=data["RSP"], sampling_rate=100)
>>> events = nk.events_find(data["Photosensor"], threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-0.1, epochs_end=1.9)
>>>
>>> # Analyze
>>> nk.rsp_analyze(epochs, sampling_rate=100) 
>>>
>>> # Example 2: Download the resting-state data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Process the data
>>> df, info = nk.rsp_process(data["RSP"], sampling_rate=100)
>>>
>>> # Analyze
>>> nk.rsp_analyze(df, sampling_rate=100) 

rsp_clean(rsp_signal, sampling_rate=1000, method='khodadad2018')

Preprocess a respiration (RSP) signal.

Clean a respiration signal using different sets of parameters, such as ‘khodadad2018’ (linear detrending followed by a fifth order 2Hz low-pass IIR Butterworth filter) or BioSPPy (second order0.1 - 0.35 Hz bandpass Butterworth filter followed by a constant detrending).

Parameters

• rsp_signal (Union[list, np.array, pd.Series]) – The raw respiration channel (as measured, for instance, by a respiration belt).

• sampling_rate (int) – The sampling frequency of rsp_signal (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “khodadad2018” (default) or “biosppy”.

Returns

array – Vector containing the cleaned respiratory signal.

See also

rsp_findpeaks(), signal_rate(), rsp_amplitude(), rsp_process(), rsp_plot()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=30, sampling_rate=50, noise=0.01)
>>> signals = pd.DataFrame({ "RSP_Raw": rsp,
...                         "RSP_Khodadad2018": nk.rsp_clean(rsp, sampling_rate=50, method="khodadad2018"),
...                         "RSP_BioSPPy": nk.rsp_clean(rsp, sampling_rate=50, method="biosppy")})
>>> fig = signals.plot()
>>> fig 

References

• Khodadad et al. (2018)

rsp_eventrelated(epochs, silent=False)

Performs event-related RSP analysis on epochs.

Parameters

• epochs (Union[dict, pd.DataFrame]) – A dict containing one DataFrame per event/trial, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df().

• silent (bool) – If True, silence possible warnings.

Returns

DataFrame – A dataframe containing the analyzed RSP features for each epoch, with each epoch indicated by the Label column (if not present, by the Index column). The analyzed features consist of the following: - “RSP_Rate_Max”: the maximum respiratory rate after stimulus onset. - “RSP_Rate_Min”: the minimum respiratory rate after stimulus onset. - “RSP_Rate_Mean”: the mean respiratory rate after stimulus onset. - “RSP_Rate_Max_Time”: the time at which maximum respiratory rate occurs. - “RSP_Rate_Min_Time”: the time at which minimum respiratory rate occurs. - “RSP_Amplitude_Max”: the maximum respiratory amplitude after stimulus onset. - “RSP_Amplitude_Min”: the minimum respiratory amplitude after stimulus onset. - “RSP_Amplitude_Mean”: the mean respiratory amplitude after stimulus onset. - “RSP_Phase”: indication of whether the onset of the event concurs with respiratory inspiration (1) or expiration (0). - “RSP_PhaseCompletion”: indication of the stage of the current respiration phase (0 to 1) at the onset of the event.

See also

events_find(), epochs_create(), bio_process()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example with simulated data
>>> rsp, info = nk.rsp_process(nk.rsp_simulate(duration=120))
>>> epochs = nk.epochs_create(rsp, events=[5000, 10000, 15000], epochs_start=-0.1, epochs_end=1.9)
>>>
>>> # Analyze
>>> rsp1 = nk.rsp_eventrelated(epochs)
>>> rsp1 
>>>
>>> # Example with real data
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data
>>> df, info = nk.bio_process(rsp=data["RSP"], sampling_rate=100)
>>> events = nk.events_find(data["Photosensor"], threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-0.1, epochs_end=2.9)
>>>
>>> # Analyze
>>> rsp2 = nk.rsp_eventrelated(epochs)
>>> rsp2 

rsp_findpeaks(rsp_cleaned, sampling_rate=1000, method='khodadad2018', amplitude_min=0.3)

Extract extrema in a respiration (RSP) signal.

Low-level function used by rsp_peaks() to identify inhalation peaks and exhalation troughs in a preprocessed respiration signal using different sets of parameters. See rsp_peaks() for details.

Parameters

• rsp_cleaned (Union[list, np.array, pd.Series]) – The cleaned respiration channel as returned by rsp_clean().

• sampling_rate (int) – The sampling frequency of ‘rsp_cleaned’ (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “khodadad2018” (default) or “biosppy”.

• amplitude_min (float) – Only applies if method is “khodadad2018”. Extrema that have a vertical distance smaller than (outlier_threshold * average vertical distance) to any direct neighbour are removed as false positive outliers. I.e., outlier_threshold should be a float with positive sign (the default is 0.3). Larger values of outlier_threshold correspond to more conservative thresholds (i.e., more extrema removed as outliers).

Returns

info (dict) – A dictionary containing additional information, in this case the samples at which inhalation peaks and exhalation troughs occur, accessible with the keys “RSP_Peaks”, and “RSP_Troughs”, respectively.

See also

rsp_clean(), rsp_fixpeaks(), rsp_peaks(), signal_rate(), rsp_amplitude(), rsp_process(), rsp_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=30, respiratory_rate=15)
>>> cleaned = nk.rsp_clean(rsp, sampling_rate=1000)
>>> info = nk.rsp_findpeaks(cleaned)
>>> fig = nk.events_plot([info["RSP_Peaks"], info["RSP_Troughs"]], cleaned)
>>> fig 

rsp_fixpeaks(peaks, troughs=None)

Correct RSP peaks.

Low-level function used by rsp_peaks() to correct the peaks found by rsp_findpeaks(). Doesn’t do anything for now for RSP. See rsp_peaks() for details.

Parameters

• peaks (list or array or DataFrame or Series or dict) – The samples at which the inhalation peaks occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with rsp_findpeaks().

• troughs (list or array or DataFrame or Series or dict) – The samples at which the inhalation troughs occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with rsp_findpeaks().

Returns

info (dict) – A dictionary containing additional information, in this case the samples at which inhalation peaks and exhalation troughs occur, accessible with the keys “RSP_Peaks”, and “RSP_Troughs”, respectively.

See also

rsp_clean(), rsp_findpeaks(), rsp_peaks(), rsp_amplitude(), rsp_process(), rsp_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=30, respiratory_rate=15)
>>> cleaned = nk.rsp_clean(rsp, sampling_rate=1000)
>>> info = nk.rsp_findpeaks(cleaned)
>>> info = nk.rsp_fixpeaks(info)
>>> fig = nk.events_plot([info["RSP_Peaks"], info["RSP_Troughs"]], cleaned)
>>> fig 

rsp_intervalrelated(data, sampling_rate=1000)

Performs RSP analysis on longer periods of data (typically > 10 seconds), such as resting-state data.

Parameters

• data (DataFrame or dict) – A DataFrame containing the different processed signal(s) as different columns, typically generated by rsp_process() or bio_process(). Can also take a dict containing sets of separately processed DataFrames.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

Returns

DataFrame – A dataframe containing the analyzed RSP features. The analyzed features consist of the following: - “RSP_Rate_Mean”: the mean heart rate. - “RSP_Amplitude_Mean”: the mean respiratory amplitude. - “RSP_RRV”: the different respiratory rate variability metrices. See rsp_rrv() docstrings for details.

See also

bio_process(), rsp_eventrelated()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Process the data
>>> df, info = nk.rsp_process(data["RSP"], sampling_rate=100)

>>> # Single dataframe is passed
>>> nk.rsp_intervalrelated(df) 
>>>
>>> epochs = nk.epochs_create(df, events=[0, 15000], sampling_rate=100, epochs_end=150)
>>> nk.rsp_intervalrelated(epochs) 

rsp_peaks(rsp_cleaned, sampling_rate=1000, method='khodadad2018', amplitude_min=0.3)

Identify extrema in a respiration (RSP) signal.

This function rsp_findpeaks() and rsp_fixpeaks to identify and process inhalation peaks and exhalation troughs in a preprocessed respiration signal using different sets of parameters, such as:

• `Khodadad et al. (2018)

<https://iopscience.iop.org/article/10.1088/1361-6579/aad7e6/meta>`_

• `BioSPPy

<https://github.com/PIA-Group/BioSPPy/blob/master/biosppy/signals/resp.py>`_

Parameters

• rsp_cleaned (Union[list, np.array, pd.Series]) – The cleaned respiration channel as returned by rsp_clean().

• sampling_rate (int) – The sampling frequency of ‘rsp_cleaned’ (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “khodadad2018” (default) or “biosppy”.

• amplitude_min (float) – Only applies if method is “khodadad2018”. Extrema that have a vertical distance smaller than (outlier_threshold * average vertical distance) to any direct neighbour are removed as false positive outliers. i.e., outlier_threshold should be a float with positive sign (the default is 0.3). Larger values of outlier_threshold correspond to more conservative thresholds (i.e., more extrema removed as outliers).

Returns

• info (dict) – A dictionary containing additional information, in this case the samples at which inhalation peaks and exhalation troughs occur, accessible with the keys “RSP_Peaks”, and “RSP_Troughs”, respectively.

• peak_signal (DataFrame) – A DataFrame of same length as the input signal in which occurences of inhalation peaks and exhalation troughs are marked as “1” in lists of zeros with the same length as rsp_cleaned. Accessible with the keys “RSP_Peaks” and “RSP_Troughs” respectively.

See also

rsp_clean(), signal_rate(), rsp_findpeaks(), rsp_fixpeaks(), rsp_amplitude(), rsp_process(), rsp_plot()

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> rsp = nk.rsp_simulate(duration=30, respiratory_rate=15)
>>> cleaned = nk.rsp_clean(rsp, sampling_rate=1000)
>>> peak_signal, info = nk.rsp_peaks(cleaned, sampling_rate=1000)
>>>
>>> data = pd.concat([pd.DataFrame({"RSP": rsp}), peak_signal], axis=1)
>>> fig = nk.signal_plot(data)
>>> fig 

rsp_phase(peaks, troughs=None, desired_length=None)

Compute respiratory phase (inspiration and expiration).

Finds the respiratory phase, labelled as 1 for inspiration and 0 for expiration.

Parameters

• peaks (list or array or DataFrame or Series or dict) – The samples at which the inhalation peaks occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with rsp_findpeaks().

• troughs (list or array or DataFrame or Series or dict) – The samples at which the inhalation troughs occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with rsp_findpeaks().

• desired_length (int) – By default, the returned respiration rate has the same number of elements as peaks. If set to an integer, the returned rate will be interpolated between peaks over desired_length samples. Has no effect if a DataFrame is passed in as the peaks argument.

Returns

signals (DataFrame) – A DataFrame of same length as rsp_signal containing the following columns: - “RSP_Inspiration”: breathing phase, marked by “1” for inspiration and “0” for expiration. - “RSP_Phase_Completion”: breathing phase completion, expressed in percentage (from 0 to 1), representing the stage of the current respiratory phase.

See also

rsp_clean(), rsp_peaks(), rsp_amplitude(), rsp_process(), rsp_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=30, respiratory_rate=15)
>>> cleaned = nk.rsp_clean(rsp, sampling_rate=1000)
>>> peak_signal, info = nk.rsp_peaks(cleaned)
>>>
>>> phase = nk.rsp_phase(peak_signal, desired_length=len(cleaned))
>>> fig = nk.signal_plot([rsp, phase], standardize=True)
>>> fig 

rsp_plot(rsp_signals, sampling_rate=None)

Visualize respiration (RSP) data.

Parameters

• rsp_signals (DataFrame) – DataFrame obtained from rsp_process().

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second).

Examples

>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=90, respiratory_rate=15)
>>> rsp_signals, info = nk.rsp_process(rsp, sampling_rate=1000)
>>> fig = nk.rsp_plot(rsp_signals)
>>> fig 

Returns

fig – Figure representing a plot of the processed rsp signals.

See also

rsp_process()

rsp_process(rsp_signal, sampling_rate=1000, method='khodadad2018')

Process a respiration (RSP) signal.

Convenience function that automatically processes a respiration signal with one of the following methods:

• `Khodadad et al. (2018)

<https://iopscience.iop.org/article/10.1088/1361-6579/aad7e6/meta>`_

• `BioSPPy

<https://github.com/PIA-Group/BioSPPy/blob/master/biosppy/signals/resp.py>`_

Parameters

• rsp_signal (Union[list, np.array, pd.Series]) – The raw respiration channel (as measured, for instance, by a respiration belt).

• sampling_rate (int) – The sampling frequency of rsp_signal (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “khodadad2018” (default) or “biosppy”.

Returns

• signals (DataFrame) – A DataFrame of same length as rsp_signal containing the following columns: - “RSP_Raw”: the raw signal. - “RSP_Clean”: the cleaned signal. - “RSP_Peaks”: the inhalation peaks marked as “1” in a list of zeros. - “RSP_Troughs”: the exhalation troughs marked as “1” in a list of zeros. - “RSP_Rate”: breathing rate interpolated between inhalation peaks. - “RSP_Amplitude”: breathing amplitude interpolated between inhalation peaks. - “RSP_Phase”: breathing phase, marked by “1” for inspiration and “0” for expiration. - “RSP_PhaseCompletion”: breathing phase completion, expressed in percentage (from 0 to 1), representing the stage of the current respiratory phase.

• info (dict) – A dictionary containing the samples at which inhalation peaks and exhalation troughs occur, accessible with the keys “RSP_Peaks”, and “RSP_Troughs”, respectively.

See also

rsp_clean(), rsp_findpeaks(), signal_rate(), rsp_amplitude(), rsp_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=90, respiratory_rate=15)
>>> signals, info = nk.rsp_process(rsp, sampling_rate=1000)
>>> fig = nk.rsp_plot(signals)
>>> fig 

rsp_rate(peaks, sampling_rate=1000, desired_length=None, interpolation_method='monotone_cubic')

Calculate signal rate from a series of peaks.

This function can also be called either via ecg_rate(), `ppg_rate() or rsp_rate() (aliases provided for consistency).

Parameters

• peaks (Union[list, np.array, pd.DataFrame, pd.Series, dict]) – The samples at which the peaks occur. If an array is passed in, it is assumed that it was obtained with signal_findpeaks(). If a DataFrame is passed in, it is assumed it is of the same length as the input signal in which occurrences of R-peaks are marked as “1”, with such containers obtained with e.g., ecg_findpeaks() or rsp_findpeaks().

• sampling_rate (int) – The sampling frequency of the signal that contains peaks (in Hz, i.e., samples/second). Defaults to 1000.

• desired_length (int) – If left at the default None, the returned rated will have the same number of elements as peaks. If set to a value larger than the sample at which the last peak occurs in the signal (i.e., peaks[-1]), the returned rate will be interpolated between peaks over desired_length samples. To interpolate the rate over the entire duration of the signal, set desired_length to the number of samples in the signal. Cannot be smaller than or equal to the sample at which the last peak occurs in the signal. Defaults to None.

• interpolation_method (str) – Method used to interpolate the rate between peaks. See signal_interpolate(). ‘monotone_cubic’ is chosen as the default interpolation method since it ensures monotone interpolation between data points (i.e., it prevents physiologically implausible “overshoots” or “undershoots” in the y-direction). In contrast, the widely used cubic spline interpolation does not ensure monotonicity.

Returns

array – A vector containing the rate.

See also

signal_findpeaks(), signal_fixpeaks(), signal_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, sampling_rate=1000, frequency=1)
>>> info = nk.signal_findpeaks(signal)
>>>
>>> rate = nk.signal_rate(peaks=info["Peaks"], desired_length=len(signal))
>>> fig = nk.signal_plot(rate)
>>> fig 

rsp_rrv(rsp_rate, peaks=None, sampling_rate=1000, show=False, silent=True)

Computes time domain and frequency domain features for Respiratory Rate Variability (RRV) analysis.

Parameters

• rsp_rate (array) – Array containing the respiratory rate, produced by signal_rate().

• peaks (dict) – The samples at which the inhalation peaks occur. Dict returned by rsp_peaks(). Defaults to None.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

• show (bool) – If True, will return a Poincaré plot, a scattergram, which plots each breath-to-breath interval against the next successive one. The ellipse centers around the average breath-to-breath interval. Defaults to False.

• silent (bool) – If False, warnings will be printed. Default to True.

Returns

DataFrame – DataFrame consisting of the computed RRV metrics, which includes: - “RRV_SDBB”: the standard deviation of the breath-to-breath intervals. - “RRV_RMSSD”: the root mean square of successive differences of the breath-to-breath intervals. - “RRV_SDSD”: the standard deviation of the successive differences between adjacent breath-to-breath intervals. - “RRV_BBx”: the number of successive interval differences that are greater than x seconds. - “RRV-pBBx”: the proportion of breath-to-breath intervals that are greater than x seconds, out of the total number of intervals. - “RRV_VLF”: spectral power density pertaining to very low frequency band i.e., 0 to .04 Hz by default. - “RRV_LF”: spectral power density pertaining to low frequency band i.e., .04 to .15 Hz by default. - “RRV_HF”: spectral power density pertaining to high frequency band i.e., .15 to .4 Hz by default. - “RRV_LFHF”: the ratio of low frequency power to high frequency power. - “RRV_LFn”: the normalized low frequency, obtained by dividing the low frequency power by the total power. - “RRV_HFn”: the normalized high frequency, obtained by dividing the low frequency power by total power. - “RRV_SD1”: SD1 is a measure of the spread of breath-to-breath intervals on the Poincaré plot perpendicular to the line of identity. It is an index of short-term variability. - “RRV_SD2”: SD2 is a measure of the spread of breath-to-breath intervals on the Poincaré plot along the line of identity. It is an index of long-term variability. - “RRV_SD2SD1”: the ratio between short and long term fluctuations of the breath-to-breath intervals (SD2 divided by SD1). - “RRV_ApEn”: the approximate entropy of RRV, calculated by entropy_approximate(). - “RRV_SampEn”: the sample entropy of RRV, calculated by entropy_sample(). - “RRV_DFA_1”: the “short-term” fluctuation value generated from Detrended Fluctuation Analysis i.e. the root mean square deviation from the fitted trend of the breath-to-breath intervals. Will only be computed if mora than 160 breath cycles in the signal. - “RRV_DFA_2”: the long-term fluctuation value. Will only be computed if mora than 640 breath cycles in the signal.

See also

signal_rate(), rsp_peaks(), signal_power(), entropy_sample(), entropy_approximate()

Examples

>>> import neurokit2 as nk
>>>
>>> rsp = nk.rsp_simulate(duration=90, respiratory_rate=15)
>>> rsp, info = nk.rsp_process(rsp)
>>> rrv = nk.rsp_rrv(rsp, show=True) 

References

• Soni, R., & Muniyandi, M. (2019). Breath rate variability: a novel measure to study the meditation

effects. International Journal of Yoga, 12(1), 45.

rsp_simulate(duration=10, length=None, sampling_rate=1000, noise=0.01, respiratory_rate=15, method='breathmetrics', random_state=None)

Simulate a respiratory signal.

Generate an artificial (synthetic) respiratory signal of a given duration and rate.

Parameters

• duration (int) – Desired length of duration (s).

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second).

• length (int) – The desired length of the signal (in samples).

• noise (float) – Noise level (amplitude of the laplace noise).

• respiratory_rate (float) – Desired number of breath cycles in one minute.

• method (str) – The model used to generate the signal. Can be ‘sinusoidal’ for a simulation based on a trigonometric sine wave that roughly approximates a single respiratory cycle. If ‘breathmetrics’ (default), will use an advanced model desbribed Noto, et al. (2018).

• random_state (int) – Seed for the random number generator.

Returns

array – Vector containing the respiratory signal.

Examples

>>> import pandas as pd
>>> import numpy as np
>>> import neurokit2 as nk
>>>
>>> rsp1 = nk.rsp_simulate(duration=30, method="sinusoidal")
>>> rsp2 = nk.rsp_simulate(duration=30, method="breathmetrics")
>>> fig = pd.DataFrame({"RSP_Simple": rsp1, "RSP_Complex": rsp2}).plot(subplots=True)
>>> fig 

References

Noto, T., Zhou, G., Schuele, S., Templer, J., & Zelano, C. (2018). Automated analysis of breathing waveforms using BreathMetrics: A respiratory signal processing toolbox. Chemical Senses, 43(8), 583–597. https://doi.org/10.1093/chemse/bjy045

See also

rsp_clean(), rsp_findpeaks(), signal_rate(), rsp_process(), rsp_plot()

EDA

Submodule for NeuroKit.

eda_analyze(data, sampling_rate=1000, method='auto')

Performs EDA analysis on either epochs (event-related analysis) or on longer periods of data such as resting- state data.

Parameters

• data (Union[dict, pd.DataFrame]) – A dictionary of epochs, containing one DataFrame per epoch, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df(). Can also take a DataFrame of processed signals from a longer period of data, typically generated by eda_process() or bio_process(). Can also take a dict containing sets of separate periods of data.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second). Defaults to 1000Hz.

• method (str) – Can be one of ‘event-related’ for event-related analysis on epochs, or ‘interval-related’ for analysis on longer periods of data. Defaults to ‘auto’ where the right method will be chosen based on the mean duration of the data (‘event-related’ for duration under 10s).

Returns

DataFrame – A dataframe containing the analyzed EDA features. If event-related analysis is conducted, each epoch is indicated by the Label column. See eda_eventrelated() and eda_intervalrelated() docstrings for details.

See also

bio_process(), eda_process(), epochs_create(), eda_eventrelated(), eda_intervalrelated()

Examples

>>> import neurokit2 as nk

>>> # Example 1: Download the data for event-related analysis
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data for event-related analysis
>>> df, info = nk.bio_process(eda=data["EDA"], sampling_rate=100)
>>> events = nk.events_find(data["Photosensor"], threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-0.1, epochs_end=1.9)
>>>
>>> # Analyze
>>> nk.eda_analyze(epochs, sampling_rate=100) 
>>>
>>> # Example 2: Download the resting-state data
>>> data = nk.data("bio_resting_8min_100hz")
>>>
>>> # Process the data
>>> df, info = nk.eda_process(data["EDA"], sampling_rate=100)
>>>
>>> # Analyze
>>> nk.eda_analyze(df, sampling_rate=100) 

eda_autocor(eda_cleaned, sampling_rate=1000, lag=4)

Computes autocorrelation measure of raw EDA signal i.e., the correlation between the time series data and a specified time-lagged version of itself.

Parameters

• eda_cleaned (Union[list, np.array, pd.Series]) – The cleaned EDA signal.

• sampling_rate (int) – The sampling frequency of raw EDA signal (in Hz, i.e., samples/second). Defaults to 1000Hz.

• lag (int) – Time lag in seconds. Defaults to 4 seconds to avoid autoregressive correlations approaching 1, as recommended by Halem et al. (2020).

Returns

float – Autocorrelation index of the eda signal.

See also

eda_simulate(), eda_clean()

Examples

>>> import neurokit2 as nk
>>>
>>> # Simulate EDA signal
>>> eda_signal = nk.eda_simulate(duration=5, scr_number=5, drift=0.1)
>>> eda_cleaned = nk.eda_clean(eda_signal)
>>> cor = nk.eda_autocor(eda_cleaned)
>>> cor 

References

• Halem, S., van Roekel, E., Kroencke, L., Kuper, N., & Denissen, J. (2020). Moments That Matter? On the Complexity of Using Triggers Based on Skin Conductance to Sample Arousing Events Within an Experience Sampling Framework. European Journal of Personality.

eda_changepoints(eda_cleaned)

Calculate the number of change points using of the skin conductance signal in terms of mean and variance. Defaults to an algorithm penalty of 10000, as recommended by Halem et al. (2020).

Parameters

eda_cleaned (Union[list, np.array, pd.Series]) – The cleaned EDA signal.

Returns

float – Number of changepoints in the

See also

eda_simulate()

Examples

>>> import neurokit2 as nk
>>>
>>> # Simulate EDA signal
>>> eda_signal = nk.eda_simulate(duration=5, scr_number=5, drift=0.1)
>>> eda_cleaned = nk.eda_clean(eda_signal)
>>> changepoints = nk.eda_changepoints(eda_cleaned)
>>> changepoints 

References

• Halem, S., van Roekel, E., Kroencke, L., Kuper, N., & Denissen, J. (2020). Moments That Matter? On the Complexity of Using Triggers Based on Skin Conductance to Sample Arousing Events Within an Experience Sampling Framework. European Journal of Personality.

eda_clean(eda_signal, sampling_rate=1000, method='neurokit')

Preprocess Electrodermal Activity (EDA) signal.

Parameters

• eda_signal (Union[list, np.array, pd.Series]) – The raw EDA signal.

• sampling_rate (int) – The sampling frequency of rsp_signal (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of ‘neurokit’ (default) or ‘biosppy’.

Returns

array – Vector containing the cleaned EDA signal.

See also

eda_simulate(), eda_findpeaks(), eda_process(), eda_plot()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> eda = nk.eda_simulate(duration=30, sampling_rate=100, scr_number=10, noise=0.01, drift=0.02)
>>> signals = pd.DataFrame({"EDA_Raw": eda,
...                         "EDA_BioSPPy": nk.eda_clean(eda, sampling_rate=100,method='biosppy'),
...                         "EDA_NeuroKit": nk.eda_clean(eda, sampling_rate=100, method='neurokit')})
>>> fig = signals.plot()
>>> fig 

eda_eventrelated(epochs, silent=False)

Performs event-related EDA analysis on epochs.

Parameters

• epochs (Union[dict, pd.DataFrame]) – A dict containing one DataFrame per event/trial, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df().

• silent (bool) – If True, silence possible warnings.

Returns

DataFrame – A dataframe containing the analyzed EDA features for each epoch, with each epoch indicated by the Label column (if not present, by the Index column). The analyzed features consist the following:

• ”EDA_SCR”: indication of whether Skin Conductance Response (SCR) occurs following the event (1 if an SCR onset is present and 0 if absent) and if so, its corresponding peak amplitude, time of peak, rise and recovery time. If there is no occurrence of SCR, nans are displayed for the below features.

• ”EDA_Peak_Amplitude”: the maximum amplitude of the phasic component of the signal.

• ”SCR_Peak_Amplitude”: the peak amplitude of the first SCR in each epoch.

• ”SCR_Peak_Amplitude_Time”: the timepoint of each first SCR peak amplitude.

• ”SCR_RiseTime”: the risetime of each first SCR i.e., the time it takes for SCR to reach peak amplitude from onset.

• ”SCR_RecoveryTime”: the half-recovery time of each first SCR i.e., the time it takes for SCR to decrease to half amplitude.

See also

events_find(), epochs_create(), bio_process()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example with simulated data
>>> eda = nk.eda_simulate(duration=15, scr_number=3)
>>>
>>> # Process data
>>> eda_signals, info = nk.eda_process(eda, sampling_rate=1000)
>>> epochs = nk.epochs_create(eda_signals, events=[5000, 10000, 15000], sampling_rate=1000,
...                           epochs_start=-0.1, epochs_end=1.9)
>>>
>>> # Analyze
>>> nk.eda_eventrelated(epochs) 
>>>
>>> # Example with real data
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data
>>> df, info = nk.bio_process(eda=data["EDA"], sampling_rate=100)
>>> events = nk.events_find(data["Photosensor"], threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-0.1, epochs_end=6.9)
>>>
>>> # Analyze
>>> nk.eda_eventrelated(epochs) 

eda_findpeaks(eda_phasic, sampling_rate=1000, method='neurokit', amplitude_min=0.1)

Identify Skin Conductance Responses (SCR) in Electrodermal Activity (EDA).

Low-level function used by eda_peaks() to identify Skin Conductance Responses (SCR) peaks in the phasic component of Electrodermal Activity (EDA) with different possible methods. See eda_peaks() for details.

Parameters

• eda_phasic (Union[list, np.array, pd.Series]) – The phasic component of the EDA signal (from eda_phasic()).

• sampling_rate (int) – The sampling frequency of the EDA signal (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “neurokit” (default), “gamboa2008”, “kim2004” (the default in BioSPPy) or “vanhalem2020”.

• amplitude_min (float) – Only used if ‘method’ is ‘neurokit’ or ‘kim2004’. Minimum threshold by which to exclude SCRs (peaks) as relative to the largest amplitude in the signal.

Returns

info (dict) – A dictionary containing additional information, in this case the aplitude of the SCR, the samples at which the SCR onset and the SCR peaks occur. Accessible with the keys “SCR_Amplitude”, “SCR_Onsets”, and “SCR_Peaks” respectively.

See also

eda_simulate(), eda_clean(), eda_phasic(), eda_fixpeaks(), eda_peaks(), eda_process(), eda_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> # Get phasic component
>>> eda_signal = nk.eda_simulate(duration=30, scr_number=5, drift=0.1, noise=0)
>>> eda_cleaned = nk.eda_clean(eda_signal)
>>> eda = nk.eda_phasic(eda_cleaned)
>>> eda_phasic = eda["EDA_Phasic"].values
>>>
>>> # Find peaks
>>> gamboa2008 = nk.eda_findpeaks(eda_phasic, method="gamboa2008")
>>> kim2004 = nk.eda_findpeaks(eda_phasic, method="kim2004")
>>> neurokit = nk.eda_findpeaks(eda_phasic, method="neurokit")
>>> vanhalem2020 = nk.eda_findpeaks(eda_phasic, method="vanhalem2020")
>>> fig = nk.events_plot([gamboa2008["SCR_Peaks"], kim2004["SCR_Peaks"], vanhalem2020["SCR_Peaks"],
...                       neurokit["SCR_Peaks"]], eda_phasic)
>>> fig 

References

• Gamboa, H. (2008). Multi-modal behavioral biometrics based on hci and electrophysiology. PhD ThesisUniversidade.

• Kim, K. H., Bang, S. W., & Kim, S. R. (2004). Emotion recognition system using short-term monitoring of physiological signals. Medical and biological engineering and computing, 42(3), 419-427.

• van Halem, S., Van Roekel, E., Kroencke, L., Kuper, N., & Denissen, J. (2020). Moments That Matter? On the Complexity of Using Triggers Based on Skin Conductance to Sample Arousing Events Within an Experience Sampling Framework. European Journal of Personality.

eda_fixpeaks(peaks, onsets=None, height=None)

Correct Skin Conductance Responses (SCR) peaks.

Low-level function used by eda_peaks() to correct the peaks found by eda_findpeaks(). Doesn’t do anything for now for EDA. See eda_peaks() for details.

Parameters

• peaks (list or array or DataFrame or Series or dict) – The samples at which the SCR peaks occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with eda_findpeaks().

• onsets (list or array or DataFrame or Series or dict) – The samples at which the SCR onsets occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with eda_findpeaks(). Defaults to None.

• height (list or array or DataFrame or Series or dict) – The samples at which the amplitude of the SCR peaks occur. If a dict or a DataFrame is passed, it is assumed that these containers were obtained with eda_findpeaks(). Defaults to None.

Returns

info (dict) – A dictionary containing additional information, in this case the aplitude of the SCR, the samples at which the SCR onset and the SCR peaks occur. Accessible with the keys “SCR_Amplitude”, “SCR_Onsets”, and “SCR_Peaks” respectively.

See also

eda_simulate(), eda_clean(), eda_phasic(), eda_findpeaks(), eda_peaks(), eda_process(), eda_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> # Get phasic component
>>> eda_signal = nk.eda_simulate(duration=30, scr_number=5, drift=0.1, noise=0)
>>> eda_cleaned = nk.eda_clean(eda_signal)
>>> eda = nk.eda_phasic(eda_cleaned)
>>> eda_phasic = eda["EDA_Phasic"].values
>>>
>>> # Find and fix peaks
>>> info = nk.eda_findpeaks(eda_phasic)
>>> info = nk.eda_fixpeaks(info)
>>>
>>> fig = nk.events_plot(info["SCR_Peaks"], eda_phasic)
>>> fig 

eda_intervalrelated(data)

Performs EDA analysis on longer periods of data (typically > 10 seconds), such as resting-state data.

Parameters

data (Union[dict, pd.DataFrame]) – A DataFrame containing the different processed signal(s) as different columns, typically generated by eda_process() or bio_process(). Can also take a dict containing sets of separately processed DataFrames.

Returns

DataFrame – A dataframe containing the analyzed EDA features. The analyzed features consist of the following: - “SCR_Peaks_N”: the number of occurrences of Skin Conductance Response (SCR). - “SCR_Peaks_Amplitude_Mean”: the mean amplitude of the SCR peak occurrences.

See also

bio_process(), eda_eventrelated()

Examples

>>> import neurokit2 as nk
>>>
>>> # Download data
>>> data = nk.data("bio_resting_8min_100hz")
>>>
>>> # Process the data
>>> df, info = nk.eda_process(data["EDA"], sampling_rate=100)
>>>
>>> # Single dataframe is passed
>>> nk.eda_intervalrelated(df) 
>>>
>>> epochs = nk.epochs_create(df, events=[0, 25300], sampling_rate=100, epochs_end=20)
>>> nk.eda_intervalrelated(epochs) 

eda_peaks(eda_phasic, sampling_rate=1000, method='neurokit', amplitude_min=0.1)

Identify Skin Conductance Responses (SCR) in Electrodermal Activity (EDA).

Identify Skin Conductance Responses (SCR) peaks in the phasic component of Electrodermal Activity (EDA) with different possible methods, such as:

• `Gamboa, H. (2008)

<http://www.lx.it.pt/~afred/pub/thesisHugoGamboa.pdf>`_ - Kim et al. (2004)

Parameters

• eda_phasic (Union[list, np.array, pd.Series]) – The phasic component of the EDA signal (from eda_phasic()).

• sampling_rate (int) – The sampling frequency of the EDA signal (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “neurokit” (default), “gamboa2008” or “kim2004” (the default in BioSPPy).

• amplitude_min (float) – Only used if ‘method’ is ‘neurokit’ or ‘kim2004’. Minimum threshold by which to exclude SCRs (peaks) as relative to the largest amplitude in the signal.

Returns

• info (dict) – A dictionary containing additional information, in this case the aplitude of the SCR, the samples at which the SCR onset and the SCR peaks occur. Accessible with the keys “SCR_Amplitude”, “SCR_Onsets”, and “SCR_Peaks” respectively.

• signals (DataFrame) – A DataFrame of same length as the input signal in which occurences of SCR peaks are marked as “1” in lists of zeros with the same length as eda_cleaned. Accessible with the keys “SCR_Peaks”.

See also

eda_simulate(), eda_clean(), eda_phasic(), eda_process(), eda_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> # Get phasic component
>>> eda_signal = nk.eda_simulate(duration=30, scr_number=5, drift=0.1, noise=0, sampling_rate=100)
>>> eda_cleaned = nk.eda_clean(eda_signal, sampling_rate=100)
>>> eda = nk.eda_phasic(eda_cleaned, sampling_rate=100)
>>> eda_phasic = eda["EDA_Phasic"].values
>>>
>>> # Find peaks
>>> _, gamboa2008 = nk.eda_peaks(eda_phasic, method="gamboa2008")
>>> _, kim2004 = nk.eda_peaks(eda_phasic, method="kim2004")
>>> _, neurokit = nk.eda_peaks(eda_phasic, method="neurokit")
>>> nk.events_plot([gamboa2008["SCR_Peaks"], kim2004["SCR_Peaks"], neurokit["SCR_Peaks"]], eda_phasic) 
<Figure ...>

References

• Gamboa, H. (2008). Multi-modal behavioral biometrics based on hci and electrophysiology. PhD ThesisUniversidade.

• Kim, K. H., Bang, S. W., & Kim, S. R. (2004). Emotion recognition system using short-term monitoring of physiological signals. Medical and biological engineering and computing, 42(3), 419-427.

eda_phasic(eda_signal, sampling_rate=1000, method='highpass')

Decompose Electrodermal Activity (EDA) into Phasic and Tonic components.

Decompose the Electrodermal Activity (EDA) into two components, namely Phasic and Tonic, using different methods including cvxEDA (Greco, 2016) or Biopac’s Acqknowledge algorithms.

Parameters

• eda_signal (Union[list, np.array, pd.Series]) – The raw EDA signal.

• sampling_rate (int) – The sampling frequency of raw EDA signal (in Hz, i.e., samples/second). Defaults to 1000Hz.

• method (str) – The processing pipeline to apply. Can be one of “cvxEDA”, “median”, “smoothmedian”, “highpass”, “biopac”, or “acqknowledge”.

Returns

DataFrame – DataFrame containing the ‘Tonic’ and the ‘Phasic’ components as columns.

See also

eda_simulate(), eda_clean(), eda_peaks(), eda_process(), eda_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> # Simulate EDA signal
>>> eda_signal = nk.eda_simulate(duration=30, scr_number=5, drift=0.1)
>>>
>>> # Decompose using different algorithms
>>> cvxEDA = nk.eda_phasic(nk.standardize(eda_signal), method='cvxeda')
>>> smoothMedian = nk.eda_phasic(nk.standardize(eda_signal), method='smoothmedian')
>>> highpass = nk.eda_phasic(nk.standardize(eda_signal), method='highpass')
>>>
>>> data = pd.concat([cvxEDA.add_suffix('_cvxEDA'), smoothMedian.add_suffix('_SmoothMedian'),
...                   highpass.add_suffix('_Highpass')], axis=1)
>>> data["EDA_Raw"] = eda_signal
>>> fig = data.plot()
>>> fig 
>>>
>>> eda_signal = nk.data("bio_eventrelated_100hz")["EDA"]
>>> data = nk.eda_phasic(nk.standardize(eda_signal), sampling_rate=100)
>>> data["EDA_Raw"] = eda_signal
>>> fig = nk.signal_plot(data, standardize=True)
>>> fig 

References

• cvxEDA: https://github.com/lciti/cvxEDA.

• Greco, A., Valenza, G., & Scilingo, E. P. (2016). Evaluation of CDA and CvxEDA Models. In Advances in Electrodermal Activity Processing with Applications for Mental Health (pp. 35-43). Springer International Publishing.

• Greco, A., Valenza, G., Lanata, A., Scilingo, E. P., & Citi, L. (2016). cvxEDA: A convex optimization approach to electrodermal activity processing. IEEE Transactions on Biomedical Engineering, 63(4), 797-804.

eda_plot(eda_signals, sampling_rate=None)

Visualize electrodermal activity (EDA) data.

Parameters

• eda_signals (DataFrame) – DataFrame obtained from eda_process().

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second). Defaults to None.

Returns

fig – Figure representing a plot of the processed EDA signals.

Examples

>>> import neurokit2 as nk
>>>
>>> eda_signal = nk.eda_simulate(duration=30, scr_number=5, drift=0.1, noise=0, sampling_rate=250)
>>> eda_signals, info = nk.eda_process(eda_signal, sampling_rate=250)
>>> fig = nk.eda_plot(eda_signals)
>>> fig 

See also

eda_process()

eda_process(eda_signal, sampling_rate=1000, method='neurokit')

Process Electrodermal Activity (EDA).

Convenience function that automatically processes electrodermal activity (EDA) signal.

Parameters

• eda_signal (Union[list, np.array, pd.Series]) – The raw EDA signal.

• sampling_rate (int) – The sampling frequency of rsp_signal (in Hz, i.e., samples/second).

• method (str) – The processing pipeline to apply. Can be one of “biosppy” or “neurokit” (default).

Returns

• signals (DataFrame) – A DataFrame of same length as eda_signal containing the following columns:

  • ”EDA_Raw”: the raw signal.

  • ”EDA_Clean”: the cleaned signal.

  • ”EDA_Tonic”: the tonic component of the signal, or the Tonic Skin Conductance Level (SCL).

  • ”EDA_Phasic”: the phasic component of the signal, or the Phasic Skin Conductance Response (SCR).

  • ”SCR_Onsets”: the samples at which the onsets of the peaks occur, marked as “1” in a list of zeros.

  • ”SCR_Peaks”: the samples at which the peaks occur, marked as “1” in a list of zeros.

  • ”SCR_Height”: the SCR amplitude of the signal including the Tonic component. Note that cumulative effects of close- occurring SCRs might lead to an underestimation of the amplitude.

  • ”SCR_Amplitude”: the SCR amplitude of the signal excluding the Tonic component.

  • ”SCR_RiseTime”: the time taken for SCR onset to reach peak amplitude within the SCR.

  • ”SCR_Recovery”: the samples at which SCR peaks recover (decline) to half amplitude, marked as “1” in a list of zeros.

• info (dict) – A dictionary containing the information of each SCR peak (see eda_findpeaks()).

See also

eda_simulate(), eda_clean(), eda_phasic(), eda_findpeaks(), eda_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> eda_signal = nk.eda_simulate(duration=30, scr_number=5, drift=0.1, noise=0)
>>> signals, info = nk.eda_process(eda_signal, sampling_rate=1000)
>>> fig = nk.eda_plot(signals)
>>> fig 

eda_simulate(duration=10, length=None, sampling_rate=1000, noise=0.01, scr_number=1, drift=- 0.01, random_state=None)

Simulate Electrodermal Activity (EDA) signal.

Generate an artificial (synthetic) EDA signal of a given duration and sampling rate.

Parameters

• duration (int) – Desired recording length in seconds.

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second). Defaults to 1000Hz.

• length (int) – The desired length of the signal (in samples). Defaults to None.

• noise (float) – Noise level (amplitude of the laplace noise). Defaults to 0.01.

• scr_number (int) – Desired number of skin conductance responses (SCRs), i.e., peaks. Defaults to 1.

• drift (float or list) – The slope of a linear drift of the signal. Defaults to -0.01.

• random_state (int) – Seed for the random number generator. Defaults to None.

Returns

array – Vector containing the EDA signal.

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> eda = nk.eda_simulate(duration=10, scr_number=3)
>>> fig = nk.signal_plot(eda)
>>> fig 

See also

ecg_simulate(), rsp_simulate(), emg_simulate(), ppg_simulate()

References

• Bach, D. R., Flandin, G., Friston, K. J., & Dolan, R. J. (2010). Modelling event-related skin conductance responses. International Journal of Psychophysiology, 75(3), 349-356.

EMG

Submodule for NeuroKit.

emg_activation(emg_amplitude=None, emg_cleaned=None, sampling_rate=1000, method='threshold', threshold='default', duration_min='default', **kwargs)

Detects onset in EMG signal based on the amplitude threshold.

Parameters

• emg_amplitude (array) – At least one EMG-related signal. Either the amplitude of the EMG signal, obtained from emg_amplitude() for methods like ‘threshold’ or ‘mixture’), and / or the cleaned EMG signal (for methods like ‘pelt’).

• emg_cleaned (array) – At least one EMG-related signal. Either the amplitude of the EMG signal, obtained from emg_amplitude() for methods like ‘threshold’ or ‘mixture’), and / or the cleaned EMG signal (for methods like ‘pelt’).

• sampling_rate (int) – The sampling frequency of emg_signal (in Hz, i.e., samples/second).

• method (str) – The algorithm used to discriminate between activity and baseline. Can be one of ‘mixture’ (default) or ‘threshold’. If ‘mixture’, will use a Gaussian Mixture Model to categorize between the two states. If ‘threshold’, will consider as activated all points which amplitude is superior to the threshold.

• threshold (float) – If method is ‘mixture’, then it corresponds to the minimum probability required to be considered as activated (default to 0.33). If method is ‘threshold’, then it corresponds to the minimum amplitude to detect as onset. Defaults to one tenth of the standard deviation of emg_amplitude.

• duration_min (float) – The minimum duration of a period of activity or non-activity in seconds. If ‘default’, will be set to 0.05 (50 ms).

• kwargs (optional) – Other arguments.

Returns

• info (dict) – A dictionary containing additional information, in this case the samples at which the onsets, offsets, and periods of activations of the EMG signal occur, accessible with the key “EMG_Onsets”, “EMG_Offsets”, and “EMG_Activity” respectively.

• activity_signal (DataFrame) – A DataFrame of same length as the input signal in which occurences of onsets, offsets, and activity (above the threshold) of the EMG signal are marked as “1” in lists of zeros with the same length as emg_amplitude. Accessible with the keys “EMG_Onsets”, “EMG_Offsets”, and “EMG_Activity” respectively.

See also

emg_simulate(), emg_clean(), emg_amplitude(), emg_process(), emg_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> # Simulate signal and obtain amplitude
>>> emg = nk.emg_simulate(duration=10, burst_number=3)
>>> emg_cleaned = nk.emg_clean(emg)
>>> emg_amplitude = nk.emg_amplitude(emg_cleaned)
>>>
>>> # Threshold method
>>> activity, info = nk.emg_activation(emg_amplitude=emg_amplitude, method="threshold")
>>> fig = nk.events_plot([info["EMG_Offsets"], info["EMG_Onsets"]], emg_cleaned)
>>> fig 
>>>
>>> # Threshold method
>>> activity, info = nk.emg_activation(emg_cleaned=emg_cleaned, method="pelt")
>>> nk.signal_plot([emg_cleaned, activity["EMG_Activity"]])
>>> fig 

References

• BioSPPy: https://github.com/PIA-Group/BioSPPy/blob/master/biosppy/signals/emg.py

emg_amplitude(emg_cleaned)

Compute electromyography (EMG) amplitude.

Compute electromyography amplitude given the cleaned respiration signal, done by calculating the linear envelope of the signal.

Parameters

emg_cleaned (Union[list, np.array, pd.Series]) – The cleaned electromyography channel as returned by emg_clean().

Returns

array – A vector containing the electromyography amplitude.

See also

emg_clean(), emg_rate(), emg_process(), emg_plot()

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> emg = nk.emg_simulate(duration=10, sampling_rate=1000, burst_number=3)
>>> cleaned = nk.emg_clean(emg, sampling_rate=1000)
>>>
>>> amplitude = nk.emg_amplitude(cleaned)
>>> fig = pd.DataFrame({"EMG": emg, "Amplitude": amplitude}).plot(subplots=True)
>>> fig 

emg_analyze(data, sampling_rate=1000, method='auto')

Performs EMG analysis on either epochs (event-related analysis) or on longer periods of data such as resting- state data.

Parameters

• data (Union[dict, pd.DataFrame]) – A dictionary of epochs, containing one DataFrame per epoch, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df(). Can also take a DataFrame of processed signals from a longer period of data, typically generated by emg_process() or bio_process(). Can also take a dict containing sets of separate periods of data.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second). Defaults to 1000Hz.

• method (str) – Can be one of ‘event-related’ for event-related analysis on epochs, or ‘interval-related’ for analysis on longer periods of data. Defaults to ‘auto’ where the right method will be chosen based on the mean duration of the data (‘event-related’ for duration under 10s).

Returns

DataFrame – A dataframe containing the analyzed EMG features. If event-related analysis is conducted, each epoch is indicated by the Label column. See emg_eventrelated() and emg_intervalrelated() docstrings for details.

See also

bio_process(), emg_process(), epochs_create(), emg_eventrelated(), emg_intervalrelated()

Examples

>>> import neurokit2 as nk
>>> import pandas as pd

>>> # Example with simulated data
>>> emg = nk.emg_simulate(duration=20, sampling_rate=1000, burst_number=3)
>>> emg_signals, info = nk.emg_process(emg, sampling_rate=1000)
>>> epochs = nk.epochs_create(emg_signals, events=[3000, 6000, 9000], sampling_rate=1000,
...                           epochs_start=-0.1, epochs_end=1.9)
>>>
>>> # Event-related analysis
>>> nk.emg_analyze(epochs, method="event-related") 
>>>
>>> # Interval-related analysis
>>> nk.emg_analyze(emg_signals, method="interval-related") 

emg_clean(emg_signal, sampling_rate=1000)

Preprocess an electromyography (emg) signal.

Clean an EMG signal using a set of parameters, such as: in `BioSPPy <https://github.com/PIA-Group/BioSPPy/blob/e65da30f6379852ecb98f8e2e0c9b4b5175416c3/biosppy/signals/emg.py>>`_: fourth order 100 Hz highpass Butterworth filter followed by a constant detrending.

Parameters

• emg_signal (Union[list, np.array, pd.Series]) – The raw EMG channel.

• sampling_rate (int) – The sampling frequency of emg_signal (in Hz, i.e., samples/second). Defaults to 1000.

Returns

array – Vector containing the cleaned EMG signal.

See also

emg_amplitude(), emg_process(), emg_plot()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> emg = nk.emg_simulate(duration=10, sampling_rate=1000)
>>> signals = pd.DataFrame({"EMG_Raw": emg, "EMG_Cleaned":nk.emg_clean(emg, sampling_rate=1000)})
>>> fig = signals.plot()
>>> fig 

emg_eventrelated(epochs, silent=False)

Performs event-related EMG analysis on epochs.

Parameters

• epochs (Union[dict, pd.DataFrame]) – A dict containing one DataFrame per event/trial, usually obtained via epochs_create(), or a DataFrame containing all epochs, usually obtained via epochs_to_df().

• silent (bool) – If True, silence possible warnings.

Returns

DataFrame – A dataframe containing the analyzed EMG features for each epoch, with each epoch indicated by the Label column (if not present, by the Index column). The analyzed features consist of the following:

• ”EMG_Activation”: indication of whether there is muscular activation following the onset

of the event (1 if present, 0 if absent) and if so, its corresponding amplitude features and the number of activations in each epoch. If there is no activation, nans are displayed for the below features. - “EMG_Amplitude_Mean”: the mean amplitude of the activity. - “EMG_Amplitude_Max”: the maximum amplitude of the activity. - “EMG_Amplitude_Max_Time”: the time of maximum amplitude. - “EMG_Bursts”: the number of activations, or bursts of activity, within each epoch.

See also

emg_simulate(), emg_process(), events_find(), epochs_create()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example with simulated data
>>> emg = nk.emg_simulate(duration=20, sampling_rate=1000, burst_number=3)
>>> emg_signals, info = nk.emg_process(emg, sampling_rate=1000)
>>> epochs = nk.epochs_create(emg_signals, events=[3000, 6000, 9000], sampling_rate=1000,
...                           epochs_start=-0.1,epochs_end=1.9)
>>> nk.emg_eventrelated(epochs) 

emg_intervalrelated(data)

Performs EMG analysis on longer periods of data (typically > 10 seconds), such as resting-state data.

Parameters

data (Union[dict, pd.DataFrame]) – A DataFrame containing the different processed signal(s) as different columns, typically generated by emg_process() or bio_process(). Can also take a dict containing sets of separately processed DataFrames.

Returns

DataFrame – A dataframe containing the analyzed EMG features. The analyzed features consist of the following: - “EMG_Activation_N”: the number of bursts of muscular activity. - “EMG_Amplitude_Mean”: the mean amplitude of the muscular activity.

See also

bio_process(), emg_eventrelated()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example with simulated data
>>> emg = nk.emg_simulate(duration=40, sampling_rate=1000, burst_number=3)
>>> emg_signals, info = nk.emg_process(emg, sampling_rate=1000)
>>>
>>> # Single dataframe is passed
>>> nk.emg_intervalrelated(emg_signals) 
>>>
>>> epochs = nk.epochs_create(emg_signals, events=[0, 20000], sampling_rate=1000, epochs_end=20)
>>> nk.emg_intervalrelated(epochs) 

emg_plot(emg_signals, sampling_rate=None)

Visualize electromyography (EMG) data.

Parameters

• emg_signals (DataFrame) – DataFrame obtained from emg_process().

• sampling_rate (int) – The sampling frequency of the EMG (in Hz, i.e., samples/second). Needs to be supplied if the data should be plotted over time in seconds. Otherwise the data is plotted over samples. Defaults to None.

Returns

fig – Figure representing a plot of the processed emg signals.

Examples

>>> import neurokit2 as nk
>>>
>>> emg = nk.emg_simulate(duration=10, sampling_rate=1000, burst_number=3)
>>> emg_signals, _ = nk.emg_process(emg, sampling_rate=1000)
>>> fig = nk.emg_plot(emg_signals)
>>> fig 

See also

ecg_process()

emg_process(emg_signal, sampling_rate=1000)

Process a electromyography (EMG) signal.

Convenience function that automatically processes an electromyography signal.

Parameters

• emg_signal (Union[list, np.array, pd.Series]) – The raw electromyography channel.

• sampling_rate (int) – The sampling frequency of emg_signal (in Hz, i.e., samples/second).

Returns

• signals (DataFrame) – A DataFrame of same length as emg_signal containing the following columns: - “EMG_Raw”: the raw signal. - “EMG_Clean”: the cleaned signal. - “EMG_Amplitude”: the signal amplitude, or the activation level of the signal. - “EMG_Activity”: the activity of the signal for which amplitude exceeds the threshold specified, marked as “1” in a list of zeros. - “EMG_Onsets”: the onsets of the amplitude, marked as “1” in a list of zeros. - “EMG_Offsets”: the offsets of the amplitude, marked as “1” in a list of zeros.

• info (dict) – A dictionary containing the information of each amplitude onset, offset, and peak activity (see emg_activation()).

See also

emg_clean(), emg_amplitude(), emg_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> emg = nk.emg_simulate(duration=10, sampling_rate=1000, burst_number=3)
>>> signals, info = nk.emg_process(emg, sampling_rate=1000)
>>> fig = nk.emg_plot(signals)
>>> fig 

emg_simulate(duration=10, length=None, sampling_rate=1000, noise=0.01, burst_number=1, burst_duration=1.0, random_state=42)

Simulate an EMG signal.

Generate an artificial (synthetic) EMG signal of a given duration and sampling rate.

Parameters

• duration (int) – Desired recording length in seconds.

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second).

• length (int) – The desired length of the signal (in samples).

• noise (float) – Noise level (gaussian noise).

• burst_number (int) – Desired number of bursts of activity (active muscle periods).

• burst_duration (float or list) – Duration of the bursts. Can be a float (each burst will have the same duration) or a list of durations for each bursts.

• random_state (int) – Seed for the random number generator.

Returns

array – Vector containing the EMG signal.

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> emg = nk.emg_simulate(duration=10, burst_number=3)
>>> fig = nk.signal_plot(emg)
>>> fig 

See also

ecg_simulate(), rsp_simulate(), eda_simulate(), ppg_simulate()

References

This function is based on this script.

EEG

Submodule for NeuroKit.

mne_channel_add(raw, channel, channel_type=None, channel_name=None, sync_index_raw=0, sync_index_channel=0)

Add channel as array to MNE.

Add a channel to a mne’s Raw m/eeg file. It will basically synchronize the channel to the eeg data following a particular index and add it.

Parameters

• raw (mne.io.Raw) – Raw EEG data from MNE.

• channel (list or array) – The signal to be added.

• channel_type (str) – Channel type. Currently supported fields are ‘ecg’, ‘bio’, ‘stim’, ‘eog’, ‘misc’, ‘seeg’, ‘ecog’, ‘mag’, ‘eeg’, ‘ref_meg’, ‘grad’, ‘emg’, ‘hbr’ or ‘hbo’.

• channel_name (str) – Desired channel name.

• sync_index_raw (int or list) – An index (e.g., the onset of the same event marked in the same signal), in the raw data, by which to align the two inputs. This can be used in case the EEG data and the channel to add do not have the same onsets and must be aligned through some common event.

• sync_index_channel (int or list) – An index (e.g., the onset of the same event marked in the same signal), in the channel to add, by which to align the two inputs. This can be used in case the EEG data and the channel to add do not have the same onsets and must be aligned through some common event.

Returns

mne.io.Raw – Raw data in FIF format.

Example

>>> import neurokit2 as nk
>>> import mne
>>>
>>> # Let's say that the 42nd sample point in the EEG correspond to the 333rd point in the ECG
>>> event_index_in_eeg = 42
>>> event_index_in_ecg = 333
>>>
>>> raw = mne.io.read_raw_fif(mne.datasets.sample.data_path() + '/MEG/sample/sample_audvis_raw.fif',
...                           preload=True) 
>>> ecg = nk.ecg_simulate(length=170000)
>>>
>>> raw = nk.mne_channel_add(raw, ecg, sync_index_raw=event_index_in_eeg,
...                          sync_index_channel=event_index_in_ecg, channel_type="ecg") 

mne_channel_extract(raw, what, name=None)

Channel array extraction from MNE.

Select one or several channels by name and returns them in a dataframe.

Parameters

• raw (mne.io.Raw) – Raw EEG data.

• what (str or list) – Can be ‘MEG’, which will extract all MEG channels, ‘EEG’, which will extract all EEG channels, or ‘EOG’, which will extract all EOG channels (that is, if channel names are named with prefixes of their type e.g., ‘EEG 001’ etc. or ‘EOG 061’). Provide exact a single or a list of channel’s name(s) if not (e.g., [‘124’, ‘125’]).

• name (str or list) – Useful only when extracting one channel. Can also take a list of names for renaming multiple channels, Otherwise, defaults to None.

Returns

DataFrame – A DataFrame or Series containing the channel(s).

Example

>>> import neurokit2 as nk
>>> import mne
>>>
>>> raw = mne.io.read_raw_fif(mne.datasets.sample.data_path() +
...                           '/MEG/sample/sample_audvis_raw.fif', preload=True) 
>>>
>>> raw_channel = nk.mne_channel_extract(raw, what=["EEG 060", "EEG 055"], name=['060', '055']) 
>>> eeg_channels = nk.mne_channel_extract(raw, "EEG") 
>>> eog_channels = nk.mne_channel_extract(raw, what='EOG', name='EOG') 

Signal Processing

Submodule for NeuroKit.

signal_autocor(signal, lag=None, normalize=True)

Auto-correlation of a 1-dimensional sequences.

Parameters

• signal (Union[list, np.array, pd.Series]) – Vector of values.

• normalize (bool) – Normalize the autocorrelation output.

• lag (int) – Time lag. If specified, one value of autocorrelation between signal with its lag self will be returned.

Returns

r – The cross-correlation of the signal with itself at different time lags. Minimum time lag is 0, maximum time lag is the length of the signal. Or a correlation value at a specific lag if lag is not None.

Examples

>>> import neurokit2 as nk
>>>
>>> x = [1, 2, 3, 4, 5]
>>> autocor = nk.signal_autocor(x)
>>> autocor 

signal_binarize(signal, method='threshold', threshold='auto')

Binarize a continuous signal.

Convert a continuous signal into zeros and ones depending on a given threshold.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• method (str) – The algorithm used to discriminate between the two states. Can be one of ‘mixture’ (default) or ‘threshold’. If ‘mixture’, will use a Gaussian Mixture Model to categorize between the two states. If ‘threshold’, will consider as activated all points which value is superior to the threshold.

• threshold (float) – If method is ‘mixture’, then it corresponds to the minimum probability required to be considered as activated (if ‘auto’, then 0.5). If method is ‘threshold’, then it corresponds to the minimum amplitude to detect as onset. If “auto”, takes the value between the max and the min.

Returns

list – A list or array depending on the type passed.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = np.cos(np.linspace(start=0, stop=20, num=1000))
>>> binary = nk.signal_binarize(signal)
>>> fig = pd.DataFrame({"Raw": signal, "Binary": binary}).plot()
>>> fig 

signal_changepoints(signal, change='meanvar', penalty=None, show=False)

Change Point Detection.

Only the PELT method is implemented for now.

Parameters

• signal (Union[list, np.array, pd.Series]) – Vector of values.

• change (str) – Can be one of “meanvar” (default), “mean” or “var”.

• penalty (float) – The algorithm penalty. Default to np.log(len(signal)).

• show (bool) – Defaults to False.

Returns

• Array – Values indicating the samples at which the changepoints occur.

• Fig – Figure of plot of signal with markers of changepoints.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.emg_simulate(burst_number=3)
>>> fig = nk.signal_changepoints(signal, change="var", show=True)
>>> fig 

References

• Killick, R., Fearnhead, P., & Eckley, I. A. (2012). Optimal detection of changepoints with a linear

computational cost. Journal of the American Statistical Association, 107(500), 1590-1598.

signal_decompose(signal, method='emd', n_components=None, **kwargs)

Decompose a signal.

Signal decomposition into different sources using different methods, such as Empirical Mode Decomposition (EMD) or Singular spectrum analysis (SSA)-based signal separation method.

The extracted components can then be recombined into meaningful sources using signal_recompose().

Parameters

• signal (Union[list, np.array, pd.Series]) – Vector of values.

• method (str) – The decomposition method. Can be one of ‘emd’ or ‘ssa’.

• n_components (int) – Number of components to extract. Only used for ‘ssa’ method. If None, will default to 50.

• **kwargs – Other arguments passed to other functions.

Returns

Array – Components of the decomposed signal.

See also

signal_recompose()

Examples

>>> import neurokit2 as nk
>>>
>>> # Create complex signal
>>> signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)  # High freq
>>> signal += 3 * nk.signal_simulate(duration=10, frequency=3, noise=0.01)  # Higher freq
>>> signal += 3 * np.linspace(0, 2, len(signal))  # Add baseline and trend
>>> signal += 2 * nk.signal_simulate(duration=10, frequency=0.1, noise=0)
>>>
>>> nk.signal_plot(signal)
>>>
>>> # EMD method
>>> components = nk.signal_decompose(signal, method="emd")
>>> fig = nk.signal_plot(components)  # Visualize components
>>> fig  
>>>
>>> # SSA method
>>> components = nk.signal_decompose(signal, method="ssa")
>>> fig = nk.signal_plot(components)  # Visualize components
>>> fig  

signal_detrend(signal, method='polynomial', order=1, regularization=500, alpha=0.75, window=1.5, stepsize=0.02)

Polynomial detrending of signal.

Apply a baseline (order = 0), linear (order = 1), or polynomial (order > 1) detrending to the signal (i.e., removing a general trend). One can also use other methods, such as smoothness priors approach described by Tarvainen (2002) or LOESS regression, but these scale badly for long signals.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• method (str) – Can be one of ‘polynomial’ (default; traditional detrending of a given order) or ‘tarvainen2002’ to use the smoothness priors approach described by Tarvainen (2002) (mostly used in HRV analyses as a lowpass filter to remove complex trends), ‘loess’ for LOESS smoothing trend removal or ‘locreg’ for local linear regression (the ‘runline’ algorithm from chronux).

• order (int) – Only used if method is ‘polynomial’. The order of the polynomial. 0, 1 or > 1 for a baseline (‘constant detrend’, i.e., remove only the mean), linear (remove the linear trend) or polynomial detrending, respectively. Can also be ‘auto’, it which case it will attempt to find the optimal order to minimize the RMSE.

• regularization (int) – Only used if method=’tarvainen2002’. The regularization parameter (default to 500).

• alpha (float) – Only used if method is ‘loess’. The parameter which controls the degree of smoothing.

• window (float) – Only used if method is ‘locreg’. The detrending ‘window’ should correspond to the desired low frequency band to remove multiplied by the sampling rate (for instance, 1.5*1000 will remove frequencies below 1.5Hz for a signal sampled at 1000Hz).

• stepsize (float) – Only used if method is ‘locreg’. Simialrly to ‘window’, ‘stepsize’ should also be multiplied by the sampling rate.

Returns

array – Vector containing the detrended signal.

See also

signal_filter(), fit_loess()

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>> import matplotlib.pyplot as plt
>>>
>>> # Simulate signal with low and high frequency
>>> signal = nk.signal_simulate(frequency=[0.1, 2], amplitude=[2, 0.5], sampling_rate=100)
>>> signal = signal + (3 + np.linspace(0, 6, num=len(signal)))  # Add baseline and linear trend
>>>
>>> # Apply detrending algorithms
>>> baseline = nk.signal_detrend(signal, order=0)  # Constant detrend (removes the mean)
>>> linear = nk.signal_detrend(signal, order=1)  # Linear detrend
>>> quadratic = nk.signal_detrend(signal, order=2)  # Quadratic detrend
>>> cubic = nk.signal_detrend(signal, order=3)  # Cubic detrend
>>> poly10 = nk.signal_detrend(signal, order=10)  # Linear detrend (10th order)
>>> tarvainen = nk.signal_detrend(signal, method='tarvainen2002')  # Tarvainen (2002) method
>>> loess = nk.signal_detrend(signal, method='loess')  # LOESS detrend (smooth removal)
>>> locreg = nk.signal_detrend(signal, method='locreg',
...                            window=1.5*100, stepsize=0.02*100)  # Local regression (100Hz)
>>>
>>> # Visualize different methods
>>> axes = pd.DataFrame({"Original signal": signal,
...                      "Baseline": baseline,
...                      "Linear": linear,
...                      "Quadratic": quadratic,
...                      "Cubic": cubic,
...                      "Polynomial (10th)": poly10,
...                      "Tarvainen": tarvainen,
...                      "LOESS": loess,
...                      "Local Regression": locreg}).plot(subplots=True)
>>> # Plot horizontal lines to better visualize the detrending
>>> for subplot in axes: 
...     subplot.axhline(y=0, color='k', linestyle='--') 

References

• `Tarvainen, M. P., Ranta-Aho, P. O., & Karjalainen, P. A. (2002). An advanced detrending method

with application to HRV analysis. IEEE Transactions on Biomedical Engineering, 49(2), 172-175. <https://ieeexplore.ieee.org/document/979357>`_

signal_distort(signal, sampling_rate=1000, noise_shape='laplace', noise_amplitude=0, noise_frequency=100, powerline_amplitude=0, powerline_frequency=50, artifacts_amplitude=0, artifacts_frequency=100, artifacts_number=5, linear_drift=False, random_state=None, silent=False)

Signal distortion.

Add noise of a given frequency, amplitude and shape to a signal.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

• noise_shape (str) – The shape of the noise. Can be one of ‘laplace’ (default) or ‘gaussian’.

• noise_amplitude (float) – The amplitude of the noise (the scale of the random function, relative to the standard deviation of the signal).

• noise_frequency (float) – The frequency of the noise (in Hz, i.e., samples/second).

• powerline_amplitude (float) – The amplitude of the powerline noise (relative to the standard deviation of the signal).

• powerline_frequency (float) – The frequency of the powerline noise (in Hz, i.e., samples/second).

• artifacts_amplitude (float) – The amplitude of the artifacts (relative to the standard deviation of the signal).

• artifacts_frequency (int) – The frequency of the artifacts (in Hz, i.e., samples/second).

• artifacts_number (int) – The number of artifact bursts. The bursts have a random duration between 1 and 10% of the signal duration.

• linear_drift (bool) – Whether or not to add linear drift to the signal.

• random_state (int) – Seed for the random number generator. Keep it fixed for reproducible results.

• silent (bool) – Whether or not to display warning messages.

Returns

array – Vector containing the distorted signal.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, frequency=0.5)
>>>
>>> # Noise
>>> noise = pd.DataFrame({"Freq100": nk.signal_distort(signal, noise_frequency=200),
...                       "Freq50": nk.signal_distort(signal, noise_frequency=50),
...                       "Freq10": nk.signal_distort(signal, noise_frequency=10),
...                       "Freq5": nk.signal_distort(signal, noise_frequency=5),
...                       "Raw": signal}).plot()
>>> noise 
>>>
>>> # Artifacts
>>> artifacts = pd.DataFrame({"1Hz": nk.signal_distort(signal, noise_amplitude=0,
...                                                    artifacts_frequency=1, artifacts_amplitude=0.5),
...                           "5Hz": nk.signal_distort(signal, noise_amplitude=0,
...                                                    artifacts_frequency=5, artifacts_amplitude=0.2),
...                           "Raw": signal}).plot()
>>> artifacts 

signal_filter(signal, sampling_rate=1000, lowcut=None, highcut=None, method='butterworth', order=2, window_size='default', powerline=50)

Filter a signal using ‘butterworth’, ‘fir’ or ‘savgol’ filters.

Apply a lowpass (if ‘highcut’ frequency is provided), highpass (if ‘lowcut’ frequency is provided) or bandpass (if both are provided) filter to the signal.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values. or “bandstop”.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

• lowcut (float) – Lower cutoff frequency in Hz. The default is None.

• highcut (float) – Upper cutoff frequency in Hz. The default is None.

• method (str) – Can be one of ‘butterworth’, ‘fir’, ‘bessel’ or ‘savgol’. Note that for Butterworth, the function uses the SOS method from scipy.signal.sosfiltfilt, recommended for general purpose filtering. One can also specify “butterworth_ba’ for a more traditional and legacy method (often implemented in other software).

• order (int) – Only used if method is ‘butterworth’ or ‘savgol’. Order of the filter (default is 2).

• window_size (int) – Only used if method is ‘savgol’. The length of the filter window (i.e. the number of coefficients). Must be an odd integer. If ‘default’, will be set to the sampling rate divided by 10 (101 if the sampling rate is 1000 Hz).

• powerline (int) – Only used if method is ‘powerline’. The powerline frequency (normally 50 Hz or 60 Hz).

See also

signal_detrend(), signal_psd()

Returns

array – Vector containing the filtered signal.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, frequency=0.5) # Low freq
>>> signal += nk.signal_simulate(duration=10, frequency=5) # High freq
>>>
>>> # Lowpass
>>> fig1 = pd.DataFrame({"Raw": signal,
...                      "Butter_2": nk.signal_filter(signal, highcut=3, method='butterworth', order=2),
...                      "Butter_2_BA": nk.signal_filter(signal, highcut=3, method='butterworth_ba', order=2),
...                      "Butter_5": nk.signal_filter(signal, highcut=3, method='butterworth', order=5),
...                      "Butter_5_BA": nk.signal_filter(signal, highcut=3, method='butterworth_ba', order=5),
...                      "Bessel_2": nk.signal_filter(signal, highcut=3, method='bessel', order=2),
...                      "Bessel_5": nk.signal_filter(signal, highcut=3, method='bessel', order=5),
...                      "FIR": nk.signal_filter(signal, highcut=3, method='fir')}).plot(subplots=True)
>>> fig1 

>>> # Highpass
>>> fig2 = pd.DataFrame({"Raw": signal,
...                      "Butter_2": nk.signal_filter(signal, lowcut=2, method='butterworth', order=2),
...                      "Butter_2_ba": nk.signal_filter(signal, lowcut=2, method='butterworth_ba', order=2),
...                      "Butter_5": nk.signal_filter(signal, lowcut=2, method='butterworth', order=5),
...                      "Butter_5_BA": nk.signal_filter(signal, lowcut=2, method='butterworth_ba', order=5),
...                      "Bessel_2": nk.signal_filter(signal, lowcut=2, method='bessel', order=2),
...                      "Bessel_5": nk.signal_filter(signal, lowcut=2, method='bessel', order=5),
...                      "FIR": nk.signal_filter(signal, lowcut=2, method='fir')}).plot(subplots=True)
>>> fig2 

>>> # Bandpass in real-life scenarios
>>> original = nk.rsp_simulate(duration=30, method="breathmetrics", noise=0)
>>> signal = nk.signal_distort(original, noise_frequency=[0.1, 2, 10, 100], noise_amplitude=1,
...                            powerline_amplitude=1)
>>>
>>> # Bandpass between 10 and 30 breaths per minute (respiratory rate range)
>>> fig3 = pd.DataFrame({"Raw": signal,
...                      "Butter_2": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                                   method='butterworth', order=2),
...                      "Butter_2_BA": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                                      method='butterworth_ba', order=2),
...                      "Butter_5": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                                   method='butterworth', order=5),
...                      "Butter_5_BA": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                                      method='butterworth_ba', order=5),
...                      "Bessel_2": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                                   method='bessel', order=2),
...                      "Bessel_5": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                                   method='bessel', order=5),
...                      "FIR": nk.signal_filter(signal, lowcut=10/60, highcut=30/60,
...                                              method='fir'),
...                      "Savgol": nk.signal_filter(signal, method='savgol')}).plot(subplots=True)
>>> fig3 

signal_findpeaks(signal, height_min=None, height_max=None, relative_height_min=None, relative_height_max=None, relative_mean=True, relative_median=False, relative_max=False)

Find peaks in a signal.

Locate peaks (local maxima) in a signal and their related characteristics, such as height (prominence), width and distance with other peaks.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• height_min (float) – The minimum height (i.e., amplitude in terms of absolute values). For example,``height_min=20`` will remove all peaks which height is smaller or equal to 20 (in the provided signal’s values).

• height_max (float) – The maximum height (i.e., amplitude in terms of absolute values).

• relative_height_min (float) – The minimum height (i.e., amplitude) relative to the sample (see below). For example, relative_height_min=-2.96 will remove all peaks which height lies below 2.96 standard deviations from the mean of the heights.

• relative_height_max (float) – The maximum height (i.e., amplitude) relative to the sample (see below).

• relative_mean (bool) – If a relative threshold is specified, how should it be computed (i.e., relative to what?). relative_mean=True will use Z-scores.

• relative_median (bool) – If a relative threshold is specified, how should it be computed (i.e., relative to what?). Relative to median uses a more robust form of standardization (see standardize()).

• relative_max (bool) – If a relative threshold is specified, how should it be computed (i.e., relative to what?). Reelative to max will consider the maximum height as the reference.

Returns

dict – Returns a dict itself containing 5 arrays: - ‘Peaks’ contains the peaks indices (as relative to the given signal). For instance, the value 3 means that the third data point of the signal is a peak. - ‘Distance’ contains, for each peak, the closest distance with another peak. Note that these values will be recomputed after filtering to match the selected peaks. - ‘Height’ contains the prominence of each peak. See scipy.signal.peak_prominences(). - ‘Width’ contains the width of each peak. See scipy.signal.peak_widths(). - ‘Onset’ contains the onset, start (or left trough), of each peak. - ‘Offset’ contains the offset, end (or right trough), of each peak.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>> import scipy.misc
>>>
>>> signal = nk.signal_simulate(duration=5)
>>> info = nk.signal_findpeaks(signal)
>>> fig1 = nk.events_plot([info["Onsets"], info["Peaks"]], signal)
>>> fig1 
>>>
>>> signal = nk.signal_distort(signal)
>>> info = nk.signal_findpeaks(signal, height_min=1)
>>> fig2 = nk.events_plot(info["Peaks"], signal)
>>> fig2 
>>>
>>> # Filter peaks
>>> ecg = scipy.misc.electrocardiogram()
>>> signal = ecg[0:1000]
>>> info1 = nk.signal_findpeaks(signal, relative_height_min=0)
>>> info2 = nk.signal_findpeaks(signal, relative_height_min=1)
>>> fig3 = nk.events_plot([info1["Peaks"], info2["Peaks"]], signal)
>>> fig3 

See also

scipy.signal.find_peaks(), scipy.signal.peak_widths(), peak_prominences.signal.peak_widths(), eda_findpeaks(), ecg_findpeaks(), rsp_findpeaks(), signal_fixpeaks()

signal_fixpeaks(peaks, sampling_rate=1000, iterative=True, show=False, interval_min=None, interval_max=None, relative_interval_min=None, relative_interval_max=None, robust=False, method='Kubios')

Correct erroneous peak placements.

Identify and correct erroneous peak placements based on outliers in peak-to-peak differences (period).

Parameters

• peaks (list or array or DataFrame or Series or dict) – The samples at which the peaks occur. If an array is passed in, it is assumed that it was obtained with signal_findpeaks(). If a DataFrame is passed in, it is assumed to be obtained with ecg_findpeaks() or ppg_findpeaks() and to be of the same length as the input signal.

• sampling_rate (int) – The sampling frequency of the signal that contains the peaks (in Hz, i.e., samples/second).

• iterative (bool) – Whether or not to apply the artifact correction repeatedly (results in superior artifact correction).

• show (bool) – Whether or not to visualize artifacts and artifact thresholds.

• interval_min (float) – The minimum interval between the peaks.

• interval_max (float) – The maximum interval between the peaks.

• relative_interval_min (float) – The minimum interval between the peaks as relative to the sample (expressed in standard deviation from the mean).

• relative_interval_max (float) – The maximum interval between the peaks as relative to the sample (expressed in standard deviation from the mean).

• robust (bool) – Use a robust method of standardization (see standardize()) for the relative thresholds.

• method (str) – Either “Kubios” or “Neurokit”. “Kubios” uses the artifact detection and correction described in Lipponen, J. A., & Tarvainen, M. P. (2019). Note that “Kubios” is only meant for peaks in ECG or PPG. “neurokit” can be used with peaks in ECG, PPG, or respiratory data.

Returns

• peaks_clean (array) – The corrected peak locations.

• artifacts (dict) – Only if method=”Kubios”. A dictionary containing the indices of artifacts, accessible with the keys “ectopic”, “missed”, “extra”, and “longshort”.

See also

signal_findpeaks(), ecg_findpeaks(), ecg_peaks(), ppg_findpeaks(), ppg_peaks()

Examples

>>> import neurokit2 as nk
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>>
>>> # Kubios
>>> ecg = nk.ecg_simulate(duration=240, noise=0.25, heart_rate=70, random_state=42)
>>> rpeaks_uncorrected = nk.ecg_findpeaks(ecg)
>>> artifacts, rpeaks_corrected = nk.signal_fixpeaks(rpeaks_uncorrected, iterative=True,
...                                                  show=True, method="Kubios")
>>> rate_corrected = nk.signal_rate(rpeaks_corrected, desired_length=len(ecg))
>>> rate_uncorrected = nk.signal_rate(rpeaks_uncorrected, desired_length=len(ecg))
>>>
>>> fig, ax = plt.subplots()
>>> ax.plot(rate_uncorrected, label="heart rate without artifact correction") 
>>> ax.plot(rate_corrected, label="heart rate with artifact correction") 
>>> ax.legend(loc="upper right") 
>>>
>>> # NeuroKit
>>> signal = nk.signal_simulate(duration=4, sampling_rate=1000, frequency=1)
>>> peaks_true = nk.signal_findpeaks(signal)["Peaks"]
>>> peaks = np.delete(peaks_true, [1])  # create gaps
>>>
>>> signal = nk.signal_simulate(duration=20, sampling_rate=1000, frequency=1)
>>> peaks_true = nk.signal_findpeaks(signal)["Peaks"]
>>> peaks = np.delete(peaks_true, [5, 15])  # create gaps
>>> peaks = np.sort(np.append(peaks, [1350, 11350, 18350]))  # add artifacts
>>>
>>> peaks_corrected = nk.signal_fixpeaks(peaks=peaks, interval_min=0.5, interval_max=1.5, method="neurokit")
>>> # Plot and shift original peaks to the rightto see the difference.
>>> fig = nk.events_plot([peaks + 50, peaks_corrected], signal)
>>> fig 

References

• Lipponen, J. A., & Tarvainen, M. P. (2019). A robust algorithm for heart rate variability time

series artefact correction using novel beat classification. Journal of medical engineering & technology, 43(3), 173-181. 10.1080/03091902.2019.1640306

signal_formatpeaks(info, desired_length, peak_indices=None)

Transforms an peak-info dict to a signal of given length.

signal_interpolate(x_values, y_values, x_new=None, method='quadratic')

Interpolate a signal.

Interpolate a signal using different methods.

Parameters

• x_values (Union[list, np.array, pd.Series]) – The samples corresponding to the values to be interpolated.

• y_values (Union[list, np.array, pd.Series]) – The values to be interpolated.

• x_new (Union[list, np.array, pd.Series] or int) – The samples at which to interpolate the y_values. Samples before the first value in x_values or after the last value in x_values will be extrapolated. If an integer is passed, nex_x will be considered as the desired length of the interpolated signal between the first and the last values of x_values. No extrapolation will be done for values before or after the first and the last valus of x_values.

• method (str) – Method of interpolation. Can be ‘linear’, ‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘previous’, ‘next’ or ‘monotone_cubic’. ‘zero’, ‘slinear’, ‘quadratic’ and ‘cubic’ refer to a spline interpolation of zeroth, first, second or third order; ‘previous’ and ‘next’ simply return the previous or next value of the point) or as an integer specifying the order of the spline interpolator to use. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.PchipInterpolator.html for details on the ‘monotone_cubic’ method.

Returns

array – Vector of interpolated samples.

Examples

>>> import numpy as np
>>> import neurokit2 as nk
>>> import matplotlib.pyplot as plt
>>>
>>> # Generate points
>>> signal = nk.signal_simulate(duration=1, sampling_rate=10)
>>>
>>> # List all interpolation methods and interpolation parameters
>>> interpolation_methods = ["zero", "linear", "quadratic", "cubic", 5, "nearest", "monotone_cubic"]
>>> x_values = np.linspace(0, 1, num=10)
>>> x_new = np.linspace(0, 1, num=1000)
>>>
>>> # Visualize all interpolations
>>> fig, ax = plt.subplots() 
>>> ax.scatter(x_values, signal, label="original datapoints", zorder=3) 
>>> for im in interpolation_methods:
...     signal_interpolated = nk.signal_interpolate(x_values, signal, x_new=x_new, method=im)
...     ax.plot(x_new, signal_interpolated, label=im) 
>>> ax.legend(loc="upper left") 

signal_merge(signal1, signal2, time1=[0, 10], time2=[0, 10])

Arbitrary addition of two signals with different time ranges.

Parameters

• signal1 (Union[list, np.array, pd.Series]) – The first signal (i.e., a time series)s in the form of a vector of values.

• signal2 (Union[list, np.array, pd.Series]) – The second signal (i.e., a time series)s in the form of a vector of values.

• time1 (list) – Lists containing two numeric values corresponding to the beginning and end of signal1.

• time2 (list) – Same as above, but for signal2.

Returns

array – Vector containing the sum of the two signals.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal1 = np.cos(np.linspace(start=0, stop=10, num=100))
>>> signal2 = np.cos(np.linspace(start=0, stop=20, num=100))
>>>
>>> signal = nk.signal_merge(signal1, signal2, time1=[0, 10], time2=[-5, 5])
>>> nk.signal_plot(signal)

signal_period(peaks, sampling_rate=1000, desired_length=None, interpolation_method='monotone_cubic')

Calculate signal period from a series of peaks.

Parameters

• peaks (Union[list, np.array, pd.DataFrame, pd.Series, dict]) – The samples at which the peaks occur. If an array is passed in, it is assumed that it was obtained with signal_findpeaks(). If a DataFrame is passed in, it is assumed it is of the same length as the input signal in which occurrences of R-peaks are marked as “1”, with such containers obtained with e.g., ecg_findpeaks() or rsp_findpeaks().

• sampling_rate (int) – The sampling frequency of the signal that contains peaks (in Hz, i.e., samples/second). Defaults to 1000.

• desired_length (int) – If left at the default None, the returned period will have the same number of elements as peaks. If set to a value larger than the sample at which the last peak occurs in the signal (i.e., peaks[-1]), the returned period will be interpolated between peaks over desired_length samples. To interpolate the period over the entire duration of the signal, set desired_length to the number of samples in the signal. Cannot be smaller than or equal to the sample at which the last peak occurs in the signal. Defaults to None.

• interpolation_method (str) – Method used to interpolate the rate between peaks. See signal_interpolate(). ‘monotone_cubic’ is chosen as the default interpolation method since it ensures monotone interpolation between data points (i.e., it prevents physiologically implausible “overshoots” or “undershoots” in the y-direction). In contrast, the widely used cubic spline interpolation does not ensure monotonicity.

Returns

array – A vector containing the period.

See also

signal_findpeaks(), signal_fixpeaks(), signal_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, sampling_rate=1000, frequency=1)
>>> info = nk.signal_findpeaks(signal)
>>>
>>> period = nk.signal_period(peaks=info["Peaks"], desired_length=len(signal))
>>> nk.signal_plot(period)

signal_phase(signal, method='radians')

Compute the phase of the signal.

The real phase has the property to rotate uniformly, leading to a uniform distribution density. The prophase typically doesn’t fulfill this property. The following functions applies a nonlinear transformation to the phase signal that makes its distribution exactly uniform. If a binary vector is provided (containing 2 unique values), the function will compute the phase of completion of each phase as denoted by each value.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• method (str) – The values in which the phase is expressed. Can be ‘radians’ (default), ‘degrees’ (for values between 0 and 360) or ‘percents’ (for values between 0 and 1).

See also

signal_filter(), signal_zerocrossings(), signal_findpeaks()

Returns

array – A vector containing the phase of the signal, between 0 and 2*pi.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10)
>>> phase = nk.signal_phase(signal)
>>> nk.signal_plot([signal, phase])
>>>
>>> rsp = nk.rsp_simulate(duration=30)
>>> phase = nk.signal_phase(rsp, method="degrees")
>>> nk.signal_plot([rsp, phase])
>>>
>>> # Percentage of completion of two phases
>>> signal = nk.signal_binarize(nk.signal_simulate(duration=10))
>>> phase = nk.signal_phase(signal, method="percents")
>>> nk.signal_plot([signal, phase])

signal_plot(signal, sampling_rate=None, subplots=False, standardize=False, labels=None, **kwargs)

Plot signal with events as vertical lines.

Parameters

• signal (array or DataFrame) – Signal array (can be a dataframe with many signals).

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second). Needs to be supplied if the data should be plotted over time in seconds. Otherwise the data is plotted over samples. Defaults to None.

• subplots (bool) – If True, each signal is plotted in a subplot.

• standardize (bool) – If True, all signals will have the same scale (useful for visualisation).

• labels (str or list) – Defaults to None.

• **kwargs (optional) – Arguments passed to matplotlib plotting.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, sampling_rate=1000)
>>> nk.signal_plot(signal, labels='signal1', sampling_rate=1000, color="red")
>>>
>>> data = pd.DataFrame({"Signal2": np.cos(np.linspace(start=0, stop=20, num=1000)),
...                      "Signal3": np.sin(np.linspace(start=0, stop=20, num=1000)),
...                      "Signal4": nk.signal_binarize(np.cos(np.linspace(start=0, stop=40, num=1000)))})
>>> nk.signal_plot(data, labels=['signal_1', 'signal_2', 'signal_3'], subplots=False)
>>> nk.signal_plot([signal, data], standardize=True)

signal_power(signal, frequency_band, sampling_rate=1000, continuous=False, show=False, **kwargs)

Compute the power of a signal in a given frequency band.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• frequency_band (tuple or list) – Tuple or list of tuples indicating the range of frequencies to compute the power in.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

• continuous (bool) – Compute instant frequency, or continuous power.

• show (bool) – If True, will return a Poincaré plot. Defaults to False.

• **kwargs – Keyword arguments to be passed to signal_psd().

See also

signal_filter(), signal_psd()

Returns

pd.DataFrame – A DataFrame containing the Power Spectrum values and a plot if show is True.

Examples

>>> import neurokit2 as nk
>>> import numpy as np
>>>
>>> # Instant power
>>> signal = nk.signal_simulate(frequency=5) + 0.5*nk.signal_simulate(frequency=20)
>>> power_plot = nk.signal_power(signal, frequency_band=[(18, 22), (10, 14)], method="welch", show=True)
>>> power_plot 
>>>
>>> # Continuous (simulated signal)
>>> signal = np.concatenate((nk.ecg_simulate(duration=30, heart_rate=75),  nk.ecg_simulate(duration=30, heart_rate=85)))
>>> power = nk.signal_power(signal, frequency_band=[(72/60, 78/60), (82/60, 88/60)], continuous=True)
>>> processed, _ = nk.ecg_process(signal)
>>> power["ECG_Rate"] = processed["ECG_Rate"]
>>> nk.signal_plot(power, standardize=True) 
>>>
>>> # Continuous (real signal)
>>> signal = nk.data("bio_eventrelated_100hz")["ECG"]
>>> power = nk.signal_power(signal, sampling_rate=100, frequency_band=[(0.12, 0.15), (0.15, 0.4)], continuous=True)
>>> processed, _ = nk.ecg_process(signal, sampling_rate=100)
>>> power["ECG_Rate"] = processed["ECG_Rate"]
>>> nk.signal_plot(power, standardize=True)

signal_psd(signal, sampling_rate=1000, method='welch', show=True, min_frequency=0, max_frequency=inf, window=None, ar_order=15, order_criteria='KIC', order_corrected=True, burg_norm=True)

Compute the Power Spectral Density (PSD).

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

• method (str) – Either ‘multitapers’ (default; requires the ‘mne’ package), or ‘welch’ (requires the ‘scipy’ package).

• show (bool) – If True, will return a plot. If False, will return the density values that can be plotted externally.

• min_frequency (float) – The minimum frequency.

• max_frequency (float) – The maximum frequency.

• window (int) – Length of each window in seconds (for Welch method). If None (default), window will be automatically calculated to capture at least 2 cycles of min_frequency. If the length of recording does not allow the formal, window will be default to half of the length of recording.

• ar_order (int) – The order of autoregression (for AR methods e.g. Burg).

• order_criteria (str) – The criteria to automatically select order in parametric PSD (for AR methods e.g. Burg).

• order_corrected (bool) – Specify for AIC and KIC order_criteria. If unsure which method to use to choose the order, rely on the default of corrected KIC.

• bug_norm (bool) – Normalization for Burg method.

See also

signal_filter(), mne.time_frequency.psd_array_multitaper(), scipy.signal.welch()

Returns

pd.DataFrame – A DataFrame containing the Power Spectrum values and a plot if show is True.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(frequency=5) + 0.5*nk.signal_simulate(frequency=20)
>>>
>>> fig1 = nk.signal_psd(signal, method="multitapers")
>>> fig1 
>>> fig2 = nk.signal_psd(signal, method="welch", min_frequency=1)
>>> fig2 
>>> fig3 = nk.signal_psd(signal, method="burg", min_frequency=1)
>>>
>>> data = nk.signal_psd(signal, method="multitapers", max_frequency=30, show=False)
>>> fig4 = data.plot(x="Frequency", y="Power")
>>> fig4 
>>> data = nk.signal_psd(signal, method="welch", max_frequency=30, show=False, min_frequency=1)
>>> fig5 = data.plot(x="Frequency", y="Power")
>>> fig5 

signal_rate(peaks, sampling_rate=1000, desired_length=None, interpolation_method='monotone_cubic')

Calculate signal rate from a series of peaks.

This function can also be called either via ecg_rate(), `ppg_rate() or rsp_rate() (aliases provided for consistency).

Parameters

• peaks (Union[list, np.array, pd.DataFrame, pd.Series, dict]) – The samples at which the peaks occur. If an array is passed in, it is assumed that it was obtained with signal_findpeaks(). If a DataFrame is passed in, it is assumed it is of the same length as the input signal in which occurrences of R-peaks are marked as “1”, with such containers obtained with e.g., ecg_findpeaks() or rsp_findpeaks().

• sampling_rate (int) – The sampling frequency of the signal that contains peaks (in Hz, i.e., samples/second). Defaults to 1000.

• desired_length (int) – If left at the default None, the returned rated will have the same number of elements as peaks. If set to a value larger than the sample at which the last peak occurs in the signal (i.e., peaks[-1]), the returned rate will be interpolated between peaks over desired_length samples. To interpolate the rate over the entire duration of the signal, set desired_length to the number of samples in the signal. Cannot be smaller than or equal to the sample at which the last peak occurs in the signal. Defaults to None.

• interpolation_method (str) – Method used to interpolate the rate between peaks. See signal_interpolate(). ‘monotone_cubic’ is chosen as the default interpolation method since it ensures monotone interpolation between data points (i.e., it prevents physiologically implausible “overshoots” or “undershoots” in the y-direction). In contrast, the widely used cubic spline interpolation does not ensure monotonicity.

Returns

array – A vector containing the rate.

See also

signal_findpeaks(), signal_fixpeaks(), signal_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=10, sampling_rate=1000, frequency=1)
>>> info = nk.signal_findpeaks(signal)
>>>
>>> rate = nk.signal_rate(peaks=info["Peaks"], desired_length=len(signal))
>>> fig = nk.signal_plot(rate)
>>> fig 

signal_recompose(components, method='wcorr', threshold=0.5, keep_sd=None, **kwargs)

Combine signal sources after decomposition.

Combine and reconstruct meaningful signal sources after signal decomposition.

Parameters

• components (array) – Array of components obtained via signal_decompose().

• method (str) – The decomposition method. Can be one of ‘wcorr’.

• threshold (float) – The threshold used to group components together.

• keep_sd (float) – If a float is specified, will only keep the reconstructed components that are superior or equal to that percentage of the max standard deviaiton (SD) of the components. For instance, keep_sd=0.01 will remove all components with SD is lower that 1% of the max SD. This can be used to filter out noise.

• **kwargs – Other arguments to override for instance metric='chebyshev'.

Returns

Array – Components of the recomposed components.

Examples

>>> import neurokit2 as nk
>>>
>>> # Create complex signal
>>> signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)  # High freq
>>> signal += 3 * nk.signal_simulate(duration=10, frequency=3, noise=0.01)  # Higher freq
>>> signal += 3 * np.linspace(0, 2, len(signal))  # Add baseline and trend
>>> signal += 2 * nk.signal_simulate(duration=10, frequency=0.1, noise=0)
>>>
>>> # Decompose signal
>>> components = nk.signal_decompose(signal, method='emd')
>>>
>>> # Recompose
>>> recomposed = nk.signal_recompose(components, method='wcorr', threshold=0.90)
>>> fig = nk.signal_plot(components)  # Visualize components
>>> fig  

signal_resample(signal, desired_length=None, sampling_rate=None, desired_sampling_rate=None, method='interpolation')

Resample a continuous signal to a different length or sampling rate.

Up- or down-sample a signal. The user can specify either a desired length for the vector, or input the original sampling rate and the desired sampling rate. See https://github.com/neuropsychology/NeuroKit/scripts/resampling.ipynb for a comparison of the methods.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• desired_length (int) – The desired length of the signal.

• sampling_rate (int) – The original sampling frequency (in Hz, i.e., samples/second).

• desired_sampling_rate (int) – The desired (output) sampling frequency (in Hz, i.e., samples/second).

• method (str) – Can be ‘interpolation’ (see scipy.ndimage.zoom()), ‘numpy’ for numpy’s interpolation (see numpy.interp()),’pandas’ for Pandas’ time series resampling, ‘poly’ (see scipy.signal.resample_poly()) or ‘FFT’ (see scipy.signal.resample()) for the Fourier method. FFT is the most accurate (if the signal is periodic), but becomes exponentially slower as the signal length increases. In contrast, ‘interpolation’ is the fastest, followed by ‘numpy’, ‘poly’ and ‘pandas’.

Returns

array – Vector containing resampled signal values.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = np.cos(np.linspace(start=0, stop=20, num=100))
>>>
>>> # Downsample
>>> downsampled_interpolation = nk.signal_resample(signal, method="interpolation",
...                                                sampling_rate=1000, desired_sampling_rate=500)
>>> downsampled_fft = nk.signal_resample(signal, method="FFT",
...                                      sampling_rate=1000, desired_sampling_rate=500)
>>> downsampled_poly = nk.signal_resample(signal, method="poly",
...                                       sampling_rate=1000, desired_sampling_rate=500)
>>> downsampled_numpy = nk.signal_resample(signal, method="numpy",
...                                        sampling_rate=1000, desired_sampling_rate=500)
>>> downsampled_pandas = nk.signal_resample(signal, method="pandas",
...                                         sampling_rate=1000, desired_sampling_rate=500)
>>>
>>> # Upsample
>>> upsampled_interpolation = nk.signal_resample(downsampled_interpolation,
...                                              method="interpolation",
...                                              sampling_rate=500, desired_sampling_rate=1000)
>>> upsampled_fft = nk.signal_resample(downsampled_fft, method="FFT",
...                                    sampling_rate=500, desired_sampling_rate=1000)
>>> upsampled_poly = nk.signal_resample(downsampled_poly, method="poly",
...                                     sampling_rate=500, desired_sampling_rate=1000)
>>> upsampled_numpy = nk.signal_resample(downsampled_numpy, method="numpy",
...                                      sampling_rate=500, desired_sampling_rate=1000)
>>> upsampled_pandas = nk.signal_resample(downsampled_pandas, method="pandas",
...                                       sampling_rate=500, desired_sampling_rate=1000)
>>>
>>> # Compare with original
>>> fig = pd.DataFrame({"Original": signal,
...                     "Interpolation": upsampled_interpolation,
...                     "FFT": upsampled_fft,
...                     "Poly": upsampled_poly,
...                     "Numpy": upsampled_numpy,
...                     "Pandas": upsampled_pandas}).plot(style='.-')
>>> fig 
>>>
>>> # Timing benchmarks
>>> %timeit nk.signal_resample(signal, method="interpolation",
...                            sampling_rate=1000, desired_sampling_rate=500) 
>>> %timeit nk.signal_resample(signal, method="FFT",
...                            sampling_rate=1000, desired_sampling_rate=500) 
>>> %timeit nk.signal_resample(signal, method="poly",
...                            sampling_rate=1000, desired_sampling_rate=500) 
>>> %timeit nk.signal_resample(signal, method="numpy",
...                            sampling_rate=1000, desired_sampling_rate=500) 
>>> %timeit nk.signal_resample(signal, method="pandas",
...                            sampling_rate=1000, desired_sampling_rate=500) 

See also

scipy.signal.resample_poly(), scipy.signal.resample(), scipy.ndimage.zoom()

signal_simulate(duration=10, sampling_rate=1000, frequency=1, amplitude=0.5, noise=0, silent=False)

Simulate a continuous signal.

Parameters

• duration (float) – Desired length of duration (s).

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second).

• frequency (float or list) – Oscillatory frequency of the signal (in Hz, i.e., oscillations per second).

• amplitude (float or list) – Amplitude of the oscillations.

• noise (float) – Noise level (amplitude of the laplace noise).

• silent (bool) – If False (default), might print warnings if impossible frequencies are queried.

Returns

array – The simulated signal.

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> fig = pd.DataFrame({"1Hz": nk.signal_simulate(duration=5, frequency=1),
...                     "2Hz": nk.signal_simulate(duration=5, frequency=2),
...                     "Multi": nk.signal_simulate(duration=5, frequency=[0.5, 3], amplitude=[0.5, 0.2])}).plot()
>>> fig 

signal_smooth(signal, method='convolution', kernel='boxzen', size=10, alpha=0.1)

Signal smoothing.

Signal smoothing can be achieved using either the convolution of a filter kernel with the input signal to compute the smoothed signal (Smith, 1997) or a LOESS regression.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• method (str) – Can be one of ‘convolution’ (default) or ‘loess’.

• kernel (Union[str, np.array]) – Only used if method is ‘convolution’. Type of kernel to use; if array, use directly as the kernel. Can be one of ‘median’, ‘boxzen’, ‘boxcar’, ‘triang’, ‘blackman’, ‘hamming’, ‘hann’, ‘bartlett’, ‘flattop’, ‘parzen’, ‘bohman’, ‘blackmanharris’, ‘nuttall’, ‘barthann’, ‘kaiser’ (needs beta), ‘gaussian’ (needs std), ‘general_gaussian’ (needs power, width), ‘slepian’ (needs width) or ‘chebwin’ (needs attenuation).

• size (int) – Only used if method is ‘convolution’. Size of the kernel; ignored if kernel is an array.

• alpha (float) – Only used if method is ‘loess’. The parameter which controls the degree of smoothing.

Returns

array – Smoothed signal.

See also

fit_loess()

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = np.cos(np.linspace(start=0, stop=10, num=1000))
>>> distorted = nk.signal_distort(signal, noise_amplitude=[0.3, 0.2, 0.1, 0.05], noise_frequency=[5, 10, 50, 100])
>>>
>>> size = len(signal)/100
>>> signals = pd.DataFrame({"Raw": distorted,
...                         "Median": nk.signal_smooth(distorted, kernel='median', size=size-1),
...                         "BoxZen": nk.signal_smooth(distorted, kernel='boxzen', size=size),
...                         "Triang": nk.signal_smooth(distorted, kernel='triang', size=size),
...                         "Blackman": nk.signal_smooth(distorted, kernel='blackman', size=size),
...                         "Loess_01": nk.signal_smooth(distorted, method='loess', alpha=0.1),
...                         "Loess_02": nk.signal_smooth(distorted, method='loess', alpha=0.2),
...                         "Loess_05": nk.signal_smooth(distorted, method='loess', alpha=0.5)})
>>> fig = signals.plot()
>>> fig_magnify = signals[50:150].plot()  # Magnify
>>> fig_magnify 

References

• Smith, S. W. (1997). The scientist and engineer’s guide to digital signal processing.

signal_synchrony(signal1, signal2, method='hilbert', window_size=50)

Compute the synchrony (coupling) between two signals.

Compute a continuous index of coupling between two signals either using the ‘Hilbert’ method to get the instantaneous phase synchrony, or using rolling window correlation.

The instantaneous phase synchrony measures the phase similarities between signals at each timepoint. The phase refers to the angle of the signal, calculated through the hilbert transform, when it is resonating between -pi to pi degrees. When two signals line up in phase their angular difference becomes zero.

For less clean signals, windowed correlations are widely used because of their simplicity, and can be a good a robust approximation of synchrony between two signals. The limitation is the need to select a window.

Parameters

• signal1 (Union[list, np.array, pd.Series]) – Time series in the form of a vector of values.

• signal2 (Union[list, np.array, pd.Series]) – Time series in the form of a vector of values.

• method (str) – The method to use. Can be one of ‘hilbert’ or ‘correlation’.

• window_size (int) – Only used if method=’correlation’. The number of samples to use for rolling correlation.

See also

signal_filter(), signal_zerocrossings(), signal_findpeaks()

Returns

array – A vector containing the phase of the signal, between 0 and 2*pi.

Examples

>>> import neurokit2 as nk
>>>
>>> signal1 = nk.signal_simulate(duration=10, frequency=1)
>>> signal2 = nk.signal_simulate(duration=10, frequency=1.5)
>>>
>>> coupling_h = nk.signal_synchrony(signal1, signal2, method="hilbert")
>>> coupling_c = nk.signal_synchrony(signal1, signal2, method="correlation", window_size=1000/2)
>>>
>>> fig = nk.signal_plot([signal1, signal2, coupling_h, coupling_c])
>>> fig 

References

• http://jinhyuncheong.com/jekyll/update/2017/12/10/Timeseries_synchrony_tutorial_and_simulations.html

signal_zerocrossings(signal, direction='both')

Locate the indices where the signal crosses zero.

Note that when the signal crosses zero between two points, the first index is returned.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• direction (str) – Direction in which the signal crosses zero, can be “positive”, “negative” or “both” (default).

Returns

array – Vector containing the indices of zero crossings.

Examples

>>> import numpy as np
>>> import neurokit2 as nk
>>>
>>> signal = np.cos(np.linspace(start=0, stop=15, num=1000))
>>> zeros = nk.signal_zerocrossings(signal)
>>> fig = nk.events_plot(zeros, signal)
>>> fig 
>>>
>>> # Only upward or downward zerocrossings
>>> up = nk.signal_zerocrossings(signal, direction='up')
>>> down = nk.signal_zerocrossings(signal, direction='down')
>>> fig = nk.events_plot([up, down], signal)
>>> fig 

Events

Submodule for NeuroKit.

events_find(event_channel, threshold='auto', threshold_keep='above', start_at=0, end_at=None, duration_min=1, duration_max=None, inter_min=0, discard_first=0, discard_last=0, event_labels=None, event_conditions=None)

Find and select events in a continuous signal (e.g., from a photosensor).

Parameters

• event_channel (array or list) – The channel containing the events.

• threshold (str or float) – The threshold value by which to select the events. If “auto”, takes the value between the max and the min.

• threshold_keep (str) – “above” or “below”, define the events as above or under the threshold. For photosensors, a white screen corresponds usually to higher values. Therefore, if your events are signaled by a black colour, events values are the lower ones, and you should set the cut to “below”.

• start_at (int) – Keep events which onset is after a particular time point.

• end_at (int) – Keep events which onset is before a particular time point.

• duration_min (int) – The minimum duration of an event to be considered as such (in time points).

• duration_max (int) – The maximum duration of an event to be considered as such (in time points).

• inter_min (int) – The minimum duration after an event for the subsequent event to be considered as such (in time points). Useful when spurious consecutive events are created due to very high sampling rate.

• discard_first (int) – Discard first or last n events. Useful if the experiment starts with some spurious events. If discard_first=0, no first event is removed.

• discard_last (int) – Discard first or last n events. Useful if the experiment ends with some spurious events. If discard_last=0, no last event is removed.

• event_labels (list) – A list containing unique event identifiers. If None, will use the event index number.

• event_conditions (list) – An optional list containing, for each event, for example the trial category, group or experimental conditions.

Returns

dict – Dict containing 3 or 4 arrays, ‘onset’ for event onsets, ‘duration’ for event durations, ‘label’ for the event identifiers and the optional ‘conditions’ passed to event_conditions.

See also

events_plot(), events_to_mne()

Example

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=4)
>>> events = nk.events_find(signal)
>>> events 
{'onset': array(...),
 'duration': array(...),
 'label': array(...)}
>>>
>>> nk.events_plot(events, signal) 
<Figure ...>

events_plot(events, signal=None, show=True, color='red', linestyle='--')

Plot events in signal.

Parameters

• events (list or ndarray or dict) – Events onset location. Can also be a list of lists, in which case it will mark them with different colors. If a dict is passed (e.g., from ‘events_find()’), will select only the ‘onset’ list.

• signal (array or DataFrame) – Signal array (can be a dataframe with many signals).

• show (bool) – If True, will return a plot. If False, will return a DataFrame that can be plotted externally.

• color (str) – Argument passed to matplotlib plotting.

• linestyle (str) – Argument passed to matplotlib plotting.

Returns

fig – Figure representing a plot of the signal and the event markers.

See also

events_find()

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> fig = nk.events_plot([1, 3, 5])
>>> fig 
>>>
>>> # With signal
>>> signal = nk.signal_simulate(duration=4)
>>> events = nk.events_find(signal)
>>> fig1 = nk.events_plot(events, signal)
>>> fig1 
>>>
>>> # Different events
>>> events1 = events["onset"]
>>> events2 = np.linspace(0, len(signal), 8)
>>> fig2 = nk.events_plot([events1, events2], signal)
>>> fig2 
>>>
>>> # Conditions
>>> events = nk.events_find(signal, event_conditions=["A", "B", "A", "B"])
>>> fig3 = nk.events_plot(events, signal)
>>> fig3 
>>>
>>> # Different colors for all events
>>> signal = nk.signal_simulate(duration=20)
>>> events = nk.events_find(signal)
>>> events = [[i] for i in events['onset']]
>>> fig4 = nk.events_plot(events, signal)
>>> fig4 

events_to_mne(events, event_conditions=None)

Create MNE compatible events for integration with M/EEG.

Parameters

• events (list or ndarray or dict) – Events onset location. Can also be a dict obtained through ‘events_find()’.

• event_conditions (list) – An optional list containing, for each event, for example the trial category, group or experimental conditions. Defaults to None.

Returns

tuple – MNE-formatted events and the event id, that can be added via ‘raw.add_events(events), and a dictionary with event’s names.

See also

events_find()

Examples

>>> import numpy as np
>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=4)
>>> events = nk.events_find(signal)
>>> events, event_id = nk.events_to_mne(events)
>>> events 
array([[   1,    0,    0],
       [1001,    0,    0],
       [2001,    0,    0],
       [3001,    0,    0]])
>>> event_id 
{'event': 0}
>>>
>>> # Conditions
>>> events = nk.events_find(signal, event_conditions=["A", "B", "A", "B"])
>>> events, event_id = nk.events_to_mne(events)
>>> event_id 
{'B': 0, 'A': 1}

Data

Submodule for NeuroKit.

data(dataset='bio_eventrelated_100hz')

Download example datasets.

Download and load available example datasets. Note that an internet connexion is necessary.

Parameters

dataset (str) – The name of the dataset. The list and description is available here.

Returns

DataFrame – The data.

Examples

>>> import neurokit2 as nk
>>>
>>> data = nk.data("bio_eventrelated_100hz")

read_acqknowledge(filename, sampling_rate='max', resample_method='interpolation', impute_missing=True)

Read and format a BIOPAC’s AcqKnowledge file into a pandas’ dataframe.

The function outputs both the dataframe and the sampling rate (encoded within the AcqKnowledge) file.

Parameters

• filename (str) – Filename (with or without the extension) of a BIOPAC’s AcqKnowledge file.

• sampling_rate (int) – Sampling rate (in Hz, i.e., samples/second). Since an AcqKnowledge file can contain signals recorded at different rates, harmonization is necessary in order to convert it to a DataFrame. Thus, if sampling_rate is set to ‘max’ (default), will keep the maximum recorded sampling rate and upsample the channels with lower rate if necessary (using the signal_resample() function). If the sampling rate is set to a given value, will resample the signals to the desired value. Note that the value of the sampling rate is outputted along with the data.

• resample_method (str) – Method of resampling (see signal_resample()).

• impute_missing (bool) – Sometimes, due to connections issues, the signal has some holes (short periods without signal). If ‘impute_missing’ is True, will automatically fill the signal interruptions using padding.

Returns

• df (DataFrame) – The AcqKnowledge file converted to a dataframe.

• sampling rate (int) – The AcqKnowledge file converted to its sampling rate.

See also

signal_resample()

Example

>>> import neurokit2 as nk
>>>
>>> data, sampling_rate = nk.read_acqknowledge('file.acq') 

Epochs

Submodule for NeuroKit.

epochs_create(data, events=None, sampling_rate=1000, epochs_start=0, epochs_end=1, event_labels=None, event_conditions=None, baseline_correction=False)

Epoching a dataframe.

Parameters

• data (DataFrame) – A DataFrame containing the different signal(s) as different columns. If a vector of values is passed, it will be transformed in a DataFrame with a single ‘Signal’ column.

• events (list or ndarray or dict) – Events onset location. If a dict is passed (e.g., from events_find()), will select only the ‘onset’ list. If an integer is passed, will use this number to create an evenly spaced list of events. If None, will chunk the signal into successive blocks of the set duration.

• sampling_rate (int) – The sampling frequency of the signal (in Hz, i.e., samples/second).

• epochs_start (int) – Epochs start relative to events_onsets (in seconds). The start can be negative to start epochs before a given event (to have a baseline for instance).

• epochs_end (int) – Epochs end relative to events_onsets (in seconds).

• event_labels (list) – A list containing unique event identifiers. If None, will use the event index number.

• event_conditions (list) – An optional list containing, for each event, for example the trial category, group or experimental conditions.

• baseline_correction (bool) – Defaults to False.

Returns

dict – A dict containing DataFrames for all epochs.

See also

events_find(), events_plot(), epochs_to_df(), epochs_plot()

Examples

>>> import neurokit2 as nk
>>>
>>> # Get data
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Find events
>>> events = nk.events_find(data["Photosensor"],
...                         threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> fig1 = nk.events_plot(events, data)
>>> fig1 
>>>
>>> # Create epochs
>>> epochs = nk.epochs_create(data, events, sampling_rate=100, epochs_end=3)
>>> fig2 = nk.epochs_plot(epochs)
>>> fig2 
>>>
>>> # Baseline correction
>>> epochs = nk.epochs_create(data, events, sampling_rate=100, epochs_end=3, baseline_correction=True)
>>> fig3 = nk.epochs_plot(epochs)
>>> fig3 
>>>
>>> # Chunk into n blocks of 1 second
>>> epochs = nk.epochs_create(data, sampling_rate=100, epochs_end=1)

epochs_plot(epochs, legend=True, show=True)

Plot epochs.

Parameters

• epochs (dict) – A dict containing one DataFrame per event/trial. Usually obtained via epochs_create().

• legend (bool) – Display the legend (the key of each epoch).

• show (bool) – If True, will return a plot. If False, will return a DataFrame that can be plotted externally.

Returns

epochs (dict) – dict containing all epochs.

See also

events_find(), events_plot(), epochs_create(), epochs_to_df()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example with data
>>> data = nk.data("bio_eventrelated_100hz")
>>> events = nk.events_find(data["Photosensor"],
...                         threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> epochs = nk.epochs_create(data, events, sampling_rate=200, epochs_end=1)
>>> fig1 = nk.epochs_plot(epochs)
>>> fig1 
>>>
>>> # Example with ECG Peaks
>>> signal = nk.ecg_simulate(duration=10)
>>> events = nk.ecg_findpeaks(signal)
>>> epochs = nk.epochs_create(signal, events=events["ECG_R_Peaks"], epochs_start=-0.5, epochs_end=0.5)
>>> fig2 = nk.epochs_plot(epochs)
>>> fig2 

epochs_to_array(epochs)

Convert epochs to an array.

TODO: make it work with uneven epochs (not the same length).

Parameters

epochs (dict) – A dict containing one DataFrame per event/trial. Usually obtained via epochs_create().

Returns

array – An array containing all signals.

See also

events_find(), events_plot(), epochs_create(), epochs_plot()

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> # Get data
>>> signal = nk.signal_simulate(sampling_rate=100)
>>>
>>> # Create epochs
>>> epochs = nk.epochs_create(signal, events=[400, 430, 460], sampling_rate=100, epochs_end=1)
>>> X = nk.epochs_to_array(epochs)
>>> nk.signal_plot(X.T)

epochs_to_df(epochs)

Convert epochs to a DataFrame.

Parameters

epochs (dict) – A dict containing one DataFrame per event/trial. Usually obtained via epochs_create().

Returns

DataFrame – A DataFrame containing all epochs identifiable by the ‘Label’ column, which time axis is stored in the ‘Time’ column.

See also

events_find(), events_plot(), epochs_create(), epochs_plot()

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> # Get data
>>> data = pd.read_csv("https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/bio_eventrelated_100hz.csv")
>>>
>>> # Find events
>>> events = nk.events_find(data["Photosensor"],
...                         threshold_keep='below',
...                         event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
>>> fig = nk.events_plot(events, data)
>>> fig 
>>>
>>> # Create epochs
>>> epochs = nk.epochs_create(data, events, sampling_rate=200, epochs_end=3)
>>> data = nk.epochs_to_df(epochs)

Statistics

Submodule for NeuroKit.

cor(x, y, method='pearson', show=False)

Density estimation.

Computes kernel density estimates.

Parameters

• x (Union[list, np.array, pd.Series]) – Vectors of values.

• y (Union[list, np.array, pd.Series]) – Vectors of values.

• method (str) – Correlation method. Can be one of ‘pearson’, ‘spearman’, ‘kendall’.

• show (bool) – Draw a scatterplot with a regression line.

Returns

r – The correlation coefficient.

Examples

>>> import neurokit2 as nk
>>>
>>> x = [1, 2, 3, 4, 5]
>>> y = [3, 1, 5, 6, 6]
>>> corr = nk.cor(x, y, method="pearson", show=True)
>>> corr 

density(x, desired_length=100, bandwith=1, show=False)

Density estimation.

Computes kernel density estimates.

Parameters

• x (Union[list, np.array, pd.Series]) – A vector of values.

• desired_length (int) – The amount of values in the returned density estimation.

• bandwith (float) – The bandwith of the kernel. The smaller the values, the smoother the estimation.

• show (bool) – Display the density plot.

Returns

• x, y – The x axis of the density estimation.

• y – The y axis of the density estimation.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.ecg_simulate(duration=20)
>>> x, y = nk.density(signal, bandwith=0.5, show=True)
>>>
>>> # Bandwidth comparison
>>> x, y1 = nk.density(signal, bandwith=0.5)
>>> x, y2 = nk.density(signal, bandwith=1)
>>> x, y3 = nk.density(signal, bandwith=2)
>>> pd.DataFrame({"x": x, "y1": y1, "y2": y2, "y3": y3}).plot(x="x") 

distance(X=None, method='mahalanobis')

Distance.

Compute distance using different metrics.

Parameters

• X (array or DataFrame) – A dataframe of values.

• method (str) – The method to use. One of ‘mahalanobis’ or ‘mean’ for the average distance from the mean.

Returns

array – Vector containing the distance values.

Examples

>>> from sklearn import datasets
>>> import neurokit2 as nk
>>>
>>> X = datasets.load_iris().data
>>> vector = distance(X)
>>> vector 

fit_error(y, y_predicted, n_parameters=2)

Calculate the fit error for a model.

Also specific and direct access functions can be used, such as fit_mse(), fit_rmse() and fit_r2().

Parameters

• y (Union[list, np.array, pd.Series]) – The response variable (the y axis).

• y_predicted (Union[list, np.array, pd.Series]) – The fitted data generated by a model.

• n_parameters (int) – Number of model parameters (for the degrees of freedom used in R2).

Returns

dict – A dictionary containing different indices of fit error.

See also

fit_mse(), fit_rmse(), fit_r2()

Examples

>>> import neurokit2 as nk
>>>
>>> y = np.array([-1.0, -0.5, 0, 0.5, 1])
>>> y_predicted = np.array([0.0, 0, 0, 0, 0])
>>>
>>> # Master function
>>> x = nk.fit_error(y, y_predicted)
>>> x 
>>>
>>> # Direct access
>>> nk.fit_mse(y, y_predicted) 
0.5
>>>
>>> nk.fit_rmse(y, y_predicted) 
0.7071067811865476
>>>
>>> nk.fit_r2(y, y_predicted, adjusted=False) 
0.7071067811865475
>>>
>>> nk.fit_r2(y, y_predicted, adjusted=True, n_parameters=2) 
0.057190958417936755

fit_loess(y, X=None, alpha=0.75, order=2)

Local Polynomial Regression (LOESS)

Performs a LOWESS (LOcally WEighted Scatter-plot Smoother) regression.

Parameters

• y (Union[list, np.array, pd.Series]) – The response variable (the y axis).

• X (Union[list, np.array, pd.Series]) – Explanatory variable (the x axis). If ‘None’, will treat y as a continuous signal (useful for smoothing).

• alpha (float) – The parameter which controls the degree of smoothing, which corresponds to the proportion of the samples to include in local regression.

• order (int) – Degree of the polynomial to fit. Can be 1 or 2 (default).

Returns

array – Prediciton of the LOESS algorithm.

See also

signal_smooth(), signal_detrend(), fit_error()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> signal = np.cos(np.linspace(start=0, stop=10, num=1000))
>>> distorted = nk.signal_distort(signal, noise_amplitude=[0.3, 0.2, 0.1], noise_frequency=[5, 10, 50])
>>>
>>> pd.DataFrame({ "Raw": distorted, "Loess_1": nk.fit_loess(distorted, order=1),
...               "Loess_2": nk.fit_loess(distorted, order=2)}).plot() 

References

• https://simplyor.netlify.com/loess-from-scratch-in-python-animation.en-us/

fit_mixture(X=None, n_clusters=2)

Gaussian Mixture Model.

Performs a polynomial regression of given order.

Parameters

• X (Union[list, np.array, pd.Series]) – The values to classify.

• n_clusters (int) – Number of components to look for.

Returns

pd.DataFrame – DataFrame containing the probability of belongning to each cluster.

See also

signal_detrend(), fit_error()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> x = nk.signal_simulate()
>>> probs = nk.fit_mixture(x, n_clusters=2)
>>> fig = nk.signal_plot([x, probs["Cluster_0"], probs["Cluster_1"]], standardize=True)
>>> fig 

fit_mse(y, y_predicted)

Compute Mean Square Error (MSE).

fit_polynomial(y, X=None, order=2)

Polynomial Regression.

Performs a polynomial regression of given order.

Parameters

• y (Union[list, np.array, pd.Series]) – The response variable (the y axis).

• X (Union[list, np.array, pd.Series]) – Explanatory variable (the x axis). If ‘None’, will treat y as a continuous signal.

• order (int) – The order of the polynomial. 0, 1 or > 1 for a baseline, linear or polynomial fit, respectively. Can also be ‘auto’, it which case it will attempt to find the optimal order to minimize the RMSE.

Returns

array – Prediction of the regression.

See also

signal_detrend(), fit_error(), fit_polynomial_findorder()

Examples

>>> import pandas as pd
>>> import neurokit2 as nk
>>>
>>> y = np.cos(np.linspace(start=0, stop=10, num=100))
>>>
>>> pd.DataFrame({"y": y, "Poly_0": nk.fit_polynomial(y, order=0),
...               "Poly_1": nk.fit_polynomial(y, order=1),
...               "Poly_2": nk.fit_polynomial(y, order=2),
...               "Poly_3": nk.fit_polynomial(y, order=3), "Poly_5": nk.fit_polynomial(y, order=5),
...               "Poly_auto": nk.fit_polynomial(y, order='auto')}).plot() 

fit_polynomial_findorder(y, X=None, max_order=6)

Polynomial Regression.

Find the optimal order for polynomial fitting. Currently, the only method implemented is RMSE minimization.

Parameters

• y (Union[list, np.array, pd.Series]) – The response variable (the y axis).

• X (Union[list, np.array, pd.Series]) – Explanatory variable (the x axis). If ‘None’, will treat y as a continuous signal.

• max_order (int) – The maximum order to test.

Returns

int – Optimal order.

See also

fit_polynomial()

Examples

>>> import neurokit2 as nk
>>>
>>> y = np.cos(np.linspace(start=0, stop=10, num=100))
>>>
>>> nk.fit_polynomial_findorder(y, max_order=10)
9

fit_r2(y, y_predicted, adjusted=True, n_parameters=2)

Compute R2.

fit_rmse(y, y_predicted)

Compute Root Mean Square Error (RMSE).

hdi(x, ci=0.95, show=False, **kwargs)

Highest Density Interval (HDI)

Compute the Highest Density Interval (HDI) of a distribution. All points within this interval have a higher probability density than points outside the interval. The HDI can be used in the context of uncertainty characterisation of posterior distributions (in the Bayesian farmework) as Credible Interval (CI). Unlike equal-tailed intervals that typically exclude 2.5% from each tail of the distribution and always include the median, the HDI is not equal-tailed and therefore always includes the mode(s) of posterior distributions.

Parameters

• x (Union[list, np.array, pd.Series]) – A vector of values.

• ci (float) – Value of probability of the (credible) interval - CI (between 0 and 1) to be estimated. Default to .95 (95%).

• show (bool) – If True, the function will produce a figure.

• **kwargs (Line2D properties) – Other arguments to be passed to density().

See also

density()

Returns

• float(s) – The HDI low and high limits.

• fig – Distribution plot.

Examples

>>> import numpy as np
>>> import neurokit2 as nk
>>>
>>> x = np.random.normal(loc=0, scale=1, size=100000)
>>> ci_min, ci_high = nk.hdi(x, ci=0.95, show=True)

mad(x, constant=1.4826)

Median Absolute Deviation: a “robust” version of standard deviation.

Parameters

• x (Union[list, np.array, pd.Series]) – A vector of values.

• constant (float) – Scale factor. Use 1.4826 for results similar to default R.

Returns

float – The MAD.

Examples

>>> import neurokit2 as nk
>>> nk.mad([2, 8, 7, 5, 4, 12, 5, 1])
3.7064999999999997

References

• https://en.wikipedia.org/wiki/Median_absolute_deviation

mutual_information(x, y, method='varoquaux', bins=256, sigma=1, normalized=True)

Computes the (normalized) mutual information (MI) between two vectors from a joint histogram. The mutual information of two variables is a measure of the mutual dependence between them. More specifically, it quantifies the “amount of information” obtained about one variable by observing the other variable.

Parameters

• x (Union[list, np.array, pd.Series]) – A vector of values.

• y (Union[list, np.array, pd.Series]) – A vector of values.

• method (str) – Method to use. Can either be ‘varoquaux’ or ‘nolitsa’.

• bins (int) – Number of bins to use while creating the histogram.

• sigma (float) – Sigma for Gaussian smoothing of the joint histogram. Only used if method==’varoquaux’.

• normalized (book) – Compute normalised mutual information. Only used if method==’varoquaux’.

Returns

float – The computed similariy measure.

Examples

>>> import neurokit2 as nk
>>>
>>> x = [3, 3, 5, 1, 6, 3]
>>> y = [5, 3, 1, 3, 4, 5]
>>>
>>> nk.mutual_information(x, y, method="varoquaux") 
0.23600751227291816
>>>
>>> nk.mutual_information(x, y, method="nolitsa") 
1.4591479170272448

References

• Studholme, jhill & jhawkes (1998). “A normalized entropy measure of 3-D medical image alignment”.

in Proc. Medical Imaging 1998, vol. 3338, San Diego, CA, pp. 132-143.

rescale(data, to=[0, 1])

Rescale data.

Rescale a numeric variable to a new range.

Parameters

• data (Union[list, np.array, pd.Series]) – Raw data.

• to (list) – New range of values of the data after rescaling.

Returns

list – The rescaled values.

Examples

>>> import neurokit2 as nk
>>>
>>> nk.rescale(data=[3, 1, 2, 4, 6], to=[0, 1]) 
[0.4, 0.0, 0.2, 0.6000000000000001, 1.0]

standardize(data, robust=False, window=None, **kwargs)

Standardization of data.

Performs a standardization of data (Z-scoring), i.e., centering and scaling, so that the data is expressed in terms of standard deviation (i.e., mean = 0, SD = 1) or Median Absolute Deviance (median = 0, MAD = 1).

Parameters

• data (Union[list, np.array, pd.Series]) – Raw data.

• robust (bool) – If True, centering is done by substracting the median from the variables and dividing it by the median absolute deviation (MAD). If False, variables are standardized by substracting the mean and dividing it by the standard deviation (SD).

• window (int) – Perform a rolling window standardization, i.e., apply a standardization on a window of the specified number of samples that rolls along the main axis of the signal. Can be used for complex detrending.

• **kwargs (optional) – Other arguments to be passed to pandas.rolling().

Returns

list – The standardized values.

Examples

>>> import neurokit2 as nk
>>> import pandas as pd
>>>
>>> # Simple example
>>> nk.standardize([3, 1, 2, 4, 6, np.nan]) 
[...]
>>> nk.standardize([3, 1, 2, 4, 6, np.nan], robust=True) 
[...]
>>> nk.standardize(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]).T) 
 array(...)
>>> nk.standardize(pd.DataFrame({"A": [3, 1, 2, 4, 6, np.nan],
...                              "B": [3, 1, 2, 4, 6, 5]})) 
          A         B
0       ...       ...
...
>>>
>>> # Rolling standardization of a signal
>>> signal = nk.signal_simulate(frequency=[0.1, 2], sampling_rate=200)
>>> z = nk.standardize(signal, window=200)
>>> nk.signal_plot([signal, z], standardize=True)

summary_plot(x, **kwargs)

Descriptive plot.

Visualize a distribution with density, histogram, boxplot and rugs plots all at once.

Examples

>>> import neurokit2 as nk
>>> import numpy as np
>>>
>>> x = np.random.normal(size=100)
>>> fig = nk.summary_plot(x)
>>> fig 

Complexity

Submodule for NeuroKit.

complexity_apen(signal, delay=1, dimension=2, r='default', corrected=False, **kwargs)

Approximate entropy (ApEn)

Python implementations of the approximate entropy (ApEn) and its corrected version (cApEn). Approximate entropy is a technique used to quantify the amount of regularity and the unpredictability of fluctuations over time-series data. The advantages of ApEn include lower computational demand (ApEn can be designed to work for small data samples (< 50 data points) and can be applied in real time) and less sensitive to noise. However, ApEn is heavily dependent on the record length and lacks relative consistency.

This function can be called either via entropy_approximate() or complexity_apen(), and the corrected version via complexity_capen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (similarity threshold). It corresponds to the filtering level - max absolute difference between segments. If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• corrected (bool) – If true, will compute corrected ApEn (cApEn), see Porta (2007).

• **kwargs – Other arguments.

See also

entropy_shannon(), entropy_sample(), entropy_fuzzy()

Returns

float – The approximate entropy as float value.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_approximate(signal)
>>> entropy1 
>>> entropy2 = nk.entropy_approximate(signal, corrected=True)
>>> entropy2 

References

• EntroPy <https://github.com/raphaelvallat/entropy>`_

• Sabeti, M., Katebi, S., & Boostani, R. (2009). Entropy and complexity measures for EEG signal classification of schizophrenic and control participants. Artificial intelligence in medicine, 47(3), 263-274.

• Shi, B., Zhang, Y., Yuan, C., Wang, S., & Li, P. (2017). Entropy analysis of short-term heartbeat interval time series during regular walking. Entropy, 19(10), 568.

complexity_capen(signal, delay=1, dimension=2, r='default', *, corrected=True, **kwargs)

Approximate entropy (ApEn)

Python implementations of the approximate entropy (ApEn) and its corrected version (cApEn). Approximate entropy is a technique used to quantify the amount of regularity and the unpredictability of fluctuations over time-series data. The advantages of ApEn include lower computational demand (ApEn can be designed to work for small data samples (< 50 data points) and can be applied in real time) and less sensitive to noise. However, ApEn is heavily dependent on the record length and lacks relative consistency.

This function can be called either via entropy_approximate() or complexity_apen(), and the corrected version via complexity_capen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (similarity threshold). It corresponds to the filtering level - max absolute difference between segments. If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• corrected (bool) – If true, will compute corrected ApEn (cApEn), see Porta (2007).

• **kwargs – Other arguments.

See also

entropy_shannon(), entropy_sample(), entropy_fuzzy()

Returns

float – The approximate entropy as float value.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_approximate(signal)
>>> entropy1 
>>> entropy2 = nk.entropy_approximate(signal, corrected=True)
>>> entropy2 

References

• EntroPy <https://github.com/raphaelvallat/entropy>`_

• Sabeti, M., Katebi, S., & Boostani, R. (2009). Entropy and complexity measures for EEG signal classification of schizophrenic and control participants. Artificial intelligence in medicine, 47(3), 263-274.

• Shi, B., Zhang, Y., Yuan, C., Wang, S., & Li, P. (2017). Entropy analysis of short-term heartbeat interval time series during regular walking. Entropy, 19(10), 568.

complexity_cmse(signal, scale='default', dimension=2, r='default', *, composite=True, refined=False, fuzzy=False, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

complexity_d2(signal, delay=1, dimension=2, r=64, show=False)

Correlation Dimension.

Python implementation of the Correlation Dimension D2 of a signal.

This function can be called either via fractal_correlation() or complexity_d2().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (str or int or list) – The sequence of radiuses to test. If an integer is passed, will get an exponential sequence ranging from 2.5% to 50% of the distance range. Methods implemented in other packages can be used via setting r='nolds' or r='Corr_Dim'.

• show (bool) – Plot of correlation dimension if True. Defaults to False.

Returns

D2 (float) – The correlation dimension D2.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>>
>>> fractal1 = nk.fractal_correlation(signal, r="nolds", show=True)
>>> fractal1 
>>> fractal2 = nk.fractal_correlation(signal, r=32, show=True)
>>> fractal2 
>>>
>>> signal = nk.rsp_simulate(duration=120, sampling_rate=50)
>>>
>>> fractal3 = nk.fractal_correlation(signal, r="nolds", show=True)
>>> fractal3 
>>> fractal4 = nk.fractal_correlation(signal, r=32, show=True)
>>> fractal4 

References

• Bolea, J., Laguna, P., Remartínez, J. M., Rovira, E., Navarro, A., & Bailón, R. (2014). Methodological framework for estimating the correlation dimension in HRV signals. Computational and mathematical methods in medicine, 2014.

• Boon, M. Y., Henry, B. I., Suttle, C. M., & Dain, S. J. (2008). The correlation dimension: A useful objective measure of the transient visual evoked potential?. Journal of vision, 8(1), 6-6.

• nolds

• Corr_Dim

complexity_delay(signal, delay_max=100, method='fraser1986', show=False)

Estimate optimal Time Delay (tau) for time-delay embedding.

The time delay (Tau) is one of the two critical parameters involved in the construction of the time-delay embedding of a signal.

Several authors suggested different methods to guide the choice of Tau:

• Fraser and Swinney (1986) suggest using the first local minimum of the mutual information between the delayed and non-delayed time series, effectively identifying a value of tau for which they share the least information.

• Theiler (1990) suggested to select Tau where the autocorrelation between the signal and its lagged version at Tau first crosses the value 1/e.

• Casdagli (1991) suggests instead taking the first zero-crossing of the autocorrelation.

• Rosenstein (1993) suggests to the point close to 40% of the slope of the average displacement from the diagonal (ADFD).

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay_max (int) – The maximum time delay (Tau or lag) to test.

• method (str) – Correlation method. Can be one of ‘fraser1986’, ‘theiler1990’, ‘casdagli1991’, ‘rosenstein1993’.

• show (bool) – If true, will plot the mutual information values for each value of tau.

Returns

int – Optimal time delay.

See also

complexity_dimension(), complexity_embedding()

Examples

>>> import neurokit2 as nk
>>>
>>> # Artifical example
>>> signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)
>>> nk.signal_plot(signal)
>>>
>>> delay = nk.complexity_delay(signal, delay_max=1000, show=True, method="fraser1986")
>>> delay = nk.complexity_delay(signal, delay_max=1000, show=True, method="theiler1990")
>>> delay = nk.complexity_delay(signal, delay_max=1000, show=True, method="casdagli1991")
>>> delay = nk.complexity_delay(signal, delay_max=1000, show=True, method="rosenstein1993")
>>>
>>> # Realistic example
>>> ecg = nk.ecg_simulate(duration=60*6, sampling_rate=150)
>>> signal = nk.ecg_rate(nk.ecg_peaks(ecg, sampling_rate=150), sampling_rate=150, desired_length=len(ecg))
>>> nk.signal_plot(signal)
>>>
>>> delay = nk.complexity_delay(signal, delay_max=1000, show=True)

References

• Gautama, T., Mandic, D. P., & Van Hulle, M. M. (2003, April). A differential entropy based method for determining the optimal embedding parameters of a signal. In 2003 IEEE International Conference on Acoustics, Speech, and Signal Processing, 2003. Proceedings.(ICASSP’03). (Vol. 6, pp. VI-29). IEEE.

• Camplani, M., & Cannas, B. (2009). The role of the embedding dimension and time delay in time series forecasting. IFAC Proceedings Volumes, 42(7), 316-320.

• Rosenstein, M. T., Collins, J. J., & De Luca, C. J. (1994). Reconstruction expansion as a geometry-based framework for choosing proper delay times. Physica-Section D, 73(1), 82-98.

complexity_dfa(signal, windows='default', overlap=True, integrate=True, order=1, multifractal=False, q=2, show=False)

(Multifractal) Detrended Fluctuation Analysis (DFA or MFDFA)

Python implementation of Detrended Fluctuation Analysis (DFA) or Multifractal DFA of a signal. Detrended fluctuation analysis, much like the Hurst exponent, is used to find long-term statistical dependencies in time series.

This function can be called either via fractal_dfa() or complexity_dfa(), and its multifractal variant can be directly accessed via fractal_mfdfa() or complexity_mfdfa()

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• windows (list) – A list containing the lengths of the windows (number of data points in each subseries). Also referred to as ‘lag’ or ‘scale’. If ‘default’, will set it to a logarithmic scale (so that each window scale hase the same weight) with a minimum of 4 and maximum of a tenth of the length (to have more than 10 windows to calculate the average fluctuation).

• overlap (bool) – Defaults to True, where the windows will have a 50% overlap with each other, otherwise non-overlapping windows will be used.

• integrate (bool) – It is common practice to convert the signal to a random walk (i.e., detrend and integrate, which corresponds to the signal ‘profile’). Note that it leads to the flattening of the signal, which can lead to the loss of some details (see Ihlen, 2012 for an explanation). Note that for strongly anticorrelated signals, this transformation should be applied two times (i.e., provide np.cumsum(signal - np.mean(signal)) instead of signal).

• order (int) – The order of the polynoiam trend, 1 for the linear trend.

• multifractal (bool) – If true, compute Multifractal Detrended Fluctuation Analysis (MFDFA), in which case the argument `q is taken into account.

• q (list) – The sequence of fractal exponents when multifractal=True. Must be a sequence between -10 and 10 (nota that zero will be removed, since the code does not converge there). Setting q = 2 (default) gives a result close to a standard DFA. For instance, Ihlen (2012) usese `` q=[-5, -3, -1, 0, 1, 3, 5]``.

• show (bool) – Visualise the trend between the window size and the fluctuations.

Returns

dfa (float) – The DFA coefficient.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=3, noise=0.05)
>>> dfa1 = nk.fractal_dfa(signal, show=True)
>>> dfa1 
>>> dfa2 = nk.fractal_mfdfa(signal, q=np.arange(-3, 4), show=True)
>>> dfa2 

References

• Ihlen, E. A. F. E. (2012). Introduction to multifractal detrended fluctuation analysis in Matlab. Frontiers in physiology, 3, 141.

• Hardstone, R., Poil, S. S., Schiavone, G., Jansen, R., Nikulin, V. V., Mansvelder, H. D., & Linkenkaer-Hansen, K. (2012). Detrended fluctuation analysis: a scale-free view on neuronal oscillations. Frontiers in physiology, 3, 450.

• nolds

• Youtube introduction

complexity_dimension(signal, delay=1, dimension_max=20, method='afnn', show=False, R=10.0, A=2.0, **kwargs)

Estimate optimal Dimension (m) for time-delay embedding.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see complexity_delay()).

• dimension_max (int) – The maximum embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’) to test.

• method (str) – Method can either be afnn (average false nearest neighbour) or fnn (false nearest neighbour).

• show (bool) – Visualize the result.

• R (float) – Relative tolerance (for fnn method).

• A (float) – Absolute tolerance (for fnn method)

• **kwargs – Other arguments.

Returns

int – Optimal dimension.

See also

complexity_delay(), complexity_embedding()

Examples

>>> import neurokit2 as nk
>>>
>>> # Artifical example
>>> signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)
>>> delay = nk.complexity_delay(signal, delay_max=500)
>>>
>>> values = nk.complexity_dimension(signal, delay=delay, dimension_max=20, show=True)

References

• Cao, L. (1997). Practical method for determining the minimum embedding dimension of a scalar time series. Physica D: Nonlinear Phenomena, 110(1-2), 43-50.

complexity_embedding(signal, delay=1, dimension=3, show=False)

Time-delay embedding of a time series (a signal)

A dynamical system can be described by a vector of numbers, called its ‘state’, that aims to provide a complete description of the system at some point in time. The set of all possible states is called the ‘state space’.

Takens’s (1981) embedding theorem suggests that a sequence of measurements of a dynamic system includes in itself all the information required to completely reconstruct the state space. Delay coordinate embedding attempts to identify the state s of the system at some time t by searching the past history of observations for similar states, and, by studying the evolution of similar states, infer information about the future of the system.

How to visualize the dynamics of a system? A sequence of state values over time is called a trajectory. Depending on the system, different trajectories can evolve to a common subset of state space called an attractor. The presence and behavior of attractors gives intuition about the underlying dynamical system. We can visualize the system and its attractors by plotting the trajectory of many different initial state values and numerically integrating them to approximate their continuous time evolution on discrete computers.

This function is adapted from EntroPy and is equivalent to the delay_embedding() function from ‘nolds’.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• show (bool) – Plot the reconstructed attractor.

Returns

array – Embedded time-series, of shape (n_times - (order - 1) * delay, order)

See also

embedding_delay(), embedding_dimension()

Examples

>>> import neurokit2 as nk
>>>
>>> # Artifical example
>>> signal = nk.signal_simulate(duration=2, frequency=5, noise=0.01)
>>>
>>> embedded = nk.complexity_embedding(signal, delay=50, dimension=2, show=True)
>>> embedded = nk.complexity_embedding(signal, delay=50, dimension=3, show=True)
>>> embedded = nk.complexity_embedding(signal, delay=50, dimension=4, show=True)
>>>
>>> # Realistic example
>>> ecg = nk.ecg_simulate(duration=60*4, sampling_rate=200)
>>> signal = nk.ecg_rate(nk.ecg_peaks(ecg, sampling_rate=200)[0], sampling_rate=200, desired_length=len(ecg))
>>>
>>> embedded = nk.complexity_embedding(signal, delay=250, dimension=2, show=True)
>>> embedded = nk.complexity_embedding(signal, delay=250, dimension=3, show=True)
>>> embedded = nk.complexity_embedding(signal, delay=250, dimension=4, show=True)

References

• Gautama, T., Mandic, D. P., & Van Hulle, M. M. (2003, April). A differential entropy based method for determining the optimal embedding parameters of a signal. In 2003 IEEE International Conference on Acoustics, Speech, and Signal Processing, 2003. Proceedings.(ICASSP’03). (Vol. 6, pp. VI-29). IEEE.

complexity_fuzzycmse(signal, scale='default', dimension=2, r='default', *, composite=True, refined=False, fuzzy=True, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

complexity_fuzzyen(signal, delay=1, dimension=2, r='default', **kwargs)

Fuzzy entropy (FuzzyEn)

Python implementations of the fuzzy entropy (FuzzyEn) of a signal.

This function can be called either via entropy_fuzzy() or complexity_fuzzyen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• **kwargs – Other arguments.

Returns

float – The fuzzy entropy as float value.

See also

entropy_shannon(), entropy_approximate(), entropy_sample()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy = nk.entropy_fuzzy(signal)
>>> entropy 

complexity_fuzzymse(signal, scale='default', dimension=2, r='default', composite=False, refined=False, *, fuzzy=True, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

complexity_fuzzyrcmse(signal, scale='default', dimension=2, r='default', composite=False, *, refined=True, fuzzy=True, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

complexity_mfdfa(signal, windows='default', overlap=True, integrate=True, order=1, *, multifractal=True, q=2, show=False)

(Multifractal) Detrended Fluctuation Analysis (DFA or MFDFA)

Python implementation of Detrended Fluctuation Analysis (DFA) or Multifractal DFA of a signal. Detrended fluctuation analysis, much like the Hurst exponent, is used to find long-term statistical dependencies in time series.

This function can be called either via fractal_dfa() or complexity_dfa(), and its multifractal variant can be directly accessed via fractal_mfdfa() or complexity_mfdfa()

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• windows (list) – A list containing the lengths of the windows (number of data points in each subseries). Also referred to as ‘lag’ or ‘scale’. If ‘default’, will set it to a logarithmic scale (so that each window scale hase the same weight) with a minimum of 4 and maximum of a tenth of the length (to have more than 10 windows to calculate the average fluctuation).

• overlap (bool) – Defaults to True, where the windows will have a 50% overlap with each other, otherwise non-overlapping windows will be used.

• integrate (bool) – It is common practice to convert the signal to a random walk (i.e., detrend and integrate, which corresponds to the signal ‘profile’). Note that it leads to the flattening of the signal, which can lead to the loss of some details (see Ihlen, 2012 for an explanation). Note that for strongly anticorrelated signals, this transformation should be applied two times (i.e., provide np.cumsum(signal - np.mean(signal)) instead of signal).

• order (int) – The order of the polynoiam trend, 1 for the linear trend.

• multifractal (bool) – If true, compute Multifractal Detrended Fluctuation Analysis (MFDFA), in which case the argument `q is taken into account.

• q (list) – The sequence of fractal exponents when multifractal=True. Must be a sequence between -10 and 10 (nota that zero will be removed, since the code does not converge there). Setting q = 2 (default) gives a result close to a standard DFA. For instance, Ihlen (2012) usese `` q=[-5, -3, -1, 0, 1, 3, 5]``.

• show (bool) – Visualise the trend between the window size and the fluctuations.

Returns

dfa (float) – The DFA coefficient.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=3, noise=0.05)
>>> dfa1 = nk.fractal_dfa(signal, show=True)
>>> dfa1 
>>> dfa2 = nk.fractal_mfdfa(signal, q=np.arange(-3, 4), show=True)
>>> dfa2 

References

• Ihlen, E. A. F. E. (2012). Introduction to multifractal detrended fluctuation analysis in Matlab. Frontiers in physiology, 3, 141.

• Hardstone, R., Poil, S. S., Schiavone, G., Jansen, R., Nikulin, V. V., Mansvelder, H. D., & Linkenkaer-Hansen, K. (2012). Detrended fluctuation analysis: a scale-free view on neuronal oscillations. Frontiers in physiology, 3, 450.

• nolds

• Youtube introduction

complexity_mse(signal, scale='default', dimension=2, r='default', composite=False, refined=False, fuzzy=False, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

complexity_optimize(signal, delay_max=100, delay_method='fraser1986', dimension_max=20, dimension_method='afnn', r_method='maxApEn', show=False)

Find optimal complexity parameters.

Estimate optimal complexity parameters Dimension (m), Time Delay (tau) and tolerance ‘r’.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay_max (int) – See complexity_delay().

• delay_method (str) – See complexity_delay().

• dimension_max (int) – See complexity_dimension().

• dimension_method (str) – See complexity_dimension().

• r_method (str) – See complexity_r().

• show (bool) – Defaults to False.

Returns

• optimal_dimension (int) – Optimal dimension.

• optimal_delay (int) – Optimal time delay.

See also

complexity_dimension(), complexity_delay(), complexity_r()

Examples

>>> import neurokit2 as nk
>>>
>>> # Artifical example
>>> signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)
>>> parameters = nk.complexity_optimize(signal, show=True)
>>> parameters 

References

• Gautama, T., Mandic, D. P., & Van Hulle, M. M. (2003, April). A differential entropy based method for determining the optimal embedding parameters of a signal. In 2003 IEEE International Conference on Acoustics, Speech, and Signal Processing, 2003. Proceedings.(ICASSP’03). (Vol. 6, pp. VI-29). IEEE.

• Camplani, M., & Cannas, B. (2009). The role of the embedding dimension and time delay in time series forecasting. IFAC Proceedings Volumes, 42(7), 316-320.

• Rosenstein, M. T., Collins, J. J., & De Luca, C. J. (1994). Reconstruction expansion as a geometry-based framework for choosing proper delay times. Physica-Section D, 73(1), 82-98.

• Cao, L. (1997). Practical method for determining the minimum embedding dimension of a scalar time series. Physica D: Nonlinear Phenomena, 110(1-2), 43-50.

• Lu, S., Chen, X., Kanters, J. K., Solomon, I. C., & Chon, K. H. (2008). Automatic selection of the threshold value r for approximate entropy. IEEE Transactions on Biomedical Engineering, 55(8), 1966-1972.

complexity_plot(signal, delay_max=100, delay_method='fraser1986', dimension_max=20, dimension_method='afnn', r_method='maxApEn', *, show=True)

Find optimal complexity parameters.

Estimate optimal complexity parameters Dimension (m), Time Delay (tau) and tolerance ‘r’.

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay_max (int) – See complexity_delay().

• delay_method (str) – See complexity_delay().

• dimension_max (int) – See complexity_dimension().

• dimension_method (str) – See complexity_dimension().

• r_method (str) – See complexity_r().

• show (bool) – Defaults to False.

Returns

• optimal_dimension (int) – Optimal dimension.

• optimal_delay (int) – Optimal time delay.

See also

complexity_dimension(), complexity_delay(), complexity_r()

Examples

>>> import neurokit2 as nk
>>>
>>> # Artifical example
>>> signal = nk.signal_simulate(duration=10, frequency=1, noise=0.01)
>>> parameters = nk.complexity_optimize(signal, show=True)
>>> parameters 

References

• Gautama, T., Mandic, D. P., & Van Hulle, M. M. (2003, April). A differential entropy based method for determining the optimal embedding parameters of a signal. In 2003 IEEE International Conference on Acoustics, Speech, and Signal Processing, 2003. Proceedings.(ICASSP’03). (Vol. 6, pp. VI-29). IEEE.

• Camplani, M., & Cannas, B. (2009). The role of the embedding dimension and time delay in time series forecasting. IFAC Proceedings Volumes, 42(7), 316-320.

• Rosenstein, M. T., Collins, J. J., & De Luca, C. J. (1994). Reconstruction expansion as a geometry-based framework for choosing proper delay times. Physica-Section D, 73(1), 82-98.

• Cao, L. (1997). Practical method for determining the minimum embedding dimension of a scalar time series. Physica D: Nonlinear Phenomena, 110(1-2), 43-50.

• Lu, S., Chen, X., Kanters, J. K., Solomon, I. C., & Chon, K. H. (2008). Automatic selection of the threshold value r for approximate entropy. IEEE Transactions on Biomedical Engineering, 55(8), 1966-1972.

complexity_r(signal, delay=None, dimension=None, method='maxApEn', show=False)

Estimate optimal tolerance (similarity threshold) :Parameters: * signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• method (str) – If ‘maxApEn’, rmax where ApEn is max will be returned. If ‘traditional’, r = 0.2 * standard deviation of the signal will be returned.

• show (bool) – If true and method is ‘maxApEn’, will plot the ApEn values for each value of r.

Returns

float – The optimal r as a similarity threshold. It corresponds to the filtering level - max absolute difference between segments.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> delay = nk.complexity_delay(signal)
>>> dimension = nk.complexity_dimension(signal, delay=delay)
>>> r = nk.complexity_r(signal, delay, dimension)
>>> r 

References

• Lu, S., Chen, X., Kanters, J. K., Solomon, I. C., & Chon, K. H. (2008). Automatic selection of the threshold value r for approximate entropy. IEEE Transactions on Biomedical Engineering, 55(8), 1966-1972.

complexity_rcmse(signal, scale='default', dimension=2, r='default', composite=False, *, refined=True, fuzzy=False, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

complexity_sampen(signal, delay=1, dimension=2, r='default', **kwargs)

Sample Entropy (SampEn)

Python implementation of the sample entropy (SampEn) of a signal.

This function can be called either via entropy_sample() or complexity_sampen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• **kwargs (optional) – Other arguments.

See also

entropy_shannon(), entropy_approximate(), entropy_fuzzy()

Returns

float – The sample entropy as float value.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy = nk.entropy_sample(signal)
>>> entropy 

complexity_se(signal)

Shannon entropy (SE)

Python implementation of Shannon entropy (SE). Entropy is a measure of unpredictability of the state, or equivalently, of its average information content. Shannon entropy (SE) is one of the first and most basic measure of entropy and a foundational concept of information theory. Shannon’s entropy quantifies the amount of information in a variable.

This function can be called either via entropy_shannon() or complexity_se().

Parameters

signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

Returns

float – The Shannon entropy as float value.

See also

entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy = nk.entropy_shannon(signal)
>>> entropy 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• EntroPy <https://github.com/raphaelvallat/entropy>`_

• nolds <https://github.com/CSchoel/nolds>`_

complexity_simulate(duration=10, sampling_rate=1000, method='ornstein', hurst_exponent=0.5, **kwargs)

Simulate chaotic time series.

Generates time series using the discrete approximation of the Mackey-Glass delay differential equation described by Grassberger & Procaccia (1983).

Parameters

• duration (int) – Desired length of duration (s).

• sampling_rate (int) – The desired sampling rate (in Hz, i.e., samples/second).

• duration (int) – The desired length in samples.

• method (str) – The method. can be ‘hurst’ for a (fractional) Ornstein–Uhlenbeck process or ‘mackeyglass’ to use the Mackey-Glass equation.

• hurst_exponent (float) – Defaults to 0.5.

• **kwargs – Other arguments.

Returns

array – Simulated complexity time series.

Examples

>>> import neurokit2 as nk
>>>
>>> signal1 = nk.complexity_simulate(duration=30, sampling_rate=100, method="ornstein")
>>> signal2 = nk.complexity_simulate(duration=30, sampling_rate=100, method="mackeyglass")
>>> nk.signal_plot([signal1, signal2])

Returns

x (array) – Array containing the time series.

entropy_approximate(signal, delay=1, dimension=2, r='default', corrected=False, **kwargs)

Approximate entropy (ApEn)

Python implementations of the approximate entropy (ApEn) and its corrected version (cApEn). Approximate entropy is a technique used to quantify the amount of regularity and the unpredictability of fluctuations over time-series data. The advantages of ApEn include lower computational demand (ApEn can be designed to work for small data samples (< 50 data points) and can be applied in real time) and less sensitive to noise. However, ApEn is heavily dependent on the record length and lacks relative consistency.

This function can be called either via entropy_approximate() or complexity_apen(), and the corrected version via complexity_capen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (similarity threshold). It corresponds to the filtering level - max absolute difference between segments. If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• corrected (bool) – If true, will compute corrected ApEn (cApEn), see Porta (2007).

• **kwargs – Other arguments.

See also

entropy_shannon(), entropy_sample(), entropy_fuzzy()

Returns

float – The approximate entropy as float value.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_approximate(signal)
>>> entropy1 
>>> entropy2 = nk.entropy_approximate(signal, corrected=True)
>>> entropy2 

References

• EntroPy <https://github.com/raphaelvallat/entropy>`_

• Sabeti, M., Katebi, S., & Boostani, R. (2009). Entropy and complexity measures for EEG signal classification of schizophrenic and control participants. Artificial intelligence in medicine, 47(3), 263-274.

• Shi, B., Zhang, Y., Yuan, C., Wang, S., & Li, P. (2017). Entropy analysis of short-term heartbeat interval time series during regular walking. Entropy, 19(10), 568.

entropy_fuzzy(signal, delay=1, dimension=2, r='default', **kwargs)

Fuzzy entropy (FuzzyEn)

Python implementations of the fuzzy entropy (FuzzyEn) of a signal.

This function can be called either via entropy_fuzzy() or complexity_fuzzyen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• **kwargs – Other arguments.

Returns

float – The fuzzy entropy as float value.

See also

entropy_shannon(), entropy_approximate(), entropy_sample()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy = nk.entropy_fuzzy(signal)
>>> entropy 

entropy_multiscale(signal, scale='default', dimension=2, r='default', composite=False, refined=False, fuzzy=False, show=False, **kwargs)

Multiscale entropy (MSE) and its Composite (CMSE), Refined (RCMSE) or fuzzy version.

Python implementations of the multiscale entropy (MSE), the composite multiscale entropy (CMSE), the refined composite multiscale entropy (RCMSE) or their fuzzy version (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

This function can be called either via entropy_multiscale() or complexity_mse(). Moreover, variants can be directly accessed via complexity_cmse(), complexity_rcmse()`, complexity_fuzzymse() and complexity_fuzzyrcmse().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• scale (str or int or list) – A list of scale factors used for coarse graining the time series. If ‘default’, will use range(len(signal) / (dimension + 10)) (see discussion here). If ‘max’, will use all scales until half the length of the signal. If an integer, will create a range until the specified int.

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• composite (bool) – Returns the composite multiscale entropy (CMSE), more accurate than MSE.

• refined (bool) – Returns the ‘refined’ composite MSE (RCMSE; Wu, 2014)

• fuzzy (bool) – Returns the fuzzy (composite) multiscale entropy (FuzzyMSE, FuzzyCMSE or FuzzyRCMSE).

• show (bool) – Show the entropy values for each scale factor.

• **kwargs – Optional arguments.

Returns

float – The point-estimate of multiscale entropy (MSE) as a float value corresponding to the area under the MSE values curvee, which is essentially the sum of sample entropy values over the range of scale factors.

See also

entropy_shannon(), entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy1 = nk.entropy_multiscale(signal, show=True)
>>> entropy1 
>>> entropy2 = nk.entropy_multiscale(signal, show=True, composite=True)
>>> entropy2 
>>> entropy3 = nk.entropy_multiscale(signal, show=True, refined=True)
>>> entropy3 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• Richman, J. S., & Moorman, J. R. (2000). Physiological time-series analysis using approximate entropy and sample entropy. American Journal of Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.

• Costa, M., Goldberger, A. L., & Peng, C. K. (2005). Multiscale entropy analysis of biological signals. Physical review E, 71(2), 021906.

• Gow, B. J., Peng, C. K., Wayne, P. M., & Ahn, A. C. (2015). Multiscale entropy analysis of center-of-pressure dynamics in human postural control: methodological considerations. Entropy, 17(12), 7926-7947.

• Norris, P. R., Anderson, S. M., Jenkins, J. M., Williams, A. E., & Morris Jr, J. A. (2008). Heart rate multiscale entropy at three hours predicts hospital mortality in 3,154 trauma patients. Shock, 30(1), 17-22.

• Liu, Q., Wei, Q., Fan, S. Z., Lu, C. W., Lin, T. Y., Abbod, M. F., & Shieh, J. S. (2012). Adaptive computation of multiscale entropy and its application in EEG signals for monitoring depth of anesthesia during surgery. Entropy, 14(6), 978-992.

entropy_sample(signal, delay=1, dimension=2, r='default', **kwargs)

Sample Entropy (SampEn)

Python implementation of the sample entropy (SampEn) of a signal.

This function can be called either via entropy_sample() or complexity_sampen().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (float) – Tolerance (i.e., filtering level - max absolute difference between segments). If ‘default’, will be set to 0.2 times the standard deviation of the signal (for dimension = 2).

• **kwargs (optional) – Other arguments.

See also

entropy_shannon(), entropy_approximate(), entropy_fuzzy()

Returns

float – The sample entropy as float value.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy = nk.entropy_sample(signal)
>>> entropy 

entropy_shannon(signal)

Shannon entropy (SE)

Python implementation of Shannon entropy (SE). Entropy is a measure of unpredictability of the state, or equivalently, of its average information content. Shannon entropy (SE) is one of the first and most basic measure of entropy and a foundational concept of information theory. Shannon’s entropy quantifies the amount of information in a variable.

This function can be called either via entropy_shannon() or complexity_se().

Parameters

signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

Returns

float – The Shannon entropy as float value.

See also

entropy_approximate(), entropy_sample(), entropy_fuzzy()

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>> entropy = nk.entropy_shannon(signal)
>>> entropy 

References

• pyEntropy <https://github.com/nikdon/pyEntropy>`_

• EntroPy <https://github.com/raphaelvallat/entropy>`_

• nolds <https://github.com/CSchoel/nolds>`_

fractal_correlation(signal, delay=1, dimension=2, r=64, show=False)

Correlation Dimension.

Python implementation of the Correlation Dimension D2 of a signal.

This function can be called either via fractal_correlation() or complexity_d2().

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• delay (int) – Time delay (often denoted ‘Tau’, sometimes referred to as ‘lag’). In practice, it is common to have a fixed time lag (corresponding for instance to the sampling rate; Gautama, 2003), or to find a suitable value using some algorithmic heuristics (see delay_optimal()).

• dimension (int) – Embedding dimension (often denoted ‘m’ or ‘d’, sometimes referred to as ‘order’). Typically 2 or 3. It corresponds to the number of compared runs of lagged data. If 2, the embedding returns an array with two columns corresponding to the original signal and its delayed (by Tau) version.

• r (str or int or list) – The sequence of radiuses to test. If an integer is passed, will get an exponential sequence ranging from 2.5% to 50% of the distance range. Methods implemented in other packages can be used via setting r='nolds' or r='Corr_Dim'.

• show (bool) – Plot of correlation dimension if True. Defaults to False.

Returns

D2 (float) – The correlation dimension D2.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=2, frequency=5)
>>>
>>> fractal1 = nk.fractal_correlation(signal, r="nolds", show=True)
>>> fractal1 
>>> fractal2 = nk.fractal_correlation(signal, r=32, show=True)
>>> fractal2 
>>>
>>> signal = nk.rsp_simulate(duration=120, sampling_rate=50)
>>>
>>> fractal3 = nk.fractal_correlation(signal, r="nolds", show=True)
>>> fractal3 
>>> fractal4 = nk.fractal_correlation(signal, r=32, show=True)
>>> fractal4 

References

• Bolea, J., Laguna, P., Remartínez, J. M., Rovira, E., Navarro, A., & Bailón, R. (2014). Methodological framework for estimating the correlation dimension in HRV signals. Computational and mathematical methods in medicine, 2014.

• Boon, M. Y., Henry, B. I., Suttle, C. M., & Dain, S. J. (2008). The correlation dimension: A useful objective measure of the transient visual evoked potential?. Journal of vision, 8(1), 6-6.

• nolds

• Corr_Dim

fractal_dfa(signal, windows='default', overlap=True, integrate=True, order=1, multifractal=False, q=2, show=False)

(Multifractal) Detrended Fluctuation Analysis (DFA or MFDFA)

Python implementation of Detrended Fluctuation Analysis (DFA) or Multifractal DFA of a signal. Detrended fluctuation analysis, much like the Hurst exponent, is used to find long-term statistical dependencies in time series.

This function can be called either via fractal_dfa() or complexity_dfa(), and its multifractal variant can be directly accessed via fractal_mfdfa() or complexity_mfdfa()

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• windows (list) – A list containing the lengths of the windows (number of data points in each subseries). Also referred to as ‘lag’ or ‘scale’. If ‘default’, will set it to a logarithmic scale (so that each window scale hase the same weight) with a minimum of 4 and maximum of a tenth of the length (to have more than 10 windows to calculate the average fluctuation).

• overlap (bool) – Defaults to True, where the windows will have a 50% overlap with each other, otherwise non-overlapping windows will be used.

• integrate (bool) – It is common practice to convert the signal to a random walk (i.e., detrend and integrate, which corresponds to the signal ‘profile’). Note that it leads to the flattening of the signal, which can lead to the loss of some details (see Ihlen, 2012 for an explanation). Note that for strongly anticorrelated signals, this transformation should be applied two times (i.e., provide np.cumsum(signal - np.mean(signal)) instead of signal).

• order (int) – The order of the polynoiam trend, 1 for the linear trend.

• multifractal (bool) – If true, compute Multifractal Detrended Fluctuation Analysis (MFDFA), in which case the argument `q is taken into account.

• q (list) – The sequence of fractal exponents when multifractal=True. Must be a sequence between -10 and 10 (nota that zero will be removed, since the code does not converge there). Setting q = 2 (default) gives a result close to a standard DFA. For instance, Ihlen (2012) usese `` q=[-5, -3, -1, 0, 1, 3, 5]``.

• show (bool) – Visualise the trend between the window size and the fluctuations.

Returns

dfa (float) – The DFA coefficient.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=3, noise=0.05)
>>> dfa1 = nk.fractal_dfa(signal, show=True)
>>> dfa1 
>>> dfa2 = nk.fractal_mfdfa(signal, q=np.arange(-3, 4), show=True)
>>> dfa2 

References

• Ihlen, E. A. F. E. (2012). Introduction to multifractal detrended fluctuation analysis in Matlab. Frontiers in physiology, 3, 141.

• Hardstone, R., Poil, S. S., Schiavone, G., Jansen, R., Nikulin, V. V., Mansvelder, H. D., & Linkenkaer-Hansen, K. (2012). Detrended fluctuation analysis: a scale-free view on neuronal oscillations. Frontiers in physiology, 3, 450.

• nolds

• Youtube introduction

fractal_mandelbrot(size=1000, real_range=- 2, 2, imaginary_range=- 2, 2, threshold=4, iterations=25, buddha=False, show=False)

Generate a Mandelbrot (or a Buddhabrot) fractal.

Vectorized function to efficiently generate an array containing values corresponding to a Mandelbrot fractal.

Parameters

• size (int) – The size in pixels (corresponding to the width of the figure).

• real_range (tuple) – The mandelbrot set is defined within the -2, 2 complex space (the real being the x-axis and the imaginary the y-axis). Adjusting these ranges can be used to pan, zoom and crop the figure.

• imaginary_range (tuple) – The mandelbrot set is defined within the -2, 2 complex space (the real being the x-axis and the imaginary the y-axis). Adjusting these ranges can be used to pan, zoom and crop the figure.

• iterations (int) – Number of iterations.

• threshold (int) – The threshold used, increasing it will increase the sharpness (not used for buddhabrots).

• buddha (bool) – Whether to return a buddhabrot.

• show (bool) – Visualize the fratal.

Returns

fig – Plot of fractal.

Examples

>>> import neurokit2 as nk
>>>
>>> # Mandelbrot fractal
>>> nk.fractal_mandelbrot(show=True) 
array(...)

>>> # Zoom at seahorse valley
>>> nk.fractal_mandelbrot(real_range=(-0.76, -0.74), imaginary_range=(0.09, 0.11),
...                       iterations=100, show=True) 
array(...)
>>>
>>> # Draw manually
>>> m = nk.fractal_mandelbrot(real_range=(-2, 0.75), imaginary_range=(-1.25, 1.25))
>>> plt.imshow(m.T, cmap="viridis") 
>>> plt.axis("off") 
>>> plt.show() 
>>>
>>> # Buddhabrot
>>> b = nk.fractal_mandelbrot(size=1500, real_range=(-2, 0.75), imaginary_range=(-1.25, 1.25),
...                           buddha=True, iterations=200)
>>> plt.imshow(b.T, cmap="gray") 
>>> plt.axis("off") 
>>> plt.show() 
>>>
>>> # Mixed
>>> m = nk.fractal_mandelbrot()
>>> b = nk.fractal_mandelbrot(buddha=True, iterations=200)
>>>
>>> mixed = m - b
>>> plt.imshow(mixed.T, cmap="gray") 
>>> plt.axis("off") 
>>> plt.show() 

fractal_mfdfa(signal, windows='default', overlap=True, integrate=True, order=1, *, multifractal=True, q=2, show=False)

(Multifractal) Detrended Fluctuation Analysis (DFA or MFDFA)

Python implementation of Detrended Fluctuation Analysis (DFA) or Multifractal DFA of a signal. Detrended fluctuation analysis, much like the Hurst exponent, is used to find long-term statistical dependencies in time series.

This function can be called either via fractal_dfa() or complexity_dfa(), and its multifractal variant can be directly accessed via fractal_mfdfa() or complexity_mfdfa()

Parameters

• signal (Union[list, np.array, pd.Series]) – The signal (i.e., a time series) in the form of a vector of values.

• windows (list) – A list containing the lengths of the windows (number of data points in each subseries). Also referred to as ‘lag’ or ‘scale’. If ‘default’, will set it to a logarithmic scale (so that each window scale hase the same weight) with a minimum of 4 and maximum of a tenth of the length (to have more than 10 windows to calculate the average fluctuation).

• overlap (bool) – Defaults to True, where the windows will have a 50% overlap with each other, otherwise non-overlapping windows will be used.

• integrate (bool) – It is common practice to convert the signal to a random walk (i.e., detrend and integrate, which corresponds to the signal ‘profile’). Note that it leads to the flattening of the signal, which can lead to the loss of some details (see Ihlen, 2012 for an explanation). Note that for strongly anticorrelated signals, this transformation should be applied two times (i.e., provide np.cumsum(signal - np.mean(signal)) instead of signal).

• order (int) – The order of the polynoiam trend, 1 for the linear trend.

• multifractal (bool) – If true, compute Multifractal Detrended Fluctuation Analysis (MFDFA), in which case the argument `q is taken into account.

• q (list) – The sequence of fractal exponents when multifractal=True. Must be a sequence between -10 and 10 (nota that zero will be removed, since the code does not converge there). Setting q = 2 (default) gives a result close to a standard DFA. For instance, Ihlen (2012) usese `` q=[-5, -3, -1, 0, 1, 3, 5]``.

• show (bool) – Visualise the trend between the window size and the fluctuations.

Returns

dfa (float) – The DFA coefficient.

Examples

>>> import neurokit2 as nk
>>>
>>> signal = nk.signal_simulate(duration=3, noise=0.05)
>>> dfa1 = nk.fractal_dfa(signal, show=True)
>>> dfa1 
>>> dfa2 = nk.fractal_mfdfa(signal, q=np.arange(-3, 4), show=True)
>>> dfa2 

References

• Ihlen, E. A. F. E. (2012). Introduction to multifractal detrended fluctuation analysis in Matlab. Frontiers in physiology, 3, 141.

• Hardstone, R., Poil, S. S., Schiavone, G., Jansen, R., Nikulin, V. V., Mansvelder, H. D., & Linkenkaer-Hansen, K. (2012). Detrended fluctuation analysis: a scale-free view on neuronal oscillations. Frontiers in physiology, 3, 450.

• nolds

• Youtube introduction

Miscellaneous

Submodule for NeuroKit.

bio_analyze(data, sampling_rate=1000, method='auto')

Automated analysis of bio signals.

Wrapper for other bio analyze functions of electrocardiography signals (ECG), respiration signals (RSP), electrodermal activity (EDA) and electromyography signals (EMG).

Parameters

• data (DataFrame) – The DataFrame containing all the processed signals, typically produced by bio_process(), ecg_process(), rsp_process(), eda_process(), or emg_process().

• sampling_rate (int) – The sampling frequency of the signals (in Hz, i.e., samples/second). Defaults to 1000.

• method (str) – Can be one of ‘event-related’ for event-related analysis on epochs, or ‘interval-related’ for analysis on longer periods of data. Defaults to ‘auto’ where the right method will be chosen based on the mean duration of the data (‘event-related’ for duration under 10s).

Returns

DataFrame – DataFrame of the analyzed bio features. See docstrings of ecg_analyze(), rsp_analyze(), eda_analyze() and emg_analyze() for more details. Also returns Respiratory Sinus Arrhythmia features produced by ecg_rsa() if interval-related analysis is carried out.

See also

ecg_analyze(), rsp_analyze(), eda_analyze(), emg_analyze()

Examples

>>> import neurokit2 as nk
>>>
>>> # Example 1: Event-related analysis
>>> # Download data
>>> data = nk.data("bio_eventrelated_100hz")
>>>
>>> # Process the data
>>> df, info = nk.bio_process(ecg=data["ECG"], rsp=data["RSP"], eda=data["EDA"],
...                           keep=data["Photosensor"], sampling_rate=100)
>>>
>>> # Build epochs
>>> events = nk.events_find(data["Photosensor"], threshold_keep='below',
...                         event_conditions=["Negative", "Neutral",
...                                           "Neutral", "Negative"])
>>> epochs = nk.epochs_create(df, events, sampling_rate=100, epochs_start=-0.1,
...                           epochs_end=1.9)
>>>
>>> # Analyze
>>> nk.bio_analyze(epochs, sampling_rate=100) 
>>>
>>> # Example 2: Interval-related analysis
>>> # Download data
>>> data = nk.data("bio_resting_5min_100hz")
>>>
>>> # Process the data
>>> df, info = nk.bio_process(ecg=data["ECG"], rsp=data["RSP"], sampling_rate=100)
>>>
>>> # Analyze
>>> nk.bio_analyze(df, sampling_rate=100) 

bio_process(ecg=None, rsp=None, eda=None, emg=None, keep=None, sampling_rate=1000)

Automated processing of bio signals.

Wrapper for other bio processing functions of electrocardiography signals (ECG), respiration signals (RSP), electrodermal activity (EDA) and electromyography signals (EMG).

Parameters

• data (DataFrame # pylint: disable=W0611) – The DataFrame containing all the respective signals (e.g., ecg, rsp, Photosensor etc.). If provided, there is no need to fill in the other arguments denoting the channel inputs. Defaults to None.

• ecg (Union[list, np.array, pd.Series]) – The raw ECG channel.

• rsp (Union[list, np.array, pd.Series]) – The raw RSP channel (as measured, for instance, by a respiration belt).

• eda (Union[list, np.array, pd.Series]) – The raw EDA channel.

• emg (Union[list, np.array, pd.Series]) – The raw EMG channel.

• keep (DataFrame) – Dataframe or channels to add by concatenation to the processed dataframe (for instance, the Photosensor channel).

• sampling_rate (int) – The sampling frequency of the signals (in Hz, i.e., samples/second). Defaults to 1000.

Returns

• bio_df (DataFrame) – DataFrames of the following processed bio features: - “ECG”: the raw signal, the cleaned signal, the heart rate, and the R peaks indexes. Also generated by ecg_process(). - “RSP”: the raw signal, the cleaned signal, the rate, and the amplitude. Also generated by rsp_process(). - “EDA”: the raw signal, the cleaned signal, the tonic component, the phasic component, indexes of the SCR onsets, peaks, amplitudes, and half-recovery times. Also generated by eda_process(). - “EMG”: the raw signal, the cleaned signal, and amplitudes. Also generated by emg_process(). - “RSA”: Respiratory Sinus Arrhythmia features generated by ecg_rsa(), if both ECG and RSP are provided.

• bio_info (dict) – A dictionary containing the samples of peaks, troughs, amplitudes, onsets, offsets, periods of activation, recovery times of the respective processed signals.

See also

ecg_process(), rsp_process(), eda_process(), emg_process()

Example

>>> import neurokit2 as nk
>>>
>>> ecg = nk.ecg_simulate(duration=30, sampling_rate=250)
>>> rsp = nk.rsp_simulate(duration=30, sampling_rate=250)
>>> eda = nk.eda_simulate(duration=30, sampling_rate=250, scr_number=3)
>>> emg = nk.emg_simulate(duration=30, sampling_rate=250, burst_number=3)
>>>
>>> bio_df, bio_info = nk.bio_process(ecg=ecg, rsp=rsp, eda=eda, emg=emg, sampling_rate=250)
>>>
>>> # Visualize all signals
>>> fig = nk.standardize(bio_df).plot(subplots=True)
>>> fig 

Submodule for NeuroKit.

as_vector(x)

Convert to vector.

Examples

>>> import neurokit2 as nk
>>>
>>> x = nk.as_vector(x=range(3))
>>> y = nk.as_vector(x=[0, 1, 2])
>>> z = nk.as_vector(x=np.array([0, 1, 2]))
>>> z 
>>>
>>> x = nk.as_vector(x=0)
>>> x 
>>>
>>> x = nk.as_vector(x=pd.Series([0, 1, 2]))
>>> y = nk.as_vector(x=pd.DataFrame([0, 1, 2]))
>>> y 
>>>

expspace(start, stop, num=50, base=1)

Exponential range.

Creates a list of integer values of a given length from start to stop, spread by an exponential function.

Parameters

• start (int) – Minimum range values.

• stop (int) – Maximum range values.

• num (int) – Number of samples to generate. Default is 50. Must be non-negative.

• base (float) – If 1, will use np.exp(), if 2 will use np.exp2().

Returns

array – An array of integer values spread by the exponential function.

Examples

>>> import neurokit2 as nk
>>> nk.expspace(start=4, stop=100, num=10) 
array([  4,   6,   8,  12,  17,  24,  34,  49,  70, 100])

find_closest(closest_to, list_to_search_in, direction='both', strictly=False, return_index=False)

Find the closest number in the array from a given number x.

Parameters

• closest_to (float) – The target number(s) to find the closest of.

• list_to_search_in (list) – The list of values to look in.

• direction (str) – “both” for smaller or greater, “greater” for only greater numbers and “smaller” for the closest smaller.

• strictly (bool) – False for stricly superior or inferior or True for including equal.

• return_index (bool) – If True, will return the index of the closest value in the list.

Returns

closest (int) – The closest number in the array.

Example

>>> import neurokit2 as nk
>>>
>>> # Single number
>>> x = nk.find_closest(1.8, [3, 5, 6, 1, 2])
>>> x  
>>>
>>> y = nk.find_closest(1.8, [3, 5, 6, 1, 2], return_index=True)
>>> y  
>>>
>>> # Vectorized version
>>> x = nk.find_closest([1.8, 3.6], [3, 5, 6, 1, 2])
>>> x  

find_consecutive(x)

Find and group consecutive values in a list.

Creates a list of integer values of a given length from start to stop, spread by an exponential function.

Parameters

x (list) – The list to look in.

Returns

list – A list of tuples corresponding to groups containing all the consecutive numbers.

Examples

>>> import neurokit2 as nk
>>>
>>> x =[2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20]
>>> nk.find_consecutive(x)
[(2, 3, 4, 5), (12, 13, 14, 15, 16, 17), (20,)]

listify(**kwargs)

Transforms arguments into lists of the same length.

Examples

>>> import neurokit2 as nk
>>>
>>> nk.listify(a=3, b=[3, 5], c=[3]) 
{'a': [3, 3], 'b': [3, 5], 'c': [3, 3]}

Benchmarks

Contents:

Benchmarking of ECG Preprocessing Methods

This study can be referenced by citing the package.

We’d like to publish this study, but unfortunately we currently don’t have the time. If you want to help to make it happen, please contact us!

Introduction

This work is a replication and extension of the work by Porr & Howell (2019), that compared the performance of different popular R-peak detectors.

Databases

Glasgow University Database

The GUDB Database (Howell & Porr, 2018) contains ECGs from 25 subjects. Each subject was recorded performing 5 different tasks for two minutes (sitting, doing a maths test on a tablet, walking on a treadmill, running on a treadmill, using a hand bike). The sampling rate is 250Hz for all the conditions.

The script to download and format the database using the ECG-GUDB Python package by Bernd Porr can be found here.

MIT-BIH Arrhythmia Database

The MIT-BIH Arrhythmia Database (MIT-Arrhythmia; Moody & Mark, 2001) contains 48 excerpts of 30-min of two-channel ambulatory ECG recordings sampled at 360Hz and 25 additional recordings from the same participants including common but clinically significant arrhythmias (denoted as the MIT-Arrhythmia-x database).

The script to download and format the database using the can be found here.

MIT-BIH Normal Sinus Rhythm Database

This database includes 18 clean long-term ECG recordings of subjects. Due to memory limits, we only kept the second hour of recording of each participant.

The script to download and format the database using the can be found here.

Concanate them together

import pandas as pd

# Load ECGs
ecgs_gudb = pd.read_csv("../../data/gudb/ECGs.csv")
ecgs_mit1 = pd.read_csv("../../data/mit_arrhythmia/ECGs.csv")
ecgs_mit2 = pd.read_csv("../../data/mit_normal/ECGs.csv")

# Load True R-peaks location
rpeaks_gudb = pd.read_csv("../../data/gudb/Rpeaks.csv")
rpeaks_mit1 = pd.read_csv("../../data/mit_arrhythmia/Rpeaks.csv")
rpeaks_mit2 = pd.read_csv("../../data/mit_normal/Rpeaks.csv")

# Concatenate
ecgs = pd.concat([ecgs_gudb, ecgs_mit1, ecgs_mit2], ignore_index=True)
rpeaks = pd.concat([rpeaks_gudb, rpeaks_mit1, rpeaks_mit2], ignore_index=True)

Study 1: Comparing Different R-Peaks Detection Algorithms

Procedure

Setup Functions

import neurokit2 as nk

def neurokit(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="neurokit")
    return info["ECG_R_Peaks"]

def pantompkins1985(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="pantompkins1985")
    return info["ECG_R_Peaks"]

def hamilton2002(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="hamilton2002")
    return info["ECG_R_Peaks"]

def martinez2003(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="martinez2003")
    return info["ECG_R_Peaks"]

def christov2004(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="christov2004")
    return info["ECG_R_Peaks"]

def gamboa2008(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="gamboa2008")
    return info["ECG_R_Peaks"]

def elgendi2010(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="elgendi2010")
    return info["ECG_R_Peaks"]

def engzeemod2012(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="engzeemod2012")
    return info["ECG_R_Peaks"]

def kalidas2017(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="kalidas2017")
    return info["ECG_R_Peaks"]

def rodrigues2020(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="rodrigues2020")
    return info["ECG_R_Peaks"]

Run the Benchmarking

Note: This takes a long time (several hours).

results = []
for method in [neurokit, pantompkins1985, hamilton2002, martinez2003, christov2004,
               gamboa2008, elgendi2010, engzeemod2012, kalidas2017, rodrigues2020]:
    result = nk.benchmark_ecg_preprocessing(method, ecgs, rpeaks)
    result["Method"] = method.__name__
    results.append(result)
results = pd.concat(results).reset_index(drop=True)

results.to_csv("data_detectors.csv", index=False)

Results

library(tidyverse)
library(easystats)
library(lme4)

data <- read.csv("data_detectors.csv", stringsAsFactors = FALSE) %>%
  mutate(Database = ifelse(str_detect(Database, "GUDB"), paste0(str_replace(Database, "GUDB_", "GUDB ("), ")"), Database),
         Method = fct_relevel(Method, "neurokit", "pantompkins1985", "hamilton2002", "martinez2003", "christov2004", "gamboa2008", "elgendi2010", "engzeemod2012", "kalidas2017", "rodrigues2020"),
         Participant = paste0(Database, Participant))

colors <- c("neurokit"="#E91E63", "pantompkins1985"="#f44336", "hamilton2002"="#FF5722", "martinez2003"="#FF9800", "christov2004"="#FFC107", "gamboa2008"="#4CAF50", "elgendi2010"="#009688", "engzeemod2012"="#2196F3", "kalidas2017"="#3F51B5", "rodrigues2020"="#9C27B0")

Errors and bugs

data %>%
  mutate(Error = case_when(
    Error == "index -1 is out of bounds for axis 0 with size 0" ~ "index -1 out of bounds",
    Error == "index 0 is out of bounds for axis 0 with size 0" ~ "index 0 out of bounds",
    TRUE ~ Error)) %>%
  group_by(Database, Method) %>%
  mutate(n = n()) %>%
  group_by(Database, Method, Error) %>%
  summarise(Percentage = n() / unique(n)) %>%
  ungroup() %>%
  mutate(Error = fct_relevel(Error, "None")) %>%
  ggplot(aes(x=Error, y=Percentage, fill=Method)) +
    geom_bar(stat="identity", position = position_dodge2(preserve = "single")) +
    facet_wrap(~Database, nrow=2) +
    theme_modern() +
    theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
    scale_fill_manual(values=colors)

Conclusion: It seems that gamboa2008 and martinez2003 are particularly prone to errors, especially in the case of a noisy ECG signal. Aside from that, the other algorithms are quite resistant and bug-free.

data <- filter(data, Error == "None")
data <- filter(data, !is.na(Score))

Computation Time

Descriptive Statistics

# Normalize duration
data <- data %>%
  mutate(Duration = (Duration) / (Recording_Length * Sampling_Rate))

data %>%
  ggplot(aes(x=Method, y=Duration, fill=Method)) +
    geom_jitter2(aes(color=Method, group=Database), size=3, alpha=0.2, position=position_jitterdodge()) +
    geom_boxplot(aes(alpha=Database), outlier.alpha = 0) +
    geom_hline(yintercept=0, linetype="dotted") +
    theme_modern() +
    theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
    scale_alpha_manual(values=seq(0, 1, length.out=8)) +
    scale_color_manual(values=colors) +
    scale_fill_manual(values=colors) +
    scale_y_sqrt() +
    ylab("Duration (seconds per data sample)")

Statistical Modelling

model <- lmer(Duration ~ Method + (1|Database) + (1|Participant), data=data)

means <- modelbased::estimate_means(model)

arrange(means, Mean)
##             Method     Mean       SE    CI_low  CI_high
## 1       gamboa2008 8.47e-06 9.34e-06 -9.98e-06 2.69e-05
## 2         neurokit 2.08e-05 7.20e-06  6.43e-06 3.52e-05
## 3     martinez2003 4.68e-05 8.00e-06  3.09e-05 6.27e-05
## 4      kalidas2017 7.77e-05 7.19e-06  6.33e-05 9.20e-05
## 5    rodrigues2020 1.17e-04 7.20e-06  1.03e-04 1.32e-04
## 6     hamilton2002 1.51e-04 7.19e-06  1.36e-04 1.65e-04
## 7    engzeemod2012 5.33e-04 7.24e-06  5.19e-04 5.47e-04
## 8  pantompkins1985 5.96e-04 7.19e-06  5.82e-04 6.11e-04
## 9      elgendi2010 9.26e-04 7.19e-06  9.12e-04 9.41e-04
## 10    christov2004 1.32e-03 7.19e-06  1.31e-03 1.34e-03

means %>%
  ggplot(aes(x=Method, y=Mean, color=Method)) +
  geom_line(aes(group=1), size=1) +
  geom_pointrange(aes(ymin=CI_low, ymax=CI_high), size=1) +
  geom_hline(yintercept=0, linetype="dotted") +
  theme_modern() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  scale_color_manual(values=colors) +
    ylab("Duration (seconds per data sample)")

Conclusion: It seems that gamboa2008 and neurokit are the fastest methods, followed by martinez2003, kalidas2017, rodrigues2020 and hamilton2002. The other methods are then substantially slower.

Accuracy

Note: The accuracy is computed as the absolute distance from the original “true” R-peaks location. As such, the closest to zero, the better the accuracy.

Descriptive Statistics

data <- data %>%
  mutate(Outlier = performance::check_outliers(Score, threshold = list(zscore = stats::qnorm(p = 1 - 0.000001)))) %>%
  filter(Outlier == 0)

data %>%
  ggplot(aes(x=Database, y=Score)) +
    geom_boxplot(aes(fill=Method), outlier.alpha = 0, alpha=1) +
    geom_jitter2(aes(color=Method, group=Method), size=3, alpha=0.2, position=position_jitterdodge()) +
    geom_hline(yintercept=0, linetype="dotted") +
    theme_modern() +
    theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
    scale_color_manual(values=colors) +
    scale_fill_manual(values=colors) +
    scale_y_sqrt() +
    ylab("Amount of Error")

Statistical Modelling

model <- lmer(Score ~ Method + (1|Database) + (1|Participant), data=data)

means <- modelbased::estimate_means(model)

arrange(means, abs(Mean))
##             Method   Mean      SE  CI_low CI_high
## 1         neurokit 0.0143 0.00448 0.00424  0.0244
## 2      kalidas2017 0.0151 0.00448 0.00500  0.0251
## 3     christov2004 0.0152 0.00455 0.00507  0.0253
## 4    rodrigues2020 0.0304 0.00449 0.02037  0.0405
## 5    engzeemod2012 0.0320 0.00462 0.02180  0.0422
## 6     martinez2003 0.0337 0.00507 0.02290  0.0445
## 7  pantompkins1985 0.0338 0.00453 0.02364  0.0439
## 8     hamilton2002 0.0387 0.00450 0.02865  0.0488
## 9      elgendi2010 0.0541 0.00459 0.04397  0.0643
## 10      gamboa2008 0.0928 0.00768 0.07750  0.1081

means %>%
  ggplot(aes(x=Method, y=Mean, color=Method)) +
  geom_line(aes(group=1), size=1) +
  geom_pointrange(aes(ymin=CI_low, ymax=CI_high), size=1) +
  geom_hline(yintercept=0, linetype="dotted") +
  theme_modern() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  scale_color_manual(values=colors) +
    ylab("Amount of Error")

Conclusion: It seems that neurokit, kalidas2017 and christov2004 the most accurate algorithms to detect R-peaks. This pattern of results differs a bit from Porr & Howell (2019) that outlines engzeemod2012, elgendi2010, kalidas2017 as the most accurate and christov2004, hamilton2002 and pantompkins1985 as the worse. Discrepancies could be due to the differences in data and analysis, as here we used more databases and modelled them by respecting their hierarchical structure using mixed models.

Conclusion

Based on the accuracy / execution time criterion, it seems like neurokit is the best R-peak detection method, followed by kalidas2017.

Study 2: Normalization

Procedure

Setup Functions

import neurokit2 as nk

def none(ecg, sampling_rate):
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="neurokit")
    return info["ECG_R_Peaks"]

def mean_detrend(ecg, sampling_rate):
    ecg = nk.signal_detrend(ecg, order=0)
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="neurokit")
    return info["ECG_R_Peaks"]

def standardize(ecg, sampling_rate):
    ecg = nk.standardize(ecg)
    signal, info = nk.ecg_peaks(ecg, sampling_rate=sampling_rate, method="neurokit")
    return info["ECG_R_Peaks"]

Run the Benchmarking

Note: This takes a long time (several hours).

results = []
for method in [none, mean_detrend, standardize]:
    result = nk.benchmark_ecg_preprocessing(method, ecgs, rpeaks)
    result["Method"] = method.__name__
    results.append(result)
results = pd.concat(results).reset_index(drop=True)

results.to_csv("data_normalization.csv", index=False)

Results

library(tidyverse)
library(easystats)
library(lme4)

data <- read.csv("data_normalization.csv", stringsAsFactors = FALSE) %>%
  mutate(Database = ifelse(str_detect(Database, "GUDB"), paste0(str_replace(Database, "GUDB_", "GUDB ("), ")"), Database),
         Method = fct_relevel(Method, "none", "mean_removal", "standardization"),
         Participant = paste0(Database, Participant)) %>%
  filter(Error == "None") %>%
  filter(!is.na(Score))

colors <- c("none"="#607D8B", "mean_removal"="#673AB7", "standardization"="#00BCD4")

Accuracy

Descriptive Statistics

data <- data %>%
  mutate(Outlier = performance::check_outliers(Score, threshold = list(zscore = stats::qnorm(p = 1 - 0.000001)))) %>%
  filter(Outlier == 0)

data %>%
  ggplot(aes(x=Database, y=Score)) +
    geom_boxplot(aes(fill=Method), outlier.alpha = 0, alpha=1) +
    geom_jitter2(aes(color=Method, group=Method), size=3, alpha=0.2, position=position_jitterdodge()) +
    geom_hline(yintercept=0, linetype="dotted") +
    theme_modern() +
    theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
    scale_color_manual(values=colors) +
    scale_fill_manual(values=colors) +
    scale_y_sqrt() +
    ylab("Amount of Error")

Statistical Modelling

model <- lmer(Score ~ Method + (1|Database) + (1|Participant), data=data)

modelbased::estimate_contrasts(model)
## Level1       |          Level2 | Difference |       SE |                95% CI |    t |     df |     p | Difference (std.)
## --------------------------------------------------------------------------------------------------------------------------
## mean_removal |            none |   1.59e-07 | 5.20e-07 | [-0.00e+00, 0.00e+00] | 0.31 | 370.00 | 0.759 |          1.64e-05
## mean_removal | standardization |   7.75e-07 | 5.20e-07 | [-0.00e+00, 0.00e+00] | 1.49 | 370.00 | 0.410 |          7.99e-05
## none         | standardization |   6.15e-07 | 5.20e-07 | [-0.00e+00, 0.00e+00] | 1.18 | 370.00 | 0.474 |          6.34e-05

means <- modelbased::estimate_means(model)
arrange(means, abs(Mean))
##            Method    Mean      SE  CI_low CI_high
## 1 standardization 0.00803 0.00136 0.00482  0.0112
## 2            none 0.00803 0.00136 0.00482  0.0112
## 3    mean_removal 0.00803 0.00136 0.00482  0.0112

means %>%
  ggplot(aes(x=Method, y=Mean, color=Method)) +
  geom_line(aes(group=1), size=1) +
  geom_pointrange(aes(ymin=CI_low, ymax=CI_high), size=1) +
  theme_modern() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  scale_color_manual(values=colors) +
    ylab("Amount of Error")

Conclusion

No significant benefits added by normalization for the neurokit method.

References

Howell, L., & Porr, B. (2018). High precision ecg database with annotated r peaks, recorded and filmed under realistic conditions.

Moody, G. B., & Mark, R. G. (2001). The impact of the mit-bih arrhythmia database. IEEE Engineering in Medicine and Biology Magazine, 20(3), 45–50.

Porr, B., & Howell, L. (2019). R-peak detector stress test with a new noisy ecg database reveals significant performance differences amongst popular detectors. bioRxiv, 722397.

Datasets

NeuroKit includes datasets that can be used for testing. These datasets are not downloaded automatically with the package (to avoid increasing its weight), but can be downloaded via the nk.data() function.

ECG (1000 hz)

Type	Frequency	Signals
Single-subject	1000 Hz	ECG

data = nk.data(dataset="ecg_1000hz")

ECG - pandas (3000 hz)

Type	Frequency	Signals
Single-subject	3000 Hz	ECG

data = nk.data(dataset="ecg_3000_pandas")

Event-related (4 events)

Type	Frequency	Signals
Single-subject with events	100 Hz	ECG, EDA, RSP, Photosensor

data = nk.data(dataset="bio_eventrelated_100hz")

• Used in the following docstrings:

  • bio_analyze()

  • ecg_analyze()

  • ecg_eventrelated()

  • ecg_rsa()

  • ecg_rsp()

  • eda_analyze()

  • eda_eventrelated()

  • eda_phasic()

  • epochs_create()

  • epochs_plot()

  • epochs_to_df()

  • rsp_analyze()

  • rsp_eventrelated()

  • signal_power()

• Used in the following examples:

  • Event-related Analysis

  • Analyze Respiratory Rate Variability (RRV)

Resting state (5 min)

Type	Frequency	Signals
Single-subject resting state	100 Hz	ECG, PPG, RSP

data = nk.data(dataset="bio_resting_5min_100hz")

• Used in the following docstrings:

  • bio_analyze()

  • ecg_analyze()

  • ecg_intervalrelated()

  • rsp_analyze()

  • rsp_intervalrelated()

• Used in the following examples:

  • Interval-related Analysis

Resting state (8 min)

Type	Frequency	Signals
Single-subject resting state	100 Hz	ECG, RSP, EDA, Photosensor

data = nk.data(dataset="bio_resting_8min_100hz")

• Used in the following docstrings:

  • eda_analyze()

  • eda_intervalrelated()

Contributing

We’re glad that you are considering joining the team and the community of open-science. You can find step-by-step guides below that will show you how to make a perfect first contribution.

All people are very much welcome to contribute to code, documentation, testing and suggestions.

This package aims at being beginner-friendly. Even if you’re new to this open-source way of life, new to coding and GitHub stuff, we encourage you to try submitting pull requests (PRs).

• “I’d like to help, but I’m not good enough with programming yet”

It’s alright, don’t worry! You can always dig in the code, in the documentation or tests. There are always some typos to fix, some docs to improve, some details to add, some code lines to document, some tests to add… Just explore the code structure, find where functions are located, where documentation is written, where tests are made, and see what you can fix. Even the smaller PRs are appreciated.

• “I don’t know how to code at all :(“

You can still contribute to the documentation by creating tutorials, help and info!

• “I’d like to help, but I don’t know where to start”

You can look around the issue section to find some features / ideas / bugs to start working on. You can also open a new issue just to say that you’re there, interested in helping out. We might have some ideas adapted to your skills.

• “I’m not sure if my suggestion or idea is worthwhile”

Enough with the impostor syndrome! All suggestions and opinions are good, and even if it’s just a thought or so, it’s always good to receive feedback.

• “Why should I waste my time with this? Do I get any credit?”

Software contributions are getting more and more valued in the academic world, so it is a good time to collaborate with us! All contributors will be added within the authors list. We’re also very keen on including them to eventual academic publications.

Anyway, starting is the most important! You will then enter a whole new world, a new fantastic point of view… So fork this repo, do some changes and submit them. We will then work together to make the best out of it 💪

Contributing Guides:

Understanding NeuroKit

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing see our guides).

Let’s start by reviewing some basic coding principles that might help you get familiar with NeuroKit

If you are reading this, it could be because you don’t feel comfortable enough with Python and NeuroKit (yet), and you impatiently want to get to know it in order to start looking at your data.

“Tous les chemins mènent à Rome” (all roads lead to Rome)

Let me start by saying that there are multiple ways you’ll be able to access the documentation in order to get to know different functions, follow examples and other tutorials. So keep in mind that you will eventually find your own workflow, and that these tricks are shared simply to help you get to know your options.

1. readthedocs

You probably already saw the README file that shows up on NeuroKit’s Github home page (right after the list of directories). It contains a brief overview of the project, some examples and figures. But, most importantly, there are the links that will take you to the Documentation.

Documentation basically means code explanations, references and examples.

In the Documentation section of the README, you’ll find links to the readthedocs website like this one :

Hint

Did you know that you can access the documentation website using the rtfd domain name https://neurokit2.rtfd.io/, which stands for READ THE F**** DOCS 😏

And a link to the API (or Application Program Interface, containing the list of functions) like this one:

All the info you will see on that webpage is rendered directly from the code, meaning that the website reads the code and generates a HTML page from it. That’s why it’s important to structure your code in a standard manner (You can learn how to contribute here).

The API is organized by types of signals. You’ll find that each function has a description, and that most of them refer to peer-reviewed papers or other GitHub repositories. Also, for each function, parameters are described in order. Some of them will take many different options and all of them should be described as well.

If the options are not explained, they should be.

It’s not your fault you don’t understand. That’s why we need you to contribute.

Example

In the ECG section, the ecg_findpeaks function takes 4 parameters. One of them is method: each method refers to a peer-reviewed paper that published a peak detection algorithm. You can also see what the function returns and what type of data has been returned (integers and floating point numbers, strings, etc). Additionally, you can find related functions in the See also part. An small example of the function should also be found. You can copy paste it in your Python kernel, or in a Jupyter Notebook, to see what it does.

2. The code on Github

Now that you’re familiar with readthedocs website, let’s go back to the repo. What you have to keep in mind is that everything you saw in the previous section is in the Github repository. The website pages, the lines that you are currently reading, are stored in the repository, which is then automatically uploaded to the website. Everything is cross-referenced, everything relates to the core which can be found in the repo. If you got here, you probably already know that a repository is like a tree containing different branches or directories that eventually lead you to a script, in which you can find a function.

Example

Ready for inception ? let’s find the location of the file you’re currently reading. Go under docs and find it by yourself… it should be straight-forward.

Hint

As you can see, there are several sections (see the Table of Content on the left), and we are in the tutorials section. So you might want to look into the tutorials folder :)

See! It’s super handy because you can visit the scripts without downloading it. Github also renders Jupyter Notebook quite well, so you can not only see the script, but also figures and markdown sections where the coder discusses results.

3. The code on YOUR machine

Now, you’re probably telling yourself :

If I want to use these functions, they should be somewhere on my computer!

For that, I encourage you to visit the installation page if you didn’t already. Once Python is installed, its default pathway should be :

Python directory

Windows

• C:\Users\<username>\anaconda3\

(if the directory doesn’t match, just search for the folder name anaconda3 or miniconda3.

Mac

• /Users/<username>/anaconda3

Or, if you’re using WinPython it should be in the folder of its installation (e.g., C:\Users\<username>\Desktop\WPy-3710\).

Linux users should know that already

Environment and NeuroKit directory

NeuroKit, along with all the other packages, are located in the python directory in the site-package folder (itself in the Lib folder). It should be located under the environment where you installed it (if you didn’t do it already, set a computing environment. Otherwise, you can run into problems when running your code). The directory should look like this:

• C:\Users\<username>\anaconda3\envs\<yourenv>\lib\site-package\neurokit2

Or, if you’re using WinPython:

• C:\Users\<username>\Desktop\WPy-3710\python-3.7.1.amd64\Lib\site-package\neurokit2

Example

Take the ECG again :

From the specified directory, I can note that the different folders are arranged in the same way as in the readthedocs website.

Let’s say I want to go back to the same function ecg_findpeaks(): I’d click on ecg folder, and from there I can see the source code for the function under ; ecg_findpeaks.py.

Contributing guide

NeuroKit2 welcomes everyone to contribute to code, documentation, testing and suggestions.

This package aims at being beginner-friendly. And if you’re not yet familiar with how contribution can be done to open-source packages, or with how to use GitHub, this guide is for you!

Let’s dive right into it!

NeuroKit’s style

Structure and code

• The NeuroKit package is organized into submodules, such as ecg, signal, statistics, etc. New functions should be created within at the appropriate places.

• The API (the functions) should be consistent, with functions starting with a prefix (plot_, ecg_, eda_, etc.) so that the user can easily find them by typing the “intuitive” prefix.

• Authors of code contribution are invited to follow the PEP 8 style sheet to write some nice (and readable) python.

• That being said, human readability should always be favoured over anything else. Ideally, we would like the code in NeuroKit to be understandable even by non-programmers.

• Contrary to Python recommendations, we prefer some nicely nested loops, rather than complex one-liners [“that” for s if h in i for t in range(“don’t”) if “understand” is False].

• The maximum line length is 100 characters

• Please document and comment your code, so that the purpose of each step (or code line) is stated in a clear and understandable way.

• Don’t forget to add tests and documentation (a description, examples, etc.) to your functions.

Run code checks

Once you’re satisfied by the code you’ve written, you will need to run some checks to make sure it is “standardized”. You will need to open the command line and install the following packages:

pip install isort black docformatter flake8 pylint

Now, navigate to the folder where your script is by typing cd C:\the\folder\of\my\file. Once you there, you can run the following commands:

isort myfile.py -l 120  --balanced --multi-line 3 --lines-between-types 1 --lines-after-imports 2 --trailing-comma
black myfile.py --line-length 120
docformatter myfile.py --wrap-summaries 120 --wrap-descriptions 113 --blank --in-place

flake8 myfile.py --max-line-length=127 --max-complexity=10 --ignore E303,C901,E203,W503
pylint myfile.py --max-line-length=127 --load-plugins=pylint.extensions.docparams --load-plugins=pylint.extensions.docstyle --variable-naming-style=any --argument-naming-style=any --reports=n --suggestion-mode=y --disable=E303 --disable=R0913 --disable=R0801 --disable=C0114 --disable=E203 --disable=E0401 --disable=W9006 --disable=C0330 --disable=R0914 --disable=R0912 --disable=R0915 --disable=W0102 --disable=W0511 --disable=C1801 --disable=C0111 --disable=R1705 --disable=R1720 --disable=C0301 --disable=C0415 --disable=C0103 --disable=C0302 --disable=R1716 --disable=W0632 --disable=E1136 --extension-pkg-whitelist=numpy

The first three commands will make some modifications to your code so that it is nicely formatted, while the two last will run some checks to detect any additional issues. Please try to fix them!

PS: If you want to check the whole package (i.e., all the files of the package), run:

isort neurokit2 -l 120 --balanced --multi-line 3 --lines-between-types 1 --lines-after-imports 2 --trailing-comma --skip neurokit2/complexity/__init__.py --recursive
black neurokit2 --line-length 120
docformatter neurokit2 --wrap-summaries 120 --wrap-descriptions 113 --blank --in-place --recursive

flake8 neurokit2 --exclude neurokit2/__init__.py --max-line-length=127 --max-complexity=10 --ignore E303,C901,E203,W503
pylint neurokit2 --max-line-length=127 --load-plugins=pylint.extensions.docparams --load-plugins=pylint.extensions.docstyle --variable-naming-style=any --argument-naming-style=any --reports=n --suggestion-mode=y --disable=E303 --disable=R0913 --disable=R0801 --disable=C0114 --disable=E203 --disable=E0401 --disable=W9006 --disable=C0330 --disable=R0914 --disable=R0912 --disable=R0915 --disable=W0102 --disable=W0511 --disable=C1801 --disable=C0111 --disable=R1705 --disable=R1720 --disable=C0301 --disable=C0415 --disable=C0103 --disable=C0302 --disable=R1716 --disable=W0632 --disable=E1136 --extension-pkg-whitelist=numpy --exit-zero

Avoid Semantic Errors

Most errors detected by our code checks can be easily automated with isort, black, and docformatter. This leaves us with the semantic errors picked up by pylint, the last style check, which often have to be fixed manually. Below is a list of the most common semantic errors that occur when writing code/documentation, so before you commit any changes, do make sure you have fixed these.

Documentation

• Missing function arguments in Parameters and Returns.

• In internal functions, missing Returns section detected only if Parameters is documented but is not followed by returns documentation.

• Failure to detect documentation of arguments when they are done simultaneously in one line:

a, b, c, discard, n, sampling_rate, x0 : int

will result in a pylint error like a, b, c, discard, n, sampling_rate, x0" missing in parameter documentation (missing-param-doc) so do document each argument separately.

• Argument name different from documentation

Code

• Unused arguments

• Unused variables

• Merge if arguments, for example: if isinstance(ecg, (list, pd.Series)) rather than if isinstance(ecg, list) or isinstance(ecg, pd.Series)

Development workflow

The NeuroKit GitHub repository has two main branches, master and the dev. The typical workflow is to work and make changes on the dev branch. This dev branch has a pull request (PR) opened to track individual commits (changes). And every now and then (when a sufficient number of changes have been made), the dev branch is merged into master, leading to an update of the version number and an upload to PyPi.

The important thing is that you should not directly make changes on the master branch, because master is usually behind dev (which means for instance, maybe the the things you are changing on master have already been changed on dev). The master should be a stable, tested branch, and dev is the place to experiment.

This is a summary of the typical workflow for contributing using GitHub (a detailed guide is available below):

1. Download GitHub Desktop and follow the small tutorial that it proposes

2. Fork the NeuroKit repository (this can be done on the GitHub website page by clicking on the Fork button), and clone it using GitHub Desktop to your local computer (it will copy over the whole repo from GitHub to your local machine)

3. In GitHub Desktop, switch to the dev branch. You are now on the dev branch (of your own fork)

4. From there, create a new branch, called for example “bugfix-functionX” or “feature-readEEG” or “typofix”

5. Make some changes and push them (this will update your fork)

6. Create a pull request (PR) from your fork to the “origin” (the original repo) dev branch

7. This will trigger automated checks that you can explore and fix

8. Wait for it to be merged into dev, and later see it being merged into master

How to use GitHub to contribute

Step 1: Fork it

A fork is a copy of a repository. Working with the fork allows you to freely experiment with changes without affecting the original project.

Hit the Fork button in the top right corner of the page and in a few seconds, you will have a copy of the repository in your own GitHub account.

Now, that is the remote copy of the project. The next step is to make a local copy in your computer.

While you can explore Git to manage your Github developments, we recommend downloading Github Desktop instead. It makes the process way easier and more straightforward.

Step 2: Clone it

Cloning allows you to make a local copy of any repositories on Github.

Go to File menu, click Clone Repository and since you have forked Neurokit2, you should be able to find it easily under Your repositories.

Choose the local path of where you want to save your local copy and as simple as that, you have a working repository in your computer.

Step 3: Find it and fix it

And here is where the fun begins. You can start contributing by fixing a bug (or even a typo in the code) that has been annoying you. Or you can go to the issue section to hunt for issues that you can address.

For example, here, as I tried to run the example in ecg_fixpeaks() file, I ran into a bug! A typo error!

Fix it and hit the save button! That’s one contribution I made to the package!

To save the changes you made (e.g. the typo that was just fixed) to your local copy of the repository, the next step is to commit it.

Step 4: Commit it and push it

In your Github Desktop, you will now find the changes that you made highlighted in red (removed) or green (added).

The first thing that you have to do is to switch from the default - Commit to Master to Commit to dev. Always commit to your dev branch as it is the branch with the latest changes. Then give the changes you made a good and succinct title and hit the Commit button.

Committing allows your changes to be saved in your local copy of the repository and in order to have the changes saved in your remote copy, you have to push the commit that you just made.

Step 4: Create pull request

The last step to make your contribution official is to create a pull request.

Go to your remote repository on Github page, the New Pull Request button is located right on top of the folders. Do remember to change your branch to dev since your commits were pushed to the dev branch previously.

And now, all that is left is for the maintainers of the package to review your work and they can either request additional changes or merge it to the original repository.

Step 5: Let’s do it

Let’s do it for real! If you have a particular feature in mind that you would want to add, we would recommend first opening an issue to let us know, so we can eventually guide you and give you some advice. And if you don’t know where to start or what to do, then read our ideas for first contributions. Good luck 💪

Useful reads

For instance, one way of starting to contribute could be to improve this file, fix typos, clarify things, add resources links etc. :)

• Understanding the GitHub flow

• How to create a Pull Request

• Why and How to Contribute

What’s next?

• Ideas for first contributions

Ideas for first contributions

Hint

Spotted a typo? Would like to add something or make a correction? Join us by contributing (see our guides).

Now that you’re familiar with how to use GitHub, you’re ready to get your hands dirty and contribute to open-science? But you’re not sure where to start or what to do? We got you covered!

In this guide, we will discuss the two best types of contributions for beginners, as they are easy to make, super useful and safe (you cannot break the package 😏).

Look for “good first contribution” issues

If you know how to code a bit, you can check out the issues that have been flagged as good for first contribution. This means that they are issue or features ideas that we believe are accessible to beginners. If you’re interested, do not hesitate to comment on these issues to know more, have more info or ask for guidance! We’ll be really happy to help in any way we can ☺️.

Improving documentation

One of the easiest thing is to improve, complete or fix the documentation for functions. For instance the ecg_simulate() function has a documentation with a general description, a description of the arguments, some example etc. As you’ve surely noticed, sometimes more details would be needed, some typos are present, or some references could be added.

The documentation for functions is located alongside the function definition (the code of the function). If you’ve read understanding NeuroKit, you know that the code of the ecg_simulate() function is here. And as you can see, just below the function name, there is a big string (starting and ending with “””) containing the documentation.

This thing is called the docstring.

If you modify it here, then it will be updated automatically on the website!

Adding tests

Tests are super important for programmers to make sure that the changes that we make at one location don’t create unexpected changes at another place.

Adding them is a good first issue for new contributors, as it takes little time, doesn’t require advanced programming skills and is a good occasion to discover functions and how they work.

By clicking on the “coverage” badge under the logo on the README page, then on the “neurokit2” folder button at the bottom, you can see the breakdown of testing coverage for each submodules (folders), and if you click on one of them, the coverage for each individual file/function (example here).

This percentage of coverage needs be improved ☺️

The common approach is to identify functions, methods or arguments that are not tested, and then try to write a small test to cover them (i.e., a small self-contained piece of code that will run through a given portion of code and which output is tested (e.g., assert x == 3) and depends on the correct functioning of that code), and then add this test to the appropriate testing file.

For instance, let’s imagine the following function:

def domsfunction(x, method="great"):
    if method == "great":
         z = x + 3
    else:
         z = x + 4
    return z

In order to test that function, I have to write some code that “runs through” it and put in a function which name starts with test_*, for instance:

def test_domsfunction():
    # Test default parameters
    output = domsfunction(1)
    assert output == 4

This will go through the function, which default method is “great”, therefore adds 3 to the input (here 1), and so the result should be 4. And the test makes sure that it is 4. However, we also need to add a second test to cover the other method of the function (when method != “great”), for instance:

def test_domsfunction():
    # Test default parameters
    output = domsfunction(1)
    assert output == 4

    # Test other method
    output = domsfunction(1, method="whatever")
    assert isinstance(output, int)

I could have written assert output == 5, however, I decided instead to check the type of the output (whether it is an integer). That’s the thing with testing, it requires to be creative, but also in more complex cases, to be clever about what and how to test. But it’s an interesting challenge 😏

You can see examples of tests in the existing test files.

Adding examples and tutorials

How to write

The documentation that is on the website is automatically built by the hosting website, readthedocs, from reStructured Text (RST) files (a syntax similar to markdown) or from jupyter notebooks (.ipynb) Notebooks are preferred if your example contains code and images.

Where to add the files

These documentation files that we need to write are located in the /docs/ folder. For instance, if you want to add an example, you need to create a new file, for instance myexample.rst, in the docs/examples/ folder.

If you want to add images to an .rst file, best is to put them in the /docs/img/ folder and to reference their link.

However, in order for this file to be easily accessible from the website, you also need to add it to the table of content located in the index file (just add the name of the file without the extension).

Do not hesitate to ask for more info by creating an issue!