OSCR

Neural population models for EEG: From Canonical models to alternative model structures.

Code ↔ Paper

16 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 16 matches · 5 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Results › Structural analysis of canonical models ↔ src/grammar/known_models_parse_trees.jl, the whole file · a weak match · score 0.77 · relaxed rectifier, membrane integrator, voltage, gating, WWR, baseline
  2. [2] § Materials and methods › Probabilistic grammar and grammar-derived candidate models ↔ models/wc.jl, the whole file · a weak match · score 0.76 · Wilson Cowan, Jansen Rit, neural mass, inhibitory, excitatory, WC
  3. [3] § Materials and methods › Empirical evaluation of canonical models ↔ src/types/params.jl, lines 47–131 · score 0.75 · 0.125–8 times, 0.25–4 times, zero default, 0.125 times, fallback, intervals
  4. [4] § Materials and methods › Canonical neural population models ↔ models/arm.jl, the whole file · a weak match · score 0.72 · Alpha Rhythm Model, thalamo cortical, ARM, population
  5. [5] § Materials and methods › Empirical evaluation of canonical models ↔ src/simulate/simulate_network.jl, lines 259–324 · score 0.72 · Euler Maruyama, adaptive solver, stiff, Rodas5, Tsit5, simulated
  6. [6] § Materials and methods › Probabilistic grammar and grammar-derived candidate models ↔ src/grammar/grammar.jl, lines 1–79 · score 0.70 · nonterminal symbols, production rules, probabilistic, grammar
  7. [7] § Materials and methods › Canonical neural population models ↔ models/mdf.jl, lines 1–39 · score 0.69 · Moran David Friston, neural mass model, MDF, population
  8. [8] § Materials and methods › Structural analysis of canonical models ↔ src/analyze/distance_measures.jl, lines 1–66 · score 0.69 · edit distance, deletion, insertion, substitution, sampled models, encoding
  9. [9] § Materials and methods › Empirical evaluation of canonical models ↔ src/optimize/optimize_network.jl, lines 437–481 · score 0.69 · CMA ES, optimization problem, tunable parameters, Evolution, objective, bounded
  10. [10] § Materials and methods › Empirical evaluation of canonical models ↔ src/types/bounds.jl, lines 305–363 · score 0.64 · 0.125–8 times, 0.25–4 times, 0.125 times, intervals, zero, 0.25 times
  11. [11] § Results › Structural analysis of canonical models ↔ src/analyze/clustering.jl, the whole file · a weak match · score 0.58 · silhouette score, distance matrix, pairwise, clustering, vectors
  12. [12] § Materials and methods › Probabilistic grammar and grammar-derived candidate models ↔ src/ENEEGMA.jl, lines 126–213 · score 0.58 · connectivity motif, coupling functions, node models, pipeline, components, ENEEGMA
  13. [13] § Materials and methods › Empirical evaluation of canonical models ↔ src/utils/spectral_transforms.jl, lines 488–536 · score 0.58 · log power, power spectral density, transformed, Welch, overlapping, windows
  14. [14] § Results › Structural analysis of canonical models ↔ src/analyze/clustering.jl, the whole file · a weak match · score 0.57 · silhouette score, distance matrix, smallest, optimal, Pairwise, clusters
  15. [15] § Results › Structural analysis of canonical models ↔ models/lb.jl, lines 1–40 · score 0.54 · population firing rate, membrane potential, sigmoidal, dynamics, canonical
  16. [16] § Results › Structural analysis of canonical models ↔ src/analyze/distance_measures.jl, lines 68–126 · score 0.50 · cosine distance, edit distance, symbolic

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

