hmmed.py

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

    # Menu Commands
    #
    # The menu commands are passed as call back parameters to 
    # the menu items.
    #
    def NewGraph(self, nrOfSymbols=0, newInput=1):

        self.DeleteDrawItems() # clear screen
	if self.hasGraph == 1:
            self.G.Clear()
	    self.HMM.G.Clear()
	    self.hasGraph = 0
            
	self.HMM = HMM(self, self.G)

	self.graphName = "New"
	self.ShowGraph(self.HMM.G,self.graphName)
	self.RegisterGraphInformer(HMMInformer(self.HMM))
	self.fileName = None
	self.SetTitle("HMMEd _VERSION_ - New Graph")
	self.SetGraphMenuOptions()
        if newInput:
            if nrOfSymbols == 0:
                nrOfSymbols  = tkSimpleDialog.askinteger("New HMM","Enter the number of output symbols")
                for i in xrange(nrOfSymbols):
                    self.HMM.G.vertexWeights[i] = VertexWeight(0.0)

                self.HMM.hmmAlphabet = DiscreteHMMAlphabet(nrOfSymbols)
		
    def OpenGraph(self):

        self.DeleteDrawItems() # clear screen
	if self.hasGraph == 1:
            self.G.Clear()
	    self.HMM.G.Clear()
            self.HMM.Clear()
	    self.hasGraph = 0
	            
	file = askopenfilename(title="Open HMM",
			       defaultextension=".xml",
			       filetypes = (("XML", ".xml"),)
			       )
	if file is "": 
	    print "cancelled"
	else:
	    self.fileName = file
	    self.graphName = stripPath(file)
	    e = extension(file)
            
	    if e == 'xml':
		self.HMM.OpenXML(file)
	    else:
		print "Unknown extension"
		return

            #self.HMM.hmmAlphabet ?
            #self.HMM.hmmClass    ?
            
	    self.ShowGraph(self.HMM.G, self.graphName)
	    self.RegisterGraphInformer(HMMInformer(self.HMM))
	    self.SetTitle("HMMEd _VERSION_ - " + self.graphName)

	    if not self.gridding:
		self.graphMenu.invoke(self.graphMenu.index('Grid'))	
                

    def SaveGraph(self):
	if self.fileName != None:
	    self.HMM.SaveAs(self.fileName)
	else:
	    self.SaveAsGraph()
	

    def SaveAsGraph(self):
	file = asksaveasfilename(title="Save HMM",
				 defaultextension=".xml",
				 filetypes = ( ("XML", ".xml"), ("GHMM", ".ghmm"), )
                                 )
	if file is "": 
	    print "cancelled"
	else:
            print file
            ext = string.lower(os.path.splitext(file)[1])
            if ext == '.xml':
                self.fileName = file
                self.HMM.SaveAs(file)
                self.graphName = stripPath(file)
                self.SetTitle("HMMEd _VERSION_ - " + self.graphName)
            else:
                self.fileName = file
                self.HMM.SaveAsGHMM(file)
                self.graphName = stripPath(file)
                self.SetTitle("HMMEd _VERSION_ - " + self.graphName)
                

    def EditWeightUp(self,event):
        """ Need to have editors multiple sets of transition probability """
	if event.widget.find_withtag(CURRENT):
	    widget = event.widget.find_withtag(CURRENT)[0]
	    tags = self.canvas.gettags(widget)
	    if "edges" in tags:
 		(tail,head) = self.edge[widget]

                transition_probabilities=ProbEditorBasics.ProbDict({})
		for head in self.HMM.G.OutNeighbors(tail):
		    weight=self.HMM.G.edgeWeights[0][(tail,head)]
		    label = "-> %d" % head
                    transition_probabilities.update({label:weight})

                if transition_probabilities.sum==0:
                    key_list=transition_probabilities.keys()
                    for key in key_list:
                        transition_probabilities[key]=1.0/len(key_list)
                e=ProbEditorBasics.emission_data(transition_probabilities)
                d=ProbEditorDialogs.emission_dialog(self,
                                                    e,
                                                    "transition probs from state %d" % tail)
                if d.success():
                    # write back normalized probabilities
                    for key in transition_probabilities.keys():
                        head = int(key[3:])
                        self.HMM.G.edgeWeights[0][(tail,head)]=transition_probabilities[key]/transition_probabilities.sum

	    else:
                # We have a vertex
		v = self.FindVertex(event)
		if v != None:
                    state = self.HMM.state[v]
                    if state.order > 0:
                        print "Ooops. Cant edit higher order states"
                        return
                    
                    if state.tiedto != '':
                        msg = "The emission parameters of state %s you attempted to edit are tied to those of state %s." %  (state.id, state.tiedto)
                        #print "Note:", msg
                        if not askokcancel("Edit Tied State", msg + "Edit those of state %s instead?" % state.tiedto):
                            return
                        else:
                            state = self.HMM.state[state.tiedto]

                    if state.emissions == []:
                        state.emissions = [1.0 / self.HMM.hmmAlphabet.size()] * self.HMM.hmmAlphabet.size()
                    emission_probabilities = ProbEditorBasics.ProbDict({})

                    for code in self.HMM.hmmAlphabet.name.keys():
                        label = self.HMM.hmmAlphabet.name[code]
                        weight = state.emissions[code] 
                        emission_probabilities.update({label:weight})
                        
                    # Normalize ... should be member function
                    if abs(emission_probabilities.sum - 1.0) > 0.01:
                        key_list = emission_probabilities.keys()
                        for key in key_list:
                            emission_probabilities[key] = 1.0 / len(key_list)

                            
                    e = ProbEditorBasics.emission_data(emission_probabilities)
                    d = ProbEditorDialogs.emission_dialog(self, e, "emission probs of state %s" % state.id)
                    if d.success():
                        # write back normalized probabilities
                        for key in emission_probabilities.keys():
                            code = self.HMM.hmmAlphabet.name2code[key]
                            state.emissions[code] = emission_probabilities[key] / emission_probabilities.sum	

    def EditHMMObj(self, event):
        # register values
        editor.register_attr("itsEditor", None)
 	editor.register_attr("G", None)
	editor.register_attr("Pi", None)
        editor.register_attr("id2index", None)

        editor.register_attr("hmmAlphabet", None)
        editor.register_attr("hmmClass", None)
        
        editor.register_attr("editableAttr", None)


        editor.register_attr("backgroundDistributions", None)

                        
        editor.register_attr("state", editor.EntryEditor)
                
        # Edit this State with editobj widget  
        editobj.edit(self.HMM)
        
        
    def EditStateUp(self,event):
        print 'Calling EditObj'
	if event.widget.find_withtag(CURRENT):
	    widget = event.widget.find_withtag(CURRENT)[0]
	    tags = self.canvas.gettags(widget)
	    if not "edges" in tags:
		v = self.FindVertex(event)
                # print "Found Vertex " + "%s" % v
                # hidden attributes set to None
                editor.register_attr("state_class", None)
                editor.register_attr("emissions", None) # hidden
                editor.register_attr("itsHMM", None)
                editor.register_attr("desc", None)
                editor.register_attr("index", None)
                editor.register_attr("pos", None)
                editor.register_attr("id", None)
                editor.register_attr("order", None)
                editor.register_attr("tiedto", None)
                editor.register_attr("reading_frame", None)
                editor.register_attr("duration", None)
                editor.register_attr("background", None)
                
                # register values
                editor.register_attr("label", ValidStringEditor)
                
                # Edit this State with editobj widget  
                editobj.edit(self.HMM.state[v])


    def EditPropertiesUp(self,event):
	if event.widget.find_withtag(CURRENT):
	    widget = event.widget.find_withtag(CURRENT)[0]
	    tags = self.canvas.gettags(widget)
	    if not "edges" in tags:
		v = self.FindVertex(event)
                # print "Found Vertex " + "%s" % v

                #XXX if self.HMM.state[v].state_class != -1: # we have attribute state_class
                #d = EditObjectAttributesDialog(self, self.HMM.state[v], HMMState.editableAttr + ['state_class'])
                #else:
                d = EditObjectAttributesDialog(self, self.HMM.state[v], HMMState.editableAttr + ['state_class'])
                    
                # We only show the label out of the editable items
                self.HMM.G.labeling[v] = ValidatingString("%s" % (self.HMM.state[v].label)) # XXX Hack Aaaargh!
                self.UpdateVertexLabel(v, 0)
                # self.HMM.id2index[self.HMM.state[v].id] = v
                
                
    def EditHMM(self):
        d = EditObjectAttributesDialog(self, self.HMM, self.HMM.editableAttr['HMM'])

    def EditClassLabel(self):
        self.HMM.hmmClass.edit(self)

    def EditAlphabet(self):
        self.HMM.hmmAlphabet.edit(self)
        
    def EditPrior(self):
	if self.HMM.G.Order() == 0:
	    return

        key2id = {}
        emission_probabilities = ProbEditorBasics.ProbDict({})
        for state in self.HMM.state.values():
            label  = state.id
            weight = state.initial
            emission_probabilities.update({str(label):weight})
            key2id[str(label)] = state.id
            
        u = 1.0 / len(emission_probabilities.keys())
        if emission_probabilities.sum == 0.0:
            for key in emission_probabilities.keys():
                id = key2id[key]
                state = self.HMM.state[self.HMM.id2index[id]]
                state.initial = typed_assign(state.initial, u)
                emission_probabilities[key] = u

        if len(emission_probabilities.keys()) > 15:
            color_list=['red','green','yellow','blue','black',
                        'grey','orange','pink','gold','brown',
                        'tan','purple','magenta','firebrick','deeppink',
                        'lavender','NavajoWhite','seagreen','violet','LightGreen']
            colors = color_list
            repeats = len(emission_probabilities.keys()) / 15
            for i in range(repeats-1):
                color_list += colors

            e = ProbEditorBasics.emission_data(emission_probabilities, color_list)
        else:
            e = ProbEditorBasics.emission_data(emission_probabilities)        
        d = ProbEditorDialogs.emission_dialog(self, e, "initial probabilities")
        
        if d.success():
            # write back normalized probabilities
            for key in emission_probabilities.keys():
                id = key2id[key]
                state = self.HMM.state[self.HMM.id2index[id]]
                if emission_probabilities.sum == 0.0:
                    state.initial = typed_assign(state.initial, u)
                else:
                    state.initial = typed_assign(state.initial,
                                                 emission_probabilities[key] / emission_probabilities.sum)
    def EditBackgroundDistributions(self):
        self.HMM.backgroundDistributions.editDistributions(self)
    
    def AddVertexCanvas(self,x,y):
	v = GraphDisplay.AddVertexCanvas(self, x, y)
        print "AddVertex ", v, "at ", x, y
        index = self.HMM.AddState(v) # return index to this state
	state = self.HMM.state[index]
	self.HMM.G.embedding[state.index] = self.G.embedding[v]
        
    def MoveVertex(self,v,x,y,doUpdate=None):
	GraphDisplay.MoveVertex(self, v,x,y,doUpdate)
	state = self.HMM.state[v] # transfer the coordinate
	self.HMM.G.embedding[state.index] = self.G.embedding[v]

    def AddEdge(self,tail,head):
        GraphDisplay.AddEdge(self,tail,head)
        self.HMM.G.edgeWeights[0][(tail, head)] = 1.0
	
    def DeleteVertex(self,v):
        self.HMM.DeleteState(v)
        SAGraphEditor.DeleteVertex(self,v)

    def ShowCoords(self,event):
        pass

    
