dataesr/scientific-paragraphs-categorization huggingface dataset:
This way, OpenCL stands as a great programming environment to experiment with heterogeneous architectures and implement higher-level layers, like runtime systems but may appear too low-level for application programmers, as the assignment of tasks and the data transfers between host and device memories are explicit. At thread level, hthreads  [4] , is a unifying programming model aiming to specify application threads running within a hybrid CPU/FPGA system. A unified multiprocessor abstracts every component of the platform. Application developers can express the concurrency of their computations using threads, arranged in a single program, which can either be compiled to run on a CPU or synthesized to run on an FPGA. The Heterogeneous System Architecture Foundation  [5]  (HSA) is a consortium of industrial and academic partners discussing ways of standardizing a whole ecosystem for heterogeneous programming.
An HSA implementation is a system consisting of a heterogeneous hardware platform that integrates both CPUs and GPUs, which operate coherently in shared memory, a software compilation stack, a user-space runtime system, and some kernel-space system components. The OpenMP accelerator support provides explicit ways of offloading portions of applications to accelerator devices. Relying on this OpenMP support, recent work  [6]  have been proposed to handle FPGA. This work focuses on making data transfers automatic based on dependencies provided at the OpenMP level and does not discuss heterogeneous scheduling questions. Relying on StarPU, our proposal will benefit from smart scheduling heuristics based on cost models for both computation and data transfers times. OmpSs is a programming environment developed at BSC that enables the execution of task-based applications on heterogeneous platforms.
It can be seen as a fork of OpenMP with original extensions. Like OpenMP, OmpSs provides compiler directives to turn serial C, C++ and Fortran applications into parallel applications initially able to offload computations on GPU. The programming environment comes with a dedicated compiler and a runtime system responsible for distributing tasks over the CPUs and the accelerator devices, managing data transfers between host and devices memories in a transparent way. OmpSs has then been extended to support offloading on FPGA  [7]. Compared to our proposal, this extension focuses on embedded heterogeneous architectures such as the Zynq from Xilinx integrating a CPU and an FPGA on the same die. Blaze  [8]  provides programming and runtime support that enables rapid and efficient deployment of FPGA accelerators at warehouse scale.
It builds upon Apache Spark, a widely used framework for writing Big Data processing applications. Among many industrial attempts to use FPGA as an accelerator in a heterogeneous environment, Amazon EC2 F1 instances can be considered to deliver high flexibility to developers  [9]. Instances come in two sizes, with up to eight 16 nm Xilinx UltraScale Plus FPGA devices connected to each one of them through PCIe. They provide all the necessary tools to develop an AFI (Amazon FPGA Image) that can later be used to configure one of the devices of the instance. The runtime decisions are yet to be managed by the developer though.
A. Vivado HLS and Vivado Vivado HLS is one of the broadly used HLS tools. From a C++ description of a kernel, Vivado HLS automatically generates an RTL description. Vivado HLS delivers performance by allowing the developer to monitor and tune the behavior of its kernel by using some pragmas to exploit the fundamentally concurrent parts of it. From an HPC developer, a relatively efficient hardware description of a C/C++ application should arrive after a basic understanding of the design principles through the rich documentation and code examples the tool provides. Once an RTL description has been generated by Vivado HLS, it needs first to be instantiated along with all the other required components for the final design. Then, the complete RTL description of the final design is synthesized to logic gates by Vivado.
B. RIFFA: The link between the host and the FPGA RIFFA (Reusable Integration Framework for FPGA Accelerators) is a simple framework for communicating data from a host to a FPGA via a PCIe bus  [10]. It is then made of a host part and a FPGA part. RIFFA is available on Linux and for several series of boards, from different vendors such as AVNet, Xilinx and Altera. On the host side there is a clean interface to exchange data between the host and the device, that relies on a custom Linux kernel driver. The communication is managed using direct memory accesses transfers and interrupt signaling. On the FPGA side, RIFFA provides a clean interface for accessing up to twelve signal controlled completely independent bidirectional channels. Each channel has two sets of signals; one for receiving and one for sending data.
To do so, StarPU takes into account the availability of targetspecific implementations for the current task, the availability of the hardware resource at the given time and some modelbased performance estimation of the task on the different processors/accelerators. On top of that, StarPU also handles data transfers automatically and transparently, and can make smart decisions on whether some data should stay in the accelerator memory or not, depending on the input data of the next tasks to be executed. In this work, we focus on using the C/C++ API of StarPU. In this case, once the different tasks making the application have been identified, the programmer has to define task types, called codelets in the StarPU terminology. A codelet establishes the number of inputs and outputs of a task along with all its implementation for one or more different types of processing units.
Once codelets have been defined, the application developer has to create the main StarPU program. This program first registers in the StarPU runtime, the inputs and outputs data that will be read and produced by tasks. Then the program creates tasks along with their codelets and their inputs and outputs and submits them to the StarPU runtime system. The task graph represents the execution of a StarPU application. As a consequence, it is fully dynamic and can, for example, depend on user-specified inputs. When a task is submitted, the StarPU runtime first checks for input dependencies. If these dependencies are satisfied, the scheduler decides on which processing units the task will execute, among all the possible ones specified in the task codelet. At this time, the runtime pushes the task into the ready queue of the chosen processing unit.
8 : Submit tasks to the StarPU runtime. effective computation of C is done using three nested for loops just as in a software implementation. Finally, the C matrix must be sent back to host side using the second hls::stream object provided to the function. In case of tasks with several outputs, as for the inputs, the sending order must be respected on the StarPU side when receiving the data. 3) Generating the bitstream: Once the RTL description of the hardware tasks has been generated with Vivado HLS, the application developer must generate the final bitstream to be used to configure the FPGA. For that task, the HEAVEN framework provides a parametric wrapper written in Verilog. This wrapper is only configured by the application developer to specify the number of hardware tasks to be instantiated.
As a movable cage was the system used in these experiments, the model simulated only this system. Submodel of herbage standing biomass, feed and fill values. When data on herbage standing biomass are not available over several weeks, it is possible to predict herbage growth by integrating a model adapted for a variety of pastures  (Duru et al. , 2009)  as a submodel of PASTRAB. We modeled feed and fill values using the INRA (2007) animal feed tables, which contain data for multiple developmental stages of many pasture types. We converted these development stages into thermal time based on  Ansquer et al. (2009)  and related these thermal times to pasture feed and fill values. The resulting following equations are used to calculate herbage N (N_Herb), OM (OM_Herb) and ADF (ADF_Herb) contents based on their initial values (Init_N_Herb, Init_OM_Herb, Init_ADF_Herb, respectively) as well as herbage initial (Init_Thermal_Age) and current (Thermal_Age) thermal age and a range of parameters (NCa, NCb, OMCa, OMCb, ADFCa, ADFCb; Table  3 ).
e. maximum herbage intake during grazing), equals the smallest of the three intake limits: Pot À Herb À Intake = min N À limit; OM À limit; ADF À limit ð Þ (7) The extent to which rabbits can reach potential herbage intake depends mainly on herbage allowance  (Martin et al. , 2016). Thus, along with the use of two parameters (UEa, UEb; Table  3 ), the model calculates that HUE logarithmically decreases as a function of the ratio of herbage allowance to potential herbage intake, following relations well established for dairy cows  (Pérez-Prieto et al. , 2011) :  Complete or incomplete data mean that all data on herbage fill and feed values are or are not available, respectively. HUE = UEa ln HA = Pot À Herb À Intake ð Þ + UEb (8) Actual herbage intake (Herb_Intake) is calculated as the minimum of potential herbage intake and herbage allowance corrected by HUE: Herb À Intake = minðPot À Herb À Intake; HA HUEÞ (9) Next, the model calculates intake of N (N_Intake), OM (OM_Intake) and ADF (ADF_Intake) by multiplying the intake of herbage, complementary feed and hay by their N, OM and ADF contents, and then summing the subtotals for each nutritive component: N À Intake = N À Herb Herb À Intake + N À Hay Hay À Intake + N À CF CF À Intake ð10Þ OM À Intake = OM À Herb Herb À Intake + OM À Hay Hay À Intake + OM À CF CF À Intake ð11Þ ADF À Intake = ADF À Herb Herb À Intake + ADF À Hay Hay À Intake + ADF À CF CF À Intake ð12Þ Submodel of rabbit growth during grazing.
Due to a lack of available process-based knowledge about rabbit mortality, the model calculates rabbit mortality (Rabbit_Mortality) as a function of the mortality level (Mortality_Level; i. e. the total percentage of mortality over the duration of rabbit fattening) and the mortality rate (MR; i. e. the percentage of the mortality level occurring each week; Table  4 ) each week (t) and the initial size of the rabbit batch (Init_Batch_Size). Accordingly, the model simulates the decrease in rabbit batch size (Batch_Size) that is required to calculate economic indicators (equation (  21 )). Rabbit À Mortality t ð Þ = Init À Batch À Size Mortality À Level MR t ð Þ (19) Batch À Size t ð Þ=Batch À Size tÀ1 ð ÞÀRabbit À Mortality t ð Þ (20) Economic submodel. PASTRAB calculates gross margin per rabbit sold as a function of rabbit live weight at sale, carcass yield (Carcass_Yield) and sale price (Sale_Price) minus the cost of herbage (Herbage_Cost), hay (Hay_Cost) and complementary feed (Complementary_Feed_Cost), including the costs of feeding rabbits that died during fattening: Gross À Margin À per À Rabbit =ðGross À Output À per À BatchÀHerbage À intake t 0 Herbage À CostÀHay À intake t 0 Hay À Cost ÀComplementary À Feed À Intake t 0 Complementary À Feed À CostÞ = minðBatch À SizeÞ ð21Þ where Gross À Output À per À Batch=Gross À Output À per À Rabbit min Batch À Size ð Þ ð 22Þ where Gross À Output À per À Rabbit=max Live À Weight À Rabbit ð Þ Carcass À Yield Sale À Price ð23Þ Data sets used for model calibration and validation For model calibration and validation, we used data from 7 and 12 independent experiments, respectively, that cover a wide range of agricultural conditions in France.
These experiments were conducted in different locations, seasons and pasture types with different stocking rates and amounts of complementary feed (Table  2 ), and using rabbits that were hybrids of traditional breeds (Fauve de Bourgogne and Papillon). The number of data points per experimental unit (i. e. production cage) differed because measurement frequency differed among experiments. In five experiments, herbage fill and feed values were not measured; thus, we used these experiments only for model validation.
e. including measures of herbage feed values) that we first separated by pasture type. Measuring intake during grazing is difficult, especially when using moving cages, because herbage allowance (used to calculate intake) is not measured directly where the animals graze but next to the cage in an area that may have a different allowance. This measuring technique has the disadvantage that the cages flatten herbage standing biomass, which makes it difficult to measure grazing refusals (used to calculate intake) when HUE is low. Therefore, the potential for measurement errors increases. We removed the following data points from each data set: measured herbage intake greater than herbage allowance or 110 g/kg of MW, that is, the maximum intake observed for conventional rabbits  (Gidenne and Lebas 2006) , and HUE <25%.
For each pasture type, we selected half of the data each for model calibration and validation. Parameter estimation yielded calibrated parameter values (Table  3 ). As our experiments were the first time these pastures had been used for rabbit grazing, they were free of parasites harmful to rabbits. Thus, mortality was much lower than that on farms, starting to increase only during the third year of the experiment. On the other hand, the farm data that we found showed extremely diverse levels of rabbit mortality. Thus, it was rather impossible to derive reliable and largely applicable parameter values from these data. Then, we calibrated the corresponding submodel based on mortality dynamics observed on conventional battery rabbit farms and kept the mortality level as a simulation input to easily account for differences among farms.
Aims. In this paper, we aim to constrain the properties of dust structures in the central first parsecs of Active Galactic Nuclei (AGN). Our goal is to study the required optical depth and composition of different dusty and ionised structures. Methods. We developed a radiative transfer code, MontAGN, optimised for polarimetric observations in the infrared. With both this code and STOKES, designed to be relevant from the hard X-ray band to near-infrared wavelengths, we investigate the polarisation emerging from a characteristic model of the AGN environment. For that purpose, we compare predictions of our models with previous infrared observations of NGC 1068, and try to reproduce several key polarisation patterns revealed by polarisation mapping. Results. We constrain the required dust structures as well as their densities.
MontAGN Simulation code Because polarimetry is a complex phenomenon, radiative transfer codes are essential tools for the interpretation of these observations. However as far as we know, no radiative transfer code was able to address of all wavelength ranges. Because of our particular requirements, we decided to develop our own simulation code optimised for AGN observations in the infrared. MontAGN (acronym for "Monte Carlo for Active Galactic Nuclei") was designed to study whether our assumptions on single and double scattering with a proper torus geometry were valid and if this would allow to reproduce the observed polarisation images of NGC 1068. The MontAGN code is aimed to be available to the public in a near future.
Overview MontAGN is written in Python 2. 7. It uses photons packets with constant initial energy instead of propagating single photons. This allows to choose between two propagation techniques: -If re-emission is disabled, the energy of the packets is modified to take into account, at each event, the photons fraction of the initial packets that continues to propagate in the medium. Therefore at each encounter with a grain, the absorbed fraction of photons is deduced so that only the scattered photons propagate. Murakawa (2010) used the same techniques for the simulations of YSO. -If re-emission is enabled, the code takes into account the absorption and re-emission by dust as well as temperature equilibrium adjustment at each absorption. If absorbed, the photon packet is re-emitted at another wavelength with the same energy but with a different number of photons.
Initialisation MontAGN uses a 3D grid of cells, sampling the densities of the different dust species in each cell. Dust grains are considered as dielectric spheres. Before the simulation starts, tables of albedo, phase function, Mueller matrix, absorption and extinction coefficients are generated for a range of grain sizes and wavelengths thanks to Mie theory. For that purpose, we use the bh_mie module initially written by  Bohren & Huffman (1983). These tables then just need to be interpolated (linear or logarithmic interpolations) to get the precise value for a given set of grain size and wavelength during the simulation. These interpolations make the execution of the code faster. MontAGN uses the Stokes vectors formalism to represent polarisation of photons packets: S =              I Q U V              (1) with I the intensity, Q and U the two components of linear polarisation and V the circular polarisation.
First tests and toy models We first conducted validation tests of the MontAGN code on YSO, using the geometry described in  Murakawa (2010). Our results were compatible with those shown in their paper in terms of polarisation degree and angles, albeit a higher Poissonian noise due to the very high optical depth involved in this model (about 6 × 10 4 in K band). The clear polarisation angle pattern seen in  Murakawa (2010) , see their figure  6 , needs more photons to be achieved. For a proper validation on AGNs, we defined a set of three models to compare the results of simulations between MontAGN and STOKES codes  (Goosmann & Gaskell 2007;  L. Grosset et al. :  Exploring the inner parsecs of AGN using NIR high resolution polarimetric simulations  Marin et al. 2012 Marin et al. , 2015) )  in a simple case.
Conclusion and Prospectives In this paper, we described and used the radiative transfer code with polarimetric capabilities MontAGN to study the inner dust structures of AGN, especially NGC 1068, in which the observed polarisation pattern is compatible with the idea of photons scattered twice proposed by  Bastien & Menard (1990)  and later validated by  Murakawa (2010)  on YSO. This was the basis of our analysis of our observations of NGC 1068  (Gratadour et al. 2015). The code allows us to simulate NIR polarimetric observations of an AGN featuring an ionisation cone, a torus and an extended envelope. Despite limiting ourselves to a simple case where the various structures have a constant density of dust or electrons, we are able with spherical grains only, to constrain the optical depth of the different dust structures so that obtaining a similar polarisation pattern as the one observed on NGC 1068.
An integer program is a mathematical formalization of a problem. It consists in an objective function to optimize on a set of integer variables, subject to a set of linear constraints. This approach is very flexible, allowing to model mathematically a large range of problems. It has been applied to various domains, from economy to industry. To our knowledge, only one team has used integer programming for RNA secondary structure prediction with pseudoknots. First they developed an integer program  [6]  to find the structure of MFE using the stacking energy parameters of Mfold 3. 0  [15]. Then they provided the IPknot software  [10]  based on an MEA model using base pair probabilities computed with different models like the McCaskill  [16]  or the Dirks and Pierce  [8]  models. This team also used integer programming to predict RNA-RNA interactions  [17].
• We combined the two thermodynamic models Mod1 and Mod2 for prediction of RNA secondary structure with pseudoknots into one BOIP. • We implemented this BOIP with our generic algorithm to predict several optimal and several sub-optimal RNA secondary structures. The tool is called BiokoP (Bi-objective programming pseudoknot Prediction) and is available on our EvryRNA platform. We evaluated our algorithm on a dataset of 198 pseudoknotted RNA sequences from PseudoBase++  [20]. The first observation is that the real structure is often given by a sub-optimal solution, which confirms the need of returning sub-optimal solutions. BiokoP was then compared with other tools proposing several solutions for pseudoknotted RNA secondary structure prediction. To our knowledge, only two tools are available in the literature, namely pKiss  [4]  and McGenus  [5].
BiokoP was also compared to IPknot  [10] , in the case where one solution is returned. Considering the dataset of pseudoknotted secondary structures, BiokoP gives better F 1 -scores than the other tools. The results in function of the type of pseudoknots show that BiokoP gives homogeneous results regardless of the pseudoknot type. Indeed, the F 1 -scores are always higher than 70% for any number of solutions returned, contrary to those of pKiss and McGenus. The results also show that BiokoP is more likely to return the best structure (according to the F 1 -score) among the optimal solutions than the other tools. We also experimented BiokoP on a dataset of pseudoknot-free RNA sequences from RNA STRAND  [21]. We compared BiokoP on this dataset with the other tools and with RNAsubopt  [22]. RNAsubopt is able to predict pseudoknot-free structures and sub-optimal solutions.
Results The BOIP presented for predicting RNA secondary structures with pseudoknots is implemented using the CPLEX Optimizer V12. 6. 3 solver  [33]. Our algorithm is implemented with ε = 0. 001 and m = 2. The obtained tool, called BiokoP, is available on our EvryRNA platform. In the following, we first present the datasets we use for the evaluation of BiokoP, then the experiments showing the distribution of real structures found over the generated solutions. The next section is devoted to a statistical analysis of structures predicted by BiokoP and by other tools from the literature. We end by giving some information on the execution time of BiokoP.
Datasets We evaluate our approach on a dataset of pseudoknotted RNAs we built from the PseudoBase++ database  [20]. This dataset gathers 198 sequences whose lengths range from 21 to 128 nucleotides. PseudoBase++ classifies the sequences by the pseudoknot types. We recovered five types of pseudoknots: H (H-type), HHH (kissing hairpin), HLout, HLin and LL. The types, described in Fig. 4 , are defined in function of the topology of the pseudoknot. In our dataset, there are 154 pseudoknotted RNAs of type H, 3 of type HHH, 26 of type HLout, 4 of type HLin and 11 of type LL. All the RNAs of type H come from the dataset of 168 sequences built by Huang et al. [34]  from PseudoBase++. This dataset excludes redundant sequences. The remaining RNAs were recovered on the database by requests according to the type of pseudoknots.
Distribution of real structures over the Pareto sets We study the distribution of real structures returned by BiokoP on our dataset of pseudoknotted RNAs over the Pareto sets. The real structure is the structure that corresponds exactly to the referenced structure for a given RNA. To study the distribution of real structures, as the number of solutions of a Pareto set can not be predicted, note that in order to have 30 solutions per RNA, the mean Fig. 4  RNA pseudoknot types. RNA pseudoknot types from Pseudobase++  [20]  classification number of Pareto sets to compute is 5. 2. The distribution of real structures found are displayed in Table  1. Around the half of real structures found are in the first Pareto set (45 over 83). These structures are the optimal ones, showing the relevance of combining these MEA and MFE models.