def test_getters(laue_inputs, mono_inputs):
for inputs in laue_inputs, mono_inputs:
if BaseModel.is_laue(inputs):
BaseModel.get_harmonic_id(inputs)
BaseModel.get_wavelength(inputs)
BaseModel.get_image_id(inputs)
BaseModel.get_intensities(inputs)
BaseModel.get_metadata(inputs)
BaseModel.get_refl_id(inputs)
BaseModel.get_uncertainties(inputs)
def test_laue_StudentTLikelihood(dof, laue_inputs):
likelihood = StudentTLikelihood(dof)(laue_inputs)
iobs = BaseModel.get_intensities(laue_inputs)
sigiobs = BaseModel.get_uncertainties(laue_inputs)
ipred = fake_ipred(laue_inputs)
l_true = tfd.StudentT(dof, iobs, sigiobs)
iconv = likelihood.convolve(ipred)
test = likelihood.log_prob(ipred).numpy()
expected = l_true.log_prob(iobs).numpy()
nobs = BaseModel.get_harmonic_id(laue_inputs).max() + 1
test = likelihood.log_prob(ipred).numpy()
expected = l_true.log_prob(iobs).numpy().T
#The zero padded entries at the end of the input will disagree
#with the expected values. This is fine, because they will not
#contribute to the gradient
test = test[:, :nobs]
expected = expected[:, :nobs]
assert np.array_equal(expected.shape, test.shape)
assert np.allclose(expected, test)
#Test batches larger than 1
ipred = np.concatenate((ipred, ipred, ipred), axis=0)
likelihood.convolve(ipred).numpy()
test = likelihood.log_prob(ipred).numpy()
test = test[:, :nobs]
assert np.array_equiv(expected, test)
def split_data_by_refl(self, test_fraction=0.5):
"""
Method for splitting data given a boolean mask.
Parameters
----------
test_fraction : float (optional)
The fraction of reflections which will be reserved for testing.
Returns
-------
train : tuple
test : tuple
"""
if BaseModel.is_laue(self.inputs):
harmonic_id = BaseModel.get_harmonic_id(self.inputs)
test_idx = (np.random.random(harmonic_id.max() + 1) <=
test_fraction)[harmonic_id]
train, test = self.split_laue_data_by_mask(test_idx)
#return self.get_tf_dataset(train), self.get_tf_dataset(test)
return train, test
test_idx = np.random.random(len(self.inputs[0])) <= test_fraction
train, test = self.split_mono_data_by_mask(test_idx)
#return self.get_tf_dataset(train), self.get_tf_dataset(test)
return train, test
def split_laue_data_by_mask(self, test_idx):
"""
Method for splitting laue data given a boolean mask.
This method will split up the data and alter the harmonic_id
column to reflect the decrease in size of the array.
Parameters
----------
test_idx : array (boolean)
Boolean array with length of inputs.
Returns
-------
train : tuple
test : tuple
"""
harmonic_id = BaseModel.get_harmonic_id(self.inputs)
# Let us just test that the boolean mask is valid for these data.
# If it does not split observations, isect should be empty
isect = np.intersect1d(
harmonic_id[test_idx].flatten(),
harmonic_id[~test_idx].flatten(),
)
if len(isect) > 0:
raise ValueError(
f"test_idx splits harmonic observations with harmonic_id : {isect}"
)
def split(inputs, idx):
harmonic_id = BaseModel.get_harmonic_id(inputs)
result = ()
uni, inv = np.unique(harmonic_id[idx], return_inverse=True)
for i, v in enumerate(inputs):
name = BaseModel.get_name_by_index(i)
if name in ('intensities', 'uncertainties'):
v = v[uni]
v = np.pad(v, [[0, len(inv) - len(v)], [0, 0]],
constant_values=1.)
elif name == 'harmonic_id':
v = inv[:, None]
else:
v = v[idx.flatten(), ...]
result += (v, )
return result
return split(self.inputs, ~test_idx), split(self.inputs, test_idx)
def split(inputs, idx):
harmonic_id = BaseModel.get_harmonic_id(inputs)
result = ()
uni, inv = np.unique(harmonic_id[idx], return_inverse=True)
for i, v in enumerate(inputs):
name = BaseModel.get_name_by_index(i)
if name in ('intensities', 'uncertainties'):
v = v[uni]
v = np.pad(v, [[0, len(inv) - len(v)], [0, 0]],
constant_values=1.)
elif name == 'harmonic_id':
v = inv[:, None]
else:
v = v[idx.flatten(), ...]
result += (v, )
return result
def fake_ipred(inputs):
harmonic_id = BaseModel.get_harmonic_id(inputs).flatten()
intensities = BaseModel.get_intensities(inputs).flatten()
result = intensities[harmonic_id] / np.bincount(harmonic_id)[harmonic_id]
return result[None, :].astype('float32')