| { | |
| "paper_id": "1991", | |
| "header": { | |
| "generated_with": "S2ORC 1.0.0", | |
| "date_generated": "2023-01-19T07:34:39.074146Z" | |
| }, | |
| "title": "Unification Algorithms for Massively Parallel Computers*", | |
| "authors": [ | |
| { | |
| "first": "Hiroaki", | |
| "middle": [], | |
| "last": "Kitano", | |
| "suffix": "", | |
| "affiliation": { | |
| "laboratory": "", | |
| "institution": "NEC Corporation", | |
| "location": { | |
| "addrLine": "2-11-5 Shibaura, Minato-ku Tokyo", | |
| "postCode": "108", | |
| "country": "Japan" | |
| } | |
| }, | |
| "email": "hiroaki@cs.cmu.edu" | |
| } | |
| ], | |
| "year": "", | |
| "venue": null, | |
| "identifiers": {}, | |
| "abstract": "This paper describes unification algorithms for fine-grained massively parallel comput ers. The algorithms are based on a par allel marker-passing scheme. The marker p \ufffd sing scheme in our algorithms carry only bit-vectors, address pointers and values. Be cause of their simplicity, our algorithms can be implemented on various architectures of massively parallel machines without loosing the inherent benefits of parallel computation. Also, we describe two augmentations of uni fication algorithms such as multiple unifi cation and fuzzy unification. Experimental results indicate that our algorithm attaines more than 500 unification per seconds (for DAGs of average depth of 4) and has a linear time-complexity. This leads to possible im plementations of massively parallel natural l \ufffd guage parsing with full linguistic analy sis.", | |
| "pdf_parse": { | |
| "paper_id": "1991", | |
| "_pdf_hash": "", | |
| "abstract": [ | |
| { | |
| "text": "This paper describes unification algorithms for fine-grained massively parallel comput ers. The algorithms are based on a par allel marker-passing scheme. The marker p \ufffd sing scheme in our algorithms carry only bit-vectors, address pointers and values. Be cause of their simplicity, our algorithms can be implemented on various architectures of massively parallel machines without loosing the inherent benefits of parallel computation. Also, we describe two augmentations of uni fication algorithms such as multiple unifi cation and fuzzy unification. Experimental results indicate that our algorithm attaines more than 500 unification per seconds (for DAGs of average depth of 4) and has a linear time-complexity. This leads to possible im plementations of massively parallel natural l \ufffd guage parsing with full linguistic analy sis.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Abstract", | |
| "sec_num": null | |
| } | |
| ], | |
| "body_text": [ | |
| { | |
| "text": "This paper describes unification algorithms using par alle ! marker-passing scheme. The purpose of this pa p _ er 1s to show parallel unification algorithms which are simple enough to be implemented by massively parallel machines, and have some novel features.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "Unification is a basic operation in computational lin guistics. However, this operation is known to be com putationally expensive, and thus is considered a major bottleneck in improving the performance of natural lan \ufffd uage processing systems. A search for efficient algo \ufffd thms has been conducted by many researchers involv mg parallel algorithms such as [Yasuura, 19841. How ever, theoretical lower-bound was shown by [Dwork et. al., 1984] that unifiability is log-space complete for P. This leads to [Knight, 1989] 's conclusion that use ? f massively parallel machines will not significantly improve the speed of unification. Then, why do we propose a parallel unification? We have three major reasons.", | |
| "cite_spans": [ | |
| { | |
| "start": 420, | |
| "end": 441, | |
| "text": "[Dwork et. al., 1984]", | |
| "ref_id": "BIBREF0" | |
| }, | |
| { | |
| "start": 503, | |
| "end": 517, | |
| "text": "[Knight, 1989]", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "First, although theoretical limitation for speed up *This work has been supported in part by the Nationa l Science Foundation under grant MIP-90/09109. bas been shown for full unification, parallelization of unification actually improves performance of the en tire system. This improvement of performance is a clear benefit for practical natural language processing systems, in particular for tasks like spoken language processing where real-time processing is essential. In addition, we propose parallel unification algorithms which attained a time-complexity of o (D) where D is a depth of the deepest path in DAGs to be uni fied. We achieved this by assuming all disjunctions are pre-expanded into several DAGs so that each pair of DAGs does not contain disjunctions, and so that higher parallelism can be maintained through out the unification process. This is a reasonable assumption when we implement unification on massively parallel machines, where the basic implementation strategy is a memory-intensive approach allowing time-complexity to be converted into space-complexity. Thus, although we do not discover faster full unification with disjunc tion, we discovered a means to substantially speed up unification on the massively parallel machines.", | |
| "cite_spans": [ | |
| { | |
| "start": 566, | |
| "end": 569, | |
| "text": "(D)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "Second, we designed our algorithm for massively parallel machines where each processor has relatively low processing capability. We only require each pro cessing unit to have some basic operations and the capa bility to pass bit-markers, pointers to other processing units, and numeric values. This design decision aims at the accomplishment of two things -development of practical unification algorithms for massively parallel computers such as SNAP [Moldovan et. al., 1989] and Connection Machine [Hillis, 1985] , and development of algorithms for specialized unification hardware such as unification chips or unification co-processors. Func tionalities of massively parallel machines \u2022 are severely limited due to the weak processing capability of each unit. Advantages of massively parallel machines for semantic processing, such as contextual priming, are widely recognized. However, in implementing seri ous natural language parsers, unification operation is essential. Unfortunately, we have not seen any algo rithm which assumes low processing capability of each processor in massively parallel machines. Although some machines support high-level language, such as C or lisp, automatic parallelization does not gu\ufffdan tee efficiency of actual operations. Thus, designing unification algorithms for massively parallel machines has great impact on exploring maximum potential of these machines for natural language processing. One other reason is that, by assuming each processor has Figure 1: PU Class Nodes and PU s low computation power, our algorithms could be im plementable as unification co-processor boards using numbers of less-powerful processors. A possibility for such a compact acceralator would be the clear benefit for the natural language community.", | |
| "cite_spans": [ | |
| { | |
| "start": 451, | |
| "end": 475, | |
| "text": "[Moldovan et. al., 1989]", | |
| "ref_id": "BIBREF0" | |
| }, | |
| { | |
| "start": 499, | |
| "end": 513, | |
| "text": "[Hillis, 1985]", | |
| "ref_id": "BIBREF0" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "Third, our algorithms can easily entail some novel features such as multiple unification and fuzzy uni fication. These features have not been considered in past unification literature. It can also incorporate typed unification. Multiple unification is a unifica tion between more than two trees or DAGs. Our al gorithms enable this scheme without undermining its performance. Fuzzy unification allows unification of on-unifiable DAGs; but assigns a cost of violations. This would be useful for applications such as spoken language processing where handling of ungrammatical input is essential, because subtle ungrammaticalities can be overlooked.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "We assume a parallel architecture where numbers of processing units are interconnected. The Processor Unit (PU) is a basic element of the system. It has its own processing capability and memory. This can be physical or logical, but, of course, we assume each unit is actually implemented as hardware. The Pro cessor Unit Class (PUC) is a class of PUs which has several PUs as instances of the PUC. For each PUC, one PU is assigned to manage instances of the class. Figure 1 illustrates relations between PUCs and PUs. PUC-1 has instances PU\ufffdlA and PU-lB, and PUC,. 2 has instances PU-2A and PU-2B. This relation will be established when DAGs are loaded onto the unification co-processor.", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 465, | |
| "end": 473, | |
| "text": "Figure 1", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "Architecture", | |
| "sec_num": "2.1." | |
| }, | |
| { | |
| "text": "We assume each PU's memory is is composed of a bit markers register, value register, and pointer memory for fan-in connections, fan-out connections, and address registers. ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Architecture", | |
| "sec_num": "2.1." | |
| }, | |
| { | |
| "text": "The following notations will be used in describing al gorithms: ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Notations", | |
| "sec_num": "2.3." | |
| }, | |
| { | |
| "text": "PU", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Notations", | |
| "sec_num": "2.3." | |
| }, | |
| { | |
| "text": ", and GLB-Search( ... ) will be explained in sec tions where they are used. In some cases, if-then else control sequence is used for ease of understand ing. However, obviously, this can be implemented using logical bit-marker operations such as (AND 1 2 4) followed by a propagation instruction, such as Propagate(P-Address,PU(4),PU(V) .... ). This case, (AND 1 2 4) is a logical operation that set marker 4 when markers 1 and 2 exist. This instruction sequence should be read as: if there are PUs such that PU(l,2), then propagate(P-Address,PU{l,2),PU(V) .... ). Knight, 1988] . The ad vantage of using pseudo-unification, instead of full unification (or graph-unification), is that it can be im plemented easier (less resource requirements and a sim pler algorithm) and faster than full.:.unification. Yet, practically, pseudo-unification can cover a substantial range of linguistic phenomena. Actually, KBMT-89 [Nirenberg et. al., 1989 ] (a knowledge-based ma chine translation system based on LFG, and devel oped at the Center for Machine Translation at Carnegie Mellon University) was implemented using pseudounification.", | |
| "cite_spans": [ | |
| { | |
| "start": 564, | |
| "end": 577, | |
| "text": "Knight, 1988]", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 906, | |
| "end": 938, | |
| "text": "KBMT-89 [Nirenberg et. al., 1989", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": ". ,z), ln(P-Address, From-Address), Equal(P-Address, &PU)", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "The algorithm which we describe in lhis section accounts for all non-disjunctive cases of pseudo unification. Tree-0 and Tree-1 \ufffde unified (figure 3). Our algorithm for destructive tree unification consists of three parts:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "The Algorithm", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "The goal of the shared node detection stage, or the common feature detection stage, is to set S markers to all nodes that are shared between trees.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Shared Node Detection", | |
| "sec_num": "3.1.1." | |
| }, | |
| { | |
| "text": "Step 1 carry out this stage. Figure 3(a) shows the initial state of trees loaded into a PU network. First of all, an address of a PUC of a root PU of the tree-0 is set to P-Address. Then, P-Address is propagated until it gets to a PU which has V marker set. During this propagation, Check-Shared is conducted at each PU which P-Address traverses through. &ISA(Root) returns an address of the PUC of the Root PU. By the same token, &ISA(PU-0) returns an address of the PUC of the PU-0. The result is shown in 3(b). All shared PUs are indicated by solid circles. Some important markers on each PU are shown in brackets, but some markers are ignored due to diagram space.", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 29, | |
| "end": 40, | |
| "text": "Figure 3(a)", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "Shared Node Detection", | |
| "sec_num": "3.1.1." | |
| }, | |
| { | |
| "text": "Next, we would like to detect conflicts. We assume that if two different value units are linked to the PUs both under the same PUC, and the PU is a shared arc unit, then unification should fail.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Failure Detection", | |
| "sec_num": "3.1.2." | |
| }, | |
| { | |
| "text": "Step 2 and 3 carry out this stage.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Failure Detection", | |
| "sec_num": "3.1.2." | |
| }, | |
| { | |
| "text": "Back-Propagate starts from terminal nodes which are not shared. The purpose of this back-propagation is to identify pre-terminal PU s which are Arcs. In case of Figure 3, tree-0 and tree-I are unifiable.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Failure Detection", | |
| "sec_num": "3.1.2." | |
| }, | |
| { | |
| "text": "Since unifiability is assured in the failure detection stage, all we need is to merge two trees.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Merging", | |
| "sec_num": "3.1.3." | |
| }, | |
| { | |
| "text": "Step 4, 5, 6, and 7 carry out this stage.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Merging", | |
| "sec_num": "3.1.3." | |
| }, | |
| { | |
| "text": "Back-propagation is used to search PUs which un shared leaves should be connected to. Figure 3(c) indicate PUs involved in this process. Propagation starts from PU(l,V,-S) and goes up until it meets a PU which is shared. These PUs are places where unshared branches should be connected. Next, propagate an ad dress of ea' ch PUs for one traverse\ufffd Now, relevant PUs have an address of PUs which should be connected. Connect a PU with markers P-Address, 0, and B and a PU with markers P-Address, 1, and T with Arc-to. Propagate marker O from PU with P-Address, 0, and B. As a result, we get a unified tree consisting of PUs marked with 0.", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 86, | |
| "end": 97, | |
| "text": "Figure 3(c)", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "Merging", | |
| "sec_num": "3.1.3." | |
| }, | |
| { | |
| "text": "Although pseudo-unification does quite a good job in most practical cases, there are cases where graph unification is necessary. Lack of the re-entrance in the pseudo-unification forces grammar writers to sub divide their grammar rules to cope with various cases of re-entrance because re-entrant structure must be ex panded to trees. This section presents full-unification (destructive version). ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Full-Unification", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "The arc merging stage for the destructive graph unifi cation is shown in table 2. For all nodes with marker F and 1, but not S, propagate marker E. Propagation stops when it arrives at a node marked S. Back-Propagate P-Address until it arrives at a node with S. For all nodes which have S and P-Address, mark B. Propa gate marker B for one traverse, and mark destination node with T. Connect a node with markers P-Address, 0, and B and a node with markers P-Address, I, and T with Arc-to. Propagate marker 0 from a node with P-Address, 0, and B.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Arc Merging", | |
| "sec_num": "4.1.1." | |
| }, | |
| { | |
| "text": "So far we have been discussing destructive unification algorithms where represented feature structures are de-stroyed in the process of unification. Obviously, this would be problematic because (I) it destroys the orig inal feature structure even when the feature structure needs to have its unifiability examined against more than one feature structure, and (2) destructive unifica tion involves over-copying and early-copying [Wrob lewski, 1988] In this section, we further extend algorithms pre sented so far, and present a nondestructive graph uni fication algorithm. To implement the nondestructive graph unification, new nodes and arcs need to be cre ated by assigning them on empty PUs. Instead of passing only P-Address, as we have been using so far, we pass P-Address and N-Address (an address of the newly assigned PU). Given two DAGs, the algorithm in table 3 creates a new DAG as a result of unification. ", | |
| "cite_spans": [ | |
| { | |
| "start": 428, | |
| "end": 447, | |
| "text": "[Wrob lewski, 1988]", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Nondestructive Unification", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "The 'Ip-terms proposed in [Ait-Kaci, 1984] are similar to the feature structure, but the functor is retained. GLB-Search is a special instruction where propa gation of markers start from nodes with V markers set but not S markers, and P-Address is propagated through ISA hierarchy downward. At each PU during the traversal, the current PU's address is set to GLB Address, and it is propagated through ISA link upward. When GLB-Address arrives at a PU with V marker set but not S marker, it means there are GLB between the origin PU and the destination PU. Now, GLB-Search is conducted backwards, starting from the previous des tination PU. This gives an address of the GLB PU to the originated PU. Thus, both PUs have an addres of the GLB PU. When one PU (PU-a) is under the other PU's (PU-b) ISA hierarchy, a GLB PU should be PU a. Using the same mechanism, an address of PU-a is given to both PUs. However, this time GLB-Address propagation is not involved since GLB-PU itself is a destination PU. At the merging stage, PUs represent ing GLB should be merged instead of PUs in DAG-0 or DAG-I (when GLB is one of the PU in DAG-0 or DAG-1, the PU in these DAGs can be merged). This can be done by using pointers to the GLB PUs propa gated to PUs in DAG-0 and DAG-1. This mechanism enables typed unification.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Typed Unification", | |
| "sec_num": "6." | |
| }, | |
| { | |
| "text": "Traditionally, unification has been a logical operation, and thus, its failure resulted in hard rejection. We pro pose an alternative scheme called a fu zzy unification or a soft rejection unification. Contrary to the tradi tional unification which only returns nil when failed, a new unification scheme returns a partially unified fea ture structure and a value which indicates the degree of failure. In the soft rejection unification, each arc is assigned with a value which is accumulated when unification in its subgraph was failed. Meanings of the value can vary depending upon application and spe cific implementation. It can be a cost of violation or a probability measure of which violation will happen.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": ".1. Fuzzy Unification", | |
| "sec_num": "7" | |
| }, | |
| { | |
| "text": "Unification operation with such property is signifi cant for many applications which require robust pars ing. For example, speech input processing requires in tegrated processing of a speech recognition module and linguistic parsing in order to limit the scope of search (reduce perplexity) which in tum improves recognition Typed 1: GLB-Search( P-Address GLB-Address, PU(V,-S) , PU(V), Set(P-Address,&PU) Set(GLB-Address,&PU), Set(GLB-Address,&PU), nil) Typed 2: GLB-Search( P-Address GLB-Address, PU(V,-S,P-Address) , PU(V), Set (P-Address,&PU) Set (GLB-Address,&PU) , Set(GLB-Address,&PU), nil) Typed 3: Mark( S, PU(Equal(P-Address,&PU))) Table 4 : Type Checking in Typed Unification rate. While spoken language inherently involves erro neous sentences, use of the traditional hard-rejection type unification cannot be applied as it is -parsing needs to proceed even with minor syntactic failures. Some relaxation techniques have been proposed for detecting and overlooking minor errors by allowing some of the constraints to be ignored. However, tradi tional relaxation methods require multiple unification operations to check against sets of constraint equations, resulting in substantial overhead against conventional unification-based parsing. In addition, these relaxation methods did not assign weights or the probability that certain violations will happen. This would have ad verse effects in reducing perplexity, because all possi ble errors are granted or predicted with equal weights. Since the likelihood of certain violations happening can be statistically obtained, providing a priori probabil ity of such violations would help improve recognition rate.", | |
| "cite_spans": [ | |
| { | |
| "start": 334, | |
| "end": 377, | |
| "text": "GLB-Search( P-Address GLB-Address, PU(V,-S)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 464, | |
| "end": 517, | |
| "text": "GLB-Search( P-Address GLB-Address, PU(V,-S,P-Address)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 531, | |
| "end": 546, | |
| "text": "(P-Address,&PU)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 551, | |
| "end": 568, | |
| "text": "(GLB-Address,&PU)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [ | |
| { | |
| "start": 642, | |
| "end": 649, | |
| "text": "Table 4", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": ".1. Fuzzy Unification", | |
| "sec_num": "7" | |
| }, | |
| { | |
| "text": "For example, in a sentence John want to attend the conference. Although John and want cause violation in the third-person-present-singular constraint, we do not want that parse to be aborted since its semantics can be easily recovered in a post-processing. However, we want to add a cost to such parse so that if a speech recognition module provided two word hypotheses of want and wants. John wants ... would be selected as a most probable hypothesis. This extension is. trivial in our algorithm. The failure detection stage is revised as seen in table 5.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": ".1. Fuzzy Unification", | |
| "sec_num": "7" | |
| }, | |
| { | |
| "text": "Alternatively, more sophisticated computation, instead of ADD, can be used to determine the degree of unifi ability.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "ADD-value adds values of markers at the root node.", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Traditionally, unification has been defined as an oper ation between between two DAGs; it takes two DAGs and returns a unified DAG or nil when fai led. We extend this notion and propose multiple unificationunification of more than two DAGs. This extension would benefit processing of linguistic analysis which uses N'-branching ", | |
| "cite_spans": [ | |
| { | |
| "start": 315, | |
| "end": 327, | |
| "text": "N'-branching", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Multiple Unification", | |
| "sec_num": "7.2." | |
| }, | |
| { | |
| "text": "The algorithm is efficient. Let's assume that we have DAGs with N nodes, depth D and width W. Shared node detection stage requires . propagation of markers from roots to each value node. Since this can be done in parallel, computational cost is approximately D x ( P + CSH ) whereas P is a time required for propa gation of a marker for one depth, and CSH is a cost for detecting wether two nodes has a same PUC. In the failure detection stage, back-propagation of mark ers for one travarsal backward is requried. The cost is P. The merging stage requires 2 x D x P + P at worst cases. The arc merging state costs 3 x D x P+ Pat worst cases. Thus, in total, 6 x D x P + 3 x P + C + CSH x D is the computational cost of the full unification in our algorithm with 2N-1 processors. Thus, in rough esti mation, a complexity of the algorithm is of order of O(D). When the number of processors (M) is less than 2N-1, efficiency might degrade depending upon allo cation of nodes onto processors. If we can allocate nodes in a same path to one processor, we only require 2: Back-Propagate (PT, PU(V,-S), 1, nil, nil, Mark(P'I) ) 3: If there is a PU with PT and S, then Back-Propagate(Value, PU(PT,S), PU(R), nil, nil, ADD-Values) Table 5 : The failure detection stage of the fuzzy unification W processors to maintain the efficiency close to the es timation above. This is because a marker-propagation in the same path is sequential. However, W processor condition may degrade its efficiency due to synchro nization required for marker-propagation at arc merg ing and branching crossing processor boundary. The worst case of W processor condition is 0( D : N ), but, of course, this can be easily avoided by designing mem ory allocation optimally. When unification failed, then the computational cost is D x P (cost for shared node detection) and P (cost for failure detection). Let S be a success rate of the unification (which is usually be tween 40% to 20% ), expected computational costs will be: S x (D x (6 x P + CSH)", | |
| "cite_spans": [ | |
| { | |
| "start": 642, | |
| "end": 647, | |
| "text": "Thus,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 648, | |
| "end": 657, | |
| "text": "in total,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 658, | |
| "end": 659, | |
| "text": "6", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [ | |
| { | |
| "start": 1081, | |
| "end": 1118, | |
| "text": "(PT, PU(V,-S), 1, nil, nil, Mark(P'I)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 1222, | |
| "end": 1229, | |
| "text": "Table 5", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "A Brief Complexity Analysis", | |
| "sec_num": "8.1." | |
| }, | |
| { | |
| "text": "+ 3 x P + C) + (1 -S) x (D x (P + CSH) +P)", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A Brief Complexity Analysis", | |
| "sec_num": "8.1." | |
| }, | |
| { | |
| "text": "We have implemented our algorithms on a simulator for a fine-grained parallel machine which assumes ac tual computation time for each instruction. To unify the DAGs shown in figure 4, the destructive graph unification took 1957 micro seconds (510 unification per second). The rate of performance degradation is about 330 micro seconds for each additional depth. Table 6 shows numbers of each instruction exe cuted, and computational cost in one example of the unification operation. Statistics clearly show that the shared node detection stage is the most computation ally expensive. Particularly, the extensive numbers of address propoagation and bit check operation are two major causes of the computational cost. The estimated time for propagating an address for one traverse is set to 15 micro seconds, which can be reduced to 3 micro seconds on SNAP architecture, thus attining substantial speed up. Algorithms described in this paper has been implemented on the SNAP massively parallel computer as a part of the joint project between Carnegie Mellon University and University of Southern California.", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 362, | |
| "end": 369, | |
| "text": "Table 6", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "Experimental Results", | |
| "sec_num": "8.2." | |
| }, | |
| { | |
| "text": "This paper described unification algorithms using marker-passing. We only assumed passing of bit markers, pointers to PUs, and values. Operations re quired for our unification algorithms are simple and easily implementable in massively parallel machines which use numbers of processing units with a rela tively low-processing capability. Actually, operations and marker-passing schemes assumed in this paper are readily available in actual massively parallel machines such as SNAP [Moldovan et. al., 1989 ].", | |
| "cite_spans": [ | |
| { | |
| "start": 481, | |
| "end": 504, | |
| "text": "[Moldovan et. al., 1989", | |
| "ref_id": "BIBREF0" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Conclusion", | |
| "sec_num": "9." | |
| }, | |
| { | |
| "text": "The algorithms are simple. It requires passing of bit-markers and addresses to PUs for conventional uni fications. Despite its simplicity, our algorithms cover all non-disjunctive cases of unification of trees and most practical cases of unification of graphs. How ever, investigations should be conducted to identify a class of graphs which our algorithms can and can not handle. Should a class of graphs which can be handled by our algorithms cover a class of graphs ap pearing in natural language processing, our algorithms can be a very powerful scheme of parallel unification processing. Typed-unification, originally proposed by [Ait-Kaci, 1984] , can be naturally incorporated in our algorithms since our algorithms are based on marker passing which is originally proposed for an intersection search. Conformity with lattice search is obvious.", | |
| "cite_spans": [ | |
| { | |
| "start": 635, | |
| "end": 651, | |
| "text": "[Ait-Kaci, 1984]", | |
| "ref_id": "BIBREF0" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Conclusion", | |
| "sec_num": "9." | |
| }, | |
| { | |
| "text": "The algorithms are efficient on massively parallel machines. Even in nondestructive_graph unification, it requires only nine propagations and back-propagations and some checking instructions. For the graphs with depth D, unification should be done at 6 x D x P + 3 x P + C + CSH x D whereas P is a time required for propagation of a marker for one arc traverse, C is a total cost of condition checks, and CSH is a total cost for detecting whether two nodes has a same PUC. Thus, the complexity is of order of O(D). The processor requirement is linear to the size of graphs. This simple estimation indicates that our algorithm would be fast enough for practical applications.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Conclusion", | |
| "sec_num": "9." | |
| }, | |
| { | |
| "text": "Novel features such as multiple-unification and fuzzy unification adds new dimensions to our unifi cation algorithms. Also, our unification algorithms are easily augmented for typed unification. In practical cases, needs for unification of more than two feature structures are commonly observed, yet this has not been proposed in the past. Use of multiple-unification reduces the amount of copying and thereby improves performance. Fuzzy unification would be a very use ful concept for applications such as spoken language processing. Instead of rejecting at the detection of unification failure, the fuzzy unification adds a cost of violation in such cases, and allows processing of violated hypotheses to proceed. Where application domains inevitably involve ungrammatical inputs, the fuzzy-unification would be a powerful extension to the traditional unification approach.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Conclusion", | |
| "sec_num": "9." | |
| } | |
| ], | |
| "back_matter": [ | |
| { | |
| "text": "The author would like to thank Hitoshi Iida, Hideto To mabechi, Dan Moldovan, and members of the SNAP", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Acknowledgement", | |
| "sec_num": null | |
| } | |
| ], | |
| "bib_entries": { | |
| "BIBREF0": { | |
| "ref_id": "b0", | |
| "title": "SNAP: A Marker-Propagation Architecture fo r Knowledge Processing", | |
| "authors": [ | |
| { | |
| "first": "H", | |
| "middle": [], | |
| "last": "Ait-Kaci ; Ait-Kaci", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "", | |
| "middle": [], | |
| "last": "Dwork", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1984, | |
| "venue": "A Lattice Theoretic Ap proach to Computation Based on a Calculus of Par tially Ordered Type Structures", | |
| "volume": "1", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Ait-Kaci, 1984] Ait-Kaci, H., A Lattice Theoretic Ap proach to Computation Based on a Calculus of Par tially Ordered Type Structures, Ph.D. Thesis, Uni versity of Pennsylvania, 1984. [Dwork et. al., 1984] Dwork, C., Kanellakis, P. and Mitchell, J., \"On the Sequential Nature of Unifica tion,\" Journal of Logic Programming, vol. 1, 1984. [Hillis, 1985] Hillis, D., The Connection Machine, The MIT Press, Cambridge, 1985. [Knight, 1989] Kevin, K., \"Unification: A Multi Disciplinary Survey,\" ACM Computing Surveys, Vo l. 21, Number 1, 1989. [Moldovan et. al., 1989] Moldovan, D., Lee, W. , and . Lin, C., SNAP: A Marker-Propagation Architecture fo r Knowledge Processing, University of Southern California Technical Report CENG 89-10, 1989. [Nirenberg et. al., 1989] Nirenberg, S. (Ed.), Knowledge-Based Machine Translation, Center for Machine Translation Project Report, Carnegie Mel lon University, 1989. [Pollard and Sag, 1987] Pollard, C. and Sag, I., An Information-based Syntax and Semantics, Vo lume 1., Chicago University Press, 1987. [Tomita and Knight, 1988] Tomita, M. and Kevin, K., \"Pseudo-Unification and Full Unification,\" CMU CMT-88-MEMO, 1988. [Wroblewski, 1988] Wroblewski, D., \"Nondestruc tive Graph Unification,\" in Proceedings of AAAl-88, 1988. [Yasuura, 1984] Yasuura, H., \"On Parallel Computa tional Complexity of Unification,\" in Proceedings of the International Conference on Fifth Generation Computer Systems, 1984.", | |
| "links": null | |
| } | |
| }, | |
| "ref_entries": { | |
| "FIGREF0": { | |
| "num": null, | |
| "text": "Trees or DAGs are represented as PUs and their con nections. Each arc and node is assigned to each PU.", | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF1": { | |
| "num": null, | |
| "text": "Figure 2: Representation of Nodes and Arcs", | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF3": { | |
| "num": null, | |
| "text": "1: Propagate(P-Address, Root, PU(V), Set(P-Address,&ISA(Root)), Check-Shared, nil) Check-Shared: If there is a PU (PU-1), under the same PUC, such that PU(l,In(P-Address, From-Addresses)), then Mark(S), Mark(S,PU-1), and Set(P-Address,&ISA(PU-0)), else abort propagation. 2: Back-Propagate(PT,PU(V,-S),1,nil,nil,Mark(PT)) 3: If there is a PU such that PU(PT,S), then unification is a failure. 4: Back-Propagate(P-Address,PU(l,V,-S),PU(S), Set(P-Address, &PU(l,V,-S)), nil, Mark(B,PU(S,P-Address))) 5: Propagate(P-Address, PU(B), 1, Set(P-Address,&PU(B)), nil, Mark(1j) 6: Connect(Arc-to, PU(P-Address,0,B), PU(P-Address,1,n) 7: Propagate(0, PU(0,B), PU(V), nil, Mark(0), Mark(0))Table 1: Pseudo-Unification Algorithm4.1. The AlgorithmIn full-unification, we only need to add merging of arcs which is not covered in the pseudo-unification algorithm.1. Shared Node DetectionStage 2. Failure Detection Stage 3. Merging Stage 4. Arc Merging Stage DAG-0 and DAG-1 are unified (figure 4). In figure 4(a), shared nodes are detected and indicated by solid circles. Figure 4(b) and ( c) shows the merging stage. In figure 4(b) top and bottom PU s are marked and then merged in figure4(c). Up to this point, we can sim ply apply algorithms presented for pseudo-unification. However, in unifying DAGs, we must take into account the existence of unshared arcs which are in between shared PUs that are not handled in the merging stage in the pseudo-unification algorithm. An arc merging stage merges such arcs into the DAG. The algorithm presented here covers most of practical cases of non disjunctive graph unification, but there are some cases which the algorithm does not provide correct result. However, even in such cases, a simple post-processing can modify the graph to provide correct results.", | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF4": { | |
| "num": null, | |
| "text": "DAG-I are unified and result in DAG-2. Figure 5 is a state after the shared node is detected. Solid circles indicate PUs for shared nodes. In fig ure 6, all unifiable branches of DAG-0 and DAG-I are merged to DAG-2 to create New DAG-2. In fig ure 7 intermediate arcs are merged into DAG-2, and create Final DAG-2. One big difference between non destructive graph unification and destructive unifica tion is that, in nondestructive unification, new PUs are assigned when unifiable subgraphs from DAG-0 and DAG-1 are merged into DAG-2, whereas destructive unification is simply marked with Oat the merging pro cess. For this reason, Append-New-Node assigns a new PU for each node merged to DAG-2, and connects it to existing DAG-2 structure. Then, pointers to the merged PU in DAG-2 and an equivalent PU in DAG-0 or DAG-1, are propagated so that the next PU can be connected to them.", | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF5": { | |
| "num": null, | |
| "text": "-Nodes: If a cuurent PU is PU(0,-S) or PU(l,-S), then Create-Node(2,N-Address), Connect(Arc-to,PU(P-Address),PU(2", | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "TABREF1": { | |
| "text": "", | |
| "type_str": "table", | |
| "html": null, | |
| "num": null, | |
| "content": "<table/>" | |
| } | |
| } | |
| } | |
| } |