def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
Phi_w = truth_dict['Phi_w']
likelihood_means = truth_dict['means']
dim = Phi_w.shape[0]
test_data = np.random.randint(-100, 100, (10, dim))
expected = []
predicted = []
for mean, label in zip(truth_dict['means'], truth_dict['labels']):
true_logps = gaussian(mean, Phi_w).logpdf(test_data)
true_logps -= logsumexp(true_logps)
test_U = model.transform(test_data, 'D', 'U_model')
predicted_logps = model.calc_logp_posterior_predictive(
test_U, label)
predicted_logps -= logsumexp(predicted_logps)
expected.append(true_logps)
predicted.append(predicted_logps)
expected = np.asarray(expected)
predicted = np.asarray(predicted)
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def test_calc_same_diff_likelihood_ratio():
np.random.seed(1234)
n_k = 100
K = 7
dim = 10
data_dictionary = generate_data(n_k, K, dim)
X_train = data_dictionary['data'][:500]
Y = data_dictionary['labels'][:500]
model = plda.Model(X_train, Y)
X_infer_category_1 = data_dictionary['data'][500:600]
X_infer_category_1 = model.transform(X_infer_category_1, 'D', 'U_model')
X_infer_category_2 = data_dictionary['data'][600:]
X_infer_category_2 = model.transform(X_infer_category_2, 'D', 'U_model')
similarity_1v2 = model.calc_same_diff_likelihood_ratio(X_infer_category_1, X_infer_category_2)
similarity_2v2 = model.calc_same_diff_likelihood_ratio(
X_infer_category_2[:50],
X_infer_category_2[50:]
)
assert_almost_equal(similarity_1v2, -46868.44557534719)
assert_almost_equal(similarity_2v2, 29.917954937414834)
def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
expected = truth_dict['Phi_w']
predicted = np.matmul(model.A, model.A.T)
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
expected = truth_dict['prior_mean']
predicted = model.m
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
dim = truth_dict['data'].shape[-1]
Phi_b = truth_dict['Phi_b']
expected = Phi_b
predicted = np.matmul(model.A, model.Psi)
predicted = np.matmul(predicted, model.A.T)
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
Phi_w = truth_dict['Phi_w']
Phi_b = truth_dict['Phi_b']
expected = Phi_b
predicted = np.matmul(Phi_w, model.Psi)
error = calc_mean_squared_error(expected, predicted, as_log=True)
print(error)
return error
def calc_off_diagonal_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
dim = truth_dict['data'].shape[-1]
Phi_w = truth_dict['Phi_w']
expected = np.zeros((dim, dim))
predicted = np.matmul(model.inv_A, Phi_w)
predicted = np.matmul(predicted, model.inv_A.T)
predicted[range(dim), range(dim)] = 0
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def calc_diagonal_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
dim = truth_dict['data'].shape[-1]
Phi_w = truth_dict['Phi_w']
expected = np.ones(dim)
predicted = np.matmul(model.inv_A, Phi_w)
predicted = np.matmul(predicted, model.inv_A.T)
predicted = np.diag(predicted)
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def test_pca(data_dict, model):
# When data has a full rank covariance matrix.
assert model.pca is None
# When the data does NOT have a full rank covariance matrix.
shape = data_dict['data'].shape
data = np.zeros((shape[0], shape[1] + 10))
data[:, :shape[1]] = data_dict['data']
actual = plda.Model(data, data_dict['labels'])
assert actual.pca is not None
assert isinstance(actual.pca, PCA)
assert actual.pca.n_features_ == data.shape[1]
assert actual.pca.n_components == shape[1]
def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
expected = truth_dict['means']
predicted = []
for k, params in model.posterior_params.items():
predicted.append(params['mean'])
predicted = np.asarray(predicted)
predicted = model.transform(predicted, from_space='U_model',
to_space='D')
error = calc_mean_squared_error(expected, predicted, as_log=True)
return error
def calc_error(truth_dict):
model = plda.Model(truth_dict['data'], truth_dict['labels'])
Phi_b = truth_dict['Phi_b']
prior_mean = truth_dict['prior_mean']
dim = prior_mean.shape[0]
random_vectors = np.random.randint(-100, 100, (10, dim))
expected = gaussian(prior_mean, Phi_b).logpdf(random_vectors)
latent_vectors = model.transform(random_vectors, 'D', 'U_model')
predicted = model.calc_logp_prior(latent_vectors)
error = calc_mean_squared_error(expected, predicted, as_log=True)
print(error)
return error
def test_transform(data_dict, model):
# When training data does have a full rank covariance matrix.
# D to U_model.
X = data_dict['data']
expected = transform_D_to_X(X, model.pca)
expected = transform_X_to_U(expected, model.inv_A, model.m)
expected = transform_U_to_U_model(expected, model.relevant_U_dims)
actual = model.transform(X, from_space='D', to_space='U_model')
assert_allclose(actual, expected)
# U_model to D.
dim = model.get_dimensionality('U')
expected = transform_U_model_to_U(actual, model.relevant_U_dims, dim)
expected = transform_U_to_X(expected, model.A, model.m)
expected = transform_X_to_D(expected, model.pca)
actual = model.transform(actual, from_space='U_model', to_space='D')
# When training data does not have a full rank covariance matrix.
# D to U_model.
shape = data_dict['data'].shape
data = np.zeros((shape[0], shape[1] + 10))
data[:, :shape[1]] = data_dict['data']
tmp_model = plda.Model(data, data_dict['labels'])
expected = transform_D_to_X(data, tmp_model.pca)
expected = transform_X_to_U(expected, tmp_model.inv_A, tmp_model.m)
expected = transform_U_to_U_model(expected, tmp_model.relevant_U_dims)
actual = tmp_model.transform(data, from_space='D', to_space='U_model')
assert_allclose(actual, expected)
# U_model to D.
dim = tmp_model.get_dimensionality('U')
expected = transform_U_model_to_U(actual, tmp_model.relevant_U_dims, dim)
expected = transform_U_to_X(expected, tmp_model.A, tmp_model.m)
expected = transform_X_to_D(expected, tmp_model.pca)
actual = model.transform(actual, from_space='U_model', to_space='D')
def test_get_dimensionality(data_dict, model):
# When data has a full rank covariance matrix.
dim = data_dict['data'].shape[1]
K = len(data_dict['means'])
assert model.get_dimensionality('D') == dim
assert model.get_dimensionality('X') == dim
assert model.get_dimensionality('U') == dim
assert model.get_dimensionality('U_model') == K - 1
# When the data does NOT have a full rank covariance matrix.
shape = data_dict['data'].shape
data = np.zeros((shape[0], shape[1] + 10))
data[:, :shape[1]] = data_dict['data']
actual = plda.Model(data, data_dict['labels'])
assert actual.get_dimensionality('D') == data.shape[-1]
assert actual.get_dimensionality('X') == dim
assert actual.get_dimensionality('U') == dim
assert actual.get_dimensionality('U_model') == K - 1
def test_calc_logp_mariginal_likelihood():
np.random.seed(1234)
n_k = 100
K = 5
dim = 10
data_dictionary = generate_data(n_k, K, dim)
X = data_dictionary['data']
Y = data_dictionary['labels']
model = plda.Model(X, Y)
prior_mean = model.prior_params['mean']
prior_cov_diag = model.prior_params['cov_diag']
logpdf = gaussian(prior_mean, np.diag(prior_cov_diag + 1)).logpdf
data = np.random.random((n_k, prior_mean.shape[-1]))
expected_logps = logpdf(data)
actual_logps = model.calc_logp_marginal_likelihood(data[:, None])
assert_allclose(actual_logps, expected_logps)
def model(data_dict):
return plda.Model(data_dict['data'], data_dict['labels'])
