Process physiological recordings in Python, including heart, brain, breathing, and muscle signals. Supports signal cleaning, heart rate variability measurements, stimulus response analysis, and combined analysis of multiple signal types.
Comprehensive biosignal processing toolkit for analyzing physiological data including ECG, EEG, EDA, RSP, PPG, EMG, and EOG signals. Use this skill when processing cardiovascular signals, brain activity, electrodermal responses, respiratory patterns, muscle activity, or eye movements. Applicable for heart rate variability analysis, event-related potentials, complexity measures, autonomic nervous system assessment, psychophysiology research, and multi-modal physiological signal integration.
Run score Not tested
See how to installReview the instructions the agent will receive before you install.
NeuroKit2 is a comprehensive Python toolkit for processing and analyzing physiological signals (biosignals). Use this skill to process cardiovascular, neural, autonomic, respiratory, and muscular signals for psychophysiology research, clinical applications, and human-computer interaction studies.
Apply this skill when working with:
Process electrocardiogram and photoplethysmography signals for cardiovascular analysis. See references/ecg_cardiac.md for detailed workflows.
Primary workflows:
Key functions:
import neurokit2 as nk
# Complete ECG processing pipeline
signals, info = nk.ecg_process(ecg_signal, sampling_rate=1000)
# Analyze ECG data (event-related or interval-related)
analysis = nk.ecg_analyze(signals, sampling_rate=1000)
# Comprehensive HRV analysis
hrv = nk.hrv(peaks, sampling_rate=1000) # Time, frequency, nonlinear domains
Compute comprehensive HRV metrics from cardiac signals. See references/hrv.md for all indices and domain-specific analysis.
Supported domains:
Key functions:
# All HRV indices at once
hrv_indices = nk.hrv(peaks, sampling_rate=1000)
# Domain-specific analysis
hrv_time = nk.hrv_time(peaks)
hrv_freq = nk.hrv_frequency(peaks, sampling_rate=1000)
hrv_nonlinear = nk.hrv_nonlinear(peaks, sampling_rate=1000)
hrv_rsa = nk.hrv_rsa(peaks, rsp_signal, sampling_rate=1000)
Analyze electroencephalography signals for frequency power, complexity, and microstate patterns. See references/eeg.md for detailed workflows and MNE integration.
Primary capabilities:
Key functions:
# Power analysis across frequency bands
power = nk.eeg_power(eeg_data, sampling_rate=250, channels=['Fz', 'Cz', 'Pz'])
# Microstate analysis
microstates = nk.microstates_segment(eeg_data, n_microstates=4, method='kmod')
static = nk.microstates_static(microstates)
dynamic = nk.microstates_dynamic(microstates)
Process skin conductance signals for autonomic nervous system assessment. See references/eda.md for detailed workflows.
Primary workflows:
Key functions:
# Complete EDA processing
signals, info = nk.eda_process(eda_signal, sampling_rate=100)
# Analyze EDA data
analysis = nk.eda_analyze(signals, sampling_rate=100)
# Sympathetic nervous system activity
sympathetic = nk.eda_sympathetic(signals, sampling_rate=100)
Analyze breathing patterns and respiratory variability. See references/rsp.md for detailed workflows.
Primary capabilities:
Key functions:
# Complete RSP processing
signals, info = nk.rsp_process(rsp_signal, sampling_rate=100)
# Respiratory rate variability
rrv = nk.rsp_rrv(signals, sampling_rate=100)
# Respiratory volume per time
rvt = nk.rsp_rvt(signals, sampling_rate=100)
Process muscle activity signals for activation detection and amplitude analysis. See references/emg.md for workflows.
Key functions:
# Complete EMG processing
signals, info = nk.emg_process(emg_signal, sampling_rate=1000)
# Muscle activation detection
activation = nk.emg_activation(signals, sampling_rate=1000, method='threshold')
Analyze eye movement and blink patterns. See references/eog.md for workflows.
Key functions:
# Complete EOG processing
signals, info = nk.eog_process(eog_signal, sampling_rate=500)
# Extract blink features
features = nk.eog_features(signals, sampling_rate=500)
Apply filtering, decomposition, and transformation operations to any signal. See references/signal_processing.md for comprehensive utilities.
Key operations:
Key functions:
# Filtering
filtered = nk.signal_filter(signal, sampling_rate=1000, lowcut=0.5, highcut=40)
# Peak detection
peaks = nk.signal_findpeaks(signal)
# Power spectral density
psd = nk.signal_psd(signal, sampling_rate=1000)
Compute nonlinear dynamics, fractal dimensions, and information-theoretic measures. See references/complexity.md for all available metrics.
Available measures:
Key functions:
# Multiple complexity metrics at once
complexity_indices = nk.complexity(signal, sampling_rate=1000)
# Specific measures
apen = nk.entropy_approximate(signal)
dfa = nk.fractal_dfa(signal)
lyap = nk.complexity_lyapunov(signal, sampling_rate=1000)
Create epochs around stimulus events and analyze physiological responses. See references/epochs_events.md for workflows.
Primary capabilities:
Key functions:
# Find events in signal
events = nk.events_find(trigger_signal, threshold=0.5)
# Create epochs around events
epochs = nk.epochs_create(signals, events, sampling_rate=1000,
epochs_start=-0.5, epochs_end=2.0)
# Average across epochs
grand_average = nk.epochs_average(epochs)
Process multiple physiological signals simultaneously with unified output. See references/bio_module.md for integration workflows.
Key functions:
# Process multiple signals at once
bio_signals, bio_info = nk.bio_process(
ecg=ecg_signal,
rsp=rsp_signal,
eda=eda_signal,
emg=emg_signal,
sampling_rate=1000
)
# Analyze all processed signals
bio_analysis = nk.bio_analyze(bio_signals, sampling_rate=1000)
NeuroKit2 automatically selects between two analysis modes based on data duration:
Event-related analysis (< 10 seconds):
Interval-related analysis (≥ 10 seconds):
Most *_analyze() functions automatically choose the appropriate mode.
uv pip install neurokit2
For development version:
uv pip install https://github.com/neuropsychology/NeuroKit/zipball/dev
import neurokit2 as nk
# Load example data
ecg = nk.ecg_simulate(duration=60, sampling_rate=1000)
# Process ECG
signals, info = nk.ecg_process(ecg, sampling_rate=1000)
# Analyze HRV
hrv = nk.hrv(info['ECG_R_Peaks'], sampling_rate=1000)
# Visualize
nk.ecg_plot(signals, info)
# Process multiple signals
bio_signals, bio_info = nk.bio_process(
ecg=ecg_signal,
rsp=rsp_signal,
eda=eda_signal,
sampling_rate=1000
)
# Analyze all signals
results = nk.bio_analyze(bio_signals, sampling_rate=1000)
# Find events
events = nk.events_find(trigger_channel, threshold=0.5)
# Create epochs
epochs = nk.epochs_create(processed_signals, events,
sampling_rate=1000,
epochs_start=-0.5, epochs_end=2.0)
# Event-related analysis for each signal type
ecg_epochs = nk.ecg_eventrelated(epochs)
eda_epochs = nk.eda_eventrelated(epochs)
This skill includes comprehensive reference documentation organized by signal type and analysis method:
Load specific reference files as needed using the Read tool to access detailed function documentation and parameters.
No reviews yet. Tell others what you thought.
No login needed. Share how it worked for you, ask a question, or note where it did not run.
No comments yet. Be the first to write one.
Support experimental validation of designed proteins through a cloud laboratory. Prepare and optimize sequences, submit tests for binding, expression, thermal stability, or enzyme activity, track experiment progress, and retrieve results through the API.
Analyze time series, observations ordered over time, using aeon in Python. Build classification, prediction, and clustering workflows, detect unusual patterns or changes, and compare methods through an interface compatible with scikit-learn.
Create original generative art with p5.js, using code to produce patterns and motion. Receive a written artistic concept and an interactive HTML viewer with adjustable parameters, reproducible random variations, seed navigation, and PNG downloads.
Retrieve stock prices, exchange rates, cryptocurrency prices, company financial statements, and economic indicators through the Alpha Vantage API. It also covers historical data, news sentiment, and technical indicators, which summarize price and trading patterns.
Design backend systems with clear boundaries between business rules, databases, and external services. Use Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to organize new applications, refactor existing code, and make core logic easier to test.
Helps process astronomical data in Python by converting coordinates, units, and time scales, working with FITS observation files, matching object catalogs, and calculating distances using cosmological models.