dataesr/scientific-paragraphs-categorization huggingface dataset:
Fourth, we can also combine data on supply with demand. Further analyses on Mintel data can identify food products that attain the most sustainability goals as regards their ingredients and also the analysis of claims associated to products. But unless they are purchased by consumers and remain on the market long-term, these products are unlikely to have a significant impact on sustainability transition. Analysing real-world consumption of these products launched on the market is also essential to understand how demand is receptive or not to sustainable products, and identify the key enablers and barriers to any long-term success of these products in the marketplace. To do so, Kantar World Panel could be used: monthly purchases are declared by a panel of consumers in several countries 8. But the ingredient list of the food products purchased are not reported in this database.
Therefore, only analysis based on the "name of the product" could help to identify well-known products using legumes. Otherwise methods must be invested to match those data with others informing on the ingredient list of the products purchased (for instance, through the barcode identified in Mintel data) in order to retreive the various legume species. To our knowledge, no such study has been conducted on legume consumption from Kantar data or other data based on the purchases of consumers. We conclude that dashboards resulting from such deep analysis, both of the supply and the demand, are essential to provide primary information on the evolution of food markets in order to assess the speed of transition towards societal expectations, evaluate how demand meets supply in sustainability challenges, and conduct critical analysis on how to define sustainable products in link with agroecosystems.
Acknowledgements The research was supported by the  European Union 's  Horizon 2020 research and innovation program  under grant agreement No  727672  for the LEGVALUE (Fostering sustainable legumebased farming systems and agrifeed and food chains in the EU) project  2017-2021 ; the  PPR   SPECIFICS  project ( ANR-20-PCPA-0008 ) funded by the " Growing and Protecting crops Differently "  French Priority Research Program  ( PPR-CPA ), part of the national investment plan operated by the  French National Research Agency (ANR) ; the  Occitanie Region  ( KING  project). Thanks to  Alice Thomson-Thibault  for her English editing of the manuscript.
Data Processing and Analysis Data were analyzed using ROSALIND TM (https://rosalind. onramp. bio/), with a HyperScale architecture developed by ROSALIND, Inc. (San Diego, CA, USA). Read Distribution percentages, identity heatmaps, and sample Multidimensional Scaling (MDS) plots were generated as part of the QC step. Housekeeping probes used for normalization were selected based on the geNorm algorithm, as implemented in the NormqPCR R library. Fold changes and p-values were calculated using nCounter®Advanced Analysis 2. 0 User Manual. P-value adjustment was performed using the Benjamini-Hochberg method of estimating false discovery rates (FDR). Hypergeometric distribution was used to analyze the enrichment of pathways. The topGO R library was used to determine local similarities and dependencies between GO terms in order to perform Elim pruning correction.
Several database sources were referenced for enrichment analysis, including Reactome. Further analyses were performed and figures were generated with GraphPad Prism 9. 0. 0 and R v3. 6. 3, using RStudio v1. 2. 5033. Hierarchical clustering and heatmaps were generated with the pheatmap package. Volcano plots were obtained using the EnhancedVolcano package. Lastly, the correlation matrix was created with the corrplot package.
Fifty-five genes were significantly upregulated at diagnosis compared to paired relapse samples (FDR < 0. 05, |FC| > 1. 5), including CD274, ICOS, KLRG2, and CD163, which are mainly involved in immune escape mechanisms, and T-cell activation genes such Cancers 2022, 14, 4893 7 of 13 as GRZB, IL15, and IL1R2. Conversely, 79 genes were significantly upregulated at relapse compared to the paired diagnosis samples (FDR < 0. 05, |FC| > 1. 5) including CD81, LAG3, TGFB1, and IL32. Based on the REACTOME database, the upregulated genes at diagnosis were involved in innate immune response pathways, especially in the interleukin-1 (IL-1) signalling and MYD88 pathways (Figure  3b ). By contrast, relapse cHL samples showed a distinct immune contexture with upregulation of genes involved in antigen presentation and type I and II interferon signalling pathways, regulating both innate and adaptive immune responses (Figure  3b ).
presented a nodular sclerosis pattern at diagnosis but a mixed-cellularity pattern at relapse. We observed gene expression variations in 134 immune-related genes between diagnosis and relapse, reflecting the dynamics of the immune TME (Figure  3a  and Supplementary Table  S2 ). Fifty-five genes were significantly upregulated at diagnosis compared to paired relapse samples (FDR < 0. 05, |FC| > 1. 5), including CD274, ICOS, KLRG2, and CD163, which are mainly involved in immune escape mechanisms, and T-cell activation genes such as GRZB, IL15, and IL1R2. Conversely, 79 genes were significantly upregulated at relapse compared to the paired diagnosis samples (FDR < 0. 05, |FC| > 1. 5) including CD81, LAG3, TGFB1, and IL32. Based on the REACTOME database, the upregulated genes at diagnosis were involved in innate immune response pathways, especially in the interleukin-1 (IL-1) signalling and MYD88 pathways (Figure  3b ).
45 n engineering design approach reduces risks and achieves the necessary engineering limitations. 46 To research mechanical systems, measurements of nonlethal projectile holders are required. Therefore, we used two licensed programs, engineering and construction packages. The first program is Solid-Works,  47  with which we designed the solid 3D geometric shapes of the nonlethal projectiles holder part are given in Table  S3. We are using a Dassault Systems engineering computer application. We address engineering challenges associated with optimizing, compiling, and verifying safety-critical integrated software. The objective is to provide efficient and dependable manufacturing. 48 We relied on the XM1006 projectile as a reference in our study. The second program is CATIA design,  49  with the help of the 3D experience platform, where we develop several products with all of the innovative stakeholders and clients on our platform.
Developing nonlethal projectiles is more effective when predicting adequate information about operational engagement distances. The current work focuses on the issue of safety, i. e. , the minimum requirements when using nonlethal missiles to avoid serious injury. Additionally, the maximum engagement distance may be calculated using existing data on the usage of nonlethal projectiles. There are many producers of nonlethal munitions. However, few factories supply nonlethal ammunition to law enforcement  personnel. 59 These manufacturers developed several guns, both 12 and 37/40 mm. The number and form of sub-munitions used and the defined velocity muzzle differ for these munitions. Table  5  displays the requirements for commercially produced nonlethal projectiles. The head is generally not targeted in government and military techniques, strategies, and procedures.
Six samples, each comprising three instances of the same composition, were evaluated. The test pieces were cylindrical, with a convex head from established formulas. The model is positioned into the pneumatic launcher, where static pneumatic pressure is applied. The length ratio ranges from 60 to 80 mm, and the diameter ranges from 35 to 35. 6 mm. Also, the weight varies from 20 g to 29 g based on what each nonlethal projectile is made of. All data regarding test samples, as shown in Table  7. The pneumatic launcher mechanism is smooth, and the breech is attached to a compressed air gas tank by manually controlling the projectile's speed. The speed may vary by changing the pressure. The pneumatic device enables home-made, nonlethal projectiles laboratory to be shot at different diameters. The impact of the projectile must be natural on the goal.
The first criteria are continuous computerized monitoring of intracranial pressure (TICP),  68  and the maximum value at the threshold is measured throughout the post-mortem human subject (PMHS). 69, 70 The second essential is the leading contact pressure force measured by an analytical model founded on the inside of the head pressure data. Table  8  summarizes the intensity of brain lesions as a function of the maximal TICP, as measured as a function of the contact pressure force. The TICP or contact strength thresholds, shown in Table  8 , are data standardization results from effects on the head's temporal, parietal, or frontal region. The significance of transcranial pressure depends on the measurement point. According to the criteria values shown in Table  8 , three standard speeds can be calculated.
The results demonstrate that HDPE is the best material for a nonlethal projectile holder. The dynamic tests were carried out on nonlethal projectiles, which we installed well, i. e. , the projectile head made of polyurethane foam stuck to its holder of high-density polyethylene. We performed in a room isolated from the personnel. The results showed similar behavior to the projectiles made and those sold on the market, such as the reference projectile XM1006. Figure  7  shows the dynamic curves obtained after filtering with Matlab. The result will be displayed as an electrical pulse proportional to the force generated during the impact. The piezoelectric sensor has a sensitivity of 56. 2 mv per 1 KN. There is a requirement for processing the oscilloscope's output with MATLAB software to obtain the force's natural evolution curves as a time function.
Multiple computed tomography-based head finite element models must be developed, or magnetic resonance (MRI) scans must be acquired to accommodate genuine head morphologic variation in dynamic head injury reactions. 79 In this study, the focus is on using SolidWorks software to simulate the ejaculation process. Some have used the LS-DYNA software for the same purpose, using the AM50 hypothetical human percentile model to predict skull fractures. 80 The FE models investigated dynamic head responses between people with varying head shapes. 81 olyurethane foams are distributed fillers incorporated into a bubble distribution in microstructure investigations. Also, successfully replacing hazardous ingredients in nonlethal weapon manufacturing can minimize costs and environmental effects. In addition, polyurethane foam production may help reduce road accidents and increase the polymer industry's sustainability.
Graphics processing units (GPUs) are widely available and have been used with great success to accelerate scientific computing in the last decade. These advances, however, are often not available to researchers interested in simulating spiking neural networks, but lacking the technical knowledge to write the necessary low-level code. Writing low-level code is not necessary when using the popular Brian simulator, which provides a framework to generate efficient CPU code from high-level model definitions in Python. Here, we present Brian2CUDA, an open-source software that extends the Brian simulator with a GPU backend. Our implementation generates efficient code for the numerical integration of neuronal states and for the propagation of synaptic events on GPUs, making use of their massively parallel arithmetic capabilities.
We benchmark the performance improvements of our software for several model types and find that it can accelerate simulations by up to three orders of magnitude compared to Brian's CPU backend. Currently, Brian2CUDA is the only package that supports Brian's full feature set on GPUs, including arbitrary neuron and synapse models, plasticity rules, and heterogeneous delays. When comparing its performance with Brian2GeNN, another GPU-based backend for the Brian simulator with fewer features, we find that Brian2CUDA gives comparable speedups, while being typically slower for small and faster for large networks. By combining the flexibility of the Brian simulator with the simulation speed of GPUs, Brian2CUDA enables researchers to efficiently simulate spiking neural networks with minimal effort and thereby makes the advancements of GPU computing available to a larger audience of neuroscientists.
, 2009). The earliest implementations were typically technology demonstrations, but not released as software packages to be used by other researchers. This changed in the following years, as a number of general-purpose simulators such as NEMO  (Fidjeland et al. , 2009; Fidjeland and Shanahan, 2010) , CNS  (Mutch et al. , 2010) , CARLsim  (Richert et al. , 2011; Chou et al. , 2018), and NCS6 (Hoang et al. , 2013)  were released. While these simulators could be adapted to a researcher's needs, they typically only supported specific neuron models or network structures: The NEMO, CARLsim, and NCS6 simulators were built to simulate networks of leaky integrate-and-fire or quadratic integrate-and-fire model  (Izhikevich, 2003)  neurons, and the CNS simulator was built to simulate networks structured in cortical layers.
For these use cases, the fact that the model description and its simulation require more than one software package can be a major hurdle. A number of simulators addressed this issue by using code generation  (Goodman, 2010; Blundell et al. , 2018). In such a framework, the model description in a convenient high-level or domain-specific language is an integral part of the simulator itself. When starting a simulation, these model descriptions are translated into efficient low-level code, compiled, and executed. Two simulators that have used this approach to generate code for GPUs are ANNarchy  (Vitay et al. , 2015) , which specializes in networks that mix rate and spike-based elements, and GeNN  (Yavuz et al. , 2016) , where model descriptions have to be specified in a variant of C++ (but note that the main simulation code can be written as a Python script via the PyGeNN interface;  Knight et al.
, 2021b). The Brian 1  simulator  (Stimberg et al. , 2019a ) is a widely used neural simulator that provides a user-friendly system for model descriptions based on mathematical equations, as well as an extensible code generation framework. So far, this framework was only capable of generating C++ code for multithreaded execution on central processing units  (CPUs). Recently, Brian's framework has been extended to generate code for the GeNN simulator (Brian2GeNN;  Stimberg et al. , 2020b) , making it finally possible to run Brian simulations on the GPU. However, this approach limits simulations to the common feature set provided by Brian, GeNN, and the Brian2GeNN interface: some of Brian's features (e. g. , multicompartmental models) are not supported by GeNN at all, and the support for other features (e.
g. , heterogeneous synaptic delays) was added after the creation of the Brian2GeNN interface, and they are therefore also unsupported at this time. Here, we present a new approach to GPU code generation with the Brian simulator. This interface, named Brian2CUDA, directly generates CUDA code for the GPU, and supports the full set of features that the Brian simulator offers. It can therefore be used as a drop-in replacement in all situations where multithreaded CPU code generation was used previously, including simulations of detailed network models of neurons, synapses, and glia cells  (Stimberg et al. , 2019b) , or when optimizing neuronal models with the brian2modelfitting toolbox  (Teska et al. , 2020). We describe how our approach exploits non-trivially parallelizable simulation parts, in particular the data structures and algorithms for the propagation of neuronal spikes through a network taking into account -potentially hetereogeneous -synaptic delays.
For several relevant generic model classes, we compare the performance of Brian2CUDA with Brian's built-in multithreaded execution on CPUs and -where possible -with the Brian2GeNN interface. The results show that Brian2CUDA strongly outperforms the multithreaded execution on CPUs, sometimes by orders of magnitudes. Its performance is comparable to the performance of Brian2GeNN. For large networks, Brian2CUDA is faster, while for smaller networks slightly slower. Our code is available as open source software under a free license at GitHub: https://github. com/brian-team/brian2cuda.
METHOD Brian2CUDA implements a new Brian backend, which runs spiking neural network simulations on NVIDIA graphics processing units (GPUs). It makes use of Brian's code generation system to generate C++/CUDA code based on a user's model definition in Python. In the following, we provide in Section 2. 1 background on the Brian simulator and describe how our proposed CUDA backend can be used. In Section 2. 2, we outline GPU programming essentials. Section 2. 3 contains the algorithms implemented in Brian2CUDA including neuronal state updates, spike propagation, and synaptic effect application. Section 2. 4 summarizes the alternative CUDA-based simulator Brian2GeNN and in Section 2. 5 we specify the benchmark models and experimental procedure.
A Python script that implements this model in Brian is shown in Figure  1D. By changing two lines of code, the simulation can be switched from Brian's C++ backend to our new Brian2CUDA backend. Both backends generate simulation code in their target language (C++ or CUDA) which is then compiled and executed. The generated code implements the simulation loop, memory management, and all computations; it can be executed independently of Python. Figure  1E  illustrates the Brian C++ backend, showing a simplified example of the generated C++ code for updating all neuronal states at a single time step of the simulation. In our example, one central processing unit (CPU) thread sequentially updates the membrane voltage V i for each neuron i. To speed up simulations, the Brian C++ backend can be configured to use OpenMP to parallelize computations over multiple CPU threads (not shown here).
Thread Hierarchy A typical C++/CUDA program is executed on a single CPU thread, which calls special GPU functions that are executed on the GPU (see Figure  2A ). These functions are called CUDA kernels. When called, kernels execute their code in parallel by multiple CUDA threads (see Figure  2B ), which are grouped into CUDA blocks (see Figure  2C ). The number of threads per block N threads and the number of blocks N blocks in this thread hierarchy is set when calling the kernel (see Figures  2A, D ).
All CUDA blocks for the same postsynaptic partition and for different spiking neurons collect synapse bundles in the same spike queues. To avoid race conditions from potential memory reallocation, a critical section code allows only one CUDA block per partition to add bundle IDs into the spike queues at any time. All threads of this block can parallelize the pushing of synapse bundle IDs into the spike queues over threads, since each bundle with a different delay will be added to a different queue. Note that CUDA blocks from different postsynaptic partitions operate on different spike queues and can be executed concurrently. Therefore, increasing the number of partitions decreases the amount of serialization during spike propagation of heterogeneous delays. This can lead to better performance as long as the additional CUDA blocks don't exceed the maximal number of active CUDA blocks on the GPU (see Table  1 ).
CUDA Code Generation With Brian2GeNN Our benchmarks compare Brian2CUDA's performance with the performance obtained when using the Brian2GeNN interface  (Stimberg et al. , 2020b). Since both are implemented as backends for the Brian 2 simulator, the exact same models can be run and easily compared. Note that the Brian2GeNN interface does not support synaptic connections with heterogeneous Synaptic effects of all synapses in all bundles in the 0 t spike queues are applied to their targets. One CUDA block per partition processes all bundles of its partition. Bundles are unpacked and each thread applies the effect on one synapse (e. g, two threads are processing the two synapses in bundle 0). delays, therefore the corresponding benchmarks only compare Brian2CUDA to CPU performance. The Brian2GeNN interface uses Brian's C++ framework to generate synaptic connections, initialize variables, and to generate the numerical update steps based on the given model equations.
In the next step, the interface converts synaptic data structures and model descriptions to the GeNN format, and runs GeNN's own code generation process. Finally, the generated code gets integrated into a run loop running on the CPU that also takes care of exchanging memory between CPU and GPU when necessary (for details see  Stimberg et al. , 2020b). The internally used data structures and algorithms are identical to running a simulation with the GeNN simulator (for details see  Yavuz et al. , 2016). GeNN allows the user to choose data structures and algorithms most adapted to their model, and many of these choices are exposed in the Brian2GeNN interface. All benchmarks presented in this paper use GeNN's sparse connectivity method, and chose the-for the respective model configuration-faster of its two parallelization modes: pre mode, i.
Note that we ensured that these modifications had no significant impact on the runtime durations. The correct versions of these packages are stored as Git submodules in our GitHub repository, together with the necessary patch files and instructions on how to apply them. C++ code was compiled with gcc version 9. 3. 0 and CUDA code was compiled with nvcc version 11. 2 based on CUDA toolkit version 11. 2. The operating system on the computers with the A100 GPUs and Intel Xeon Gold 6226R CPUs was CentOS Linux release 7. 4. 1708 and on the computers with RTX2080 GPUs it was Ubuntu Linux version 20. 04. 3 LTS. For all benchmarks, we first recorded network activities for different network sizes and inspected that network activities were as expected. Additionally, we compared the results of Brian's C++ backend with the results of the Brian2CUDA backend for validation.
In all benchmarks with heterogeneous delays, synapse bundles are used (and not individual synapses as Brian2CUDA can be configured to do). For Figure  8 , the STDP benchmark with homogeneous delays was simulated for the biological times and network sizes shown in the figure legends and simulations were not interrupted after 1,000 s computation time. Code generation and compilation times were recorded from within the Brian package. To measure the initialization and finalization times, we computed the difference between the time spent within the main loop of the generated code and the total execution time of the compiled binary.
Hodgkin-Huxley Benchmark To make efficient use of GPUs, simulation code has to perform highly parallel computations. The independent integration of neuronal state variables performed at each simulation time step for all neurons is trivial to parallelize on a GPU. In Brian2CUDA, each GPU thread computes the full state update for a single neuron (see Section 2. 3. 1). For a network of Hodgkin-Huxley (HH) type neurons without synapses, Brian2CUDA achieves a speedup of 3 orders of magnitude compared to Brian's single-threaded C++ backend for large enough network sizes (N > 10 5 ; Figure  5A ). The speedup of the GPU backend implemented in Brian2GeNN is comparable to the speedup of Brian2CUDA. With singleprecision floats as shown here, Brian2CUDA performs slightly better than Brian2GeNN for large network sizes (Figure  5A ), while for double-precision floats this difference is negligible (shown in Supplementary Figure  S1F ).