Integrating metacognitive mechanisms optimizes EEG generative models via hierarchical regularization.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 530 lines · 20 KB · no license

from __future__ import print_function, division
import tensorflow as tf
tf.compat.v1.enable_eager_execution()
from keras.layers import Input, Dense, Reshape, Flatten, Dropout
from keras.layers import BatchNormalization, Activation, ZeroPadding2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import UpSampling2D, Conv2D
from keras.models import Sequential, Model
from keras.optimizers import Adam
from keras import regularizers
import keras.backend as K
import matplotlib.pyplot as plt
import scipy.io as sio
import sys
import os
import numpy as np
from keras.optimizers import RMSprop, Adam
from scipy.io import savemat
from tensorflow import keras
from keras import regularizers
from tensorflow.keras.layers import Input, Conv1D, Flatten, Dense, Conv2DTranspose, Reshape, Lambda, LeakyReLU, ReLU, \
Embedding, Concatenate, BatchNormalization
from tensorflow.keras.layers import Input, Conv1D, Flatten, Dense, Conv2DTranspose, Reshape, Lambda, LeakyReLU, ReLU, \
Embedding, Concatenate, BatchNormalization
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
# from tensorflow import pad, maximum, random, int3
from scipy.fftpack import fft, fftshift, ifft
from scipy.fftpack import fftfreq
from sklearn import preprocessing
from tensorflow_core import maximum
from tensorflow_core.python import pad
from tensorflow_core.python.kernel_tests import random
from torch import nn
import torch
from torch import nn
Tensor = torch.FloatTensor
from torch.autograd import Variable
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from scipy.stats import wasserstein_distance
import numpy.linalg as LA
from scipy.stats import wasserstein_distance
import math
from tensorflow import int32
mm = MinMaxScaler()
criterion_freq = nn.BCELoss()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
PATH = '生成代码\wavegan\\231\data2_231f.mat'
data = sio.loadmat(PATH)
train_data = data['eeg']
#train_data = train_data.swapaxes(1, 2)
train_data = train_data[:, :, :]
all_data = np.zeros((2946, 231, 32))
train_data = np.array(train_data)
print(train_data.shape)
for i in range(32):
train_data1 = train_data[:, :, i:i + 1]
newdata = np.squeeze(train_data1, axis=2)
newdata = preprocessing.MaxAbsScaler().fit_transform(newdata)
newdata = np.expand_dims(newdata, axis=2)
print(newdata.shape)
newdata = np.array(newdata)
all_data[:, :, i:i + 1] = newdata
print(all_data.shape)
x = all_data
X = []
F7 = x[:,:,3:4]
F4 = x[:,:,5:6]
FC1= x[:,:,8:9]
#C3 = x[:,:,12:13]
P3 = x[:,:,21:22]
Pz = x[:,:,22:23]
P4 = x[:,:,23:24]
#X = X + [F7, F4, P3, Pz, P4]
X = X + [FC1]
x = np.array(X)
x = x.swapaxes(0, 3)
x = np.squeeze(x, axis=0)
X_train = x.reshape(2946, 231, 1)
x = X_train
print(x.shape)
def gradient_penalty(self, batch_size, real_images, fake_images):
""" Calculates the gradient penalty.
This loss is calculated on an interpolated image
and added to the discriminator loss.
"""
# get the interplated image
alpha = tf.random.normal([batch_size, 1, 1], 0.0, 1.0)
diff = fake_images - real_images
interpolated = real_images + alpha * diff
with tf.GradientTape() as gp_tape:
gp_tape.watch(interpolated)
# 1. Get the discriminator output for this interpolated image.
pred = self.discriminator(interpolated, training=True)
# 2. Calculate the gradients w.r.t to this interpolated image.
grads = gp_tape.gradient(pred, [interpolated])[0]
# 3. Calcuate the norm of the gradients
norm = tf.sqrt(tf.reduce_sum(tf.square(grads), axis=[1, 2]))
gp = tf.reduce_mean((norm - 1.0) ** 2)
return gp
def apply_phaseshuffle(args):
x, rad = args
pad_type = 'reflect'
b, x_len, nch = x.get_shape().as_list()
phase = random.uniform([], minval=-rad, maxval=rad + 1, dtype=int32)
pad_l = maximum(phase, 0)
pad_r = maximum(-phase, 0)
phase_start = pad_r
x = pad(x, [[0, 0], [pad_l, pad_r], [0, 0]], mode=pad_type)
x = x[:, phase_start:phase_start + x_len]
x.set_shape([b, x_len, nch])
return x
def Conv1DTranspose(input_tensor, filters, kernel_size, strides=2, padding='same'
, name='1DTConv', activation='relu'):
x = Conv2DTranspose(filters=filters, kernel_size=(1, kernel_size), strides=(1, strides), padding=padding,
name=name, activation=activation)(K.expand_dims(input_tensor, axis=1))
x = K.squeeze(x, axis=1)
return x
def clip_layer(**kwargs):
def layer_c(x):
return tf.image.resize_with_crop_or_pad(x, 1, 231)
return Lambda(layer_c, **kwargs)
class GAN():
def __init__(self, ):
super(GAN, self).__init__()
self.eeg_rows = 231
self.eeg_cols = 1
self.eeg_shape = (self.eeg_rows, self.eeg_cols)
self.latent_dim = 231
self.z_dim = 231
self.batch_size = 128
self.gp_weight = 4.0
self.ap = 0.1
# d_optimizer = keras.optimizers.Adam(learning_rate=0.0004)
# g_optimizer = keras.optimizers.Adam(learning_rate=0.0004)
d_optimizer = keras.optimizers.Adam(learning_rate=0.0004)
g_optimizer = keras.optimizers.Adam(learning_rate=0.0004)
# Build and compile the discriminator self.discriminator = self.build_discriminator(is_training=True)
use_batch_norm = False
self.phaseshuffle_samples = 0
self.generator = self.generator(self.latent_dim, use_batch_norm=use_batch_norm)
self.discriminator = self.discriminator(self.phaseshuffle_samples)
self.d_optimizer = d_optimizer
self.g_optimizer = g_optimizer
self.d_loss_fn = self.discriminator_loss
self.g_loss_fn = self.generator_loss
self.d_steps = 5
'''
self.discriminator.compile(loss='binary_crossentropy',
optimizer=tf.keras.optimizers.Adam(learning_rate=0.0004),
metrics=['accuracy'])
'''
def discriminator_loss(self, real_img, fake_img):
real_loss = tf.reduce_mean(real_img)
fake_loss = tf.reduce_mean(fake_img)
return fake_loss - real_loss
# Define the loss functions to be used for generator
def generator_loss(self, fake_img):
return -tf.reduce_mean(fake_img)
def gradient_penalty(self, batch_size, real_images, fake_images):
""" Calculates the gradient penalty.
This loss is calculated on an interpolated image
and added to the discriminator loss.
"""
# get the interplated image
alpha = tf.random.normal([batch_size, 1, 1], 0.0, 1.0)
diff = fake_images - real_images
interpolated = real_images + alpha * diff
with tf.GradientTape() as gp_tape:
gp_tape.watch(interpolated)
# 1. Get the discriminator output for this interpolated image.
pred = self.discriminator(interpolated, training=True)
# 2. Calculate the gradients w.r.t to this interpolated image.
grads = gp_tape.gradient(pred, [interpolated])[0]
# 3. Calcuate the norm of the gradients
norm = tf.sqrt(tf.reduce_sum(tf.square(grads), axis=[1, 2]))
gp = tf.reduce_mean((norm - 1.0) ** 2)
return gp
def compute_kappa(self, xq, y):
C = []
for i in range(33):
t_a = tf.norm([xq[7 * i + 3] - xq[7 * i], y[7 * i + 3] - y[7 * i]])
t_b = tf.norm([xq[7 * i + 6] - xq[7 * i + 3], y[7 * i + 6] - y[7 * i + 3]])
P = tf.convert_to_tensor([xq[7 * i], xq[7 * i + 3], xq[7 * i + 6]], dtype=tf.float32)
P = tf.reshape(P, [3, 1])
Q = tf.convert_to_tensor([y[7 * i], y[7 * i + 3], y[7 * i + 6]], dtype=tf.float32)
Q = tf.reshape(Q, [3, 1])
M = tf.convert_to_tensor([
[1, -t_a, t_a ** 2],
[1, 0, 0],
[1, t_b, t_b ** 2]
], dtype=tf.float32)
a = tf.matmul(tf.linalg.inv(M), P)
b = tf.matmul(tf.linalg.inv(M), Q)
kappa = 2 * (a[2] * b[1] - b[2] * a[1]) / tf.pow(a[1] ** 2. + b[1] ** 2., 1.5)
kappa = tf.abs(kappa)
C.append(kappa)
return tf.convert_to_tensor(C, dtype=tf.float32)
def calculate_loss_bc(self, Y, Y2):
# Compute frequency domain loss (e.g., mean squared error)
criterion_loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
loss = criterion_loss(Y, Y2)
return loss
def compute_fft(self, x, num_fft):
# Compute FFT and return the absolute value
fft_result = tf.abs(tf.signal.fft(tf.cast(x, tf.complex64)))
return fft_result
def ncosine_similarity(self, tensor1, tensor2, epsilon=1e-8):
# Normalize tensors
norm_tensor1 = tf.norm(tensor1, axis=-1, keepdims=True)
norm_tensor2 = tf.norm(tensor2, axis=-1, keepdims=True)
# Compute cosine similarity
similarity = tf.reduce_sum(tensor1 * tensor2, axis=-1) / (norm_tensor1 * norm_tensor2 + epsilon)
return similarity
def anti_collapse_regularizer(self, z1, z2, fake_feats_z1, fake_feats_z2):
# Compute cosine similarity
cos_fake_feats = self.ncosine_similarity(fake_feats_z1, fake_feats_z2)
cos_z = self.ncosine_similarity(z1, z2)
# Compute regularizer
an_regularizer = tf.reduce_mean((1 - cos_fake_feats) / (1 - cos_z))
return an_regularizer
def generator(self, z_dim,
use_batch_norm=False
):
generator_filters = [1024, 512, 256, 128, 64]
generator_input = Input(shape=(231,), name='generator_input')
x = generator_input
x = Dense(240, name='generator_input_dense')(x)
x = Reshape((12, 20), name='generator_input_reshape')(x)
# if use_batch_norm == True:
x = BatchNormalization()(x)
x = ReLU()(x)
# x = Concatenate()([x, label_em])
for i in range(4):
x = Conv1DTranspose(
input_tensor=x
, filters=generator_filters[i + 1]
, kernel_size=25
, strides=1
, padding='same'
, name=f'generator_Tconv_{i}'
, activation='relu'
)
# if use_batch_norm == True:
x = BatchNormalization()(x)
#
x = Conv1DTranspose(
input_tensor=x
, filters=1
, kernel_size=25
, strides=20
, padding='same'
, name='generator_Tconv_4'
, activation='tanh'
)
#
x = Dense(1, kernel_regularizer=regularizers.l2(0.01))(x)
# x = Dense(1, activity_regularizer=regularizers.l1(0.01))(x)
x = Reshape((1, 240, 1))(x)
# x=np.expand_dims(x,axis=2)
x = clip_layer()(x)
# x=np.squeeze(x,2)
x = Reshape((231, 1))(x)
generator_output = x
generator = Model([generator_input], generator_output, name='Generator')
model = Model(inputs=generator_input, outputs=generator_output)
model.summary()
return generator
def discriminator(self, phaseshuffle_samples):
discriminator_filters = [64, 128, 256, 512, 1024, 2048]
discriminator_input = Input(shape=(231, 1), name='discriminator_input')
x = discriminator_input
for i in range(4):
x = Conv1D(
filters=discriminator_filters[i]
, kernel_size=25
, strides=1
, padding='same'
, name=f'discriminator_conv_{i}'
)(x)
x = LeakyReLU(alpha=0.2)(x)
if phaseshuffle_samples > 0:
x = Lambda(apply_phaseshuffle)([x, phaseshuffle_samples])
# layer 4, no phase shuffle
x = Conv1D(
filters=discriminator_filters[4]
, kernel_size=25
, strides=20
, padding='same'
, name=f'discriminator_conv_4'
)(x)
x = Flatten()(x)
# x = Dense(1, kernel_regularizer=regularizers.l2(0.01),
# activity_regularizer=regularizers.l1(0.01))(x)
discriminator_output = Dense(1)(x)
discriminator = Model([discriminator_input], discriminator_output, name='Discriminator')
model = Model(inputs=discriminator_input, outputs=discriminator_output)
model.summary()
return discriminator
def train(self, epochs, batch_size=128, sample_interval=2, ap=0.1):
x_plot_loss_g = []
y_plot_loss_g = []
if not os.path.exists('hse-wavegan231-3R-1-FC1-2/'):
os.makedirs('hse-wavegan231-3R-1-FC1-2/')
for epoch in range(epochs):
idx = np.random.randint(0, x.shape[0], batch_size)
real_images = x[idx]
d_steps = 5
for i in range(d_steps):
random_latent_vectors = tf.random.normal( shape=(batch_size, self.latent_dim))
with tf.GradientTape() as tape:
fake_images = self.generator(random_latent_vectors, training=True)
fake_logits = self.discriminator(fake_images, training=True)
# Get the logits for real images
# real_logits = self.discriminator(real_images, training=True)
real_images_32 = tf.cast(real_images, dtype=tf.float32)
real_logits = self.discriminator(real_images_32, training=True)
# Calculate discriminator loss using fake and real logits
d_cost = self.d_loss_fn(real_img=real_logits, fake_img=fake_logits)
# Calculate the gradient penalty
# WS= wasserstein_distance(real_images, fake_images)
# d_cost1=np.abs(d_cost)
# log=math.log( d_cost1)
gp = self.gradient_penalty(batch_size, real_images, fake_images)
# Add the gradient penalty to the original discriminator loss
d_loss = d_cost + gp * self.gp_weight
# if np.abs(d_loss) > 0.5:
# self.d_steps = 6
# if np.abs(d_loss)<0.5:
# self.d_steps=5
# Get the gradients w.r.t the discriminator loss
d_gradient = tape.gradient(d_loss, self.discriminator.trainable_variables)
# Update the weights of the discriminator using the discriminator optimizer
self.d_optimizer.apply_gradients(
zip(d_gradient, self.discriminator.trainable_variables)
)
random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))
with tf.GradientTape() as tape:
# Generate fake images using the generator
generated_images = self.generator(random_latent_vectors, training=True)
# b = generated_images.numpy()
b=K.eval(generated_images)
sio.savemat('hse-wavegan231-3R-1-FC1-2/%d.mat' % (epoch), {'eeg': b})
# Get the discriminator logits for fake images
gen_img_logits = self.discriminator(generated_images, training=True)
# Calculate the generator loss
# 频谱
x1 = real_images[:, :, 0]
x2 = generated_images[:, :, 0]
Y = self.compute_fft(x1, num_fft=256)
# Y = tf.convert_to_tensor(Y)
Y2 = self.compute_fft(x2, num_fft=256)
# Y2 = tf.Variable(Y2)
SR = self.calculate_loss_bc(Y, Y2)
lambda_sr = 1e-6
# CR
generated_images1 = generated_images[:, :, 0]
generated_images1_np = K.eval(generated_images1)
table = np.array(generated_images1_np)
# generated_images1 = tf.squeeze(generated_images, axis=2)
# table = np.array(generated_images1)
y = np.array([np.sum(table[:, i]) / 128 for i in range(231)])
xq = np.arange(231)
C = self.compute_kappa(xq, y)
# C = tf.Variable(C, dtype=tf.float32, trainable=True)
# Preprocess real images
real_images1 = real_images[:, :, 0]
# real_images1 = tf.squeeze(real_images, axis=2)
table1 = np.array(real_images1)
y1 = np.array([np.sum(table1[:, i]) / 128 for i in range(231)])
xq1 = np.arange(231)
C1 = self.compute_kappa(xq1, y1)
CR = self.calculate_loss_bc(C, C1)
lambda_cr = 1e-5
# 反陷入
z1 = tf.random.normal(shape=(batch_size, self.latent_dim))
z2 = tf.random.normal(shape=(batch_size, self.latent_dim))
s1 = self.generator(z1, training=True)
s2 = self.generator(z2, training=True)
s1 = tf.squeeze(s1, axis=2)
s2 = tf.squeeze(s2, axis=2)
epsilon = 1e-10
norm_s1 = tf.maximum(tf.norm(s1, axis=1, keepdims=True), epsilon)
norm_s2 = tf.maximum(tf.norm(s2, axis=1, keepdims=True), epsilon)
s1 = s1 / norm_s1
s2 = s2 / norm_s2
# ql=np.abs(C1-C)
g_loss = self.g_loss_fn(gen_img_logits)
AR = self.anti_collapse_regularizer(z1, z2, s1, s2)
lambda_ar = 1e-3
# loss_freq = wasserstein_distance(Y.detach(), Y2.detach())
# loss_freq = loss_freq .numpy()
# print(loss_freq)
#########################################
a1 = 0.6
b1 = 1 - a1
# print(wd)
# g_loss = g_loss + 1 / anti_collapse_regularizer * lambda_freq2
# g_loss = g_loss + a*lambda_freq*loss_freq+b*(lambda_freq1*loss_freq3+(1 / anti_collapse_regularizer* lambda_freq2))
# g_loss = g_loss + a1*lambda_freq * loss_freq + b1*(1 / anti_collapse_regularizer)
g_loss = g_loss + a1 * (1 / AR * lambda_ar) + b1 * (
0.5 * lambda_sr * SR + 0.5 * lambda_cr * CR)
# Get the gradients w.r.t the generator loss
# g_loss = self.g_loss_fn(gen_img_logits)
gen_gradient = tape.gradient(g_loss, self.generator.trainable_variables)
# Update the weights of the generator using the generator optimizer
self.g_optimizer.apply_gradients(
zip(gen_gradient, self.generator.trainable_variables)
)
d_loss = d_loss.numpy()
g_loss = g_loss.numpy()
x_plot_loss_g.append(d_loss)
y_plot_loss_g.append(g_loss)
# sio.savemat('wavegan231-3R-sy/loss.mat', {'d_loss': x_plot_loss_g, 'g_loss': y_plot_loss_g})
print("epoch:%d [D loss: %f] [G loss: %f]" % (epoch, d_loss, g_loss))
sio.savemat('hse-wavegan231-3R-1-FC1-2/loss.mat', {'d_loss': x_plot_loss_g, 'g_loss': y_plot_loss_g})
# print(errors[-1])
'''
if epoch < 4000:
x_plot_loss_g.append(epoch)
y_plot_loss_g.append(g_loss)
g_loss = 0
x_plot_loss_d.append(epoch)
y_plot_loss_d.append(d_loss)
d_loss = 0
plt.figure()
plt.subplot(2, 1, 1)
loss_plt_d = plt.plot(x_plot_loss_d, y_plot_loss_d, 'b-')
plt.title('d_loss')
plt.subplot(2, 1, 2)
loss_plt_g = plt.plot(x_plot_loss_g, y_plot_loss_g, 'r-')
plt.title('g_loss')
plt.savefig('loss_wavegan-sin-1.png')
sio.savemat('wavegan231-3R-lt2/loss.mat', {'d_loss': y_plot_loss_d, 'g_loss': y_plot_loss_g})
'''
if __name__ == '__main__':
gan = GAN()
gan.train(epochs=3000, batch_size=128)
K.clear_session()