Julia · 387 lines · 12 KB · MIT · 2 matches

  1. """
  2. Distance / dissimilarity utilities between sampled models and known models.
  4. Two notions of equation distance:
  5. 1. Histogram / structural overlap via operation label histograms
  6. 2. Token sequence edit distance for canonicalized equations
  8. api: calculate_distances_to_known_models(new_model, known_models; distance_types=[...]) -> NamedTuple of distance vectors
  9. """
  11. using SymbolicUtils, Symbolics, StringDistances, Distances
  12. const SymbolicEquation = Symbolics.Equation
  14. # --- small helper for safe normalization of scalar distances in [0, ∞) ---
  15. # mirrors `normalize_safe` logic used in check_analysis.jl but for scalars
  16. _normalize_safe_scalar(x::Float64)::Float64 = isfinite(x) ? (x == 0.0 ? 0.0 : x / max(x, 1.0)) : 0.0
  18. # --- Tokenization of recipe strings ---
  19. tokenize_string(s::AbstractString)::Vector{String} = [String(m.match) for m in eachmatch(r"-?\d+", s)]
  21. """
  22. _levenshtein_wildcard(ta, tb; wildcard="0") -> Int
  24. Levenshtein edit distance between two token sequences where any token equal to
  25. `wildcard` matches anything at zero cost (substitution, insertion, deletion).
  27. This is used so that recipe positions encoded as rule_id 0 (from `"any"
  28. terminals in `terminals_gsn`) are ignored in distance calculations.
  29. """
  30. function _levenshtein_wildcard(ta::Vector{String}, tb::Vector{String};
  31. wildcard::String="0")::Int
  32. m, n = length(ta), length(tb)
  33. # dp[i+1, j+1] = edit distance between ta[1:i] and tb[1:j]
  34. dp = zeros(Int, m + 1, n + 1)
  35. # base cases: inserting/deleting wildcards costs 0
  36. for i in 1:m
  37. dp[i+1, 1] = dp[i, 1] + (ta[i] == wildcard ? 0 : 1)
  38. end
  39. for j in 1:n
  40. dp[1, j+1] = dp[1, j] + (tb[j] == wildcard ? 0 : 1)
  41. end
  42. for i in 1:m
  43. for j in 1:n
  44. if ta[i] == tb[j] || ta[i] == wildcard || tb[j] == wildcard
  45. dp[i+1, j+1] = dp[i, j] # match or wildcard (0 cost)
  46. else
  47. dp[i+1, j+1] = min(
  48. dp[i, j] + 1, # substitute
  49. dp[i+1, j] + 1, # insert
  50. dp[i, j+1] + 1, # delete
  51. )
  52. end
  53. end
  54. end
  55. return dp[m+1, n+1]
  56. end
  58. function edit_distance_recipe(a::AbstractString, b::AbstractString; method::String="levenshtein")
  59. ta = tokenize_string(a)
  60. tb = tokenize_string(b)
  61. if method == "levenshtein"
  62. return _levenshtein_wildcard(ta, tb)
  63. else
  64. error("Unknown edit distance method: $method")
  65. end
  66. end
  68. # --- Histogram based distances on equations ---
  69. _isnode(x) = SymbolicUtils.istree(x)
  70. _args(x) = SymbolicUtils.arguments(x)
  71. _oplabel(x) = string(SymbolicUtils.operation(x))
  73. "Make a histogram of operation labels from a list of RHS expressions."
  74. function _op_histogram(rhs_exprs)::Dict{String,Int}
  75. h = Dict{String,Int}()
  76. for ex in rhs_exprs
  77. stack = Any[ex]
  78. while !isempty(stack)
  79. x = pop!(stack)
  80. if _isnode(x)
  81. key = _oplabel(x)
  82. h[key] = get(h, key, 0) + 1
  83. append!(stack, _args(x))
  84. end
  85. end
  86. end
  87. return h
  88. end
  90. "Cosine distance between two histograms."
  91. function _hist_cosine_distance(h1::Dict{String,Int}, h2::Dict{String,Int})
  92. ks = union(keys(h1), keys(h2))
  93. v1 = Float64[get(h1, k, 0) for k in ks]
  94. v2 = Float64[get(h2, k, 0) for k in ks]
  95. return cosine_dist(v1, v2)
  96. end
  98. """
  99. edit_distance_equations(eqsA, eqsB; metric=:cosine)
  101. Histogram-based distance between two sets of equations, comparing RHS operation label counts.
  102. """
  103. function set_distance_equations(eqsA::Union{Nothing,Vector{SymbolicEquation}},
  104. eqsB::Union{Nothing,Vector{SymbolicEquation}};
  105. metric::Symbol = :cosine)::Float64
  106. rhsA = (eqsA === nothing) ? Any[] : [eq.rhs for eq in eqsA]
  107. rhsB = (eqsB === nothing) ? Any[] : [eq.rhs for eq in eqsB]
  108. hA = _op_histogram(rhsA)
  109. hB = _op_histogram(rhsB)
  111. if metric == :cosine
  112. return _hist_cosine_distance(hA, hB)
  113. elseif metric == :jaccard
  114. sA, sB = Set(keys(hA)), Set(keys(hB))
  115. inter = length(intersect(sA, sB))
  116. uni = length(union(sA, sB))
  117. return uni == 0 ? 0.0 : 1.0 - inter/uni
  118. elseif metric == :l1
  119. ks = union(keys(hA), keys(hB))
  120. v1 = Float64[get(hA, k, 0) for k in ks]
  121. v2 = Float64[get(hB, k, 0) for k in ks]
  122. return sum(abs.(v1 .- v2))
  123. else
  124. error("Unknown metric: $metric")
  125. end
  126. end
  128. # --- Canonicalization + token sequence edit distance ---
  130. const COMMUTATIVE_OPS = Set{Any}((+, *))
  132. function _canonical_term_type(ex)
  133. T = Symbolics.symtype(ex)
  134. return T === Any ? Real : T
  135. end
  137. function canonicalize_expr(ex)
  138. if !Symbolics.istree(ex)
  139. return ex
  140. end
  142. op = Symbolics.operation(ex)
  143. args = Symbolics.arguments(ex)
  145. canon_args = map(canonicalize_expr, args)
  147. if op in COMMUTATIVE_OPS
  148. sort!(canon_args; by = string)
  149. end
  151. return Symbolics.term(op, canon_args...; type=_canonical_term_type(ex))
  152. end
  154. canonicalize_equation(eq::SymbolicEquation) =
  155. SymbolicEquation(canonicalize_expr(eq.lhs), canonicalize_expr(eq.rhs))
  157. function canonicalize_equations(eqs::Vector{SymbolicEquation})
  158. ceqs = canonicalize_equation.(eqs)
  159. # still sort by lhs,rhs for consistent ordering
  160. sort!(ceqs; by = eq -> (string(eq.lhs), string(eq.rhs)))
  161. return ceqs
  162. end
  164. function postfix_tokens(ex)::Vector{String}
  165. if !Symbolics.istree(ex)
  166. return [string(ex)]
  167. end
  168. op = Symbolics.operation(ex)
  169. args = Symbolics.arguments(ex)
  171. toks = String[]
  172. for a in args
  173. append!(toks, postfix_tokens(a))
  174. end
  175. push!(toks, string(op))
  176. return toks
  177. end
  179. """
  180. rhs_tokens(eq) -> Vector{String}
  182. Return postfix tokens of RHS only.
  183. """
  184. function rhs_tokens(eq::SymbolicEquation)::Vector{String}
  185. return postfix_tokens(eq.rhs)
  186. end
  188. """
  189. edit_distance_equations_rhs(eqs_a, eqs_b; method="levenshtein", normalize=false)
  191. Distance between two systems of equations as sum of RHS-only token-level edit
  192. distances, plus penalty for extra equations.
  193. """
  194. function edit_distance_equations_rhs(eqs_a::Vector{SymbolicEquation},
  195. eqs_b::Vector{SymbolicEquation};
  196. method::String="levenshtein",
  197. normalize::Bool=false)
  199. ca = canonicalize_equations(eqs_a)
  200. cb = canonicalize_equations(eqs_b)
  202. ma, mb = length(ca), length(cb)
  203. k = min(ma, mb)
  205. dist = 0.0
  206. total_tokens = 0
  208. # matched equations
  209. for i in 1:k
  210. ta = rhs_tokens(ca[i])
  211. tb = rhs_tokens(cb[i])
  213. d = if method == "levenshtein"
  214. StringDistances.Levenshtein()(ta, tb)
  215. else
  216. error("Unknown edit distance method: $method")
  217. end
  219. dist += d
  220. total_tokens += max(length(ta), length(tb))
  221. end
  223. # extra equations in A (RHS distance to empty)
  224. if ma > mb
  225. for i in (k+1):ma
  226. ta = rhs_tokens(ca[i])
  227. d_extra = StringDistances.Levenshtein()(ta, String[])
  228. dist += d_extra
  229. total_tokens += length(ta)
  230. end
  231. end
  233. # extra equations in B
  234. if mb > ma
  235. for i in (k+1):mb
  236. tb = rhs_tokens(cb[i])
  237. d_extra = StringDistances.Levenshtein()(tb, String[])
  238. dist += d_extra
  239. total_tokens += length(tb)
  240. end
  241. end
  243. if normalize && total_tokens > 0
  244. return dist / total_tokens
  245. else
  246. return dist
  247. end
  248. end
  251. """
  252. dim_distance_equations(eqsA, eqsB) -> Float64
  254. Distance based purely on the difference in number of equations
  255. (e.g. state variables).
  257. Returns a value in [0, 1], where 0 means same number of equations,
  258. 1 means one system is empty and the other non-empty.
  259. """
  260. function dim_distance_equations(eqsA, eqsB)::Float64
  261. nA = (eqsA === nothing) ? 0 : length(eqsA)
  262. nB = (eqsB === nothing) ? 0 : length(eqsB)
  264. if nA == 0 && nB == 0
  265. return 0.0
  266. else
  267. return abs(nA - nB) / max(nA, nB)
  268. end
  269. end
  273. # Robust min-max scaling with clamping.
  274. # Maps lo -> 0, hi -> 1, clamps outside.
  275. @inline function _robust_minmax(x::Real, lo::Real, hi::Real)::Float64
  276. den = (hi - lo)
  277. den <= 0 && return 0.0
  278. return Float64(clamp((x - lo) / (den + eps(Float64)), 0.0, 1.0))
  279. end
  281. # Compute (lo, hi) robust bounds (defaults: 5th–95th percentiles)
  282. function _robust_bounds(vals::AbstractVector{<:Real}; qlo=0.05, qhi=0.95)
  283. isempty(vals) && error("Cannot compute robust bounds on an empty vector.")
  284. lo = quantile(Float64.(vals), qlo)
  285. hi = quantile(Float64.(vals), qhi)
  286. return lo, hi
  287. end
  290. function combined_distance_editcos(
  291. eqsA::Vector{SymbolicEquation},
  292. eqsB::Vector{SymbolicEquation};
  293. edit_lo::Real=0.0, edit_hi::Real=984.0,
  294. w_edit::Real=0.5, w_set::Real=0.5
  295. )::Float64
  296. d_edit = edit_distance_equations_rhs(eqsA, eqsB; normalize=false)
  297. d_set = set_distance_equations(eqsA, eqsB; metric=:cosine)
  299. d_edit_norm = _robust_minmax(d_edit, edit_lo, edit_hi)
  301. return Float64(w_edit * d_edit_norm + w_set * d_set)
  302. end
  307. """
  308. hamming_distance(f1::Vector{Int}, f2::Vector{Int}) -> Float64
  310. Normalized Hamming distance between two fixed-length grammar feature vectors.
  312. Interprets all entries as categorical IDs:
  313. - distance = 0.0 if all positions match
  314. - distance = 1.0 if all positions differ
  315. """
  316. function hamming_distance(f1::Vector{Int}, f2::Vector{Int})::Float64
  317. @assert length(f1) == length(f2) "Feature vectors must have the same length"
  319. n = length(f1)
  320. n == 0 && return 0.0
  322. mismatches = 0
  323. @inbounds for i in 1:n
  324. f1[i] == f2[i] || (mismatches += 1)
  325. end
  327. return mismatches / n
  328. end
  331. """
  332. compute_distances_to_known_models(new_model, known_models;
  333. distance_types = [...])
  335. Compute a NamedTuple of distance vectors for a new_model against a list of known_models.
  337. Allowed distance types:
  338. - edit_distance_recipe
  339. - set_distance_equations
  340. - edit_distance_norm
  341. - edit_distance
  342. - feature_distance
  343. """
  344. function compute_distances_to_known_models(
  345. new_model,
  346. known_models::Vector;
  347. distance_types::Vector{String} = ["combined_distance_editcos"])::NamedTuple
  349. cols = Dict{String, Vector{Float64}}(t => Float64[] for t in distance_types)
  351. eqs_new = getfield(new_model, :equations)
  352. recipe_new = getfield(new_model, :recipe)
  353. features_new = getfield(new_model, :features)
  355. for km in known_models
  356. eqs_k = getfield(km, :equations)
  357. recipe_k = getfield(km, :recipe)
  358. features_k = getfield(km, :features)
  360. for t in distance_types
  361. val = if t == "edit_distance_recipe"
  362. edit_distance_recipe(recipe_new, recipe_k)
  363. elseif t == "set_distance_equations" || t == "set_distance_cos"
  364. set_distance_equations(eqs_new, eqs_k; metric=:cosine)
  365. elseif t == "set_distance_jac"
  366. set_distance_equations(eqs_new, eqs_k; metric=:jaccard)
  367. elseif t == "set_distance_l1"
  368. set_distance_equations(eqs_new, eqs_k; metric=:l1)
  369. elseif t == "edit_distance_norm"
  370. edit_distance_equations_rhs(eqs_new, eqs_k; normalize=true)
  371. elseif t == "edit_distance_equations" || t == "edit_distance"
  372. edit_distance_equations_rhs(eqs_new, eqs_k; normalize=false)
  373. elseif t == "geometric_distance"
  374. geometric_distance(eqs_new, eqs_k)
  375. elseif t == "feature_distance"
  376. hamming_distance(features_new, features_k)
  377. elseif t == "combined_distance_editcos"
  378. combined_distance_editcos(eqs_new, eqs_k)
  379. else
  380. error("Unknown distance type: $t")
  381. end
  382. push!(cols[t], val)
  383. end
  384. end
  386. return (; (Symbol(d) => cols[d] for d in distance_types)...)
  387. end

