Neural population models for EEG: From Canonical models to alternative model structures.
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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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] § 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
- """
- Distance / dissimilarity utilities between sampled models and known models.
- Two notions of equation distance:
- 1. Histogram / structural overlap via operation label histograms
- 2. Token sequence edit distance for canonicalized equations
- api: calculate_distances_to_known_models(new_model, known_models; distance_types=[...]) -> NamedTuple of distance vectors
- """
- using SymbolicUtils, Symbolics, StringDistances, Distances
- const SymbolicEquation = Symbolics.Equation
- # --- small helper for safe normalization of scalar distances in [0, ∞) ---
- # mirrors `normalize_safe` logic used in check_analysis.jl but for scalars
- _normalize_safe_scalar(x::Float64)::Float64 = isfinite(x) ? (x == 0.0 ? 0.0 : x / max(x, 1.0)) : 0.0
- # --- Tokenization of recipe strings ---
- tokenize_string(s::AbstractString)::Vector{String} = [String(m.match) for m in eachmatch(r"-?\d+", s)]
- """
- _levenshtein_wildcard(ta, tb; wildcard="0") -> Int
- Levenshtein edit distance between two token sequences where any token equal to
- `wildcard` matches anything at zero cost (substitution, insertion, deletion).
- This is used so that recipe positions encoded as rule_id 0 (from `"any"
- terminals in `terminals_gsn`) are ignored in distance calculations.
- """
- function _levenshtein_wildcard(ta::Vector{String}, tb::Vector{String};
- wildcard::String="0")::Int
- m, n = length(ta), length(tb)
- # dp[i+1, j+1] = edit distance between ta[1:i] and tb[1:j]
- dp = zeros(Int, m + 1, n + 1)
- # base cases: inserting/deleting wildcards costs 0
- for i in 1:m
- dp[i+1, 1] = dp[i, 1] + (ta[i] == wildcard ? 0 : 1)
- end
- for j in 1:n
- dp[1, j+1] = dp[1, j] + (tb[j] == wildcard ? 0 : 1)
- end
- for i in 1:m
- for j in 1:n
- if ta[i] == tb[j] || ta[i] == wildcard || tb[j] == wildcard
- dp[i+1, j+1] = dp[i, j] # match or wildcard (0 cost)
- else
- dp[i+1, j+1] = min(
- dp[i, j] + 1, # substitute
- dp[i+1, j] + 1, # insert
- dp[i, j+1] + 1, # delete
- )
- end
- end
- end
- return dp[m+1, n+1]
- end
- function edit_distance_recipe(a::AbstractString, b::AbstractString; method::String="levenshtein")
- ta = tokenize_string(a)
- tb = tokenize_string(b)
- if method == "levenshtein"
- return _levenshtein_wildcard(ta, tb)
- else
- error("Unknown edit distance method: $method")
- end
- end
- # --- Histogram based distances on equations ---
- _isnode(x) = SymbolicUtils.istree(x)
- _args(x) = SymbolicUtils.arguments(x)
- _oplabel(x) = string(SymbolicUtils.operation(x))
- "Make a histogram of operation labels from a list of RHS expressions."
- function _op_histogram(rhs_exprs)::Dict{String,Int}
- h = Dict{String,Int}()
- for ex in rhs_exprs
- stack = Any[ex]
- while !isempty(stack)
- x = pop!(stack)
- if _isnode(x)
- key = _oplabel(x)
- h[key] = get(h, key, 0) + 1
- append!(stack, _args(x))
- end
- end
- end
- return h
- end
- "Cosine distance between two histograms."
- function _hist_cosine_distance(h1::Dict{String,Int}, h2::Dict{String,Int})
- ks = union(keys(h1), keys(h2))
- v1 = Float64[get(h1, k, 0) for k in ks]
- v2 = Float64[get(h2, k, 0) for k in ks]
- return cosine_dist(v1, v2)
- end
- """
- edit_distance_equations(eqsA, eqsB; metric=:cosine)
- Histogram-based distance between two sets of equations, comparing RHS operation label counts.
- """
- function set_distance_equations(eqsA::Union{Nothing,Vector{SymbolicEquation}},
- eqsB::Union{Nothing,Vector{SymbolicEquation}};
- metric::Symbol = :cosine)::Float64
- rhsA = (eqsA === nothing) ? Any[] : [eq.rhs for eq in eqsA]
- rhsB = (eqsB === nothing) ? Any[] : [eq.rhs for eq in eqsB]
- hA = _op_histogram(rhsA)
- hB = _op_histogram(rhsB)
- if metric == :cosine
- return _hist_cosine_distance(hA, hB)
- elseif metric == :jaccard
- sA, sB = Set(keys(hA)), Set(keys(hB))
- inter = length(intersect(sA, sB))
- uni = length(union(sA, sB))
- return uni == 0 ? 0.0 : 1.0 - inter/uni
- elseif metric == :l1
- ks = union(keys(hA), keys(hB))
- v1 = Float64[get(hA, k, 0) for k in ks]
- v2 = Float64[get(hB, k, 0) for k in ks]
- return sum(abs.(v1 .- v2))
- else
- error("Unknown metric: $metric")
- end
- end
- # --- Canonicalization + token sequence edit distance ---
- const COMMUTATIVE_OPS = Set{Any}((+, *))
- function _canonical_term_type(ex)
- T = Symbolics.symtype(ex)
- return T === Any ? Real : T
- end
- function canonicalize_expr(ex)
- if !Symbolics.istree(ex)
- return ex
- end
- op = Symbolics.operation(ex)
- args = Symbolics.arguments(ex)
- canon_args = map(canonicalize_expr, args)
- if op in COMMUTATIVE_OPS
- sort!(canon_args; by = string)
- end
- return Symbolics.term(op, canon_args...; type=_canonical_term_type(ex))
- end
- canonicalize_equation(eq::SymbolicEquation) =
- SymbolicEquation(canonicalize_expr(eq.lhs), canonicalize_expr(eq.rhs))
- function canonicalize_equations(eqs::Vector{SymbolicEquation})
- ceqs = canonicalize_equation.(eqs)
- # still sort by lhs,rhs for consistent ordering
- sort!(ceqs; by = eq -> (string(eq.lhs), string(eq.rhs)))
- return ceqs
- end
- function postfix_tokens(ex)::Vector{String}
- if !Symbolics.istree(ex)
- return [string(ex)]
- end
- op = Symbolics.operation(ex)
- args = Symbolics.arguments(ex)
- toks = String[]
- for a in args
- append!(toks, postfix_tokens(a))
- end
- push!(toks, string(op))
- return toks
- end
- """
- rhs_tokens(eq) -> Vector{String}
- Return postfix tokens of RHS only.
- """
- function rhs_tokens(eq::SymbolicEquation)::Vector{String}
- return postfix_tokens(eq.rhs)
- end
- """
- edit_distance_equations_rhs(eqs_a, eqs_b; method="levenshtein", normalize=false)
- Distance between two systems of equations as sum of RHS-only token-level edit
- distances, plus penalty for extra equations.
- """
- function edit_distance_equations_rhs(eqs_a::Vector{SymbolicEquation},
- eqs_b::Vector{SymbolicEquation};
- method::String="levenshtein",
- normalize::Bool=false)
- ca = canonicalize_equations(eqs_a)
- cb = canonicalize_equations(eqs_b)
- ma, mb = length(ca), length(cb)
- k = min(ma, mb)
- dist = 0.0
- total_tokens = 0
- # matched equations
- for i in 1:k
- ta = rhs_tokens(ca[i])
- tb = rhs_tokens(cb[i])
- d = if method == "levenshtein"
- StringDistances.Levenshtein()(ta, tb)
- else
- error("Unknown edit distance method: $method")
- end
- dist += d
- total_tokens += max(length(ta), length(tb))
- end
- # extra equations in A (RHS distance to empty)
- if ma > mb
- for i in (k+1):ma
- ta = rhs_tokens(ca[i])
- d_extra = StringDistances.Levenshtein()(ta, String[])
- dist += d_extra
- total_tokens += length(ta)
- end
- end
- # extra equations in B
- if mb > ma
- for i in (k+1):mb
- tb = rhs_tokens(cb[i])
- d_extra = StringDistances.Levenshtein()(tb, String[])
- dist += d_extra
- total_tokens += length(tb)
- end
- end
- if normalize && total_tokens > 0
- return dist / total_tokens
- else
- return dist
- end
- end
- """
- dim_distance_equations(eqsA, eqsB) -> Float64
- Distance based purely on the difference in number of equations
- (e.g. state variables).
- Returns a value in [0, 1], where 0 means same number of equations,
- 1 means one system is empty and the other non-empty.
- """
- function dim_distance_equations(eqsA, eqsB)::Float64
- nA = (eqsA === nothing) ? 0 : length(eqsA)
- nB = (eqsB === nothing) ? 0 : length(eqsB)
- if nA == 0 && nB == 0
- return 0.0
- else
- return abs(nA - nB) / max(nA, nB)
- end
- end
- # Robust min-max scaling with clamping.
- # Maps lo -> 0, hi -> 1, clamps outside.
- @inline function _robust_minmax(x::Real, lo::Real, hi::Real)::Float64
- den = (hi - lo)
- den <= 0 && return 0.0
- return Float64(clamp((x - lo) / (den + eps(Float64)), 0.0, 1.0))
- end
- # Compute (lo, hi) robust bounds (defaults: 5th–95th percentiles)
- function _robust_bounds(vals::AbstractVector{<:Real}; qlo=0.05, qhi=0.95)
- isempty(vals) && error("Cannot compute robust bounds on an empty vector.")
- lo = quantile(Float64.(vals), qlo)
- hi = quantile(Float64.(vals), qhi)
- return lo, hi
- end
- function combined_distance_editcos(
- eqsA::Vector{SymbolicEquation},
- eqsB::Vector{SymbolicEquation};
- edit_lo::Real=0.0, edit_hi::Real=984.0,
- w_edit::Real=0.5, w_set::Real=0.5
- )::Float64
- d_edit = edit_distance_equations_rhs(eqsA, eqsB; normalize=false)
- d_set = set_distance_equations(eqsA, eqsB; metric=:cosine)
- d_edit_norm = _robust_minmax(d_edit, edit_lo, edit_hi)
- return Float64(w_edit * d_edit_norm + w_set * d_set)
- end
- """
- hamming_distance(f1::Vector{Int}, f2::Vector{Int}) -> Float64
- Normalized Hamming distance between two fixed-length grammar feature vectors.
- Interprets all entries as categorical IDs:
- - distance = 0.0 if all positions match
- - distance = 1.0 if all positions differ
- """
- function hamming_distance(f1::Vector{Int}, f2::Vector{Int})::Float64
- @assert length(f1) == length(f2) "Feature vectors must have the same length"
- n = length(f1)
- n == 0 && return 0.0
- mismatches = 0
- @inbounds for i in 1:n
- f1[i] == f2[i] || (mismatches += 1)
- end
- return mismatches / n
- end
- """
- compute_distances_to_known_models(new_model, known_models;
- distance_types = [...])
- Compute a NamedTuple of distance vectors for a new_model against a list of known_models.
- Allowed distance types:
- - edit_distance_recipe
- - set_distance_equations
- - edit_distance_norm
- - edit_distance
- - feature_distance
- """
- function compute_distances_to_known_models(
- new_model,
- known_models::Vector;
- distance_types::Vector{String} = ["combined_distance_editcos"])::NamedTuple
- cols = Dict{String, Vector{Float64}}(t => Float64[] for t in distance_types)
- eqs_new = getfield(new_model, :equations)
- recipe_new = getfield(new_model, :recipe)
- features_new = getfield(new_model, :features)
- for km in known_models
- eqs_k = getfield(km, :equations)
- recipe_k = getfield(km, :recipe)
- features_k = getfield(km, :features)
- for t in distance_types
- val = if t == "edit_distance_recipe"
- edit_distance_recipe(recipe_new, recipe_k)
- elseif t == "set_distance_equations" || t == "set_distance_cos"
- set_distance_equations(eqs_new, eqs_k; metric=:cosine)
- elseif t == "set_distance_jac"
- set_distance_equations(eqs_new, eqs_k; metric=:jaccard)
- elseif t == "set_distance_l1"
- set_distance_equations(eqs_new, eqs_k; metric=:l1)
- elseif t == "edit_distance_norm"
- edit_distance_equations_rhs(eqs_new, eqs_k; normalize=true)
- elseif t == "edit_distance_equations" || t == "edit_distance"
- edit_distance_equations_rhs(eqs_new, eqs_k; normalize=false)
- elseif t == "geometric_distance"
- geometric_distance(eqs_new, eqs_k)
- elseif t == "feature_distance"
- hamming_distance(features_new, features_k)
- elseif t == "combined_distance_editcos"
- combined_distance_editcos(eqs_new, eqs_k)
- else
- error("Unknown distance type: $t")
- end
- push!(cols[t], val)
- end
- end
- return (; (Symbol(d) => cols[d] for d in distance_types)...)
- end
distance_measures.jl at commit 6001d08, under MIT · at the source
Overview
- Department of Knowledge Technologies, Jožef Stefan Institute, Ljubljana, Slovenia
- Jožef Stefan International Postgraduate School, Ljubljana, Slovenia
- Department of Mathematics, Faculty of Mathematics and Physics, University of Ljubljana, Ljubljana, Slovenia
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
6001d08d033ca05c36517b5f59cde58156cfe93e, 21 September 2026Availability: 1 check, the latest on 27 September 2026: the link answers
- 27 September 2026: the link answers
83 files
- examples/
example1_settings.jl , Julia, 41 lines - examples/
example2_simulation.jl , Julia, 85 lines - examples/
example3_grammar_samplin , Julia, 61 linesg.jl - examples/
example4a_optimization_o , Julia, 67 linesf_canonical_model.jl - examples/
example4b_optimization_o , Julia, 77 linesf_sampled_model.jl - examples/
example4c_optimization_o , Julia, 84 linesf_two_nodes.jl - examples/
example5_hyperparam_opti , Julia, 70 linesmization.jl - models/
arm.jl , Julia, 85 lines, 1 match - models/
do.jl , Julia, 48 lines - models/
fhn.jl , Julia, 48 lines - models/
ho.jl , Julia, 56 lines - models/
jr.jl , Julia, 71 lines - models/
lb.jl , Julia, 119 lines, 1 match - models/
lw.jl , Julia, 108 lines - models/
mdf.jl , Julia, 111 lines, 1 match - models/
mpr.jl , Julia, 97 lines - models/
rrw.jl , Julia, 101 lines - models/
stl.jl , Julia, 44 lines - models/
utils_plot.jl , Julia, 109 lines - models/
vdp.jl , Julia, 43 lines - models/
w.jl , Julia, 84 lines - models/
wc.jl , Julia, 55 lines, 1 match - models/
ww.jl , Julia, 210 lines - models/
wwr.jl , Julia, 61 lines - src/
ENEEGMA.jl , Julia, 213 lines, 1 match - src/
analyze/ , Julia, 86 lines, 2 matchesclustering.jl - src/
analyze/ , Julia, 106 linescomplexity_measures.jl - src/
analyze/ , Julia, 387 lines, 2 matchesdistance_measures.jl - src/
build/ , Julia, 888 linesbuild_network.jl - src/
build/ , Julia, 642 linesbuild_node.jl - src/
build/ , Julia, 167 linesbuild_population.jl - src/
build/ , Julia, 504 linesbuild_utils.jl - src/
build/ , Julia, 1,488 linescanonical_node_models.jl - src/
build/ , Julia, 334 linesconnectivity_functions.j l - src/
build/ , Julia, 882 linesconnectivity_motifs.jl - src/
build/ , Julia, 792 linesinput_dynamics.jl - src/
build/ , Julia, 136 linesoutput_dynamics.jl - src/
grammar/ , Julia, 762 lines, 1 matchgrammar.jl - src/
grammar/ , Julia, 139 linesgrammar_utils.jl - src/
grammar/ , Julia, 74 lines, 1 matchknown_models_parse_trees .jl - src/
optimize/ , Julia, 884 linesdata_preparation.jl - src/
optimize/ , Julia, 350 linesevaluation.jl - src/
optimize/ , Julia, 219 lineshyperparameter_sweep.jl - src/
optimize/ , Julia, 1,468 lineslosses.jl - src/
optimize/ , Julia, 483 linesoptimization_utils.jl - src/
optimize/ , Julia, 673 lines, 1 matchoptimize_network.jl - src/
optimize/ , Julia, 389 linesphase_optimization_plots .jl - src/
optimize/ , Julia, 553 linesreparametrization.jl - src/
optimize/ , Julia, 1,466 linessave_optimization_result s.jl - src/
simulate/ , Julia, 214 linessave_simulation_results. jl - src/
simulate/ , Julia, 505 lines, 1 matchsimulate_network.jl - src/
types/ , Julia, 8 linesabstract_types.jl - src/
types/ , Julia, 709 lines, 1 matchbounds.jl - src/
types/ , Julia, 154 linesdata.jl - src/
types/ , Julia, 394 linesnetwork_types.jl - src/
types/ , Julia, 117 linesoptimization_types.jl - src/
types/ , Julia, 1,317 lines, 1 matchparams.jl - src/
types/ , Julia, 1,666 linessettings.jl - src/
types/ , Julia, 686 linesvariables.jl - src/
utils/ , Julia, 210 linesextract_brain_source.jl - src/
utils/ , Julia, 1,265 linesio.jl - src/
utils/ , Julia, 1,112 lines, 1 matchspectral_transforms.jl - src/
utils/ , Julia, 266 linesutils.jl - src/
utils/ , Julia, 439 linesvisualization.jl - test/
bound_adaptation_tests.j , Julia, 81 linesl - test/
canonical_stability_test , Julia, 81 liness.jl - test/
cmaes_callback_alignment , Julia, 25 lines_tests.jl - test/
delay_tests.jl , Julia, 121 lines - test/
grammar_brain_source_tes , Julia, 152 linests.jl - test/
internode_coupling_fallb , Julia, 145 linesack_tests.jl - test/
measurement_noise_bands_ , Julia, 20 linestests.jl - test/
mpr_tests.jl , Julia, 30 lines - test/
phase_dynamics_tests.jl , Julia, 217 lines - test/
problem_isolation_tests. , Julia, 37 linesjl - test/
psd_preprocessing_tests. , Julia, 229 linesjl - test/
runtests.jl , Julia, 222 lines - test/
settings_serialization_t , Julia, 26 linesests.jl - test/
spectral_roi_settings_te , Julia, 160 linessts.jl - test/
test_examples_subprocess , Julia, 87 lines.jl - test/
transient_handling_tests , Julia, 46 lines.jl - test_loss_functions.jl, Julia, 167 lines
- LICENSE, License, 21 lines
- README.md, Text, 148 lines
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://
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://
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/
url = {https://
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/
VL - 22
IS - 8
SP - e1014222
SN - 1553-734X
PB - PLOS
DO - 10.1371/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.1371/
"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":
"volume": "22",
"issue": "8",
"page": "e1014222",
"DOI": "10.1371/
"PMID": "42561039",
"PMCID": "PMC13460749",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://
"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: eLifeIn 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 biologyIn 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: eLifeIn 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 applicationsIn 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 biologyIn 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 biologyIn common: computational, 11 references
- [8] doi:10.1038/s41467-025-64470-3 [code]
- Modeling macroscopic brain dynamics with brain-inspired computing architecture.Journal: Nature communicationsIn common: computational, 10 references
- [9] doi:10.1523/eneuro.0379-25.2026 [code]
- Next-Generation Neural Mass Models Reproduce Features of Speech Processing.Journal: eNeuroIn 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 biologyIn 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.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 1 repository of the authors' code, each at its verified commit and with its license, 81 scripts, and 16 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:599bef02eb078e34…
Add the badge to the code's README
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 -->
[](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:endHTML
<!-- 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.