WAVEGAN-231eeg-3R-1.py at commit 9e2d7b3, no license · at the source

Overview

Authors: Miaomiao Yu¹, Te Guo^1,2, Shangen Han¹, Na Xue³, Wanying Yang¹, Junda Huang¹, Hongyu Chen¹, Cheng He¹, Jinhong Ding³, Likun Xia¹

ORCID iDs: Likun Xia

Institutions: Capital Normal University (China); Beijing University of Chemical Technology (China)

Journal: iScience, volume 29, issue 6, article 115785

Dates: received 31 August 2025; accepted 15 April 2026; published online 16 April 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1016/j.isci.2026.115785 · PMID 42256276 · PMCID PMC13233779 · OpenAlex W7154625149

Open access: gold, a free copy (OpenAlex)

Status: code verified

Categories: EEG (modality), human (organism), cognitive (subfield)

Methods: Spectral & time-frequency, Smoothing, state filtering, decompositions, Machine learning, Evoked potentials, Statistics

Keywords: health sciences, medicine, medical specialty, electrodiagnostic medicine

Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Funding: Beijing Natural Science Foundation (4242033)

Citations: not cited yet (Europe PMC); 44 references in the paper

Abstract

Obtaining sufficient electroencephalography (EEG) signals for training deep neural networks (DNNs) in brain-computer interfaces (BCIs) is challenging due to individual differences in neural activity, which require large per-participant data to map signals to actions, while factors like movement artifacts often limit data collection. Existing advances mainly leverage generative models with various regularizers to produce sufficient EEG signals. However, selecting appropriate regularizers remains challenging. Inspired by metacognition, the human cognitive process that monitors and regulates learning and decision-making, we propose a metacognitive regulation module including three regularizers that explicitly capture EEG temporal dynamics and functional resolution, thereby improving both the diversity and similarity of generated data. Through extensive theoretical and empirical validation on two datasets, we demonstrate that our module: (1) significantly improves generative models for generating highly complex, realistic EEG activity; (2) improves generalization across different generative models; and (3) endows DNN models with enhanced human-like decision-making and adaptation capabilities.

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

