dataesr/scientific-paragraphs-categorization huggingface dataset:
This would be expected for the spike propagation code because the mainly feedforward structure of the Mbody model lends itself better to parallelisation on GPUs with GeNN than the randomly recurrently connected COBAHH model. Inspection of the computation time used for neuron and synapse updates and synapse updates (spike propagation) revealed that for both models, but contrary to the CPU situation, a large percentage of computing time is typically spent for spike propagation when using a GPU.
Time for other tasks So far we have presented results for the core simulation time. As explained in the methods, Brian2GeNN has a substantial pipeline of tasks before and after the main simulation takes place. Figure  3  illustrates the essence of how the computation times necessary along this pipeline stack up. We defined four main phases of a Brian2GeNN run: "code generation and compilation", "synapse creation", "main simulation" and "overheads", which bundles smaller tasks such as transforming data formats between Brian 2 format and GeNN format, copying from and to the GPU and writing results to disk. For illustration we have used the data from the TITAN Xp card. The data in the 3 2 5 8 2 5 2 7 0 0 1 0 2 0 0 4 0 2 0 0 1 6 0 2 0 0 6 4 0 2 0 0 2 5 6 0 2 0 0 1 0 2 4 0 2 0 0 Model size (# neurons) Simulation time (relative to biological time) Mbody double precision 3 2 5 8 2 5 2 7 0 0 1 0 2 0 0 4 0 2 0 0 1 6 0 2 0 0 6 4 0 2 0 0 2 5 6 0 2 0 0 1 0 2 4 0 2 0 0 Model size (# neurons) Simulation time (relative to biological time) Mbody single precision 2 0 0 1 0 0 0 4 0 0 0 1 6 0 0 0 6 4 0 0 0 2 5 6 0 0 0 1 0 2 4 0 0 0 Model size (# neurons)   2 ).
To give a rough guide at which amount of biological time for any given model size it becomes viable to use Brian2GeNN we have calculated the minimum simulated biological time for which the overall runtime for Brian2GeNN is smaller than a 24 thread OpenMP solution (figure  4 ). For simulated biological time of 100s or more it is always faster to use Brian2GeNN, regardless of model size or employed GPU accelerator. For shorter simulated time it depends on the simulated model and the GPU. For example, simulating 10s biological time is perfectly viable on a V100 for the Mbody model at size 40,200 but would be slower on a K40c; or, simulating 10s biological time would not be viable for any of the tested GPUs for the COBAHH model at size 8,000 but viable 4 5 0 1 4 5 0 5 2 0 0 2 0 2 0 0 8 0 2 0 0 3 2 0 2 0 0 1 2 8 0 2 0 0 5 1 2 0 2 0 0 2 0 4 8 0 2 0 0 Model size (# neurons) 10 1 10 0 10 1 10 2 necessary biological runtime (s) Mbody 2 0 0 1 0 0 0 4 0 0 0 1 6 0 0 0 6 4 0 0 0 2 5 6 0 0 0 1 0 2 4 0 0 0 Model size (# neurons) necessary biological runtime (s) COBAHH Quadro K2200 (single) Tesla K40c (double) TITAN Xp (single) Tesla V100 (double) Figure  4 : Minimal biological runtime after which the total simulation time, including preparations such as code generation and compilation (cf.
Discussion In designing software for computational neuroscience, there are two seemingly conflicting requirements: for high performance and for flexibility. The ability to create new types of models is essential for research that goes beyond what is already known at the time that a simulator package is created. However, hand written code that implements particular models can be much more computationally efficient. This is particularly true in the case of GPU simulations, as it is difficult to make maximally efficient use of GPU resources. Consequently, almost all GPU-based simulators for spiking neural networks have not made it possible to easily create new user-defined neuron models  (Nageswaran et al. , 2009; Fidjeland and Shanahan, 2010; Mutch et al. , 2010; Hoang et al. , 2013; Bekolay et al.
, 2014). The exceptions are GeNN, the package Brian2CUDA  (Augustin et al. , 2018)  currently under development, and ANNarchy  (Vitay et al. , 2015) , which is discussed below. The technique of code generation allows us to solve this apparent conflict, and has been used by both the GeNN and Brian simulators  (Goodman, 2010; Yavuz et al. , 2016; Stimberg et al. , 2014). In the case of GeNN, when writing a new model users need to write only a very small section of generic C++ code that defines how the variables of a neuron model are updated, and this is then inserted into a detailed template that allows that model to be simulated efficiently on a GPU. Brian meanwhile allows users to write their model definition at an even higher level, as standard mathematical equations in a Python script. These are then automatically converted into low-level C++ code to be compiled and executed on a CPU.
In both cases, users write high level code (short snippets of C++ in the case of GeNN, or Python/mathematics in the case of Brian) and efficient low level code is automatically generated. Linking Brian and GeNN accomplishes two tasks. Firstly, it allows existing Brian users to make use of a GPU to run their simulations without any technical knowledge of GPUs (via GeNN). Secondly, it gives GeNN users a high level and feature packed interface (Brian and Python) to manage their simulations. GeNN was originally designed to be used at the C++ level, with network setup and simulation management handled by the user in C++, but not all computational neuroscientists are comfortable working at this level and there can be considerable savings in development time working at a higher level.
Related work The only other spiking neural network simulation package to allow for flexible model definition in a high level language, and for code to run on GPUs, is ANNarchy  (Vitay et al. , 2015). This simulator was originally designed to adapt a model definition syntax similar to Brian's to rate-coded networks (rather than spiking neural networks), and to make use of GPUs for high performance. It has subsequently been updated to allow for the definition of spiking neural networks as well as hybrid networks, and simulating spiking networks on the GPU is now provided as an experimental feature. In contrast to Brian2GeNN which supports all major operating systems, ANNarchy only supports running simulations on the GPU on Linux. As noted in  Brette and Goodman (2012) , on GPUs it is unlikely that there is a single best algorithm for spiking neural network simulation, but rather the best algorithm will depend on the model.
However, some features that are supported may also lead to slow code on the GPU. This is because efficient use of the GPU requires appropriate paralellisation strategies and specific memory access patterns, and for some features (particularly relating to backpropagation of information in synapses) it is very difficult to arrange data in memory so that it can be accessed efficiently for both, forward and backward propagation on the GPU  (Brette and Goodman, 2012). The very different scaling of runtimes in the COBA example for pre-and post-synaptic parallelisation strategies for synaptic updates in large model instances, as seen in figure  1 , is a very typical example of such phenomena. However, it is not straightforward to predict when problems of this kind will be significant. The Mbody example has STDP but because it is otherwise well suited for GeNN due to essentially feedforward connectivity for the majority of synapses and sparse firing, it speeds up well in Brian2GeNN.
An interface to generate CUDA code directly from a Brian script, called Brian2CUDA  (Augustin et al. , 2018) , is also under development, but has not yet been released. For Brian2GeNN itself, we are planning to expose more of the optimisation choices offered to direct users of GeNN to Brian2GeNN users, for instance per-synapse group choices for connectivity matrix representations (sparse, dense, ragged, bitmask) and parallelisation strategies (pre-or postsynaptic). We will also work on exposing the emerging on-GPU initialisation methods mentioned above and the heterogeneous synaptic delays that were recently introduced to GeNN.
Brian2GeNN Brian2GeNN makes use of the existing code generation facilities in the Brian and GeNN simulators. These code generation facilities differ in important aspects. The Brian simulator provides a comprehensive code generation framework that converts not only high-level descriptions of neural and synaptic models to executable code, but also extends this framework to model initialization including the generation of synapses according to high-level rules. In addition, the user code is written in Python, a language that is very accessible to researchers with a less technical background. However, the generated code is C++ code that runs only on the CPU, and therefore cannot make use of the computational power of GPU accelerators. GeNN's code generation framework on the other hand is focused more on organizing the code to run efficiently on highly parallel GPUs, leaving the task of defining the code for simulating the neural and synaptic model, and the details of how to run the overall simulation to the user.
This is completed in C++, which allows tight integration with other C++ based code, e. g. in the context of robotic controllers, but also makes writing a GeNN simulation relatively difficult for inexperienced programmers. The major advantage of using GeNN is its ability to generate efficient CUDA code that can be executed on a GPU to accelerate simulations. Brian2GeNN acts as a "glue" between Brian and GeNN, thereby combining the advantages of both simulators. It is built as an extension of Brian's code generation mechanism and can therefore be directly used from within a Brian script; by choosing the "GeNN device" (l. 2-3, figure 5 top), a standard Brian simulation is turned into a hybrid Brian/GeNN simulation. Such a script typically sets up the simulation components and then triggers the simulation of the network (figure  5  top and bottom left).
At this point, the code generation process is activated and generates, compiles and executes the target code. The results of this simulation are then written to disk by the executed code, enabling the Python code to access the requested results to analyze or plot them. The executable code (figure 5 bottom right) is jointly generated by Brian (blue boxes), Brian2GeNN (green boxes/arrows), and GeNN (red box) and executed partly on the CPU and partly on the GPU. The initial steps, synapse creation and model initialization, are unchanged from Brian's default code generation process. However, since Brian and GeNN use different data structures to represent synapses, Brian2GeNN has to generate code to convert between the two formats. In addition, it copies all the data to the GPU so that it can be used during the simulation run.
The main simulation loop delegates the core of the simulation, the dynamic update of neuronal and synaptic state variables as well as the propagation of synaptic events, to the code generated by the GeNN simulator, which executes on the GPU. After each time step, some of this data may be copied back from the GPU and converted to the Brian format so that it can be recorded by Brian's monitoring mechanism. After the end of the simulation run, Brian2GeNN takes care to copy all data back from the GPU and to convert it to the Brian format, so that Brian can store the results to disk and make them available for analysis in the Python script.
Data analysis Data were analyzed using SPSS version 17 (SPSS Inc. , Chicago, IL, USA) and Mplus software version 7. 0. 19 Preliminary analyses included the study of missing values, distribution of our data, and scale reliability. Scale reliability was assessed using McDonald's coefficient omega (ω). 20 Subsequently, we analyzed the factor structure of the questionnaires used in this study in order to provide evidence supporting their internal structure. The measurement model of SASMAT-METHER was tested comparing a series of nested measurement models: Model 1 was based on an exploratory structural equation modeling (ESEM) approach where items were allowed to load into three correlated factors including cross-loadings;  21  Model 2 assumed a confirmatory factor analysis (CFA) structure where each item loaded into one of the three correlated factors and cross-loadings were fixed to zero; Model 3 was also based on a CFA approach and tested for a three uncorrelated factor structure (ie, correlations between factors were constrained to 0); and Model In this study, all measurement models and the structural model were estimated using the weighted least squares mean and variance adjusted (WLSMV) estimator, an estimator that is appropriate for Likert scales.
27 he comparison between SASMAT-METHER nested measurement models was based on χ 2 along with CFI, TLI, and RMSEA differences. According to previous research, the more parsimonious model should be selected only when changes in CFI are ,0. 01 and increases in RMSEA are ,0. 015. 28, 29 Changes in the TLI were evaluated following the guidelines associated with CFI changes. 30 hen, in order to provide evidence supporting the discriminant validity of the latent factors that would be included within the structural model, we tested the correlations between these factors. Correlation coefficients were interpreted using Zhu's criterion: 31 0-0. 19 =no correlation, 0. 20-0. 39 =low correlation, 0. 40-0. 59 =moderate correlation, 0. 60-0. 79 =moderately high correlation, and $0. 80 =high correlation. As a final step of our data analyses, we constructed an SEM to evaluate the relationship between SASMAT-METHER factors and basic interventions.
Specifically, it was hypothesized that all three SASMAT-METHER factors (ie, personal functioning and well-being, anti-addictive effect on heroin, and antiaddictive effect on other substances) would positively predict patients' perceptions of the basic interventions conducted at their methadone-treatment centers. The fit of the SEM to the data was assessed using the same criteria explained earlier, although these criteria should be treated with a degree of caution. 32.
Acknowledgments The authors are grateful to the patients who kindly participated in the study and to  Saiko Allende  and  Isabel Blásquiz  for their secretarial support. Funding for this study was provided by grants  PS09/01072  and  PI06/0531  from  Fondo de Investigación Sanitaria, Instituto de Salud Carlos III (Spanish Ministries of Economy and Competitiveness, and Health, Social Services and Equality). Funding sources had no role in the study design, collection, analysis or interpretation of the data, writing the manuscript, or the decision to submit the paper for publication.
Accuracy of Allan variance estimation The sample estimate given in Eq. (  13 ) (time-average) approximates the true value 1  from Eq. (  12 ) (average over process randomness) well, provided that the series is wide-sense stationary and has rapidly decreasing correlations 2   [25]. One can think of small correlations as a short memory of the process: substantial new information is gained with every sample, so that the estimate becomes increasingly accurate. To check the quality of our estimate, we examined the process of counter values (used to compute the variance) and their first differences (used to compute the Allan variance) in more detail. We collected the data from four different hardware configurations, i. e. Configurations 1 to 4 described earlier in this section. All projects used k = 30 000 periods of s 2 to set the counting time.
Implementation Language We implemented the procedure to estimate the min-entropy rate of a Markov chain in Python; to increase the speed, parts of the code were compiled to C by the Cython module. For computation, we used the Numpy library with double precision (64 bits). Algorithmic issues Computation of the transition matrix requires one pass on the data file. The value in Eq. (  26 ) is found by dynamic programming; namely, for every and every pair of states s , s we compute r(s , s , ) = min s1=s ,s2,. ,s -1 ,s =s k i=1 log 1 Ps k ,s k+1 where s 1 ,. , s -1 are different; dynamic programming is used to update values of r when changing from to + 1. Once we have these numbers, we can determine the value in Eq. (26). Because the formula assumes different states s 1 ,. , s we have that |S|.
We measured the number of periods of both clocks in this time interval. Finally, to make the comparison of values obtained using the external and embedded measurements more consistent, we measured the number of cycles of both clocks at the same time interval and normalized the resulting data according to the following equation: cnt = n 1 n 2 • k, ( 27 ) where n 1 represents the number of clock periods of s 1 and n 2 the number of clock periods of s 2 that appear during the same time interval determined by oscilloscope's time base. In our case, we used k = 30 000 to normalize oscilloscope measurements. Table  4  shows the results of external and internal measurements. The jitters of Osc 1 and Osc 2 were both measured by the oscilloscope. To compare these values with those obtained using the Allan variance according to Eq.
By combining Equations (  41 ) and (42) we obtain We used two standardized batteries of statistical tests alongside the method proposed in this article to evaluate the output of the TRNGs: Var 1 M M i=1 Z 2 i = 1 M 2   E Z 2 i -E(Z 2 i ) 2 + i =j E Z 2 i -E(Z 2 i ) Z 2 j -E(Z 2 j )   = O(p/M ). ( 43 • Markov chain min-entropy estimate. This method is explained in detail in Section 2. • German AIS 20/31 test suite from Procedure B, which is intended to test the output of the TRNG core. Entropy is estimated by the test T8 is the Shannon entropy per random bit. • American NIST 800-90B test suites for independent and identically distributed data (IID) and non-IID data. If data is detected to be IID, the min-entropy estimate of the IID test track is given. Otherwise, the non-IID entropy estimate is used.
Acknowledgments This work received funding from the  European Union 's  Horizon 2020 research and innovation programme  in the framework of the project  HECTOR (Hardware Enabled Crypto and Randomness)  under grant agreement No  644052. Maciej Skorski  also acknowledges funding from the  European Research Council (ERC)  under the European Union's  Horizon 2020 research and innovation programme  (grant agreement No  682815/TOCNeT ).
Erosion prevention and water purification Water purification and erosion prevention services were assessed using the software InVEST -Integrated Valuation of Ecosystem Services and Tradeoffs  (Natural Capital Project, 2015). InVEST is an open-source software that includes several spatially-explicit models to map and value different ES, from a local to a global scale (for a revision on ES modelling software please see  Bagstad et al. , 2013 and Olosutean, 2015). For erosion and water purification services, InVEST uses two main sets of parameters. The first parameter is a digital terrain model, used by InVEST to calculate slope or amount of draining cells in each cell. This digital terrain model was built using level contours, provided by the municipality, through ArcGIS contour interpolation adjusted for hydrographic correctness  (ESRI, 2015).
Nimis and Martellos, 2008)  was used as a surrogate of habitat quality. Tree diameter at breast height was measured to test if it influenced lichen metrics, but no significant relations were found (data not shown, p < 0. 05). Variogram analysis revealed a good spatial structure for both metrics, with a nugget effect of zero and a spatial continuity of 500 m for both. A spherical model without anisotropy was fitted to this experiment variogram and was used to interpolate both lichen metrics within the park using ordinary kriging, and then the average values were determined within each vegetation type.
Acknowledgements This work was supported by the following projects: i) Project promoted by the  Department for Environment, Climate, Energy and Mobility of the City Council of Almada ; ii) Portuguese national funds, through  FCT -Fundação para a Ciência e a Tecnologia  ( UID/ BIA/ 00329/2013 ); iii) Portuguese national funds, through  FCT-MCTES grant  ( SFRH/BPD/75425/2010 ); iv) GreenSurge- FP7  ( ENV. 2013. 6. 2-5 );v) BioVeins-BiodivERsA32015104. We thank two anonymous reviewers for their comments and suggestions that helped to improve the.
☆ This work was supported by the following projects: i) Project promoted by the  Department for Environment, Climate, Energy and Mobility of the City Council of Almada ; ii) Portuguese national funds, through  FCT -Fundação para a Ciência e a Tecnologia  ( UID/ BIA/00329/2013 ); iii) Portuguese national funds, through  FCT-MCTES grant  ( SFRH/BPD/ 75425/2010 ); iv) GreenSurge- FP7  ( ENV. 2013. 6. 2-5 );v)  BioVeins-BiodivERsA32015104.
Methods The clinical data were compiled by clinical geneticists and pediatricians (R. S, K. BA, K. M, and FZ. C). The patient's parents signed written informed consent to consultation and molecular studies for both diagnostic and research purposes and also for publication of the patient's pictures. Along this, parents give also their consent for participation in genetic testing in addition to their child. This work complies with the declaration of Helsinki (https://www. wma. net/policies-post/wma-declaration-of-helsinki-ethical-principles-for-medical-research-involving-human-subjects/) and with the ethical guidelines of the institutions involved. Genomic DNA of the patient and her parents was manually extracted from peripheral blood collected in EDTA tubes according to standard salting out methods and purified by QIAmp CDN kit (Qiagen).
NGS analysis A panel of 29 genes was designed using the online Sure Design software (Agilent Technologies). A predesigned Haloplex Noonan panel containing the genes PTPN11, SOS1, RAF1, KRAS, BRAF, NRAS, HRAS, MAP2K1, MAP2K2, SHOC2, CBL, SPRED1 and NF1 was used, to which were added other genes involved in RASopathies (the list of all analyzed genes can be provided on request). The size of the final target region was 232. 387kpb with 570 amplicons and the mean sequence coverage was 93. 73 at 20× priori 99. 41% coverage of the target region. The preparation of the libraries was performed using the Haloplex target enrichment system dedicated to Ion Torrent PGM. Massively parallel sequencing was performed on an Ion Torrent PGM (Thermo Fisher Scientific). Raw data generated by the PGM sequencer were processed by Torrent Suite Software v.
4 and aligned using TMAPv. 3. Sequence variants were identified using the Variant Caller tool from the Ion Torrent package using default "germline low stringency" parameters (min_co-v_each_strand: 0, min_variant_score: 10, min_allele_freq: 0. 1, snp_min_coverage: 6 snp and indel; strand_bias: 0. 98 snp and 0. 85 indel) then prioritized using the in-house software Varaft (http://varaft. eu) that includes Annovar  [26]  and UMP-Predictor  [27]. Variants not previously reported in healthy controls and classified as pathogenic were evaluated for sequencing depth and visually inspected using the Integrative Genomic Viewer (IGV) before validation by Sanger Sequencing using the manufacturer's protocol for BigDye ® Terminator sequencing kits. Segregation analysis was performed in both parents by Sanger sequencing.
Results A total of 184 variants were detected across the 29 genes analyzed. Filtering these results using in silico software predictors of a mutation's impact such as UMD predictor, Mutation-taster, PolyPhen and others, whose algorithms are integrated into the Varaft software, issued only one heterozygous variant as potentially pathogenic: a heterozygous SNV in exon 7 of the RAF1 gene predicted to lead to a missense amino acid change (NM_002880: c. 788 T > G, p. Val263Gly) (Fig. 2a ). This was retained since it was correlated to the phenotypic description of the patient and was already reported  [29]. We confirmed this alteration in the patient by Sanger Sequencing. The analysis of transmission in the patients' parents confirmed that it occurred as de novo mutation (Fig. 2b ). Presence of a de novo exon 4-10 deletion of IKBKG gene was demonstrated by PCR amplification in the proband (Fig.