func TestTrainBasic(t *testing.T) { data := [][]float64{{0.1}, {0.3}, {1.1}, {5.5}, {7.8}, {10.0}, {5.2}, {4.1}, {3.3}, {6.2}, {8.3}} m := makeHMM(t) h := m.Set.Nets[0] tp0 := narray.Exp(nil, h.A.Copy()) obs := model.NewFloatObsSequence(data, model.SimpleLabel(""), "") m.Clear() m.UpdateOne(obs, 1.0) m.Estimate() m.Clear() m.UpdateOne(obs, 1.0) m.Estimate() tp := narray.Exp(nil, h.A.Copy()) ns := tp.Shape[0] for i := 0; i < ns; i++ { for j := 0; j < ns; j++ { p0 := tp0.At(i, j) p := tp.At(i, j) if p > smallNumber || p0 > smallNumber { t.Logf("TP: %d=>%d, p0:%5.2f, p:%5.2f", i, j, p0, p) } } } t.Log("") t.Logf("hmm g1: %+v, g2:%+v", h.B[1], h.B[2]) }
// Score implements the graph.Viterbier interface. // The argument x must be of type []float64. func (nv nodeValue) Score(x interface{}) float64 { if nv.scorer == nil { return 0 // non-emitting node. } o := model.NewFloatObs(x.([]float64), model.SimpleLabel("")) return nv.scorer.LogProb(o) }
func TestLRAssign(t *testing.T) { initChainFB(t) ms2, e := NewSet(hmm0, hmm1) fatalIf(t, e) testScorer := func() scorer { return scorer{op: []float64{math.Log(0.4), math.Log(0.2), math.Log(0.4)}} } _, err := ms2.makeLeftToRight("model 2", 4, 0.4, 0.1, []model.Modeler{nil, testScorer(), testScorer(), nil}) fatalIf(t, err) _, errr := ms2.makeLeftToRight("model 3", 6, 0.3, 0.2, []model.Modeler{nil, testScorer(), testScorer(), testScorer(), testScorer(), nil}) fatalIf(t, errr) // we need to put a label to use assigner - use same sequence as in TestLR() using the model names simplelab := model.SimpleLabel("model 0,model 2,model 3,model 0,model 0,model 0,model 0,model 2") oo := model.NewFloatObsSequence(xobs.Value().([][]float64), simplelab, "") // read it back sl := oo.Label().(model.SimpleLabel) glog.V(5).Infoln("read label: ", sl) var assigner DirectAssigner hmms2, err := ms2.chainFromAssigner(oo, assigner) if err != nil { t.Fatal(err) } hmms2.update() nq := hmms2.nq alpha2 := hmms2.alpha.At(nq-1, hmms2.ns[nq-1]-1, nobs-1) beta2 := hmms2.beta.At(0, 0, 0) t.Logf("alpha2:%f", alpha2) t.Logf("beta2:%f", beta2) // check log prob per obs calculated with alpha and beta delta := math.Abs(alpha2-beta2) / float64(nobs) if delta > smallNumber { t.Fatalf("alphaLogProb:%f does not match betaLogProb:%f", alpha2, beta2) } if math.Abs(alpha2-expectedProb) > smallNumber { t.Fatalf("alphaLogProb:%f, expected:%f", alpha2, expectedProb) } }
func TestHMMModel(t *testing.T) { initChainFB(t) modelSet, e := NewSet(hmm0, hmm1) fatalIf(t, e) testScorer := func() scorer { return scorer{op: []float64{math.Log(0.4), math.Log(0.2), math.Log(0.4)}} } _, err := modelSet.makeLeftToRight("model 2", 4, 0.4, 0.1, []model.Modeler{nil, testScorer(), testScorer(), nil}) fatalIf(t, err) _, errr := modelSet.makeLeftToRight("model 3", 6, 0.3, 0.2, []model.Modeler{nil, testScorer(), testScorer(), testScorer(), testScorer(), nil}) fatalIf(t, errr) // we need to put a label to use assigner - use same sequence as in TestLR() using the model names simplelab := model.SimpleLabel("model 0,model 2,model 3,model 0,model 0,model 0,model 0,model 2") oo := model.NewFloatObsSequence(xobs.Value().([][]float64), simplelab, "") // read it back var assigner DirectAssigner hmm := NewModel(OSet(modelSet), OAssign(assigner)) hmm.UpdateOne(oo, model.NoWeight(oo)) hmm.Estimate() hmm.Clear() hmm.UpdateOne(oo, model.NoWeight(oo)) hmm.Estimate() hmm.Clear() hmm.UpdateOne(oo, model.NoWeight(oo)) hmm.Estimate() hmm.Clear() hmm.UpdateOne(oo, model.NoWeight(oo)) hmm.Estimate() }
// Next returns the next observation sequence. func (gen *generator) next(id string) (*model.FloatObsSequence, []string) { var data [][]float64 name := gen.hmm.Name states := []string{name + "-0"} r := gen.r seq := model.NewFloatObsSequence(data, model.SimpleLabel(name), id).(model.FloatObsSequence) s := gen.hmm.nextState(0, r) states = append(states, name+"-"+strconv.FormatInt(int64(s), 10)) for { if s == gen.hmm.ns-1 { // Reached exit state. break } glog.V(8).Infof("start loop for hmm: %s, state: %d, num states: %d", name, s, gen.hmm.ns) g := gen.hmm.B[s] if g == nil { glog.Infof("hmm name: %s, state: %d, num states: %d", name, s, gen.hmm.ns) panic("output PDF is nil - can't generate data") } gs, ok := g.(model.Sampler) if !ok { glog.Info(gen.hmm.A) glog.Infof("hmm name: %s, state: %d, num states: %d", name, s, gen.hmm.ns) panic("output PDF does not implement the sampler interface") } x := gs.Sample(r).(model.FloatObs) seq.Add(x, "") s = gen.hmm.nextState(s, r) states = append(states, name+"-"+strconv.FormatInt(int64(s), 10)) } if gen.noNull { states = states[1 : len(states)-1] } return &seq, states }
func (m *Net) logProb(s int, x []float64) float64 { o := model.NewFloatObs(x, model.SimpleLabel("")) return m.B[s].LogProb(o) }
// should be equivalent to training a single gaussian, great for debugging. func TestSingleState(t *testing.T) { // HMM to generate data. g01 := gm.NewModel(1, gm.Name("g01"), gm.Mean([]float64{0}), gm.StdDev([]float64{1})) h0 := narray.New(3, 3) h0.Set(1, 0, 1) h0.Set(.8, 1, 1) h0.Set(.2, 1, 2) h0 = narray.Log(nil, h0.Copy()) ms0, _ := NewSet() net0, e0 := ms0.NewNet("hmm", h0, []model.Modeler{nil, g01, nil}) fatalIf(t, e0) hmm0 := NewModel(OSet(ms0)) _ = hmm0 // Create gaussian to estimate without using the HMM code. g := gm.NewModel(1, gm.Name("g1"), gm.Mean([]float64{-1}), gm.StdDev([]float64{2})) // Create initial HMM and estimate params from generated data. g1 := gm.NewModel(1, gm.Name("g1"), gm.Mean([]float64{-1}), gm.StdDev([]float64{2})) h := narray.New(3, 3) h.Set(1, 0, 1) h.Set(.5, 1, 1) h.Set(.5, 1, 2) h = narray.Log(nil, h.Copy()) ms, _ = NewSet() net, e := ms.NewNet("hmm", h, []model.Modeler{nil, g1, nil}) fatalIf(t, e) hmm := NewModel(OSet(ms), UpdateTP(true), UpdateOP(true)) iter := 5 // number of sequences m := 1000 numFrames := 0 t0 := time.Now() // Start timer. for i := 0; i < iter; i++ { t.Logf("iter [%d]", i) // Make sure we generate the same data in each iteration. r := rand.New(rand.NewSource(33)) gen := newGenerator(r, false, net0) // Reset all counters. hmm.Clear() g.Clear() // fix the seed to get the same sequence for j := 0; j < m; j++ { obs, states := gen.next("oid-" + fi(j)) numFrames += len(states) - 2 hmm.UpdateOne(obs, 1.0) // Update Gaussian for _, o := range obs.ValueAsSlice() { vec := o.([]float64) gobs := model.NewFloatObs(vec, model.SimpleLabel("")) g.UpdateOne(gobs, 1.0) } } hmm.Estimate() g.Estimate() t.Logf("iter:%d, hmm g1: %+v", i, net.B[1]) t.Logf("iter:%d, direct g1:%+v", i, g) } dur := time.Now().Sub(t0) tp0 := narray.Exp(nil, h0.Copy()) tp := narray.Exp(nil, net.A.Copy()) ns := tp.Shape[0] for i := 0; i < ns; i++ { for j := 0; j < ns; j++ { p0 := tp0.At(i, j) logp0 := h0.At(i, j) p := tp.At(i, j) logp := h.At(i, j) if p > smallNumber || p0 > smallNumber { t.Logf("TP: %d=>%d, p0:%5.2f, p:%5.2f, logp0:%8.5f, logp:%8.5f", i, j, p0, p, logp0, logp) } } } t.Log("") t.Logf("hmm0 g1:%+v", net0.B[1]) t.Logf("hmm g1: %+v", net.B[1]) t.Log("") t.Logf("direct g1:%+v", g) // Print time stats. t.Log("") t.Logf("Total time: %v", dur) t.Logf("Time per iteration: %v", dur/time.Duration(iter)) t.Logf("Time per frame: %v", dur/time.Duration(iter*numFrames*m)) gjoa.CompareSliceFloat(t, tp0.Data, tp.Data, "error in Trans Probs [0]", .03) CompareGaussians(t, net0.B[1].(*gm.Model), net.B[1].(*gm.Model), 0.03) if t.Failed() { t.FailNow() } // Recognize. sg := ms.SearchGraph() dec, e := graph.NewDecoder(sg) if e != nil { t.Fatal(e) } r := rand.New(rand.NewSource(5151)) gen := newGenerator(r, true, net0) // testDecoder(t, gen, dec, 1000) testDecoder(t, gen, dec, 10) }
func TestMain(m *testing.M) { // Configure glog. Example to set debug level 6 for file viterbi.go and 3 for everythign else: // export GLOG_LEVEL=3 // go test -v -run TestTrainHmmGau -vmodule=viterbi=6 > /tmp/zzz flag.Set("alsologtostderr", "true") flag.Set("log_dir", "/tmp/log") level := os.Getenv("GLOG_LEVEL") if len(level) == 0 { level = "0" } flag.Set("v", level) glog.Info("glog debug level is: ", level) ns = 5 // max num states in a model nstates[0] = 5 nstates[1] = 4 nobs = len(obs) a = narray.New(nq, ns, ns) b = narray.New(nq, ns, nobs) alpha = narray.New(nq, ns, nobs) beta = narray.New(nq, ns, nobs) a.Set(1, 0, 0, 1) a.Set(.5, 0, 1, 1) a.Set(.5, 0, 1, 2) a.Set(.3, 0, 2, 2) a.Set(.6, 0, 2, 3) a.Set(.1, 0, 2, 4) a.Set(.7, 0, 3, 3) a.Set(.3, 0, 3, 4) a.Set(1, 1, 0, 1) a.Set(.3, 1, 1, 1) a.Set(.2, 1, 1, 2) a.Set(.5, 1, 1, 3) a.Set(.6, 1, 2, 2) a.Set(.4, 1, 2, 3) dist := [][]float64{{.4, .5, .1}, {.3, .5, .2}} // prob dist for states in model 0 and 1 // output probs as a function of model,state,time for q := 0; q < nq; q++ { for i := 1; i < nstates[q]-1; i++ { for t := 0; t < nobs; t++ { p := dist[q][obs[t]] // k := r.Intn(len(someProbs)) // b.Set(someProbs[k], q, i, t) b.Set(p, q, i, t) } } } // same output probs but as a function of model,state,symbol // we need this to test the network implementation. outputProbs = narray.New(nq, ns, nsymb) for q := 0; q < nq; q++ { for i := 1; i < nstates[q]-1; i++ { for k := 0; k < nsymb; k++ { p := math.Log(dist[q][k]) outputProbs.Set(p, q, i, k) } } } loga = narray.Log(loga, a.Copy()) logb = narray.Log(logb, b.Copy()) data := make([][]float64, len(obs), len(obs)) for k, v := range obs { data[k] = []float64{float64(v)} } xobs = model.NewFloatObsSequence(data, model.SimpleLabel(""), "") os.Exit(m.Run()) }
func (m *Net) testLogProb(s, o int) float64 { return m.B[s].LogProb(model.NewIntObs(o, model.SimpleLabel(""), "")) }
// Sample returns a Gaussian sample. func (g *Model) Sample(r *rand.Rand) model.Obs { obs := model.RandNormalVector(r, g.Mean, g.StdDev) return model.NewFloatObs(obs, model.SimpleLabel("")) }