dataesr/scientific-paragraphs-categorization huggingface dataset:
Conclusions In this paper, a methodology for irrigation mapping using the Sentinel-1 SAR data time series is introduced. The backscatter mean value, the signal variance, and the correlation length are derived from the backscatter signal time series and are used for classification. The classification result of irrigated and non-irrigated fields is compared with the ground truth from SIGPAC database over 26,434 fields in the whole study area. The result shows a good overall accuracy, which is 81. 08% using the SVM. The mean value of the backscatter time series is the key to separating irrigated and non-irrigated fields, while the correlation length and variance are used for the separation of irrigated trees and irrigated crops. The results of the SVM show good accuracy for irrigated croplands and non-irrigated fields, with soil moisture change more dominant to multi-temporal radar signals.
Classification results for irrigated trees are slightly poor, and the effect of vegetation cover over backscatter in the case of trees is more obvious than the effect of soil moisture change. The RF classification gives a similar accuracy as SVM, but it depends a lot on the number and location of the ground truth fields for machine learning, and is less robust compared with SVM. In areas where there is no ground field information available, instead of using field boundary information, field segmentation was performed using Sentinel-2 NDVI data  [57] [58] [59] , but only for areas without frequent cloud cover. Another alternative method is using 100-m resolution cells directly to calculate the metrics only from Sentinel-1 SAR data, which is more consistent with our original intention to use the methodology under any weather conditions.
Aims. Adaptive optics (AO) system performance is improved using post-processing techniques, such as point spread function (PSF) deconvolution. The PSF estimation involves characterization of the different wavefront (WF) error sources in the AO system. We propose a numerical error breakdown estimation tool that allows studying AO error source behavior such as their correlations. We also propose a new analytical model for anisoplanatism and bandwidth errors that were validated with the error breakdown estimation tool. This model is the first step for a complete AO residual error model that is expressed in deformable mirror space, leading to practical usage such as PSF reconstruction or turbulent parameters identification. Methods. We have developed in the computing platform for adaptive optics systems (COMPASS) code, which is an end-to-end simulation code using graphics processing units (GPU) acceleration, an estimation tool that provides a comprehensive error breakdown by the outputs of a single simulation run.
2014). The novelty of ROKET is that all the error terms are determined frame by frame at each single iteration step of the simulation, instead of only assessing their statistical behavior. This is done by using known internal quantities that are computed by the simulation to estimate these errors on the fly without interrupting the main AO loop. Thus, this tool provides an error breakdown with no other assumption than those that are made by the endto-end models, which are usually weaker than the assumptions needed by analytical models. The goal of this tool is to quantify a detailed wavefront error breakdown in an AO system design by numerical simulations. In particular, statistical correlations between contributors can be evaluated using ROKET. The code can be use to study the behavior of error breakdown contributors and to validate or disprove strong assumptions made by an analytical model.
Then, we now have two ways of producing a PSF after a simulation run. The built-in way is naturally produced by COM-PASS itself as a simulation output. This is noted PSF C and is regarded as the reference PSF. The other way is computed from ROKET data using a PSF reconstruction algorithm. We propose to compare the two PSFs and discuss their difference. We have chosen to compare them in terms of maximum value (or SR) and ensquared energy (EE) at a half-width of 5 λ D. The importance of the error contributors and their possible correlations are then studied in detail in Sect. 3.
Bandwidth and anisoplanatism models This work prepares some tools for PSF reconstruction based on the telemetry data of a real system. We propose an analytical model of the covariance matrix between bandwidth and anisoplanatism to be retrieved from these telemetry and turbulence profiling tools. Similar models already exist that aim at PSF computation  Jolissaint et al. (2006) ;  Neichel et al. (2008). In this section, we propose a different approach that does not rely on a Fourier analysis, but on an expression of covariance matrices of the anisoplanatism and bandwidth errors, including their possible correlation, directly in the DM space. Applications and limitations of this approach are discussed.
Computing performance The simulations presented in this paper have been run on a Nvidia DGX-1 server, with Dual 20-core Intel Xeon E5-2698 v4 @ 2. 2 Ghz and 8 Tesla V100-SXM2 GPUs. The GPU acceleration enables COMPASS to run the 12-layer simulation, without the error estimation feature, at approximately 330 frames per At the ELT scale, COMPASS is able to run a 35-layer SCAO simulation at 73 frames per second, and the error estimation is performed at 15 frames per second. We have also developed a multi-GPU module to perform PSF reconstruction using the algorithm proposed by  Gendron et al. (2006). This implementation allows reconstructing a 4 096 by 4 096 ELT PSF on 5 000 modes in 35 seconds on two GPUs. The covariance matrix model described in Section 4 is highly parallelizable as each element of the matrix can be computed independently of the other elements.
Computer simulation The web app 'CloneSim' was written in JavaScript with Angular JS and was designed to run on the web browser, Google Chrome. For each simulation, a 1-dimensional circular array (closed linear array) was established to represent a mixture of two populations of LESCs (referred to as 'blue' and 'white' or 'positive' and 'negative' stem cells) at G0. The following parameters were varied at set-up: (1) the number of LESCs in the array at generation 0 (G0); (2) the number of subsequent LESC generations (division iterations) to be simulated; (3) the initial proportion of positive (blue) LESCs; (4) the number of LESCs per coherent clone (the value is set at 1, to simulate random distributions, or higher, to simulate coherent clonal groups); (5) the probability of an LESC being replaced by a neighbouring LESC and (6) the probability of an LESC being lost (and not replaced).
Statistical analysis The choice of parametric or non-parametric tests was guided, in part, by normality tests. GraphPad Prism version 5. 0c (GraphPad Software Inc. , La Jolla, USA) was used for most statistical tests, including 1-way analysis of variance (ANOVA), 2-way ANOVA, Kruskal-Wallis test, 2 × 2 Fisher's exact test and chi square test for trend. The log-rank (Mantel-Cox) test and log-rank test for trend were used for survival distributions. An online statistical calculator  (Lowry, 2017)  was used for Fisher's exact test with tables larger than 2 × 2. The error bars in the figures are 95% confidence intervals (CI) unless stated otherwise.
Second use of clinical data commonly involves annotating biomedical text with terminologies and ontologies. The National Center for Biomedical Ontology Annotator is a frequently used annotation service, originally designed for biomedical data, but not very suitable for clinical text annotation. In order to add new functionalities to the NCBO Annotator without hosting or modifying the original Web service, we have designed a proxy architecture that enables seamless extensions by pre-processing of the input text and parameters, and post processing of the annotations. We have then implemented enhanced functionalities for annotating and indexing free text such as: scoring, detection of context (negation, experiencer, temporality), new output formats and coarse-grained concept recognition (with UMLS Semantic Groups).
In this paper, we present the NCBO Annotatorþ, a Web service which incorporates these new functionalities as well as a small set of evaluation results for concept recognition and clinical context detection on two standard evaluation tasks (Clef eHealth 2017, SemEval 2014). Availability and implementation: The Annotatorþ has been successfully integrated into the SIFR BioPortal platform-an implementation of NCBO BioPortal for French biomedical terminologies and ontologies-to annotate English text. A Web user interface is available for testing and ontology selection (http://bioportal. lirmm. fr/ncbo_annotatorplus); however the Annotatorþ is meant to be used through the Web service application programming interface (http://services. bioportal. lirmm. fr/ncbo_ annotatorplus). The code is openly available, and we also provide a Docker packaging to enable easy local deployment to process sensitive (e.
The annotation workflow is based on a highly efficient syntactic concept recognition tool [95% precision for diseases  (Dai et al. , 2008) ] that uses concept names and synonyms. The recognizer optionally allows to use names and synonyms of related concepts through semantic expansion [e. g. is_a assertions and concept-to-concept mappings  (Shah et al. , 2009) ]. The NCBO Annotator has been widely adopted in the community and is one of the most actively used services from NCBO BioPortal, with a dictionary made from labels of 600þ ontologies. Yet, the Annotator lacks natural language processing capabilities (e. g. handling of morphological variants, disambiguation) required to improve the accuracy of annotations. Another limitation is the absence of scoring and of the contextualization of clinical text annotations, something it was never really designed for.
g. annotating with a threshold of 90% only retains the annotations with scores in the top 10% of the score distribution). New output formats. NCBO Annotator supports XML and JSON-LD outputs. While JSON-LD is a recognized format, it is not sufficient for many annotation benchmarks and tasks, especially in the semantic Web and natural-language-processing communities. Annotatorþ adds support for standard (BRAT, RDF) and taskspecific (e. g. CLEF eHealth) formats. RDF is the backbone language of the semantic Web and BRAT (http://brat. nlplab. org) is widely used for evaluation campaigns and for the production of annotated corpora. We also enriched the JSON-LD output with additional information (e. g. scores or clinical context). Clinical context. For clinical text, the context of the annotated clinical conditions is crucial: Distinguishing between affirmed and negated occurrences (e.
g. 'but'). We integrated this algorithm within the NCBO Annotatorþ by post-processing the sentence in which an annotation appears. To our knowledge, this is the first implementation of a Web-based ConText-like system in a publicly accessible platform allowing non-experts in natural-languageprocessing to both annotate and contextualize medical conditions in clinical notes. Coarse-grained semantic annotation. Recognizing broad entity types (e. g. gene, drug, disease) is a task of high interest for the BioNLP community. The 10 Semantic Groups  (McCray et al. , 2001)  are often used as coarse-grained groupings of the Unified Medical Language System (UMLS) Semantic Types  (Bodenreider, 2004). Thanks to the capability of the NCBO Annotator to filter ontologies by Semantic Types, we have also added the capability to filter by Semantic Groups in Annotatorþ.
Funding This work is supported by the  French National Research Agency within the PractiKPharma  (grant  ANR-15-CE23-0028 ) and  SIFR  (grant  ANR-12-JS02-01001 ) projects as well as by the European  H2020   Marie Curie  actions (grant  701771 ), the  University of Montpellier  and the  CNRS. We also thank the  US National Center for Biomedical Ontology  for their assistance with the NCBO Annotator.
The Bindlib library for OCaml provides a set of tools for the manipulation of data structures with variable binding. It is very well suited for the representation of abstract syntax trees, and has already been used for the implementation of half a dozen languages and proof assistants (including a new version of the logical framework Dedukti). Bindlib is optimised for fast substitution, and it supports variable renaming. Since the representation of binders is based on higher-order abstract syntax, variable capture cannot arise during substitution. As a consequence, variable names are not updated at substitution time. They can however be explicitly recomputed to avoid "visual capture" (i. e. , distinct variables with the same apparent name) when a data structure is displayed. (** Representation of a type.
Introduction The implementation of programming languages and/or theorem provers plays an important role in our community. It allows us to concretely illustrate the mathematical models that we consider, and also helps us discovering new intuitions through experimentations. In practice, implementing languages is more difficult than one could expect. It requires the combination of specific techniques, ranging from the parsing of source files to unification algorithms, through the representation of data structures with variable bindings. We here focus on the latter point and introduce the Bindlib library  [16]  for OCaml. Variable binding is very common in computer science, as it is used for the representation of computer programs and mathematical formulas as abstract syntax trees. However, implementing the necessary primitives, including variable renaming and capture-avoiding substitution, is cumbersome and error-prone.
Moreover, naive implementations generally result in poor performances, especially when many substitutions must be performed. The Bindlib library solves these problems thanks to an abstract representation of binders with an efficient substitution operation. It is based on a form of higher-order abstract syntax  [12] , 1 which eliminates the possibility of variable capture. Variable names are managed using a distinct mechanism, and bound variables are not effectively renamed when performing a substitution. As a consequence, displaying a data structure in which substitutions have occurred may introduce "visual capture", or distinct variables with the same apparent name. To avoid this unfortunate, but harmless situation, variable names must be explicitly updated. 2 This is achieved using a glorified "identity function", which injects the data structure into a specific Bindlib type constructor.
Main working principles The Bindlib library provides type constructors 'a var and ('a,'b) binder , for representing free variables (of type 'a ) and binders (of a value of type 'a in an element of type 'b ) respectively. A bound variable can be substituted using the subst function. val subst : ('a,'b) binder -> 'a -> 'b However, it is not possible to bind a free variable directly, as there is no built-in function of type 'a var -> 'b -> ('a,'b) binder. This is not surprising because this function does not have any specific information on the structure of the elements of type 'b. To bind variables in a data structure, it must first be injected in a specific type constructor 'a box. Intuitively, an element of type 'a box corresponds to a value of type 'a under construction, and its free variables can be bound easily using bind_var.
The Bindlib library aims at being very flexible, and it does not impose any restriction on the types of variables that can be bound, nor on the type of elements in which they are bound. As a consequence, it is the responsibility of the programmer to implement the lifting functions transforming values of type 'a into values of type 'a box for every type 'a that may contain bound variables. This limited amount of boiler-plate code is generally straightforward, and mainly amounts to providing smart constructors for each constructor of the abstract syntax tree. In other words, every constructor of the type 'a must be lifted to the 'a box type using provided Bindlib functions. In an earlier version of Bindlib, this process was partly automated using an OCaml syntax extension. However, this approach proved to be rather confusing for new users, and the benefits did not really outweigh the costs.
Origins and applications of Bindlib The development of Bindlib  [16]  was initiated by the second author in the nineties. An early version of the library was used to implement an efficient normaliser for the λ -calculus  [5]. It was then made into a separate library, and used in the implementation of the first version of the PML language  [6]. Starting from version 4, Bindlib was mostly rewritten by the first author, who proposed some simplifications an made a significant documentation effort. Further simplifications and improvements have been put into the version 5 of Bindlib  [16] , which is being released at the time of writing. Bindlib is now finally ready to be used by a larger community. The latest version can be easily installed with the Opam package manager, using the following command.
opam update && opam install bindlib The Bindlib Library Bindlib has been and is used for the implementation of half a dozen programming languages and/or proof assistants, as well as for a large number of small prototypes, including an implementation of the pure type systems (PTS), and an implementation of the combinatory reduction systems (CRS). We give below a list of the most recent and relevant systems relying on Bindlib. The SubML language. The SubML language  [10]  implements a rich extension of System F with Subtyping  [17]. It features polymorphic, existential, inductive and coinductive types, which all require variable binding. Variable binding is also used for the standard λ -abstraction constructor, as well as a fixpoint for general recursion. The SubML language makes a particularly extensive use of binders as the system relies on choice operators (similar to Hilbert's Epsilon operator) in its syntax.
Moreover, the language allows quantification over sizes for inductive types, which requires binding a syntactic representation of ordinals into types (as it is usually done for sized types). The PML 2 proof system. The PML 2 proof system  [11]  implements the type system described in the PhD thesis of the first author  [9]. This project certainly contains the most advanced uses of Bindlib so far, as it mixes many different types of binders. In particular, the language admits a higher-order type system with several base sorts (values, terms, stacks, propositions and ordinals), as well as an arrow sort. In particular, Bindlib binders are mixed with GADTs in order to implement multiple binders with non-homogeneous types (i. e. , binding values of different types at once into a term). A new version of Dedukti.
Bindlib was most recently used by the first author to propose a new implementation of the logical framework Dedukti  [1] , called Lambdapi  [8]. Although the abstract syntax of the language has a rather simple binding structure, with only λ -abstractions and dependent product types, the system makes a singular use of Bindlib for representing rewriting rules. A rewriting rule l → r is formed of a left-hand side (LHS) l, which corresponds to a pattern, and a right-hand side (RHS) r, in which the free variables of l are bound. For example, the term "Plus 12 (Succ 29)" matches the pattern of the rewriting rule "Plus n (Succ m) → Succ (Plus n m)", associating the values 12 and 29 to variables n and m, thus resulting in the term "Succ (Plus 12 29)" after the application of the rewriting rule. In the implementation, the RHS is effectively represented as a binder ranging over the free variables of the LHS.
Higher-order abstract syntax and its variations Another alternative is the use of higher-order abstract syntax (or HOAS)  [12] , in which a binder is represented using a function of the host language. As it relies on the binders of the meta-language, the correctness of this approach is immediate. A HOAS representation of pure λ -terms is given below. The term λ x. λ y. x y is here encoded as Abs(fun x -> Abs(fun y -> App(x,y))). As with De Bruijn indices, the name of bound variables are not stored. As a consequence, they must be handled using a separate mechanism. A variation of this technique is used in the internals of Bindlib, but it is not visible to the user. An important remark about the use of HOAS is that the domain of binders appears negatively (i. e. , to the left of an odd number of arrows).
Related works and similar tools There are only very few available tools or libraries for the representation of binders in the OCaml language. The only one that seems to be a serious alternative is Francois Pottier's Cαml (or alpha-Caml)  [14, 15] , which follows a completely different approach. Indeed, Cαml is not an OCaml library, but a meta-programming tool that generates OCaml code from a "binding specification". Yet another difference with Bindlib is that Cαml relies on De Bruijn indices, not a form of HOAS. Another approach is that of the FreshML family of languages  [13, 18, 19] , which extend OCaml with specific binding facilities. There seem to be some similarities between these tools and the Bindlib approach, most notably in the idea of generating fresh names (or rather, variable) to substitute binders.
Abstract syntax tree The abstract syntax tree of our language can be encoded as follow, using the Bindlib data types. Free variables are represented using the 'a var type, and binders using the ('a,'b) binder type. The definition of these types closely follows the BNF grammar given at the top of Figure  1  page 46, and similar definitions can be made for richer languages. In the following sections, we will demonstrate the construction of terms and types using this representation, and the implementation of various functions. In particular, we will see how it is possible to work under binders, using user-defined lifting functions. Note that such functions are not needed when we do not want to work under binders, or when binders only have to be substituted. For example, it is possible to define the following head-normalisation function on terms.
On the use of magic The implementation Bindlib relies on the Obj module 9  of OCaml to store values of different types in a single array, intuitively corresponding to the environments of a closure. However, the implementation of Bindlib satisfies the invariant that the value at every given index is always read or written at a fixed type. As mentioned earlier, the Obj. magic function is also used to transform variables of type 'a var into value of type any_var (defined as Obj. t var ), which are only used in a type-safe way. Although the lists of variables with heterogeneous types used in the 'a box type could be encoded with an existential type, this is not the case for the environments. Ensuring (more) type safety in the handling of environments would require the user to provide a runtime representation of all the type of variables that can be bound.
In particular, we will use the following notations for operators on DNFs: -, ⊥ denote true and false (universe and empty set) for their union (including subsumption simplification) for their intersection (including transformation to DNF and simplification) for their (semantic) subsumption relation We have experimented with two prototype realizations of our algorithms. One approach is based on CLP (constraint logic programming) in SWI-Prolog  [19]  + CLP(Q). We wrote a small meta-program for the subsumption check. The other approach is based on Parma Polyhedra Library  [1]. In particular, its Pointset Powerset Closed Polyhedra provide efficient implementations of the operations on DNFs.