distance_measures.jl at commit 6001d08, under MIT · at the source

Overview

Authors: Nina Omejc1,2, Sabin Roman1, Ljupčo Todorovski3, Sašo Džeroski1
ORCID iDs: Nina Omejc, Ljupčo Todorovski
  1. Department of Knowledge Technologies, Jožef Stefan Institute, Ljubljana, Slovenia
  2. Jožef Stefan International Postgraduate School, Ljubljana, Slovenia
  3. Department of Mathematics, Faculty of Mathematics and Physics, University of Ljubljana, Ljubljana, Slovenia
Institutions: Jožef Stefan Institute (Slovenia); Jožef Stefan International Postgraduate School (Slovenia); University of Ljubljana (Slovenia)
Journal: PLoS computational biology, volume 22, issue 8, article e1014222
Dates: received 9 April 2026; accepted 26 July 2026; published online 6 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014222 · PMID 42561039 · PMCID PMC13460749 · OpenAlex W7196927555
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), computational (subfield)
Methods: Spectral & time-frequency, Machine learning, Smoothing, state filtering, decompositions, Preprocessing, Statistics, Single-unit activity, calcium imaging
MeSH: Electroencephalography*, Models, Neurological*, Neurons*, Algorithms, Computational Biology, Computer Simulation, Evoked Potentials, Visual, Humans (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Slovenian Research and Innovation Agency
Citations: not cited yet (Europe PMC); 100 references in the paper

Abstract

Neural population models are widely used to interpret electroencephalography (EEG), yet the relationship between the two remains far less systematically understood as compared with single-neuron models. More fundamentally, it remains unclear whether EEG can support a uniquely plausible population-level mechanism, or whether multiple structurally distinct models can explain the data equally well. To address this question, we combine comparative analysis of canonical model families with grammar-based generation of new candidate architectures. We assemble 17 canonical neural mass and phenomenological models and embed them in a shared structural space. From their common processes, we define a probabilistic grammar over interpretable dynamical components and develop ENEEGMA (Exploring Neural EEG Model Architectures), a Julia-based framework for grammar-based model generation, simulation, and parameter optimization. With this grammar, we generate additional candidate models. We then assess both canonical and generated models by fitting them to EEG independent-component spectra from four datasets for two conditions, i.e., resting state and steady-state visual evoked potentials (SSVEP). Canonical models form six structural clusters. Across conditions, compact low-dimensional polynomial oscillators perform best overall, with generalized Montbrió–Pazó–Roxin, FitzHugh–Nagumo, and Stuart–Landau models offering the best balance of fit quality, stability, and simplicity. Grammar-based exploration further showed that the space of viable EEG node models extends beyond canonical formulations: Even a restricted search over 1,000 generated models produces compact alternatives competitive with nearly all canonical families, with the generated cluster achieving the strongest Bayesian expected rank for SSVEP fits. These findings suggest that EEG spectra constrain classes of plausible population-level dynamical architectures without uniquely determining them and that grammar-based model exploration provides a principled, data-driven framework for EEG-constrained model discovery.

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 16 matches between paragraphs and lines of code.

NinaOmejc/ENEEGMA

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6001d08d033ca05c36517b5f59cde58156cfe93e, 21 September 2026
Languages: Julia (81)
Size: 98 files, 81 scripts
Software Heritage: not checked
Found in: “Data Availability”
Holds: README, license file, environment (Project.toml), tests
Not found: CITATION.cff, continuous integration, documentation
Tools: DataFrames.jl (12 files), DifferentialEquations.jl (6 files), Plots.jl (4 files), Distributions.jl (3 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
83 files
At the source: github.com/NinaOmejc/ENEEGMA

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;
  • 81 scripts, each with its path and the digest of its content;
  • 16 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 Availability

The EEG data underlying this study were obtained from publicly available datasets accessed through the MOABB framework: https://moabb.neurotechx.com/docs/generated/moabb.datasets.Lee2019_SSVEP.html. All code used to generate, simulate, and evaluate the models is publicly available in the ENEEGMA repository at GitHub: https://github.com/NinaOmejc/ENEEGMA.

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

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 8 MeSH terms, 1 funder, 85 references.

Cite

This paper

Omejc, N., Roman, S., Todorovski, L., & Džeroski, S. (2026). Neural population models for EEG: From Canonical models to alternative model structures. PLoS computational biology, 22(8), e1014222. https://doi.org/10.1371/journal.pcbi.1014222

BibTeX

@article{omejc2026neural,
author = {Omejc, Nina and Roman, Sabin and Todorovski, Ljupčo and Džeroski, Sašo},
title = {{Neural population models for EEG: From Canonical models to alternative model structures}},
journal = {PLoS computational biology},
year = {2026},
month = aug,
volume = {22},
number = {8},
pages = {e1014222},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014222},
url = {https://doi.org/10.1371/journal.pcbi.1014222},
pmid = {42561039},
pmcid = {PMC13460749}
}

RIS

TY - JOUR
AU - Omejc, Nina
AU - Roman, Sabin
AU - Todorovski, Ljupčo
AU - Džeroski, Sašo
TI - Neural population models for EEG: From Canonical models to alternative model structures
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/08/06
VL - 22
IS - 8
SP - e1014222
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014222
UR - https://doi.org/10.1371/journal.pcbi.1014222
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014222",
"type": "article-journal",
"title": "Neural population models for EEG: From Canonical models to alternative model structures",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Omejc",
"given": "Nina"
},
{
"family": "Roman",
"given": "Sabin"
},
{
"family": "Todorovski",
"given": "Ljupčo"
},
{
"family": "Džeroski",
"given": "Sašo"
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "8",
"page": "e1014222",
"DOI": "10.1371/journal.pcbi.1014222",
"PMID": "42561039",
"PMCID": "PMC13460749",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014222",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
6
]
]
}
}

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.1249 [code]
Global search metaheuristics for neural mass model calibration.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: DifferentialEquations.jl, Plots.jl, Distributions.jl, computational, EEG, 7 references
[2] doi:10.1371/journal.pcbi.1014022 [code]
Emergence of multifrequency activity in a laminar neural mass model.
Journal: PLoS computational biology
In common: DifferentialEquations.jl, 9 references
[3] doi:10.1523/eneuro.0379-25.2026 [code]
Next-Generation Neural Mass Models Reproduce Features of Speech Processing.
Journal: eNeuro
In common: DifferentialEquations.jl, DataFrames.jl, Plots.jl, 1 other tool, EEG, 2 references
[4] doi:10.1038/s41540-026-00749-5 [code]
A novel approach to quantify out-of-distribution uncertainty in Neural and Universal Differential Equations.
Journal: NPJ systems biology and applications
In common: DifferentialEquations.jl, DataFrames.jl, Plots.jl, 1 other tool, 1 reference
[5] doi:10.1162/imag.a.1147 [code]
The Virtual Brain links transcranial magnetic stimulation evoked potentials and inhibitory neurotransmitter changes in major depressive disorder.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: computational, 7 references
[6] doi:10.1038/s41467-026-71918-7 [code]
Developmental disinhibition gates language lateralization in childhood.
Journal: Nature communications
In common: 8 references
[7] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: DifferentialEquations.jl, DataFrames.jl, Plots.jl, 1 other tool
[8] doi:10.1371/journal.pcbi.1014549 [code]
Inward rectifier potassium channels interact with calcium channels to promote robust and physiological bistability.
Journal: PLoS computational biology
In common: DifferentialEquations.jl, DataFrames.jl, Plots.jl, 1 other tool
[9] doi:10.1093/pnasnexus/pgag213 [code]
Two-factor synaptic plasticity enables memory consolidation during neuronal burst firing.
Journal: PNAS nexus
In common: DifferentialEquations.jl, DataFrames.jl, Plots.jl, 1 other tool
[10] doi:10.1371/journal.pcbi.1014001 [code]
Burst firing creates an attractor in synaptic weight dynamics.
Journal: PLoS computational biology
In common: DifferentialEquations.jl, DataFrames.jl, Plots.jl, 1 other tool

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.