File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/90/c90-2049_metho.xml
Size: 16,774 bytes
Last Modified: 2025-10-06 14:12:25
<?xml version="1.0" standalone="yes"?> <Paper uid="C90-2049"> <Title>Dependency Analyzer: A Knowledge-Based Approach to Structural Disambiguation</Title> <Section position="3" start_page="282" end_page="283" type="metho"> <SectionTitle> 2 Knowledge Base </SectionTitle> <Paragraph position="0"> The knowledge must be large=scale, since natural language semantics should have a broad coverage of lexical items.</Paragraph> <Paragraph position="1"> Since dependency structures are built by analyzing sentences and by tra:nsforming phr~e structures in a straight-forward way, if knowledge is assumed to consist of dependency structures, a knowledge base is easily constructed by using already-existing on-line dictionaries. This idea of using on-line dictionary definitions as a knowledge base was originally proposed by Karen Jensen and Jean-Louis Binot \[6\]. Jun-ichi Nakamura and Makoto Nagao \[101 evaluated tile automatic extraction of semantic relationships between words from the on-line dictionary. We emphasize that a data structure for representing knowledge should be as simple as possible, because it must be easy to construct and efficient.</Paragraph> <Paragraph position="2"> We selected the tree structure as a means of representing knowledge, because it is a very simple and manageable data structure, and because tree structures are suitable for describing dependency structures.</Paragraph> <Paragraph position="3"> Tile tree structure is defined as follows. A Tree consists of a Node and reeursions (or null) of Tree, and a Node consists of repetitions of a paired attribute name and u.ttribute value.</Paragraph> <Paragraph position="4"> For example, Figure 1 shows a tree (dependency) strncture for the clause &quot;the operating system stores the files in the disk.&quot; In this tree, &quot;WORD,&quot; &quot;POS (part of speech),&quot; and &quot;CASE&quot; are att,qbute names, and &quot;store,&quot; &quot;VERB,&quot; and &quot;AGENT&quot; are attribute values.</Paragraph> <Paragraph position="5"> In our system, the knowledge can be extracted fi:om dictionaries of terminology, and is of two types: (1) dependency structures and (2) synonym and taxonym relation- null ( ((WORD . &quot;store&quot;) (POS . VERB)) (((WORD . &quot;operating system&quot;) (CASE . AGENT) (POS . NOUN))) (((WORD . &quot;file&quot;) (CASE , PATIENT) (POS . NOUN))) (((WORD . &quot;disk&quot;) (CASE . LOCATION) (POS . NOUN))) ) Table h Tree Index Table d synonym and taxonyra trees</Paragraph> <Paragraph position="7"> lqgure h Tree structure for the clause &quot;the operating system stores the files in the disk&quot; ships.</Paragraph> <Paragraph position="8"> The process of knowledge extraction is as follows. First, dictionary statements are rewritten manually as simple :~entences. Next, sentences are parsed into phrase struetm'es by tile PEG parser. Then. phrase structures are transformed into dependency structm'es by the Depende'nc:q Str~zctu're Builder, which is a component of tile Dependency Analyzer. Finally, sernantie case markers are manually added to the modification links in dependency .structures. Synonym and taxollym relationships are extracted from sentences of the form &quot;X is a synonynt for Y&quot; and &quot;X is a Y&quot; respectively. These sentences are automatically transformed into tree structures each of which has two nodes R)r tile words &quot;X&quot; and &quot;Y&quot; and a link from &quot;X&quot; to &quot;Y&quot; with the label &quot;isa.&quot; In the case of &quot;X is a synonym for Y,&quot; since &quot;Y&quot; is also a synonym for &quot;X,&quot; &quot;Y'&quot; is connected with &quot;X&quot; at the same time by a link with the label &quot;isa.'&quot; \Ve developed an interactive tree management tool, the Tree Editor. which makes it easy for users to deal with trees.</Paragraph> <Paragraph position="9"> Another problem of natural language processiug is the knowledge acquisition bottleneck. Some ideas on how to a.cquire knowledge fi'om a!ready-existing dictionaries automatically or semi-automatically haw~ be.en proposed \[10,41. But it is still difficult to develop a knowledge base hilly automatically because of ambiguities in the natural language analysis of dictionary definitions. A more practical way, to overcome the t)otthmeck is so-called kno'wledge bootstraptn'a~.\]. By knowledge bootstrapping, the Dependency Analyzer extends its knowledge automatically by using a eor'e knowledge base that includes mammllv edited dependency .~;truetures. Since the De.pendency Analyzer uses dependency structures as knowledge and outputs a dependency structure with no ambiguity (case ambiguity is also resolved by the system), tile output can be added to the knowledge base. Of course we still need to evaluate the automatically constructed knowledge base. But the reliability (performance) of the knowledge base is rising gradua\[ly, so it is expected that human interw,ntion wilI be greatly reduced in the near future.</Paragraph> <Paragraph position="10"> &quot;t Path Search An EtIicient Algorithm null Path search is a process for finding relationships between the words in a candidate dependency by using a knowledge base. Since relationships between words in these candidates do not always exist in the knowledge base, relation-</Paragraph> <Paragraph position="12"> also /)e targets. Path search is done ill the following steps: 1. Synonyms and t~u,:onyms of words in the candidate dependencies are found by using the knowledge base. In the knowledge base, synonym and taxonym relationships are also defined in the form of trees. All the synonyms and taxonyms can be collected by transiting relationships.</Paragraph> <Paragraph position="13"> 2. Dependencies between elements of each synonym and taxonym set (including the original words) are also found by using the knowledge base.</Paragraph> <Paragraph position="14"> We developed an efficient algorithm for path search, using the table of indices shown in Table 1. In this table, t~, represents the pointer of the tree in which the word on the same line appears, and the numbers in parentheses represent the node location of the word in the tree. Relationships between the numbers amt the node are shown in Figure 2. The left side of tile table shows trees in which a synonym or a taxonym of the word on the same line appears as its parent node. For example, in the tree to, the word a is on the node of location (0), and by traversing to up by one node fl'om location (0) we can find that the word b is on the node of location (), so b is a synonym or a taxonym of a, as shown in Figure 3. Thus, in order to find a synonym or a taxonym of a word, we just traverse up tile tree on the left side of the table by one node. We assume that synonym and taxonym relationships are transitive, that is. that a synonym/taxonym of one of the synonyms/taxonyms of a word is also a synonym/taxonym of the word itself. We can tl. tO 0/0~ / b d &quot;keep&quot; .~,..</Paragraph> <Paragraph position="15"> &quot;VM/SP .... information&quot; / collect all its synonyms/taxonyms by iteration of that process. The next stage of path search is to find whether there are dependencies between words within each set of synonyms/taxonyms. This process searches trees that involve both words and checks whether there is a path from one word to the other. In the dependency trees, the words' locations show whether there is a dependency between them. For example, we can see that tile word b is a dominator of the word d frmn the locations of these words in the emnmou tree tH0 (shown in Figure 4), which is included in both the set of dependency trees that include b. {ttl, ttl0}, and that of dependency trees that include d, {tas, t110}. In the tree structures, if the node a is an ancestor of the node b, then there is a unique path front b to a. Thus, finding dependency between words is equivalent to checking their node locations in the dependency trees. A path between words wl and w2 is found by the following processes: Several conditions are added to path.s, and the ch)seness of dependevcy in a path is computed according to these conditions. The degree of closeness of dependenc.y is called the dependency distance. This is calculated by using the number of dependencies inclnded in a path and the values of the conditions. Three conditions are used to calculate the dependency distartce: I. Case consistency For example, in the sentence &quot;VM/SP kceps the information on the virtual disk,&quot; there is a prepositional phrase attachment ambiguity, as shown in Figure 6. If the path shown in Figure 8 is found together with the candidate dependency shown in Figure 7, then tile semantic case of the path's dependency between &quot;store&quot; and &quot;disk&quot; must be consistent with the grammatical case of the sentence's dependency between &quot;keep&quot; and &quot;virtual disk.&quot; lIere, the case consistency between the sentence and the path holds, since the grammatical case &quot;on&quot; call have the role of the semantic case &quot;location.&quot; If this consistency holds, then the value of case consistency is 1; otherwise, it is 0.</Paragraph> </Section> <Section position="4" start_page="283" end_page="286" type="metho"> <SectionTitle> 2. Co-occurrence consistency </SectionTitle> <Paragraph position="0"> This is the consistency between the other modifiers of the modifiee of tile candidate dependency, called the co-occurrent modifiers, and those of a path.</Paragraph> <Paragraph position="1"> 2. The common trees tz... that involve both elenmnts, ei 6 Swl and ej ~ Sw2, of each set are found.</Paragraph> <Paragraph position="2"> 3. Tile node locations of ei and ej in t~... are checked. For example, a path between the words a and c is shown in Figure 5.</Paragraph> <Paragraph position="3"> the dependency tree shown in Figure 10, then there is also a eo-oceurrent modilicr &quot;operating systenf' that has the semantic ease of agent. In addition, there is a tmxonym relationship between &quot;VM/SP&quot; and &quot;operating system&quot; in the knowledge base, as shown in Figure \].I. In this case, the co-occurrence consistency between &quot;VM/SP&quot; and &quot;operating systenf' holds, since there is a relationship between the words and both case,; are consistent (the grammatical case subject call have a semantic case agent), as shown in Figure 12. The vahm of co-occurrence consistency is tile number of co-oceurrent modifiers that are consistent between the path and the sentence. Here, the value is 1, since only one co-oecurrent modifier &quot;VM/SP&quot; is consistent.</Paragraph> <Paragraph position="4"> Context consistency Context consistency holds if dependencies in a path already exist in previous sentences. For example, if the sentence &quot;the data is stored in the storage device&quot; comes before tile above sentence, then the dependency structure shown in Figure 13 is in the context base in which the dependency structures of previous sentences are stored. Then the other path (shown in Figure 14), which corresponds to the dependency between &quot;store&quot; and &quot;disk&quot; in the &quot;path,&quot; is found by using the context base. Thus the dependency between &quot;store&quot; and &quot;disk&quot; is defined by the context. The vahn', of context consistmmy is the number of dependencies in the path that are. defined by tile context. In this case, the wflue The dependency distance is computed from the following formula:</Paragraph> <Paragraph position="6"> where \]Dep\] represents the number of dependencies included in the palh, i&quot;c ..... is the value of case consistency, 1 ~'oo~. is that of co-occurrence cm~sistency, and l'C,o,,t is that of context consistency.</Paragraph> <Paragraph position="7"> This formula assumes that case and co-occurrence consistency affect the distance of the whole path, but that context consistency affects the distance of each dependency in the path.</Paragraph> <Paragraph position="8"> n is a real number in tile range 0 < n < 1; it is a heuristic parameter that represents the degree of unimportance of context consistency.</Paragraph> <Paragraph position="9"> The dependency distance between &quot;keep&quot; and &quot;virtual disk&quot; that is calculated by using the path in the example is 0.125, because the number of depenttencies is 1, the value of case consistency is 1, that of co-occurrence consistency</Paragraph> <Section position="1" start_page="285" end_page="286" type="sub_section"> <SectionTitle> and Process of Disambiguation </SectionTitle> <Paragraph position="0"> When there are several attachment ambiguities in one sentence, the relationships of each pair of ambiguities are represented by a constraint network \[91. The idea that am-Mguous syntactic structures can be represented by a data structure of constraint network was originally developed by Hiroshi Maruyama \[7 t. A constraint network consists of constraint tables.</Paragraph> <Paragraph position="1"> For example, the constraint tables shown in Table 2 are constructed from tile ambiguous dependency structure shown in Figure 15. In this dependency structure, words 5, 6, and 7 have attachment ambiguities, so their possible modifiees are {1,3}, {1,5}, and {3,6} respectively. The constraint table is a two-dimensional matrix that represents the. possibility of simultaneous modification of two ambiguous attachments. The rows and columns of the matrix show the candidate modifiees of each modifier, and an element in the matrix means the possibility (1 or 0) that both dependencies can exist simultaneously. For example, constraint table T5.7 indicates that if word 5 modifies word 1, then word 7 cannot modify word 3 because of the rule of no-crossing.</Paragraph> <Paragraph position="2"> By using the constraint tables, the system decides which ambiguity should be resolved first. This process is called planning. In the above example, words 5, 6, and 7 have two candidate modifiees each. But from the constraint tables, we can see that if word 7 modifies word 3, then words 5 and 6 cannot modify word 1. Thus, in this case, the ambiguity concerning the modification of word 7 should be resolved first. The algorithm for plauning consists of the following steps: 1. On each row of the constraint table Ti.j, sum up the element values (Ai in Table 2), and subtract the sum from the size of the row (Bi). Then sum up the results on all rows (Ci). The result is the value of merit of the ambiguity of word i.</Paragraph> <Paragraph position="3"> 2. Do the same in each cohmm. The result is the value of merit of the ambiguity of word j.</Paragraph> <Paragraph position="4"> 3. In all the constraint tables, sum up all the values of merit of each ambiguity, and divide each of these values by the number of their candidate modifiees.</Paragraph> <Paragraph position="5"> 4. The expected values of meTit of all ambiguities are given by the above process. Select the ambiguity that has the highest expected value.</Paragraph> <Paragraph position="6"> When an ambiguity is resolved, the system updates the constraint tables by tile filtering algorithm called constraint propagation. We apply Mohr and Henderson's AC4 algorithm \[8\] for constraint propagation. We reduce the computational cost of disambiguation by using planning and constraint propagation.</Paragraph> <Paragraph position="7"> Structural disambiguation of a sentence is done as follows. The PEG parser tmrses a sentence and constructs its phrase structure. The Dependency Stracturc Builder transhttes the phrase structure int.o the dependency strm:ture, and constructs the constraint tables when the phrase structure contains sew~ral structural ambiguities. The Planner, which is the component for planning, gives the Disambiguator the information on an ambiguous dependency and its candidate modifiees. The Disambiguator decides which modifiee is the most preferable by doing path search and distance calculation. After resolving one ambiguous attachment, it calls the constraint propagation routine to filter the other ambiguities' candidates. After filtering, the Transformer transforms the dependency structure into one that has correc t dependencies for all resolved attachments. These processes are iterated until no ambiguity remains.</Paragraph> </Section> </Section> class="xml-element"></Paper>