xmlutil.py

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

    def buildAlphabets(self, nrOfSymbols):
	""" Only fixed to 5 symbols for the moment """ 
	alphas = range(1, nrOfSymbols+1)
	alphas = map( lambda x: 'a'+ str(x), alphas)
	for code in range(1,nrOfSymbols+1):
	    self.addCode( code, alphas[code-1], desc = None)
 


class HMMClass(DOM_Map):
    def __init__(self):
        DOM_Map.__init__(self)
        self.code2name = {-1:'None'}
        self.name2code = {'None':-1}
        self.maxCode = 0
    
    def fromDOM(self, XMLNode):
        """Take dom subtree representing a <hmm:class></hmm:class> element"""
        self.initialize()
        self.symbolsFromDom(XMLNode)
        # copy self.name to self.code2name
        for key in self.name.keys():            
            self.code2name[key] = self.name[key]
        
    def toDOM(self, XMLDoc, XMLNode):        
        hmmclass = XMLDoc.createElement("hmm:class")   
        DOM_Map.toDOM(self, XMLDoc, hmmclass)
        XMLNode.appendChild(hmmclass)

    def size(self):
        return len(self.name.keys())

            
class HMMState:

    def __init__(self, nodeIndex, itsHMM):

        self.initial  = Probability("0.0")
        self.label    = ValidatingString("None")
        self.itsHMM   = itsHMM
	# print type(self.label)
	
        self.index = nodeIndex # The node index in the underlying graph
        self.id    = DefaultedInt() # identification by the canvas, not always the same
        self.state_class = PopupableInt(-1)
        self.state_class.setPopup(itsHMM.hmmClass.code2name, itsHMM.hmmClass.name2code, 10)
        # XXX self.state_class.setPopup(itsHMM.hmmClass.name, itsHMM.hmmClass.name2code, 10)

	self.order = DefaultedInt()
        self.order.setDefault(1, 0) # the default state order is 0

        self.emissions = []

        self.tiedto = DefaultedString()
        self.tiedto.setDefault(1, '')
        self.desc = self.id

        self.reading_frame = PopupableInt(-1)
        code2name = {-1:'None', 0:'0', 1:'1', 2:'2'}
        name2code = {'None':-1, '0':0, '1':1, '2':2}
        self.reading_frame.setPopup(code2name, name2code, 4)

        self.duration = DefaultedInt()
        self.duration.setDefault(1, 0)

        self.background = PopupableInt(-1)
        self.background.setPopup(self.itsHMM.backgroundDistributions.code2name, self.itsHMM.backgroundDistributions.name2code, 10)

        self.editableAttr = ['label', 'state_class', 'initial', 'order', 'background', 'offsetX', 'offsetY', 'alphabet_id']
        self.xmlAttr = self.editableAttr + ['ngeom', 'emissions']
        # pair HMM stuff
        self.alphabet_id = ValidatingInt(0)
        self.offsetX = ValidatingInt(1)
        self.offsetY = ValidatingInt(0)
        self.kclasses = ValidatingInt(1)
        self.transitionFunction = ValidatingInt(-1)
        
    editableAttr = ['label', 'state_class', 'initial', 'order', 'background', 'offsetX', 'offsetY', 'alphabet_id']
    xmlAttr = editableAttr + ['ngeom', 'emissions']
    
    # ['id', 'state_class', 'label', 'order', 'initial', 'tiedto', 'reading_frame', 'duration', 'background']

    #
    # Set_<Attribute> Methods: for integration with class editobj.Editor.set_value()
    # the name of the method must be in the form of set_<attr name>(self,value).
    # Otherwise, EditObj cannot propogate new values. (See the base method editobj.EntryEditor.set_value())
    # When necessary, we also update the Graph here.
    #
    def set_label(self, value):
        # Get the id2index from the Graph
        oldv = self.itsHMM.id2index[self.id]
        self.label = typed_assign(self.label, value)
        
        # We only show the label out of the editable items
        self.itsHMM.G.labeling[oldv] = "%s\n%s" % (self.id, self.label) # XXX Hack Aaaargh!
        self.itsHMM.itsEditor.UpdateVertexLabel(oldv, 0)


    def set_initial(self, value):
        self.initial = typed_assign(self.initial, value)

    def set_offsetX(self, value):
        self.offsetX = typed_assign(self.offsetX, value)

    def set_offsetY(self, value):
        self.offsetY = typed_assign(self.offsetY, value)

    def set_alphabet_id(self, value):
        self.alphabet_id = typed_assign(self.alphabet_id, value)

    def fromDOM(self, XMLNode):
        
        self.id = typed_assign(self.id, int(XMLNode.attributes['id'].nodeValue)) # state's id
        
        self.index = self.itsHMM.G.AddVertex()
        
        datas = XMLNode.getElementsByTagName("data")
        for data in datas:
            dataKey = data.attributes['key'].nodeValue
            dataValue = data.firstChild.nodeValue

            #print dataValue
            
            #  if dataValue == None: # use default Value
            #     self.state_class = typed_assign(self.state_class, int(0))
            #  else:
            #      self.state_class = typed_assign(self.state_class, int(dataValue))

            if dataKey == 'class':
                self.state_class = typed_assign(self.state_class, int(dataValue))
                    
            elif  dataKey == 'label':
                self.label = type(self.label)(dataValue.encode('ascii', 'replace'))

            elif  dataKey == 'order':
                if dataValue == None: # use default value
                    self.order = typed_assign(self.order, self.order.defaultValue)
                    self.order.useDefault = 1
                else:
                    self.order = typed_assign(self.order, int(dataValue))
                    self.order.useDefault = 0

            elif  dataKey == 'initial':
                self.initial = typed_assign(self.initial, float(dataValue))
                
            elif  dataKey == 'tiedto':
                
                if dataValue == None: # use default value
                    self.tiedto = typed_assign(self.tiedto, self.tiedto.defaultValue)
                    self.tiedto.useDefault = 1
                else:
                    self.tiedto = typed_assign(self.tiedto, dataValue.encode('ascii', 'replace'))
                    self.tiedto.useDefault = 0

            elif dataKey == 'reading-frame':
                self.reading_frame = typed_assign(self.reading_frame, int(dataValue))

            elif dataKey == 'background':
                self.background = typed_assign(self.background, self.itsHMM.backgroundDistributions.name2code[dataValue])

            elif dataKey == 'duration':
                self.duration = typed_assign(self.duration, int(dataValue))
                self.duration.useDefault = 0
                                    
            elif dataKey == 'ngeom':
                # We only use pos
                pos = XMLNode.getElementsByTagName('pos')[0] # Just one pos ...                
                self.pos = Point2D(float(pos.attributes['x'].nodeValue),
                                   float(pos.attributes['y'].nodeValue))
                
            elif dataKey == 'emissions':
                # collect all strings from childnodes
                dataValue = ""
                for child in data.childNodes:
                    dataValue += child.nodeValue
                self.emissions = listFromCSV(dataValue, types.FloatType)
                #print self.emissions

            elif dataKey == 'alphabet_id':
                self.alphabet_id = ValidatingInt(dataValue)

            elif dataKey == 'offset_x':
                self.offsetX = ValidatingInt(dataValue)

            elif dataKey == 'offset_y':
                self.offsetY = ValidatingInt(dataValue)

            elif dataKey == 'kclasses':
                self.kclasses = ValidatingInt(dataValue)

            elif dataKey == 'transitionfunction':
                self.transitionFunction = ValidatingInt(dataValue)
                    
            else:
                print "HMMState.fromDOM: unknown key %s of value %s" % (dataKey, dataValue)
        

    def toDOM(self, XMLDoc, XMLNode, initial_sum):
        node = XMLDoc.createElement("node")
        node.setAttribute('id', "%s" % self.id)

        # Mandatory elems
        writeData(XMLDoc, node, 'label', self.label)
        writeData(XMLDoc, node, 'class', self.state_class)
        writeData(XMLDoc, node, 'initial', self.initial / initial_sum)

        pos_elem = XMLDoc.createElement("pos")
        try:
            pos = self.itsHMM.G.embedding[self.index] 
            pos_elem.setAttribute('x', "%s" % pos.x)
            pos_elem.setAttribute('y', "%s" % pos.y)
            writeXMLData(XMLDoc, node, 'ngeom', pos_elem)
        except:
            pos_elem.setAttribute('x', "%s" % 100)
            pos_elem.setAttribute('y', "%s" % 50)
            writeXMLData(XMLDoc, node, 'ngeom', pos_elem)

        writeData(XMLDoc, node, 'offset_x', self.offsetX)

        writeData(XMLDoc, node, 'offset_y', self.offsetY)

        writeData(XMLDoc, node, 'alphabet_id', self.alphabet_id)

        writeData(XMLDoc, node, 'kclasses', self.kclasses)

        writeData(XMLDoc, node, 'transitionfunction', self.transitionFunction)
            
        if not self.order.useDefault:
            writeData(XMLDoc, node, 'order', self.order)

        if self.reading_frame != -1:
            writeData(XMLDoc, node, 'reading-frame', self.reading_frame)

        if self.background != -1:
            writeData(XMLDoc, node, 'background', self.itsHMM.backgroundDistributions.code2name[self.background])

        if not self.duration.useDefault:
            writeData(XMLDoc, node, 'duration', self.duration)
           
        if not self.tiedto == '':
            writeData(XMLDoc, node, 'tiedto', self.tiedto)
            self.emissions = self.itsHMM.state[self.itsHMM.id2index[int(self.tiedto)]].emissions # XXX            

        if self.order.useDefault:
            order = 0
        else:
            order = self.order

        # XXX Produce uniform emission probs, if we dont have the correct number of
        # parameters
            
        size = self.itsHMM.hmmAlphabets[self.alphabet_id].size()**(order+1)
        if (self.itsHMM.modelType == "pairHMM"):
            if (self.offsetX != 0 and self.offsetY != 0):
                size = size**2
        if len(self.emissions) != size:
            print "in state %s len(emissions) = %i size should be %i" % (self.id, len(self.emissions), size)
            tmp = [1.0/self.itsHMM.hmmAlphabets[self.alphabet_id].size()] * self.itsHMM.hmmAlphabet.size()
            if order == 0:
                self.emissions = tmp
            else:
                self.emissions = tmp * self.itsHMM.hmmAlphabets[self.alphabet_id].size()**order
                    
                
        if order > 0:
            writeData(XMLDoc, node, 'emissions', csvFromList(self.emissions,
                                                             self.itsHMM.hmmAlphabets[self.alphabet_id].size()))
        else:
            writeData(XMLDoc, node, 'emissions', csvFromList(self.emissions))
            
        XMLNode.appendChild(node)

    def toGHMM(self, XMLDoc, XMLNode, initial_sum):
        node = XMLDoc.createElement("state")
        node.setAttribute('id', "%s" % self.id)

        writeXMLTextNode(XMLDoc, node, 'initial', self.initial / initial_sum)
        # ignore order
        writeXMLTextNode(XMLDoc, node, 'emission', string.join(map(str,self.emissions),'\n'))
        XMLNode.appendChild(node)
        

    def fromDiscreteState( self, id, pi, B, label, order, tiedto=None, background=False ):
        """ Convert from ghmm.DiscreteEmissionHMM to the member attributes
        """
        self.id = id
        self.index = self.itsHMM.G.AddVertex()
        self.initial = typed_assign(self.initial, float(pi))
        self.label   = type(self.label)(label)	
	self.order = DefaultedInt(order)

        self.order = typed_assign(self.order, int(order))
        self.order.useDefault = 0
        self.emissions = B

        if tiedto is None:
            self.tiedto.useDefault = 1
        else:
            self.tiedto = typed_assign(self.tiedto, tiedto)
            self.tiedto.useDefault = 0

        if background is True:
            self.background = PopupableInt(-1)
            self.background.setPopup(self.itsHMM.backgroundDistributions.code2name, self.itsHMM.backgroundDistributions.name2code, 10)


