OSCR

From surface to depth: Using deep learning to predict striatal fMRI reward signaling from EEG.

Code ↔ Paper

4 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 4 matches
  1. [1] § Methods › Deep learning model › Model training ↔ code/main_train.py, lines 205–268 · score 0.92 · cosine annealing learning, AdamW, CosineAnnealingLR, T_max, weight decay, scheduler
  2. [2] § Methods › Deep learning model › Model architecture ↔ code/utils/model_arch/autoencoder_new_ArturNH.py, lines 4–60 · score 0.70 · ReLU, spatial filtering, stride, kernel, Autoencoder, layer
  3. [3] § Methods › Deep learning model › Model training ↔ code/utils/train_utils.py, lines 163–302 · score 0.65 · training loss, scheduler, optimizer, cosine, PyTorch, epochs
  4. [4] § Methods › Data preprocessing ↔ code/utils/model_arch/autoencoder_new_ArturNH.py, lines 4–60 · score 0.54 · ReLU, spatial filtering, layer, block, temporal, channel

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 244 lines · 6.9 KB · no license · 2 matches

  1. import torch
  2. import torch.nn as nn
  4. class ArturBlock(nn.Module):
  5. """
  6. Input is [batch, emb, time]
  7. Artur block. Interpretable and lightweight.
  10. """
  11. FILTERING_SIZE = 51
  12. ENVELOPE_SIZE = 51
  13. # HIDDEN_CHANNELS = 5
  15. def __init__(self, in_channels, hidden_channels=5):
  16. super(ArturBlock, self).__init__()
  17. self.HIDDEN_CHANNELS = hidden_channels
  19. self.unmixing_layer = nn.Conv1d(in_channels, self.HIDDEN_CHANNELS, 1)
  20. self.unmixed_channels_batchnorm = torch.nn.BatchNorm1d(self.HIDDEN_CHANNELS, affine=True)
  22. # use it instead stride.
  23. self.band_pass = nn.Conv1d(
  24. self.HIDDEN_CHANNELS,
  25. self.HIDDEN_CHANNELS,
  26. kernel_size=self.FILTERING_SIZE,
  27. bias=False,
  28. groups=self.HIDDEN_CHANNELS,
  29. padding="same")
  31. self.norm = nn.BatchNorm1d(self.HIDDEN_CHANNELS, affine=False)
  32. self.act = nn.ReLU()
  33. self.low_pass = nn.Conv1d(
  34. self.HIDDEN_CHANNELS,
  35. self.HIDDEN_CHANNELS,
  36. kernel_size=self.ENVELOPE_SIZE,
  37. groups=self.HIDDEN_CHANNELS,
  38. padding="same")
  41. def forward(self, x):
  42. """
  43. - Spatial filter
  44. - Temporal filter
  45. 1. Learn band pass flter
  46. 2. Centering signals
  47. 3. Abs
  48. 4. low pass to get envelope
  49. """
  50. # Spatial filter
  51. x = self.unmixing_layer(x)
  52. x = self.unmixed_channels_batchnorm(x)
  54. # Temporal filter
  55. x = self.band_pass(x)
  56. x = self.norm(x)
  57. x = self.act(x)
  58. x = self.low_pass(x)
  60. return x
  63. class ConvBlock(nn.Module):
  64. """
  65. Input is [batch, emb, time]
  66. simple conv block from wav2vec 2.0
  67. - conv
  68. - layer norm by embedding axis
  69. - activation
  70. To do:
  71. add res blocks.
  72. """
  74. def __init__(
  75. self,
  76. in_channels,
  77. out_channels,
  78. kernel_size,
  79. stride=1,
  80. dilation=1,
  81. p_conv_drop=0.3):
  83. super(ConvBlock, self).__init__()
  85. # use it instead stride.
  86. self.conv1d = nn.Conv1d(
  87. in_channels,
  88. out_channels,
  89. kernel_size=kernel_size,
  90. bias=False,
  91. padding="same")
  93. self.norm = nn.LayerNorm(out_channels)
  94. self.activation = nn.GELU()
  95. self.drop = nn.Dropout(p=p_conv_drop)
  96. self.downsample = nn.MaxPool1d(kernel_size=stride, stride=stride)
  99. def forward(self, x):
  100. """
  101. - conv
  102. - norm
  103. - activation
  104. - downsample
  106. """
  108. x = self.conv1d(x)
  110. # norm by last axis.
  111. x = torch.transpose(x, -2, -1)
  112. x = self.norm(x)
  113. x = torch.transpose(x, -2, -1)
  115. x = self.activation(x)
  116. x = self.drop(x)
  117. x = self.downsample(x)
  119. return x
  122. class UpConvBlock(nn.Module):
  123. def __init__(self, scale, **args):
  124. super(UpConvBlock, self).__init__()
  125. self.conv_block = ConvBlock(**args)
  126. self.upsample = nn.Upsample(scale_factor=scale, mode="linear", align_corners=False)
  128. def forward(self, x):
  129. x = self.conv_block(x)
  130. x = self.upsample(x)
  132. return x
  137. class AutoEncoder1D_Artur(nn.Module):
  138. """
  139. This is implementation of AutoEncoder1D model for time serias regression
  141. decoder_reduce -size of reducing parameter on decoder stage. We do not want use a lot of features here.
  142. """
  144. def __init__(
  145. self,
  146. n_electrodes=30,
  147. n_freqs=16,
  148. n_channels_out=21,
  149. channels=[8, 16, 32, 32],
  150. kernel_sizes=[3, 3, 3],
  151. strides=[4, 4, 4],
  152. dilation=[1, 1, 1],
  153. decoder_reduce=1,
  154. hidden_channels=5,
  155. dropout_rate=0.3):
  157. super(AutoEncoder1D_Artur, self).__init__()
  159. self.n_electrodes = n_electrodes
  160. self.n_freqs = n_freqs
  161. self.n_inp_features = n_freqs*n_electrodes
  162. self.n_channels_out = n_channels_out
  164. self.model_depth = len(channels)-1
  166. self.artur_block = ArturBlock(
  167. in_channels=self.n_electrodes, hidden_channels=hidden_channels)
  168. self.spatial_reduce = ConvBlock(
  169. self.artur_block.HIDDEN_CHANNELS, channels[0], kernel_size=3, p_conv_drop=dropout_rate)
  171. # create downsample blcoks in Sequentional manner.
  172. self.downsample_blocks = nn.ModuleList([ConvBlock(channels[i],
  173. channels[i + 1],
  174. kernel_sizes[i],
  175. stride=strides[i],
  176. dilation=dilation[i],
  177. p_conv_drop=dropout_rate) for i in range(self.model_depth)])
  179. # make the same but in another side w/o last conv.
  180. channels = [ch // decoder_reduce for ch in channels[:-1]] + channels[-1:]
  181. # channels
  182. self.upsample_blocks = nn.ModuleList([UpConvBlock(scale=strides[i],
  183. in_channels=channels[i + 1],
  184. out_channels=channels[i],
  185. kernel_size=kernel_sizes[i]) for i in range(self.model_depth - 1, -1, -1)])
  187. self.conv1x1_one = nn.Conv1d(channels[0], self.n_channels_out, kernel_size=1, padding="same")
  189. def forward(self, x):
  190. """
  191. """
  192. batch, elec, time = x.shape
  194. x = self.artur_block(x)
  195. x = self.spatial_reduce(x)
  197. # encode information
  198. for i in range(self.model_depth):
  199. x = self.downsample_blocks[i](x)
  201. for i in range(self.model_depth):
  202. x = self.upsample_blocks[i](x)
  204. x = self.conv1x1_one(x)
  206. return x
  209. class AutoEncoder1D_Artur_MultiHead(nn.Module):
  210. """
  211. This is implementation of AutoEncoder1D model for time serias regression
  213. decoder_reduce -size of reducing parameter on decoder stage. We do not want use a lot of features here.
  214. """
  216. def __init__(self, dict_setting):
  217. super(AutoEncoder1D_Artur_MultiHead, self).__init__()
  218. dict_setting_new = dict_setting.copy()
  219. self.n_channels_out = dict_setting_new["n_channels_out"]
  221. dict_setting_new.pop("n_channels_out")
  223. dropout_rate = dict_setting_new.pop("dropout_rate", 0.3) # Default to 0.3 if not set
  225. # print('HOW: ', dict_setting)
  226. self.models = nn.ModuleList(
  227. [
  228. AutoEncoder1D_Artur(n_channels_out=1, dropout_rate=dropout_rate, **dict_setting_new)
  229. for i in range(self.n_channels_out)
  230. ])
  231. # print('HUI', len(self.models))
  234. def forward(self, x):
  235. """
  236. """
  237. batch, elec, time = x.shape
  238. preds = [model(x) for model in self.models]
  239. preds = torch.cat(preds, dim=1)
  241. return preds

autoencoder_new_ArturNH.py at commit 22671dc, no license · at the source

Overview

Authors: Nadine Herzog1,2, Luka Vähäsarja1,3, Pia Reinfeld1,4,5, Nico Scherf6,7, Simon M. Hofmann1,6, Christina Andreou8, Arno Villringer1, Christoph Mulert2
ORCID iDs: Nadine Herzog, Luka Vähäsarja, Pia Reinfeld, Nico Scherf, Simon M. Hofmann, Christina Andreou, Arno Villringer, Christoph Mulert
  1. Department of Neurology, Max Planck Institute for Human Cognitive & Brain Sciences, Leipzig, Germany
  2. Center for Psychiatry, Justus Liebig University, Giessen, Germany
  3. Department of Medicine, University of Helsinki, Helsinki, Finland
  4. University of Applied Sciences Jena, Jena, Germany
  5. IMPRS CoNI, Max Planck Research School on Cognitive NeuroImaging, Leipzig, Germany
  6. Neural Data Science and Statistical Computing Group, Max Planck Institute for Human Cognitive and Brain Sciences, Leipzig, Germany
  7. Center for Scalable Data Analytics and Artificial Intelligence (ScaDS.AI), Dresden/Leipzig, Germany
  8. Translational Psychiatry Unit, Department of Psychiatry and Psychotherapy, University Hospital Schleswig-Holstein, Lübeck, Germany
Institutions: Justus-Liebig-Universität Gießen (Germany); Max Planck Institute for Human Cognitive and Brain Sciences (Germany); University of Helsinki (Finland); Ernst Abbe University of Applied Sciences Jena (Germany); Center for Scalable Data Analytics and Artificial Intelligence (Germany); University Hospital Schleswig-Holstein (Germany)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1160
Dates: received 16 July 2025; accepted 8 February 2026; published online 9 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1160 · PMID 41816006 · PMCID PMC12973074 · OpenAlex W7129453308
Open access: diamond, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), fMRI (modality), human (organism), cognitive (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, fMRI & imaging, Evoked potentials
Keywords: EEG–fMRI, deep learning, reward processing, ventral striatum, neurofeedback
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) (project number 222641018 — SFB/TRR 135); LOEWE program of the Hessian Ministry of Science and Arts (LOEWE1/16/519/03/09.001[0009]/98); Max Planck Society; BMBF (Federal Ministry of Education and Research) through the Center for Scalable Data Analytics and Artificial Intelligence (ScaDS.AI); European Union and the Free State of Saxony through BIOWIN; BMBF (Federal Ministry of Education and Research) through ACONITE (01IS22065)
Citations: not cited yet (Europe PMC); 69 references in the paper

