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.

15 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 16 matches · 5 of them tie a paragraph to a whole file without 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 · block oscr:b:0EKW9GTS0F694-S · Report a mismatch
  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 · block oscr:b:15X2TJEA2Q0ME-U · Report a mismatch
  3. [3] § Materials and methods › Empirical evaluation of canonical models ↔ src/types/params.jl, lines 47 to 131 · score 0.75 · 0.125–8 times, 0.25–4 times, zero default, 0.125 times, fallback, intervals · block oscr:b:ZZB9TT7A6EMGA-Z · Report a mismatch
  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 · block oscr:b:8B16J8YC81MP9-G · Report a mismatch
  5. [5] § Materials and methods › Empirical evaluation of canonical models ↔ src/simulate/simulate_network.jl, lines 259 to 324 · score 0.72 · Euler Maruyama, adaptive solver, stiff, Rodas5, Tsit5, simulated · block oscr:b:D7RXRB4CAKP7G-S · Report a mismatch
  6. [6] § Materials and methods › Probabilistic grammar and grammar-derived candidate models ↔ src/grammar/grammar.jl, lines 1 to 79 · score 0.70 · nonterminal symbols, production rules, probabilistic, grammar · block oscr:b:QMXMJY1836MVE-D · Report a mismatch
  7. [7] § Materials and methods › Canonical neural population models ↔ models/mdf.jl, lines 1 to 39 · score 0.69 · Moran David Friston, neural mass model, MDF, population · block oscr:b:ZPBQ78ZTQF9C6-P · Report a mismatch
  8. [8] § Materials and methods › Structural analysis of canonical models ↔ src/analyze/distance_measures.jl, lines 1 to 66 · score 0.69 · edit distance, deletion, insertion, substitution, sampled models, encoding · block oscr:b:BABE56XETYYVP-Z · Report a mismatch
  9. [9] § Materials and methods › Empirical evaluation of canonical models ↔ src/optimize/optimize_network.jl, lines 437 to 481 · score 0.69 · CMA ES, optimization problem, tunable parameters, Evolution, objective, bounded · block oscr:b:T14JQD8T3WAN5-J · Report a mismatch
  10. [10] § Materials and methods › Empirical evaluation of canonical models ↔ src/types/bounds.jl, lines 305 to 363 · score 0.64 · 0.125–8 times, 0.25–4 times, 0.125 times, intervals, zero, 0.25 times · block oscr:b:YNNXC6DK686V7-F · Report a mismatch
  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 · block oscr:b:4K3CSFVQ76B72-F · Report a mismatch
  12. [12] § Materials and methods › Probabilistic grammar and grammar-derived candidate models ↔ src/ENEEGMA.jl, lines 126 to 213 · score 0.58 · connectivity motif, coupling functions, node models, pipeline, components, ENEEGMA · block oscr:b:PGS8DWPB8C2Z9-D · Report a mismatch
  13. [13] § Materials and methods › Empirical evaluation of canonical models ↔ src/utils/spectral_transforms.jl, lines 488 to 536 · score 0.58 · log power, power spectral density, transformed, Welch, overlapping, windows · block oscr:b:0F01WBQS786NM-2 · Report a mismatch
  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 · block oscr:b:4K3CSFVQ76B72-F · Report a mismatch
  15. [15] § Results › Structural analysis of canonical models ↔ models/lb.jl, lines 1 to 40 · score 0.54 · population firing rate, membrane potential, sigmoidal, dynamics, canonical · block oscr:b:MGND9BW4S5XYN-0 · Report a mismatch
  16. [16] § Results › Structural analysis of canonical models ↔ src/analyze/distance_measures.jl, lines 68 to 126 · score 0.50 · cosine distance, edit distance, symbolic · block oscr:b:RK92X1JP17S0D-B · Report a mismatch

Paper

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

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.7554/elife.106194 [code]
Virtual Brain Inference (VBI), a flexible and integrative toolkit for efficient probabilistic inference on whole-brain models.
Journal: eLife
In common: computational, 18 references
[2] doi:10.1371/journal.pcbi.1012926 [code]
A comprehensive investigation of intracortical and corticothalamic models of the alpha rhythm.
Journal: PLoS computational biology
In common: computational, EEG, 14 references
[3] doi:10.1162/imag.a.1249 [code]
Global search metaheuristics for neural mass model calibration.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: DifferentialEquations.jl, Distributions.jl, Plots.jl, computational, EEG, 7 references
[4] doi:10.7554/elife.104249 [code]
Biophysically inspired mean-field model of neuronal populations driven by ion-exchange mechanisms.
Journal: eLife
In common: computational, 11 references
[5] doi:10.1038/s41540-025-00543-9 [code]
Region-specific mean field models enhance simulations of local and global brain dynamics.
Journal: NPJ systems biology and applications
In common: computational, 11 references
[6] 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
[7] doi:10.1371/journal.pcbi.1011434 [code]
A multi-layer mean-field model of the cerebellum embedding microstructure and population-specific dynamics.
Journal: PLoS computational biology
In common: computational, 11 references
[8] doi:10.1038/s41467-025-64470-3 [code]
Modeling macroscopic brain dynamics with brain-inspired computing architecture.
Journal: Nature communications
In common: computational, 10 references
[9] 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, Distributions.jl, 1 other tool, EEG, 2 references
[10] doi:10.1371/journal.pcbi.1011761 [code]
PyRates-A code-generation tool for modeling dynamical systems in biology and beyond.
Journal: PLoS computational biology
In common: DifferentialEquations.jl, Plots.jl, computational, 5 references

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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014222.svg)](https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014222)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014222.svg
   :target: https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014222
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014222"><img src="https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014222.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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