dataesr/scientific-paragraphs-categorization huggingface dataset:
Acknowledgments: The authors would like to express their gratitude to the following individuals for their invaluable help during the project: His Majesty the Sultan Sepuh XIV PRA and Iwan Purnama for authorizing the acquisition of the Kasepuhan dataset; Father Jérome Hess of the St-Pierre-le-Jeune parish for his gracious authorization for the acquisition of the St-Pierre dataset and Samuel Guillemin of the ICube-TRIO Laboratory for his help during the acquisition; the DAD and DIATI research groups of the Turin Polytechnic for their willingness to share the Valentino dataset; and Mathieu Koehl and Xiucheng Yang of the ICube-TRIO Laboratory for sharing the HK-Castle dataset. The following persons also contributed via important discussions and suggestions: Deni Suwardhi of Bandung Institute of Technology, Hélène Macher and Rami Assi of the ICube-TRIO Laboratory, Francesca Matrone of Politecnico di Torino, and Sutrisno Murtiyoso of the Indonesian Institute for History of Architecture.
Computer programs have taken an important role in the prediction of future ecological trajectories. This study reviewed the existing computer programs that aim to predict future trajectories of ecosystems, biological populations, or ecological systems. Overall, 106 programs were examined. A rich set of programs exist and most of them are free. A substantial proportion (43%) are distributed open source. A majority (57%) of these programs took some form of uncertainty into account, although not always in a rigorous way. Programs considering uncertainty were preferentially implemented in a standard compiled language (C/Fortran) or a statistical language (R). The vast majority of the programs were delivered with recent, sometimes extensive, documentation. None of the reviewed programs used an open-source collaborative framework.
Clearly, computer programs have an important role to play here since uncertainty assessment is typically based on computer-intensive methods. The rise of open source software and worldwide networks such as the Internet has been a formidable stimulus for the development and spread of computer resources. For instance, scientific fields such as bioinformatics have now adopted a "free and open source software" (FOSS) model for the publication of computer programs. Furthermore, the availability of freely distributed computer programs is a requirement for publication in journals such as Bioinformatics, BMC Bioinformatics, or Methods in Ecology and Evolution. FOSS is not only about the price of the computer programs, but also about portability, repeatability, and open knowledge  (Wheeler, 2015). The following definitions are used in this paper: an 'ecological system' is a set of interacting living entities that also interact with their environment which can itself be composed of living and/or non-living entities.
An 'ecosystem' is an ecological system that is restriced to a geographically defined area (e. g. , a lake, a forest). A 'biological population' is an ecological system whose entities are individuals belonging to the same species so their interactions are directed by some specific activities (e. g. , mating, feeding). An ecological system is characterized by a number of variables (e. g. , nutrients, species richness, number of individuals, age structure). 'Prediction' aims at finding the predicted values of these variables in the future. In this paper, I report the results of an investigation of the availability of computer programs aimed at predicting the future trajectories of ecosystems, ecological systems, or biological populations. The main objectives were firstly to provide a global picture of the "software ecosystem"  (Manikas, 2016)  available for ecological prediction, and secondly to identify the issues that require attention to improve this 'ecosystem' following the statements from IPBES.
Is there a support for users? 10. Is there a mailing/discussion list? These questions were defined before investigating the programs; however, the way they were addressed was adjusted during the study. Considering the large number of programs found that meet the above criteria, it was not practically possible to run and test all of them. The answers to questions 1 and 3-7 were searched by reading the documentation or the general presentation of the program (e. g. , section "About" of a web page). Questions 2 and 8-10 were answered by looking at the web pages of the program. Further information to answer questions 1, 3, and 8 were found by inspecting the downloaded programs. Questions 2 and 3 are not independent and are related to the distribution licence of the programs. However, the licence under which a computer program is distributed is a complex issue as illustrated by the many existing free licences (e.
g. , https: //en. wikipedia. org/wiki/Free_and_open-source_software). Furthermore, a program can be published under several licences or its licencing status can change through time (e. g. , https://www. r-project. org/Licenses/). Although this is clearly an important isssue, it was out of the scope of the present study which considered only the availability of source code. Questions 3 and 4 were connected since some programs are distributed simply as source code and not as compiled executables for one or several specific OSs, so 'source code' was a separate category when answering question 4. In order to be more specific, if any form of source or computer code was available, then the program was considered as 'open source' (question 3), whereas if a program was packaged only with its source code, then it was considered as 'source code' (question 4).
Thus, a program could be 'open source' while not being distributed as 'source code' (whereas a program classified as 'source code' is necessarily 'open source'). The distinction between these two categories stems from the fact 'source code' programs are often independent of the OS. In order to answer question 6, the programs that model a specific system (e. g. , diffusion of pollutants) or consider a specific geographical area were classified as specialist. Programs that consider or model a system which can be considered generic (e. g. , a biological population, a watershed) were classified as generalist. Question 6 stems from the importance of being able to use the outputs of a program for further downstream analyses with other program(s), for instance, for uncertainty assessment, or graphical display.
Almost all programs were distributed on dedicated web pages: only two were distributed on GitHub and two others on R-Forge. One hundred and two programs (96%) were available free, some of them after registration, three were available as commercial products, and one was available as a free demo version. For 34 programs (32%), it was not possible to find the computer programming language or platform used for implementation. For 24 programs (23%), a standard compiled language C or Fortran (or one of their variants or dialects: F77, F90, C++, or C#) was used (Fig. 1 ). Eleven programs were implemented in Excel, six in R, six in Python, six as ArGIS modules, four in Java, one in Julia, and one in Delphi. Six programs were modules of commercial programs (e. g. , SAS, Matlab). Finally, seven programs were available as Web forms through Internet and not available for download.
Forty-six programs (43%) were available as open-source, 33 (31%) were distributed only as compiled applications and their sources were not available, one was available as open-source subject to collaboration, and four were commercially distributed. The open-source status of the remaining 22 programs (21%) could not be determined (Fig. 2 ). For the analysis of OSs, the programs coded in Excel or in Java were considered as source code because a wide range of office applications can run Excel spreadsheets on most OSs, and there are many Java environments on most OSs as well. The vast majority of programs were available as applications running under Windows (73 or 69%), or even only for this OS (55 or 52%; Fig. 3 ). Twenty-nine (27%) programs were distributed as source-code, and exclusively in this form for 22 of them (mainly as Excel code and secondarily as R programs which are OS-independent).
Only one program was available only for Linux, and none of them were distributed as MacOS application. Additionally, one program run under 16-bit MS-DOS, and the running OS of two programs was not found. A majority of programs (47 or 44%) output their results as text files, either only (37 or 35%) or in association with other formats (GIS or HDF5; Fig. 4 ). Six programs output their results in various file formats (labelled as "many" on Fig. 4 ). Seventeen programs (16%) did not output files, 13 output Excel files, and two output results in files that cannot be interfaced with other software (PDF reports or private format). Finally, the output format could not be determined for 13 programs (12%). The vast majority of the programs (71 or 67%) were specialist. There seemed to be an association between this variable and the programming language used: programs coded in Excel or as Web forms were all specialist, whereas the generalist ones were more represented among the programs implements in C/Fortran, R, or under a commercial platform (Fig.
5 ). No association with other variables were apparent. Uncertainty was a feature in 60 (57%) programs, while this could not be found in six of the 106 (6%). There was a very significant association between this variable and whether a program is specialist or generalist: among the 35 generalist programs, 30 took uncertainty into account, whereas 30 specialist programs did out of 71 (Fisher's exact test: P < 0. 0001; this test excluded the six programs where handling of uncertainty was unknown). There was also an association with the programing language: programs taking uncertainty into   account were implemented in C/Fortran, R (all four of them) or with commercial programs (also all four of them; Fig. 6 ). On the other hand, programs in Python, Excel, or available as Web forms did not mostly consider uncertainty.
Discussion The present study leads to draw an overall positive picture of software for ecosystem prediction: a remarkable diversity of free programs are available, their associated documentations are generally of good quality (sometimes very extensive), and a good percentage (43%) are also distributed open-source. Another significantly positive feature is that a majority of programs output their results in file formats which are easily read by other software, considering that Excel files can be open by many other programs (see for instance the R-package 'readxl';  Wickham and Bryan, 2019). Remarkably, US federal agencies took a major part of the programs considered here. This highlights several points. First, this emphasises the importance of public agencies in making available to the public the research work on ecosystems and biodiversity.
From a practical point of view, it is important for programs to include the possibility to save their outputs in a format which can be read and write by the vast majority of software (typically text). Parallel computing will also certainly attract more attention in the future in order to implement such intensive computing tasks. Interestingly, parallel programming is available in the major languages observed in this study (C, C++, Fortran, R, Python). It is interesting to note that the programs considering uncertainty were preferentially implemented in compiled languages (C/Fortran) or in a statistical language (R). This highlights the need to use a performing computer language to implement uncertainty. Moreover, these languages are widely used, free, and efficient implementations (e. g. , the GCC compilers) are available to all users.
It It is regrettable that the computer programs for ecosystem prediction do not currently benefit of this free service. Open source is not only about the price of the software, it also makes possible to develop code in a more transparent and efficient manner with two major side-effects: scalability and integration. The latter feature is of particular importance for ecosystem prediction. Indeed, predicting future ecosystem trajectories, or some of its characteristics such as ecosystem services, often requires the integration of different components  (Titeux et al. , 2016; Di Minin et al. , 2017). Open software makes integration of different components much easier than closed systems  (Wheeler, 2015). In this perspective, the integration of spatial data, for instance land use and land cover data, is a predominant feature or many studies attempting to predict changes in ecosystems or biodiversity  (Titeux et al.
Furthermore, only 50% of these tools are being updated after the end of the project. Interestingly, only a small portion of these tools (3. 4%) were available as downloadable programs, and a minority (31%) were integrated with other tools. No mention of either "source code" or "open source" is made in this study. GIS data, an open binary format (e. g. , GeoTIFF or netCDF for more complex data structures) should be preferred to simple text files. The main criterion for guiding decisions in an open-source software development project should always be quality over quantity. Releasing a lot of computer code that it is not operational, that has not been tested or documentated is very likely to be a waste of resources.
There are free implementations for all common OSs of these languages. Furthermore, they make possible high-performance computing, and there already exist a wide range of tools in these languages to handle the data commonly encountered in ecosystem modelling (see for instance the package rgdal for reading GIS data in a wide range of formats  Bivand et al. , 2018). 2. Uncertainty: there is need to have more rigorous implementation of uncertainty in ecosystem predictive modelling. The statement that "different input parameter values" can be tested is not generally a valid approach, and should be avoided. Statistical techniques such as weighted integration should be considered more widely. 3. Output file formats: greater care should be taken on output formats. Even if using the standard text output files, a number of difficulties may be encountered, typically related to encoding, text layout, or file sizes.
Open-source autopilots for diverse environments The choice of open-source is important, because the autopilots thus designed can benefit from all the support of the community to integrate and propose the most efficient algorithms from the literature. It is therefore the ideal choice for research work. Within this category, many autopilots are exclusively developed for the air domain  (Chao et al. , 2010 , Colomina, Molina, 2014)   ). This allowed these two autopilots to take full advantage of other projects that can be found in the fold of DroneCode such as MAVLink (Micro Air Vehicle Link), a communication protocol  (Koubaa et al. , 2019)  and QGroundControl, a mission planning and monitoring software (Ramirez-Atencia,  Camacho, 2018). From 2016, Ardupilot remained in the spirit of free code by keeping the GPL license, while PX4 and the other projects federated by DroneCode went into BSD license in order to market their solutions (source codes can then become proprietary codes).
A more appropriate solution is to start with readymade development modules. Those boards, available at a very low cost (around 10$), provide some utilities around a microcontroller (USB to UART interface, CPU pin, reset buttons, etc. ) beside providing some voltage peaks protection. Then it only remains to design an electronic support board that distributes the inputs / outputs to take full advantage of all the resources of the micro-controller and obtain functional hardware for the low-level unit. The two main families of microcontrollers powerful enough to run Ardupilot are the STM32 and the ESP32. The STM32 family of micro-controllers is the one used on the Pixhawk and on other hardwares for Ardupilot as it is the one which is natively supported by the autopilot. They are powerfull and efficient micro-controllers.
On the other hand, for the same price, the ESP32 modules are more efficient and, since they are optimized for IoT, they consume much less energy. They also have a built-in WiFi which is an interesting feature to easily communicate directly with the low-level. And, as they have various built-in additional calculation units, it can be usefull to introduce some security encryption over MAVLink protocol to secure the communication link with the ground station (a functionality under development) without adding an additional electronic module. Our choice therefore fall on the ESP32. All the sensors can be changed and upgraded easily, the module itself can be quickly changed in the event of failure at minimal cost, including during a field mission, and the simplicity of the support board will limit possible failures.
PORTING ARDUPILOT TO ESP32 2. 1 Ardupilot: overview The Ardupilot embedded software suite offers a set of solutions to be able to use the chosen vector with a variable degree of autonomy, from assisted steering to automatic navigation, provided if sensors capable of acquiring the necessary information for the different algorithms to operate (attitude, altitude / depth, absolute position, speed, distance, etc. ) are available  (Audronis, 2017). To allow its portability on several types of boards (hardware) and to adapt to a great diversity of robotic architectures (vectors), Ardupilot is based on different layers of abstraction. As shown in figure  2 , there are three particularly important layers of abstraction: one for the hardware, one for the sensors and the last one for the kind of vehicle (and therefore the robot dynamics).
The hardware abstraction allows independence from specifics of the board on which Ardupilot runs. The link between physical material and abstractions is described in a module: the HAL (Hardware Abstraction Layer). Each type of board therefore has its own HAL. But what makes Ardupilot so convenient is that this layer of abstraction makes all the other layers completely independent of physical material. In fact, they exclusively use the abstractions defined by the HAL to interact with the peripherals and memories. In other words, this mode of operation is similar to a request system. For example, to recover the data measured by a sensor, the driver implements the sensor logic and the way of using it. Then it sends the commands to the HAL which implement the underlying protocols like I 2 C, SPI or UART using hardware module specific to the board.
So, only the HAL knows how to communicate with the hardware and the other higher modules of Ardupilot can continue to work the same way whatever the board used. The variability of the sensors that can be connected to specific hardware is also managed at the HAL layer. We can distinguish two types of sensors: those that are integrated into the board and those that can be added. The former are critical: without them there is no possible action for the robot. For example, to make a drone flying, at least an AHRS (Attitude and Heading Reference System) and a barometer are needed. These critical sensors are meant to be natively implemented on the board. The user can calibrate and configure them but doesn't need to care about how they are connected to the board. The other sensors that the user can choose to connect or not are considered external: Ardupilot scans the different communication ports at startup to establish the list of sensors actually available by recognizing them with their identifiers.
), to describe its specificities (number of motors, their position relative to the center of gravity, their direction of action, etc. ) and offers a chain of basic modules adapted to this set as well as the corresponding safety and security procedures (returning to the base or landing when the signal from the ground station is lost, for example). Finally, to complete this overview, Ardupilot operates on top of the minimalist on-board operating system (OS) which is responsible for accessing the functionalities of the micro-controller and managing its operation. The OS of micro-controllers are real time OS, that is to say that they manage time very strictly: indeed, the maximum time to perform an action from its launch (jitter) and the scheduling of these actions are precisely determined. Ardupilot and the real-time OS are compiled in a single firmware which forms the program integrated into the microcontroller.
Porting HAL on ESP32 We saw in the introduction that Ardupilot was developed for the family of STM32 micro-controllers. Those embed the ChibiOS real-time operating system. Our hardware solution is based on the ESP32 family of micro-controllers that embeds the Free-RTOS real-time operating system. It will therefore be necessary to port the Ardupilot code on this new family of microcontrollers to benefit from all its functionalities. But as we saw in the previous section, thanks to the levels of abstraction, the modifications required for porting Ardupilot are all exclusively located in the HAL. In this section, besides of all the problems involving porting a program to a new micro-controller unit, we will present the two main changes that need to be addressed: the differences in hardware layout and the differences in scheduling on simple or multiple cores.
The familly of ESP32 micro-controllers is optimized for IoT applications, which explains the major architectural differences with the STM32 familly. Indeed, the needs of IoT focus on energy saving and ease of communication more than on processing speed performance. This is why the ESP32 does not have DMA (Direct Memory Access) unlike the STM32. When this device exists, the data passing through a peripheral is managed by a dedicated controller which redirects it to the main memory without the intervention of the CPU (Central Processing Unit) apart from the start and end orders of the action. On the contrary, in its absence, the entire action is taken over by the CPU, so it is therefore necessary to review all the memory accesses in the HAL to make these modifications. It increases the overall load of CPU, but as the processor of the ESP32 is powerful, that does not pose any problem concerning the speed of execution in the end.
The second problem comes from the fact that the compilation tools for each of these two entities are different (waf for ardupilot, cmake for FreeRTOS). On STM32, Ardupilot code reimplements the compilation of ChibiOS in an integrated manner. But that implies maintenance every time there is an update on Chi-biOS. The alternative we have chosen is to compile the two by their respective toolchain in static libraries and then link them together in a single final binary to create the firmware to flash on the ESP32. Figure  3. On the left, the internal elements of our low-level unit (the custom support PCB, the integrated IMU and the ESP32 board). On the right: our low-level unit assembled.
RESULTS The previous section presented how to port the Ardupilot software to a new range of micro-controllers and what problems are posed by this port. It is recalled that the objective is to obtain a universal solution for the low level critical architecture suitable for all types of platforms dedicated to close-range remote sensing, whatever the environment of evolution (aerial, terrestrial, surface or underwater). To demonstrate the universality of our solution, we therefore worked on different exploration robots developed by our team to cover all of the evolution environments. All these robots have the same low level unit (Ardupilot on ESP32, see figure  3 ), the particularities of each robot (the number and orientation of motors, their orientation, the friction of the frame in the environment, the available sensors, etc.