ghmmunittests.py

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

                                        + ", value: " + str(alpha[i][j]) )
                else:
                    self.assertEqual(alpha[i][j], 0.0, "Zeichen: " + str(i) + ", State: " + str(j)
                                        + ", value: " + str(alpha[i][j]))


    def testkbest(self): 
        seq = ghmm.EmissionSequence(self.model.emissionDomain,
                                    ['a','c','g','t','t','a','a','a','c','g',
                                     't','g','a','c','g','c','a','t','t','t'],
                                    self.model.labelDomain,
                                    ['fst', 'scd', 'thr', 'thr', 'thr', 'thr', 'scd',
                                     'scd', 'thr', 'thr', 'scd', 'thr', 'scd', 'thr',
                                     'thr', 'thr', 'scd', 'fst', 'scd', 'fst'])


        path = self.model.kbest(seq)
        self.assertEqual(path,(['fst', 'thr', 'thr', 'scd', 'fst', 'scd', 'fst', 'scd',
                                'thr', 'thr', 'fst', 'thr', 'thr', 'thr', 'thr', 'thr',
                                'scd', 'fst', 'scd', 'fst'], -35.735009627142446)) 


    def testgradientdescent(self):
        A2 = [[0.3,0.2,0.5],[0.1,0.8,0.1],[0.1,0.4,0.5]]
        B2 = [[0.4,0.2,0.2,0.2],[0.4,0.2,0.2,0.2],
             [0.2,0.1,0.1,0.6,   0.25,0.25,0.25,0.25,   0.5,0.1,0.3,0.1, 0.2,0.1,0.1,0.6]]
        pi2 = [0.5,0.5,0.0] 
    
        model2 = ghmm.HMMFromMatrices(ghmm.DNA,ghmm.DiscreteDistribution(ghmm.DNA), A2, B2, pi2,labelDomain=self.l_domain2,labelList=['fst','scd','thr'])
        
        train = self.model.sample(10,300,seed=3586662)
        model2.gradientSearch(train)

    def testbaumwelch(self):
        # print"\ntestbaumwelch ",
        seq = self.model.sample(100,100,seed=3586662)
        self.model.baumWelchLabels(seq,5,0.01)
        
        self.model.setEmission(2,[0.25,0.25,0.25,0.25])
        self.model.baumWelchLabels(seq,5,0.01)   
    
   
    def testviterbilabels(self):
        seq = ghmm.EmissionSequence(ghmm.DNA, ['a','c','g','t','t','a','a','a','c','g','t','g','a','c','g','c','a','t','t','t'])
        
        p = self.model.viterbiLabels(seq)

        self.assertEqual(p[0], ['fst', 'thr', 'thr', 'scd', 'fst', 'scd', 'fst', 'scd', 'thr', 'thr', 'fst', 'thr', 'thr', 'thr', 'thr', 'thr', 'scd', 'fst', 'scd', 'fst'])
        self.assertEqual(round(p[1],14) ,round(-39.893892710502115,14))


    # TO DO: testing XML-file read
   

class GaussianEmissionHMMTests(unittest.TestCase):

    def setUp(self):
        # print"setUp"
        F = ghmm.Float()
        self.A = [[0.0,1.0,0],[0.5,0.0,0.5],[0.3,0.3,0.4]]
        self.B = [[0.0,1.0],[-1.0,0.5], [1.0,0.2]]
        self.pi = [1.0,0.0,0.0]
        self.model = ghmm.HMMFromMatrices(F,ghmm.GaussianDistribution(F), self.A, self.B, self.pi)

    def test__str__(self):
        # we aren't interested in the output but the function should run fine
        str(self.model)

    def testaccessfunctions(self):
        # print"\ntestaccessfunctions",
        
        self.assertEqual(self.model.N,3)
        self.assertEqual(self.model.M,1)
        
        pi = self.model.getInitial(2)
        self.assertEqual(pi,0)
        self.model.setInitial(2,0.5,fixProb=1)
        pi = self.model.getInitial(2)
        self.assertEqual(pi,0.5)
        
        trans = self.model.getTransition(0,1)
        self.assertEqual(trans, 1.0)
        self.model.setTransition(0,1,0.6)
        
        trans = self.model.getTransition(0,1)
        self.assertEqual(trans, 0.6)
        
        emission = self.model.getEmission(1)
        self.assertEqual(emission, (-1.0,0.5) )
        self.model.setEmission(1,(3.0,0.5))
        
        emission = self.model.getEmission(1)
        self.assertEqual(emission, (3.0,0.5))
    
    def testtomatrices(self):
        # print"\ntesttomatrices ",
        tA,tB,tpi = self.model.asMatrices()
        
        self.assertEqual(self.A,tA)
        self.assertEqual(self.B,tB)
        self.assertEqual(self.pi,tpi)    
    
    def testsample(self):
        # print"\ntestsample ",
        seq = self.model.sampleSingle(100,seed=3586662)
        seq2 = self.model.sample(10,100,seed=3586662)


    def testbaumwelch(self):
        # print"\ntestbaumwelch",
        seq = self.model.sample(100,100,seed=0)
        self.model.baumWelch(seq,5,0.01)
    
    
    def oneStateModel(self, mean, var):
        # one state model with N(mean, var)
        return ghmm.HMMFromMatrices(ghmm.Float(),
                                    ghmm.GaussianDistribution(ghmm.Float),
                                    [[1.0]],[[mean, var]], [1.0])

    def testdel(self):
        # print"\ntestdel ",
        del(self.model)


