1 /* pspp - a program for statistical analysis.
2 Copyright (C) 2012 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 1. "Coding Logistic Regression with Newton-Raphson", James McCaffrey
21 http://msdn.microsoft.com/en-us/magazine/jj618304.aspx
23 2. "SPSS Statistical Algorithms" Chapter LOGISTIC REGRESSION Algorithms
26 The Newton Raphson method finds successive approximations to $\bf b$ where
27 approximation ${\bf b}_t$ is (hopefully) better than the previous ${\bf b}_{t-1}$.
29 $ {\bf b}_t = {\bf b}_{t -1} + ({\bf X}^T{\bf W}_{t-1}{\bf X})^{-1}{\bf X}^T({\bf y} - {\bf \pi}_{t-1})$
32 $\bf X$ is the $n \times p$ design matrix, $n$ being the number of cases,
33 $p$ the number of parameters, \par
34 $\bf W$ is the diagonal matrix whose diagonal elements are
35 $\hat{\pi}_0(1 - \hat{\pi}_0), \, \hat{\pi}_1(1 - \hat{\pi}_2)\dots \hat{\pi}_{n-1}(1 - \hat{\pi}_{n-1})$
42 #include <gsl/gsl_blas.h>
44 #include <gsl/gsl_linalg.h>
45 #include <gsl/gsl_cdf.h>
46 #include <gsl/gsl_matrix.h>
47 #include <gsl/gsl_vector.h>
50 #include "data/case.h"
51 #include "data/casegrouper.h"
52 #include "data/casereader.h"
53 #include "data/dataset.h"
54 #include "data/dictionary.h"
55 #include "data/format.h"
56 #include "data/value.h"
57 #include "language/command.h"
58 #include "language/commands/split-file.h"
59 #include "language/lexer/lexer.h"
60 #include "language/lexer/value-parser.h"
61 #include "language/lexer/variable-parser.h"
62 #include "libpspp/assertion.h"
63 #include "libpspp/hash-functions.h"
64 #include "libpspp/hmap.h"
65 #include "libpspp/ll.h"
66 #include "libpspp/message.h"
67 #include "libpspp/misc.h"
68 #include "math/categoricals.h"
69 #include "math/interaction.h"
70 #include "output/pivot-table.h"
73 #define N_(msgid) msgid
74 #define _(msgid) gettext (msgid)
79 #define PRINT_EACH_STEP 0x01
80 #define PRINT_SUMMARY 0x02
81 #define PRINT_CORR 0x04
82 #define PRINT_ITER 0x08
83 #define PRINT_GOODFIT 0x10
87 #define PRINT_DEFAULT (PRINT_SUMMARY | PRINT_EACH_STEP)
90 The constant parameters of the procedure.
91 That is, those which are set by the user.
95 /* The dependent variable */
96 const struct variable *dep_var;
98 /* The predictor variables (excluding categorical ones) */
99 const struct variable **predictor_vars;
100 size_t n_predictor_vars;
102 /* The categorical predictors */
103 struct interaction **cat_predictors;
104 size_t n_cat_predictors;
107 /* The union of the categorical and non-categorical variables */
108 const struct variable **indep_vars;
112 /* Which classes of missing vars are to be excluded */
113 enum mv_class exclude;
115 /* The weight variable */
116 const struct variable *wv;
118 /* The dictionary of the dataset */
119 const struct dictionary *dict;
121 /* True iff the constant (intercept) is to be included in the model */
124 /* Ths maximum number of iterations */
127 /* Other iteration limiting conditions */
132 /* The confidence interval (in percent) */
135 /* What results should be presented */
138 /* Inverse logit of the cut point */
139 double ilogit_cut_point;
143 /* The results and intermediate result of the procedure.
144 These are mutated as the procedure runs. Used for
145 temporary variables etc.
149 /* Used to indicate if a pass should flag a warning when
150 invalid (ie negative or missing) weight values are encountered */
151 bool warn_bad_weight;
153 /* The two values of the dependent variable. */
158 /* The sum of caseweights */
161 /* The number of missing and nonmissing cases */
162 casenumber n_missing;
163 casenumber n_nonmissing;
168 /* The categoricals and their payload. Null if the analysis has no
169 categorical predictors */
170 struct categoricals *cats;
174 /* The estimates of the predictor coefficients */
175 gsl_vector *beta_hat;
177 /* The predicted classifications:
178 True Negative, True Positive, False Negative, False Positive */
179 double tn, tp, fn, fp;
184 Convert INPUT into a dichotomous scalar, according to how the dependent variable's
186 For simple cases, this is a 1:1 mapping
187 The return value is always either 0 or 1
190 map_dependent_var (const struct lr_spec *cmd, const struct lr_result *res, const union value *input)
192 const int width = var_get_width (cmd->dep_var);
193 if (value_equal (input, &res->y0, width))
196 if (value_equal (input, &res->y1, width))
199 /* This should never happen. If it does, then y0 and/or y1 have probably not been set */
205 static void output_classification_table (const struct lr_spec *cmd, const struct lr_result *res);
207 static void output_categories (const struct lr_spec *cmd, const struct lr_result *res);
209 static void output_depvarmap (const struct lr_spec *cmd, const struct lr_result *);
211 static void output_variables (const struct lr_spec *cmd,
212 const struct lr_result *);
214 static void output_model_summary (const struct lr_result *,
215 double initial_likelihood, double likelihood);
217 static void case_processing_summary (const struct lr_result *);
220 /* Return the value of case C corresponding to the INDEX'th entry in the
223 predictor_value (const struct ccase *c,
224 const struct variable **x, size_t n_x,
225 const struct categoricals *cats,
228 /* Values of the scalar predictor variables */
230 return case_num (c, x[index]);
232 /* Coded values of categorical predictor variables (or interactions) */
233 if (cats && index - n_x < categoricals_df_total (cats))
235 double x = categoricals_get_dummy_code_for_case (cats, index - n_x, c);
239 /* The constant term */
245 Return the probability beta_hat (that is the estimator logit(y))
246 corresponding to the coefficient estimator for case C
249 pi_hat (const struct lr_spec *cmd,
250 const struct lr_result *res,
251 const struct variable **x, size_t n_x,
252 const struct ccase *c)
256 size_t n_coeffs = res->beta_hat->size;
260 pi += gsl_vector_get (res->beta_hat, res->beta_hat->size - 1);
264 for (v0 = 0; v0 < n_coeffs; ++v0)
266 pi += gsl_vector_get (res->beta_hat, v0) *
267 predictor_value (c, x, n_x, res->cats, v0);
270 pi = 1.0 / (1.0 + exp(-pi));
277 Calculates the Hessian matrix X' V X,
278 where: X is the n by N_X matrix comprising the n cases in INPUT
279 V is a diagonal matrix { (pi_hat_0)(1 - pi_hat_0), (pi_hat_1)(1 - pi_hat_1), ... (pi_hat_{N-1})(1 - pi_hat_{N-1})}
280 (the partial derivative of the predicted values)
282 If ALL predicted values derivatives are close to zero or one, then CONVERGED
286 hessian (const struct lr_spec *cmd,
287 struct lr_result *res,
288 struct casereader *input,
289 const struct variable **x, size_t n_x,
292 struct casereader *reader;
295 double max_w = -DBL_MAX;
297 gsl_matrix_set_zero (res->hessian);
299 for (reader = casereader_clone (input);
300 (c = casereader_read (reader)) != NULL; case_unref (c))
303 double pi = pi_hat (cmd, res, x, n_x, c);
305 double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
306 double w = pi * (1 - pi);
311 for (v0 = 0; v0 < res->beta_hat->size; ++v0)
313 double in0 = predictor_value (c, x, n_x, res->cats, v0);
314 for (v1 = 0; v1 < res->beta_hat->size; ++v1)
316 double in1 = predictor_value (c, x, n_x, res->cats, v1);
317 double *o = gsl_matrix_ptr (res->hessian, v0, v1);
322 casereader_destroy (reader);
324 if (max_w < cmd->min_epsilon)
327 msg (MN, _("All predicted values are either 1 or 0"));
332 /* Calculates the value X' (y - pi)
333 where X is the design model,
334 y is the vector of observed independent variables
335 pi is the vector of estimates for y
338 the likelihood is stored in LIKELIHOOD;
339 the predicted values are placed in the respective tn, fn, tp fp values in RES
342 xt_times_y_pi (const struct lr_spec *cmd,
343 struct lr_result *res,
344 struct casereader *input,
345 const struct variable **x, size_t n_x,
346 const struct variable *y_var,
349 struct casereader *reader;
351 gsl_vector *output = gsl_vector_calloc (res->beta_hat->size);
354 res->tn = res->tp = res->fn = res->fp = 0;
355 for (reader = casereader_clone (input);
356 (c = casereader_read (reader)) != NULL; case_unref (c))
360 double pi = pi_hat (cmd, res, x, n_x, c);
361 double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
364 double y = map_dependent_var (cmd, res, case_data (c, y_var));
366 *llikelihood += (weight * y) * log (pi) + log (1 - pi) * weight * (1 - y);
368 for (v0 = 0; v0 < res->beta_hat->size; ++v0)
370 double in0 = predictor_value (c, x, n_x, res->cats, v0);
371 double *o = gsl_vector_ptr (output, v0);
372 *o += in0 * (y - pi) * weight;
373 pred_y += gsl_vector_get (res->beta_hat, v0) * in0;
376 /* Count the number of cases which would be correctly/incorrectly classified by this
378 if (pred_y <= cmd->ilogit_cut_point)
394 casereader_destroy (reader);
401 /* "payload" functions for the categoricals.
402 The only function is to accumulate the frequency of each
407 frq_create (const void *aux1 UNUSED, void *aux2 UNUSED)
409 return xzalloc (sizeof (double));
413 frq_update (const void *aux1 UNUSED, void *aux2 UNUSED,
414 void *ud, const struct ccase *c UNUSED , double weight)
421 frq_destroy (const void *aux1 UNUSED, void *aux2 UNUSED, void *user_data)
429 Makes an initial pass though the data, doing the following:
431 * Checks that the dependent variable is dichotomous,
432 * Creates and initialises the categoricals,
433 * Accumulates summary results,
434 * Calculates necessary initial values.
435 * Creates an initial value for \hat\beta the vector of beta_hats of \beta
437 Returns true if successful
440 initial_pass (const struct lr_spec *cmd, struct lr_result *res, struct casereader *input)
442 const int width = var_get_width (cmd->dep_var);
445 struct casereader *reader;
454 size_t n_coefficients = cmd->n_predictor_vars;
458 /* Create categoricals if appropriate */
459 if (cmd->n_cat_predictors > 0)
461 res->cp.create = frq_create;
462 res->cp.update = frq_update;
463 res->cp.calculate = NULL;
464 res->cp.destroy = frq_destroy;
466 res->cats = categoricals_create (cmd->cat_predictors, cmd->n_cat_predictors,
469 categoricals_set_payload (res->cats, &res->cp, cmd, res);
473 for (reader = casereader_clone (input);
474 (c = casereader_read (reader)) != NULL; case_unref (c))
477 bool missing = false;
478 double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
479 const union value *depval = case_data (c, cmd->dep_var);
481 if (var_is_value_missing (cmd->dep_var, depval) & cmd->exclude)
486 for (v = 0; v < cmd->n_indep_vars; ++v)
488 const union value *val = case_data (c, cmd->indep_vars[v]);
489 if (var_is_value_missing (cmd->indep_vars[v], val) & cmd->exclude)
496 /* Accumulate the missing and non-missing counts */
504 /* Find the values of the dependent variable */
507 value_clone (&res->y0, depval, width);
512 if (!value_equal (&res->y0, depval, width))
514 value_clone (&res->y1, depval, width);
520 if (!value_equal (&res->y0, depval, width)
522 !value_equal (&res->y1, depval, width)
525 msg (ME, _("Dependent variable's values are not dichotomous."));
531 if (v0set && value_equal (&res->y0, depval, width))
534 if (v1set && value_equal (&res->y1, depval, width))
540 categoricals_update (res->cats, c);
542 casereader_destroy (reader);
544 categoricals_done (res->cats);
548 /* Ensure that Y0 is less than Y1. Otherwise the mapping gets
549 inverted, which is confusing to users */
550 if (var_is_numeric (cmd->dep_var) && value_compare_3way (&res->y0, &res->y1, width) > 0)
553 value_clone (&tmp, &res->y0, width);
554 value_copy (&res->y0, &res->y1, width);
555 value_copy (&res->y1, &tmp, width);
556 value_destroy (&tmp, width);
560 n_coefficients += categoricals_df_total (res->cats);
561 res->beta_hat = gsl_vector_calloc (n_coefficients);
565 double mean = sum / res->cc;
566 gsl_vector_set (res->beta_hat, res->beta_hat->size - 1, log (mean / (1 - mean)));
572 casereader_destroy (reader);
578 /* Start of the logistic regression routine proper */
580 run_lr (const struct lr_spec *cmd, struct casereader *input,
581 const struct dataset *ds UNUSED)
585 bool converged = false;
587 /* Set the log likelihoods to a sentinel value */
588 double log_likelihood = SYSMIS;
589 double prev_log_likelihood = SYSMIS;
590 double initial_log_likelihood = SYSMIS;
592 struct lr_result work;
594 work.n_nonmissing = 0;
595 work.warn_bad_weight = true;
597 work.beta_hat = NULL;
600 /* Get the initial estimates of \beta and their standard errors.
601 And perform other auxiliary initialisation. */
602 if (!initial_pass (cmd, &work, input))
605 for (i = 0; i < cmd->n_cat_predictors; ++i)
607 if (1 >= categoricals_n_count (work.cats, i))
610 ds_init_empty (&str);
612 interaction_to_string (cmd->cat_predictors[i], &str);
614 msg (ME, _("Category %s does not have at least two distinct values. Logistic regression will not be run."),
621 output_depvarmap (cmd, &work);
623 case_processing_summary (&work);
626 input = casereader_create_filter_missing (input,
633 input = casereader_create_filter_missing (input,
640 work.hessian = gsl_matrix_calloc (work.beta_hat->size, work.beta_hat->size);
642 /* Start the Newton Raphson iteration process... */
643 for(i = 0; i < cmd->max_iter; ++i)
649 hessian (cmd, &work, input,
650 cmd->predictor_vars, cmd->n_predictor_vars,
653 gsl_linalg_cholesky_decomp (work.hessian);
654 gsl_linalg_cholesky_invert (work.hessian);
656 v = xt_times_y_pi (cmd, &work, input,
657 cmd->predictor_vars, cmd->n_predictor_vars,
663 gsl_vector *delta = gsl_vector_alloc (v->size);
664 gsl_blas_dgemv (CblasNoTrans, 1.0, work.hessian, v, 0, delta);
668 gsl_vector_add (work.beta_hat, delta);
670 gsl_vector_minmax (delta, &min, &max);
672 if (fabs (min) < cmd->bcon && fabs (max) < cmd->bcon)
674 msg (MN, _("Estimation terminated at iteration number %d because parameter estimates changed by less than %g"),
679 gsl_vector_free (delta);
684 if (-log_likelihood > -(1.0 - cmd->lcon) * prev_log_likelihood)
686 msg (MN, _("Estimation terminated at iteration number %d because Log Likelihood decreased by less than %g%%"), i + 1, 100 * cmd->lcon);
691 initial_log_likelihood = log_likelihood;
692 prev_log_likelihood = log_likelihood;
701 msg (MW, _("Estimation terminated at iteration number %d because maximum iterations has been reached"), i);
704 output_model_summary (&work, initial_log_likelihood, log_likelihood);
707 output_categories (cmd, &work);
709 output_classification_table (cmd, &work);
710 output_variables (cmd, &work);
712 casereader_destroy (input);
713 gsl_matrix_free (work.hessian);
714 gsl_vector_free (work.beta_hat);
715 categoricals_destroy (work.cats);
720 casereader_destroy (input);
721 gsl_matrix_free (work.hessian);
722 gsl_vector_free (work.beta_hat);
723 categoricals_destroy (work.cats);
730 struct hmap_node node; /* Node in hash map. */
731 const struct variable *var; /* The variable */
734 static struct variable_node *
735 lookup_variable (const struct hmap *map, const struct variable *var, unsigned int hash)
737 struct variable_node *vn;
738 HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
746 insert_variable (struct hmap *map, const struct variable *var, unsigned int hash)
748 if (!lookup_variable (map, var, hash))
750 struct variable_node *vn = xmalloc (sizeof *vn);
751 *vn = (struct variable_node) { .var = var };
752 hmap_insert (map, &vn->node, hash);
756 /* Parse the LOGISTIC REGRESSION command syntax */
758 cmd_logistic (struct lexer *lexer, struct dataset *ds)
760 /* Temporary location for the predictor variables.
761 These may or may not include the categorical predictors */
762 const struct variable **pred_vars = NULL;
763 size_t n_pred_vars = 0;
766 struct dictionary *dict = dataset_dict (ds);
767 struct lr_spec lr = {
770 .wv = dict_get_weight (dict),
774 .min_epsilon = 0.00000001,
777 .print = PRINT_DEFAULT,
780 if (lex_match_id (lexer, "VARIABLES"))
781 lex_match (lexer, T_EQUALS);
783 lr.dep_var = parse_variable_const (lexer, lr.dict);
787 if (!lex_force_match (lexer, T_WITH))
790 if (!parse_variables_const (lexer, lr.dict, &pred_vars, &n_pred_vars,
794 while (lex_token (lexer) != T_ENDCMD)
796 lex_match (lexer, T_SLASH);
798 if (lex_match_id (lexer, "MISSING"))
800 lex_match (lexer, T_EQUALS);
801 while (lex_token (lexer) != T_ENDCMD
802 && lex_token (lexer) != T_SLASH)
804 if (lex_match_id (lexer, "INCLUDE"))
805 lr.exclude = MV_SYSTEM;
806 else if (lex_match_id (lexer, "EXCLUDE"))
810 lex_error_expecting (lexer, "INCLUDE", "EXCLUDE");
815 else if (lex_match_id (lexer, "ORIGIN"))
817 else if (lex_match_id (lexer, "NOORIGIN"))
819 else if (lex_match_id (lexer, "NOCONST"))
821 else if (lex_match_id (lexer, "EXTERNAL"))
823 /* This is for compatibility. It does nothing */
825 else if (lex_match_id (lexer, "CATEGORICAL"))
827 lex_match (lexer, T_EQUALS);
828 struct variable **cats;
830 if (!parse_variables (lexer, lr.dict, &cats, &n_cats, PV_NO_DUPLICATE))
833 lr.cat_predictors = xrealloc (lr.cat_predictors,
834 sizeof *lr.cat_predictors
835 * (n_cats + lr.n_cat_predictors));
836 for (size_t i = 0; i < n_cats; i++)
837 lr.cat_predictors[lr.n_cat_predictors++] = interaction_create (cats[i]);
840 else if (lex_match_id (lexer, "PRINT"))
842 lex_match (lexer, T_EQUALS);
843 while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
845 if (lex_match_id (lexer, "DEFAULT"))
846 lr.print |= PRINT_DEFAULT;
847 else if (lex_match_id (lexer, "SUMMARY"))
848 lr.print |= PRINT_SUMMARY;
850 else if (lex_match_id (lexer, "CORR"))
851 lr.print |= PRINT_CORR;
852 else if (lex_match_id (lexer, "ITER"))
853 lr.print |= PRINT_ITER;
854 else if (lex_match_id (lexer, "GOODFIT"))
855 lr.print |= PRINT_GOODFIT;
857 else if (lex_match_id (lexer, "CI"))
859 lr.print |= PRINT_CI;
860 if (!lex_force_match (lexer, T_LPAREN)
861 || !lex_force_num (lexer))
863 lr.confidence = lex_number (lexer);
865 if (!lex_force_match (lexer, T_RPAREN))
868 else if (lex_match_id (lexer, "ALL"))
872 lex_error_expecting (lexer, "DEFAULT", "SUMMARY",
874 "CORR", "ITER", "GOODFIT",
881 else if (lex_match_id (lexer, "CRITERIA"))
883 lex_match (lexer, T_EQUALS);
884 while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
886 if (lex_match_id (lexer, "BCON"))
888 if (!lex_force_match (lexer, T_LPAREN)
889 || !lex_force_num (lexer))
891 lr.bcon = lex_number (lexer);
893 if (!lex_force_match (lexer, T_RPAREN))
896 else if (lex_match_id (lexer, "ITERATE"))
898 if (!lex_force_match (lexer, T_LPAREN)
899 || !lex_force_int_range (lexer, "ITERATE", 0, INT_MAX))
901 lr.max_iter = lex_integer (lexer);
903 if (!lex_force_match (lexer, T_RPAREN))
906 else if (lex_match_id (lexer, "LCON"))
908 if (!lex_force_match (lexer, T_LPAREN)
909 || !lex_force_num (lexer))
911 lr.lcon = lex_number (lexer);
913 if (!lex_force_match (lexer, T_RPAREN))
916 else if (lex_match_id (lexer, "EPS"))
918 if (!lex_force_match (lexer, T_LPAREN)
919 || !lex_force_num (lexer))
921 lr.min_epsilon = lex_number (lexer);
923 if (!lex_force_match (lexer, T_RPAREN))
926 else if (lex_match_id (lexer, "CUT"))
928 if (!lex_force_match (lexer, T_LPAREN)
929 || !lex_force_num_range_closed (lexer, "CUT", 0, 1))
932 cp = lex_number (lexer);
935 if (!lex_force_match (lexer, T_RPAREN))
940 lex_error_expecting (lexer, "BCON", "ITERATE", "LCON", "EPS",
948 lex_error_expecting (lexer, "MISSING", "ORIGIN", "NOORIGIN",
949 "NOCONST", "EXTERNAL", "CATEGORICAL",
950 "PRINT", "CRITERIA");
955 lr.ilogit_cut_point = - log (1/cp - 1);
957 /* Copy the predictor variables from the temporary location into the
958 final one, dropping any categorical variables which appear there.
959 FIXME: This is O(NxM).
961 struct hmap allvars = HMAP_INITIALIZER (allvars);
962 size_t allocated_predictor_vars = 0;
963 for (size_t v = 0; v < n_pred_vars; ++v)
966 const struct variable *var = pred_vars[v];
968 unsigned int hash = hash_pointer (var, 0);
969 insert_variable (&allvars, var, hash);
971 for (size_t cv = 0; cv < lr.n_cat_predictors; ++cv)
973 const struct interaction *iact = lr.cat_predictors[cv];
974 for (size_t iv = 0; iv < iact->n_vars; ++iv)
976 const struct variable *ivar = iact->vars[iv];
977 unsigned int hash = hash_pointer (ivar, 0);
978 insert_variable (&allvars, ivar, hash);
988 if (lr.n_predictor_vars >= allocated_predictor_vars)
989 lr.predictor_vars = x2nrealloc (lr.predictor_vars,
990 &allocated_predictor_vars,
991 sizeof *lr.predictor_vars);
992 lr.predictor_vars[lr.n_predictor_vars++] = var;
995 lr.n_indep_vars = hmap_count (&allvars);
996 lr.indep_vars = xmalloc (lr.n_indep_vars * sizeof *lr.indep_vars);
998 /* Interate over each variable and push it into the array */
1000 struct variable_node *vn, *next;
1001 HMAP_FOR_EACH_SAFE (vn, next, struct variable_node, node, &allvars)
1003 lr.indep_vars[x++] = vn->var;
1004 hmap_delete (&allvars, &vn->node);
1007 assert (x == lr.n_indep_vars);
1008 hmap_destroy (&allvars);
1010 /* Run logistical regression for each split group. */
1011 struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), lr.dict);
1012 struct casereader *group;
1014 while (casegrouper_get_next_group (grouper, &group))
1015 ok = run_lr (&lr, group, ds) && ok;
1016 ok = casegrouper_destroy (grouper) && ok;
1017 ok = proc_commit (ds) && ok;
1019 for (size_t i = 0; i < lr.n_cat_predictors; ++i)
1020 interaction_destroy (lr.cat_predictors[i]);
1021 free (lr.predictor_vars);
1022 free (lr.cat_predictors);
1023 free (lr.indep_vars);
1029 for (size_t i = 0; i < lr.n_cat_predictors; ++i)
1030 interaction_destroy (lr.cat_predictors[i]);
1031 free (lr.predictor_vars);
1032 free (lr.cat_predictors);
1033 free (lr.indep_vars);
1042 /* Show the Dependent Variable Encoding box.
1043 This indicates how the dependent variable
1044 is mapped to the internal zero/one values.
1047 output_depvarmap (const struct lr_spec *cmd, const struct lr_result *res)
1049 struct pivot_table *table = pivot_table_create (
1050 N_("Dependent Variable Encoding"));
1052 pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Mapping"),
1053 N_("Internal Value"));
1055 struct pivot_dimension *original = pivot_dimension_create (
1056 table, PIVOT_AXIS_ROW, N_("Original Value"));
1057 original->root->show_label = true;
1059 for (int i = 0; i < 2; i++)
1061 const union value *v = i ? &res->y1 : &res->y0;
1062 int orig_idx = pivot_category_create_leaf (
1063 original->root, pivot_value_new_var_value (cmd->dep_var, v));
1064 pivot_table_put2 (table, 0, orig_idx, pivot_value_new_number (
1065 map_dependent_var (cmd, res, v)));
1068 pivot_table_submit (table);
1072 /* Show the Variables in the Equation box */
1074 output_variables (const struct lr_spec *cmd,
1075 const struct lr_result *res)
1077 struct pivot_table *table = pivot_table_create (
1078 N_("Variables in the Equation"));
1080 struct pivot_dimension *statistics = pivot_dimension_create (
1081 table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1082 N_("B"), PIVOT_RC_OTHER,
1083 N_("S.E."), PIVOT_RC_OTHER,
1084 N_("Wald"), PIVOT_RC_OTHER,
1085 N_("df"), PIVOT_RC_INTEGER,
1086 N_("Sig."), PIVOT_RC_SIGNIFICANCE,
1087 N_("Exp(B)"), PIVOT_RC_OTHER);
1088 if (cmd->print & PRINT_CI)
1090 struct pivot_category *group = pivot_category_create_group__ (
1092 pivot_value_new_text_format (N_("%d%% CI for Exp(B)"),
1094 pivot_category_create_leaves (group, N_("Lower"), N_("Upper"));
1097 struct pivot_dimension *variables = pivot_dimension_create (
1098 table, PIVOT_AXIS_ROW, N_("Variables"));
1099 struct pivot_category *step1 = pivot_category_create_group (
1100 variables->root, N_("Step 1"));
1103 int idx_correction = 0;
1106 int nr = cmd->n_predictor_vars;
1110 nr += categoricals_df_total (res->cats) + cmd->n_cat_predictors;
1112 for (int row = 0; row < nr; row++)
1114 const int idx = row - idx_correction;
1117 if (idx < cmd->n_predictor_vars)
1118 var_idx = pivot_category_create_leaf (
1119 step1, pivot_value_new_variable (cmd->predictor_vars[idx]));
1120 else if (i < cmd->n_cat_predictors)
1122 const struct interaction *cat_predictors = cmd->cat_predictors[i];
1123 struct string str = DS_EMPTY_INITIALIZER;
1124 interaction_to_string (cat_predictors, &str);
1126 ds_put_format (&str, "(%d)", ivar);
1127 var_idx = pivot_category_create_leaf (
1128 step1, pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
1130 int df = categoricals_df (res->cats, i);
1131 bool summary = ivar == 0;
1134 /* Calculate the Wald statistic,
1135 which is \beta' C^-1 \beta .
1136 where \beta is the vector of the coefficient estimates comprising this
1137 categorial variable. and C is the corresponding submatrix of the
1140 gsl_matrix_const_view mv =
1141 gsl_matrix_const_submatrix (res->hessian, idx, idx, df, df);
1142 gsl_matrix *subhessian = gsl_matrix_alloc (mv.matrix.size1, mv.matrix.size2);
1143 gsl_vector_const_view vv = gsl_vector_const_subvector (res->beta_hat, idx, df);
1144 gsl_vector *temp = gsl_vector_alloc (df);
1146 gsl_matrix_memcpy (subhessian, &mv.matrix);
1147 gsl_linalg_cholesky_decomp (subhessian);
1148 gsl_linalg_cholesky_invert (subhessian);
1150 gsl_blas_dgemv (CblasTrans, 1.0, subhessian, &vv.vector, 0, temp);
1152 gsl_blas_ddot (temp, &vv.vector, &wald);
1154 double entries[] = { wald, df, gsl_cdf_chisq_Q (wald, df) };
1155 for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
1156 pivot_table_put2 (table, j + 2, var_idx,
1157 pivot_value_new_number (entries[j]));
1160 gsl_matrix_free (subhessian);
1161 gsl_vector_free (temp);
1166 ++i; /* next interaction */
1174 var_idx = pivot_category_create_leaves (step1, N_("Constant"));
1176 double b = gsl_vector_get (res->beta_hat, idx);
1177 double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
1178 double wald = pow2 (b) / sigma2;
1180 double wc = (gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0)
1182 bool show_ci = cmd->print & PRINT_CI && row < nr - cmd->constant;
1184 double entries[] = {
1189 gsl_cdf_chisq_Q (wald, df),
1191 show_ci ? exp (b - wc) : SYSMIS,
1192 show_ci ? exp (b + wc) : SYSMIS,
1194 for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
1195 if (entries[j] != SYSMIS)
1196 pivot_table_put2 (table, j, var_idx,
1197 pivot_value_new_number (entries[j]));
1200 pivot_table_submit (table);
1204 /* Show the model summary box */
1206 output_model_summary (const struct lr_result *res,
1207 double initial_log_likelihood, double log_likelihood)
1209 struct pivot_table *table = pivot_table_create (N_("Model Summary"));
1211 pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1212 N_("-2 Log likelihood"), PIVOT_RC_OTHER,
1213 N_("Cox & Snell R Square"), PIVOT_RC_OTHER,
1214 N_("Nagelkerke R Square"), PIVOT_RC_OTHER);
1216 struct pivot_dimension *step = pivot_dimension_create (
1217 table, PIVOT_AXIS_ROW, N_("Step"));
1218 step->root->show_label = true;
1219 pivot_category_create_leaf (step->root, pivot_value_new_integer (1));
1221 double cox = (1.0 - exp ((initial_log_likelihood - log_likelihood)
1223 double entries[] = {
1224 -2 * log_likelihood,
1226 cox / (1.0 - exp(initial_log_likelihood * (2 / res->cc)))
1228 for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1229 pivot_table_put2 (table, i, 0, pivot_value_new_number (entries[i]));
1231 pivot_table_submit (table);
1234 /* Show the case processing summary box */
1236 case_processing_summary (const struct lr_result *res)
1238 struct pivot_table *table = pivot_table_create (
1239 N_("Case Processing Summary"));
1241 pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1242 N_("N"), PIVOT_RC_COUNT,
1243 N_("Percent"), PIVOT_RC_PERCENT);
1245 struct pivot_dimension *cases = pivot_dimension_create (
1246 table, PIVOT_AXIS_ROW, N_("Unweighted Cases"),
1247 N_("Included in Analysis"), N_("Missing Cases"), N_("Total"));
1248 cases->root->show_label = true;
1250 double total = res->n_nonmissing + res->n_missing;
1258 { 0, 0, res->n_nonmissing },
1259 { 0, 1, res->n_missing },
1261 { 1, 0, 100.0 * res->n_nonmissing / total },
1262 { 1, 1, 100.0 * res->n_missing / total },
1265 for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1266 pivot_table_put2 (table, entries[i].stat_idx, entries[i].case_idx,
1267 pivot_value_new_number (entries[i].x));
1269 pivot_table_submit (table);
1273 output_categories (const struct lr_spec *cmd, const struct lr_result *res)
1275 struct pivot_table *table = pivot_table_create (
1276 N_("Categorical Variables' Codings"));
1277 pivot_table_set_weight_var (table, dict_get_weight (cmd->dict));
1281 for (int i = 0; i < cmd->n_cat_predictors; ++i)
1283 size_t n = categoricals_n_count (res->cats, i);
1284 size_t df = categoricals_df (res->cats, i);
1290 struct pivot_dimension *codings = pivot_dimension_create (
1291 table, PIVOT_AXIS_COLUMN, N_("Codings"),
1292 N_("Frequency"), PIVOT_RC_COUNT);
1293 struct pivot_category *coding_group = pivot_category_create_group (
1294 codings->root, N_("Parameter coding"));
1295 for (int i = 0; i < max_df; ++i)
1296 pivot_category_create_leaf_rc (
1298 pivot_value_new_user_text_nocopy (xasprintf ("(%d)", i + 1)),
1301 struct pivot_dimension *categories = pivot_dimension_create (
1302 table, PIVOT_AXIS_ROW, N_("Categories"));
1304 int cumulative_df = 0;
1305 for (int v = 0; v < cmd->n_cat_predictors; ++v)
1308 const struct interaction *cat_predictors = cmd->cat_predictors[v];
1309 int df = categoricals_df (res->cats, v);
1311 struct string str = DS_EMPTY_INITIALIZER;
1312 interaction_to_string (cat_predictors, &str);
1313 struct pivot_category *var_group = pivot_category_create_group__ (
1315 pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
1317 for (cat = 0; cat < categoricals_n_count (res->cats, v); ++cat)
1319 const struct ccase *c = categoricals_get_case_by_category_real (
1321 struct string label = DS_EMPTY_INITIALIZER;
1322 for (int x = 0; x < cat_predictors->n_vars; ++x)
1324 if (!ds_is_empty (&label))
1325 ds_put_byte (&label, ' ');
1327 const union value *val = case_data (c, cat_predictors->vars[x]);
1328 var_append_value_name (cat_predictors->vars[x], val, &label);
1330 int cat_idx = pivot_category_create_leaf (
1332 pivot_value_new_user_text_nocopy (ds_steal_cstr (&label)));
1334 double *freq = categoricals_get_user_data_by_category_real (
1336 pivot_table_put2 (table, 0, cat_idx, pivot_value_new_number (*freq));
1338 for (int x = 0; x < df; ++x)
1339 pivot_table_put2 (table, x + 1, cat_idx,
1340 pivot_value_new_number (cat == x));
1342 cumulative_df += df;
1345 pivot_table_submit (table);
1349 create_classification_dimension (const struct lr_spec *cmd,
1350 const struct lr_result *res,
1351 struct pivot_table *table,
1352 enum pivot_axis_type axis_type,
1353 const char *label, const char *total)
1355 struct pivot_dimension *d = pivot_dimension_create (
1356 table, axis_type, label);
1357 d->root->show_label = true;
1358 struct pivot_category *pred_group = pivot_category_create_group__ (
1359 d->root, pivot_value_new_variable (cmd->dep_var));
1360 for (int i = 0; i < 2; i++)
1362 const union value *y = i ? &res->y1 : &res->y0;
1363 pivot_category_create_leaf_rc (
1364 pred_group, pivot_value_new_var_value (cmd->dep_var, y),
1367 pivot_category_create_leaves (d->root, total, PIVOT_RC_PERCENT);
1371 output_classification_table (const struct lr_spec *cmd, const struct lr_result *res)
1373 struct pivot_table *table = pivot_table_create (N_("Classification Table"));
1374 pivot_table_set_weight_var (table, cmd->wv);
1376 create_classification_dimension (cmd, res, table, PIVOT_AXIS_COLUMN,
1377 N_("Predicted"), N_("Percentage Correct"));
1378 create_classification_dimension (cmd, res, table, PIVOT_AXIS_ROW,
1379 N_("Observed"), N_("Overall Percentage"));
1381 pivot_dimension_create (table, PIVOT_AXIS_ROW, N_("Step"), N_("Step 1"));
1394 { 2, 0, 100 * res->tn / (res->tn + res->fp) },
1395 { 2, 1, 100 * res->tp / (res->tp + res->fn) },
1397 100 * (res->tp + res->tn) / (res->tp + res->tn + res->fp + res->fn)},
1399 for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1401 const struct entry *e = &entries[i];
1402 pivot_table_put3 (table, e->pred_idx, e->obs_idx, 0,
1403 pivot_value_new_number (e->x));
1406 pivot_table_submit (table);