Estimation of single-trial activity

[abelowska]

Hi all,

I am wondering if it is possible to estimate single-trial ERPs after correction, specifically to disentangle stimuli-related and response-related brain activity.

Here is my model specification (I am calling Julia from Python):

# Specify model formula
jl.seval("bf_stimuli = firbasis(τ = (-0.3, 0.5), sfreq = 1024)")
jl.seval("bf_response = firbasis(τ = (-0.3, 0.5), sfreq = 1024)")

jl.seval("f = @formula 0 ~ 1")
bfDict = jl.seval("[ \"stimuli\" => (f, bf_stimuli), \"response\" => (f, bf_response) ]")

type_column = jl.seval("Vector{String}")(events_df['type'].tolist())
latency_column = jl.seval("Vector{Int64}")(events_df['latency'].tolist())

# Create the Julia DataFrame
events_df_jl = jl.DataFrame(type=type_column, latency=latency_column)

# Fit Unfold model
m = Unfold.fit(
    Unfold.UnfoldModel,
    bfDict,
    events_df_jl,
    data,
    eventcolumn = "type",
)

Where data is the continuous EEG signal with a shape of (1, 935936), sampled at 1024 Hz. Using Unfold.coeftable(m), I can extract rERPs for each type of event.

My question is: is there any way to use the estimated coefficients/rERPs to disentangle stimuli-related single-trial ERPs and response-related single-trial ERPs? When calling predicted_data = Unfold.predict(m, overlap=False), I get single-trials, but all have exactly the same values. I suppose this makes sense because I only estimate the intercepts for the effects.

Do you have any recommendations on how to obtain these corrected single-trial ERPs?

Thank you!

[behinger]

Hi there,
to confirm I understood what you need: Single trials, without the (modelled) overlap of neighbouring events?

If yes, you are in luck, this is implemented

Cheerio, Bene

[abelowska]

Exactly :)

[behinger]

Great!

I recommend the internal function "singletrial" from UnfoldDecode.jl

get overlap free single trails

X_train = singletrials(data, uf_model, events, "response", "type" )

Just in case you want to do decoding on overlap corrected trials, that package would already implement one algorithm to do so. One issue: it is not yet registered, you have to install it via Pkg.add(url="https://github.com/unfoldtoolbox/UnfoldDecode.jl"). Unfold decode is unfortunately not yet as polished as unfold, but what you want to do is also not the standard case so that is fine I guess :-)

If you want to put the pieces together yourself, you can use predict with keep/remove basis to exclude/keep certain eventtypes. If you provide to which events to epoch the data at the same time, it will even do it in a memory efficient way. Here is the docs for that (not yet a tutorial, didn't have time yet)

Unfold.jl/src/predict.jl

Lines 160 to 191 in ce2b36f

	"""
	function predict(
	uf,
	f::Vector{<:FormulaTerm},
	evts::Vector{<:DataFrame};
	overlap = true,
	kwargs...
	)
	Returns a predicted ("y_hat = X*b") `Array`.
	- `uf` is an `<:UnfoldModel`
	- `f` is a (vector of) formulas, typically `Unfold.formulas(uf)`, but formulas can be modified e.g. by `effects`.
	- `evts` is a (vector of) events, can be `Unfold.events(uf)` to return the (possibly continuous-time) predictions of the model. Can be a custom even
	## kwargs:
	if `overlap = true` (default), overlap based on the `latency` column of 'evts` will be simulated, or in the case of `!ContinuousTimeTrait` just X*coef is returned.
	if `overlap = false`, returns predictions without overlap (models with `ContinuousTimeTrait` (=> with basisfunction / deconvolution) only), via `predict_no_overlap`
	if `keep_basis` or `exclude_basis` is defined, then `predict_partial_overlap` is called, which allows to selective introduce overlap based on specified (or excluded respective) events/basisfunctions
	`epoch_to` and `epoch_timewindow` currently only defined for partial_overlap, calculated (partial) overlap controlled predictions, but returns them at the specified `epoch_at` event, with the times `epoch_timewindow` in samples.
	`eventcolumn` can be specified as well if different from the default `event`
	Hint: all vectors can be "single" types, and will be containered in a vector
	## Output
	- If `overlap=false`, returns a 3D-Array
	- If `overlap=true` and `epoch_to=nothing` (default), returns a 2D-array
	- If `overlap=true` and `epoch_to!=nothing`, returns a 3D array
	"""

Ok, long answer, maybe something helpful for you. If you can say more on your use case I might be able to put out a short tutorial for that.