def testem(self):
        # complex DataSet with HMM sequences and scalar data
        dat = self.gen.sampleSet(100)

        # sampling hmm data
        seq1 = self.h1.hmm.sample(40, 10)
        seq2 = self.h2.hmm.sample(60, 10)

        seq1.merge(seq2)

        data = mixtureHMM.SequenceDataSet()
        data.fromGHMM(dat, [seq1])
        data.internalInit(self.m)

        tA = [[0.5, 0.2, 0.3], [0.2, 0.3, 0.5], [0.1, 0.5, 0.4]]
        tB = [[0.2, 0.4, 0.1, 0.3], [0.5, 0.1, 0.2, 0.2],
              [0.4, 0.3, 0.15, 0.15]]
        tpi = [0.3, 0.3, 0.4]
        th1 = mixtureHMM.getHMM(
            mixtureHMM.ghmm.IntegerRange(0, 4),
            mixtureHMM.ghmm.DiscreteDistribution(
                mixtureHMM.ghmm.IntegerRange(0, 4)), tA, tB, tpi)

        tA2 = [[0.5, 0.4, 0.1], [0.3, 0.2, 0.5], [0.3, 0.2, 0.5]]
        tB2 = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.4, 0.4],
               [0.2, 0.1, 0.6, 0.1]]
        tpi2 = [0.3, 0.4, 0.3]
        th2 = mixtureHMM.getHMM(
            mixtureHMM.ghmm.IntegerRange(0, 4),
            mixtureHMM.ghmm.DiscreteDistribution(
                mixtureHMM.ghmm.IntegerRange(0, 4)), tA2, tB2, tpi2)

        tn1 = mixture.NormalDistribution(-1.5, 1.5)
        tn2 = mixture.NormalDistribution(9.0, 1.2)

        tmult1 = mixture.MultinomialDistribution(3,
                                                 4, [0.1, 0.1, 0.55, 0.25],
                                                 alphabet=self.DIAG)
        tmult2 = mixture.MultinomialDistribution(3,
                                                 4, [0.4, 0.3, 0.1, 0.2],
                                                 alphabet=self.DIAG)

        tc1 = mixture.ProductDistribution([tn1, tmult1, th1])
        tc2 = mixture.ProductDistribution([tn2, tmult2, th2])

        tmpi = [0.7, 0.3]
        tm = mixture.MixtureModel(2, tmpi, [tc1, tc2])

        tm.EM(data, 80, 0.1, silent=1)
    def testinternalinitcomplex(self):
        # complex DataSet with HMM sequences
        dat = self.gen.sampleSet(100)

        # sampling hmm data
        seq1 = self.h1.hmm.sample(40, 10)
        seq2 = self.h2.hmm.sample(60, 10)

        seq1.merge(seq2)

        data = mixtureHMM.SequenceDataSet()
        data.fromGHMM(dat, [seq1])
        data.internalInit(self.m)

        self.assertEqual(str(data.complexFeature), '[0, 0, 1]')
        self.assertEqual(data.p, 5)
        self.assertEqual(data.suff_p, 6)
    def testgetinternalfeature(self):
        # complex DataSet with HMM sequences
        dat = self.gen.sampleSet(100)

        # sampling hmm data
        seq1 = self.h1.hmm.sample(40, 10)
        seq2 = self.h2.hmm.sample(60, 10)

        seq1.merge(seq2)

        data = mixtureHMM.SequenceDataSet()
        data.fromGHMM(dat, [seq1])
        data.internalInit(self.m)

        f0 = data.getInternalFeature(0)
        self.assertEqual(isinstance(f0, numarray.numarraycore.NumArray), True)

        f1 = data.getInternalFeature(1)
        self.assertEqual(isinstance(f1, numarray.numarraycore.NumArray), True)

        f2 = data.getInternalFeature(2)
        self.assertEqual(isinstance(f2, ghmm.SequenceSet), True)
    def testsimpleem(self):

        # sampling hmm data
        seq1 = self.h1.hmm.sample(40, 10)
        seq2 = self.h2.hmm.sample(60, 10)
        seq1.merge(seq2)

        data = mixtureHMM.SequenceDataSet()
        data.fromGHMM([], [seq1])

        tA = [[0.5, 0.2, 0.3], [0.2, 0.3, 0.5], [0.1, 0.5, 0.4]]
        tB = [[0.2, 0.4, 0.1, 0.3], [0.5, 0.1, 0.2, 0.2],
              [0.4, 0.3, 0.15, 0.15]]
        tpi = [0.3, 0.3, 0.4]
        th1 = mixture.ProductDistribution([
            mixtureHMM.getHMM(
                mixtureHMM.ghmm.IntegerRange(0, 4),
                mixtureHMM.ghmm.DiscreteDistribution(
                    mixtureHMM.ghmm.IntegerRange(0, 4)), tA, tB, tpi)
        ])

        tA2 = [[0.5, 0.4, 0.1], [0.3, 0.2, 0.5], [0.3, 0.2, 0.5]]
        tB2 = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.4, 0.4],
               [0.2, 0.1, 0.6, 0.1]]
        tpi2 = [0.3, 0.4, 0.3]
        th2 = mixture.ProductDistribution([
            mixtureHMM.getHMM(
                mixtureHMM.ghmm.IntegerRange(0, 4),
                mixtureHMM.ghmm.DiscreteDistribution(
                    mixtureHMM.ghmm.IntegerRange(0, 4)), tA2, tB2, tpi2)
        ])

        mpi = [0.4, 0.6]
        hm = mixture.MixtureModel(2, mpi, [th1, th2])

        data.internalInit(hm)

        hm.EM(data, 80, 0.1, silent=1)
    def testinternalinitcomplexempty(self):
        # complex DataSet with HMM sequences only

        # sampling hmm data
        seq1 = self.h1.hmm.sample(40, 10)
        seq2 = self.h2.hmm.sample(60, 10)
        seq1.merge(seq2)

        data = mixtureHMM.SequenceDataSet()
        data.fromGHMM([], [seq1])

        self.assertRaises(AssertionError, data.internalInit, self.m)

        c1 = mixture.ProductDistribution([self.h1])
        c2 = mixture.ProductDistribution([self.h2])

        mpi = [0.4, 0.6]
        hm = mixture.MixtureModel(2, mpi, [c1, c2])

        data.internalInit(hm)

        self.assertEqual(str(data.complexFeature), '[1]')
        self.assertEqual(data.p, 1)
        self.assertEqual(data.suff_p, 1)
示例#6
0
# mixture for sampling
gc1 = mixture.ProductDistribution([n1, mult1])
gc2 = mixture.ProductDistribution([n2, mult2])
gen = mixture.MixtureModel(2, mpi, [gc1, gc2])

dat = gen.sampleSet(100)
#print dat

# sampling hmm data
seq1 = h1.hmm.sample(40, 10)
seq2 = h2.hmm.sample(60, 10)

seq1.merge(seq2)

data = mixtureHMM.SequenceDataSet()

#data.fromGHMM(dat,[seq1])
data.fromGHMM(dat, [seq1])

data.internalInit(m)

#print data.getInternalFeature(0)
#print data.getInternalFeature(1)

# -------- construct model to be trained -------------

tA = [[0.5, 0.2, 0.3], [0.2, 0.3, 0.5], [0.1, 0.5, 0.4]]
tB = [[0.2, 0.4, 0.1, 0.3], [0.5, 0.1, 0.2, 0.2], [0.4, 0.3, 0.15, 0.15]]
tpi = [0.3, 0.3, 0.4]
th1 = mixtureHMM.getHMM(