The catchaMouse16 feature set provides a useful set of features to summarize the dynamics of fMRI time-series data, with implementations for Python, MATLAB, and C.

Overview

• A specific subset of 16 features from the hctsa time-series feature library designed to distinguish changes in functional Magnetic Resonance Imaging (fMRI) time series taken from mice undergoing experimental manipulations of excitatory and inhibitory neural activity in their cortical circuits.

• It is a collection of features that are generated from a general pipeline (which can be accessed here) applied to mouse fMRI time-series data taken from mice. This represents a high-performing but minimally redundant data-driven subset of the full library of hctsa features, that best discriminate biologically relevant manipulations (using the DREADD technique) from non-invasive fMRI time series.

Reading more about catchaMouse16

Want to use the pipeline or the feature set? If you use catchaMouse16 in a scientific publication, please read and cite this open-access article:

For information on the full set of over 7000 features, see the following (open) publications:

• B.D. Fulcher and N.S. Jones. hctsa: A computational framework for automated time-series phenotyping using massive feature extraction. Cell Systems 5, 527 (2017).

• B.D. Fulcher, M.A. Little, N.S. Jones Highly comparative time-series analysis: the empirical structure of time series and their methods. J. Roy. Soc. Interface 10, 83 (2013).

The pipeline to reproduce to create the catchaMouse16 feature set is an adaptation of the general pipeline from C.H. Lubba, S.S. Sethi, P. Knaute, S.R. Schultz, B.D. Fulcher, N.S. Jones. catch22: CAnonical Time-series CHaracteristics. Data Mining and Knowledge Discovery (2019).

Installation

For C, MATLAB, and Python, the catchaMouse16 Github repository contains source code for building native binaries that can be called from these languages. You will need to download the source code, install gsl (unix only), then follow the instructions below to build the binaries for your language.

For Julia users, these binaries have been pre-built for all platforms. You can use them by installing the CatchaMouse16.jl package.

./run_feat <infile> <outfile>

python3 setup_P3.py build
python3 setup_P3.py install

python3 test_features.py

python2 setup.py build
python2 setup.py install

python2 test_features.py

import catchaMouse16
import numpy as np
ts_data = np.rand(100,1)
print(catchaMouse16.SC_FluctAnal_2_dfa_50_2_logi_r2_se2(ts_data))

ts_data = randn(100,1) % column vector
catchaMouse16_all(ts_data)

using Pkg
Pkg.add("CatchaMouse16")

using CatchaMouse16
X = randn(1000, 10) # an Array{Float64, 2} with 10 time series
f = catchaMouse16[:AC_nl_035](X) # a 1×10 Matrix{Float64} (for a single feature)
F = catchaMouse16(X) # a 16×10 FeatureMatrix{Float64} (for 16 features)

Feature Description

Note: All catchaMouse16 features are statistical properties of the z-scored time series - they aim to focus on the properties of the time-ordering of the data and are insensitive to the raw values in the time series.

The table belows follows the same cypher as in the pre-print with the hctsa name and an interpretable name referred to throughout the paper with corresponding descriptions.

📕 Original Paper

📙 B. Harris, L. Gollo, B.D. Fulcher. "Tracking the distance to criticality in systems with unknown noise", Physical Review X 14: 031021 (2024).

❓ What is RAD?

In the original paper, we use a data-driven approach to develop theory on how to infer the DTC in the variable-noise setting. This theory relies on two key time-series properties: i) the distribution of values; and ii) the scale of fast fluctuations. Combining these two properties, such as by curve-fitting the distribution and solving the Fokker--Planck equation, partials-out the noise strength to give a noise-robust estimate of the shape of the potential function (and hence the control parameter). RAD implements these key algorithmic steps in a simplified way, efficiently estimating the DTC from data using elementary time-series operations. In RAD, the two algorithmic elements are captured by standard deviations above and below the median value (measuring the distribution) and the standard deviation of lag-1 differences (measuring fast fluctuations). Our RAD feature is given by:

where is the input time series, is the lag-1 difference operator, is the standard deviation, and:

where is the median value of .

🏃 Running RAD in Matlab, Julia, and Python

Code for implementing RAD is available in Matlab, Julia, and Python is collected in this .

RAD is also available through existing toolboxes in both Matlab and Julia:

• Matlab: in hctsa (as of v1.08), as the CR_RAD()master function, and CR_RAD_1, CR_RAD_2, and CR_RAD_tau operations

• Julia: in the TimeseriesFeatures.jl package (StatsBase.jl extension), as the CR_RAD::Feature

⚠️ Usage Guide

RAD is best suited to univariate, regularly-sampled time-series data. The sampling period should be constant between time series, and if the time series are excessively smooth or over-sampled then the tau parameter should be set to a value greater than 1 (a suitable tau can often be inferred by inspecting the autocorrelation function of a time series).

RAD also includes an optional centering step (doAbs), which should be enabled if the time series do not represent radial values (e.g., enable doAbs if the distribution is approximately symmetric or 'two-sided').

Overview

Original Paper 📕

A feature-based information-theoretic approach for detecting interpretable, long-timescale pairwise interactions from time series.

• 📙

<⚠️Public code repository and usage details are currently under construction⚠️>

We are the (led by Ben Fulcher) and part of Complex Systems research in the School of Physics at the University of Sydney.

We are detectives interested in finding patterns in time-series measured from complex time-varying systems . As part of this process, we often develop algorithms and analysis techniques that could be useful to researchers or general analysts interested in applying them on their own data.

Our group has developed three main types of software:

• Software for implementing highly comparative time-series analysis, in which a large library of scientific methods are implemented and compared.

• Feature subsets are efficiently coded (and high-performing) subsets of time-series features derived from the full set of features in hctsa.

• New types of specific time-series analysis methods developed in the group.

Highly Comparative Toolkits

Software for implementing highly comparative time-series analysis, in which a large library of scientific methods are implemented and compared.

Feature Subsets

Efficiently coded (and high-performing) subsets of time-series features derived from the full set of features in hctsa.

Time-Series Analysis Methods

Time-series analysis methods developed we've developed.

For full documentation for using catch22 across multiple programming languages, click the link below!:

Original Paper 📕

Feature-Based Time-Series Analysis in R using the theft Package.

• 📙 arXiv preprint (2022).

theft is a software package for R that facilitates user-friendly access to a consistent interface for the extraction of time-series features. The package provides a single point of access to >1200 time-series features from a range of existing R and Python packages.

Overview

Link to substantial documentation