Repository

Its files are read in the Code ↔ Paper reader above.

Seanhanyy/Metacognitive-Regulation-Module

License: none: the authors keep all their rights

State: the link answers, verified on 29 September 2026

Evidence: files inventoried

Commit: 9e2d7b3fb9ec2240fe002b4977f6e1b26f860634, 4 April 2026

Languages: Python (23)

Size: 30 files, 23 scripts

Software Heritage: not archived

Found in: “Data and code availability”

Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation

Tools: Keras (23 files), NumPy (23 files), scikit-learn (23 files), SciPy (23 files), TensorFlow (23 files), PyTorch (21 files), Matplotlib (19 files)

Availability: 1 check, the latest on 29 September 2026: the link answers

29 September 2026: the link answers

23 files

generated/WAVEGAN-231eeg-3R-1.py, Python, 530 lines
generated/WAVEGAN-231eeg-AR.py, Python, 494 lines
generated/WAVEGAN-231eeg-CR.py, Python, 480 lines
generated/WAVEGAN-231eeg-SR.py, Python, 486 lines
generated/WAVEGAN-551eeg-1.py, Python, 436 lines
generated/WAVEGAN-551eeg-3R-1.py, Python, 487 lines
generated/WAVEGAN-551eeg-AR.py, Python, 422 lines
generated/WAVEGAN-551eeg-CR.py, Python, 414 lines
generated/WAVEGAN-551eeg-SR.py, Python, 389 lines
generated/c-wgan.py, Python, 299 lines
generated/cc-wgan-3R-231-1.py, Python, 552 lines
generated/cc-wgan-3R-551-1.py, Python, 521 lines
generated/wgan-231-1-AR.py, Python, 478 lines
generated/wgan-231-1-SR.py, Python, 472 lines
generated/wgan-231-1.py, Python, 463 lines
generated/wgan-3R-231-1.py, Python, 505 lines
generated/wgan-3R-551-5.py, Python, 505 lines
generated/wgan-551-1.py, Python, 448 lines
generated/wgan-LSTM-1-SR.py, Python, 476 lines
generated/wgan-LSTM-3R-231-1.py, Python, 512 lines
generated/wgan-LSTM-3R-551-1.py, Python, 503 lines
generated/wgan-LSTM-551-1.py, Python, 444 lines
generated/wgan231-1-CR.py, Python, 481 lines

