Bootstrapping UMR s from U niversal D ependencies for Scalable Multilingual Annotation (2025)

Abstract: Uniform Meaning Representation (UMR) is a semantic annotation framework designed to be applicable across typologically diverse languages. However, UMR annotation is a labor-intensive task, requiring significant effort and time especially when no prior annotations are available. In this paper, we present a method for bootstrapping UMR graphs by leveraging Universal Dependencies (UD), one of the most comprehensive multilingual resources, encompassing languages across a wide range of language families. Given UMR’s strong typological and cross-linguistic orientation, UD serves as a particularly suitable starting point for the conversion. We describe and evaluate an approach that automatically derives partial UMR graphs from UD trees, providing annotators with an initial representation to build upon. While UD is not a semantic resource, our method extracts useful structural information that aligns with the UMR formalism, thereby facilitating the annotation process. By leveraging UD’s broad typological coverage, this approach offers a scalable way to support UMR annotation across different languages.

## introduction uniform meaning representation (umr) (van gysel et al., 2021) is a graph-based meaning representation framework primarily grounded in abstract meaning representation (amr) (banarescu et al., 2013). unlike amr, which is mainly designed for english, umr was specifically developed with a cross-linguistic scope, focusing particularly on morphologically complex and low-resource languages. umr provides a sentence-level representation that captures core elements of meaning such as predicate-argument structure and word senses. compared to amr, it also introduces features to better handle tense, aspect, modality, and * work partially done while visiting the university of colorado boulder. quantification in a way that generalizes across languages. beyond the sentence level, umr supports document-level annotation, which defines strategies to represent coreference among entities and events, temporal relations, and modal relations. all these features make umr a rich, flexible framework for modeling meaning in cross-lingual contexts. umr graphs are directed graphs, mostly acyclic, with each concept represented as a node and edges encoding semantic relations. through the use of re-entrancies, a single node can participate in multiple relations, supporting the expression of shared arguments and anaphoric reference. as is often the case with deep semantic annotations, annotating data according to the umr formalism has proven to be extremely timeconsuming, highlighting the need for alternative solutions and partial automation of the annotation process. this issue is particularly relevant for languages which lack the same resources and annotators as widely spoken languages like english. in this paper, we present a method for converting universal dependencies (ud) (de marneffe et al., 2021) trees into (partial) umrs. ud is one of the most comprehensive multilingual resources, covering a wide range of typologically diverse languages -179 in total as of version 2.16. in light of the typologically motivated nature of umr, ud's broad typological coverage is particularly valuable for this task. at the same time, while umr abstracts away from the morpho-syntactic representation of language properties, ud is primarily concerned with representing morpho-syntax. since ud is not a semantic resource, a full umr graph cannot be expected from this conversion. however, generating reasonably accurate partial graphs is already highly beneficial, as it provides annotators with a structured starting point, reducing the effort required for manual annotation. our contributions include: a) a languageindependent ud-to-umr converter; b) a manually annotated test set comprising 100 parallel sentences in three languages (czech, english, and italian), for a total of 300 sentences; foot_0 c) two-fold evaluation of the conversion, aimed at providing insights into the interaction between syntax and semantics. the remainder of the paper is structured as follows. we first provide background on conversion strategies to umr (section 2), followed by the presentation (section 3) and evaluation (section 4) of the ud-to-umr converter. finally, we conclude with a discussion of future directions (section 5). ## related work like other forms of semantic representation, umr annotation is a time-consuming and labor-intensive task, highlighting the need for automatization methods that could streamline the process. converting amr corpora to umr (bonn et al., 2023) is undoubtedly a promising and valid approach. however, due to umr's inherent emphasis on multilinguality, restricting umrs to languages with existing amrs is not sufficient. instead, it is crucial to develop strategies that leverage other available corpora to generate umrs. buchholz et al. (2024) address this challenge by proposing a method to bootstrap umrs from interlinear glossed text (igt), providing annotators with a preliminary structure rather than requiring them to annotate from scratch -an objective that aligns with our ud-to-umr conversion efforts. while their approach is applied exclusively to arapaho, its potential for broader applicability is demonstrated with quechua data. their method generates subgraphs centered around individual verbs, leaving it to the annotator to integrate them into a cohesive structure for complex constructions, such as subordinate clauses. in contrast, our approach builds a single, comprehensive graph that directly incorporates subordination. another line of research involves converting the prague dependency treebank (pdt) to umr (lopatková et al., 2024). the tectogrammatical layer in pdt (hajič et al., 2020) captures deep syntactic-semantic properties of language; while maintaining the dependency structure used at the surface-syntactic level, it encodes semantic features such as argument (valency) structure, predicate senses, and semantic attributes of nodes. pdt trees share structural similarities with ud trees, but the presence of rich semantic annotations facilitates a more comprehensive conversion to umr, including elements such as coreference. pdt is a czech resource, so its conversion process remains language-specific. however, a similar pdt-style annotation exists for latin, foot_1 and efforts are underway to convert it as well. a prior attempt to generate meaning representations from dependency syntax was made by han and pavlova (2019), who focused on developing a system to convert ud trees into amrs. this approach utilizes a rewriting system supported by a lexical resource containing predicates from the propbank dataset. while this work serves as an important precedent, it differs from our approach in at least three key aspects: it converts to amr rather than umr, it is language-specific (english only), and it is highly lexicalized, relying on propbank to disambiguate concepts. in addition to efforts to generate complete or partial umrs, there have also been attempts to automatically extract specific elements of the graph, such as verbal aspect (chen et al., 2021) and word senses (gamba, 2024). ## ud-to-umr approach in our work, we focus exclusively on generating the sentence-level umr graph and alignments for each sentence, whereas a full umr annotation typically includes a document-level block. our approach involves iterating over all nodes in each ud tree and processing them sequentially. for each node, we determine its position in the sentence graph being generated and produce alignments by extracting token indices. to handle umr graphs and ud trees, we use the penman (goodman, 2020) and udapi (popel et al., 2017) python libraries, respectively. concept nodes are defined as lemmas. since we do not rely on language-specific frame files, we extract ud lemmas to label concepts. this approach occasionally leads to a literal interpretation of the sentence, which may not always align perfectly with the intended umr representation. however, in most cases, it provides a sufficient approximation for our purposes. participant roles are defined through a set of linguistically informed rules that map ud annotations to umr structures. these mappings go beyond a simple one-to-one correspondence between ud syntactic relations and umr semantic roles; they combine syntactic labels with morphological features (e.g., case, polarity) to infer appropriate semantic roles. for instance, nsubj, csubj, and obl:agent are mapped to the semantic role actor, while obj, nsubj:pass, and csubj:pass are interpreted as undergoer. morphological cues play a key role in disambiguation: for example, a dependent labeled obl with @xmath0. in some cases, the mapping introduces abstract predicates rather than roles. for instance, appositions (appos) are not merely mapped to a role label; instead, they are converted to the abstract predicate identity-91, following umr conventions. similarly, copular constructions (cop) are also converted to a set of of abstract predicate structures. since ud relations are not as semantically fine-grained as umr roles require, exact alignment is not always possible. our goal is to approximate semantic roles in a principled way using available syntactic and morphological cues, rather than striving for exhaustive and exact coverage. the participant roles in our generated umrs correspond to non-lexicalized semantic roles foot_2 typically used in what umr guidelines call 'stage 0 annotation', where no propbank-style frame files are available. incorporating frame files would introduce language-specific dependencies, and our goal is to develop a broadly applicable approach. hereafter, we use the english sentence "it contains a monument to martin luther king, jr." as an example and present the corresponding humanannotated graph, the converted umr graph, and its ud tree (figure 1 ). ## evaluation evaluating the performance of our ud-to-umr conversion system is crucial for understanding its strengths and limitations. to this end, we propose a two-fold evaluation aimed at addressing two key questions: (a) how accurate is the conversion? that is, to what extent are the partial graphs constructed from ud syntactic information correct? and (b) how useful is the conversion for annotators? specifically, does providing converted graphs as a starting point help streamline annotation? to answer the first question, we design a quantitative evaluation to assess the converter's performance. however, evaluating converted umr graphs poses challenges, as these graphs are often incomplete due to the inherent difficulty of capturing certain semantic phenomena solely from syntax. @xcite as of ud v2.16. @xcite some determiners, like some and all in english, are included in umr graphs because they contribute meaning -for example, by indicating quantity. in contrast, articles are left out, since they typically do not add any semantic content. while tools like ancast (sun and xue, 2024) and metrics like smatch (cai and knight, 2013; opitz, 2023) exist for evaluating graph-based meaning representations, relying solely on the metrics they provide would be insufficient. a more insightful approach involves focusing on specific challenging phenomena rather than just general scores. for example, examining how well the converter handles abstract predicates offers a clearer understanding of its performance with complex structures. our approach is inspired by groschwitz et al. (2023), who developed the grapes evaluation suite to assess not only the overall performance of amr parsers but also their ability to handle specific linguistic and structural phenomena. similarly, we aim to complement overall f 1 scores with targeted evaluations of key challenges in umr conversion. another factor affecting evaluation is graph connectivity. to prevent the generation of disconnected subgraphs, some converted triples foot_5 are discarded before finalizing the graph. this happens when the parent node cannot be converted, leaving the subgraph unattached to the main structure. such trade-off ensures structural integrity, while slightly affecting overall conversion scores and adding complexity to interpretation of the evaluation results. in addition to the quantitative evaluation, we address the second question by conducting a timebased evaluation. our goal is to measure whether, and to what extent, providing annotators with a graph backbone (the converted ud graph) helps them complete their annotations more efficiently. ## conclusion and future work in this paper, we introduced an approach to bootstrap umr graphs from ud trees. the approach was evaluated from two angles: the accuracy (las) of generated graphs, and the relative speedup of manual work. multiple ud-related factors were discussed as possible obstacles for better results (but we cannot measure the impact of each such factor separately). and even if some semantic relations cannot be accurately extracted from syntax, the proposed conversion method has proven to be a valuable tool for annotation. by automating part of the process, it helps to make the annotation workflow faster, reducing the time and effort needed for annotators to complete their tasks. given the broad availability of syntactic parsers, the potential of this approach is significant. in principle, a dependency parser can be applied to any dataset to generate the syntactic tree, which can then be converted to umr. this makes the method highly accessible and scalable for a wide range of linguistic datasets. future work includes extending evaluation to a broader range of typologically diverse languages to further assess the robustness of the proposed approach. while the current results already demonstrate cross-linguistic applicability, additional testing on languages with different syntactic structures and morphologies will provide deeper insight into the generalizability and limitations of the conversion process. additionally, refining specific conversion choices-such as improving aspect annotation and integrating named entity recognition (via dedicated ner tools or the universal ner project (mayhew et al., 2024)) could enhance semantic accuracy. to maximize the scalability of this approach, we also plan to develop a comprehensive guide to complement the existing technical documentation, making it easier for new users to apply the converter to additional languages.