def run_prior(self,
n_train=100,
epochs=100,
minibatch=50,
n_atoms=None,
moo=None,
train_on_all=False,
round_cl=1,
stop_on_nan=False,
monitor=None,
verbose=False,
print_each_epoch=False,
patience=20,
monitor_every=None,
reuse_prior_samples=True,
**kwargs):
# simulate data
self.generator.proposal = self.generator.prior
trn_data, n_train_round = self.gen(n_train)
self.trn_datasets.append(trn_data)
if train_on_all and reuse_prior_samples:
prior_datasets = [
d for i, d in enumerate(self.trn_datasets)
if self.proposal_used[i] == 'prior'
]
trn_data = combine_trn_datasets(prior_datasets)
n_train_round = trn_data[0].shape[0]
# train network
self.loss, trn_inputs = self.define_loss(n=n_train_round,
round_cl=round_cl,
proposal='prior')
t = Trainer(self.network,
self.loss,
trn_data=trn_data,
trn_inputs=trn_inputs,
seed=self.gen_newseed(),
monitor=self.monitor_dict_from_names(monitor),
**kwargs)
log = t.train(epochs=self.epochs_round(epochs),
minibatch=minibatch,
verbose=verbose,
print_each_epoch=print_each_epoch,
stop_on_nan=stop_on_nan,
patience=patience,
monitor_every=monitor_every)
return log, trn_data
def run_atomic(self,
n_train=100,
epochs=100,
minibatch=50,
n_atoms=10,
moo='resample',
train_on_all=False,
reuse_prior_samples=True,
combined_loss=False,
round_cl=1,
stop_on_nan=False,
monitor=None,
verbose=False,
**kwargs):
# activetrainer doesn't de-norm params before evaluating the prior
assert np.all(self.params_mean == 0.0) \
and np.all(self.params_std == 1.0), "prior_norm+atomic not OK"
assert minibatch > 1, "minimum minibatch size 2 for atomic proposals"
if n_atoms is None:
n_atoms = minibatch - 1 if theano.config.device.startswith(
'cuda') else np.minimum(minibatch - 1, 9)
assert n_atoms < minibatch, "Minibatch too small for this many atoms"
# simulate data
self.set_proposal()
trn_data, n_train_round = self.gen(n_train)
self.trn_datasets.append(trn_data) # don't store prior_masks
if train_on_all:
if reuse_prior_samples:
trn_data = combine_trn_datasets(self.trn_datasets,
max_inputs=2)
else:
trn_data = combine_trn_datasets([
td for td, pu in zip(self.trn_datasets, self.proposal_used)
if pu != 'prior'
])
if combined_loss:
prior_masks = \
[np.ones(td[0].shape[0], dtype) * (pu == 'prior')
for td, pu in zip(self.trn_datasets, self.proposal_used)]
trn_data = (*trn_data, np.concatenate(prior_masks))
n_train_round = trn_data[0].shape[0]
# train network
self.loss, trn_inputs = self.define_loss(n=n_train_round,
round_cl=round_cl,
proposal='atomic',
combined_loss=combined_loss)
t = ActiveTrainer(self.network,
self.loss,
trn_data=trn_data,
trn_inputs=trn_inputs,
seed=self.gen_newseed(),
monitor=self.monitor_dict_from_names(monitor),
generator=self.generator,
n_atoms=n_atoms,
moo=moo,
obs=(self.obs - self.stats_mean) / self.stats_std,
**kwargs)
log = t.train(epochs=self.epochs_round(epochs),
minibatch=minibatch,
stop_on_nan=stop_on_nan,
verbose=verbose,
strict_batch_size=True)
return log, trn_data
def run_gaussian(self,
n_train=100,
epochs=100,
minibatch=50,
n_atoms=None,
moo=None,
train_on_all=False,
round_cl=1,
stop_on_nan=False,
monitor=None,
verbose=False,
reuse_prior_samples=True,
**kwargs):
# simulate data
self.set_proposal(project_to_gaussian=True)
prop = self.generator.proposal
assert isinstance(prop, dd.Gaussian)
trn_data, n_train_round = self.gen(n_train)
# here we're just repeating the same fixed proposal, though we
# could also introduce some variety if we wanted.
prop_m = np.expand_dims(prop.m, 0).repeat(n_train_round, axis=0)
prop_P = np.expand_dims(prop.P, 0).repeat(n_train_round, axis=0)
trn_data = (*trn_data, prop_m, prop_P)
self.trn_datasets.append(trn_data)
if train_on_all:
prev_datasets = []
for i, d in enumerate(self.trn_datasets):
if self.proposal_used[i] == 'gaussian':
prev_datasets.append(d)
continue
elif self.proposal_used[
i] != 'prior' or not reuse_prior_samples:
continue
# prior samples. the Gauss loss will reduce to the prior loss
if isinstance(self.generator.prior, dd.Gaussian):
prop_m = self.generator.prior.mean
prop_P = self.generator.prior.P
elif isinstance(self.generator.prior, dd.Uniform):
# model a uniform as an zero-precision Gaussian:
prop_m = np.zeros(self.generator.prior.ndim, dtype)
prop_P = np.zeros(
(self.generator.prior.ndim, self.generator.prior.ndim),
dtype)
else: # can't reuse prior samples unless prior is uniform or Gaussian
continue
prop_m = np.expand_dims(prop_m, 0).repeat(d[0].shape[0],
axis=0)
prop_P = np.expand_dims(prop_P, 0).repeat(d[0].shape[0],
axis=0)
prev_datasets.append((*d, prop_m, prop_P))
trn_data = combine_trn_datasets(prev_datasets)
n_train_round = trn_data[0].shape[0]
# train network
self.loss, trn_inputs = self.define_loss(n=n_train_round,
round_cl=round_cl,
proposal='gaussian')
t = Trainer(self.network,
self.loss,
trn_data=trn_data,
trn_inputs=trn_inputs,
seed=self.gen_newseed(),
monitor=self.monitor_dict_from_names(monitor),
**kwargs)
log = t.train(epochs=self.epochs_round(epochs),
minibatch=minibatch,
verbose=verbose,
stop_on_nan=stop_on_nan)
return log, trn_data
def run_MoG(self,
n_train=100,
epochs=100,
minibatch=50,
n_atoms=None,
moo=None,
train_on_all=False,
round_cl=1,
stop_on_nan=False,
monitor=None,
verbose=False,
print_each_epoch=False,
reuse_prior_samples=True,
patience=20,
monitor_every=None,
**kwargs):
# simulate data
self.set_proposal(project_to_gaussian=False)
assert isinstance(self.generator.proposal, dd.MoG)
prop = self.generator.proposal.ztrans(self.params_mean,
self.params_std)
trn_data, n_train_round = self.gen(n_train)
trn_data = (*trn_data, *MoG_prop_APT_training_vars(
prop, n_train_round, prop.n_components))
self.trn_datasets.append(trn_data)
if train_on_all:
prev_datasets = []
for i, d in enumerate(self.trn_datasets):
if self.proposal_used[i] == 'mog':
prev_datasets.append(d)
elif self.proposal_used == 'prior' and reuse_prior_samples:
prior = self.generator.prior
if not isinstance(prior, dd.Uniform):
prior = prior.ztrans(self.params_mean, self.params_std)
d = (*d, *MoG_prop_APT_training_vars(prior, n_train_round))
prev_datasets.append(d)
elif self.proposal_used[i] == 'gaussian':
params, stats, prop_m, prop_P = d
if np.diff(prop_m, axis=0).any() or np.diff(prop_P,
axis=0).any():
continue # reusing samples with proposals that changed within a round is not yet supported
prop = dd.Gaussian(m=prop_m[0], P=prop_P[0])
d = (params, stats,
*MoG_prop_APT_training_vars(prop, n_train_round))
prev_datasets.append(d)
else: # can't re-use samples from this proposal
continue
trn_data = combine_trn_datasets(prev_datasets)
n_train_round = trn_data[0].shape[0]
self.loss, trn_inputs = self.define_loss(n=n_train_round,
round_cl=round_cl,
proposal='mog')
t = Trainer(self.network,
self.loss,
trn_data=trn_data,
trn_inputs=trn_inputs,
seed=self.gen_newseed(),
monitor=self.monitor_dict_from_names(monitor),
**kwargs)
log = t.train(epochs=self.epochs_round(epochs),
minibatch=minibatch,
verbose=verbose,
print_each_epoch=print_each_epoch,
stop_on_nan=stop_on_nan,
patience=patience,
monitor_every=monitor_every)
return log, trn_data
