skjerns / tdlm-python

Python code for running TDLM (temporally delayed linear modelling)

You can reach me also here:

ORC-iD	0000-0002-9050-9040
ResearchGate	Simon Kern
Twitter	@skjerns
Website	skjerns.de

tdlm-python's Issues

Add time window approach

In Toby Wise's paper a windowed TDLM approach is presented.

Task:

• Implement windowed approach
• should take arguments win_size
• should take argument aggr_func which is a function that post-processes the output of for each window, e.g. taking the mean differential replay

possible skeleton

def mean_diff(seq_fwd, seq_bkw):
    # calculate the mean differential sequenceness
    mean_diff = np.mean(seq_fwd-seq_bkw)
    return mean_diff 

def compute_windowed(preds, tf, win_size, aggr_func= seq_type='glm/crosscorr', ...):
    # ...
    win_values = []
    for win in windows:
        seq_fwd_win, seq_bkw_win = compute_glm(preds_win)
        aggregated = aggr_func(seq_fwd_win, seq_bkw_win)
        win_values += [aggregated]
    # ....
    # possibly convert win_values into np.ndarray if possible?
    return win_values 

Replace plot_sequenceness

Currently we're still using plot_sequenceness as a port from the MATLAB code.

TDLM-Python/tdlm/plotting.py

Line 11 in 660d7b2

def plot_sequenceness(seq_fwd, seq_bkw, cTime=None, ax=None, title=None,

It would be better to have a pythonic version, e.g. using seaborn.

Add n-step computation

Add feature to compute n-step TDLM/cross-correlation.

this is slightly more complicated to implement, haven't thought through yet what's the best option. Feel free to add ideas.

Task:

• should either take a transition matrix that will automatically be advanced
• alternatively: a list of transition matrices for each step

possible skeleton

def compute_glm_nstep(preds, tf, n_steps=x...)
    preds_step = preds.copy()
    for step in range(n_steps):
        tf_step = get_next_step_tf(tf)
        fwd, bkw = compute_glm(preds_step , tf, ...)
        # ...

Problems:

• Do we map AB->C or A->BC ? Or both and take mean? Does it even make a difference?
• How do we perform the permutations accurately per step?
• How to implement alpha frequency correction?

Add EEG simulation

Two functions should be added for simulation purposes:

simulate_eeg_resting_state to create fake M/EEG data and simulate_eeg_localizer to create localizer data

Potentially either yunzhes code can be translated to python or alternatively there are packages to simulate EEG that could be called here.

Replace unique_perms

Currently we're still using unique_permutations which is a port from MATLAB

TDLM-Python/tdlm/utils.py

Line 13 in 660d7b2

def unique_permutations(X, k=None):

It would be better to have a more performant and pythonic implementation.

Also add more functions based on the suggestions in the TDLM methods paper (e.g. exclude real transitions from the shuffles)

Setup CI and tests

A CI should be setup using GitHub actions and more tests need to be written.

TF per trial

Currently only on transition matrix can be supplied for all trials. There should be a helper function that takes several prediction trials (3d matrix) and a list of TFs (and TBs) with expected transitions for each trial