dataesr/scientific-paragraphs-categorization huggingface dataset:
The generated model elements are saved in the default XML-based serialization (blue). The NeuroML core tools (orange) include modules to import model descriptions expressed in the XML serialization, and supports multiple options for how simulators can execute these models (green). These include native execution of the NeuroML models by core simulators (  1 ) and others such as EDEN (2) and generation of helper Python scripts allowing direct importation of the NeuroML model by simulators which support this (3). For other simulators, the fully expanded LEMS description of the models can be generated, which can be mapped to simulator specific formats to generate scripts to run in the target simulators (4). Finally, a number of other standardized formats are supported (5), to which the loaded model can be mapped.
Visualizing/analyzing NeuroML models Multiple visualization, inspection, and analysis tools are available in the NeuroML software ecosystem. Since NeuroML models have a fixed, well defined structure, the core NeuroML libraries can extract all information from their descriptions. This information can be used by modelers and their programs/tools to run automated programmatic analyses on models. pyNeuroML includes a range of ready-made inspection utilities for users (Box 1) that can be used via Python scripts, interactive Jupyter Notebooks, and command line tools. Examining the structure of cell and network models with 2D and 3D views is important for manual validation and to compare them to their biological counterparts. Graphical views of cell model morphology and the 3-dimensional network layout (Fig.
The graphical applications included in the NeuroML ecosystem (e. g. neuroConstruct, NeuroML-DB, OSB (v1 4  and v2), NetPyNE, and Arbor-GUI) also provide many of their own analysis and visualization functions. OSBv1, for example, supports automated 3D visualization of networks and cell morphologies, network connectivity graphs and metrics, and advanced model inspection features  (Gleeson et al. , 2019)  (Fig. 7b ). On OSBv2, NetPyNE provides advanced graphical plotting and analysis facilities (Fig. 7c ). A complete JupyterLab 5  interface is also included in OSBv2 for Python scripting, allowing interactive notebooks to be created and shared, mixing scripting and graphical elements, including those generated by pyNeuroML. NeuroML-DB also provides information on electrophysiology, morphology, and the simulation aspects of neuronal models, such as their computational complexity, i.
Simulating NeuroML models Users can simulate NeuroML models using a number of simulation "back ends" without making any changes to their models. This is because the NeuroML/LEMS descriptions of the models can be automatically translated into any number of simulator specific formats. pyNeuroML facilitates access to all available simulation options, both from the command line and using single function calls in Python scripts when using the API (Box 1). The simulation back ends can be classified into five broad categories (Fig. 5 ): 1. core NeuroML/LEMS simulation engines (reference implementations)   5. export to other standardized formats which may allow simulation/analysis in other packages. Having multiple strategies in place for supporting NeuroML gives more freedom to simulator developers to choose how much they wish to be involved with implementing and supporting NeuroML functionality in their applications, while maximizing the options available for end users.
The first category includes jLEMS, jNeuroML, and PyLEMS (Fig. 4 ). jLEMS serves as the reference implementation for the LEMS language, and as such it can simulate any model described in LEMS (not necessarily from neuroscience). When coupled with the LEMS definitions of NeuroML standard entity structure/dynamics, it can simulate most NeuroML models, though it does not currently support numerically solving the cable equation  (Rall, 1962) , which is required for multicompartmental neurons. jNeuroML bundles the NeuroML standard LEMS definitions, jLEMS and other functionality into a single package for ease of installation/usage. There is also a pure Python implementation of a LEMS interpreter, PyLEMS, which can be used in a similar way to jLEMS. The pyNeuroML package encapsulates all of these tools to give easy access (at both command line and in Python) to all of their functionality (Box 1).
NeuroML and other standards in computational neuroscience A number of other standards and formats exist to support computational modeling of neuronal systems. Whereas NeuroML is a modular, declarative simulator independent standard for biophysical neuronal modelling, PyNN  (Davison et al. , 2009)  and SONATA  (Dai et al. , 2020)  provide a procedural Python based simulator independent API and a framework for efficiently handling large scale network simulations, respectively. Even though there is some overlap in the functionality provided by these standards, they each target distinct use cases and have their own goals and features. The teams developing these standards work in concert to ensure that they remain interoperable with each other, frequently sharing methods and techniques  (Dai et al.
Note that inherited attributes are not re-listed in the complex type definition-the compulsory capacitance attribute, C, is inherited here from BaseCellMembPotCap. The NeuroMLv2 schema serves a number of critical functions. A variety of tools and libraries support the validation of files against XSD schema definitions. Therefore, the NeuroMLv2 schema enables the validation of model descriptions prior to simulation (Fig. 6 ). XSD schema definitions, as language independent data models, also allow the generation of APIs in different languages. More information on how APIs in different languages are generated using the NeuroMLv2 XSD schema definition is provided in later sections. The NeuroMLv2 XSD schema is also released and maintained as a versioned artifact, similar to the software packages.
LEMS ComponentType definitions The second part of the NeuroMLv2 standard consists of the corresponding LEMS ComponentType LEMS allows the definition of new model types referred to as ComponentTypes. These are formal descriptions of how a generic model element of that type behaves (the "dynamics"), independent of the specific set of parameters in any instance. To describe the dynamics, such descriptions must list any necessary parameters that are required, as well as the time-varying state variables. The dimensions of these parameters and state variables must be specified, and any expressions involving them must be dimensionally consistent. An instance of such a generic model is termed a Component, and can be instantiated from a ComponentType by providing the necessary parameters. One can can think of ComponentTypes as user defined data types similar to "classes" in many programming languages, and Components as "objects" of these types with particular sets of parameters.
add("ExplicitInput", target="%s[%i]" % (pop0. id, 0), input=pg. id, destination="synapses") Save (serialize) the model to a file XML is the default serialization of NeuroML, and all existing APIs can read and write the format (and it should be seen as a minimal requirement for new APIs to support XML). There is however an alternative HDF5 28  based serialization of NeuroML files which is supported by both libNeuroML and the Java API, org. neuroml. model 29. This format is based on an efficient representation of cell positions and connectivity data as HDF5 data sets, which can be serialized in compact binary format, and loaded into memory for optimized access (e. g. as numpy arrays in libNeuroML). This reduces the size of the saved files for large scale networks, and speeds up loading/writing models, eliminating the need to parse/generate large text files containing XML.
Simulating NeuroML models The model description shown in Fig. 10   As noted previously, NeuroML/LEMS model and simulation descriptions are machine readable and simulator independent. They can, therefore, be translated into specific formats for simulation on different simulation backends. The core tool for simulating NeuroML/LEMS models is jNeuroML, which is also made available to Python users via pyNeuroML. In addition to functions for programmatic access, jNeuroML and pyNeuroML also provide the jnml and pynml command line tools (Box 1). jNeuroML supports all five simulator engine categories (Fig. 5 ). To ensure replication and reproduction of studies, it is important to note the exact versions of software used in studies. For NeuroML and LEMS packages, archives of each release along with citations are published on Zenodo 36 to enable researchers to cite them in their work.
Acknowledgments We thank all the members of the NeuroML Community who have contributed to the development of the standard over the years, have added support for the language to their applications, or who have converted published models to NeuroML. We would particularly like to thank the following for contributions to the NeuroML Scientific Committee:  Upi Bhalla ,  Avrama Blackwell ,  Hugo Cornells ,  Robert McDougal ,  Lyle Graham ,  Cengiz Gunay  and  Michael Hines. The following have also contributed to developments related to the named tools/simulators/resources: EDEN - Mario Negrello  and  Christos Strydis ,  SONATA -Anton Arkhipov  and  Kael Dai ,  MOOSE -Subhasis Ray ,  NeuroML-DB -Justas Birgiolas ,  NeuroMorpho. Org -Giorgio Ascoli ,  N2A -Fred Rothganger ,  pyLEMS -Gautham Ganapathy ,  MDF -Manifest Chakalov , libNeuroML and  NeuroTune -Mike Vella ,  Open Source Brain -Matt Earnshaw ,  Adrian Quintana  and  Eugenio Piasini ,  SciUnit/NeuronUnit -Richard C Gerkin ,  Brian -Marcel Stimberg  and  Dominik Krzemi  ński,  Arbor -Nora Abi Akar ,  Thorsten Hater  and  Brent Huisman ,  BluePyOpt -Jaquier Aurélien Tristan  and  Werner van Geit , C++/MATLAB APIs - Jonathan Cooper.
We thank  Rokas Stanislavos ,  András Ecker ,  Jessica Dafflon ,  Ronaldo Nunes ,  Anuja Negi  and  Shayan Shafquat  for their work converting models to NeuroML format as part of the  Google Summer  of Code program. We also thank  Diccon Coyle  for feedback on the manuscript. Funding Funder Grant reference number Author Wellcome  212941   R. Angus Silver ,  Padraig Gleeson ,  Ankur Sinha   Wellcome 203048 ,  224499  R. Angus Silver Kavli Foundation   LS-2022-GR-40-2648 Padraig Gleeson  Engineering and Physical  EP/X011151/1   Padraig Gleeson Research Council NIH   MH081905   Sharon Crook   NIH EB014640   Sharon Crook   NIH MH106674   Sharon Crook EU Horizon Europe SEPTON  (Gr. Agr. No. 101094901 )  Sotirios Panagiotou.
Increased communitywide collaborations have also extended the software ecosystem well beyond the NeuroMLv2 tools developed by the core NeuroML team: additional simulators such as Brian (Stimberg et al. , 2019), NetPyNE (Dura-Bernal et al. , 2019), Arbor (Abi Akar et al. , 2019) and EDEN (Panagiotou et al. , 2022) all support NeuroMLv2. We have worked to ensure interoperability with other structured formats for model development in neuroscience such as PyNN (Davison et al. , 2009) and SONATA (Dai et al. , 2020). Platforms for collaboratively developing, visualizing, and sharing NeuroML models (Open Source Brain (OSB) (Gleeson et al. , 2019)) as well as a searchable database of NeuroML model components (NeuroML Database (NeuroML-DB) (Birgiolas et al. , 2023)) have been developed. These enhancements, driven by an ever expanding community, have helped NeuroMLv2 mature into a standard which has been officially endorsed by international organizations such as the INCF and COmputational.
NeuroMLFigure 5. 5 Figure5. Workflow showing how to create and simulate NeuroML models using Python. The Python API can be used to create models which can include elements built from scratch from the core NeuroML standard, re-use elements from previously created models, or create new components based on novel model definitions expressed in LEMS (red). The generated model elements are saved in the default XML-based serialization (blue). The NeuroML core tools (orange) include modules to import model descriptions expressed in the XML serialization, and supports multiple options for how simulators can execute these models (green). These include native execution of the NeuroML models by core simulators (1) and others such as EDEN (2) and generation of helper Python scripts allowing direct importation of the NeuroML model by simulators which support this (3).
NeuroML-DB aims to promote the uptake of standardized NeuroML models by providing a convenient location for archiving and exploration. It includes advanced database search functions, including ontology based search (Birgiolas et al. , 2015) , coupled with pre-computed analyses on models' electrophysiological and morphological properties, as well as their computational complexity (and indication of the relative speed of execution of different models). NeuroML's modular nature ensures that models and their components can be easily shared with others through standard code sharing resources. The simplest way of sharing NeuroML models and components is to share their Python descriptions or their XML serializations available through these resources. Indeed, it is straightforward to make Python descriptions or the XML serializations available via different file, code (GitHub, GitLab), model sharing (ModelDB (Migliore et al.
, 2003; McDougal et al. , 2017) ), and archival (Zenodo, Open Science Framework) platforms, just like any other code/data produced in scientific investigations. Complex models with many components, spanning multiple files, such as networks and neuronal models that reference multiple cell and ionic conductance definitions, can also be exported into a COMBINE archive (Bergmann et al. , 2014) , a zip file with a manifest that includes metadata about its contents. pyNeuroML includes functions to easily create COMBINE archives from NeuroML models and simulations (Box 1).
GitHub 22. 22 https://github. com/NeuroML/NeuroML2/tree/master/Schemas/NeuroML2 <xs:simpleType name="Nml2Quantity_none"> <!--For dimensionless parameters --> <xs:restriction base="xs:string"> <xs:pattern value="-?([0-9]*(\. [0-9]+)?)([eE]-?[0-9]+)?"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="Nml2Quantity_voltage"> <!--For params with dimension voltage --> <xs:restriction base="xs:string"> <xs:pattern value="-?([0-9]*(\. [0-9]+)?)([eE]-?[0-9]+)?[\s]*(V|mV)Hindmarsh Rose model is a simplified point cell model which captures complex firing patterns of single neurons, such as periodic and chaotic bursting.
NeuroML model description serialization <neuroml xmlns="http://www. neuroml. org/schema/neuroml2" xmlns:xs="http://www. w3. org/2001/XMLSchema" xmlns:xsi="http://www. w3. org/2001/XMLSchema-instance" xsi:schemaLocation="http://www. neuroml. org/schema/neuroml2 https://raw. github. com/NeuroML/NeuroML2/development/Schemas/NeuroML2/NeuroML_v2. 3. xsd" id="HindmarshRoseNeuron"> 20 https://neuroml. org/schema/neuroml2 21 https://www. w3. org/TR/xmlschema-1/ a.
Attention is a heterogeneous function theoretically divided into different systems. While functional magnetic resonance imaging (fMRI) has extensively characterized their functioning, the role of white matter in cognitive function has gained recent interest due to diffusion-weighted imaging advancements. However, most evidence relies on correlations between white matter properties and behavioral or cognitive measures. This study used a new method that combines the signal from distant voxels of fMRI images using the probability of structural connection given by high-resolution normative tractography. We analyzed three fMRI datasets with a visual perceptual task and three attentional manipulations: phasic alerting, N=18; spatial orienting, N=18; and executive attention, N=20. The phasic alerting network engaged temporal areas and their communication with frontal and parietal regions, with left hemisphere dominance.
In this vein, some recent developments have allowed the detection of task-related and resting-state white matter fMRI signals  (Gawryluk et al. , 2014; Gore et al. , 2019). However, while very promising, this approach needs more time and practice to be fully understood and generalized. Recently, new proposals have also tried to integrate functional and structural data. The functionnectome approach  (Nozais et al. , 2021)  projects the fMRI signal from grey matter voxels to the white matter, and weights the signal by the probability of structural connections, which are derived from 100 high-resolution DWI datasets. These new methods hold much promise to integrate function and structure to further understand core questions in the eld of cognitive neuroscience beyond localization of function, such as how do function and structure interact? Or how does structure support cognitive function? Indeed, since the very rst post-mortem anatomical dissections, the study of white matter has allowed the scienti c community to move from a more localizationist approach to a more associationist approach.
Datasets Three previously collected and published datasets were employed in this study for the alerting task (18 participants,  Chica et al. , 2016) , the orienting task (18 participants,  Chica et al. , 2013)  and the executive attention task (20 participants,  Martín-Signes et al. , 2019). Data was originally collected with the informed consent of the participants and with the approval of the Ethics Committee of the INSERM (France) and the University of Granada (Spain). Datasets were provided by the authors of the original studies and analyzed with their consent.
4-mm cubic axial slides, no interslice gap, ip angle = 75°, FOV = 220 mm, 245 volumes per run). High-resolution T1-weighted anatomical images were also collected. Note that DWI data from the participants' sample was not used in this study since the functionnectome employs a normative high-resolution tractography  (Nozais et al. , 2021). fMRI preprocessing Preprocessing routines and analyses were performed using FEAT (FSL, FMRIB's Software Library,  Woolrich et al. , 2001). Brain extraction was performed using BET  (Smith, 2002). Images were corrected for differences in timing of slice acquisition and were realigned to the middle volume by means of rigidbody transformation for motion correction using MCFLIRT  (Jenkinson et al. , 2002). Motion plots were visually inspected to discard those runs with excessive motion (i.
Functionnectome We applied the functionnectome over the preprocessed data (for a detailed description of the method see  Nozais et al. , 2021). This method projects the signal from each voxel of the fMRI 4D volume using their probabilistic structural relationship. This probability map is composed by the structural connectivity between a given voxel and the rest of the brain, and it is derived from a normative high-resolution tractography (openly available at https://osf. io/5zqwg/). This process generates a new 4D volume projecting the fMRI signal from grey matter voxels to the white matter (weighted by the probability of connection). The functionnectome is open-source software available at http://www. bcblab. com.
The complexity of executive attention processes is re ected in the implication of a broad set of brain regions and white matter tracts connecting them, supporting its conceptualization as a network or networks. Our results (i. e. , involvement of the anterior thalamic radiation in the use of alerting signals, the superior thalamic radiation in orienting, and both thalamic radiations in executive attention) also converge with new evidence pointing at the importance of subcortical structures and their corticosubcortical connections in attention  (Alves et al. , 2022). The equivalence of our results with previous white matter ndings was somewhat less consistent. These discrepancies may be due to the relatively scarce literature on white matter, which is derived from studies with patients that link white matter lesions and cognitive de cits or from correlational studies employing DWI data and behavioral indices.
The use of federated learning allows incremental updates of the global model while new data from participating nodes (edge devices) come in, therefore achieving adaptivity. To support resource-constrained edge devices as local nodes, we propose novel lightweight transformer-based Autoencoders (AE) and a Variational Autoencoders (VAE) as building blocks of AnoFed. Moreover, we combine the proposed models with the Support Vector Data Description (SVDD)  (Tax and Duin, 2004)  with kernel density estimation for adaptive anomaly detection, for each global round of training in the federated setting. We also provide an eXplainable AI (XAI) module to trace the most critical part(s) of the ECG that is/are responsible for the detected anomaly. The key contributions of this paper are summarized as follows.
3. We design an XAI module to improve the explainability of the results of our framework, which helps enhance the trust of users in the proposed framework. 4. We trained and tested our proposed framework using two datasets from PhysioNet  (Goldberger et al. , 2000)  and a testbed with three edge devices and a global server, and the results show that our the framework could achieve the state-of-theart detection accuracy with the proven ability to automatically adapt to different distributions of the data. The rest of the paper is organized as follows. Section 2 presents related work and background. Section 3 presents the proposed framework. Sections 4 and 5 presents the experimental setup and performance analysis, respectively. Comparisons with some state-of-the-art methods and an analysis of the time complexity of the proposed framework are also included in Section 5.
If we denote the prior distribution of 𝑍 as 𝑝(𝑍), and consider that the input 𝑍 is sampled from the conditional likelihood 𝑝(𝑋|𝑍), then Bayes theorem gives the link between the prior 𝑝(𝑍), likelihood 𝑝(𝑋|𝑍), posterior distribution 𝑝(𝑍|𝑋), as shown in the following equation: 𝑝(𝑍|𝑋) = 𝑝(𝑋|𝑍) 𝑝(𝑋). ( 7 ) Given an input dataset 𝑋 defined by an unknown probability function 𝑝(𝑋) and a latent vector 𝑍, a VAE learns from the input to get a distribution 𝑝 𝜃 (𝑋), where 𝜃 is the set of the network parameters. Eq. (  8 ) represents the mathematical formulation of the unknown probability function. 𝑝(𝑋) = ∫ 𝑝(𝑋, 𝑍)𝑑𝑧. ( 8 ) Unfortunately, 𝑝(𝑋) is intractable distribution and hence we cannot compute it directly. However, by leveraging variational inference the problem of intractable distribution can be solved.
Support vector data description (SVDD) The Support Vector Data Description (SVDD)  (Tax and Duin, 2004 ) leverages a support vector classifier  (Chang and Lin, 2001)  to construct a spherical boundary around a given distribution of a dataset, with a minimum volume containing as many as possible data samples from the given data distribution. Let us suppose that {𝑋 𝑖 ∈ R 𝑑 } 𝑁 𝑖=1 are a set of 𝑁 𝑑-dimensional training samples, 𝑎 and 𝑅 denote the center and the radius of a sphere covering the training set, respectively. Huang et al. (2011)  formulated this goal as a constrained convex optimization problem, given as follow: min 𝑅,𝑎,𝜉 𝑖 𝐹 (𝑅, 𝑎, 𝜉 𝑖 ) = 𝑅 2 + 𝐶 ∑ 𝑖 𝜉 𝑖 , s. t. { ‖𝑋 𝑖 -𝑎‖ 2 ≤ 𝑅 2 + 𝜉 𝑖 , 𝜉 𝑖 ≥ 0, 𝑖 = 1, … , 𝑁, (13) where the slack variable 𝜉 𝑖 defines the possibility of anomalous (outliers) data in the given training data.
Dataset description To train and test the proposed framework AnoFed, we used a combination of two datasets from PhysioNet  (Goldberger et al. , 2000). For the anomaly class, we used the BIDMC Congestive Heart Failure Database. This database contains longer-term ECG recordings of severe congestive heart failures from 15 subjects, out of which 11 were men (aged 22 to 71), and 4 were women (aged 54 to 63). Further details about the data are available in  Goldberger et al. (2000). The data was pre-processed by extracting each heartbeat of equal length using interpolation, and the class values were obtained by automated annotations  (Chen et al. , 2015). For normal subjects, we use the Massachusetts Institute of Technology-Beth Israel Hospital (MIT-BIH) normal sinus rhythm  (Goldberger et al. , 2000).