Abstract

Reward processing is critical for motivation, learning, and decision making. It involves a network centered on the fronto-striatal circuit, with the ventral striatum (VS) playing a pivotal role. While functional magnetic resonance imaging (fMRI) has been instrumental in mapping subcortical VS reward signals, its cost and limited accessibility hinder broader clinical applications. In this study, we adapted a convolutional autoencoder deep learning (DL) model to reconstruct VS blood-oxygen-level-dependent (BOLD) activity from task-based electroencephalography (EEG) data, both recorded during a two-choice gambling task known to elicit reward-related activation in the VS. The model was trained on consecutive EEG–fMRI data from 19 healthy participants, allowing it to identify patterns that generalize across individuals. Results show that the DL model significantly outperforms linear baseline models in predicting VS activity: across leave-one-out folds, the mean correlation between the DL-derived and the ground truth VS BOLD signal was r¯=0.323, compared with r¯=0.213 for the linear model. Further validation confirmed that the DL-derived signal is anatomically specific to the VS and other reward-related areas, and that it is modulated by reward conditions, indicating its functional validity. EEG feature analyses revealed theta to beta frequency band involvement, particularly in right centroparietal and temporal, as well as frontal electrodes. Although the model’s generalization performance was modest, these findings demonstrate the feasibility of decoding subcortical reward-related signals from surface EEG using interpretable deep learning models. This work contributes to the foundation for EEG-based neurofeedback systems aimed at modulating subcortical reward circuits, with potential clinical applications for disorders characterized by impairments in these circuits. Future improvements in model generalization may be achieved by training on larger and more diverse datasets.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 4 matches between paragraphs and lines of code.