class GaussianMixtureHMMTests(unittest.TestCase):
    def setUp(self):
        # print"setUp"
        F = ghmm.Float()
        self.A = [[0.25,0.5,0.25],[0.3,0.2,0.5],[0.3,0.3,0.4]]

        self.B = [[ [0.0,1.0,2.0],[1.0,2.5,5.5], [0.5,0.3,0.2]],
             [ [2.0,6.0,1.0],[1.0,0.5,0.7], [0.1,0.5,0.4]],
             [ [4.0,5.0,1.0],[1.0,2.5,2.0], [0.3,0.3,0.4]] ]

        self.pi = [1.0,0.0,0.0]
        
        self.model = ghmm.HMMFromMatrices(F,ghmm.GaussianMixtureDistribution(F), self.A, self.B, self.pi)
        #print "** GaussianMixtureHMMTests **"

    def test__str__(self):
        # we aren't interested in the output but the function should run fine
        str(self.model)

    def testSMO(self):
        model = ghmm.HMMOpen('testdata/tiny.smo')

    def testNewXML(self):
        model = ghmm.HMMOpen('../doc/xml_cont_example.xml')

    def testMultipleTransitionClasses(self):
        model = ghmm.HMMOpen('testdata/xml_cont_multiple.xml')
        state = model.cmodel.getState(0)
        self.assertEqual(state.getOutProb(0, 0), state.getOutProb(0))
        self.assertEqual(state.getOutProb(0, 0), 0.1)
        self.assertEqual(state.getOutProb(0, 1), 0.2)

    def testcomponentfixing(self):
        #print "testcomponentfixing"
        f = self.model.getMixtureFix(0)
        self.assertEqual(f,[0,0,0])
        self.model.setMixtureFix(0,[0,1,0])    
        f = self.model.getMixtureFix(0)
        self.assertEqual(f,[0,1,0])
        self.model.setMixtureFix(1,[1,1,1])    
        f = self.model.getMixtureFix(1) 
        self.assertEqual(f,[1,1,1])
        
        # XXX check mu,v,u

    def testtomatrices(self):
        #print"\ntesttomatrices "
        tA,tB,tpi = self.model.asMatrices()
        
        self.assertEqual(self.A,tA)
        self.assertEqual(self.B,tB)
        self.assertEqual(self.pi,tpi)    
        
        
    def testsample(self):
        #print"\ntestsample "
        seq = self.model.sampleSingle(100,seed=3586662)
        seq2 = self.model.sample(10,100,seed=3586662)
        

