dataesr/scientific-paragraphs-categorization huggingface dataset:
In all, these five themes were the most frequent, respectively, 22%, 19%, 17%, 13%, and 12%. All these remarks show the importance of the delineation strategy in building a bibliometric corpus. Moreover, it is clear that conducting bibliometric analysis requires considerable support of experts in the scientific themes investigated, since relying on wcs alone is not sufficient to delineate a relevant bibliometric corpus. Consequently, for us, the methodology kept to establish Fusion corpus is the most appropriate for identifying a "core" literature dataset on grain-legumes whose records can be classified by relevant themes (see also Table  A3 ). Notwithstanding, some statistics presented in the Section 3, were also calculated on the datasets Species1, -2, and -3, to be compared to the ones established on Fusion corpus.
Funding: This work was supported by funding from the  European Union 's  Horizon 2020 research and innovation program  under grant agreement No. 727672-LEGVALUE (Fostering sustainable legume-based farming systems and agri-feed and food chains in the EU); from the  Agence Nationale de la Recherche (ANR)  under grant number  ANR-11-LABX-0066 ; and by the  French National Institute for Agricultural Research (INRA).
| Computational algorithms of adaptive learning We implemented, fitted, tested and simulated six learning algorithms, including model-free and model-based RL and DL algorithms, with ad hoc parameters (Table  1 ). The data set consisted of the aggregated sequence of all trials played by the 27 subjects with the same prerecorded opponents. The important parameters were the learning rate (a measure of how much weight was given to recent feedback with respect to older feedback) and the randomness of choice, embodied in the inverse temperature of the softmax function (a measure of degree of action selection randomness) for RL algorithms, and in the dispersion parameters for DL algorithms. The dispersion parameters could be specific to the upper or lower side of the preferred bid and to the previous trial outcome contingency.
This is a problem for algorithm fitting, and in particular, estimating 101 initial action values depletes all useful degrees of freedom during optimization. Therefore, either we simplified the initial action values using a three-parameter (as opposed to 101) density based on the Beta distribution (for RW-type algorithms; Figure  2b , upper left) or we simply used the first round bids as initial conditions (for DL-type algorithms; Figure  2b , upper right). Data were processed with code written in Python with the scientific computing packages Numpy (RRID:SCR_008633), Scipy (RRID:SCR_008058), Matplotlib (RRID:SCR_008624) and Pandas. Purpose-specific code was written to define the maximum likelihood functions used to estimate the parameters of the learning algorithms. The numerical optimizer employed was a bound-constrained version of the Broyden-Fletcher-Goldfarb-Shanno algorithm, a local search technique which approximates local curvature.
| Data acquisition The fMRI data were obtained using ascending interleaved slice acquisition with gradient echo T2*-weighted echo-planar imaging (EPI) sequence in a 3T Magnetom Verio equipped with a 32-channel head coil (Siemens; Erlangen, Germany). Scanning protocol parameters were as follows: TE = 30 ms; flip angle = 80°; TR = 2280 m; slice thickness = 3 mm; no gap; slice matrix = 64 × 64; number of axial slices = 35; FoV = 192 mm; and voxel resolution = 3x3x3. 7 mm. High-resolution structural MRI data acquisition used a T 1 -weighted MP-RAGE sequence. Parameters were as follows: TE = 2. 47 ms; flip angle = 9°; TR = 1900 ms; slice thickness = 0. 5 mm; slice matrix = 512 × 512 × 176; number of slices = 176; FoV = 256 mm; and voxel resolution = 0. 508 × 0. 508 × 1 mm. These data were used for anatomical localization.
, 2004; Bartra et al. , 2013; Rilling, Sanfey, Aronson, Nystrom, & Cohen, 2004; Carter, Bowling, Reeck, & Huettel, 2012) , in internal representation of the number line and manipulation of arithmetic objects  (Dehaene, Molko, Cohen, & Wilson, 2004; Dehaene, Piazza, Pinel, & Cohen, 2003). These ROIs were orbitofrontal cortex, frontopolar and dorsolateral prefrontal cortex, anterior cingulate cortex, medial prefrontal cortex and temporo-parietal junction. Cluster-defining thresholds for all types of activity inference were appropriately set at p = 0. 001  (Eklund et al. , 2016; Flandin & Friston, 2019). Brain regions are displayed on a standard MNI template. All clusters from all figures are listed in Tables 2, 3 and 4. Thresholded cluster edges are indicated with black contour lines. Activation maps were dual-coded  (Allen, Erhardt, & Calhoun, 2012) , where significance level and effect size were represented by means of colour saturation and hue, respectively, with MATLAB code from  Zandbelt (2017).
To localize potential brain regions involved in the computation of the economic transactions, we assessed on a trial-by-trial basis the correlations between neural data and model proxy variables. The data set comprising all the game sequences from all subjects was used to fit the parameters of each learning algorithm. The fitting process was informed by plausible assumptions about the players strategies, such as initializing prior bid values (see section "Computational algorithms of adaptive learning" for details). We selected the best algorithm based on BIC scores. Then, we derived time series of expected values (PBV) and prediction error (DS, pseudo-RPE) signals from each of the learning algorithms by making each of the artificial bidding agents to enact human subjects behaviour. This entailed pitting the artificial bidders against the same sequences of stimuli that the human subjects played against, and in each trial computing the proxy variables (PBV, pseudo-RPE, DS) furnished by their underlying learning algorithm, conditioned on the fact that they selected the same bids as the human subject they were enacting.
We standardized all algorithm proxy variables as z-scores across subjects before entering them as parametric regressors in the design matrix. In the group-level analysis, we used this analysis to link between-subject differences to activations  (Haruno et al. , 2004). Finally, a neural model comparison routine based on a SPM Bayesian model selection module was performed on anatomical ROIs encompassing striatum and inferior posterior parietal cortex. To assess the goodness of fit of both DL and RL algorithms to neural activity, we defined GLMs in OUTCOME, including either DS or RPE parametric modulators, respectively, and then estimated them using Bayesian statistics, which provided a measure of the evidence of the model for each subject. Log evidence was then fed to a BMS random effect analysis  (Palminteri et al.
I G U R E 2 RL-and DL-type algorithms comparison. (a) Normal form (top centre) of a one seller versus one buyer (NC market) game: matrix cell colours represent the buyer's payoff. The buyer holds an estimate of the (possibly varying) seller's ask price (horizontal fuzzy white stripe) and tries to maximize profit by choosing the lowest possible bid that does not fall in a cell of the zeroprofit yielding upper right triangle. (b) Simulations enacting bidding behaviour of learning algorithms. Artificial bidders (left column: best-fitting DL algorithm; right column: best-fitting RL algorithm) were pitted against the subjects of the prerecorded dataset for 29 sessions and their preferred bids averaged within each trial and market type. (Upper left) Estimated prior parametric action-value functions (using a Beta distribution with rescaled support and range) for each market type.
F I G U R E 2 RL-and DL-type algorithms comparison. (a) Normal form (top centre) of a one seller versus one buyer (NC market) game: matrix cell colours represent the buyer's payoff. The buyer holds an estimate of the (possibly varying) seller's ask price (horizontal fuzzy white stripe) and tries to maximize profit by choosing the lowest possible bid that does not fall in a cell of the zeroprofit yielding upper right triangle. (b) Simulations enacting bidding behaviour of learning algorithms. Artificial bidders (left column: best-fitting DL algorithm; right column: best-fitting RL algorithm) were pitted against the subjects of the prerecorded dataset for 29 sessions and their preferred bids averaged within each trial and market type. (Upper left) Estimated prior parametric action-value functions (using a Beta distribution with rescaled support and range) for each market type.
In this view, most of the research eorts have been devoted to phenology  (He et al. , 2009)  without an explicit spatial approach to measure spectral turnover in space and time. The aim of this paper is to present an innovative approach to calculate the temporal change of remotely sensed diversity. We will rst introduce the theoretical background of the diversity calculation in time and then provide an empirical example based on MODIS data, by also providing the complete R code (Appendix 1 or https://gitlab. com/danidr/temporal_rs_ biodiversity/blob/master/RocchiniEtAl_2019_slopes. R). Q = d ij × p i × p j (1) where d ij = pairwise distance between pixels attaining to reectance val-ues i and j, p i = relative abundance of pixels attaining to reectance value i, and p j = relative abundance of pixels attaining to reectance value j.
Summarising, the average slope of the LOESS curve is expected to represent the amount of mean diversity along a temporal trend, while its coecient of variation would represent the temporal turnover in the spectral Rao's Q. Temporal diversity can thus be calculated pixel-wise in terms of both slope and coecient of variation and further plotted over the whole matrix / image. In order to implement an empirical example of the method being proposed, we made use of the free set of Rao's Q data based on MODIS NDVI images at a resolution of 5km provided in  Rocchini et al. (2018). A sketch of the original MODIS NDVI input set is provided in Appendix 3. In order to rely on a high complexity landscape we decided to focus on the italian peninsula, which guarantees a high ecological gradient from the sea to high.
, 2014) , our approach might represent a benchmark for modelling the variability in space and time of diversity at multiple spatial scales. It is far beyond the aim of this paper to test the sensitivity of the method to dierent spatial grains and spectral resolutions, but since it is based on pixel distances and relative abundance we expect that it can be applied to any kind of multi-or hyper-volumes like multi-or hyper-spectral images at dierent spatial and spectral resolutions from high (e. g. Quickbird, Ikonos) to medium (e. g. Sentinel-2 or Landsat data) and low grains (like MODIS data in our case). Furthermore, our method might help measuring not only spatial variations in beta-diversity to be related directly to the eect of ecosystem dynamics  (Wang and Loreau, 2014) , but also supply a synthesis of temporal variations in beta-diversity thus implicitly incorporating such dynamcis.
g. in urban areas) a high environmental variability is not necessarily related to a high amount of biodiversity in the eld  (Ricotta et al. , 2010). However, in case of natural and seminatural areas, spectral variability might represent one of the main proxies of diversity  (Skidmore et al. , 2015; Schmeller et al. , 2017). Hence, in order to measure spatial and temporal changes in diversity, it could be coupled with additional variables such as: i) climatic predictors  (Zellweger et al. , 2019) , ii) soil properties  (Tuomisto et al. , 2003) , iii) topographical complexity  (Badgley et al. , 2017). Furthermore, in this manuscript we made use of a spectral index like the inter-annual NDVI as an example dataset to calculate spatial heterogeneity, as in Oindo and  Skidmore (2002)  or  Gillespie (2005)  and more recently  Feilhauer et al.
The open source code provided will guarantee the robustness and reproducibility of the method. In fact, we are expecting that such a code will be used by other researchers to further develop additional algorithms on temporal variability measurement from satellite images. From an ecological and operational point of view, for species inventorying maximisation in biodiversity protection, advocated by the Sustainable Development Goal 15 (halt biodiversity loss) and scientically proposed by  Rocchini et al. (2005)  and more recently reviewed by  Schmeller et al. (2017) , the temporal variability, together with the spatial one, could be benecial in order to plan more ecient conservation practices starting with those diversity hotspots detected in space and time by remote sensing techniques. Attempts have been made to measure the spatial sensitivity of the relation between species and spectral diversity  (Wang et al.
Acknowledgements Computational resources have been provided by the supercomputing facilities of the  Université catholique de Louvain (CISM/UCL ) and the  Consortium des Equipements de Calcul Intensif en Fédération Wallonie Bruxelles (CECI)  funded by the  Fond de la Recherche Scientique de Belgique (FRS-FNRS ). We thank two anonymous reviewers who provided useful insights on a previous version of this manuscript. DR was supported by the  H2020  project  ECOPOTENTIAL  (grant agreement  641762 ) and the  H2020 TRuStEE -Training on Remote Sensing for Ecosystem Modelling project  (grant agreement  721995 ).
High-performance multithreaded software often relies on optimized implementations of common abstract data types (ADTs) like counters, key-value stores, and queues, i. e. , concurrent objects. By using fine-grained and non-blocking mechanisms for efficient inter-thread synchronization, these implementations are vulnerable to violations of ADTconsistency which are difficult to detect: bugs can depend on specific combinations of method invocations and argument values, as well as rarely-occurring thread interleavings. Even given a bug-triggering interleaving, detection generally requires unintuitive test assertions to capture inconsistent combinations of invocation return values. In this work we describe the Violat tool for generating tests that witness violations to atomicity, or weaker consistency properties.
Violat generates tests according to a three-step pipeline. The first step, described in Sect. 3, enumerates test program schemas, i. e. , concise descriptions of programs as parallel sequences of invocations of the given concurrent object's methods. For example, Fig. 2  lists several test schemas for Java's Concurren-tHashMap. The second step, described in Sect. 4, annotates each schema with a set of expected outcomes, i. e. , the combinations of return values among the given schema's invocations which are admitted according to the given object's ADT specification. The final step, described in Sect. 5, translates each schema into a self-contained 1  Java class. Technically, to guide the enumeration of schemas and calculation of outcomes, Violat requires a specification of the given concurrent object, describing constructor and method signatures.
To see this, consider any outcome y admitted by some execution of a program with arbitrarily-complex control and data flow in which methods are invoked with argument values x, collectively. The schema in which each thread invokes the same methods of a thread of the original program with literal values x, collectively, is guaranteed to admit the same outcome y. For a given concurrent object, Violat enumerates schemas according to a few configurable parameters, including bounds on the number of threads, invocations, and (primitive) values. By default, Violat generates schemas with exactly 2 threads, between 3 and 6 invocations, and exactly 2 values. While our initial implementation enumerated schemas systematically according to a welldefined order, empirically we found that this strategy spends too much time in neighborhoods of uninteresting schemas, i.
Note that while the manifestation of a given concurrency bug can, in principle, rely on large bounds on threads, invocations, and values, recent studies demonstrate that the majority (96%) can be reproduced with just 2 threads  [25]. Furthermore, while our current implementation adheres to the simple notion of schema in which all threads are execute in parallel, Violat can easily be extended to handle a more complex notion of schema in which threads are partially ordered, thus capturing arbitrary program synchronization. Nevertheless, this simple notion seems effective at exposing violations without requiring additional synchronization -see Emmi and Enea [12, Section 5. 2].
Computing Expected Outcomes To capture violations to observational refinement, Violat computes the set of expected outcomes, i. e. , those admitted by a given concurrent object's abstract data type (ADT), for each program schema. Violat essentially follows the approach of Line-Up  [4]  by computing expected outcomes from sequential executions of the given implementation. While this approach assumes that the sequential behavior of a given implementation does adhere to its implicit ADT specification -and that the outcomes of concurrent executions are also outcomes of sequential executions -there is typically no practical alternative, since behavioral ADT specifications are rarely provided. Violat computes the expected outcomes of a given schema once, by enumerating all possible shuffles of threads' invocations, and recording the return values of each shuffle when executed by the given implementation.
For instance, there are 10 ways to shuffle the threads of the schema { get(1); containsValue(1) } || { put(1,1); put(0,1); put(1,0) } from Fig. 2 , including the sequence get(1); put(1,1); put(0,1); put(1,0); containsValue  (1). Executing Java's ConcurrentHashMap on this shuffle yields the values null, null, null, 1, and true, respectively. To construct the generated outcome, Violat reorders the return values according to the textual order of their corresponding invocations in the given schema; since containsValue is second in this order, after get, the generated outcome is null, true, null, null, 1. Among the 10 possible shuffles of this schema, there are only four unique outcomes -shown later in Figs. 3  and 4. Code generation for jcstress similar, but conforms to the tool's idiomatic test format using decorators, and built-in thread and outcome management.
Code Generation and Back-End Integrations Once schemas are annotated with expected outcomes, the translation to actual test programs is fairly straightforward. Note that until this point, Violat is mainly agnostic to the underlying platform for which tests are being generated. The only exception is in computing the expected outcomes for schema linearizations, which executes the given concurrent object implementation as a stand-in oracle for its implicit ADT specification. Figure  3  lists a simplification of the code generated for the containsValue schema of Fig. 2. The test program initializes a concurrent-object instance and a hash table of expected outcomes, then runs the schema's threads in parallel, recording the results of each invocation, and checks, after threads complete, whether the recorded outcome is expected.
To avoid added inter-thread interference and the masking of potential weak-memory effects, each recorded result is isolated to a distinct cache line via Java's contended decorator. The actual generated code also includes exception handling, elided here for brevity. Our current implementation of Violat integrates with two analysis back-ends: the Java Concurrency Stress testing tool  [42]  (jcstress) and Java Pathfinder  [47]. Figure  4  demonstrates the results of each tool on the code generated from the containsValue schema of Fig. 2. Each tool observes executions with the 4 expected outcomes, as well as executions yielding an outcome that Violat does not predict, thus signaling a violation to observational refinement (and atomicity). Java Pathfinder explores 18 program paths in a few seconds -achieving exhaustiveness via partial-order reduction  [16]  -while jcstress explores nearly 4 million executions in 1 s, observing the unpredicted outcome only twice.
Usage Violat is implemented as a Node. js command-line application, available from GitHub and npm. 2  Its basic functionality is provided by the command: $ violat-validator ConcurrentHashMap. json. violation discovered ---{ put(0,1); size(); contains(1) } || { put(0,0); put(1,1) } --outcome OK frequency -  --------------------------------  reporting violations among 100 generated programs. User-provided classes, individual schemas, program limits, and particular back-ends can also be specified: $ violat-validator MyConcurrentHashMap. json \ --jar MyCollections. jar \ --schema "{get(1); containsValue(1)} || {put(1,1); put(0,1); put(1,0)}" \ --max-programs 1000 \ --tester "Java Pathfinder" A full selection of parameters is available from the usage instructions: $ violat-validator --help.
Field Programmable Gate Array (FPGA) draws a significant attention from both industry and academia by accelerating computationally expensive applications and achieving low power consumption. FPGAs are interesting due to the flexibility and reconfigurabiltiy of their device. Cloud computing becomes a major trend towards infrastructure and computing resources dematerialization. It provides "unlimited" storage capacities and a large number of data and applications that make collaboration easier between multiple (not domain specific) designers. Many papers in the literature have surveyed Cloud and FPGA separately and, more precisely, their services and challenges. e acceleration of applications by FPGA and the unlimited capacities of the cloud are expected to be more and more pervasive. As more and more FPGA are being deployed in traditional cloud, it is appropriate to clarify what is the cloud FPGA and which drawbacks of using FPGA in local are resolved.
ese resources can be dynamically scalable making possible to meet the performance objective required by applications. Nevertheless, the cloud involves various issues to be resolved  [7] [8] [9] : (i) the increase of power over a cluster of servers, (ii) the varying response times, (iii) the security and privacy of data, and (iv) the standardizing of cloud technology. FPGA can respond of the answer. In this paper, we present a survey of cloud FPGA. Our aim is to provide a better understanding of the current research issues in this emerging field. Several states of the art present cloud computing applications that have implemented FPGA as common hardware in data centers to accelerate remote applications  [10] [11] [12]. Some surveys focus on the virtualization of FPGA in cloud  [13] [14] [15]  to provide an abstraction of the used FPGA hardware.
Amazon uses FPGA instances to accelerate some tasks ranging from analytics and machine learning to databases and network virtualization. e Amazon F1 instance achieves 10x better cost efficiency than Amazon's CPU Elastic Cache  [32]. e CAPI solution from IBM is similar to that from Amazon; it deploys the Xeon processor with FPGA in the same package  [33]. Microsoft released the Catapult project in 2014  [34, 35]  which deployed one Altera Stratix vFPGA per CPU. Microsoft connects FPGAs directly to the network but does not make them directly accessible and programmable by hardware designers. Catapult is difficult to be adapted to different applications. e target application accelerates the Bing web search engine with achieving an improvement of 95% in e second approach considers FPGA as a standalone disaggregated component  [36]  independent from the CPU.