def test_run_merge_move_on_dup_comps_succeeds_with_marglik_choice(self):
''' Consider Duplicated Comps model.
Use marglik criteria to select candidates kA, kB.
Verify that the merge accept rate is much higher than at random.
The accept rate should actually be near perfect!
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel,
self.Data,
SS,
mergename='marglik',
randstate=PRNG)
print MoveInfo['msg']
if MoveInfo['didAccept']:
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess) / float(nTrial)
print "Expected rate: >.95"
print "Measured rate: %.3f" % (rate)
assert rate > 0.95
def test_propose_merge_candidate_produces_valid_model(self):
''' Test a proposal where we explicitly choose which comps to merge (kA,kB)
and verify it produces a valid model
'''
propModel, propSS = MergeMove.propose_merge_candidate(self.hmodel, self.SS, kA=0, kB=1)
# Check number of components!
assert propSS.K == self.SS.K - 1
self.verify_proposed_model(propModel, propSS)
# Check that we can now do further E-steps and get sensible results
LP = propModel.calc_local_params(self.Data)
R = LP['resp']
assert R.shape[0] == self.Data.nObs
assert R.shape[1] == propSS.K
assert not np.any(np.isnan(R))
Neff = np.sum(R, axis=0)
# Merger should cause new component "0" to explain twice as much data as
# component 1. Let's verify this
assert Neff[0] > 1.5*Neff[1]
# Merged model should have mu for comp 0 (merged one) around -5
mu0 = propModel.obsModel.get_mean_for_comp(0)
distFromExpected = np.abs(mu0[0] - -5.0)
assert distFromExpected < 1.0
# Merged model should have mu for comp 1 near where only comp 2 was
newMu1 = propModel.obsModel.get_mean_for_comp(1)
oldMu2 = self.hmodel.obsModel.get_mean_for_comp(2)
distFromExpected = np.max(np.abs(newMu1 - oldMu2))
assert distFromExpected < 1.0
def test_run_merge_move_on_dup_comps_succeeds_with_random_choice(self):
''' Consider Duplicated Comps model.
Out of (8 choose 2) = 28 possible pairs,
exactly 4 produce sensible merges.
Verify that over many random trials where kA,kB drawn uniformly,
we obtain a success rate not too different from 4 / 28 = 0.142857
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel,
self.Data,
SS,
mergename='random',
randstate=PRNG)
if MoveInfo['didAccept']:
print MoveInfo['msg']
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess) / float(nTrial)
print "Expected rate: .1428"
print "Measured rate: %.3f" % (rate)
assert rate > 0.1
assert rate < 0.2
def test_run_merge_move_on_dup_comps_succeeds_with_random_choice(self):
''' Consider Duplicated Comps model.
Out of (8 choose 2) = 28 possible pairs,
exactly 4 produce sensible merges.
Verify that over many random trials where kA,kB drawn uniformly,
we obtain a success rate not too different from 4 / 28 = 0.142857
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel, self.Data, SS, mergename='random', randstate=PRNG)
if MoveInfo['didAccept']:
print MoveInfo['msg']
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess)/float(nTrial)
print "Expected rate: .1428"
print "Measured rate: %.3f" % (rate)
assert rate > 0.1
assert rate < 0.2
def test_run_merge_move_on_duplicated_comps_succeeds_with_random_choice(
self):
''' Verify that merges remove some "duplicate" comps from dupModel,
even when the pairs to merge are chosen at random.
Also verify that the success rate of merges agrees with theory.
For a dupModel with K=6, out of (6 choose 2) = 15 possible pairs,
exactly 3 produce sensible merges for dupModel (K=6).
Verify that over many random trials where kA,kB drawn uniformly,
we obtain a success rate not too different from 3 / 15 = 0.2.
'''
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel,
self.Data,
self.dupSS,
mergename='random',
randstate=PRNG)
if MoveInfo['didAccept']:
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess) / float(nTrial)
assert rate > 0.1
assert rate < 0.3
def test_propose_merge_candidate_produces_valid_model(self):
''' Test a proposal where we explicitly choose which comps to merge (kA,kB)
and verify it produces a valid model
'''
propModel, propSS = MergeMove.propose_merge_candidate(self.hmodel,
self.SS,
kA=0,
kB=1)
# Check number of components!
assert propSS.K == self.SS.K - 1
self.verify_proposed_model(propModel, propSS)
# Check that we can now do further E-steps and get sensible results
LP = propModel.calc_local_params(self.Data)
R = LP['resp']
assert R.shape[0] == self.Data.nObs
assert R.shape[1] == propSS.K
assert not np.any(np.isnan(R))
Neff = np.sum(R, axis=0)
# Merger should cause new component "0" to explain twice as much data as
# component 1. Let's verify this
assert Neff[0] > 1.5 * Neff[1]
# Merged model should have mu for comp 0 (merged one) around -5
mu0 = propModel.obsModel.get_mean_for_comp(0)
distFromExpected = np.abs(mu0[0] - -5.0)
assert distFromExpected < 1.0
# Merged model should have mu for comp 1 near where only comp 2 was
newMu1 = propModel.obsModel.get_mean_for_comp(1)
oldMu2 = self.hmodel.obsModel.get_mean_for_comp(2)
distFromExpected = np.max(np.abs(newMu1 - oldMu2))
assert distFromExpected < 1.0
def test_run_merge_move_on_true_comps_fails(self):
''' Verify that "true" model, with only components that generated the Data,
no merges are accepted
'''
for trial in range(10):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.hmodel, self.Data, self.SS, mergename='random')
assert newModel.allocModel.K == self.hmodel.allocModel.K
assert newModel.obsModel.K == self.hmodel.obsModel.K
def test_run_merge_move_on_true_comps_fails(self):
''' Verify that "true" model, with only components that generated the Data,
no merges are accepted
'''
for trial in range(10):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.hmodel, self.Data, self.SS, mergename='random')
assert newModel.allocModel.K == self.hmodel.allocModel.K
assert newModel.obsModel.K == self.hmodel.obsModel.K
def test_run_many_merge_moves_trueModel_random(self):
LP, SS = self.getSuffStatsPrepForMerge(self.hmodel)
PRNG = np.random.RandomState(0)
mergeKwArgs = dict(mergename='random')
a, b, c, MTracker = MergeMove.run_many_merge_moves(self.hmodel,
self.Data, SS,
nMergeTrials=100, randstate=PRNG,
**mergeKwArgs)
assert MTracker.nTrial == SS.K * (SS.K-1)/2
assert MTracker.nSuccess == 0
def test_run_merge_move_on_true_comps_fails(self):
''' Should not be able to merge "true" components into one another
Each is necessary to explain (some) data
'''
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.hmodel.calc_local_params(self.Data)
SS = self.hmodel.get_global_suff_stats(self.Data, LP, **mergeFlags)
for trial in range(10):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.hmodel, self.Data, SS, mergename='random')
assert newModel.allocModel.K == self.hmodel.allocModel.K
assert newModel.obsModel.K == self.hmodel.obsModel.K
def test_run_many_merge_moves_removes_duplicates(self):
''' Verify run_many_merge_moves method on duplicated model
produces a new model with K=Ktrue components (duplicates gone)
'''
PRNG = np.random.RandomState(12345)
newModel, newSS, ev, MTracker = MergeMove.run_many_merge_moves(
self.dupModel, self.Data, self.dupSS, nMergeTrials=6,
randstate=PRNG)
assert newSS.K == self.SS.K
assert newModel.allocModel.K == self.SS.K
assert newModel.obsModel.K == self.SS.K
def test_run_merge_move_on_duplicated_comps_succeeds_with_ideal_choice(self):
''' Verify that merges remove "duplicate" components from dupModel.
when the IDs are of the duplicate pairs are specifically targeted.
Attempt merge move on each pair of known "duplicates",
these are comp IDs (0,3), (1,4), and (2,5)
This is "ideal", since in practice we wont know which comps to merge.
This isolates whether the merges work even in the best of circumstances.
'''
Ktrue = self.hmodel.obsModel.K
for k in range(Ktrue):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel, self.Data, self.dupSS, kA=k, kB=Ktrue+k)
assert newModel.obsModel.K == self.dupModel.obsModel.K - 1
def test_select_merge_components_random_seed_reproduceable(self):
''' Run "select_merge_comps" repeatedly, verify it selects same merge pair
when given the same exact random seed
'''
Alist = list()
Blist = list()
for trial in range(10):
kA, kB = MergeMove.select_merge_components(self.hmodel, self.Data, self.SS, mergename='random', randstate=np.random.RandomState(0))
Alist.append(kA)
Blist.append(kB)
assert np.all( np.asarray(Alist) == Alist[0])
assert np.all( np.asarray(Blist) == Blist[0])
def test_run_merge_move_on_dup_comps_succeeds_with_all_ideal_pairs(self):
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
myModel = self.dupModel.copy()
for kA in [3,2,1,0]: # descend backwards so indexing still works
kB = kA + 4 # Ktrue=4, so kA's best match is kA+4
myModel, SS, newEv, MoveInfo = MergeMove.run_merge_move(myModel,
self.Data, SS, kA=kA, kB=kB)
print MoveInfo['msg']
assert MoveInfo['didAccept'] == 1
def test_run_many_merge_moves_trueModel_random(self):
LP, SS = self.getSuffStatsPrepForMerge(self.hmodel)
PRNG = np.random.RandomState(0)
mergeKwArgs = dict(mergename='random')
a, b, c, MTracker = MergeMove.run_many_merge_moves(self.hmodel,
self.Data,
SS,
nMergeTrials=100,
randstate=PRNG,
**mergeKwArgs)
assert MTracker.nTrial == SS.K * (SS.K - 1) / 2
assert MTracker.nSuccess == 0
def test_run_merge_move_on_true_comps_fails(self):
''' Should not be able to merge "true" components into one another
Each is necessary to explain (some) data
'''
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.hmodel.calc_local_params(self.Data)
SS = self.hmodel.get_global_suff_stats(self.Data, LP, **mergeFlags)
for trial in range(10):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.hmodel, self.Data, SS, mergename='random')
assert newModel.allocModel.K == self.hmodel.allocModel.K
assert newModel.obsModel.K == self.hmodel.obsModel.K
def test_run_many_merge_moves_changes_nothing_on_true_model(self):
''' Verify run_many_merge_moves method on true model
produces a new model with K=Ktrue components (no merges accepted)
'''
PRNG = np.random.RandomState(12345)
newModel, newSS, ev, MTracker = MergeMove.run_many_merge_moves(
self.hmodel, self.Data, self.SS, nMergeTrials=100, randstate=PRNG)
assert newSS.K == self.SS.K
assert newModel.allocModel.K == self.SS.K
assert newModel.obsModel.K == self.SS.K
assert MTracker.nSuccess == 0
K = self.SS.K
assert MTracker.nTrial == K * (K - 1) / 2
def test_run_many_merge_moves_changes_nothing_on_true_model(self):
''' Verify run_many_merge_moves method on true model
produces a new model with K=Ktrue components (no merges accepted)
'''
PRNG = np.random.RandomState(12345)
newModel, newSS, ev, MTracker = MergeMove.run_many_merge_moves(
self.hmodel, self.Data, self.SS, nMergeTrials=100,
randstate=PRNG)
assert newSS.K == self.SS.K
assert newModel.allocModel.K == self.SS.K
assert newModel.obsModel.K == self.SS.K
assert MTracker.nSuccess == 0
K = self.SS.K
assert MTracker.nTrial == K * (K-1)/2
def test_run_many_merge_moves_dupModel_random(self):
self.MakeModelWithDuplicatedComps()
LP, SS = self.getSuffStatsPrepForMerge(self.dupModel)
PRNG = np.random.RandomState(0)
mergeKwArgs = dict(mergename='random')
a, b, c, MTracker = MergeMove.run_many_merge_moves(self.dupModel,
self.Data, SS,
nMergeTrials=100, randstate=PRNG,
**mergeKwArgs)
assert MTracker.nSuccess == 4
assert (0,4) in MTracker.acceptedOrigIDs
assert (1,5) in MTracker.acceptedOrigIDs
assert (2,6) in MTracker.acceptedOrigIDs
assert (3,7) in MTracker.acceptedOrigIDs
def test_run_merge_move_on_duplicated_comps_succeeds_with_ideal_choice(
self):
''' Verify that merges remove "duplicate" components from dupModel.
when the IDs are of the duplicate pairs are specifically targeted.
Attempt merge move on each pair of known "duplicates",
these are comp IDs (0,3), (1,4), and (2,5)
This is "ideal", since in practice we wont know which comps to merge.
This isolates whether the merges work even in the best of circumstances.
'''
Ktrue = self.hmodel.obsModel.K
for k in range(Ktrue):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel, self.Data, self.dupSS, kA=k, kB=Ktrue + k)
assert newModel.obsModel.K == self.dupModel.obsModel.K - 1
def test_run_many_merge_moves_removes_duplicates(self):
''' Verify run_many_merge_moves method on duplicated model
produces a new model with K=Ktrue components (duplicates gone)
'''
PRNG = np.random.RandomState(12345)
newModel, newSS, ev, MTracker = MergeMove.run_many_merge_moves(
self.dupModel,
self.Data,
self.dupSS,
nMergeTrials=6,
randstate=PRNG)
assert newSS.K == self.SS.K
assert newModel.allocModel.K == self.SS.K
assert newModel.obsModel.K == self.SS.K
def test_run_merge_move_on_dup_comps_succeeds_with_all_ideal_pairs(self):
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
myModel = self.dupModel.copy()
for kA in [3, 2, 1, 0]: # descend backwards so indexing still works
kB = kA + 4 # Ktrue=4, so kA's best match is kA+4
myModel, SS, newEv, MoveInfo = MergeMove.run_merge_move(myModel,
self.Data,
SS,
kA=kA,
kB=kB)
print MoveInfo['msg']
assert MoveInfo['didAccept'] == 1
def test_run_many_merge_moves_dupModel_random(self):
self.MakeModelWithDuplicatedComps()
LP, SS = self.getSuffStatsPrepForMerge(self.dupModel)
PRNG = np.random.RandomState(0)
mergeKwArgs = dict(mergename='random')
a, b, c, MTracker = MergeMove.run_many_merge_moves(self.dupModel,
self.Data,
SS,
nMergeTrials=100,
randstate=PRNG,
**mergeKwArgs)
assert MTracker.nSuccess == 4
assert (0, 4) in MTracker.acceptedOrigIDs
assert (1, 5) in MTracker.acceptedOrigIDs
assert (2, 6) in MTracker.acceptedOrigIDs
assert (3, 7) in MTracker.acceptedOrigIDs
def test_run_merge_move_on_dup_comps_fails_with_nonideal_pairs(self):
''' Given the duplicated comps model,
which has a redundant copy of each "true" component,
We show that deliberately merging each pair does succeed.
This is "ideal" since we know in advance which merge pair to try
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
for Kstep in [1, 2, 3, 5, 6, 7]:
for kA in range(8 - Kstep):
kB = kA + Kstep
newM, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel, self.Data, SS, kA=kA, kB=kB)
print MoveInfo['msg']
assert MoveInfo['didAccept'] == 0
def test_run_merge_move_on_dup_comps_fails_with_nonideal_pairs(self):
''' Given the duplicated comps model,
which has a redundant copy of each "true" component,
We show that deliberately merging each pair does succeed.
This is "ideal" since we know in advance which merge pair to try
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
for Kstep in [1,2,3,5,6,7]:
for kA in range(8 - Kstep):
kB = kA + Kstep
newM, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel,
self.Data, SS, kA=kA, kB=kB)
print MoveInfo['msg']
assert MoveInfo['didAccept'] == 0
def test_select_merge_components_random_seed_reproduceable(self):
''' Run "select_merge_comps" repeatedly, verify it selects same merge pair
when given the same exact random seed
'''
Alist = list()
Blist = list()
for trial in range(10):
kA, kB = MergeMove.select_merge_components(
self.hmodel,
self.Data,
self.SS,
mergename='random',
randstate=np.random.RandomState(0))
Alist.append(kA)
Blist.append(kB)
assert np.all(np.asarray(Alist) == Alist[0])
assert np.all(np.asarray(Blist) == Blist[0])
def test_run_merge_move_on_dup_comps_succeeds_with_each_ideal_pair(self):
''' Given the duplicated comps model,
which has a redundant copy of each "true" component,
We show that deliberately merging each pair does succeed.
This is "ideal" since we know in advance which merge pair to try
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
for kA in [0,1,2,3]:
kB = kA + 4 # Ktrue=4, so kA's best match is kA+4
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel,
self.Data, SS, kA=kA, kB=kB)
print MoveInfo['msg']
assert newModel.allocModel.K == self.dupModel.allocModel.K - 1
assert newModel.obsModel.K == self.dupModel.obsModel.K - 1
assert MoveInfo['didAccept'] == 1
def test_run_merge_move_on_dup_comps_succeeds_with_each_ideal_pair(self):
''' Given the duplicated comps model,
which has a redundant copy of each "true" component,
We show that deliberately merging each pair does succeed.
This is "ideal" since we know in advance which merge pair to try
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
for kA in [0, 1, 2, 3]:
kB = kA + 4 # Ktrue=4, so kA's best match is kA+4
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel, self.Data, SS, kA=kA, kB=kB)
print MoveInfo['msg']
assert newModel.allocModel.K == self.dupModel.allocModel.K - 1
assert newModel.obsModel.K == self.dupModel.obsModel.K - 1
assert MoveInfo['didAccept'] == 1
def test_run_merge_move_duplicated_comps_succeeds_with_marglik_choice(self):
''' Verify that merges remove some "duplicate" comps from dupModel,
when the pairs to merge are chosen via the marglik criterion.
This selection method should produce much better success rate,
than just choosing pairs at random.
'''
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel, self.Data, self.dupSS, mergename='marglik', randstate=PRNG)
if MoveInfo['didAccept']:
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess)/float(nTrial)
print rate
assert rate > 0.8
def test_run_merge_move_on_duplicated_comps_succeeds_with_random_choice(self):
''' Verify that merges remove some "duplicate" comps from dupModel,
even when the pairs to merge are chosen at random.
Also verify that the success rate of merges agrees with theory.
For a dupModel with K=6, out of (6 choose 2) = 15 possible pairs,
exactly 3 produce sensible merges for dupModel (K=6).
Verify that over many random trials where kA,kB drawn uniformly,
we obtain a success rate not too different from 3 / 15 = 0.2.
'''
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel, self.Data, self.dupSS, mergename='random', randstate=PRNG)
if MoveInfo['didAccept']:
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess)/float(nTrial)
assert rate > 0.1
assert rate < 0.3
def test_run_merge_move_on_dup_comps_succeeds_with_marglik_choice(self):
''' Consider Duplicated Comps model.
Use marglik criteria to select candidates kA, kB.
Verify that the merge accept rate is much higher than at random.
The accept rate should actually be near perfect!
'''
self.MakeModelWithDuplicatedComps()
mergeFlags = dict(doPrecompEntropy=True, doPrecompMergeEntropy=True)
LP = self.dupModel.calc_local_params(self.Data)
SS = self.dupModel.get_global_suff_stats(self.Data, LP, **mergeFlags)
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(self.dupModel, self.Data, SS, mergename='marglik', randstate=PRNG)
print MoveInfo['msg']
if MoveInfo['didAccept']:
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess)/float(nTrial)
print "Expected rate: >.95"
print "Measured rate: %.3f" % (rate)
assert rate > 0.95
def test_run_merge_move_duplicated_comps_succeeds_with_marglik_choice(
self):
''' Verify that merges remove some "duplicate" comps from dupModel,
when the pairs to merge are chosen via the marglik criterion.
This selection method should produce much better success rate,
than just choosing pairs at random.
'''
nTrial = 100
nSuccess = 0
PRNG = np.random.RandomState(0)
for trial in range(nTrial):
newModel, newSS, newEv, MoveInfo = MergeMove.run_merge_move(
self.dupModel,
self.Data,
self.dupSS,
mergename='marglik',
randstate=PRNG)
if MoveInfo['didAccept']:
nSuccess += 1
assert nSuccess > 0
rate = float(nSuccess) / float(nTrial)
print rate
assert rate > 0.8
def test_select_merge_components_random_in_bounds(self): kA, kB = MergeMove.select_merge_components(self.hmodel, self.Data, self.SS, mergename='random') self.verify_selected_component_ids(kA, kB)
def test_select_merge_components_random_in_bounds(self):
kA, kB = MergeMove.select_merge_components(self.hmodel,
self.Data,
self.SS,
mergename='random')
self.verify_selected_component_ids(kA, kB)