At the source: github.com/Seanhanyy/Metacognitive-Regulation-Module

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;
23 scripts, each with its path and the digest of its content;
no match between paragraphs and code yet;
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

• Data: The Bi2015a dataset be reached at here.35 The perception of structure-from-motion (PSFM) are available at Science Data Bank: https://doi.org/10.57760/sciencedb.32593. • Code: Code is publicly available at https://github.com/Seanhanyy/Metacognitive-Regulation-Module. • Additional information: Any additional information required to reanalyze the data reported in this paper is available from the lead contact upon request.

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, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 10 authors, 4 keywords, 1 funder, 24 references.

Cite

This paper

Yu, M., Guo, T., Han, S., Xue, N., Yang, W., Huang, J., Chen, H., He, C., Ding, J., & Xia, L. (2026). Integrating metacognitive mechanisms optimizes EEG generative models via hierarchical regularization. iScience, 29(6), 115785. https://doi.org/10.1016/j.isci.2026.115785

BibTeX

@article{yu2026integrating, author = {Yu, Miaomiao and Guo, Te and Han, Shangen and Xue, Na and Yang, Wanying and Huang, Junda and Chen, Hongyu and He, Cheng and Ding, Jinhong and Xia, Likun}, title = {{Integrating metacognitive mechanisms optimizes EEG generative models via hierarchical regularization}}, journal = {iScience}, year = {2026}, month = apr, volume = {29}, number = {6}, pages = {115785}, publisher = {Elsevier}, issn = {2589-0042}, doi = {10.1016/j.isci.2026.115785}, url = {https://doi.org/10.1016/j.isci.2026.115785}, pmid = {42256276}, pmcid = {PMC13233779} }

RIS

TY - JOUR AU - Yu, Miaomiao AU - Guo, Te AU - Han, Shangen AU - Xue, Na AU - Yang, Wanying AU - Huang, Junda AU - Chen, Hongyu AU - He, Cheng AU - Ding, Jinhong AU - Xia, Likun TI - Integrating metacognitive mechanisms optimizes EEG generative models via hierarchical regularization T2 - iScience J2 - iScience PY - 2026 DA - 2026/04/16 VL - 29 IS - 6 SP - 115785 SN - 2589-0042 PB - Elsevier DO - 10.1016/j.isci.2026.115785 UR - https://doi.org/10.1016/j.isci.2026.115785 LA - en ER -

CSL-JSON

{ "id": "10.1016/j.isci.2026.115785", "type": "article-journal", "title": "Integrating metacognitive mechanisms optimizes EEG generative models via hierarchical regularization", "container-title": "iScience", "author": [ { "family": "Yu", "given": "Miaomiao" }, { "family": "Guo", "given": "Te" }, { "family": "Han", "given": "Shangen" }, { "family": "Xue", "given": "Na" }, { "family": "Yang", "given": "Wanying" }, { "family": "Huang", "given": "Junda" }, { "family": "Chen", "given": "Hongyu" }, { "family": "He", "given": "Cheng" }, { "family": "Ding", "given": "Jinhong" }, { "family": "Xia", "given": "Likun" } ], "container-title-short": "iScience", "volume": "29", "issue": "6", "page": "115785", "DOI": "10.1016/j.isci.2026.115785", "PMID": "42256276", "PMCID": "PMC13233779", "ISSN": "2589-0042", "publisher": "Elsevier", "URL": "https://doi.org/10.1016/j.isci.2026.115785", "language": "en", "issued": { "date-parts": [ [ 2026, 4, 16 ] ] } }

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

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.