dataesr/scientific-paragraphs-categorization huggingface dataset:
To reuse the formal model from task T1 for task T2, we had three options: 1. Using the model as a template to implement the VBF core by hand. 2. Generating code from the model and combine this code and the handwritten boundaries. 3. Executing the model at runtime by incorporating the execution engine and the handwritten boundaries. The first option would require us to maintain both the model and the code. This could be time-consuming if there were changes to the specification (due to feedback from Pro-Rail, the specification was changed considerably). With the second approach, we would have to use an existing code generator (there was no time to develop our own) and thus have to refine our abstract B model down to implementation level B0-also time-consuming. Concerning the third option, we had already gained some experience of integrating ProB  [16]  as the execution engine in different software products  [17, 18].
Given our time constraints, the third option was the only feasible option, but it also posed the biggest research challenge: using a formal model at runtime interacting with various hardware and software components. Model structure The VBF model (without environment) consists of 13 B Machines, 14 definition files and has 45 constants and 33 variables. We used package pragmas to put topology independent parts separate from test data and from tests. We used ProB's package pragmas, which allow different machines to be put into different folders. The contents of a package X can be found in the folder of the same name X, while the contents of a package X. Y can be found in the folder Y within the folder X. The main, topology independent machines were found in the main package and the associated main directory: /*@package main */ MACHINE VSS_Constants.
We have various instances of our model in these subdirectories: -a very simple topology, -the topology from the HL3 specification (HL3), -the actual topology to be used for the on-site field tests (ENIF). The topology data was put into XML files, which were read using ProB's external library for reading XML. We reused parts of our Rubin engineering rules  [17]  to process the XML and turn it into B datavalues. Traceability The names of the VSS state machine transitions have been used within the model: -as the name of B operations. For example, the transition 9A from ambiguous to free is modelled by the B operation VSS_Ambiguous_Free_9A. -some higher-level operations, which collect updates to the various VSS, return the track name and transition number (such as 9A) as return result, which can be inspected in the ProB animation interface.
123 Observe that the operation has the VSS under consideration as parameter. Our model contains an outer loop which ensures that all enabled transition operations for all VSSs are processed; see Sect. 5. 2. For early validation (see, e. g. , Sect. 6. 3. 1) it was useful to have an individual operation for each transition. In ProB's animation view we can see at a glance which transitions are enabled, and by inspecting the guard predicates we can analyse the reason a transition is enabled or not enabled (see traceability in Sect. 4). However, in the model of the VBF, we need to execute in a given cycle all enabled VSS transitions, until no more are applicable. We assume that the order of processing the VSS updates is not significant (see  [21]  which studies just this question). We also need to encode the priorities, i.
Modelling of time We had a dedicated B machine (GenericTimer) to keep track of the timers and the current time, modelled as an integer B variable currentTime. The progress of time is modelled by calling an operation UpdateCurrentTime which obtains the new time as an input and also updates the set of expired and running timers. It is the only way time can be modified in our model. During actual execution of our B model, the surrounding Java program was responsible for regularly calling the UpdateCurrentTime operation with the current system time in milliseconds as parameter. The GenericTimer machine provides various facilities to add new timers and to inspect the status of the existing timers. It is also possible to query the machine for the earliest deadline.
Animation of scenarios The HL3 document describes a number of scenarios in addition to the VSS state machine. We used these scenarios as test specifications, i. e. , to check that these scenarios are feasible in our model. To animate the scenarios with ProB, we developed an environment model and composed it with the VBF core model (software model) to obtain a system model. The environment model has knowledge of the "real" (physical) position of a train, which allows it to move the train and to send train positions reports which are inputs of the VBF. Below we show some parts of this model. The invariant shows the relevant "real" state of the environment, as opposed to the view of the VBF (and the VSS statemachine). 3  shows a system state where the "real" position differs from the train position within the VBF.
Visualisation One requirement for the actual on-site field demonstration was to provide a visualisation for checking the correct functioning of the VBF. Additionally, our experience has shown  [22] [23] [24]  that a visualisation combined with an interactive animator can be especially useful in early stages of the development such as the modelling and analysis stage. Thus, our intention was to develop one visualisation that could be used in the early stages and during the field demonstration. As a consequence, the visualisation was developed as a separate software component with clearly defined interfaces for it to be integrated both into the ProB-Animator and the final VBF product. In both cases, the state information is extracted from the same (core) model. The only difference is that within the ProB-Animator the model is interactively controlled by a human (typically a domain expert using ProB) and in the final VBF software, the model is controlled via the real interfaces of the VBF.
g. , to repeatedly apply changes to the VSSs (see Sect. 5. 2) or for computing topology information (during VBF startup). This would have been more involved in Event-B, requiring the specification of an event scheduler or using the code generation rules from Chapter 15 of  [19]. Concerning systems modelling, it turns out that the classical B machine composition primitives (like SEES and INCLUDES) are sometimes sufficient to decompose a sys-tem into components. Synchronisation by events can then be achieved by a main machine which calls the operations of the included machines in an appropriate manner. The following sketches how a system machine can include two components and then synchronise events between these two components. Finally, from a pragmatic point of view, it is still easier to work as a team on models with textual representation as offered by Atelier-B rather than the XML database of Rodin.
Acknowledgements Open Access funding provided by Projekt DEAL. We thank  Jens Bendisposto ,  David Geleßus ,  Christoph Heinzen ,  Antonia Pütz ,  Yumiko Takahashi ,  Fabian Vu  and  Michelle Werth  for all the work that went into the  ProB Java API  and the new ProB-Animator UI. We thank  Mirko Aigner ,  Stefano Allrath ,  Burkhard Börner ,  Joachim Jost ,  Editha Nentzl ,  Sebastian Neuhauß ,  Michael Schilling , Wilfried.
Similarly, HiFi PacBio reads have been shown to be capable of improving the contiguity and accuracy in complex regions of the human genome  [30]. These advances toward more accurate and complete genome assembly could not be achieved without the recent development of assemblers specifically tailored for LRs. These tools assemble LRs either after an error correction step  [14, 4]  or directly without any prior error correction  [17, 25, 12]. Although LRs are becoming more widely used for de novo genome assembly, using hybrid approaches (that utilize a complementary SR dataset) is still popular for several reasons: (i) SRs have higher accuracy and can be generated by Illumina sequencers at a high throughput for a lower cost; (ii) plenty of SR datasets are already publicly available for many genomes; (iii) for some basic tasks such as variant calling (SNV and short indel detection), SRs still provide better resolution due to their high accuracy which often motivates researchers to generate SRs even when LRs are in hand; and (iv) unlike PacBio assemblies whose accuracy increases with the depth of coverage thanks to their unbiased random error model  [23] , constructing reference quality genomes solely from ONT reads remains challenging due to biases in base calling, even with a high coverage  [14, 1].
hybridSPAdes and Unicycler are similar in design. Both of these tools first use SPAdes  [2]  which takes SRs as input and generates an assembly graph, a data structure in which multiple copies of a genome segment are collapsed into a single contig (see  [35]  for more details). This data structure also records connections between subsequent contigs such that every region of the genome corresponds to a path in the graph. hybridSPAdes and Unicycler then align LRs to this assembly graph in order to resolve ambiguities and generate longer contigs. On the other hand, DBG2OLC first assembles contigs from SRs and maps them onto raw LRs to get a compressed representation of LRs based on SR contig identifiers, and then applies an overlap-layout-consensus (OLC) approach on these compressed LRs to assemble the genome.
However, for mammalian genomes, PBcR and Masurca require a large computational time and cannot be used without a computing cluster. DBG2OLC is faster due to its use of compressed LRs. Wengan is also a fast assembler and can be used for assembling large genomes in a reasonable time. In this paper, we introduce HASLR, a fast hybrid assembler that is capable of assembling large genomes. HASLR, similar to hybridSPAdes, Unicycler, and Wengan builds SR contigs using a fast SR assembler (i. e. Minia). Then it builds a novel data structure called backbone graph to put short read contigs in the order expected to appear in the genome and to fill the gaps between them using consensus of long reads. Based on our results, HASLR is the fastest between all the assemblers we tested, while generating the lowest number of mis-assemblies.
Fig. 3 : Two backbone graphs built from a real PacBio dataset sequenced from a yeast genome. Each graph is visualized with Bandage  [33]  and colored using its rainbow coloring feature. Each chromosome is colored with a full rainbow spectrum. (Left) Tangled graph built from all SRCs. (Right) Untangled graph built from unique SRCs. Backbone graph vs. assembly graph. It is important to note that the backbone graph is not an assembly graph per se, for two reasons. First, the regions between each pair of connected unique SRCs are not present in the graph. These missing regions are obtained by calculating the consensus of LR subsequences between each pair of unique SRCs. Second, unlike assembly graphs, there are some segments of the genome that cannot be translated to a path in the backbone graph.
This is due to the potential fragmentation that was mentioned earlier. Implementation details. (i) HASLR utilizes a SR assembler to build its initial SRCs. However, a higher quality assembly that has fewer misassemblies is preferred. For this purpose, HASLR utilizes Minia  [3]  to assemble SRs into SRCs. Based on our experiments, Minia can generate a high quality assembly quickly using a small memory footprint. (ii) For finding UCs, HASLR calculates mean k-mer frequencies with a small value of k (default k = 55). This information can be easily obtained by performing a k-mer counting on the SR dataset (for example using KMC  [11] ) and calculating the average k-mer count of all k-mers present in each SRC. Nevertheless, usually assemblers automatically provide such information (e. g Minia and SPAdes).
HASLR takes k-mer frequencies reported by Minia for this task. (iii) HASLR uses only longest 25× coverage of long reads for building the backbone graph which are extracted based on the given expected genome size. (iv) In order to align UCs to LRs, HASLR employs minimap2  [18]. (v) Graph cleaning is done with minSupp = 3 meaning that any edge that is supported with less than 3 LRs is discarded. (vi) Finally, consensus sequences are obtained using the Partial Order Alignment  [16, 15]  (POA) algorithm implemented in the SPOA package  [29]. We have provided the versions of the tools and the parameters that are used to execute them in Supplements S2 and S3, respectively.
Results We evaluated the performance of HASLR on both simulated and real datasets. We selected five hybrid assemblers ( hybridSPAdes  [1] , Unicycler  [32] , DBG2OLC  [34] , Masurca  [36]  and Wengan  [5] ) as well as two non-hybrid methods (Canu  [14]  and wtdbg2  [25] ). All experiments were performed on isolated nodes of a cluster (i. e. no other simultaneous jobs were allowed on each node). Each node runs CentOS 7 and is equipped with 32 cores (2 threads per core; total of 64 CPUs) Intel(R) Xeon(R) processors (Gold 6130 @ 2. 10GHz) and 720 GB of memory. Each tool was run with their recommended settings. See supplementary Sections S2 and S3 for more details about the versions of tools and the employed commands. Note that for wtdbg2, we used the provided wtdbg2. pl wrapper which automatically performs a polishing step using the embedded polishing module.
Experiment on simulated dataset We evaluated all the selected methods on 4 simulated datasets, namely E. coli, yeast, C. elegans and human, to provide a wide range of genome sizes and complexity. For each genome, we used Note: Mismatch and indel rates are reported per 100 kbp. Unicycler crashed on C. elegans dataset due to maximum recursion limit. For the human dataset, hybridSPAdes and Unicycler failed due to memory limit and Masurca failed due to a segmentation fault. For the human dataset, Canu was run with option useGrid=true which makes it run on multiple nodes of a cluster, and therefore, the time and memory usage are not available. ART  [7]  to simulate 50× coverage short Illumina reads (2×150 bp long, 500 bp insert size mean, and 50 bp insert size deviation) using the Illumina HiSeq 2000 error model.
We also simulated 50× coverage long PacBio reads using PBSIM  [24]. In order to capture the characteristics of real datasets, a set of PacBio reads generated from a human genome (See Supplementary Section S1. 1 for details) with P6-C4 chemistry was passed to PBSIM via option --sample-fastq. This enables PBSIM to sample the read length and error model from the real long reads. Table  1 , shows the QUAST metrics calculated for assemblies generated by different tools. As it can be seen, HASLR generates assemblies with the lowest number of misassemblies in all datasets. It is important to note that since reads are simulated from the same reference used for this assessment, any misassembly reported by QUAST is indeed a structural assembly mistake. In terms of the contiguity, HASLR achieves NGA50 on par with other tools for all datasets except for C.
elegans where Canu shows an NGA50 twice larger than others tools. On the human dataset, HASLR generates the most contiguous assembly with an NGA50 of 17. 03 Mb and only 2 extensive misassemblies, although at the price of a lower genome fraction (see Discussion). In addition, HASLR is the fastest assembler across the board. wtdbg2 has a comparable speed but generates lower quality assemblies, both in terms of misassemblies and mismatch/indel rate. It is particularly interesting to compare HASLR with hybridSPAdes, Unicycler and Wengan, since they share similar design in that they connect short read contigs rather than explicitly assembling long reads. In addition, Wengan uses short read contigs generated by Minia, similar Note: Alignment statistics were obtaine by aligning long reads against their reference genome using lordFAST  [6].
to HASLR. hybridSPAdes and Unicycler do not scale for large genomes as they have been designed for small and bacterial genomes. On C. elegans dataset, HASLR gives significantly more contiguous assembly than hybridSPAdes and Wengan without any structural assembly error. For the human dataset, HASLR has a higher NGA50 while generating significantly less misassemblies. Note that, HASLR does not employ any polishing step neither internally nor externally. Thus, the indel rate of the draft assemblies generated by HASLR is less than desirable. However, these types of local assembly erros can be easily addressed through a polishing step as shown in Table  S3. With a single round of polishing, both indel and mismatches rates match the other tools in two datasets.
Experiment on real dataset To compare the performance of HASLR on real dataset with other tools, we tested them on 4 publicly available datasets, E. coli, yeast, C. elegans, and human. Table  2  contains details about these real datasets (see Table  S1  for the availability of each dataset). Similar to simulated datasets, on real dataset HASLR generates less misassembly compared to other assemblers while remaining the fastest. Compared to other hybrid assemblers, HASLR performs similar or better in terms of contiguity, while stands behind self-assembly tools with a lower NGA50. For real datasets, we further evaluated the accuracy of assemblies by performing gene completeness analysis using BUSCO  [26] , which quantifies gene completeness using single-copy orthologs. Table  4  shows the results of BUSCO on E.
coli, yeast, and C. elegans. We were unable to obtain BUSCO results for the human genome due to a high run time requirement. Another observation is that for some experiments, HASLR does not perform as well as others in terms of genome fraction (see Discussions for more details). However, our gene completeness analysis shows that HASLR is on par with other tools based on BUSCO gene completeness measure (see Table  4 ). Note that very low gene completeness of Canu, wtdbg2, and DBG2OLC on E. coli dataset could be due to high indel rates of their assemblies.
Discussion HASLR introduces the notion of backbone graph for hybrid genome assembly. This enables HASLR to keep up with increasing throughput of LR sequencing technologies while remaining time and memory efficient. The high speed of HASLR is due to two reasons; (i) HASLR uses the fast SPOA consensus module rather than normal POA implementation, and (ii) HASLR uses only longest 25× of LRs for assembly. Assemblies generated by HASLR are similar to those generated by best-performing tools in terms of contiguity while having the lowest number of misassemblies. In other words, we prefer to remain conservative in resolving ambiguous regions without strong signal rather than aggressively resolving them to generate longer contigs and possibly generating misassemblies. However the conservative nature of HASLR does not implies it compromises on assembling complex regions.
Every complex region that is covered by a sufficient number of LRs, together with its flanking unique SR contigs, would be resolved. In fact, based on our manual inspections, there are regions that HASLR assembles properly but all other tools either misassemble or generate fragmented assembly (see supplementary Section S7 for visual examples of such cases). There are a number of future directions that are planned for future releases of HASLR. First, compared to other tools, HASLR usually has a higher indel rate. Note that most of the small local assembly mistakes (including mismatch and indel errors) can be fixed by further polishing. But since a large portion of the assembled genome is built from SRCs, a polishing module could be specifically designed for HASLR that only polishes the regions between unique SRCs which have been generated using SPOA.
This would enable a faster polishing phase. HASLR sometimes generates assemblies with relatively lower genome fraction than other tools. This is more clear when we compare it against Canu, especially on a large and complex genome like the human genome. The main reason is the lack of unique SRCs in a large region. This limitation could be mitigated by extracting unused LRs and assembling them in an OLC fashion (e. g. using miniasm  [17] ). Note that only a small portion of LRs are unused compared to the original input Note: We used enterobacterales odb10, saccharomycetes odb10, and nematoda odb10 gene sets for assessing gene completeness of E. coli, Yeast, and C. elegans assemblies, respectively. We were not able to obtain the gene completeness results for the human dataset due to time restrictions.
dataset. As a result, using an OLC approach for such a small set of LRs should not affect the total running time significantly. of the main bottlenecks of OLC-based assembly approach in terms of speed is that they require to find all overlaps between input reads. Recent LR assemblers have tried to speed up this process by using minimizers  [17, 14]  or compressed representation of LRs  [25]  techniques. However, an all-versus-all alignment is still required in order to generate such a graph. In fact, OLC-based assemblers can use HASLR (or the idea of backbone graph assembly) as a first step before performing the computationally expensive all-vs-all alignment step. An important factor in the contiguity of assemblies generated by HASLR is the length of reads. Obviously, longer reads would generate a more connected and resolved backbone graph.
341 341,861 308+336 35. 75 121. 11 45:45 33. 48 HASLR 261 97. 431 453,631 259+331 26. 08 140. 40 15:35 17. 93 CHM1 Canu 2,110 96. 084 2,329,909 6,715+7,048 145. 81 120. 69 689:26:01 70. 44 (PacBio) wtdbg2 3,723 92. 896 2,081,842 3,535+6,286 118. 45 72. 54 11:35:22 202. 41 hybridSPAdes NA Unicycler NA DBG2OLC 2,118 95. 547 1,599,466 3,718+8,690 116. 81 116. 89 78:21:08 64. 94 Masurca 3,781 93. 782 1,761,291 4,984+7,491 180. 83 57. 53 350:35:59 225. 63 Wengan 4,474 88. 948 875,489 2,771+7,577 115. 65 160. 71 18:19:47 112. 73 HASLR 1,469 92. 664 1,699,092 2,097+7,661 113. 06 281. 74 6:32:33 60. 75 Note: Mismatch and indel rates are reported per 100 kbp. hybridSPAdes and Unicycler failed on human genome datasets due to memory limit. Unicycler did not finish on E. coli dataset within two weeks.
We propose a data augmentation method to improve the segmentation accuracy of the convolutional neural network on multimodality cardiac magnetic resonance (CMR) dataset. The strategy aims to reduce over-fitting of the network toward any specific intensity or contrast of the training images by introducing diversity in these two aspects. The style data augmentation (SDA) strategy increases the size of the training dataset by using multiple image processing functions including adaptive histogram equalisation, Laplacian transformation, Sobel edge detection, intensity inversion and histogram matching. For the segmentation task, we developed the thresholded connection layer network (TCL-Net), a minimalist rendition of the U-Net architecture, which is designed to reduce convergence and computation time.
We integrate the dual U-Net strategy to increase the resolution of the 3D segmentation target. Utilising these approaches on a multi-modality dataset, with SSFP and T2 weighted images as training and LGE as validation, we achieve 90% and 96% validation Dice coefficient for endocardium and epicardium segmentations. This result can be interpreted as a proof of concept for a generalised segmentation network that is robust to the quality or modality of the input images. When testing with our mono-centric LGE image dataset, the SDA method also improves the performance of the epicardium segmentation, with an increase from 87% to 90% for the single network segmentation.