class XMLIOTests(unittest.TestCase):
    
    def setUp(self):
        self.A = [[0.3,0.3,0.4],[0.6,0.1,0.3],[1.0,0.0,0.0]]
        self.B = [[0.0,0.5,0.5,0.0],[0.1,0.0,0.8,0.1], [0.0,0.0,0.0,0.0]]
        self.pi = [1.0,0,0]
        self.model = ghmm.HMMFromMatrices(ghmm.DNA,ghmm.DiscreteDistribution(ghmm.DNA), self.A, self.B, self.pi)

        # model with labels
        random.seed(0)
        slength = 45
        self.labels = ['One']*slength
        self.allLabels = ['a','b','c','d','e','f','g']
        self.l_domain= ghmm.LabelDomain(['One','a','b','c','d','e','f','g'])
        

        self.A = [[0.0,0.5,0.5],[0.4,0.2,0.4],[0.3,0.3,0.4]]
        self.B = [[0.2,0.1,0.1,0.6],[0.3,0.1,0.1,0.5],
                  [0.25,0.25,0.25,0.25,   0.0, 0.0, 1.0, 0.0,   0.25,0.25,0.25,0.25,  0.25,0.25,0.25,0.25]]
        self.pi = [1.0,0,0.0]

        self.l_domain2 = ghmm.LabelDomain(['fst','scd','thr'])
        self.label_model = ghmm.HMMFromMatrices(ghmm.DNA,ghmm.DiscreteDistribution(ghmm.DNA), self.A, self.B, self.pi,labelDomain=self.l_domain2,labelList=['fst','scd','thr'])
        
        sequence = []
        for i in range(slength):
            sequence.append(random.choice(ghmm.DNA.listOfCharacters))
        self.tSeq  = ghmm.EmissionSequence(ghmm.DNA, sequence, labelDomain=self.l_domain,labelInput=self.labels)
        #print "** XMLIOTests **"
        #print self.tSeq

    def testReadHMMed(self):
        model = ghmm.HMMOpen('testdata/multexon-4.xml')
        del model
        model = ghmm.HMMOpen('testdata/test2.xml')
        del model

    def testWriteReadXML(self):
        """
        Test writing from matrices to XML.
        Ignored attributes: tied_to and background.
        """
        #self.model.toXML('testdata/discrete.xml')
        model2 = ghmm.HMMOpen('testdata/discrete.xml')

        #self.label_model.toXML('testdata/model_label.xml')
        model3 = ghmm.HMMOpen('testdata/model_label.xml')

########### PAIR HMM TESTS ##############

class ComplexEmissionSequenceTests(unittest.TestCase):
    
    def setUp(self):
        i_alph = ghmm.IntegerRange(0,5)
        d_alph = ghmm.Float()
        self.seq = ghmm.ComplexEmissionSequence([i_alph, ghmm.DNA, d_alph],
                                                [[1,2,0,0,0,3,4],
                                                 ['a','t','g','c','t','g','c'],
                                                 [1.3, 2.1, 0.8, 0.1, 0.03, 3.6, 43.3]])
        
    def testprint(self):
        # print"\ntestprint ",
        s = ("ComplexEmissionSequence (len=7, discrete=2, continuous=1)\n" +
             "1200034\n" +
             "atgctgc\n" +
             "1.3,2.1,0.8,0.1,0.03,3.6,43.3\n")

        self.assertEqual(self.seq.verboseStr(),s)
        
        
    def testattributes(self):
        # print"\ntestattributes ", 
        self.assertEqual(self.seq.cseq.number_of_alphabets,2)
        self.assertEqual(self.seq.cseq.number_of_d_seqs,1)    
        self.assertEqual(self.seq.cseq.length,7)    
        self.assertEqual(len(self.seq),7)    
    
    def testitemaccess(self):
        # print"\ntestitemaccess ",
        b = self.seq.getInternalDiscreteSequence(0)
        self.assertEqual(b[5], 3)    
        
        b2 = self.seq.getInternalContinuousSequence(0)
        self.assertEqual(b2[1],2.1)    

    def testerrors(self):
        pass


# Run ALL tests (comment out to deactivate)
if __name__ == '__main__':
    unittest.main()


# Individual test suites for each of the different classes
suiteAlphabet = unittest.makeSuite(AlphabetTests,'test')
suiteEmissionSequence = unittest.makeSuite(EmissionSequenceTests,'test')
suiteSequenceSet = unittest.makeSuite(SequenceSetTests,'test')
suiteDiscreteEmissionHMM = unittest.makeSuite(DiscreteEmissionHMMTests,'test')
suiteBackgroundDistribution = unittest.makeSuite(BackgroundDistributionTests,'test')
suiteStateLabelHMM = unittest.makeSuite(StateLabelHMMTests,'test')
suiteGaussianEmissionHMM = unittest.makeSuite(GaussianEmissionHMMTests,'test')
suiteGaussianMixtureHMM = unittest.makeSuite(GaussianMixtureHMMTests,'test')
suiteXMLIO = unittest.makeSuite(XMLIOTests,'test')

# Call to individual test suites, uncomment to activate as needed.
runner = unittest.TextTestRunner()
#runner.run(suiteAlphabet)
#runner.run(suiteEmissionSequence)
#runner.run(suiteSequenceSet)
#runner.run(suiteDiscreteEmissionHMM)
#runner.run(suiteBackgroundDistribution)
#runner.run(suiteStateLabelHMM)
#runner.run(suiteGaussianEmissionHMM)
#runner.run(suiteGaussianMixtureHMM)
#runner.run(suiteXMLIO)