def createEdge(self, childEdges, currentNode, span, hyperEdge): """ Create a new edge from the list of edges 'edge'. Creating an edge involves: (1) Initializing the PartialGridAlignment data structure (2) Adding links (f,e) to list newEdge.links (3) setting the score of the edge with scoreEdge(newEdge, ...) In addition, set the score of the new edge. """ newEdge = PartialGridAlignment() newEdge.decodingPath.data = currentNode.data newEdge.decodingPath.isDummy = False newEdge.scoreVector_local = svector.Vector() newEdge.scoreVector = svector.Vector() newEdge.hyperEdgeScore = hyperEdge.score for index, e in enumerate(childEdges): newEdge.links += e.getDepthAddedLink() newEdge.scoreVector_local += e.scoreVector_local # TOP node does not have local hypothesis so there is only one childedge if currentNode.data["word_id"] != e.decodingPath.data["word_id"]: newEdge.decodingPath.addChild(e.decodingPath) newEdge.scoreVector += e.scoreVector if e.boundingBox is None: e.boundingBox = self.boundingBox(e.links) score, boundingBox = self.scoreEdge(newEdge, currentNode, span, childEdges) return newEdge, boundingBox
def createEdge(self, childEdges, currentNode, span): """ Create a new edge from the list of edges 'edge'. Creating an edge involves: (1) Initializing the PartialGridAlignment data structure (2) Adding links (f,e) to list newEdge.links (3) setting the score of the edge with scoreEdge(newEdge, ...) In addition, set the score of the new edge. """ newEdge = PartialGridAlignment() newEdge.scoreVector_local = svector.Vector() newEdge.scoreVector = svector.Vector() for e in childEdges: newEdge.links += e.links newEdge.scoreVector_local += e.scoreVector_local newEdge.scoreVector += e.scoreVector if e.boundingBox is None: e.boundingBox = self.boundingBox(e.links) score, boundingBox = self.scoreEdge(newEdge, currentNode, span, childEdges) return newEdge, boundingBox
def createDummyEdge(self, childEdges, currentNode, dummyCurrentNode, span, hyperEdge, isLastMerge = True): newEdge = PartialGridAlignment() newEdge.decodingPath.data = dummyCurrentNode.data newEdge.decodingPath.isDummy = not isLastMerge newEdge.scoreVector_local = svector.Vector() newEdge.scoreVector = svector.Vector() newEdge.hyperEdgeScore = hyperEdge.score for index, e in enumerate(childEdges): if isLastMerge: newEdge.links += e.getDepthAddedLink() else: newEdge.links += e.links newEdge.scoreVector_local += e.scoreVector_local # TOP node does not have local hypothesis so there is only one childedge if currentNode.data["word_id"] != e.decodingPath.data["word_id"]: newEdge.decodingPath.addChild(e.decodingPath) e.decodingPath.parent = newEdge.decodingPath newEdge.scoreVector += e.scoreVector if e.boundingBox is None: e.boundingBox = self.boundingBox(e.links) score, boundingBox = self.scoreEdge(newEdge, currentNode, span, childEdges) return newEdge, boundingBox
def nonterminal_operation_cube(self, currentNode): # To speed up each epoch of training (but not necessarily convergence), # generate a single forest with model score as thz objective # Search through that forest for the oracle hypotheses, # e.g. hope (or fear) # Compute the span of currentNode # span is an ordered pair [i,j] where: # i = index of the first eword in span of currentNode # j = index of the last eword in span of currentNode currentNode.span = (currentNode.span_start(), currentNode.span_end()) ############################# Start of hypothesis calculation #################################### if self.BINARIZE: self.binarizeKbest(currentNode, "hyp") else: self.kbest(currentNode, "hyp") ############################# End of hypothesis calculation #################################### ############################# Start of oracle calculation("oracle" or "hope") ###################################### if self.COMPUTE_ORACLE: # Oracle BEFORE beam is applied. # Should just copy oracle up from terminal nodes. best = PartialGridAlignment() best.fscore = -1.0 # Any negative value suffices for hyperEdge in currentNode.hyperEdges: if self.BINARIZE: queue = Queue.Queue() for child in hyperEdge.tail: queue.put(child.oracle) if currentNode.oracle: # TOP node does not have local oracle queue.put(currentNode.oracle) while queue.qsize() >= 2: first = queue.get() second = queue.get() dummy = ForestNode(copy.deepcopy(currentNode.data)) if not queue.empty(): dummy.data["surface"] = "__DUMMY__" dummy.addHyperEdge(dummy, [first, second], hyperEdge.score) oracleAlignment, boundingBox = self.createDummyEdge([first,second], currentNode, dummy, currentNode.span, hyperEdge, queue.empty()) queue.put(oracleAlignment) oracleAlignment = queue.get() else: oracleChildEdges = [c.oracle for c in hyperEdge.tail] if currentNode.oracle: oracleChildEdges.append(currentNode.oracle) oracleAlignment, boundingBox = self.createEdge(oracleChildEdges, currentNode, currentNode.span, hyperEdge) if oracleAlignment.fscore > best.fscore: best = oracleAlignment currentNode.partialAlignments["oracle"] = currentNode.oracle = best # Oracle AFTER beam is applied. #oracleCandidates = list(currentNode.partialAlignments) #oracleCandidates.sort(key=attrgetter('fscore'),reverse=True) #oracleAlignment = oracleCandidates[0] # currentNode.oracle = oracleAlignment elif self.COMPUTE_HOPE: if self.BINARIZE: self.binarizeKbest(currentNode, "hyp") else: self.kbest(currentNode, "oracle")
def bottom_up_visit(self): """ Visit each node in the tree, bottom up, and in level-order. ########################################################### # bottom_up_visit(self): # traverse etree bottom-up, in level order # (1) Add terminal nodes to the visit queue # (2) As each node is visited, add its parent to the visit # queue if not already on the queue # (3) During each visit, perform the proper alignment function # depending on the type of node: 'terminal' or 'non-terminal' ########################################################### """ queue = [ ] if self.etree.data is None: empty = PartialGridAlignment() empty.score = None if self.etree.partialAlignments is not None: self.etree.partialAlignments.append(empty) else: self.etree.partialAlignments = [empty] self.etree.oracle = PartialGridAlignment() return # Add first-level nodes to the queue for terminal in self.etree.getTerminals(): queue.append(terminal) # Visit each node in the queue and put parent # in queue if not there already # Parent is there already if it is the last one in the queue while len(queue) > 0: currentNode = queue.pop(0) # Put parent in the queue if it is not there already # We are guaranteed to have visited all of a node's children before we visit that node if (currentNode.parent is not None) and (len(queue) == 0 or queue[-1] is not currentNode.parent()): if abs(currentNode.parent().depth() - currentNode.depth()) == 1: queue.append(currentNode.parent()) # Visit node here. # if currentNode.isTerminal(): # Is current node a preterminal? if len(currentNode.children[0].children) == 0: self.terminal_operation(currentNode.eIndex, currentNode) else: self.nonterminal_operation_cube(currentNode)
def bottom_up_visit(self): """ Visit each node in the tree, bottom up, and in level-order. ########################################################### # bottom_up_visit(self): # traverse etree bottom-up, in level order # (1) Add terminal nodes to the visit queue # (2) As each node is visited, add its parent to the visit # queue if not already on the queue # (3) During each visit, perform the proper alignment function # depending on the type of node: 'terminal' or 'non-terminal' ########################################################### """ queue = [ ] if self.etree is None: empty = PartialGridAlignment() empty.score = None self.etree.partialAlignments["hyp"].append(empty) self.etree.partialAlignments["oracle"] = PartialGridAlignment() return # Add first-level nodes to the queue # for terminal in sorted(list(self.etree.getTerminals()),key=lambda x: x.data["word_id"]): for terminal in self.etree.getTerminals(): queue.append(terminal) # Visit each node in the queue and put parent # in queue if not there already # Parent is there already if it is the last one in the queue while len(queue) > 0: currentNode = queue.pop(0) # Put parent in the queue if it is not there already # We are guaranteed to have visited all of a node's children before we visit that node for edgeToParent in currentNode.parent: edgeToParent["parent"].unprocessedChildNum -= 1 if edgeToParent["parent"].unprocessedChildNum == 0: queue.append(edgeToParent["parent"]) # Visit node here. if currentNode.data["pos"] != "TOP": self.terminal_operation(currentNode) if len(currentNode.hyperEdges) > 0: self.nonterminal_operation_cube(currentNode) return
def bottom_up_visit(self): """ Visit each node in the tree, bottom up, and in level-order. ########################################################### # bottom_up_visit(self): # traverse etree bottom-up, in level order # (1) Add terminal nodes to the visit queue # (2) As each node is visited, add its parent to the visit # queue if not already on the queue # (3) During each visit, perform the proper alignment function # depending on the type of node: 'terminal' or 'non-terminal' ########################################################### """ queue = [ ] if self.etree is None or self.etree.data is None: empty = PartialGridAlignment() empty.score = None self.etree.partialAlignments.append(empty) self.etree.oracle = PartialGridAlignment() return # print self.etree # Add first-level nodes to the queue for terminal in self.etree.getTreeTerminals(): queue.append(terminal) # Visit each node in the queue and put parent # in queue if not there already # Parent is there already if it is the last one in the queue while len(queue) > 0: currentNode = queue.pop(0) # Put parent in the queue if it is not there already # We are guaranteed to have visited all of a node's children before we visit that node if (currentNode.parent is not None) and (len(queue) == 0 or queue[-1] is not currentNode.parent()): if abs(currentNode.parent().depth() - currentNode.depth()) == 1: queue.append(currentNode.parent()) # Visit node here. # if currentNode.isTerminal(): # Is current node a preterminal? self.terminal_operation(currentNode) if len(currentNode.children) > 0: self.nonterminal_operation_cube(currentNode)
def createEdge(self, childEdges, currentNode, span): """ Create a new edge from the list of edges 'edge'. Creating an edge involves: (1) Initializing the PartialGridAlignment data structure (2) Adding links (f,e) to list newEdge.links (3) setting the score of the edge with scoreEdge(newEdge, ...) In addition, set the score of the new edge. """ newEdge = PartialGridAlignment() newEdge.scoreVector_local = svector.Vector() newEdge.scoreVector = svector.Vector() for e in childEdges: newEdge.links += e.links newEdge.scoreVector_local += e.scoreVector_local newEdge.scoreVector += e.scoreVector if e.boundingBox is None: e.boundingBox = self.boundingBox(e.links) score, boundingBox = self.scoreEdge(newEdge, currentNode, span, childEdges) return newEdge, boundingBox
def terminal_operation(self, index, currentNode = None): """ Fire features at (pre)terminal nodes of the tree. """ ################################################## # Setup ################################################## partialAlignments = [] partialAlignments_hope = [] partialAlignments_fear = [] oracleAlignment = None heapify(partialAlignments) tgtWordList = self.f srcWordList = self.e tgtWord = None srcWord = currentNode.children[0].data srcTag = currentNode.data tgtIndex = None srcIndex = currentNode.children[0].eIndex span = (srcIndex, srcIndex) ################################################## # null partial alignment ( assign no links ) ################################################## tgtIndex = -1 tgtWord = '*NULL*' scoreVector = svector.Vector() # Compute feature score for k, func in enumerate(self.featureTemplates): value_dict = func(self.info, tgtWord, srcWord, tgtIndex, srcIndex, [], self.diagValues, currentNode) for name, value in value_dict.iteritems(): if value != 0: scoreVector[name] += value nullPartialAlignment = PartialGridAlignment() nullPartialAlignment.score = score = scoreVector.dot(self.weights) nullPartialAlignment.scoreVector = scoreVector nullPartialAlignment.scoreVector_local = svector.Vector(scoreVector) self.addPartialAlignment(partialAlignments, nullPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_ORACLE or self.COMPUTE_FEAR: nullPartialAlignment.fscore = self.ff_fscore(nullPartialAlignment, span) if self.COMPUTE_ORACLE: oracleAlignment = nullPartialAlignment if self.COMPUTE_HOPE: nullPartialAlignment.hope = nullPartialAlignment.fscore + nullPartialAlignment.score self.addPartialAlignment_hope(partialAlignments_hope, nullPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_FEAR: nullPartialAlignment.fear = (1 - nullPartialAlignment.fscore) + nullPartialAlignment.score self.addPartialAlignment_fear(partialAlignments_fear, nullPartialAlignment, self.BEAM_SIZE) ################################################## # Single-link alignment ################################################## bestTgtWords = [] for tgtIndex, tgtWord in enumerate(tgtWordList): currentLinks = [(tgtIndex, srcIndex)] scoreVector = svector.Vector() for k, func in enumerate(self.featureTemplates): value_dict = func(self.info, tgtWord, srcWord, tgtIndex, srcIndex, currentLinks, self.diagValues, currentNode) for name, value in value_dict.iteritems(): if value != 0: scoreVector[name] += value # Keep track of scores for all 1-link partial alignments score = scoreVector.dot(self.weights) bestTgtWords.append((score, tgtIndex)) singleLinkPartialAlignment = PartialGridAlignment() singleLinkPartialAlignment.score = score singleLinkPartialAlignment.scoreVector = scoreVector singleLinkPartialAlignment.scoreVector_local = svector.Vector(scoreVector) singleLinkPartialAlignment.links = currentLinks self.addPartialAlignment(partialAlignments, singleLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_ORACLE or self.COMPUTE_FEAR: singleLinkPartialAlignment.fscore = self.ff_fscore(singleLinkPartialAlignment, span) if self.COMPUTE_ORACLE: if singleLinkPartialAlignment.fscore > oracleAlignment.fscore: oracleAlignment = singleLinkPartialAlignment if self.COMPUTE_HOPE: singleLinkPartialAlignment.hope = singleLinkPartialAlignment.fscore + singleLinkPartialAlignment.score self.addPartialAlignment_hope(partialAlignments_hope, singleLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_FEAR: singleLinkPartialAlignment.fear = (1-singleLinkPartialAlignment.fscore)+singleLinkPartialAlignment.score self.addPartialAlignment_fear(partialAlignments_fear, singleLinkPartialAlignment, self.BEAM_SIZE) ################################################## # Two link alignment ################################################## # Get ready for 2-link alignments # Sort the fwords by score bestTgtWords.sort(reverse=True) LIMIT = max(10, len(bestTgtWords)/2) for index1, obj1 in enumerate(bestTgtWords[0:LIMIT]): for _, obj2 in enumerate(bestTgtWords[index1+1:LIMIT]): # clear contents of twoLinkPartialAlignment tgtIndex_a = obj1[1] tgtIndex_b = obj2[1] # Don't consider a pair (tgtIndex_a, tgtIndex_b) if distance between # these indices > 1 (Arabic/English only). # Need to debug feature that is supposed to deal with this naturally. if self.LANG == "ar_en": if (abs(tgtIndex_b - tgtIndex_a) > 1): continue tgtWord_a = tgtWordList[tgtIndex_a] tgtWord_b = tgtWordList[tgtIndex_b] currentLinks = [(tgtIndex_a, srcIndex), (tgtIndex_b, srcIndex)] scoreVector = svector.Vector() for k, func in enumerate(self.featureTemplates): value_dict = func(self.info, tgtWord, srcWord, tgtIndex, srcIndex, currentLinks, self.diagValues, currentNode) for name, value in value_dict.iteritems(): if value != 0: scoreVector[name] += value score = scoreVector.dot(self.weights) twoLinkPartialAlignment = PartialGridAlignment() twoLinkPartialAlignment.score = score twoLinkPartialAlignment.scoreVector = scoreVector twoLinkPartialAlignment.scoreVector_local = svector.Vector(scoreVector) twoLinkPartialAlignment.links = currentLinks self.addPartialAlignment(partialAlignments, twoLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_ORACLE or self.COMPUTE_FEAR: twoLinkPartialAlignment.fscore = self.ff_fscore(twoLinkPartialAlignment, span) if self.COMPUTE_ORACLE: if twoLinkPartialAlignment.fscore > oracleAlignment.fscore: oracleAlignment = twoLinkPartialAlignment if self.COMPUTE_HOPE: twoLinkPartialAlignment.hope = twoLinkPartialAlignment.fscore + twoLinkPartialAlignment.score self.addPartialAlignment_hope(partialAlignments_hope, twoLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_FEAR: twoLinkPartialAlignment.fear = (1-twoLinkPartialAlignment.fscore)+twoLinkPartialAlignment.score self.addPartialAlignment_fear(partialAlignments_fear, twoLinkPartialAlignment, self.BEAM_SIZE) ######################################################################## # Finalize. Sort model-score list and then hope list. ######################################################################## # Sort model score list. sortedBestFirstPartialAlignments = [] while len(partialAlignments) > 0: sortedBestFirstPartialAlignments.insert(0,heappop(partialAlignments)) # Sort hope score list. if self.COMPUTE_HOPE: sortedBestFirstPartialAlignments_hope = [] while len(partialAlignments_hope) > 0: (_, obj) = heappop(partialAlignments_hope) sortedBestFirstPartialAlignments_hope.insert(0,obj) # Sort fear score list. if self.COMPUTE_FEAR: sortedBestFirstPartialAlignments_fear = [] while len(partialAlignments_fear) > 0: (_, obj) = heappop(partialAlignments_fear) sortedBestFirstPartialAlignments_fear.insert(0, obj) currentNode.partialAlignments = sortedBestFirstPartialAlignments if self.COMPUTE_FEAR: currentNode.partialAlignments_fear = sortedBestFirstPartialAlignments_fear if self.COMPUTE_HOPE: currentNode.partialAlignments_hope = sortedBestFirstPartialAlignments_hope if self.COMPUTE_ORACLE: currentNode.oracle = None # Oracle BEFORE beam is applied currentNode.oracle = oracleAlignment
def terminal_operation(self, currentNode = None): """ Fire features at (pre)terminal nodes of the tree. """ ################################################## # Setup ################################################## partialAlignments = [] partialAlignments_hope = [] partialAlignments_fear = [] oracleAlignment = None heapify(partialAlignments) tgtWordList = self.f srcWordList = self.e tgtWord = None srcWord = currentNode.data["surface"] srcTag = currentNode.data["pos"] tgtIndex = None srcIndex = currentNode.eIndex span = (srcIndex, srcIndex) ################################################## # null partial alignment ( assign no links ) ################################################## tgtIndex = -1 tgtWord = '*NULL*' scoreVector = svector.Vector() # Compute feature score for k, func in enumerate(self.featureTemplates): value_dict = func(self.info, tgtWord, srcWord, tgtIndex, srcIndex, [], self.diagValues, currentNode) for name, value in value_dict.iteritems(): if value != 0: scoreVector[name] += value nullPartialAlignment = PartialGridAlignment() nullPartialAlignment.score = score = scoreVector.dot(self.weights) nullPartialAlignment.scoreVector = scoreVector nullPartialAlignment.scoreVector_local = svector.Vector(scoreVector) self.addPartialAlignment(partialAlignments, nullPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_ORACLE or self.COMPUTE_FEAR: nullPartialAlignment.fscore = self.ff_fscore(nullPartialAlignment, span) if self.COMPUTE_ORACLE: oracleAlignment = nullPartialAlignment if self.COMPUTE_HOPE: nullPartialAlignment.hope = nullPartialAlignment.fscore + nullPartialAlignment.score self.addPartialAlignment_hope(partialAlignments_hope, nullPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_FEAR: nullPartialAlignment.fear = (1 - nullPartialAlignment.fscore) + nullPartialAlignment.score self.addPartialAlignment_fear(partialAlignments_fear, nullPartialAlignment, self.BEAM_SIZE) ################################################## # Single-link alignment ################################################## singleBestAlignment = [] alignmentList = [] for tgtIndex, tgtWord in enumerate(tgtWordList): currentLinks = [(tgtIndex, srcIndex)] scoreVector = svector.Vector() for k, func in enumerate(self.featureTemplates): value_dict = func(self.info, tgtWord, srcWord, tgtIndex, srcIndex, currentLinks, self.diagValues, currentNode) for name, value in value_dict.iteritems(): if value != 0: scoreVector[name] += value # Keep track of scores for all 1-link partial alignments score = scoreVector.dot(self.weights) singleBestAlignment.append((score, [tgtIndex])) singleLinkPartialAlignment = PartialGridAlignment() singleLinkPartialAlignment.score = score singleLinkPartialAlignment.scoreVector = scoreVector singleLinkPartialAlignment.scoreVector_local = svector.Vector(scoreVector) singleLinkPartialAlignment.links = currentLinks self.addPartialAlignment(partialAlignments, singleLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_ORACLE or self.COMPUTE_FEAR: singleLinkPartialAlignment.fscore = self.ff_fscore(singleLinkPartialAlignment, span) if self.COMPUTE_ORACLE: if singleLinkPartialAlignment.fscore > oracleAlignment.fscore: oracleAlignment = singleLinkPartialAlignment if self.COMPUTE_HOPE: singleLinkPartialAlignment.hope = singleLinkPartialAlignment.fscore + singleLinkPartialAlignment.score self.addPartialAlignment_hope(partialAlignments_hope, singleLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_FEAR: singleLinkPartialAlignment.fear = (1-singleLinkPartialAlignment.fscore)+singleLinkPartialAlignment.score self.addPartialAlignment_fear(partialAlignments_fear, singleLinkPartialAlignment, self.BEAM_SIZE) alignmentList = singleBestAlignment singleBestAlignment.sort(reverse=True) ################################################## # N link alignment(N>=2) ################################################## # Get ready for N-link alignments(N>=2) for i in xrange(2,self.nto1+1): # Sort the fwords by score alignmentList.sort(reverse=True) newAlignmentList = [] LIMIT_1 = max(10, self.lenF/2) LIMIT_N = max(10, self.lenF/i) for (_,na) in alignmentList[0:LIMIT_N]:# na means n link alignment for (_, sa) in singleBestAlignment[0:LIMIT_1]:#sa means single-link alignment if(na[-1]>=sa[0]):#sa actually always have only one element continue # clear contents of twoLinkPartialAlignment tgtIndex_a = na[-1] tgtIndex_b = sa[0] # Don't consider a pair (tgtIndex_a, tgtIndex_b) if distance between # these indices > 1 (Arabic/English only). # Need to debug feature that is supposed to deal with this naturally. if self.LANG == "ar_en": if (abs(tgtIndex_b - tgtIndex_a) > 1): continue currentLinks = list(map(lambda x: (x,srcIndex),na+sa)) scoreVector = svector.Vector() for k, func in enumerate(self.featureTemplates): value_dict = func(self.info, tgtWord, srcWord, tgtIndex, srcIndex, currentLinks, self.diagValues, currentNode) for name, value in value_dict.iteritems(): if value != 0: scoreVector[name] += value score = scoreVector.dot(self.weights) newAlignmentList.append((score, na+sa)) NLinkPartialAlignment = PartialGridAlignment() NLinkPartialAlignment.score = score NLinkPartialAlignment.scoreVector = scoreVector NLinkPartialAlignment.scoreVector_local = svector.Vector(scoreVector) NLinkPartialAlignment.links = currentLinks self.addPartialAlignment(partialAlignments, NLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_ORACLE or self.COMPUTE_FEAR: NLinkPartialAlignment.fscore = self.ff_fscore(NLinkPartialAlignment, span) if self.COMPUTE_ORACLE: if NLinkPartialAlignment.fscore > oracleAlignment.fscore: oracleAlignment = NLinkPartialAlignment if self.COMPUTE_HOPE: NLinkPartialAlignment.hope = NLinkPartialAlignment.fscore + NLinkPartialAlignment.score self.addPartialAlignment_hope(partialAlignments_hope, NLinkPartialAlignment, self.BEAM_SIZE) if self.COMPUTE_FEAR: NLinkPartialAlignment.fear = (1-NLinkPartialAlignment.fscore)+NLinkPartialAlignment.score self.addPartialAlignment_fear(partialAlignments_fear, NLinkPartialAlignment, self.BEAM_SIZE) alignmentList = newAlignmentList ######################################################################## # Finalize. Sort model-score list and then hope list. ######################################################################## # Sort model score list. sortedBestFirstPartialAlignments = [] while len(partialAlignments) > 0: sortedBestFirstPartialAlignments.insert(0,heappop(partialAlignments)) # Sort hope score list. if self.COMPUTE_HOPE: sortedBestFirstPartialAlignments_hope = [] while len(partialAlignments_hope) > 0: (_, obj) = heappop(partialAlignments_hope) sortedBestFirstPartialAlignments_hope.insert(0,obj) # Sort fear score list. if self.COMPUTE_FEAR: sortedBestFirstPartialAlignments_fear = [] while len(partialAlignments_fear) > 0: (_, obj) = heappop(partialAlignments_fear) sortedBestFirstPartialAlignments_fear.insert(0, obj) currentNode.partialAlignments = sortedBestFirstPartialAlignments if self.COMPUTE_FEAR: currentNode.partialAlignments_fear = sortedBestFirstPartialAlignments_fear if self.COMPUTE_HOPE: currentNode.partialAlignments_hope = sortedBestFirstPartialAlignments_hope if self.COMPUTE_ORACLE: currentNode.oracle = None # Oracle BEFORE beam is applied currentNode.oracle = oracleAlignment