func makeHMM(t *testing.T) *Model {
// Gaussian 1.
mean1 := []float64{1}
sd1 := []float64{1}
g1 := gm.NewModel(1, gm.Name("g1"), gm.Mean(mean1), gm.StdDev(sd1))
// Gaussian 2.
mean2 := []float64{4}
sd2 := []float64{2}
g2 := gm.NewModel(1, gm.Name("g2"), gm.Mean(mean2), gm.StdDev(sd2))
var err error
h0 := narray.New(4, 4)
// h0.Set(.8, 0, 1)
h0.Set(1, 0, 1)
// h0.Set(.2, 0, 2)
h0.Set(.5, 1, 1)
h0.Set(.5, 1, 2)
h0.Set(.7, 2, 2)
h0.Set(.3, 2, 3)
h0 = narray.Log(nil, h0.Copy())
ms, _ = NewSet()
_, err = ms.NewNet("hmm0", h0,
[]model.Modeler{nil, g1, g2, nil})
fatalIf(t, err)
return NewModel(OSet(ms), UpdateTP(true), UpdateOP(true))
}
func MakeGMM(t *testing.T) *Model {
mean0 := []float64{1, 2}
sd0 := []float64{0.3, 0.3}
mean1 := []float64{4, 4}
sd1 := []float64{1, 1}
weights := []float64{0.6, 0.4}
dim := len(mean0)
g0 := gaussian.NewModel(2, gaussian.Name("g0"), gaussian.Mean(mean0), gaussian.StdDev(sd0))
g1 := gaussian.NewModel(2, gaussian.Name("g1"), gaussian.Mean(mean1), gaussian.StdDev(sd1))
components := []*gaussian.Model{g0, g1}
gmm := NewModel(dim, 2, Name("mygmm"), Components(components), Weights(weights))
return gmm
}
// creates a random gaussian by adding a perturbation to an existing gaussian.
func initGaussian(r *rand.Rand, m model.Modeler) *gm.Model {
g := m.(*gm.Model)
var mean, sd []float64
for i := 0; i < g.ModelDim; i++ {
a := r.NormFloat64()*0.2 + 1.0 // pert 0.8 to 1.2
mean = append(mean, g.Mean[i]*a)
sd = append(sd, g.StdDev[i]*a)
}
return gm.NewModel(g.ModelDim, gm.Name(g.ModelName), gm.Mean(mean), gm.StdDev(sd))
}
func randomGaussian(r *rand.Rand, id string, dim int) *gm.Model {
var mean, sd []float64
startSD := 40.0
for i := 0; i < dim; i++ {
mean = append(mean, float64(r.Intn(10)*100.0))
a := r.NormFloat64()*0.2 + 1.0 // pert 0.8 to 1.2
sd = append(sd, startSD*a)
}
return gm.NewModel(dim, gm.Name(id), gm.Mean(mean), gm.StdDev(sd))
}
// RandomModel generates a random Gaussian mixture model using mean and variance vectors as seed.
// Use this function to initialize the GMM before training. The mean and sd
// vector can be estimated from the data set using a Gaussian model.
func RandomModel(mean, sd []float64, numComponents int,
name string, seed int64) *Model {
n := len(mean)
if !floats.EqualLengths(mean, sd) {
panic(floatx.ErrLength)
}
cs := make([]*gaussian.Model, n, n)
r := rand.New(rand.NewSource(seed))
for i := 0; i < n; i++ {
rv := RandomVector(mean, sd, r)
cs[i] = gaussian.NewModel(n, gaussian.Mean(rv), gaussian.StdDev(sd))
}
gmm := NewModel(n, numComponents, Name(name), Components(cs))
return gmm
}
// 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 TestHMMGauss(t *testing.T) {
// Create reference HMM to generate observations.
g01 := gm.NewModel(1, gm.Name("g01"), gm.Mean([]float64{0}), gm.StdDev([]float64{1}))
g02 := gm.NewModel(1, gm.Name("g02"), gm.Mean([]float64{16}), gm.StdDev([]float64{2}))
h0 := narray.New(4, 4)
h0.Set(.6, 0, 1)
h0.Set(.4, 0, 2)
h0.Set(.9, 1, 1)
h0.Set(.1, 1, 2)
h0.Set(.7, 2, 2)
h0.Set(.3, 2, 3)
h0 = narray.Log(nil, h0.Copy())
ms0, _ := NewSet()
net0, e0 := ms0.NewNet("hmm", h0,
[]model.Modeler{nil, g01, g02, nil})
fatalIf(t, e0)
hmm0 := NewModel(OSet(ms0), UpdateTP(true), UpdateOP(true))
_ = hmm0
// Create random HMM and estimate params from obs.
g1 := gm.NewModel(1, gm.Name("g1"), gm.Mean([]float64{-1}), gm.StdDev([]float64{2}))
g2 := gm.NewModel(1, gm.Name("g2"), gm.Mean([]float64{18}), gm.StdDev([]float64{4}))
h := narray.New(4, 4)
h.Set(.5, 0, 1)
h.Set(.5, 0, 2)
h.Set(.5, 1, 1)
h.Set(.5, 1, 2)
h.Set(.5, 2, 2)
h.Set(.5, 2, 3)
h = narray.Log(nil, h.Copy())
ms, _ = NewSet()
net, e := ms.NewNet("hmm", h,
[]model.Modeler{nil, g1, g2, nil})
fatalIf(t, e)
hmm := NewModel(OSet(ms), UpdateTP(true), UpdateOP(true))
iter := 10
// number of sequences
m := 500
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()
// 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)
}
hmm.Estimate()
}
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, g2:%+v", net0.B[1], net0.B[2])
t.Logf("hmm g1: %+v, g2:%+v", net.B[1], net.B[2])
// 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)
CompareGaussians(t, net0.B[2].(*gm.Model), net.B[2].(*gm.Model), 0.03)
if t.Failed() {
t.FailNow()
}
// Recognize.
g := ms.SearchGraph()
dec, e := graph.NewDecoder(g)
if e != nil {
t.Fatal(e)
}
r := rand.New(rand.NewSource(5151))
gen := newGenerator(r, true, net0)
testDecoder(t, gen, dec, 1000)
}
