dataesr/scientific-paragraphs-categorization huggingface dataset:
Model Input and Tool Conversions Despite their very different features, all the tools considered here take as input a logical model, in an adequate format. All the related Python modules provide a load function, which takes as input the location of the model, being a local file, for instance: m = biolqm. load("path/to/localfile. sbml") a web link to a file, as obtained on GINSIM repository 12  for instance: m = biolqm. load("http://ginsim. org/sites/default/ files/Traynard_Boolean_MamCC_Apr2016. sbml") or a web link to the model on CELLCOLLECTIVE, for instance: m = biolqm. load("https://cellcollective. org/ #5128/lac-operon") In each case, the returned object (identified by m in the above examples) is a Python object representing the loaded model and defined specifically for the corresponding tool (Python module).
BIOLQM -Qualitative Model Toolbox The biolqm Python module provides direct access to the Java programming interface of BIOLQM (Naldi, in review 6 ). BIOLQM is available and documented at http://colomoto. org/biolqm. BIOLQM supports the conversion of SBML-qual files, GINML files, as well as simple textual files specifying the raw logical functions into the formats associated with the different software tools. Besides the file format features, BIOLQM implements model modifications, such as mutations forcing the value of given nodes, iterative model reduction (see above), model reversal, the conversion of multi-valued model into Boolean ones, as well as the computation of stable states, trap spaces, and simulations. Part of these features are illustrated in the Supplementary File "Notebooks/demo-biolqm" 15.
PINT -Formal Predictions for Controlling Trajectories The pypint Python module provides complete access to features documented at https://loicpauleve. name/pint. The software PINT is devoted to the analysis of trajectories in very large-scale asynchronous Boolean and multi-valued networks  (Paulevé, 2017). Its main features include the verification of the existence of a trajectory reaching a state of interest (reachability), the identification of common points between all the trajectories leading to a state of interest (cut sets), and the formal prediction of mutations preventing the existence of any trajectory to the given state. These features are illustrated in the Supplementary File "Notebooks/demo-pint" 16.
In the above example, S specifies a property on a state, by giving the values of some nodes of the network. The conversion of a network model into NUSMV format depends on the tool used, sometimes introducing different variable names for the nodes of the original biological network. But this technical point is transparent for the user: the nusmv Python module will automatically translate the node names into the correct NUSMV variable names. The Supplementary File "Notebooks/demo-nusmv" 17  gives a simple example of usage of the nusmv Python module to verify properties of a GINSIM model.
MaBoSS -Stochastic Simulations The maboss Python module provides an interface to MABOSS, available at https://maboss. curie. fr, as well as basic plotting functionalities  (Stoll et al. , 2017). The purpose of MABOSS is to perform stochastic simulations of a Boolean network, where the propensity of transitions (probabilistic rates) are explicitly specified. The Python module allows to fully define and parameterize a model, as well as to parse an existing MaBoSS model and modify it programmatically. The object returned after the simulations can then be used to plot the probability of node activation over time, and the proportion of states in which the simulations ended, in order to estimate the probability of reaching different attractors. The Supplementary File "Notebooks/demo-maboss" 18  provides a brief tutorial to the main features of the maboss Python module.
Advanced Combinations of Tools These Python modules provide a unified interface to chain different tools and process their results. The small tutorials referenced above show simple chaining of tools, most of the time using a tool to import a model (e. g. , from CELLCOLLECTIVE or GINSIM) and convert it (using BIOLQM) for specific analysis by another tool. As the Python functions of the different modules rely on standard Python data-structures, such as lists and dictionaries, it is possible to easily re-use the result from a tool function as input to the function of a different tool. A simple example is provided in Supplementary File "Notebooks/demoginsim" 19  , where we use BIOLQM to compute the stable states of a GINSIM model, and then give one of the resulting state as input to GINSIM show function to display it over the regulatory graph.
Moreover, one can use the programmatic features of Python to implement advanced algorithms for executing multiple analyses and process their results. For instance, one can program loops to iterate over a list of results of a preceding analysis from one tool to perform a subsequent analysis on each result with another tool. This is illustrated in the Supplementary File "Notebooks/demo-pint+maboss" 20  , where we use PINT to formally predict combinations of mutations controlling the existence of trajectories toward a specified state; then, we quantify with MABOSS the efficiency of applying only partially the predicted combinations, by evaluating each related doublemutants. The example involves Python for loops and a function to enumerate all possible subsets provided by the standard Python library.
CoLoMoTo Jupyter Interactive Notebook Jupyter 21  is a software providing an interactive web interface for creating documents, called notebooks, mixing code, equations, and formatted texts. A notebook typically describes a full analysis workflow, combining textual explanations, the code itself, along with parameters to reproduce the results. A notebook is a single file, which can be easily modified, shared, re-executed, and visualized online. The short tutorials of the previous section provided in the Supplementary File "Notebooks" are actually Jupyter notebooks (files with the extension. ipynb) and can be re-executed using Jupyter. A Jupyter notebook is made of a sequence of so-called cells, which can contain formatted text, including sections, links, images, tables, etc. , or which can contain code in a specified programming language, typically Python.
A code cell can be executed (by pressing Shift-Enter) and the value returned by the code is displayed below the cell. The display format is selected according to the type of the returned value (image, graph, list, table,. ) to offer an adequate visualization. Having a unified Python interface to invoke the CoLoMoTo software tools, one can directly create Jupyter notebooks for the analysis of qualitative biological networks using these tools, as shown in Supplementary File "Notebooks" and in the companion publication providing a complete model analysis workflow  (Levy et al. , 2018). We added several features in the CoLoMoTo Python modules to increase interactivity and improve the user experience for editing Jupyter notebooks. First, menus provide pre-defined Python code for accessing to the main features of the tools.
Once validated, the Docker image is then tagged with a time-stamp, typically the date of the image validation (of the form YYYY-MM-DD, e. g. , 2018-03-31). These tagged images are then stored in the public Docker image registry, and can be retrieved any time later. The list of existing tags of colomoto/colomoto-docker Docker images can be viewed at https://hub. docker. com/r/ colomoto/colomoto-docker/tags/. When sharing a notebook, and notably when attaching it to a publication, it is highly recommended to specify the timestamp of the Docker image in which the notebook has been executed. Then, by downloading the image with this specific tag, other users are ensured to repeat the execution in the exact same software environment. To help following this recommendation, we took two technical decisions.
First, we do not use the default non-persistent tag for Docker images (latest). It means that the user has always to specify explicitly the time-stamp of the CoLoMoTo Docker image. To remove the burden of actively checking the list of existing time-stamps, we provide a script which, by default, fetches the most recent Docker image (see section 5). Second, when loading a CoLoMoTo-related Python module within a Docker container, a textual message indicating the time-stamp of the Docker image is displayed. Therefore, when created within a CoLoMoTo Docker image, notebooks always contain the required information to repeat their execution. Because a Jupyter notebook is a single file containing everything to execute it, one can easily check if it can be replicated in a different software environment, e.
g. , using a more recent CoLoMoTo Docker image. Moreover, a notebook can be easily repurposed by modifying some arguments of the Python function calls, for instance changing the input model or analysis parameters. One can even define interactive notebooks describing a common model analysis, so that the user only needs to provide the input model and execute the Jupyter code cells, as shown in the Supplementary File "Notebooks/demo-interactivefixpoints" 22  for the computation and visualization of the stable states of a bioLQM model.
Reproduce Analysis With a Different Method Reproducing the same analysis with two different methods is a good mean to increase confidence in the results, as it reduces the chance of software misuse or that the results are affected by a software bug. The subset of software tools selected for this first CoLoMoTo Docker image presentation already provides redundant implementations of equivalent model analyses, in particular for the identification of stable states and for the verification of temporal properties with NUSMV. To help switch between two tools for performing the same task, we harmonized the usage of Python module functions to ensure that the same functions with the same arguments generate equivalent results with different tools.
Stable States There exists several methods to compute the full set of stable states (or fixed points) of a logical model, relying on different data-structures and different algorithms. The software BIOLQM implements the computation of stable states for Boolean and multi-valued logical models using a Java implementation of decision diagrams. In contrast, the software PINT implements the computation of stable states of Automata networks (a generalization of logical networks) using Boolean satisfaction constraints. As BIOLQM provides a conversion of Boolean/multivalued network into equivalent Automata networks, it is possible to compute the stable states of a model with both software tools. Both biolqm and pypint Python modules provide a fixpoint function taking as input the model instance of the corresponding tool and returning a list of Python dictionaries describing the stable states.
Provided lqm is a BIOLQM model, the following Python code compute its stable states with both tools: fps_biolqm = biolqm. fixpoints(lqm) fps_pint = pypint. fixpoints(biolqm. to_pint(lqm)) The Supplementary File "Notebooks/demo-reproducibilityfixpoints" 23  shows a complete example of reproduction of stable state computation using BIOLQM and PINT.
Temporal Property Verification (Model-Checking) Both GINSIM and PINT allow to export their respective model into NUSMV format, where temporal properties can be specified using LTL or CTL (see section 2. 2). However, the generated NUSMV models have different features as the input formalisms of these tools rely on different paradigms: the specification is centered on logical rules in the case of Boolean/multivalued networks in GINSIM, and on transitions (à la Petri nets) in the case of Automata networks in PINT. Nevertheless, in the appropriate settings, the verification of an equivalent CTL or LTL property should give the same result. Hence, the functions ginsim. to_nusmv and pypint. to_nusmv are implemented in such ways that, when using their default options, the resulting NUSMV models, albeit different, should produce identical results for identical temporal logic properties.
Note, however, that each tool provides specific options for the NUSMV export, which can lead to incomparable results. The following Python code uses operators defined in the Python module colomoto. temporal_logics to specify a property p, meaning that from any state, there always exists a trajectory leading to a cyclic attractor where the level of node a can always oscillate. Then, assuming lrg is a GINSIM model, the code uses GINSIM and PINT conversions to NUSMV to perform model verification. The Supplementary File "Notebooks/demo-reproducibilitymodelchecking" 24 provides a more detailed example of the reproduction of model-checking results using GINSIM and PINT.
Academic Use Cases The prime aim of the CoLoMoTo Interactive Notebook is to foster the production of accessible and reproducible computational analysis of biological models, with a focus on qualitative models, including Boolean and multi-valued networks. As demonstrated in the Supplementary File "SnakeMake", the CoLoMoTo Docker image can also be used in standard workflow systems, such as SnakeMake, to lighten the burden of installing the different software tools and make them accessible on different operating systems. A notebook issued from the CoLoMoTo Docker image gives some guarantees of repeatability, as it contains references to the persistent Docker image to re-execute code in the same software environment. Therefore, the notebook file (with. ipynb extension) can be distributed as a Supplementary File of the related scientific article, along with instruction to run the Docker image.
The Jupyter interface further allows to export the notebook in a static HTML file, which could also be joined as a Supplementary File to provide a quick visualization. A notebook can also be distributed independently, for instance by publishing it on Gist 27  or myExperiment 28   (Goble et al. , 2010) , to follow download and potential updates. For instance, the tutorial notebook presented by  Levy et al. (2018)  is hosted at https://gist. github. com/pauleve/ a86717b0ae8750440dd589f778db428f. Services like Zenodo 29  further provide persistent DOI links to notebook files. The CoLoMoTo Interactive Notebook is also relevant for teaching purposes. With Jupyter, students can straightforwardly execute, modify, and extend a template notebook to learn methods for analysing models of biological networks.
A potential direction is to include a visual edition module in the Jupyter interface, which represents a substantial development effort. The support for standard exchange formats is key to enable reproducibility of analyses with different tools. In that sense, BIOLQM plays an important role for the CoLoMoTo Interactive Notebook as it provides bridges between SBMLqual standard specifications and numerous software tools (Figure  2 ). The Tellurium Notebook system by Sauro et al. (in review) 31 offers support for SED-ML to help reproduce quantitative simulation of biological networks. Future work should consider bringing this feature for qualitative models as well, in order to better meet FAIR (Findability, Accessibility, Interoperability, and Reusability) recommendations  (Wittig et al. , 2017).
p = EF (AG (EF (S(a=0)) & EF (S(a=1)))) nusmv_ginsim = ginsim. to_nusmv(lrg) nusmv_ginsim. add_ctl(p) nusmv_ginsim. verify() nusmv_pint = pypint. to_nusmv(ginsim. to_pint(lrg)) nusmv_pint. add_ctl(p) nusmv_pint. verify()Note that the Python object p represents the CTL property to be tested, whatever the origin of the model (GINSIM or PINT).
The OpenStreetMap (OSM) database includes original items very useful for geographical analysis and for creating thematic maps. Contributors record in the open database various themes regarding amenities, leisure, transports, buildings and boundaries. The Michelin mapping department develops map prototypes to test the feasibility of mapping based on OSM. To translate the OSM database structure into a database structure fitted with Michelin graphic guidelines a research project is in development. It aims at defining the right structure for the Michelin uses. The research project relies on the analysis of semantic and geometric heterogeneities in OSM data. In that order, Michelin implements methods to transform the input geographical database into a cartographic image dedicated for specific uses (routing and tourist maps).
The paper focuses on the mapping tools available to produce a personalised spatial database. Based on processed data, paper and Web maps can be displayed. Two prototypes are described in this article: a vector tile web map and a mapping method to produce paper maps on a regional scale. The vector tile mapping method offers an easy navigation within the map and within graphic and thematic guide-lines. Paper maps can be partly automatically drawn. The drawing automation and data management are part of the mapping creation as well as the final handdrawing phase. Both prototypes have been set up using the OSM technical ecosystem.
Introduction In 2011, the mapping department of Michelin answered to the following question: could the OpenStreetMap (OSM) database be used to produce a Michelin paper plan of Clermont-Ferrand city on a 1/12,000 scale? To publish the map, archivists, cartographers and engineers have cooperated. The project was thought as a proto-type of the first Michelin plan based on open data which are under the ODbL licence. It was required to depict, as much as possible, road names, public facilities and a selection of buildings of interest. Three distinctive features explain the choice to use this open data source. First, the database covers the world and provides significant inputs on local scales. Then, the data is accessible thanks to the Open Database Licence. Finally, numerous online and offline editing tools (ID and JOSM) are dedicated to the OSM project  (Chilton, 2009).
The OpenStreetMap project gathers multiple activities focusing on map tools and database management. It seems that the open source and collaborative framework supports technological and graphical innovations. The purpose of my research activities follows up this first release. I produce web and paper maps prototypes based on OSM database. I wonder to what extent the OSM data can be used for any mapping purpose from world web maps to regional or local papers maps. Moreover, my research activity in Michelin is applied to various themes related to mobility and tourism. I make the assumption that the OSM project can enable these kinds of mapping. I conduct this work as a Ph. D. student within a partnership based on an agreement with Michelin and the laboratory Géographie-Cités 1. My academic research is partly drawn on a direct practical application within Michelin.
Michelin is a worldwide French tire manufacturer. The company has expanded its activities by publishing plans, Atlases and travel guides. Most of the Michelin publications are well known for their graphical guidelines (for roads) and for their tourist selection. Michelin's plans, maps and travel guides follow a same editorial line: providing a better mobility. Graphical and thematic choices are based on this editorial line. At this stage of my studies I observe that to produce a map, based on OSM data, the production context of the database and its technological ecosystem have to be fully understood. This paper describes this production context. This paper focuses on the graphic results that can be achieved. The mapping methods deployed in Michelin are based on the understanding of the contributing process.
Using OpenStreetMap for cartography In the OSM database, the number of geographical objects and their attributes is growing day by day. Data is uploaded into the OSM database by contributors who describe freely the attributes of the objects they create or alter. The choice of the element (node, way or relation) describing the shape of the geographical object is free as well. The liberty of choice regarding the use of geometry, a node or a way, has important consequences in the definition of graphic guidelines and the global visual harmony. To make the most appropriate use of the database, a period dedicated to an in-depth analysis of the tagging conventions and their respective evolutions must be planned.
OpenStreetMap database, a data source for cartography Online services as Google Maps and OpenStreetMap have connected geospatial data to online information. Both web-mapping services participate in the geospatial densification, opening visualization through interactive geo-graphic tools (Geoweb). The paper focuses on collaborative and open geospatial data or, Volunteered Geographic Information  (Goodchild, 2007) , produced by web communities of contributors. These communities are shaping features that facilitate customization and interaction on the Geoweb  (Joliveau, 2011). OSM contributors constitute a new 'stakeholder' community alongside the public and private agencies founded to produce and maintain geographical information.
The World drawn by OSM The OSM project aims at producing a global geographical database available under an open licence. This project focuses on permanent physical features of the ground, as well as administrative divisions and places (city or village for example). One of the guidance for the contributors consists in adding objective information. In this context, the project ensures that it is possible to check the accuracy of the information. The other main guidance refers to the drawing according to a very large scale. The core product of the project is the free editable database. To focus on the geographic database -and not only on one particular map -enables various uses such as route computation, route guidance, thematic mappings, mashups and geocoding. Therefore, these characteristics (topology and various thematic) of the database explain the data model complexity of the OSM database.
First, when creating an object in the database, the contributor has to choose to which element (a node, a way or a relation) he will associate thematic tags. A node is a specific point defined by its geographical coordinates. A node can be tagged with thematic information and then, may represent a tree, the centre of a locality or a street lamp for example. However, nodes are also used to compose ways. Ways are lists of nodes. They can be either a line or an area (a closed way). A way may represent linear features such as boundaries or roads but also areas like buildings or land uses. Relations are combinations of data. They are used to build a relationship between elements that are part of a larger geographical information. For example, a relation can be used to define a political area by including the outer and inner boundaries and the admin centre.
Secondly, the contributor tags elements in order to create geographical objects such as buildings, forests and places. Tags are a combination of a key and a value. Contributors are free to choose which tag is the good one to depict the main attribute of the object ("highway=tertiary") and more specific attributes ("oneway=yes"). The choice of these items often starts with a review of the OSM wiki. Technical and mapping documentations are available on this collaborative Website. Based on this resource, contributors can choose the most commonly used tags which are described on the wiki or to create new ones. In practice the free choice of the elements leads to some complexity. It is a part of the mapping process to analyse the diversity of objects in the database regarding the features that will be drawn.