double gsl_cdf_lognormal_Qinv (const double Q, const double zeta, const double sigma) { double x, u; if (Q == 0.0) { return GSL_POSINF; } else if (Q == 1.0) { return 0.0; } u = gsl_cdf_ugaussian_Qinv (Q); x = exp (zeta + sigma * u); return x; }
void test_sparse_als_zero_order_only(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int k = 0; ffm_param param = {.n_iter = 1, .warm_start = true, .ignore_w = true, .init_sigma = 0.1, .SOLVER = SOLVER_ALS, .TASK = TASK_REGRESSION}; ffm_coef *coef = alloc_fm_coef(n_features, k, true); param.init_lambda_w = 0; sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); // g_assert_cmpfloat(4466.666666, ==, coef->w_0); g_assert_cmpfloat(fabs(4466.666666 - coef->w_0), <, 1e-6); free_ffm_coef(coef); } void test_sparse_als_first_order_only(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int k = 0; ffm_param param = {.n_iter = 1, .warm_start = true, .ignore_w_0 = true, .init_sigma = 0.1, .SOLVER = SOLVER_ALS, .TASK = TASK_REGRESSION}; ffm_coef *coef = alloc_fm_coef(n_features, k, false); coef->w_0 = 0; param.init_lambda_w = 0; ffm_vector_set(coef->w, 0, 10); ffm_vector_set(coef->w, 1, 20); sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); // hand calculated results 1660.57142857 -11.87755102 g_assert_cmpfloat(fabs(1660.57142857 - ffm_vector_get(coef->w, 0)), <, 1e-8); g_assert_cmpfloat(fabs(-11.87755102 - ffm_vector_get(coef->w, 1)), <, 1e-8); free_ffm_coef(coef); } void test_sparse_als_second_order_only(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int k = 1; ffm_param param = {.n_iter = 1, .warm_start = true, .ignore_w_0 = true, .ignore_w = true, .init_sigma = 0.1, .SOLVER = SOLVER_ALS, .TASK = TASK_REGRESSION}; ffm_coef *coef = alloc_fm_coef(n_features, k, false); coef->w_0 = 0; param.init_lambda_w = 0; param.init_lambda_V = 0; ffm_matrix_set(coef->V, 0, 0, 300); ffm_matrix_set(coef->V, 0, 1, 400); sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); // hand calculated results 0.79866412 400. g_assert_cmpfloat(fabs(0.79866412 - ffm_matrix_get(coef->V, 0, 0)), <, 1e-8); g_assert_cmpfloat(fabs(400 - ffm_matrix_get(coef->V, 0, 1)), <, 1e-8); free_ffm_coef(coef); } void test_sparse_als_all_interactions(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int k = 1; ffm_param param = {.n_iter = 1, .warm_start = true, .ignore_w_0 = false, .ignore_w = false, .init_sigma = 0.1, .SOLVER = SOLVER_ALS, .TASK = TASK_REGRESSION}; ffm_coef *coef = alloc_fm_coef(n_features, k, false); coef->w_0 = 0; ffm_vector_set(coef->w, 0, 10); ffm_vector_set(coef->w, 1, 20); ffm_matrix_set(coef->V, 0, 0, 300); ffm_matrix_set(coef->V, 0, 1, 400); sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); // hand calculated results checked with libfm g_assert_cmpfloat(fabs(-1755643.33333 - coef->w_0), <, 1e-5); g_assert_cmpfloat(fabs(-191459.71428571 - ffm_vector_get(coef->w, 0)), <, 1e-6); g_assert_cmpfloat(fabs(30791.91836735 - ffm_vector_get(coef->w, 1)), <, 1e-6); g_assert_cmpfloat(fabs(253.89744249 - ffm_matrix_get(coef->V, 0, 0)), <, 1e-6); g_assert_cmpfloat(fabs(400 - ffm_matrix_get(coef->V, 0, 1)), <, 1e-6); param.n_iter = 99; sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); g_assert_cmpfloat(fabs(210911.940403 - coef->w_0), <, 1e-7); g_assert_cmpfloat(fabs(-322970.68313639 - ffm_vector_get(coef->w, 0)), <, 1e-6); g_assert_cmpfloat(fabs(51927.60978978 - ffm_vector_get(coef->w, 1)), <, 1e-6); g_assert_cmpfloat(fabs(94.76612018 - ffm_matrix_get(coef->V, 0, 0)), <, 1e-6); g_assert_cmpfloat(fabs(400 - ffm_matrix_get(coef->V, 0, 1)), <, 1e-6); free_ffm_coef(coef); } void test_sparse_als_first_order_interactions(TestFixture_T *pFix, gconstpointer pg) { ffm_vector *y_pred = ffm_vector_calloc(5); int n_features = pFix->X->n; int k = 0; ffm_coef *coef = alloc_fm_coef(n_features, k, false); ffm_param param = {.n_iter = 500, .init_sigma = 0.1, .SOLVER = SOLVER_ALS, .TASK = TASK_REGRESSION}; sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); sparse_predict(coef, pFix->X, y_pred); /* reference values from sklearn LinearRegression y_pred: [ 321.05084746 346.6779661 -40.15254237 321.05084746 790.37288136] coef: [ 69.6779661 152.16949153] mse: 3134.91525424 */ g_assert_cmpfloat(fabs(321.05084746 - ffm_vector_get(y_pred, 0)), <, 1e-6); g_assert_cmpfloat(fabs(346.6779661 - ffm_vector_get(y_pred, 1)), <, 1e-6); g_assert_cmpfloat(fabs(-40.15254237 - ffm_vector_get(y_pred, 2)), <, 1e-6); g_assert_cmpfloat(fabs(321.05084746 - ffm_vector_get(y_pred, 3)), <, 1e-6); g_assert_cmpfloat(fabs(790.37288136 - ffm_vector_get(y_pred, 4)), <, 1e-6); ffm_vector_free(y_pred); free_ffm_coef(coef); } void test_sparse_als_second_interactions(TestFixture_T *pFix, gconstpointer pg) { ffm_vector *y_pred = ffm_vector_calloc(5); int n_features = pFix->X->n; int k = 2; ffm_coef *coef = alloc_fm_coef(n_features, k, false); ffm_param param = {.n_iter = 1000, .init_sigma = 0.1, .SOLVER = SOLVER_ALS}; sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); sparse_predict(coef, pFix->X, y_pred); /* reference values from sklearn LinearRegression y_pred: [ 298. 266. 29. 298. 848.] coeff: [ 9. 2. 40.] mse: 4.53374139449e-27 */ g_assert_cmpfloat(fabs(298 - ffm_vector_get(y_pred, 0)), <, 1e-4); g_assert_cmpfloat(fabs(266 - ffm_vector_get(y_pred, 1)), <, 1e-4); g_assert_cmpfloat(fabs(29 - ffm_vector_get(y_pred, 2)), <, 1e-3); g_assert_cmpfloat(fabs(298 - ffm_vector_get(y_pred, 3)), <, 1e-4); g_assert_cmpfloat(fabs(848.0 - ffm_vector_get(y_pred, 4)), <, 1e-4); ffm_vector_free(y_pred); free_ffm_coef(coef); } void test_sparse_mcmc_second_interactions(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int n_samples = pFix->X->m; int k = 2; ffm_coef *coef = alloc_fm_coef(n_features, k, false); ffm_vector *y_pred = ffm_vector_calloc(n_samples); ffm_param param = {.n_iter = 100, .init_sigma = 0.1, .SOLVER = SOLVER_MCMC, .TASK = TASK_REGRESSION, .rng_seed = 1234}; sparse_fit(coef, pFix->X, pFix->X, pFix->y, y_pred, param); g_assert_cmpfloat(ffm_r2_score(pFix->y, y_pred), >, .98); ffm_vector_free(y_pred); free_ffm_coef(coef); } void test_sparse_mcmc_second_interactions_classification(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int n_samples = pFix->X->m; int k = 2; ffm_vector_make_labels(pFix->y); ffm_coef *coef = alloc_fm_coef(n_features, k, false); ffm_vector *y_pred = ffm_vector_calloc(n_samples); ffm_param param = {.n_iter = 10, .init_sigma = 0.1, .SOLVER = SOLVER_MCMC, .TASK = TASK_CLASSIFICATION}; sparse_fit(coef, pFix->X, pFix->X, pFix->y, y_pred, param); g_assert_cmpfloat(ffm_vector_accuracy(pFix->y, y_pred), >=, .98); ffm_vector_free(y_pred); free_ffm_coef(coef); } void test_train_test_of_different_size(TestFixture_T *pFix, gconstpointer pg) { int n_features = pFix->X->n; int k = 2; int n_samples_short = 3; int m = n_samples_short; int n = n_features; cs *X = cs_spalloc(m, n, m * n, 1, 1); /* create triplet identity matrix */ cs_entry(X, 0, 0, 6); cs_entry(X, 0, 1, 1); cs_entry(X, 1, 0, 2); cs_entry(X, 1, 1, 3); cs_entry(X, 2, 0, 3); cs *X_csc = cs_compress(X); /* A = compressed-column form of T */ cs *X_t = cs_transpose(X_csc, 1); cs_spfree(X); ffm_vector *y = ffm_vector_calloc(n_samples_short); // y [ 298 266 29 298 848 ] y->data[0] = 298; y->data[1] = 266; y->data[2] = 29; ffm_coef *coef = alloc_fm_coef(n_features, k, false); ffm_vector *y_pred = ffm_vector_calloc(n_samples_short); ffm_param param = {.n_iter = 20, .init_sigma = 0.01}; // test: train > test param.SOLVER = SOLVER_ALS; sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); sparse_predict(coef, X_csc, y_pred); param.TASK = TASK_CLASSIFICATION; sparse_fit(coef, pFix->X, NULL, pFix->y, NULL, param); sparse_predict(coef, X_csc, y_pred); param.SOLVER = SOLVER_MCMC; param.TASK = TASK_CLASSIFICATION; sparse_fit(coef, pFix->X, X_csc, pFix->y, y_pred, param); param.TASK = TASK_REGRESSION; sparse_fit(coef, pFix->X, X_csc, pFix->y, y_pred, param); // test: train < test param.SOLVER = SOLVER_MCMC; param.TASK = TASK_CLASSIFICATION; sparse_fit(coef, X_csc, pFix->X, y_pred, pFix->y, param); param.TASK = TASK_REGRESSION; sparse_fit(coef, X_csc, pFix->X, y_pred, pFix->y, param); param.SOLVER = SOLVER_ALS; sparse_fit(coef, X_csc, NULL, y_pred, NULL, param); sparse_predict(coef, pFix->X, pFix->y); param.TASK = TASK_CLASSIFICATION; sparse_fit(coef, X_csc, NULL, y_pred, NULL, param); sparse_predict(coef, pFix->X, pFix->y); ffm_vector_free(y_pred); free_ffm_coef(coef); cs_spfree(X_t); cs_spfree(X_csc); } void test_sparse_als_generated_data(void) { int n_features = 10; int n_samples = 100; int k = 2; TestFixture_T *data = makeTestFixture(124, n_samples, n_features, k); ffm_vector *y_pred = ffm_vector_calloc(n_samples); ffm_coef *coef = alloc_fm_coef(n_features, k, false); ffm_param param = {.n_iter = 50, .init_sigma = 0.01, .SOLVER = SOLVER_ALS}; param.init_lambda_w = 23.5; param.init_lambda_V = 23.5; sparse_fit(coef, data->X, NULL, data->y, NULL, param); sparse_predict(coef, data->X, y_pred); g_assert_cmpfloat(ffm_r2_score(data->y, y_pred), >, 0.85); ffm_vector_free(y_pred); free_ffm_coef(coef); TestFixtureDestructor(data, NULL); } void test_hyerparameter_sampling(void) { ffm_rng *rng = ffm_rng_seed(12345); int n_features = 20; int n_samples = 150; int k = 1; // don't just change k, the rank is hard coded in the test // (ffm_vector_get(coef->lambda_V, 0);) int n_replication = 40; int n_draws = 1000; ffm_vector *alpha_rep = ffm_vector_calloc(n_replication); ffm_vector *lambda_w_rep = ffm_vector_calloc(n_replication); ffm_vector *lambda_V_rep = ffm_vector_calloc(n_replication); ffm_vector *mu_w_rep = ffm_vector_calloc(n_replication); ffm_vector *mu_V_rep = ffm_vector_calloc(n_replication); ffm_vector *err = ffm_vector_alloc(n_samples); for (int j = 0; j < n_replication; j++) { TestFixture_T *data = makeTestFixture(124, n_samples, n_features, k); ffm_coef *coef = data->coef; sparse_predict(coef, data->X, err); ffm_vector_scale(err, -1); ffm_vector_add(err, data->y); // make sure that distribution is converged bevore selecting // reference / init values for (int l = 0; l < 50; l++) sample_hyper_parameter(coef, err, rng); double alpha_init = coef->alpha; double lambda_w_init = coef->lambda_w; double lambda_V_init = ffm_vector_get(coef->lambda_V, 0); double mu_w_init = coef->mu_w; double mu_V_init = ffm_vector_get(coef->mu_V, 0); double alpha_count = 0; double lambda_w_count = 0, lambda_V_count = 0; double mu_w_count = 0, mu_V_count = 0; for (int l = 0; l < n_draws; l++) { sample_hyper_parameter(coef, err, rng); if (alpha_init > coef->alpha) alpha_count++; if (lambda_w_init > coef->lambda_w) lambda_w_count++; if (lambda_V_init > ffm_vector_get(coef->lambda_V, 0)) lambda_V_count++; if (mu_w_init > coef->mu_w) mu_w_count++; if (mu_V_init > ffm_vector_get(coef->mu_V, 0)) mu_V_count++; } ffm_vector_set(alpha_rep, j, alpha_count / (n_draws + 1)); ffm_vector_set(lambda_w_rep, j, lambda_w_count / (n_draws + 1)); ffm_vector_set(lambda_V_rep, j, lambda_V_count / (n_draws + 1)); ffm_vector_set(mu_w_rep, j, mu_w_count / (n_draws + 1)); ffm_vector_set(mu_V_rep, j, mu_V_count / (n_draws + 1)); TestFixtureDestructor(data, NULL); } double chi_alpha = 0; for (int i = 0; i < n_replication; i++) chi_alpha += ffm_pow_2(gsl_cdf_ugaussian_Qinv(ffm_vector_get(alpha_rep, i))); g_assert_cmpfloat(gsl_ran_chisq_pdf(chi_alpha, n_replication), <, .05); double chi_lambda_w = 0; for (int i = 0; i < n_replication; i++) chi_lambda_w += ffm_pow_2(gsl_cdf_ugaussian_Qinv(ffm_vector_get(lambda_w_rep, i))); g_assert_cmpfloat(gsl_ran_chisq_pdf(chi_lambda_w, n_replication), <, .05); double chi_lambda_V = 0; for (int i = 0; i < n_replication; i++) chi_lambda_V += ffm_pow_2(gsl_cdf_ugaussian_Qinv(ffm_vector_get(lambda_V_rep, i))); g_assert_cmpfloat(gsl_ran_chisq_pdf(chi_lambda_V, n_replication), <, .05); double chi_mu_w = 0; for (int i = 0; i < n_replication; i++) chi_mu_w += ffm_pow_2(gsl_cdf_ugaussian_Qinv(ffm_vector_get(mu_w_rep, i))); g_assert_cmpfloat(gsl_ran_chisq_pdf(chi_mu_w, n_replication), <, .05); double chi_mu_V = 0; for (int i = 0; i < n_replication; i++) chi_mu_V += ffm_pow_2(gsl_cdf_ugaussian_Qinv(ffm_vector_get(mu_V_rep, i))); g_assert_cmpfloat(gsl_ran_chisq_pdf(chi_mu_V, n_replication), <, .05); ffm_vector_free_all(alpha_rep, lambda_w_rep, lambda_V_rep, mu_w_rep, mu_V_rep, err); ffm_rng_free(rng); }
double gsl_cdf_gaussian_Qinv (const double Q, const double sigma) { return sigma * gsl_cdf_ugaussian_Qinv (Q); }
double gsl_cdf_gamma_Qinv (const double Q, const double a, const double b) { double x; if (Q == 1.0) { return 0.0; } else if (Q == 0.0) { return GSL_POSINF; } /* Consider, small, large and intermediate cases separately. The boundaries at 0.05 and 0.95 have not been optimised, but seem ok for an initial approximation. */ if (Q < 0.05) { double x0 = -log (Q) + gsl_sf_lngamma (a); x = x0; } else if (Q > 0.95) { double x0 = exp ((gsl_sf_lngamma (a) + log1p (-Q)) / a); x = x0; } else { double xg = gsl_cdf_ugaussian_Qinv (Q); double x0 = (xg < -0.5*sqrt (a)) ? a : sqrt (a) * xg + a; x = x0; } /* Use Lagrange's interpolation for E(x)/phi(x0) to work backwards to an improved value of x (Abramowitz & Stegun, 3.6.6) where E(x)=P-integ(phi(u),u,x0,x) and phi(u) is the pdf. */ { double lambda, dQ, phi; unsigned int n = 0; start: dQ = Q - gsl_cdf_gamma_Q (x, a, 1.0); phi = gsl_ran_gamma_pdf (x, a, 1.0); if (dQ == 0.0 || n++ > 32) goto end; lambda = -dQ / GSL_MAX (2 * fabs (dQ / x), phi); { double step0 = lambda; double step1 = -((a - 1) / x - 1) * lambda * lambda / 4.0; double step = step0; if (fabs (step1) < 0.5 * fabs (step0)) step += step1; if (x + step > 0) x += step; else { x /= 2.0; } if (fabs (step0) > 1e-10 * x) goto start; } } end: return b * x; }
double gsl_cdf_tdist_Qinv (const double Q, const double nu) { double x, qtail; if (Q == 0.0) { return GSL_POSINF; } else if (Q == 1.0) { return GSL_NEGINF; } if (nu == 1.0) { x = tan (M_PI * (0.5 - Q)); return x; } else if (nu == 2.0) { x = (1 - 2 * Q) / sqrt (2 * Q * (1 - Q)); return x; } qtail = (Q < 0.5) ? Q : 1 - Q; if (sqrt (M_PI * nu / 2) * qtail > pow (0.05, nu / 2)) { double xg = gsl_cdf_ugaussian_Qinv (Q); x = inv_cornish_fisher (xg, nu); } else { /* Use an asymptotic expansion of the tail of integral */ double beta = gsl_sf_beta (0.5, nu / 2); if (Q < 0.5) { x = sqrt (nu) * pow (beta * nu * Q, -1.0 / nu); } else { x = -sqrt (nu) * pow (beta * nu * (1 - Q), -1.0 / nu); } /* Correct nu -> nu/(1+nu/x^2) in the leading term to account for higher order terms. This avoids overestimating x, which makes the iteration unstable due to the rapidly decreasing tails of the distribution. */ x /= sqrt (1 + nu / (x * x)); } { double dQ, phi; unsigned int n = 0; start: dQ = Q - gsl_cdf_tdist_Q (x, nu); phi = gsl_ran_tdist_pdf (x, nu); if (dQ == 0.0 || n++ > 32) goto end; { double lambda = - dQ / phi; double step0 = lambda; double step1 = ((nu + 1) * x / (x * x + nu)) * (lambda * lambda / 4.0); double step = step0; if (fabs (step1) < fabs (step0)) { step += step1; } if (Q < 0.5 && x + step < 0) x /= 2; else if (Q > 0.5 && x + step > 0) x /= 2; else x += step; if (fabs (step) > 1e-10 * fabs (x)) goto start; } } end: return x; }