dataesr/scientific-paragraphs-categorization huggingface dataset:
We used SHIN+GO to determine co-regulated genes for the three individual experiments, including (1) growth in different nutritional conditions, (2) kinetics of plant-fungal co-culture and (3) basidiocarp development  [9, [27] [28] [29]  (Supplementary Information). To identify similarities and dissimilarities in expression patterns over all tested conditions, normalized read counts were used as an entry for the web-based visualization and analysis tool Morpheus ( https://software. broadinstitute. org/morpheus; last accessed on 21 October 2021). Hierarchical clustering was run using default settings and the data were visualized in a color-coded heatmap. TopGO  [30]  was used to conduct the enrichment analyses for Gene Ontology. A webtool (http://bioinformatics. psb. ugent. be/webtools/Venn/; last accessed on 21 October 2021) was used for the generation of Venn diagrams.
Funding: This research study was supported by the  Laboratory of Excellence ARBRE  ( ANR-11-LABX-0002-01 ), the  Region Lorraine , the  European Regional Development Fund  and the  Plant-Microbe Interfaces Scientific Focus Area in the Genomic Science Program , the  Office of Biological and Environmental Research in the US DOE Office of Science. J. R. is an  Agreenskills Marie Sklodowska Curie  postdoctoral fellow co-funded by the  European Union  ( CoFUND-FP7-267196 ).
Changes in FVC may be affected by pleural disease, and by the concomitant presence of UIP in lower lung zones. We therefore measured lobar lung volumes using HRCT in an attempt to assess the net change in upper lobe volume related to PPFE. A trend was observed toward slower volume loss in all lobes, although statistical signi cance was not reached in this small sample. We observed that the right lower lobe volumes were increasing before nintedanib initiation, and started to decrease on nintedanib therapy. Such paradox might be explained by the development of compensatory lower lobe emphysema following retraction of the upper lobes, a putative mechanism that could have been reduced by nintedanib treatment (Fig. 2 ). In addition, several patients had more preserved lobules at imaging at the last follow up than at presentation (data not showed), suggesting some air trapping in lower lobes.
Methods Data on clinical and chest high-resolution computed tomography (HRCT), all available pulmonary function tests (PFT), and outcome, were reviewed. Patients were divided into three groups for analysis: 1/ patients who had received nintedanib for 3 months or more (nintedanib group); 2/ patients who had received treatments other than nintedanib for 3 months or more (non-nintedanib group); 3/ patients who had received no treatment for PPFE or any treatment but for less than 3 months (surveillance/no treatment group). Patients without available clinical, functional or radiological data were excluded. To compare intra and intergroup changes in lung function and volume, surveillance and on-treatment periods were calculated as follows: the surveillance period was the time between the rst available PFT/HRCT and the last visit before treatment initiation (for both the nintedanib and non-nintedanib groups), or until the last follow-up visit (for the surveillance group).
CT Image Analysis CT images were obtained by full inspiratory HRCT for 2D and 3D volumetric measurements. A radiologist specialized in lung imaging (SSM with 8 years of experience in thoracic imaging) performed a 2D analysis using previously reported parameters, i. e. the transverse tracheal diameter at 1 cm above the carina, the anteroposterior diameter of the thoracic cage (APDT), and the transthoracic transverse diameter of the thoracic cage (TDT) at the level of the fth dorsal vertebra body scan. 17 A 3D volumetric analysis of the lobar and lung volumes was performed to segment both lung lobes using an appropriate semi-automatic software (COPD, IntelliSpace Portal, Philips). 18 This software allowed exclusion of the main pulmonary vessels and adjustments to ssure location and lung borders (Fig.
Gene Expression Analysis by Reverse Transcription and Real-Time PCR mRNA from colonic tissues or macrophages were prepared and cDNA were synthetized according to the manufacturer's recommendations (total RNA Minipreps super kit, BioBasic; Verso cDNA kit, Thermo Fisher Scientific). RT-PCR was performed on a Light Cycler 480 system with Light Cycler SYBR Green I Master Mix (Roche). Serially diluted samples of pooled cDNA were used as external standards in each run for the quantification. Primers, listed in Table  2 , were designed with the software Primer 3. GAPDH was used as the housekeeping gene.
Statistical Analysis GraphPad Prism (GraphPad Software, Inc. , La Jolla, CA, USA) was used for graph preparation and statistical evaluation. Differences between groups were assessed using ANOVA, followed by nonparametric Mann-Whitney test. Data with p-value ≤ 0. 05 were considered to be significant (* p ≤ 0. 05, ** p ≤ 0. 01, *** p ≤ 0. 001, **** p ≤ 0. 0001). Data represent mean values ± standard error of the mean (SEM).
The phage sequencing libraries were performed on the Illumina NextSeq550 sequencer with paired end, 150 bp per read at the Microbial Genome Sequencing Center (Pittsburgh, PA, USA). Whole-genome sequence data of phages PVN06 and PVN09 are available in the GenBank database under the following accession numbers MZ220765 (PVN06) and MZ220766 (PVN09). Raw data were trimmed with Trimmomatic v0. 39 using default parameters to remove adapter sequence  [27]. The trimmed reads were then subsampled at one tenth by seqtk_sample (https://github. com/lh3/seqtk/, access on 20 August 2021). Subsampled reads were assembled with Unicycler configured with -mode, -min_fasta_length, -lin-ear_seqs, and -min_anchor_seg_len default  [28]. Assembly errors were corrected with Pilon integrated in Unicycler by using default parameters  [28].
The genome was annotated and determined ORFs using Prokka v1. 14. 6 with default parameters  [29, 30]. The potential functions of ORFs were predicted by using BLASTP on the non-redundant proteins database  [31]  and phmmer search on the UniProtKB database  [32]. The large terminase (terL) amino-acid sequences from bacteriophage PVN06 and from the most similar phage were aligned with MAFTT  [33]  and phylogenetic trees were constructed by IQ-TREE using Maximum Likelihood method with 1000 bootstrap replicates  [34]. A representative gene encoding the major capsid protein (MCP) was used for phylogenetic analysis of bacteriophage PVN09. The genomic comparisons between Edwardsiella phages and references were visualized by EasyFig tool  [35].
Through protein database analysis, putative protein functions were assigned to 15 of the 69 ORFs (Figure  2A  and Table  S2 ). Moreover, PVN06 genome contained genes shared a similarity to counterparts found in two Edwardsiella dwarf myoviruses (Figure  3A  and Table  S3 ), associated with terminase, DNA metabolism, endolysin and structural proteins such as portal proteins, major capsid proteins, baseplate proteins, tail fiber assembly proteins, and inner membrane spanin subunit. Remarkably, the PVN06 genome did not own any gene encoding a protein product in DNA replication such as DNA polymerase, suggesting that the phage may employ host machinery to replicate its DNA genome. PVN06 also possesses a gene encoding cytosine-specific DNA methyltransferase which may be involved in DNA processing  [39].
The phylogenetic analysis placed PVN06 in a separate clade that was equivalent to another clade included two other members PEi21 and MSW-3. In agreement with the current guideline of the ICTV for species-level classification  [42] , and considering the differences in nucleotide (<95% nucleotide identity) between PVN06 and PEi21/MSW-3, it was proposed that phage PVN06 represents a separate and novel species within the Yokohamavirus genus, Myoviridae family which infected pathogen host E. ictaluri. For phage PVN09, a Genbank BLASTn search revealed the genome hits of T7-like phages belonging to Teseptimavirus genus, Autographiviridae family. Sequence alignment between PVN09 genome and the best hit of vB_EcoP_IME390 (accession no. NC_048082) in BLASTn produced a result of 91% coverage and 94% overall nucleotide identity.
ictaluri were isolated using the water samples  [14, 16]. However, in our study, and unexpectedly, E. ictaluri phage was unsuccessfully isolated after labor-consuming screening of more than 300 aquaculture pond water samples collected from different positions of fish farms in the Mekong Delta, implying the extremely low abundance of phages specific to E. ictaluri in water. The mud samples, possibly favorite habitats of host E. ictaluri, were examined in an alternative approach of phage isolation. To reduce the sophisticated impacts of cohabited organisms during isolation process, mud samples were previously treated by chloroform. With this strategy, we obtained successfully a collection of lytic Myoviridae phages, in which vB_EiM_PVN06 is a representative. The phage PVN06 possessed a high similarity of myovirus morphology and genomic data as size, structure, and gene content (Figure  3A, B  and Table  S3 ) compared to E.
Approximate Computing (AxC) paradigm aims at designing computing systems that can satisfy the rising performance demands and improve the energy efficiency. AxC exploits the gap between the level of accuracy required by the users, and the actual precision provided by the computing system, for achieving diverse optimizations. Various AxC techniques have been proposed so far in the literature at different abstraction levels from hardware to software. These techniques have been successfully utilized and combined to realize approximate implementations of applications in various domains (e. g. data analytic, scientific computing, multimedia and signal processing, and machine learning). Unfortunately, state-ofthe-art approximation methodologies focus on a single abstraction level, such as combining elementary components (e.
g. , arithmetic operations) which are firstly approximated using component-level metrics and then combined to provide a good trade-off between efficiency and accuracy at the application level. This hinders the possibility for designers to explore different approximation opportunities, optimized for different applications and implementation targets. Therefore, we designed and implemented E-IDEA, an automatic framework that provides an application-driven approximation approach to find the best approximate versions of a given application targeting different implementations (i. e. , hardware and software). E-IDEA compounds (i) a source-to-source manipulation tool and (ii) an evolutionary search engine to automatically realize approximate application variants and perform a Design-Space Exploration (DSE).
I. INTRODUCTION Approximate Computing (AxC) term has been introduced to define a computing paradigm applied at different abstraction levels, spanning from hardware to software components  [1]. Intuitively, instead of performing exact computation requiring a high amount of resources, AxC aims to carefully violate non-critical specifications, trading accuracy off for efficiency. For several real-world scenarios, the effectiveness of imprecise computation has been demonstrated in the literature, for both software and hardware components implementing inexact algorithms. Indeed, some applications show an inherent resiliency to errors  [2] ,  [3]. The inherent resiliency property tightly depends on the application domain. It can be observed for algorithms dealing with noisy real-world input data (e.
The methodology does not need to specify which part(s) of the application should be approximated and how. It only requires the definition of the acceptable output degradation from the user. Moreover, it allows the user to define custom approximation techniques and describe the most suitable optimization objectives, according to the requirements. Therefore, we developed Evolutionary-IDEA, or E-IDEA (IIDEAA Is a Design Exploration tool for Approximate Algorithm), which is able to find approximate versions for an application expressed as C/C++ code, by mutating the original code. The output can be either a software or a hardware implementation of the approximated application, according to involved approximation technique(s). E-IDEA consists of two main components: (i) a sourceto-source manipulation tool, the clang-Chimera, and (ii) an evolutionary search engine, the Bellerophon.
Firstly, Clang-Chimera analyzes the Abstract Syntax Tree (AST) of the C/C++ code to apply approximation techniques. These techniques are described as code mutators, which allow introducing approximation by means of tunable parameters, and, as previously mentioned, new approximation techniques can be defined by implementing new code mutators. Secondly, Bellerophon is devoted to find the best approximation version of a given C/C++ code, according to user-defined optimization objectives. In other words, Bellerophon is confronted to a Multi-objective Optimization Problem (MOP). To face such a complex problem, Bellerophon gradually tunes the parameters of the mutators to obtain different approximate application codes. The evolutionary nature of the approach allows converging towards the Pareto-optimal solutions in terms of the defined objective functions, in a fairly reasonable time.
Indeed, existing methodologies allow the programmer (i. e. , the user) to indicate what are the code lines or blocks to be approximated and how. For example, the programmer can annotate through compiler directives that a given loop has to be approximated by applying the loop perforation technique  [15]. Moreover, existing approaches target a specific implementation, either software-level or hardware-level. The established approach to validate the approximation effect (i. e. , verify whether it satisfies the accuracy requirements) is the application profiling. After applying different combinations of AxC operators, the application is executed several times and the results are compared with those produced by a golden (i. e. , approximation-free) implementation. The comparison is done exploiting metrics that suit the specific application domain (e.
Indeed, Precimonious uses the Low Level Virtual Machine (LLVM) Intermediate Representation (IR) to perform a float-type exploration by means of annotations. This allows the user to specify the maximum loss in accuracy. Early approaches, however, were very unsophisticated and little automated, requiring several user interventions, including specifying which operations to approximate. The state-of-the-art techniques working at software-level are ACCEPT  [4]  and its extension REACT  [19]. ACCEPT is an adaptation for C/C++ of EnerJ  [20] , which has been designed to work within Java environment. ACCEPT introduces an extension of the C/C++ language to provide programming annotations. Such tools give to designers a program-guided technique for the inner-implemented approximation techniques. The implementation of ACCEPT involves the LLVM IR  [21] , providing a modified compiler to support the language extension.
The paper by Nepal et al. introduced the ABACUS tool  [24] , which directly manipulates hardware circuits coded in Hardware Description Languages (HDL). It adopts a greedy algorithm to perform a design exploration to find solutions in terms of a trade-off between accuracy and power consumption. Another approach, proposed in  [25] , is able to take into account information about the underlying hardware architecture, such as the use of over-scaling techniques. Recently, authors of  [26]  proposed WOAxC, a workload-aware framework to automatically select pre-existing approximate units (adders and multipliers) minimizing energy consumption while meeting quality requirements of the application. Since quality requirements may change at run-time, authors of  [27]  propose an automated framework for the design of dynamically reconfigurable circuits.
Specifically, we resort to (i) a model of the target application (i. e. , C/C++), (ii) a model of the approximation techniques (i. e. , code mutators), and (iii) a model of the application accuracy requirement (i. e. , error metrics). An early version of the proposed framework, IDEA, was presented in  [33]  and was applied only at hardware-level. Moreover, at that time, the search engine was not based on evolutionary algorithms. In fact, it was based on the Branch & Bound (B&B) algorithm. The latter is a well-known generic method to find an optimal solution of single-objective optimization problems. Therefore, this approach was not suitable to deal with MOPs, such as the ones that we face in this work. Moreover, B&B could not scale with the complexity of the input application. Finally, in  [33]  only results for the bit-width precision reduction approximate operator were presented.
Concerning mutators, E-IDEA is already provided with a set of mutators implementing the most common approximation techniques. As main output, E-IDEA produces the mutator configuration of the best approximate application variants obtained (i. e. , the non-dominated solutions). Such configurations are then used to produce software or hardware implementations, possibly involving also High Level Synthesis (HLS) tools. Below, we report a few remarks on the requirements that drove E-IDEA development. • E-IDEA is general: the implementation of any approximate computing technique is possible through codemutation; • E-IDEA is target independent: it produces configurations applicable at any level of the computing stack; • E-IDEA is application independent: it allows the user to define custom error/reward functions to evaluate application approximation variants; • E-IDEA is extensible: it is an ensemble of tools written in C++ that can be easily extended and integrated; • E-IDEA is free and open-source: it is released under the GNU Affero General Public License and its code is publicly available  [34].
A. Clang-Chimera The green dotted box in Figure  1  reports Clang-Chimera flow. Clang-Chimera is a mutation engine for C/C++ code. It is based on the Clang compiler  [35] , used to rapidly develop source-to-source C/C++ compilers. Clang-Chimera applies the set of mutators (i. e. , AxC Operators) to the input application code , in order to make systematic modifications to the latter, and produce a set of mutated files, i. e. the configurable approximate variants of the input application code. In addition, it also provides the mutators configuration file, which will be subsequently used during the DSE. Clang-Chimera borrows the terminology from the mutation testing technique, which is a software testing approach used to evaluate the quality of a test set, in terms of its ability to detect software faults  [36].
Mutation technique consists in using supporting tools to mutate the original source codethus emulating programmer mistakes -to generate erroneous programs. The test set quality is evaluated according to the number of mutated versions detected. In the context of Clang-Chimera, the mutation is used in order to generate modified (i. e. , approximate) versions of the original code. Here, the concept of software fault is replaced by the concept of approximation technique. The latter is formalized as a mutator. M u = {M atch, M utate} (1) Eq. 1 defines the mutator M u as a duplet where: • Match identifies where in the code the mutation has to take place. This is defined by means of matching rules; • Mutate indicates how to actually modify the source code. This is defined by means of mutation rules.
Clang-Chimera analyzes and manipulates the input application source code through its'AST, which is a tree-based representation of the application code where each node of the tree denotes a language construct of the analyzed code. A set of AST nodes defines an AST pattern, which corresponds to a specific structure of the code. Altering the AST results in introducing constructs through which it is possible to tune the approximation degree. Clang-Chimera utilizes LLVM/Clang facilities, such as AST M atcher and Rewriter in order to apply a given mutator M u i. In details, AST M atcher searches for all occurrences of the "M u i. M atch" rule and Rewriter modifies the identified nodes by applying the "M u i. M utate" rule. Clang-Chimera is already provided with a set of mutators implementing common approximation techniques, such as: (i) two loop-perforation mutators, namely LOOP1 and LOOP2; (ii) two precision-scaling mutators for the floating-point arithmetic, namely Variable Precision Arithmetic (VPA) and FLexible Arithmetic Precision (FLAP); (iii) a precision scaling mutator for the integer arithmetic, namely TRUNC; (iv) a mutator supporting approximate arithmetic operator models of circuits being part of the EvoApprox-Lib  [31]  and EvoApproxLib-Lite  [37]  libraries.
Anyway, from the Clang-Chimerapoint of view, the particular approximate technique being implemented does not matter: using the appropriate mutator, the Clang-Chimera mutates the code in Listing 4 and generates the code in Listing 5. As for the loop-perforation technique discussed above, the effects of approximation depend on the actual value of configuration parameters. Hence, the main problem is to find an appropriate value for these parameters, in order to achieve the best trade-off between performance gains and accuracy losses. i n t ax_sum ( i n t add1 , i n t add2 , i n t ax ) ; Listing 3: Example of approximate sum. y = x + 2 z = 2 * x + 3 * y + 2 ;. Listing 4: Example code to be mutated i n t ax_0 = 0 ; i n t ax_1 = 0 ; i n t ax_2 = 0 ;. y = ax_sum ( x , 2 , ax_0 ) ; z = ax_sum ( ax_sum ( 2 * x , 3 * y , ax_1 ) , 2 , ax_2 ) ; Listing 5: Mutated code As described in the next section, the main goal of Bellerophon is tuning these values to ultimately find nondominated solutions in terms of trade-off between performance gain and accuracy loss.
3) Evolution Example Let us refer again to the example in subsection III-A1. Clang-Chimera applied the mutations to the AST and, consequently, it generated the C/C++ code shown in listing 2 and provided the "mutators configuration" file. In this example, a Mutator (i. e. , approximation technique) modeling the loop perforation has been used. The technique has been applied to both the loops in the code (lines 2 and 3 of the code). The mutators configuration file produced by Clang-Chimera reports the maximum and minimum values for the two stride variable introduced (i. e. , stride 1 and stride 2 ). The following listing reports the mutators configuration file generated by Clang-Chimera for this example. Each individual is characterized by its own chromosomes (i. e. value of the stride variables), reported in the table rows.
IV. EXPERIMENTAL RESULTS In this section, we report experimental results achieved with the proposed approach. The main goal of the experiments is to prove the effectiveness and the flexibility of the proposed approach in terms of target application, AxC techniques and implementation level. We thus applied E-IDEA to different applications and target implementations. In particular, we show case studies of different complexities and targeting hardware accelerator and software implementations. Application source codes belong to the AxBench benchmark suite for AxC  [43]. The goal of the experiments is to show the versatility and the efficiency of the proposed approach. To this end, we performed the experiments by using various error metrics and rewards, as well as diversified approximation techniques.
For what pertains to scalability and sufficiency of the DSE, the E-IDEAframework addresses them both by allowing the user to set (i) the number of iterations, (ii) the size of the initial population, (iii) the technique to define the initial population, (iv) mutation and crossover probabilities, and (v) the amount of genes involved in crossover. Moreover, the framework allows to retry experimental campaigns each time results belongs to an uncrowded Pareto-front or they are too close to few minimum spots. Finally, the E-IDEA framework is intended to be employed on common hardware. In order to run experiments reported below, we employed a common personal computer based on Intel I7 8550@1. 8GHz, equipped with 16 GB of RAM and running Linux 4. 9.