class HMM:    
    def __init__(self, XMLFileName = None, G = None):
        # self.itsEditor = itsEditor
        if ( G is None ):
            self.G = Graph()
        else:
            self.G = G

        self.G.directed = 1
        self.G.euclidian = 0
        self.G.simple = 0
        self.Pi = {}
        self.id2index = {}
            
        # self.hmmAlphabet = DiscreteHMMAlphabet()
        self.hmmClass    = HMMClass()

        # in the case of pair HMMs we have several
        self.hmmAlphabets = {}
        self.transitionFunctions = {}
        
        self.editableAttr = {}
        self.editableAttr['HMM'] = ['desc']
        self.desc = ValidatingString()       

        self.state = {}

        self.modelType = 0
        self.name = "NoName"
        
        self.backgroundDistributions = NamedDistributions(self)

        self.DocumentName = "graphml"
        if XMLFileName != None:
            self.OpenXML(XMLFileName)

    def Clear(self):
        self.G.Clear()
        self.Pi = {}
        self.id2index = {}
            
        # self.hmmAlphabet = DiscreteHMMAlphabet()
        self.hmmAlphabets = {}
        self.hmmClass    = HMMClass()
        self.backgroundDistributions = NamedDistributions(self)
        
        self.editableAttr = {}
        self.editableAttr['HMM'] = ['desc']
        self.desc = ValidatingString()       
        self.state = {}
        self.DocumentName = "graphml"  

    def AddState(self, index, label='None'):
        state = HMMState(-1, self)
        if self.id2index.keys() != []:
            state.id = max(self.id2index.keys()) + 1
        else:
            state.id = 1
        state.index = index
        self.id2index[state.id] = state.index
        self.state[state.index] = state # XXX Use canvas id
        state.label = typed_assign(state.label, state.id)
        self.G.labeling[state.index] = "%s" % (state.label)
        return state.index
        
    def DeleteState(self, index):
	""" The method only deletes a map between index and its state object.
	    The caller must delete the corresponding vertex in the owner Graph self.G. """