dataesr/scientific-paragraphs-categorization huggingface dataset:
Discussion In some software like the Atmel OTAU (over-the-air-upgrade)  [35] , the application is not decoupled from the system, and the monolithic software image (commonly larger than 100 KB) needs to be updated for the WSN reprogramming. The reprogramming cost of this software is high and the reprogramming success probability is low. In the article  [35] , it is computed that in a network with 100 routers, the entire OTAU reprogramming process will take approximately 7 h to be completed for a non-secure network, 11 h to be completed for a secure network, and 14 h to be completed for a high-security network. However, if the EMIDE is applied, only the application code needs to be reprogrammed, and the reprogramming process can be completed quickly within several minutes (just hundreds of bytes need to be updated).
Application Code Execution Efficiency In the ContikiDL and TinyLD, the final executed code, which is generated after the dynamic linking process, is the pure machine code. Thus, the application code execution efficiency is high. In the simpleRTJ and nanoVM, the final executed code is the Java byte code. This code needs to be interpreted, thus the execution efficiency is low. To compare the execution efficiency of the machine code and the byte code, the time between the calling of the application system-call function and the executing of the corresponded system function in the simpleRTJ and the ContikiDL is computed, and the result is shown in Table  7. From this result, it can be known that the execution efficiency of the machine code is 34. 6 times higher than that of the simpleRTJ Java byte code.
Therefore, less energy resource will be consumed if the machine code is used for the application image. In EMIDE, the machine code is also used, but the access from the application system-call function to the system service function is done through an intermediate jump table, thus the application code execution efficiency is a bit lower if compared with that of ContikiDL. The execution efficiency proportion of these two mechanisms can be modeled as follows: where N represents the number of the system-call functions in the application program, 10 represents the clock cycle of each entry in the jump table, S represents the clock cycle of the whole application code (includes the sub-functions). Provided that S is 1000 and N is 6, then the P will be 1. 06. / ( 1 0 )/ 1 ( 1 0 / ) EMIDE ContikiDL P E E N S S N S = = + = + (3).
Application Code Size Application code size is critical for the WSN system as it will not only determine the reprogramming success probability, but also determine the reprogramming energy and time consumption. To compare the application code size of the different mechanisms, a packet sending and acknowledgement program is used as the example, and the comparison result is shown in Table  8. In the Atmel OTAU, the application is not decoupled from the system, thus the monolithic software image needs to be reprogrammed. In the EMIDE, the reprogramming size is the minimum; because EMIDE uses the pre-linked machine code, no extra interpretation or resolving data needs to be contained in the application image. The application code size of the simpleRTJ is larger than that of the nanoVM, as simpleRTJ is full-time JVM, and a set of exception handling classes are linked inside its application image.
Code Size of Different Components in MIROS Currently, two kinds of network stacks, the Atmel IEEE802. 15. 4  [42]  and the Atmel lightweight mesh stack  [43] , have been ported to the MIROS. In Figure  16 , the code size of different components in the MIROS is shown. If the SFL allocator is applied, the size of the MIROS kernel is 2896 bytes. If the Atmel mesh stack is used, the size of the software firmware is 24,590 bytes. If the Atmel IEEE802. 15. 4 stack is used, the size of the software firmware is 53,234 bytes. These results prove that WSN working core (resource-constrained AVR ATmega1281) Debugging core (powerful SoC Broadcom BCM2835).
Furthermore, MIROS provides a user-friendly application development environment. In this manner, the WSN proliferation can be promoted to more application domains. Typically, MIROS can be applied in the contexts with the following rigorous conditions: (1) nodes are equipped with the low-end microcontrollers, and are constrained in the memory and energy resources; (2) a real-time guarantee is required by some tasks; (3) the deployment environment is harsh so that it is difficult to re-collect the nodes after they are deployed. As for the ongoing work, MIROS will focus on the following topics: Finite-state-machine MIROS: To improve the software reliability further, all the system services in MIROS will be developed by using the finite-state-machine programming style. Every time the code related to a state is executed, the execution result will be checked.
Acknowledgments This work has been sponsored by the  French government research program  " Investissements d'avenir " through the  IMobS3 Laboratory of Excellence  ( ANR-10-LABX-16-01 ), by the  European Union  through the program Regional competitiveness and employment 2007-2013 (ERDF-Auvergne region). Our thanks also to the support from  Jianfeng Yang  ( Electronic Information School, Wuhan University ) for his guidance on our research, to the support from the  China Advanced Technology 863 Research Program  ( 2012AA010904 ), the  China National Natural Science  (No. 60903195 ), and the support from the project " Space satellite research on collaborative ad hoc networks " by the  Innovation Fund of Satellite Application Institute in China Aerospace Science and Technology Corporation.
Remote sensing imagery has been widely used in urban growth and environment analysis with many effective and advanced strategies being developed. However, most of these approaches are separated from each other. There is an urgent need to combine different modules into some practical processing chains. Firstly, we present a comprehensive analysis of key processing chains in applying remote sensing images to urban environment analysis from such aspects as Land Use/Land Cover (LULC), urban landscape ecology, Urban Heat Islands (UHIs), vegetation and water monitoring, change detection, urban ecological security assessment and urban environmental mapping. Secondly, an integrated system, namely Urban Environment Analysis System (UEAS), is implemented based on the OPEN ACCESS Remote Sens. 2014, 6 9459 aforementioned processing chains to analyze urban environment using multi-temporal and multi-source remotely sensed data.
Generally speaking, classification and change detection techniques can be grouped into two main categories: supervised and unsupervised. The former needs a number of samples for training the supervised classifier or detector according to prior knowledge of the study area and used dataset. Representative methods include Post-Classification Comparison (PCC)  [15] , Support Vector Machine (SVM)  [16]  and Artificial Neural Network (ANN)  [17]. The latter directly derives spectral clusters and extracts ground changes without support from ground samples. Typical algorithms consist of Iterative Self Organizing Data Analysis (ISODATA), K-means for classification, image differencing  [18] , Principal Component Analysis (PCA)  [19] , and Change Vector Analysis (CVA) for change detection  [20].
Software System and Case Applications Based on the aforementioned analysis, we developed a software system, namely the Urban Environment Analysis System (UEAS), including basic modules and advanced modules for urban environment analysis. These software routines were developed mainly by Interactive Data Language (IDL) (http://www. exelisvis. com/language/en-US/Company/CompanyHome. asp IDL introduction link). A part of them is combined with ENVI functions. The main functional modules embodied as menu items include (  1  The UEAS is realized with a collection of IDL source files. In order to run these scripts, installation of a virtual machine of IDL 8. x or later is required. The freely distributed virtual machine can be downloaded from the homepage of EXELISVIS (http://www. exelisvis. com).
Then thermal environmental trends were simulated by the Cellular Automata (CA)_Markov model. Processing chains for trend simulation using the CA_Markov model include initial data acquisition and preprocessing, determining the rules of cellular transformation and simulation. The UHIs map of 2007, which is shown in Figure  9b , is simulated on the basis of UHIs distribution maps obtained from 1995 and 2001. Accuracies of simulation maps could be assessed based on the contrast of the true UHIs map and the simulated map.
Acknowledgments This work was funded by the  Jiangsu Provincial Natural Science Foundation  under Grant No. BK2012018 , the  National Natural Science Foundation of China  under Grant No. 41171323 , the  Fundamental Research Funds for the Central Universities  and the  Priority Academic Program Development of Jiangsu Higher Education Institutions (PAPD). The authors would like to thank the Editor who handled our manuscript, the Anonymous Reviewers for their insightful comments and  Xiyan He  for her careful revisions, which improved the technical content and presentation of our manuscript.
The Semantic Web (SW) is now made of billions of triples, which are available as Linked Open Data (LOD) or as RDF stores. The SPARQL query language provides a very expressive way to search and explore this wealth of semantic data. However, userfriendly interfaces are needed to bridge the gap between end-users and SW formalisms. Navigation-based interfaces and natural language interfaces require no or little training, but they cover a small fragment of SPARQL's expressivity. We propose SQUALL, a query and update language that provides the full expressiveness of SPARQL 1. 1 through a flexible controlled natural language (e. g. , solution modifiers through superlatives, relational algebra through coordinations, filters through comparatives). A comprehensive and modular definition is given as a Montague grammar, and an evaluation of naturalness is done on the QALD challenge.
Introduction An open challenge of the Semantic Web  [3]  is semantic search, i. e. , the ability for users to browse and search semantic data according to their needs. Semantic search systems can be classified according to their usability, the expressive power they offer, their compliance to Semantic Web standards, and their scalability. The most expressive approach by far is to use SPARQL  [4] , the standard RDF query language. SPARQL 1. 1  [5]  features graph patterns, filters, unions, differences, optionals, aggregations, expressions, subqueries, ordering, etc. However, SPARQL is also the least usable approach, because of the gap between users and the formal languages that RDF and SPARQL are. There are mainly two approaches to make semantic search more usable: navigation and natural language (NL).
Navigation is used in semantic browsers (e. g. , Fluidops Information Workbench 2  ), and in semantic faceted search (e. g. , SlashFacet  [6] , BrowseRDF  [7] , Sewelis  [8] ). Semantic faceted search can reach a significant expressiveness  [8] , but still much below SPARQL 1. 1, and it does not scale easily to large datasets such as DBpedia 3. Natural language is used in Ontology-based Query Answering (OQA) systems  [9]  in various forms, going from full natural language (e. g. , FREyA  [10] , PowerAqua  [11] ) to mere keywords (e. g. , NLP-Reduce  [12] ) through controlled natural languages (e. g. , Ginseng  [13] ). Existing systems devote the most effort to bridging the gap between lexical forms and ontology triples (mapping and disambiguation), and process only the simplest questions, i.
e. , generate SPARQL queries with only one or two triples. Most of them support none of aggregations (e. g. , counting), comparatives, or superlatives, even though those features are relatively frequent  [14]. This means that even if full natural language is allowed as input, expressiveness is in fact strongly limited. A less studied aspect is the update of RDF datasets, i. e. , the insertion and deletion of triples. SPARQL 1. 1 offers an update language to this purpose but with the same usability problem as the query language. Proposals for more usable interfaces have been made in faceted search (e. g. , UTILIS  [15] ), and as a controlled natural language (e. g. , ACE  [16] ). We think that update (and creation) of RDF data is as important as querying for end-users because it makes them first-class citizens, rather than consumers only.
In this paper, we define and evaluate SQUALL, a Semantic Query and Update High-Level Language  4. Its contribution is:  (1)  to offer the full expressiveness of SPARQL 1. 1 Query/Update (SPARQL for short) apart from a few details,  (2)  to cover a significant fragment of natural language (English), and (3) to be defined in a domain-independent way and in a concise way (its grammar has about 120 rules). SQUALL qualifies as a Controlled Natural Language (CNL)  [17, 18]  because it combines a fragment of natural language syntax, and the unambiguous semantics of formal languages. The main advantage of CNLs over formal languages is a better readability and understandability by people whose background knowledge does not cover logic or computer languages. SQUALL provides a lot of syntactic flexibility in that a same SPARQL query/update can be expressed in many different ways.
A triple (s p o) is made of 3 resources, and can be read as a simple sentence, where s is the subject, p is the verb (called the predicate), and o is the object. For instance, the triple (Bob knows Alice) says that "Bob knows Alice", where Bob and Alice are the bare qualified names of two individuals, and knows is the bare qualified name of a property, i. e. , a binary relation. The triple (Bob rdf:type man) says that "Bob has type man", or simply "Bob is a man". Here, the resource man is used as a class, and rdf:type is a property from the RDF namespace. The triple (man rdfs:subClassOf person) says that "man is a subclass of person", or simply "every man is a person". The set of all triples of a knowledge base forms an RDF graph. RDF query languages  [21]  provide on semantic web knowledge bases the same service as SQL on relational databases.
They generally assume that implicit triples have been inferred and added to the base. The standard RDF query language, SPARQL 1. 1  [5] , reuses the SELECT FROM WHERE shape of SQL queries, using graph patterns in the WHERE clause. A graph pattern G is one of: • a triple pattern (s p o. ) made of RDF terms and variables (e. g. , ?x), • a join of two patterns (G 1 G 2 ), • an union of two patterns (G 1 UNION G 2 ), • a difference of two patterns (G 1 MINUS G 2 ), • an optional pattern (OPTIONAL G 1 ), • a filter pattern (FILTER C), where C is a constraint, i. e. , a Boolean expression based on predicates (e. g. , comparing, matching), functions (e. g. , arithmetic, string concatenation), and the (un)satisfiability of a graph pattern ((NOT) EXISTS G 1 ), • an assignement to a variable: either of the result of an expression (BIND (expr AS x)), or of a RDF resource (VALUES x { res }), • a named graph pattern (GRAPH g G 1 ), where g denotes a named graph, in which the graph pattern G 1 should be matched, • a service graph pattern (SERVICE uri G 1 ), where uri points to another SPARQL endpoint against which the graph pattern G 1 should be matched, • a subquery.
SQUALL overview through SPARQL features This section presents an overview of the SQUALL language by giving for each SPARQL feature its counterpart in SQUALL. It aims to give the reader a first taste of the language, and also a first assessment of its expressiveness compared to SPARQL. This list of SPARQL features is adapted and extended from a comparison of RDF query languages  [21]. For each feature, SQUALL sentences are given as illustrations, with relevant parts underlined. For the sake of simplicity, we assume that all resources belong to a same namespace so that bare qualified names can be used (e. g. , "person", "author", "Paper42"). The SPARQL translation of SQUALL sentences can be obtained from the translation form at http://lisfs2008. irisa. fr/ocsigen/squall/. Triple patterns. Each noun or non-auxiliary verb plays the role of a class or predicate in a triple pattern.
This is a common practice in the compilation of high-level programming languages, and has a number of advantages. First, it makes the semantics easier to write and understand because defined at a more abstract level. As a side effect, it would also make it easier to redefine SQUALL for other natural languages than English. Second, it gives freedom in the choice of the implementation. For instance, the operational semantics of the intermediate language can be given by translating it to an existing language, e. g. , SPARQL; by interpreting it in a relational algebra engine; or by using continuation passing-style, like in Prolog. In Section 5, we describe a solution for the first approach. SQUALL sentences are decomposed into noun phrases, verb phrases, relatives, determiners, prepositional phrases, etc.
However, when there are dimensions (e. g. , a GROUP BY clause), the description of what has to be aggregated depends on the values taken on each dimension ([e]), hence the type ([e] → p1) → p1 for aggregators. This type is a complex analogue of the type of quantifiers (p1 → s). Because the focus of this paper is about the SQUALL language and its correspondence with SPARQL, we do not elaborate much about the lexical analysis, i. e. , about the translation from concrete word forms to a Semantic Web vocabulary. There is active research on this task (see Section 8), and integrating their results is left to future work. The current implementation of SQUALL has a default definition of lexical units based only on URIs, and SPARQL built-ins (see below), but the way it is coded makes it relatively easy to extend those definitions for a particular vocabulary.
Syntactic rules In this section, we describe the syntactic rules of SQUALL in a modular fashion, where each module corresponds either to some SPARQL feature, or to some natural language feature, and often to a combination of both. This has the benefits to split the whole grammar (about 120 rules) in smaller parts, and to emphasize the relationships between SQUALL and SPARQL. This is also a way to assess the coverage of SPARQL by SQUALL (see Section 6 for a more rigorous evaluation of expressiveness). The reader should feel free to skip some modules, or to ignore the formal grammars on first reading.
Quantifiers as determiners Quantifiers are commonplace in natural languages in the form of determiners, whereas they are notoriously difficult to express in SPARQL or SQL  [27]. Determiners behave as binary quantifiers (type s2), but unary quantifiers (type s1) can be cast as binary quantifiers by conjuncting the two descriptions. The definite article the has its own semantic primitive because it is interpreted either as the existential quantifier or as the universal quantifier depending on its syntactic context (see Section 4. 6). A noun phrase can be formed by a determiner followed by a noun group (NG1 ). A binary noun phrase (NP2 ) is a noun phrase abstracted over an entity, and is made of a relation noun group (NG2 ). Noun groups are based on a noun (a relational noun for NG2 ), and may be modified by an adjective, an apposition (App), and a relative clause (Rel ) (to be defined in the following sections).
Comparisons Although comparators have type p2 and can therefore be verbalized as transitive verbs (e. g. , is greater than), or as transitive adjectives (e. g. , greater than), they deserve a special treatment because of the rich combinations offered by natural languages. We define below a number of constructs that do not increase SQUALL's expressivity, but that improves a lot SQUALL's naturalness and concision when expressing comparisons. We only detail here the "greater than" comparator (constant gt), but other comparators are straightforward to add. Relatives are extended by using comparators as transitive adjectives, and by adding "between" as a ditransitive adjective. Their semantics is the same as for transitive adjectives. Rel → greater than OP { λx. (op λy. (gt x y)) } → between OP and OP { λx.
Translation to SPARQL The generation of a SPARQL query or update from the intermediate representation of semantics is much simpler than syntactic and semantic analysis because it mostly consists in mapping logical constructs to SPARQL constructs, which are at the same level of abstraction. Note that the intermediate representation would make it easy to support another target RDF query language. As an illustration, the SPARQL translation of the SQUALL sentence "For which researcher-s X, in graph DBLP every publication whose author is X and whose :publication year is greater than 2000 has at least 2 author-s?", from the introduction of Section 4, is as follows: The two nested FILTER NOT EXISTS encode the universal quantifier "every", and the subquery with aggregation encodes the numeric quantifier "at least 2".
and per var n } Constraints are also translated to sentences, using the same SQUALL coordinations for Boolean operators as for relational algebra operators. Constraints simply produce sentences based on predicates, where graph patterns produce sentences based on classes and properties. Therefore, unary predicates translate to nouns (like classes), and binary predicates translate to transitive verbs (like properties). Expressions translate to noun phrases, as they play the same role as variables and RDF terms. We have looked in detail at SPARQL's grammar 9  in order to identify all restrictions of SQUALL compared to SPARQL. The main restriction is arbitrary length property paths (e. g. , (ˆauthor/author)+), which involves a form a recursivity that is difficult to express in natural language.
Evaluation on the QALD challenge This section reports on the evaluation of SQUALL on the QALD-3 challenge, in which we took part. The QALD 10 challenge (Query Answering over Linked Data) provides "a benchmark for comparing different approaches and systems that mediate between a user, expressing his or her information need in natural language, and semantic data". The last campaign, QALD-3, provides hundreds of questions in natural language over two large and real linked datasets: DBpedia  [33]  and MusicBrainz  [34]. The principle of the challenge is that a training set of 100 questions is provided, along with SPARQL translations and answers, and systems are evaluated on a test set that is made of 100 new questions. Systems are compared in terms of precision and recall for the test questions.
The QALD questions do not cover all features of SPARQL 1. 1, and hence, do not permit to evaluate all features of SQUALL. However, we find that the DBpedia questions provide a rich set of questions in natural language on many topics, and cover a wide range of SPARQL features including aggregations and solution modifiers. The missing features are updates, named graphs, built-ins and expressions, graph literals (CONSTRUCT and DESCRIBE queries), and collections. The objective of our participation in the QALD-3 question answering task was to evaluate the capability of SQUALL to express English questions in a natural and precise way, and the precision and recall of its SPARQL translations. Because our approach relies on a reformulation of the original questions, which is allowed by the QALD challenge, the QALD measures of precision and recall are not enough to evaluate it.