예제 #1
0
    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
예제 #2
0
    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
예제 #3
0
    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
예제 #4
0
    def calc_error(truth_dict):
        X = truth_dict['data']
        Y = truth_dict['labels']

        expected = truth_dict['prior_mean']
        predicted = optimize_maximum_likelihood(X, Y)[0]

        error = calc_mean_squared_error(expected, predicted, as_log=True)

        return error
예제 #5
0
    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
예제 #6
0
    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
예제 #7
0
    def calc_error(truth_dict):
        data = truth_dict['data']
        labels = truth_dict['labels']

        S_b, S_w = calc_scatter_matrices(data, labels)
        n = truth_dict['n_k']

        expected = truth_dict['Phi_b']
        predicted = S_b - S_w / (n - 1)

        error = calc_mean_squared_error(expected, predicted, as_log=True)

        return error
예제 #8
0
    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
예제 #9
0
    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
예제 #10
0
    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
예제 #11
0
    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