naherzog/DLEEGfMRI

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 22671dc7494b23ec546c6bb2ee515ccbd663af66, 12 December 2025
Languages: Python (6)
Size: 13 files, 6 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (5 files), PyTorch (5 files), pandas (3 files), Matplotlib (2 files), MNE-Python (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
7 files
At the source: github.com/naherzog/DLEEGfMRI

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 6 scripts, each with its path and the digest of its content;
  • 4 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data and Code Availability

The pre-processed data, the codes used to train and evaluate the model, and the final weights are available here: https://github.com/naherzog/DLEEGfMRI. Requests for raw EEG or fMRI data will be evaluated individually and must comply with local regulations and the requirements of German authorities.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 8 authors, 5 keywords, 6 funders, 67 references.

Cite

This paper

Herzog, N., Vähäsarja, L., Reinfeld, P., Scherf, N., Hofmann, S. M., Andreou, C., Villringer, A., & Mulert, C. (2026). From surface to depth: Using deep learning to predict striatal fMRI reward signaling from EEG. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1160. https://doi.org/10.1162/imag.a.1160

BibTeX

@article{herzog2026surface,
author = {Herzog, Nadine and Vähäsarja, Luka and Reinfeld, Pia and Scherf, Nico and Hofmann, Simon M. and Andreou, Christina and Villringer, Arno and Mulert, Christoph},
title = {{From surface to depth: Using deep learning to predict striatal fMRI reward signaling from EEG}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = mar,
volume = {4},
pages = {IMAG.a.1160},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1160},
url = {https://doi.org/10.1162/imag.a.1160},
pmid = {41816006},
pmcid = {PMC12973074}
}

RIS

TY - JOUR
AU - Herzog, Nadine
AU - Vähäsarja, Luka
AU - Reinfeld, Pia
AU - Scherf, Nico
AU - Hofmann, Simon M.
AU - Andreou, Christina
AU - Villringer, Arno
AU - Mulert, Christoph
TI - From surface to depth: Using deep learning to predict striatal fMRI reward signaling from EEG
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/03/09
VL - 4
SP - IMAG.a.1160
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1160
UR - https://doi.org/10.1162/imag.a.1160
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1160",
"type": "article-journal",
"title": "From surface to depth: Using deep learning to predict striatal fMRI reward signaling from EEG",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Herzog",
"given": "Nadine"
},
{
"family": "Vähäsarja",
"given": "Luka"
},
{
"family": "Reinfeld",
"given": "Pia"
},
{
"family": "Scherf",
"given": "Nico"
},
{
"family": "Hofmann",
"given": "Simon M."
},
{
"family": "Andreou",
"given": "Christina"
},
{
"family": "Villringer",
"given": "Arno"
},
{
"family": "Mulert",
"given": "Christoph"
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1160",
"DOI": "10.1162/imag.a.1160",
"PMID": "41816006",
"PMCID": "PMC12973074",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1160",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
9
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1162/imag.a.105 [code]
Right posterior theta reflects human parahippocampal phase resetting by salient cues during goal-directed navigation
Journal: n/a
In common: MNE-Python, pandas, Matplotlib, 1 other tool, fMRI, EEG, cognitive, 2 references
[2] doi:10.1002/hbm.70562 [code]
Distinct Physiological Mechanisms Drive Grey Matter Plasticity in Complex Versus Simple Sequence Learning.
Journal: Human brain mapping
In common: pandas, Matplotlib, NumPy, author A. Villringer
[3] doi:10.1371/journal.pone.0351872 [code]
Decoding visual object recognition from EEG signals.
Journal: PloS one
In common: MNE-Python, PyTorch, pandas, 2 other tools, EEG, 1 reference
[4] doi:10.7554/elife.100056 [code]
Multi-talker speech comprehension at different temporal scales in listeners with normal and impaired hearing.
Journal: eLife
In common: MNE-Python, PyTorch, pandas, 1 other tool, EEG, cognitive, 1 reference
[5] doi:10.1162/imag.a.1174 [code]
Retinal nerve fibre layer thickness reflects characteristics of brain grey and white matter.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Matplotlib, NumPy, author A. Villringer
[6] doi:10.1016/j.neuroimage.2026.122051 [code]
Determining hemispheric language dominance from MEG beta-power modulations: Concordance with fMRI.
Journal: NeuroImage
In common: MNE-Python, pandas, Matplotlib, 1 other tool, fMRI, cognitive, 1 reference
[7] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-Python, PyTorch, pandas, 2 other tools, fMRI, EEG
[8] doi:10.1162/imag.a.1169 [code]
Diazepam alters the shape of alpha oscillations recorded from human cortex using EEG.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, pandas, Matplotlib, 1 other tool, EEG, 1 reference
[9] doi:10.1162/imag.a.1207 [code]
Investigating the temporal dynamics and modeling of mid-level feature representations in humans.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, PyTorch, pandas, 2 other tools, EEG, cognitive
[10] doi:10.1002/hbm.70528 [code]
Explainable AI Insights Into EEG Classification and Its Alignment to Neural Correlates.
Journal: Human brain mapping
In common: MNE-Python, PyTorch, pandas, 2 other tools, EEG, cognitive

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.