dataesr/scientific-paragraphs-categorization huggingface dataset:
Genome assembly All sequencing data have been deposited in the NCBI SRA under the project accession number PRJNA633105 (sequencing runs are SRR11797353-SRR11797365, SRR4000573, and SRR4000567); the draft assembly has been deposited under accession number GCA_015478945. 1. The draft genome assembly of T. rathkei is approximately 5. 2 Gb in total length. The genome is highly repetitive, consisting of approximately 70% repetitive elements. Transposable elements constitute the largest repeat category, with LINEs, followed by DNA elements and LTRs, being the most represented (Figure  1 ). All repeat families seem to have a single divergence peak of around 7-10% (Figure  1 ). Despite its large size, the draft assembly is likely only partially complete, with ~25% of arthropod BUSCO genes missing (Table  2 ).
For an independent assessment of assembly completeness, we also estimated the proportion of transcripts from the previously available transcriptome dataset that were present in the assembly. There were 15,805 transcripts assembled from that previously available transcriptome whose best hits in blastn searches against the NCBI nt database and diamond blastx searches against Uniprot-Swissprot were from other arthropods (and thus were unlikely to come from bacterial contaminants); of those, only 53% had nearly full-length matches in the genome (≥90% of the transcript length at ≥ 90% sequence identity), suggesting some missing data and/or remaining uncorrected sequencing errors in the draft assembly as well. At a more relaxed cutoff of at least 50% of the transcript having BLAST hits in the genome at ≥ 90% sequence identity, then 91% of transcripts appear to be represented somewhere in the assembly, suggesting that most transcripts are indeed present in the assembly but may be partial fragments rather than whole gene sequences.
The observation that there are far more male-specific 21-mers than there are female-specific 21-mers in our dataset suggests that most of these are from real male-specific genomic sequences. Of the initial 16 candidate Y-linked PCR markers designed from anonymous sequences, none showed the expected pattern of male-specific amplification in our early tests (Supplementary Table  5 ). This may be due to (1) the highly repetitive nature of the T. rathkei genome, despite our best efforts to target primers to non-repetitive sequences, or (2) low divergence between Xand Y-linked copies. Because the candidate male-specific contigs were assembled from Illumina data only and thus short and fragmented, we were unable to screen them for annotated candidate sex-determining genes using the typical MAKER pipeline.
AGHY3, on the other hand, covers a different region of the AGH gene (Figure  4 ), so AGHY3 may not be an additional third duplicate, but may instead be a part of AGHY1 or AGHY2 that just assembled into a separate contig. We also find some evidence of additional autosomal duplicates of the androgenic gland hormone (AGH) gene. Two contigs in the full assembly contained annotated transcripts with at least partial homology to the expressed transcript identified as the AGH sequence, and a third contained no annotated genes but still showed high sequence similarity to AGH in BLAST searches. However, not all of the annotated exons in the first two copies matched the expressed transcript, and there were unannotated portions of the same contigs that did show sequence similarity to the transcript (Figure  4 ).
Acknowledgments We thank the editor and three anonymous reviewers for constructive comments on earlier drafts of this manuscript. We also appreciate computing time and assistance provided by the  National Center for Genome Analysis Support at Indiana University , especially  Tom Doak  and  Sheri Sanders. This research was funded by  National Science Foundation  grant  NSF-DEB 1453298  to CHC. It was also supported in part by  Lilly Endowment, Inc. , through its support for the  Indiana University Pervasive Technology Institute. This research is based upon work supported by the  National Science Foundation  under Grant Nos. DBI-1062432 2011  ,  ABI-1458641 2015  , and  ABI-1759906 2018  to  Indiana University. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the  National Science Foundation , the  National Center for Genome Analysis Support , or  Indiana University.
In experimental psychology and other applications, researchers will often have numerous datafiles (e. g. , one for each participant) that need to be joined together into one larger dataset before data analyses. Many experimental software programs, including some increasingly popular ones (e. g. , PsychoPy or OpenSesame), do not include data merging functionality. Copy-and-pasting (potentially error prone) or the writing of situation-specific scripts (potentially difficult and time consuming) may be necessary. CSVDataMerge was created as a free Java application that merges CSV (or comma-separated TXT) data with little more than a double-click. The program also appropriately deals with datasets that have different column orders in different datafiles or empty cells. More trivially, it can also concatenate datafiles that do not contain headers and allows the user to specify which columns to keep and in what order.
INTRODUCTION CSVDataMerge was primarily developed with the objective of merging together experimental datafiles (e. g. , from individual participants in a psychology experiment). In principle, the program could be used (without modification) for merging any type of CSV (commaseparated values) files with or without column headers (whether saved with. csv or. txt file extensions), but I will talk about the merging of experiment datafiles in the rest of this paper. The program represents a simple solution to an inconvenience of certain experimental software programs (e. g. , for designing and running psychology experiments). Many such programs (e. g. , PsychoPy  [7]  and OpenSesame  [4] ) create individual datafiles for each participant, generally in CSV format. These programs are growing in popularity, especially for online data collection (e.
g. , because they are free software and some popular paid software programs, like E-Prime [8], do not allow for online data collection), perhaps even more so recently with limitations on the ability to run experiments in the lab during the COVID-19 pandemic. The absence of a simple manner of concatenating together the individual datafiles in many such software programs represents a rather large inconvenience. Indeed, after completing data collection, most experimenters will want one large dataset with the data of all participants combined into one file (e. g. , to import into R  [9]  or another statistics program for data analysis). While some programs have automatic, but proprietary, data merging programs (e. g. , E-Merge for E-Prime experiments), others do not. For some programs, it also depends on the options selected.
For instance, when run online, PsychoPy can either store individual CSV files or create an organized database, but some forum discussions seem to indicate that the former option is more trustworthy than the latter. Simple copy-pasting of each individual dataset into a larger datafile is possible (e. g. , in Excel), but this is both time consuming (e. g. , if there are a large number of participants) and prone to error. The researcher or student could also imagine writing an experiment-specific script (e. g. , in R, MATLAB  [12] , or Python), but this could also be time consuming and may be beyond the programming capabilities of the individual. I note that some other external tools exist that require a bit more work to use, for instance, by creating a Visual Basic script for Excel  [2]. There are also paid (previously free) programs that require the researcher to upload data to the web  [3] , which may not be acceptable for data security reasons.
Other free-to-use programs exists that are not as easy to use and do not deal with formatting inconsistencies  [5] , unlike CSVDataMerge (to be explained shortly). Another useful R package, prepdat, does exist  [1] , which also allows users to compute things like condition means and perform data trimming (using R commands), which may be a useful alternative for many users. The objective of CSVDataMerge was therefore to provide a simple script that requires minimal setup and technical capabilities. Indeed, the user is only required to know how to install the Java Runtime Environment (JRE  [6] ; if they have not already), create and name a folder, copy-andpaste, and double-click. CSVDataMerge is a free-to-use Java program that automatically merges all datafiles placed within a "data" folder into a larger dataset file.
The program is free to use, edit, and redistribute for noncommercial purposes (GNU General Public License v3. 0) and I provide open-source code with this manuscript. In addition to simply merging files, CSVDataMerge addresses a few added complications. For example, most experiment files will have headers on the first line for the variable names in each datafile, which the experimenter will normally only want to copy once (e. g. , before Participant 1) in the concatenated dataset (i. e. , not repeatedly for each participant). Again, the redundant headers could be deleted manually (or filtered out during data analysis), but this is obviously not ideal. Simply concatenating together CSV files is therefore suboptimal. CSVDataMerge copies the column headers only once. Furthermore, the author was disappointed to find out that at least one popular program (PsychoPy) does not always order the columns the same for all participants.
For example, the "response time" variable might be in Column 5 for one participant and Column 35 for the next. Obviously, if these files are simply concatenated, values will not be in the correct columns for all participants, again leaving to the experimenter stuck either copyand-pasting or writing some kind of situation-specific script to correct the inconsistencies. To my knowledge, no existing data merging applications can deal with this inconsistency. CSVDataMerge automatically reorders the columns to match the order of columns in a headers array that is either automatically extracted from the individual datafiles or specified explicitly by the user (see the different use cases below). For example, if the "response time" variable is in Column 5 for Participant 1 and Column 35 for Participant 2, all the values for Participant 2 in Column 35 will be moved to Column 5 to match Participant 1 (and the column headers).
The program also does not have problems with empty cells. The row lengths might sometimes be shorter than the header length in a CSV file if there are empty cells in the last columns of certain trials (i. e. , rows). For example, if the last column is response time, but the participant did not respond on a certain trial, a blank value will not be recorded in this line. That is, the row will be shorter, with one less comma-separated value. CSVDataMerge detects this and simply adds a blank value for the corresponding cell (i. e. , a comma). Further, on a more technical side, the line parser also correctly distinguishes between comma separators and commas within cell values (in addition to quotation marks). More trivially, the program also allows the user to concatenate datafiles that do not contain headers (though the columns must be in the same order; see more details below).
IMPLEMENTATION AND ARCHITECTURE Using the CSVDataMerge program has limited requirements. First, you will have to install Java on your computer, if you have not done so already. If not, download the Java Runtime Environment (JRE). This can be downloaded for free from Oracle  [6]. Developers looking to edit the code will, of course, also need the Java Development Kit (JDK), also available from Oracle, and one of the many available IDEs (e. g. , NetBeans, Eclipse, or simply Notepad++). Second, either (a) all of your datafiles should contain headers, or (b) none of the datafiles should contain headers (some different use cases will be described shortly). If the files do contain headers, then the headers need not be in the same order in each file, because CSVDataMerge will rearrange them if necessary.
g. , not RFC4180). There are a few different use cases possible. The simplest default use is with data that do contain headers and where users do not want to (a) reorder columns or (b) delete some columns in the concatenation process (both of which, of course, can be done easily after the fact). Readers that merely want to use the program without editing the source code can simply place the CSVDataMerge. jar file in whichever folder they wish, let us call this "MyExperimentFolder" (but you can use whatever name you want). In the same folder, they should create a new folder and name it "data" (case sensitive). This is illustrated in Figure  1. All the individualparticipant CSV files from the experiment with either a. csv or. txt file extension should be placed in this "data" folder. Note that no other non-data files with the same file extension should be placed in the same folder, but files with other file extensions (e.
g. ,. log) will be ignored. Note also that the program will first check for files with a. csv extension. If none are found, it will check for files with a. txt extension. Thus, "MyExperimentFolder" should have CSVDataMerge. jar and a folder called "data" (which, in turn, is filled with your CSV or TXT files). Doubleclicking on the JAR file will produce a new file in the "MyExperimentFolder" called dataset. csv, also shown in Note that you will need to delete all files in the "data" folder before merging new datafiles. Alternatively, given that the JAR file is so small (7 KB), it can simply be copied into the experiment folder of each individual experiment that you want to use it for. Additionally, dataset. csv is overwritten each time that the JAR file is executed, so make sure that you have either renamed or moved dataset files that you would like to keep before merging new data into the same folder.
g. , Notepad), and enter a comma-Figure  1  To use CSVDataMerge, simple copy the JAR file into a folder and place the CSV datafiles into a folder named "data" (case sensitive). Double click on CSVDataMerge. jar and a file called dataset. csv will appear. separated list of headers (e. g. , "Participant,RT,ACC") on a single line. Do not add extra white spaces between columns (e. g. , "Participant, RT, ACC"). Then save the file as a CSV file (i. e. , not TXT). An example headers. csv file is provided in the GitHub repository. Note that if a headers. csv file exists in the relevant folder, the program will use this file for determining the columns. Thus, if you instead want to use the default approach preceding this one, either delete or rename the headers. csv file. As a third use case, datasets without headers can also be merged.
Some experimental software programs, such as PsyToolkit  [10, 11] , do not save column headers. Merging together headless datafiles is rather trivial, but CSVDataMerge also allows for the merger of these types of datafiles. In this case, a headers. csv file must be created. The first line must read, exactly "no headers", with no trailing characters (note that if saved from Excel, trailing commas may have to be removed manually with a text editor, such as Notepad). A second line must also be added to this file. The second line should either (a) contain a comma-separated list of headers that you want to print at the top of the concatenated file, or (b) read (again, exactly) "leave blank". In the second case, no headers will be added to the concatenated file. Note that for this third use case, it is assumed that all datafiles have the same columns in the same order.
QUALITY CONTROL CSVDataMerge was tested for correct functionality with a large set of "problematic" datafiles. Some initial datafiles were created with PsychoPy (more precisely with the PsychoJS JavaScript-converted code for data collection online via Pavlovia. org). All datafiles contained the same columns of data, but (a) the order of these columns, for unclear reasons, were not consistent from one participant to another, and (b) numerous cells were empty for a variety of reasons (e. g. , if the participant did not respond fast enough, a blank value for their response time was recorded; other columns track trials within certain blocks and cells were therefore empty for trials from other blocks). It was confirmed that CSVDataMerge deals with both problems (a) and (b) above by assuring that the merged data (a) correctly reordered all cell data to match the extracted headers array and (b) correctly coded blank values and maintained the column orders for all values.
These original datasets are not included in the repository, as they contain sensitive information (Prolific. ac participant numbers), which would be difficult to remove. Other test data files were created and are available in the GitHub repository. These files contain the same two problems plus two additional ones: cell values that contain commas and cell columns that contain quotation marks. Both of these extra additions would create problems if the program was not appropriately parsing the lines of the datafiles to recognize when a comma represents a separator and when it is simply part of the cell value. The program was confirmed to deal appropriately with these cases. Though it is difficult to imagine how the program could sort data incorrectly, to ensure that the resulting datafile has been merged correctly, the user can simply scroll through the datafile in Excel to check that the correct values are presented in each column, especially the final columns.
If anything is incorrect, the errors should be very apparent to the eye (e. g. , empty cells where there should not be). The source code and JAR file are available on the GitHub repository. The GitHub project is also linked to the Open Science Framework (https://osf. io/g3qw8/) and the webpage of the author (http://leadserv. u-bourgogne. fr/~jschmidt/CSVDataMerge/). (2) AVAILABILITY.
No headers exist or should be added Case 2: No headers exist but a header array is specified Case 3: A custom headers array is specified For each file in "data" folder: Add to list of file names If no "headers. csv" file exists: For each file in list: Split first row into separate header values Add new header values to headers array If a headers array exists: Print headers to first line of file For each file in file list: Split first row into header values and store in array If header order does not match headers array: For each header in headers array: Find corresponding header in new file Set position index for new file For each row (excluding header row) in new file: Split row into values and store in array Write values in adjusted order to "dataset. csv" Else (i. e. , the headers do match): Write each row in file to "dataset.
Case 1 : 1 No headers exist or should be added Case 2: No headers exist but a header array is specified Case 3: A custom headers array is specified For each file in "data" folder: Add to list of file names If no "headers. csv" file exists: For each file in list: Split first row into separate header values Add new header values to headers array If a headers array exists: Print headers to first line of file For each file in file list: Split first row into header values and store in array If header order does not match headers array: For each header in headers array: Find corresponding header in new file Set position index for new file For each row (excluding header row) in new file: Split row into values and store in array Write values in adjusted order to "dataset. csv" Else (i. e. , the headers do match): Write each row in file to "dataset.
Two of them, iDEP and Shiny-Seq rely on the popular WGCNA framework (WeiGhted Correlation Network Analysis)  [12] , which falls into the category of correlation networks. This inference method have the disadvantage of being very vulnerable to false positives as it easily captures indirect or spurious interactions. When the number of samples in the experiment is low or moderate, high correlations are often accidentally found  [13]. Besides, linear correlations like Pearson coefficient can miss complex non-linear effects. Lastly, WGCNA addresses the question of co-expression networks, more than GRN. To infer GRN, which should link Transcription Factors (TF) to target genes, iGEAK retrieves information from external interaction databases and binding motives. This allows to exploit valuable information, but makes this step extremely dependent on already publicly available datasets.
An exhaustive comparison with respect to the features and methods handled by the described interfaces for RNA-Seq analysis is given in Fig. 1. Other frameworks focus on gene network reconstruction and visualization only. For instance, the web server GeNeCK  [14]  makes the combination of several probabilistic inference strategies easily available, but there is no possibility to select a subset of genes to be considered as regulators during inference. The online tool ShinyBN  [15]  performs Bayesian network inference and visualization. This Bayesian approach is however prohibitive when large scale datasets are involved. Lastly, neither ShinyBN nor GeNecK allow for upstream analyses and exploration of RNA-Seq expression data. Consequently, efficient statistical and machine learning approaches for GRN inference (like for instance GENIE3  [16] , TIGRESS  [17] , or PLNModels  [18] , see  [19]  for a review) are not available, to our knowledge, as a graphical user interfaces allowing necessary upstrem operations like normalization or DEA.
Pathways reconstruction Feature is absent Ease of use / reproducibility Non parametric approaches: k-means, hierarchcal clustering on heatmaps. None or limited parametrization for models/number of clusters. Fig. 1  Comparison of tools for facilitating the valorization of expression datasets. Eight interactive tools for analysis of count data from RNA-Seq are presented here and compared in terms of features and methodological choices. The features included are the ones we believe are the expectation from most users willing to exploit RNA-Seq experiments and understand regulatory mechanisms, and that we included to DIANE. Although not reported here for clarity reasons, many compared tools had their own features and specificities of interest. For instance, IRIS-DEA handles single cell RNA-Seq and facilitates GEO submission of the data, iDEP enables to build protein-protein interaction network and has an impressive organisms database, while Shiny-Seq can summarise results directly into power point presentations Besides, all of the cited applications are available as online tools or as local packages with source code, although the useful possibility to provide both solutions simultaneously, in order to satisfy advanced users as much as occasional ones, is not always available.
Proposed approach In this article, we propose a new R-Shiny tool called DIANE (Dashboard for the Inference and Analysis of Networks from Expression data), both as an online application and as a fully encoded R package. DIANE performs gold-standard interactive operations on RNA-Seq datasets, possibly multi-factorial, for any organism (normalization, DEA, visualization, GO enrichment, data exploration, etc. ), while pushing further the clustering and network inference possibilities for the community. Clustering exploits Mixture Models including RNA-seq data prior transformations  [11]  and GRN inference uses Random Forests  [16, 20] , a non-parametric machine learning method based on a collection of regression trees. In addition, a dedicated statistical approach, based on both the biological networks sparsity and the estimation of empirical p-values, is proposed for the selection of the edges.