dataesr/scientific-paragraphs-categorization huggingface dataset:
Conclusions and Future Work Conclusions: (1) A specialized dataset comprising 4890 images, which includes internet-crawled pictures and on-site photographs, covering the "Four Famous Gardens" and other renowned gardens, reflecting various angles and lighting conditions, has been constructed. The dataset was annotated using rectangular boxes and category labels and manual annotation was performed using LabelImg. The dataset was randomly divided using the holdout method and the image size was adjusted and normalized. Data augmentation strategies such as image mirroring, random flipping, random graying, Gaussian noise addition, and random occlusion have been employed to enhance the model's generalization ability and robustness. (2) By enhancing the network structure of YOLOv8, the detection accuracy was improved, thereby addressing the identification problem of complex garden scenes.
The DBB module in the backbone optimizes feature extraction through a multi-branch structure and multiscale convolution, improves detection accuracy, and maintains efficient operation during the inference phase. The replacement of BiFPN in the neck enhances feature fusion and improves the retention rate of small-object information in target detection. The integration of an attention mechanism called DyHead into the head layer enhances the representational capability for object detection. (3) The experimental results demonstrated that the improved model exhibited superior accuracy and robustness in the complex scenes of Jiangnan private gardens. The improved model demonstrated a precision of 66. 1%, a recall of 46. 7%, and an mAP50 of 57. 1%, validating the effectiveness of the proposed method for object detection.
Introduction Comparing genomic sequences is essential for genome-wide analyses, such as phylogenetic inference, genome annotation, and function prediction  (Dewey 2012). Similarly, aligning protein sequences is required for template-based protein structure prediction and function annotation  (Yan et al. 2013). Traditional techniques for global sequence alignments  (Needleman and Wunsch 1970, Gotoh 1982) , where entire sequences are to be compared, commonly use dynamic programming, which can be inefficient for very long sequences. This can also be particularly time-consuming when aligning a query sequence to a database of reference sequences, e. g. RefSeq  (O'Leary et al. 2016). Seed-based alignment techniques have become increasingly popular, due to their moderate resource requirements, in comparison to the traditional dynamic-programmingbased methods, as well as maintaining a high alignment accuracy.
Many seed-based techniques make use of k-mers  (Luczak et al. 2019 , Alser et al. 2021) , which are short substrings of fixed length k. In a nutshell, when a reference k-mer is found within a query sequence, the match is referred to as a hit or seed. The well-known BLAST software  (Altschul et al. 1990 ) uses k-mer seeds, which are then chained and extended to produce alignment(s) between target and query sequences. Spaced-seeds (binary patterns of symbols 0 and 1, denoting a match and a wildcard, respectively) have also been used extensively to improve alignment results via higher sensitivity when compared to traditional seed-based techniques  (Ma et al. 2002). For instance,  Khiste and Ilie (2017)  employ the notion of spacedseeds for assembling PacBio data showing higher alignment detection sensitivity in comparison to pre-existing tools.
Other less common sequence comparison techniques include employing the notion of longest common substring  (Leimeister and Morgenstern 2014)  or common absent words  (Charalampopoulos et al. 2018) , or even employing Fourier transformations  (Yin and Yau 2015). Roberts et al. (2004)  introduced the idea of sampling seeds using minimizers, where only a small fraction of seeds need to be stored during computations. Minimizers can speed up string-matching computations by a large factor while missing only a small fraction of the matches found using all seeds. Intuitively, this is because, when a target sequence exactly matches a query sequence, the same minimizers are sampled from both sequences. Minimap2  (Li 2018 ) is a versatile sequence alignment program that uses minimizers as seeds to compute alignments of DNA (or mRNA) sequences against a large set of reference sequences.
Results Seedability was implemented using the Cþþ programming language, taking in as input a set of sequences in multiFASTA format and an optional reference sequence in FASTA format. Seedability outputs optimal values for (t, k) either for the estimated alignment of all pairwise sequences or for the estimated alignment of the reference sequence and every sequence. The source code is distributed under the GNU General Public License (GPL v3. 0) at https://github. com/lorrainea/ Seedability. We have conducted experiments on a computer using an Intel Core i5-8265U CPU, running at 1. 60 GHz, equipped with 8GB of RAM, under GNU/Linux. Seedability was compiled with gþþ version 9. 3. 0. Minimap2  (Li 2018 ) is a widely-used bioinformatics tool for aligning DNA or mRNA sequences to a large reference database.
Synthetic data Synthetic data consisted of 100 pairs (x, y) of sequences with varying divergence threshold d x;y , such that 0:05 d x;y 0:25, and varying average length ' 2 f10 2 ; 200; 300; 500; 10 3 ; 2000; 5000; 10 4 ; 15000g. The sequences were generated using the generate dataset tool implemented as part of the Wavefront Alignment (WFA) tool (Marco-Sola et al. 2020). Minimap2 has a wide range of preset options, which include default values for j (the minimizer's length) and w (the number of consecutive j-mers considered for sampling). These preset options include: The average k-mer length output by Seedability, denoted bydk avg e, was used to determine the ðj; wÞ values for Minimap2. We set j ¼ dk avg e and w ¼ d 2 3 je. The value for w was determined using Mimimap2 0 s default value of w ¼ 2 3 j.
We tested the ðj; wÞ values presented in Table  1  on simulated reads from Chromosome 1 of the human genome (version GRCh38. p14). We used PBsim (Ono et al. 2020), a sequence simulator, to generate four datasets using GRCh38. p14: one dataset with an average length of 200 and divergence 0. 10; one dataset with an average length of 200 and divergence 0. 15; one dataset with an average length of 500 and divergence 0. 10; and one dataset with an average length of 500 and divergence 0. 15. Pairs of sequences were created by taking each simulated read and its original sequence interval in the genome. All datasets contained 100 pairs of sequences. Figure  8a  shows the number of sequences out of 100 that were mapped when using the default ðj; wÞ values for Minimap2. Figure  8b  shows the number of sequences out of 100 that were aligned when using the ðj; wÞ values determined by Seedability in Table  1.
Note that for all experiments, the default preset map-ont was used. The parameter values determined by Seedability were able to produce mapped alignments for all sequences unlike when using the default parameter values of Minimap2. In particular, when using a divergence of 0. 15 and length 200, the default parameter values of Minimap2 resulted in only 32 mapped alignments, that is, 68 fewer than when using the parameter values determined by Seedability. Table  4  shows the average time in ms required to map the 100 sequences to candidate positions in Chromosome 1 of the human genome when using Minimap2's default (j,w) values in comparison to those determined by Seedability. The datasets are presented in the table in the form A. B where A is the average length of the sequences and B is their divergence.
The difference in time between the two runs is negligible. In fact, for the datasets with an average length of 500, Minimap2 performed faster when using the parameter values determined by Seedability in comparison to the default parameter values. Table  5  shows similar results for the peak memory required to compute the mappings. Again it is clear that for the datasets with an average length of 500, Minimap2 used, on average, less peak memory when using the parameter values determined by Seedability in comparison to the default parameter values. 1.
Funding R. C. was supported by  ANR Full-RNA, SeqDigger, Inception , and  PRAIRIE grants  ( ANR-22-CE45-0007 ,  ANR-19-CE45-0008 ,  PIA/ANR16-CONV-0005 ,  ANR-19-P3IA-0001 ). This project has received funding from the  European Union 's  Horizon 2020 research and innovation programme  under the  Marie Skłodowska-Curie  grant agreements No. 872539  ( PANGAIA ) and  956229  (ALPACA).
Data availability The data underlying this article are available either in https:// github. com/lorrainea/Seedability or in the ensembl database at www. ensembl. org, and can be accessed using the gene names ENSPTRG00000044036 and ENSG00000174236 or in the NCBI database at www. ncbi. nlm. nih. gov and can be found using the reference sequence NC_000001. 11.
Discussion A large number of existing bioinformatics tools aim to perform sensitive sequence comparisons. Winnowmap2  (Jain et al. 2022 ) is based on Minimap2 but does not use fixed-length k-mers as seeds. NGMLR  (Sedlazeck et al. 2018 ) is designed to sensitively align PacBio or Oxford Nanopore reads to large reference genomes for structural variant calling. In many practical scenarios, identifying optimal k values is challenging, and default k values provide suboptimal results. In this article, we presented Seedability, an alignment framework designed for estimating an optimal value for k as well as a minimal number t of shared seeds based on a given alignment identity threshold. Our extensive results, using both synthetic and real datasets, demonstrate that the (t, k) values determined by Seedability lead to improved alignments compared to the original alignments produced by Minimap2 when using sequences with lengths of a varying range and a varied divergence.
To avoid that hassle, most compilation phases from CompCert  [Leroy 2009 ] are carried out on deterministic intermediate languages, for which forward simulation implies backward simulation. Yet, many realistic languages (C included) are not naturally seen as deterministic. CompCert involves special effort to maintain determinism, through its celebrated memory model. Rather than revealing pointers as integers, CompCert semantics allocate pointers deterministically, taking care to trigger undefined behavior for any coding pattern that would be sensitive to the literal values of pointers. As a result, any compiler transformations that modify allocation order require the complex machinery of memory injections, to connect executions that use different deterministic pointer values. Omnisemantics make it possible to retain the simplicity of forward simulation, while keeping nondeterminism explicit.
Factoring out the cases makes a huge difference in terms of proof effort and maintainability. The second limitation is associated with the case inspection involved in the preservation proof. Concretely, for each possible rule that derives the typing judgment (E ⊢ t : T ), one needs to select the applicable rules that can derive the reduction rule (t -→ t ′ ) for that same term t. Typically, only a few reduction rules are applicable. The trouble is that fully rigorous checking of the proof must still inspect all of those cases to confirm their irrelevance. A direct Coq proof, of the form "induction H1; inversion H2", results in a proof term of size quadratic in the size of the language 1. As we expect to handle each possible transition at most once, a proof that takes only linear work would be more satisfying.
Contributions and Contents of the Paper The contributions of this paper are as follows. • We present big-step and small-step omnisemantics for a standard imperative λ-calculus as well as for a standard imperative while language, which we believe should make the presentation more accessible than in prior publications. Moreover, we accompany this presentation with a Coq formalization of all definitions and proofs. 2 • We explain four key beneficial features of omnisemantics: They provide a convenient way to reason about the absence of stuck terms (feature #1) and the absence of diverging terms (feature #2) in nondeterministic languages, they enable forward-simulation-based correctness proofs for compilers with nondeterministic target languages (feature #3), and they enable Omnisemantics: Smooth Handling of Nondeterminism 1:5 type-safety proofs that avoid quadratic case inspection even in the case of a nondeterministic language (feature #4).
t -→ t ′ ) Each of these proofs is most typically carried out by induction on the typing judgment. One difficulty that might arise in the type-preservation proof for a large language with dozens (if not hundreds) of typing rules is the fact that one needs, for each case of the typing judgment E ⊢ t : T , to inspect all the potential cases of the reduction judgment t -→ t ′. This inspection is not really quadratic in practice, because one can filter out applicable rules based on the shape of the term t. Nevertheless, a typical Coq proof performing "intros HT HR; induction HT; inversion HR" does produce a proof term whose size is quadratic in the number of term constructs. Coq users have experienced performance challenges with quadratic-complexity proof terms when formalizing PL metatheory  [Monin and Shi 2013].
Composing this subset relation by transitivity with T /S ⊆ Q yields T /S ′ ⊆ Q. The conclusion ([v ′ /x] t 2 )/s ′ ⇓ Q then follows from the coinduction hypothesis applied to S ′ ; ∅ ⊢ ([v ′ /x] t 2 ) : T and ⊢ s ′ : S ′ and T /S ′ ⊆ Q. Note that most of these arguments are easily handled by automated proof search in Coq. □ Like for the small-step settings, we proved once-and-for-all that the statement coinductionfor-type-safety entails type-safety. Our coinductive omni-big-step approach offers, to those who have good reasons to work with a big-step-style semantics, a means to establish type safety without introducing error rules. Regarding the comparison with the standard preservation-and-progress approach, at this stage we cannot draw general conclusions on whether omni-big-step and omni-small-step type-safety proofs are more effective, because we considered a relatively simple language.
{Q 1 v ′ } ([v ′ /x] t 2 ) {Q } {H } (let x = t 1 in t 2 ) {Q } The only difference between omni-big-let and hoare-let is that the first rule considers one specific state s, whereas the second rule considers a set of possible states satisfying the precondition H. By exploiting the fact that {H } t {Q } is defined as ∀s. H s ⇒ (t/s ⇓ Q ), it is straightforward to establish that hoare-let is a consequence of omni-big-let. The corresponding Coq proof script witnesses the simplicity of the proof: "intros. applys mbig_let; eauto. " As another example, consider the consequence rule. The Hoare-logic rule is, again, an immediate consequence of the omni-big-step rule. omni-big-conseqence t/s ⇓ Q Q ⊆ Q ′ t/s ⇓ Q ′ hoare-conseqence H ′ ⊆ H {H } t {Q } Q ⊆ Q ′ {H ′ } t {Q ′ }.
hoare-bind {H } t {Q 1 } ∀v. {Q 1 v} E[v] {Q } {H } E[t] {Q } wp-bind wp t λv. wp (E[v]) Q ⊢ wp (E[t]) Q 6 COMPILER-CORRECTNESS PROOFS FOR TERMINATING PROGRAMS Omnisemantics also simplify some of the characteristic complexities of behavior-preservation proofs for compilers. 6. 1 Motivation: Avoiding Both Backward Simulations and Artificial Determinism Following CompCert's terminology  [Leroy 2009 ], one particular evaluation of a program can admit one out of four possible behaviors: terminate (with a value, an exception, a fatal error, etc. ), trigger undefined behavior, diverge silently after performing a finite number of I/O operations, or be reactive by performing an infinite sequence of I/O operations. Whether an error such as a division by zero is considered as a terminating behavior or as an undefined behavior is a design decision associated with each programming language.
Case Study: Compiling Immutable Pairs to Heap-Allocated Records This section describes a simple compiler pass that increases the amount of nondeterminism. The source language assumes a primitive notion of tuples, whereas the target language encodes such tuples by means of heap allocation. This case study is formalized with respect to a language based on commands whose arguments all must be variables. Such a language could be an intermediate language in a compiler pipeline, reached after an expression-flattening phase. Language syntax. We let c denote a command, x, y, and z denote identifiers, and n denote unbounded natural-number constants. The grammar of the language is as follows. c := x = unop(y) | x = binop(y, z) | x = input() | output(x ) | x = y[n] | x[n] = y | x = alloc(n) | x = n | x = y | c 1 ; c 2 | if x then c 1 else c 2 | while x do c | skip We actually consider two variants of this language, differing only in the types of values and in the available unary operators unop and binary operators binop.
A trace consists of a list of I/O events e whose grammar is e := IN n | OUT n. The rules defining the judgment appear in Figure  6. They are common to both languages-only the set of supported unary and binary operators differs. The semantics of operators are defined by two straightforward auxiliary relations (spelled out in Appendix H), evalunop(unop, v 1 , v 2 ) asserting that applying unop to value v 1 results in v 2 , and evalbinop(binop, v 1 , v 2 , v 3 ) asserting that applying binop to v 1 and v 2 results in v 3. The load command x = y[n] requires that the local variable y contains a natural number a and stores the value of the memory at address a + n into variable x (and is undefined if a + n is not mapped by the memory). The store command x[n] = y stores the natural number contained in the local variable y at memory location a + n, where a is the address contained in local variable x, but only if memory at address a + n has already been allocated.
2. eval-seq-chained : c 1 /m/ℓ/τ ⇓ λm ′ ℓ ′ τ ′. (c 2 /m ′ /ℓ ′ /τ ′ ⇓ Q ) ⇒ (c 1 ; c 2 )/m/ℓ/τ ⇓ Q Note that the chained variant cannot be used to define the judgement inductively in Coq due to the strict positivity requirement; more details on encoding choices can be found in Appendix A. Compilation function. The compilation function C lays out the pairs of the source language on the heap memory of the target language. This function is defined recursively on the source program. It maps the source-language operators that are not supported by the target language as follows. C(x = fst(y)) := x = y[0] C(x = snd(y)) := x = y[1] C(x = mkpair(y, z)) := tmp = alloc(2); tmp[0] = y; tmp[1] = z; x = tmp Note that to compile mkpair, we cannot simply store the address returned by alloc directly into x, because if x is the same variable name as y or z, then we would be overwriting the argument.
In fact, addressable stack allocation was initially omitted from the language exactly to avoid these intricacies (based on the experience from CompCert), but switching to omnisemantics made its addition local and uncomplicated. The input language is an imperative command language similar to the one described in §6. 4. The memory is modeled as a partial map from machine words (32-bit or 64-bit integers) to bytes. The stack-allocation feature here consists of a command let x = stackalloc(n) in c made available in the source language. This command assigns an address to variable x at which n bytes of memory will be available during the execution of command c. Our compiler extension implements this command by allocating the requested n bytes on the stack, computing the address at runtime based on the stack pointer.
4). It asserts not only that t/s cannot get stuck but also that any potential final configuration belongs to Q. We formalized in Coq the following equivalence. omni-co-big-step-iff-safe-and-correct : t/s ⇓ co Q ⇐⇒ safe(t, s) ∧ ∀vs ′. (t/s ⇓ v/s ′ ) ⇒ (v, s ′ ) ∈ Q Our rule omni-big-let extends safe-let not just by adding the postcondition Q to the judgment but also by changing the quantification over v 1 /s ′. In the rule safe-let, the quantification is constrained by t 1 /s ⇓ v 1 /s ′ , whereas in the rule omni-big-let, it is constrained by (v 1 , s ′ ) ∈ Q 1 , where Q 1 denotes the postcondition of t 1 /s. The key innovation here is that, thanks to the introduction of postconditions, we no longer need to refer to the standard big-step judgment-the judgment t/s ⇓ Q gives a stand-alone definition of the semantics of the language.
We speculate that several proofs of example compilers in that paper could be revisited using omnisemantics. Doing so would not only simplify the proofs but also make the results stronger by removing the target-language determinacy assumption, which they need to derive backward simulations from forward simulations. Semantics of concurrent programs. Concurrency increases the amount of nondeterminism, due to interleavings, and generally increases the sources of undefined behaviors, due in particular to data races. The work on CompCertTSO  [Ševčík et al. 2013]  shows how to deal with this additional complexity in a compiler-correctness proof. A direction for future work is to investigate the extent to which omni-small-step semantics would help simplify proofs from CompCertTSO. The Iris framework  [Jung et al.
, 2006; Mootha et al. , 2003; Pagliarini et al. , 2008). The breadth and depth of such studies has been largely driven by technological advances in the field in combination with improvements of mitochondria isolation procedures, such as differential centrifugation (DC), DC in conjunction with ultracentrifugation on e. g. Percoll gradients, magnetic bead-assisted methods (MACS)  (Kappler et al. , 2016)  or MitoTags  (Bayraktar et al. , 2019). Efforts in defining the mitochondrial proteome lead to databases like MitoCarta2. 0 and IMPI (http://impi. mrc-mbu. cam. ac. uk/), both integrated in Mitominer4. 0  (Smith and Robinson, 2019). A recent quantitative and high confidence proteome of human mitochondria identified 1134 different proteins that vary over six orders in magnitude in abundance  (Morgenstern et al.
, 2009). Proteomes of these ultra-pure mitochondrial samples were acquired by a state-of-the-art proteomics workflow (Figure  1A ), allowing the robust identification and quantification (coefficient of variation (CV) < 20%) of proteins that covered a dynamic range of more than five orders of magnitude (Supplementary File 1). In total, we identified over 7000 proteins of which 1620 were annotated as mitochondrial proteins using MitoCarta3. 0  (Rath et al. , 2021)  and the IMPI (http://impi. mrc-mbu. cam. ac. uk/) database. This essentially covers (92%) the mitochondrial proteome by the measure of MitoCarta3. 0 and even in the IMPI database, which also includes predicted mitochondrial proteins, we still identified 62% (Figure  1B ). For further analysis, we filtered for proteins identified in more than half of the biological replicates in at least one tissue, which resulted in 1548 mitochondrial proteins.
This still represents over 90% of MitoCarta3. 0 and 59% of the IMPI databases and highlights the deep and reproducible mitochondrial proteome coverage of this study (Figure  1C ). Interestingly, half of these mitochondrial proteins were identified across all tissues while only 9% were exclusively detected in one specific tissue (Figure  1C ), confirming previous reports on mitochondrial proteomes by us and others  (Calvo and Mootha, 2010; Forner et al. , 2006; Johnson et al. , 2007; Mootha et al. , 2003). Of these, almost half (65 proteins) were both reproducibly identified and not in the lowest 20% of ranked abundances (Supplementary File 2), making them clear candidates for tissue specific mitochondrial proteins. A similar proportion of the mitochondrial proteome was also exclusive to two or more tissues by the same criterion.