def _get_sample(self, number_samples, resample=False, observed=False, input_values={}, differentiable=True):
if self in input_values:
value = input_values[self]
else:
value = self.value
if not is_discrete(value):
return {self: tile_parameter(value, number_samples=number_samples)}
else:
return {self: value}
def _get_sample(self, differentiable, **parameters):
"""
One line description
Parameters
----------
Returns
-------
Without replacement
"""
dataset = parameters["dataset"]
if "indices" not in parameters:
if "weights" in parameters:
weights = parameters["weights"]
p = np.array(weights).astype("float64")
p = p/np.sum(p)
else:
p = None
if is_tensor(dataset):
if self.is_observed:
dataset_size = dataset.shape[1]
else:
dataset_size = dataset.shape[2]
else:
dataset_size = len(dataset)
if dataset_size < self.batch_size:
raise ValueError("It is impossible to have more samples than the size of the dataset without replacement")
if is_discrete(dataset): #
indices = np.random.choice(range(dataset_size), size=self.batch_size, replace=False, p=p)
else:
number_samples = dataset.shape[0]
indices = [np.random.choice(range(dataset_size), size=self.batch_size, replace=False, p=p)
for _ in range(number_samples)]
else:
indices = parameters["indices"]
if is_tensor(dataset):
if isinstance(indices, list) and isinstance(indices[0], np.ndarray):
if self.is_observed:
sample = torch.cat([dataset[n, k, :].unsqueeze(dim=0) for n, k in enumerate(indices)], dim=0)
else:
sample = torch.cat([dataset[n, :, k, :].unsqueeze(dim=0) for n, k in enumerate(indices)], dim=0)
elif isinstance(indices, list) and isinstance(indices[0], (int, np.int32, np.int64)):
if self.is_observed:
sample = dataset[:, indices, :]
else:
sample = dataset[:, :, indices, :]
else:
raise IndexError("The indices of an empirical variable should be either a list of integers or a list of arrays")
else:
sample = list(np.array(dataset)[indices])
return sample
def _apply_link(self, parents_values):
number_samples, number_datapoints = get_number_samples_and_datapoints(parents_values)
cont_values, discrete_values = split_dict(parents_values,
condition=lambda key, val: not is_discrete(val) or contains_tensors(val))
reshaped_dict = discrete_values
if cont_values:
reshaped_dict.update(map_iterable(lambda x: broadcast_and_reshape_parent_value(x, number_samples, number_datapoints),
cont_values, recursive=True))
reshaped_output = self.link(reshaped_dict)
cast_to_new_shape = lambda tensor: tensor.view(size=(number_samples, number_datapoints) + tensor.shape[1:])
output = {key: cast_to_new_shape(val)
if is_tensor(val) else map_iterable(cast_to_new_shape, val) if contains_tensors(val) else val
for key, val in reshaped_output.items()}
return output
def _get_sample(self,
number_samples,
resample=False,
observed=False,
input_values={}):
if self in input_values:
value = input_values[self]
else:
value = self.value
if not is_discrete(value):
return {self: tile_parameter(value, number_samples=number_samples)}
else:
return {
self: value
} #TODO: This is for allowing discrete data, temporary? (for Julia)
def _apply_link(
self, parents_values
): #TODO: This is for allowing discrete data, temporary? (for julia) #For Julia: Very important method
cont_values, discrete_values = split_dict(
parents_values, condition=lambda key, val: not is_discrete(val))
if cont_values:
reshaped_dict, number_samples, number_datapoints = broadcast_parent_values(
cont_values)
reshaped_dict.update(discrete_values)
else:
reshaped_dict = discrete_values
reshaped_output = self.link(reshaped_dict)
output = {
key: val.view(size=(number_samples, number_datapoints) +
val.shape[1:]) if is_tensor(val) else val
for key, val in reshaped_output.items()
}
return output
def __init__(self, data, name, learnable=False, is_observed=False):
self.name = name
self.distribution = distributions.DeterministicDistribution()
self._evaluated = False
self._observed = is_observed
self.parents = set()
self.ancestors = set()
self._type = "Deterministic"
self.learnable = learnable
self.link = None
self._value = coerce_to_dtype(data, is_observed)
if self.learnable:
if not is_discrete(data):
self._value = torch.nn.Parameter(coerce_to_dtype(data, is_observed), requires_grad=True)
self.link = ParameterModule(self._value) # add to optimizer; opt checks links
else:
self.learnable = False
warnings.warn('Currently discrete parameters are not learnable. Learnable set to False')
def get_sample(self, dataset, indices, number_samples, weights=None):
"""
One line description
Parameters
----------
Returns
-------
Without replacement
"""
if not indices:
if weights:
p = np.array(weights).astype("float64")
p = p / np.sum(p)
else:
p = None
if is_tensor(dataset):
if self.is_observed:
dataset_size = dataset.shape[1]
else:
dataset_size = dataset.shape[2]
else:
dataset_size = len(dataset)
if dataset_size < self.batch_size:
raise ValueError(
"It is impossible to have more samples than the size of the dataset without replacement"
)
if is_discrete(
dataset
): # TODO: This is for allowing discrete data, temporary?
indices = np.random.choice(range(dataset_size),
size=self.batch_size,
replace=False,
p=p)
else:
indices = [
np.random.choice(range(dataset_size),
size=self.batch_size,
replace=False,
p=p) for _ in range(number_samples)
]
if is_tensor(dataset):
if isinstance(indices, list) and isinstance(
indices[0], np.ndarray):
if self.is_observed:
# sample = F.concat([F.expand_dims(dataset[n, k, :], axis=0) for n, k in enumerate(indices)], axis=0)
sample = torch.cat([
dataset[n, k, :].unsqueeze(dim=0)
for n, k in enumerate(indices)
],
dim=0)
else:
# sample = F.concat([F.expand_dims(dataset[n, :, k, :], axis=0) for n, k in enumerate(indices)], axis=0)
sample = torch.cat([
dataset[n, :, k, :].unsqueeze(dim=0)
for n, k in enumerate(indices)
],
dim=0)
elif isinstance(indices, list) and isinstance(
indices[0], (int, np.int32, np.int64)):
if self.is_observed:
sample = dataset[:, indices, :]
else:
sample = dataset[:, :, indices, :]
else:
raise IndexError(
"The indices of an empirical variable should be either a list of integers or a list of arrays"
)
else:
sample = list(
np.array(dataset)[indices]
) # TODO: This is for allowing discrete data, temporary? For julia
return sample
