def __init__(
self,
param_list,
head: Optional[nn.Module] = DefaultHead,
tail: Optional[nn.Module] = DefaultTail,
head_args={},
tail_args={},
device: Device = "cpu",
):
"""RatioEstimator takes simulated points from the iP3 sample store and handles training and posterior calculation.
Args:
points: points dataset from the iP3 sample store
head: initialized module which processes observations, head(x0) = y
previous_ratio_estimator: ratio estimator from another round. if given, reuse head.
device: default is cpu
statistics: x_mean, x_std, z_mean, z_std
"""
self.param_list = format_param_list(param_list)
self._device = device
if isinstance(head, type):
self._uninitialized_head = head
self._uninitialized_head_args = head_args
self.head = None
else:
self.head = deepcopy(head).to(device)
if isinstance(head, type):
self._uninitialized_tail = tail
self._uninitialized_tail_args = tail_args
self.tail = None
else:
self.tail = deepcopy(tail).to(device)
self._train_diagnostics = []
def __init__(
self,
partitions,
prior,
obs,
store=None,
simhook=None,
device="cpu",
Ninit=3000,
Nmax=100000,
head=DefaultHead,
tail=DefaultTail,
density_factor=2.0,
train_args: dict = {},
head_args: dict = {},
tail_args: dict = {},
log_volume_convergence_threshold=0.1,
):
"""Initialize swyft.
Args:
prior (Prior): Prior model.
obs (dict): Target observation
noise (function): Noise model, optional.
store (Store): Storage for simulator results. If none, create MemoryStore.
Ninit (int): Initial number of training points.
Nmax (int): Maximum number of training points per round.
density_factor (float > 1): Increase of training point density per round.
log_volume_convergence_threshold (float > 0.): Convergence threshold measured as difference between log prior volume to log contrainted prior volume.
device (str): Device.
"""
assert density_factor > 1.0
assert log_volume_convergence_threshold > 0.0
if not all_finite(obs):
raise ValueError("obs must be finite.")
# Not stored
self._simhook = simhook
self._store = store
self._device = device
self._status = 0
self._partitions = format_param_list(partitions)
# Stored in state_dict()
self._obs = obs
self._config = dict(
Ninit=Ninit,
Nmax=Nmax,
train_args=train_args,
head_args=head_args,
tail_args=tail_args,
head=head,
tail=tail,
)
self._initial_prior = prior # Initial prior
self._datasets = []
self._posteriors = []
self._next_priors = []
def __init__(
self,
partitions,
prior,
obs,
store=None,
simhook=None,
device="cpu",
Ninit=3000,
head=DefaultHead,
tail=DefaultTail,
new_simulation_factor: float = 1.5,
new_simulation_term: int = 0,
convergence_ratio=0.8,
epsilon_threshold=-13,
train_args: dict = {},
head_args: dict = {},
tail_args: dict = {},
):
"""Initialize swyft.
next_round_num_samples = new_simulation_factor * last_round_num_samples + new_simulation_term
Args:
partitions,
prior (Prior): Prior model.
obs (dict): Target observation
store (Store): Storage for simulator results. If none, create MemoryStore.
simhook (function): Noise model, optional.
device (str): Device.
Ninit (int): Initial number of training points.
head
tail
new_simulation_factor (float >= 1)
new_simulation_term (int >= 0)
convergence_ratio (float > 0.): Convergence ratio between new_volume / old_volume.
epsilon_threshold: log ratio cutoff
"""
assert new_simulation_factor >= 1.0
assert new_simulation_term >= 0
assert convergence_ratio > 0.0
if not all_finite(obs):
raise ValueError("obs must be finite.")
# Not stored
self._simhook = simhook
self._store = store
self._device = device
self._status = 0
self._partitions = format_param_list(partitions)
# Stored in state_dict()
self._obs = obs
self._config = dict(
Ninit=Ninit,
train_args=train_args,
head_args=head_args,
tail_args=tail_args,
head=head,
tail=tail,
convergence_ratio=convergence_ratio,
new_simulation_factor=new_simulation_factor,
new_simulation_term=new_simulation_term,
epsilon_threshold=epsilon_threshold,
)
self._initial_prior = prior # Initial prior
self._datasets = []
self._posteriors = []
self._next_priors = []
self._initial_n_simulations = len(store)
self._n_simulations = []