class HMMInformer(GraphInformer):
    def __init__(self, itsHMM):
        GraphInformer.__init__(self, itsHMM.G)
        self.itsHMM = itsHMM

    def VertexInfo(self,v):
	""" v is the vertex id on the canvas,
            mapping to internal representation must be done from v->index
        """
	state = self.itsHMM.state[v]
	try:
	    self.itsHMM.hmmClass.name[state.state_class]
	    msg = "State '%s' class=%s (%s:%s) order=%d" % (state.id, state.state_class,
							    self.itsHMM.hmmClass.name[state.state_class],
							    self.itsHMM.hmmClass.desc[state.state_class],
							    state.order)
	except:
	    msg = "State '%s' class=%s" % (state.id, state.state_class)
							    
        if state.order == 0 and state.emissions != []:
            emsg = ""
            for e in state.emissions:
                emsg += " %0.3f " % e
            msg += ":[ %s ]" % emsg
        return msg
    

    def EdgeInfo(self,tail,head):
        """ Display a list of transition probabilities for this edge
            (We only draw the edge once, not as many as a number of classes)
        """
	
        tail_state = self.itsHMM.state[tail]
        head_state = self.itsHMM.state[head]
        # p = self.itsHMM.G.edgeWeights[0][(tail, head)]
        transitions  = []
	if self.itsHMM.hmmClass.size > 1:
            
	    nr_classes = int(self.itsHMM.hmmClass.high())-int(self.itsHMM.hmmClass.low())+1
	    for cl in range(nr_classes):
                if self.itsHMM.G.edgeWeights.has_key(cl):
                    if self.itsHMM.G.edgeWeights[cl].has_key( (tail,head) ):
                        transitions.append(self.itsHMM.G.edgeWeights[cl][(tail,head)])
                    else:
                        transitions.append(0.0)
                else:
                    transitions.append(0.0)

	    plist = csvFromList( transitions )
	    msg = "Transition: '%s' -> '%s'(%2d):" % (tail_state.id, head_state.id, nr_classes)
	    msg = msg + plist
	else:
	    msg = "Transition: '%s' -> '%s'" % (tail_state.id, head_state.id)
        return msg
       
        
    
        
################################################################################
if __name__ == '__main__':
    
    # Make HMM available in the EditObj evaluation environment
    editobj.EVAL_ENV["HMM"] = HMM
    editobj.EVAL_ENV["HMMState"] = HMMState
    graphEditor = HMMEditor(Tk())
    graphEditor.NewGraph(2)
    graphEditor.mainloop()