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/dictionary/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/ll.h"
64 #include "libpspp/message.h"
65 #include "libpspp/misc.h"
66 #include "math/categoricals.h"
67 #include "math/interaction.h"
68 #include "libpspp/hmap.h"
69 #include "libpspp/hash-functions.h"
71 #include "output/tab.h"
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 */
142 /* The results and intermediate result of the procedure.
143 These are mutated as the procedure runs. Used for
144 temporary variables etc.
148 /* Used to indicate if a pass should flag a warning when
149 invalid (ie negative or missing) weight values are encountered */
150 bool warn_bad_weight;
152 /* The two values of the dependent variable. */
157 /* The sum of caseweights */
160 /* The number of missing and nonmissing cases */
161 casenumber n_missing;
162 casenumber n_nonmissing;
167 /* The categoricals and their payload. Null if the analysis has no
168 categorical predictors */
169 struct categoricals *cats;
173 /* The estimates of the predictor coefficients */
174 gsl_vector *beta_hat;
176 /* The predicted classifications:
177 True Negative, True Positive, False Negative, False Positive */
178 double tn, tp, fn, fp;
183 Convert INPUT into a dichotomous scalar, according to how the dependent variable's
185 For simple cases, this is a 1:1 mapping
186 The return value is always either 0 or 1
189 map_dependent_var (const struct lr_spec *cmd, const struct lr_result *res, const union value *input)
191 const int width = var_get_width (cmd->dep_var);
192 if (value_equal (input, &res->y0, width))
195 if (value_equal (input, &res->y1, width))
198 /* This should never happen. If it does, then y0 and/or y1 have probably not been set */
204 static void output_classification_table (const struct lr_spec *cmd, const struct lr_result *res);
206 static void output_categories (const struct lr_spec *cmd, const struct lr_result *res);
208 static void output_depvarmap (const struct lr_spec *cmd, const struct lr_result *);
210 static void output_variables (const struct lr_spec *cmd,
211 const struct lr_result *);
213 static void output_model_summary (const struct lr_result *,
214 double initial_likelihood, double likelihood);
216 static void case_processing_summary (const struct lr_result *);
219 /* Return the value of case C corresponding to the INDEX'th entry in the
222 predictor_value (const struct ccase *c,
223 const struct variable **x, size_t n_x,
224 const struct categoricals *cats,
227 /* Values of the scalar predictor variables */
229 return case_data (c, x[index])->f;
231 /* Coded values of categorical predictor variables (or interactions) */
232 if (cats && index - n_x < categoricals_df_total (cats))
234 double x = categoricals_get_dummy_code_for_case (cats, index - n_x, c);
238 /* The constant term */
244 Return the probability beta_hat (that is the estimator logit(y) )
245 corresponding to the coefficient estimator for case C
248 pi_hat (const struct lr_spec *cmd,
249 const struct lr_result *res,
250 const struct variable **x, size_t n_x,
251 const struct ccase *c)
255 size_t n_coeffs = res->beta_hat->size;
259 pi += gsl_vector_get (res->beta_hat, res->beta_hat->size - 1);
263 for (v0 = 0; v0 < n_coeffs; ++v0)
265 pi += gsl_vector_get (res->beta_hat, v0) *
266 predictor_value (c, x, n_x, res->cats, v0);
269 pi = 1.0 / (1.0 + exp(-pi));
276 Calculates the Hessian matrix X' V X,
277 where: X is the n by N_X matrix comprising the n cases in INPUT
278 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})}
279 (the partial derivative of the predicted values)
281 If ALL predicted values derivatives are close to zero or one, then CONVERGED
285 hessian (const struct lr_spec *cmd,
286 struct lr_result *res,
287 struct casereader *input,
288 const struct variable **x, size_t n_x,
291 struct casereader *reader;
294 double max_w = -DBL_MAX;
296 gsl_matrix_set_zero (res->hessian);
298 for (reader = casereader_clone (input);
299 (c = casereader_read (reader)) != NULL; case_unref (c))
302 double pi = pi_hat (cmd, res, x, n_x, c);
304 double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
305 double w = pi * (1 - pi);
310 for (v0 = 0; v0 < res->beta_hat->size; ++v0)
312 double in0 = predictor_value (c, x, n_x, res->cats, v0);
313 for (v1 = 0; v1 < res->beta_hat->size; ++v1)
315 double in1 = predictor_value (c, x, n_x, res->cats, v1);
316 double *o = gsl_matrix_ptr (res->hessian, v0, v1);
321 casereader_destroy (reader);
323 if ( max_w < cmd->min_epsilon)
326 msg (MN, _("All predicted values are either 1 or 0"));
331 /* Calculates the value X' (y - pi)
332 where X is the design model,
333 y is the vector of observed independent variables
334 pi is the vector of estimates for y
337 the likelihood is stored in LIKELIHOOD;
338 the predicted values are placed in the respective tn, fn, tp fp values in RES
341 xt_times_y_pi (const struct lr_spec *cmd,
342 struct lr_result *res,
343 struct casereader *input,
344 const struct variable **x, size_t n_x,
345 const struct variable *y_var,
348 struct casereader *reader;
350 gsl_vector *output = gsl_vector_calloc (res->beta_hat->size);
353 res->tn = res->tp = res->fn = res->fp = 0;
354 for (reader = casereader_clone (input);
355 (c = casereader_read (reader)) != NULL; case_unref (c))
359 double pi = pi_hat (cmd, res, x, n_x, c);
360 double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
363 double y = map_dependent_var (cmd, res, case_data (c, y_var));
365 *likelihood *= pow (pi, weight * y) * pow (1 - pi, weight * (1 - y));
367 for (v0 = 0; v0 < res->beta_hat->size; ++v0)
369 double in0 = predictor_value (c, x, n_x, res->cats, v0);
370 double *o = gsl_vector_ptr (output, v0);
371 *o += in0 * (y - pi) * weight;
372 pred_y += gsl_vector_get (res->beta_hat, v0) * in0;
375 pred_y = 1 / (1.0 + exp(-pred_y));
376 assert (pred_y >= 0);
377 assert (pred_y <= 1);
379 if (pred_y <= cmd->cut_point)
395 casereader_destroy (reader);
402 /* "payload" functions for the categoricals.
403 The only function is to accumulate the frequency of each
408 frq_create (const void *aux1 UNUSED, void *aux2 UNUSED)
410 return xzalloc (sizeof (double));
414 frq_update (const void *aux1 UNUSED, void *aux2 UNUSED,
415 void *ud, const struct ccase *c UNUSED , double weight)
422 frq_destroy (const void *aux1 UNUSED, void *aux2 UNUSED, void *user_data UNUSED)
430 Makes an initial pass though the data, doing the following:
432 * Checks that the dependent variable is dichotomous,
433 * Creates and initialises the categoricals,
434 * Accumulates summary results,
435 * Calculates necessary initial values.
436 * Creates an initial value for \hat\beta the vector of beta_hats of \beta
438 Returns true if successful
441 initial_pass (const struct lr_spec *cmd, struct lr_result *res, struct casereader *input)
443 const int width = var_get_width (cmd->dep_var);
446 struct casereader *reader;
455 size_t n_coefficients = cmd->n_predictor_vars;
459 /* Create categoricals if appropriate */
460 if (cmd->n_cat_predictors > 0)
462 res->cp.create = frq_create;
463 res->cp.update = frq_update;
464 res->cp.calculate = NULL;
465 res->cp.destroy = frq_destroy;
467 res->cats = categoricals_create (cmd->cat_predictors, cmd->n_cat_predictors,
468 cmd->wv, cmd->exclude, MV_ANY);
470 categoricals_set_payload (res->cats, &res->cp, cmd, res);
474 for (reader = casereader_clone (input);
475 (c = casereader_read (reader)) != NULL; case_unref (c))
478 bool missing = false;
479 double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
480 const union value *depval = case_data (c, cmd->dep_var);
482 for (v = 0; v < cmd->n_indep_vars; ++v)
484 const union value *val = case_data (c, cmd->indep_vars[v]);
485 if (var_is_value_missing (cmd->indep_vars[v], val, cmd->exclude))
492 /* Accumulate the missing and non-missing counts */
500 /* Find the values of the dependent variable */
503 value_clone (&res->y0, depval, width);
508 if ( !value_equal (&res->y0, depval, width))
510 value_clone (&res->y1, depval, width);
516 if (! value_equal (&res->y0, depval, width)
518 ! value_equal (&res->y1, depval, width)
521 msg (ME, _("Dependent variable's values are not dichotomous."));
526 if (v0set && value_equal (&res->y0, depval, width))
529 if (v1set && value_equal (&res->y1, depval, width))
535 categoricals_update (res->cats, c);
537 casereader_destroy (reader);
539 categoricals_done (res->cats);
543 /* Ensure that Y0 is less than Y1. Otherwise the mapping gets
544 inverted, which is confusing to users */
545 if (var_is_numeric (cmd->dep_var) && value_compare_3way (&res->y0, &res->y1, width) > 0)
548 value_clone (&tmp, &res->y0, width);
549 value_copy (&res->y0, &res->y1, width);
550 value_copy (&res->y1, &tmp, width);
551 value_destroy (&tmp, width);
555 n_coefficients += categoricals_df_total (res->cats);
556 res->beta_hat = gsl_vector_calloc (n_coefficients);
560 double mean = sum / res->cc;
561 gsl_vector_set (res->beta_hat, res->beta_hat->size - 1, log (mean / (1 - mean)));
567 casereader_destroy (reader);
573 /* Start of the logistic regression routine proper */
575 run_lr (const struct lr_spec *cmd, struct casereader *input,
576 const struct dataset *ds UNUSED)
580 bool converged = false;
582 /* Set the likelihoods to a negative sentinel value */
583 double likelihood = -1;
584 double prev_likelihood = -1;
585 double initial_likelihood = -1;
587 struct lr_result work;
589 work.n_nonmissing = 0;
590 work.warn_bad_weight = true;
592 work.beta_hat = NULL;
594 /* Get the initial estimates of \beta and their standard errors.
595 And perform other auxilliary initialisation. */
596 if (! initial_pass (cmd, &work, input))
599 for (i = 0; i < cmd->n_cat_predictors; ++i)
601 if (1 >= categoricals_n_count (work.cats, i))
604 ds_init_empty (&str);
606 interaction_to_string (cmd->cat_predictors[i], &str);
608 msg (ME, _("Category %s does not have at least two distinct values. Logistic regression will not be run."),
615 output_depvarmap (cmd, &work);
617 case_processing_summary (&work);
620 input = casereader_create_filter_missing (input,
628 work.hessian = gsl_matrix_calloc (work.beta_hat->size, work.beta_hat->size);
630 /* Start the Newton Raphson iteration process... */
631 for( i = 0 ; i < cmd->max_iter ; ++i)
637 hessian (cmd, &work, input,
638 cmd->predictor_vars, cmd->n_predictor_vars,
641 gsl_linalg_cholesky_decomp (work.hessian);
642 gsl_linalg_cholesky_invert (work.hessian);
644 v = xt_times_y_pi (cmd, &work, input,
645 cmd->predictor_vars, cmd->n_predictor_vars,
651 gsl_vector *delta = gsl_vector_alloc (v->size);
652 gsl_blas_dgemv (CblasNoTrans, 1.0, work.hessian, v, 0, delta);
656 gsl_vector_add (work.beta_hat, delta);
658 gsl_vector_minmax (delta, &min, &max);
660 if ( fabs (min) < cmd->bcon && fabs (max) < cmd->bcon)
662 msg (MN, _("Estimation terminated at iteration number %d because parameter estimates changed by less than %g"),
667 gsl_vector_free (delta);
670 if ( prev_likelihood >= 0)
672 if (-log (likelihood) > -(1.0 - cmd->lcon) * log (prev_likelihood))
674 msg (MN, _("Estimation terminated at iteration number %d because Log Likelihood decreased by less than %g%%"), i + 1, 100 * cmd->lcon);
679 initial_likelihood = likelihood;
680 prev_likelihood = likelihood;
685 casereader_destroy (input);
686 assert (initial_likelihood >= 0);
689 msg (MW, _("Estimation terminated at iteration number %d because maximum iterations has been reached"), i );
692 output_model_summary (&work, initial_likelihood, likelihood);
695 output_categories (cmd, &work);
697 output_classification_table (cmd, &work);
698 output_variables (cmd, &work);
700 gsl_matrix_free (work.hessian);
701 gsl_vector_free (work.beta_hat);
703 categoricals_destroy (work.cats);
710 struct hmap_node node; /* Node in hash map. */
711 const struct variable *var; /* The variable */
714 static struct variable_node *
715 lookup_variable (const struct hmap *map, const struct variable *var, unsigned int hash)
717 struct variable_node *vn = NULL;
718 HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
723 fprintf (stderr, "Warning: Hash table collision\n");
730 /* Parse the LOGISTIC REGRESSION command syntax */
732 cmd_logistic (struct lexer *lexer, struct dataset *ds)
734 /* Temporary location for the predictor variables.
735 These may or may not include the categorical predictors */
736 const struct variable **pred_vars;
741 lr.dict = dataset_dict (ds);
742 lr.n_predictor_vars = 0;
743 lr.predictor_vars = NULL;
745 lr.wv = dict_get_weight (lr.dict);
749 lr.min_epsilon = 0.00000001;
753 lr.print = PRINT_DEFAULT;
754 lr.cat_predictors = NULL;
755 lr.n_cat_predictors = 0;
756 lr.indep_vars = NULL;
759 if (lex_match_id (lexer, "VARIABLES"))
760 lex_match (lexer, T_EQUALS);
762 if (! (lr.dep_var = parse_variable_const (lexer, lr.dict)))
765 lex_force_match (lexer, T_WITH);
767 if (!parse_variables_const (lexer, lr.dict,
768 &pred_vars, &n_pred_vars,
773 while (lex_token (lexer) != T_ENDCMD)
775 lex_match (lexer, T_SLASH);
777 if (lex_match_id (lexer, "MISSING"))
779 lex_match (lexer, T_EQUALS);
780 while (lex_token (lexer) != T_ENDCMD
781 && lex_token (lexer) != T_SLASH)
783 if (lex_match_id (lexer, "INCLUDE"))
785 lr.exclude = MV_SYSTEM;
787 else if (lex_match_id (lexer, "EXCLUDE"))
793 lex_error (lexer, NULL);
798 else if (lex_match_id (lexer, "ORIGIN"))
802 else if (lex_match_id (lexer, "NOORIGIN"))
806 else if (lex_match_id (lexer, "NOCONST"))
810 else if (lex_match_id (lexer, "EXTERNAL"))
812 /* This is for compatibility. It does nothing */
814 else if (lex_match_id (lexer, "CATEGORICAL"))
816 lex_match (lexer, T_EQUALS);
819 lr.cat_predictors = xrealloc (lr.cat_predictors,
820 sizeof (*lr.cat_predictors) * ++lr.n_cat_predictors);
821 lr.cat_predictors[lr.n_cat_predictors - 1] = 0;
823 while (parse_design_interaction (lexer, lr.dict,
824 lr.cat_predictors + lr.n_cat_predictors - 1));
825 lr.n_cat_predictors--;
827 else if (lex_match_id (lexer, "PRINT"))
829 lex_match (lexer, T_EQUALS);
830 while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
832 if (lex_match_id (lexer, "DEFAULT"))
834 lr.print |= PRINT_DEFAULT;
836 else if (lex_match_id (lexer, "SUMMARY"))
838 lr.print |= PRINT_SUMMARY;
841 else if (lex_match_id (lexer, "CORR"))
843 lr.print |= PRINT_CORR;
845 else if (lex_match_id (lexer, "ITER"))
847 lr.print |= PRINT_ITER;
849 else if (lex_match_id (lexer, "GOODFIT"))
851 lr.print |= PRINT_GOODFIT;
854 else if (lex_match_id (lexer, "CI"))
856 lr.print |= PRINT_CI;
857 if (lex_force_match (lexer, T_LPAREN))
859 if (! lex_force_int (lexer))
861 lex_error (lexer, NULL);
864 lr.confidence = lex_integer (lexer);
866 if ( ! lex_force_match (lexer, T_RPAREN))
868 lex_error (lexer, NULL);
873 else if (lex_match_id (lexer, "ALL"))
879 lex_error (lexer, NULL);
884 else if (lex_match_id (lexer, "CRITERIA"))
886 lex_match (lexer, T_EQUALS);
887 while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
889 if (lex_match_id (lexer, "BCON"))
891 if (lex_force_match (lexer, T_LPAREN))
893 if (! lex_force_num (lexer))
895 lex_error (lexer, NULL);
898 lr.bcon = lex_number (lexer);
900 if ( ! lex_force_match (lexer, T_RPAREN))
902 lex_error (lexer, NULL);
907 else if (lex_match_id (lexer, "ITERATE"))
909 if (lex_force_match (lexer, T_LPAREN))
911 if (! lex_force_int (lexer))
913 lex_error (lexer, NULL);
916 lr.max_iter = lex_integer (lexer);
918 if ( ! lex_force_match (lexer, T_RPAREN))
920 lex_error (lexer, NULL);
925 else if (lex_match_id (lexer, "LCON"))
927 if (lex_force_match (lexer, T_LPAREN))
929 if (! lex_force_num (lexer))
931 lex_error (lexer, NULL);
934 lr.lcon = lex_number (lexer);
936 if ( ! lex_force_match (lexer, T_RPAREN))
938 lex_error (lexer, NULL);
943 else if (lex_match_id (lexer, "EPS"))
945 if (lex_force_match (lexer, T_LPAREN))
947 if (! lex_force_num (lexer))
949 lex_error (lexer, NULL);
952 lr.min_epsilon = lex_number (lexer);
954 if ( ! lex_force_match (lexer, T_RPAREN))
956 lex_error (lexer, NULL);
961 else if (lex_match_id (lexer, "CUT"))
963 if (lex_force_match (lexer, T_LPAREN))
965 if (! lex_force_num (lexer))
967 lex_error (lexer, NULL);
970 lr.cut_point = lex_number (lexer);
971 if (lr.cut_point < 0 || lr.cut_point > 1.0)
973 msg (ME, _("Cut point value must be in the range [0,1]"));
977 if ( ! lex_force_match (lexer, T_RPAREN))
979 lex_error (lexer, NULL);
986 lex_error (lexer, NULL);
993 lex_error (lexer, NULL);
998 /* Copy the predictor variables from the temporary location into the
999 final one, dropping any categorical variables which appear there.
1000 FIXME: This is O(NxM).
1004 struct variable_node *vn, *next;
1005 struct hmap allvars;
1006 hmap_init (&allvars);
1007 for (v = x = 0; v < n_pred_vars; ++v)
1010 const struct variable *var = pred_vars[v];
1013 unsigned int hash = hash_pointer (var, 0);
1014 struct variable_node *vn = lookup_variable (&allvars, var, hash);
1017 vn = xmalloc (sizeof *vn);
1019 hmap_insert (&allvars, &vn->node, hash);
1022 for (cv = 0; cv < lr.n_cat_predictors ; ++cv)
1025 const struct interaction *iact = lr.cat_predictors[cv];
1026 for (iv = 0 ; iv < iact->n_vars ; ++iv)
1028 const struct variable *ivar = iact->vars[iv];
1029 unsigned int hash = hash_pointer (ivar, 0);
1030 struct variable_node *vn = lookup_variable (&allvars, ivar, hash);
1033 vn = xmalloc (sizeof *vn);
1036 hmap_insert (&allvars, &vn->node, hash);
1049 lr.predictor_vars = xrealloc (lr.predictor_vars, sizeof *lr.predictor_vars * (x + 1));
1050 lr.predictor_vars[x++] = var;
1051 lr.n_predictor_vars++;
1055 lr.n_indep_vars = hmap_count (&allvars);
1056 lr.indep_vars = xmalloc (lr.n_indep_vars * sizeof *lr.indep_vars);
1058 /* Interate over each variable and push it into the array */
1060 HMAP_FOR_EACH_SAFE (vn, next, struct variable_node, node, &allvars)
1062 lr.indep_vars[x++] = vn->var;
1065 hmap_destroy (&allvars);
1069 /* logistical regression for each split group */
1071 struct casegrouper *grouper;
1072 struct casereader *group;
1075 grouper = casegrouper_create_splits (proc_open (ds), lr.dict);
1076 while (casegrouper_get_next_group (grouper, &group))
1077 ok = run_lr (&lr, group, ds);
1078 ok = casegrouper_destroy (grouper);
1079 ok = proc_commit (ds) && ok;
1082 free (lr.predictor_vars);
1083 free (lr.cat_predictors);
1084 free (lr.indep_vars);
1090 free (lr.predictor_vars);
1091 free (lr.cat_predictors);
1092 free (lr.indep_vars);
1100 /* Show the Dependent Variable Encoding box.
1101 This indicates how the dependent variable
1102 is mapped to the internal zero/one values.
1105 output_depvarmap (const struct lr_spec *cmd, const struct lr_result *res)
1107 const int heading_columns = 0;
1108 const int heading_rows = 1;
1109 struct tab_table *t;
1113 int nr = heading_rows + 2;
1115 t = tab_create (nc, nr);
1116 tab_title (t, _("Dependent Variable Encoding"));
1118 tab_headers (t, heading_columns, 0, heading_rows, 0);
1120 tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1122 tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1123 tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1125 tab_text (t, 0, 0, TAB_CENTER | TAT_TITLE, _("Original Value"));
1126 tab_text (t, 1, 0, TAB_CENTER | TAT_TITLE, _("Internal Value"));
1130 ds_init_empty (&str);
1131 var_append_value_name (cmd->dep_var, &res->y0, &str);
1132 tab_text (t, 0, 0 + heading_rows, 0, ds_cstr (&str));
1135 var_append_value_name (cmd->dep_var, &res->y1, &str);
1136 tab_text (t, 0, 1 + heading_rows, 0, ds_cstr (&str));
1139 tab_double (t, 1, 0 + heading_rows, 0, map_dependent_var (cmd, res, &res->y0), &F_8_0);
1140 tab_double (t, 1, 1 + heading_rows, 0, map_dependent_var (cmd, res, &res->y1), &F_8_0);
1147 /* Show the Variables in the Equation box */
1149 output_variables (const struct lr_spec *cmd,
1150 const struct lr_result *res)
1153 const int heading_columns = 1;
1154 int heading_rows = 1;
1155 struct tab_table *t;
1161 int idx_correction = 0;
1163 if (cmd->print & PRINT_CI)
1169 nr = heading_rows + cmd->n_predictor_vars;
1174 nr += categoricals_df_total (res->cats) + cmd->n_cat_predictors;
1176 t = tab_create (nc, nr);
1177 tab_title (t, _("Variables in the Equation"));
1179 tab_headers (t, heading_columns, 0, heading_rows, 0);
1181 tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1183 tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1184 tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1186 tab_text (t, 0, row + 1, TAB_CENTER | TAT_TITLE, _("Step 1"));
1188 tab_text (t, 2, row, TAB_CENTER | TAT_TITLE, _("B"));
1189 tab_text (t, 3, row, TAB_CENTER | TAT_TITLE, _("S.E."));
1190 tab_text (t, 4, row, TAB_CENTER | TAT_TITLE, _("Wald"));
1191 tab_text (t, 5, row, TAB_CENTER | TAT_TITLE, _("df"));
1192 tab_text (t, 6, row, TAB_CENTER | TAT_TITLE, _("Sig."));
1193 tab_text (t, 7, row, TAB_CENTER | TAT_TITLE, _("Exp(B)"));
1195 if (cmd->print & PRINT_CI)
1197 tab_joint_text_format (t, 8, 0, 9, 0,
1198 TAB_CENTER | TAT_TITLE, _("%d%% CI for Exp(B)"), cmd->confidence);
1200 tab_text (t, 8, row, TAB_CENTER | TAT_TITLE, _("Lower"));
1201 tab_text (t, 9, row, TAB_CENTER | TAT_TITLE, _("Upper"));
1204 for (row = heading_rows ; row < nr; ++row)
1206 const int idx = row - heading_rows - idx_correction;
1208 const double b = gsl_vector_get (res->beta_hat, idx);
1209 const double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
1210 const double wald = pow2 (b) / sigma2;
1211 const double df = 1;
1213 if (idx < cmd->n_predictor_vars)
1215 tab_text (t, 1, row, TAB_LEFT | TAT_TITLE,
1216 var_to_string (cmd->predictor_vars[idx]));
1218 else if (i < cmd->n_cat_predictors)
1221 bool summary = false;
1223 const struct interaction *cat_predictors = cmd->cat_predictors[i];
1224 const int df = categoricals_df (res->cats, i);
1226 ds_init_empty (&str);
1227 interaction_to_string (cat_predictors, &str);
1231 /* Calculate the Wald statistic,
1232 which is \beta' C^-1 \beta .
1233 where \beta is the vector of the coefficient estimates comprising this
1234 categorial variable. and C is the corresponding submatrix of the
1237 gsl_matrix_const_view mv =
1238 gsl_matrix_const_submatrix (res->hessian, idx, idx, df, df);
1239 gsl_matrix *subhessian = gsl_matrix_alloc (mv.matrix.size1, mv.matrix.size2);
1240 gsl_vector_const_view vv = gsl_vector_const_subvector (res->beta_hat, idx, df);
1241 gsl_vector *temp = gsl_vector_alloc (df);
1243 gsl_matrix_memcpy (subhessian, &mv.matrix);
1244 gsl_linalg_cholesky_decomp (subhessian);
1245 gsl_linalg_cholesky_invert (subhessian);
1247 gsl_blas_dgemv (CblasTrans, 1.0, subhessian, &vv.vector, 0, temp);
1248 gsl_blas_ddot (temp, &vv.vector, &wald);
1250 tab_double (t, 4, row, 0, wald, 0);
1251 tab_double (t, 5, row, 0, df, &F_8_0);
1252 tab_double (t, 6, row, 0, gsl_cdf_chisq_Q (wald, df), 0);
1256 gsl_matrix_free (subhessian);
1257 gsl_vector_free (temp);
1261 ds_put_format (&str, "(%d)", ivar);
1264 tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, ds_cstr (&str));
1267 ++i; /* next interaction */
1278 tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, _("Constant"));
1281 tab_double (t, 2, row, 0, b, 0);
1282 tab_double (t, 3, row, 0, sqrt (sigma2), 0);
1283 tab_double (t, 4, row, 0, wald, 0);
1284 tab_double (t, 5, row, 0, df, &F_8_0);
1285 tab_double (t, 6, row, 0, gsl_cdf_chisq_Q (wald, df), 0);
1286 tab_double (t, 7, row, 0, exp (b), 0);
1288 if (cmd->print & PRINT_CI)
1290 double wc = gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0);
1291 wc *= sqrt (sigma2);
1293 if (idx < cmd->n_predictor_vars)
1295 tab_double (t, 8, row, 0, exp (b - wc), 0);
1296 tab_double (t, 9, row, 0, exp (b + wc), 0);
1305 /* Show the model summary box */
1307 output_model_summary (const struct lr_result *res,
1308 double initial_likelihood, double likelihood)
1310 const int heading_columns = 0;
1311 const int heading_rows = 1;
1312 struct tab_table *t;
1315 int nr = heading_rows + 1;
1318 t = tab_create (nc, nr);
1319 tab_title (t, _("Model Summary"));
1321 tab_headers (t, heading_columns, 0, heading_rows, 0);
1323 tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1325 tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1326 tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1328 tab_text (t, 0, 0, TAB_LEFT | TAT_TITLE, _("Step 1"));
1329 tab_text (t, 1, 0, TAB_CENTER | TAT_TITLE, _("-2 Log likelihood"));
1330 tab_double (t, 1, 1, 0, -2 * log (likelihood), 0);
1333 tab_text (t, 2, 0, TAB_CENTER | TAT_TITLE, _("Cox & Snell R Square"));
1334 cox = 1.0 - pow (initial_likelihood /likelihood, 2 / res->cc);
1335 tab_double (t, 2, 1, 0, cox, 0);
1337 tab_text (t, 3, 0, TAB_CENTER | TAT_TITLE, _("Nagelkerke R Square"));
1338 tab_double (t, 3, 1, 0, cox / ( 1.0 - pow (initial_likelihood, 2 / res->cc)), 0);
1344 /* Show the case processing summary box */
1346 case_processing_summary (const struct lr_result *res)
1348 const int heading_columns = 1;
1349 const int heading_rows = 1;
1350 struct tab_table *t;
1353 const int nr = heading_rows + 3;
1356 t = tab_create (nc, nr);
1357 tab_title (t, _("Case Processing Summary"));
1359 tab_headers (t, heading_columns, 0, heading_rows, 0);
1361 tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1363 tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1364 tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1366 tab_text (t, 0, 0, TAB_LEFT | TAT_TITLE, _("Unweighted Cases"));
1367 tab_text (t, 1, 0, TAB_CENTER | TAT_TITLE, _("N"));
1368 tab_text (t, 2, 0, TAB_CENTER | TAT_TITLE, _("Percent"));
1371 tab_text (t, 0, 1, TAB_LEFT | TAT_TITLE, _("Included in Analysis"));
1372 tab_text (t, 0, 2, TAB_LEFT | TAT_TITLE, _("Missing Cases"));
1373 tab_text (t, 0, 3, TAB_LEFT | TAT_TITLE, _("Total"));
1375 tab_double (t, 1, 1, 0, res->n_nonmissing, &F_8_0);
1376 tab_double (t, 1, 2, 0, res->n_missing, &F_8_0);
1378 total = res->n_nonmissing + res->n_missing;
1379 tab_double (t, 1, 3, 0, total , &F_8_0);
1381 tab_double (t, 2, 1, 0, 100 * res->n_nonmissing / (double) total, 0);
1382 tab_double (t, 2, 2, 0, 100 * res->n_missing / (double) total, 0);
1383 tab_double (t, 2, 3, 0, 100 * total / (double) total, 0);
1389 output_categories (const struct lr_spec *cmd, const struct lr_result *res)
1391 const struct fmt_spec *wfmt =
1392 cmd->wv ? var_get_print_format (cmd->wv) : &F_8_0;
1396 const int heading_columns = 2;
1397 const int heading_rows = 2;
1398 struct tab_table *t;
1408 for (i = 0; i < cmd->n_cat_predictors; ++i)
1410 size_t n = categoricals_n_count (res->cats, i);
1411 size_t df = categoricals_df (res->cats, i);
1417 nc = heading_columns + 1 + max_df;
1418 nr = heading_rows + total_cats;
1420 t = tab_create (nc, nr);
1421 tab_title (t, _("Categorical Variables' Codings"));
1423 tab_headers (t, heading_columns, 0, heading_rows, 0);
1425 tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1427 tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1428 tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1431 tab_text (t, heading_columns, 1, TAB_CENTER | TAT_TITLE, _("Frequency"));
1433 tab_joint_text_format (t, heading_columns + 1, 0, nc - 1, 0,
1434 TAB_CENTER | TAT_TITLE, _("Parameter coding"));
1437 for (i = 0; i < max_df; ++i)
1439 int c = heading_columns + 1 + i;
1440 tab_text_format (t, c, 1, TAB_CENTER | TAT_TITLE, _("(%d)"), i + 1);
1444 for (v = 0; v < cmd->n_cat_predictors; ++v)
1447 const struct interaction *cat_predictors = cmd->cat_predictors[v];
1448 int df = categoricals_df (res->cats, v);
1450 ds_init_empty (&str);
1452 interaction_to_string (cat_predictors, &str);
1454 tab_text (t, 0, heading_rows + r, TAB_LEFT | TAT_TITLE, ds_cstr (&str) );
1458 for (cat = 0; cat < categoricals_n_count (res->cats, v) ; ++cat)
1461 const struct ccase *c = categoricals_get_case_by_category_real (res->cats, v, cat);
1462 const double *freq = categoricals_get_user_data_by_category_real (res->cats, v, cat);
1465 ds_init_empty (&str);
1467 for (x = 0; x < cat_predictors->n_vars; ++x)
1469 const union value *val = case_data (c, cat_predictors->vars[x]);
1470 var_append_value_name (cat_predictors->vars[x], val, &str);
1472 if (x < cat_predictors->n_vars - 1)
1473 ds_put_cstr (&str, " ");
1476 tab_text (t, 1, heading_rows + r, 0, ds_cstr (&str));
1478 tab_double (t, 2, heading_rows + r, 0, *freq, wfmt);
1480 for (x = 0; x < df; ++x)
1482 tab_double (t, heading_columns + 1 + x, heading_rows + r, 0, (cat == x), &F_8_0);
1486 cumulative_df += df;
1495 output_classification_table (const struct lr_spec *cmd, const struct lr_result *res)
1497 const struct fmt_spec *wfmt =
1498 cmd->wv ? var_get_print_format (cmd->wv) : &F_8_0;
1500 const int heading_columns = 3;
1501 const int heading_rows = 3;
1503 struct string sv0, sv1;
1505 const int nc = heading_columns + 3;
1506 const int nr = heading_rows + 3;
1508 struct tab_table *t = tab_create (nc, nr);
1510 ds_init_empty (&sv0);
1511 ds_init_empty (&sv1);
1513 tab_title (t, _("Classification Table"));
1515 tab_headers (t, heading_columns, 0, heading_rows, 0);
1517 tab_box (t, TAL_2, TAL_2, -1, -1, 0, 0, nc - 1, nr - 1);
1518 tab_box (t, -1, -1, -1, TAL_1, heading_columns, 0, nc - 1, nr - 1);
1520 tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1521 tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1523 tab_text (t, 0, heading_rows, TAB_CENTER | TAT_TITLE, _("Step 1"));
1526 tab_joint_text (t, heading_columns, 0, nc - 1, 0,
1527 TAB_CENTER | TAT_TITLE, _("Predicted"));
1529 tab_joint_text (t, heading_columns, 1, heading_columns + 1, 1,
1530 0, var_to_string (cmd->dep_var) );
1532 tab_joint_text (t, 1, 2, 2, 2,
1533 TAB_LEFT | TAT_TITLE, _("Observed"));
1535 tab_text (t, 1, 3, TAB_LEFT, var_to_string (cmd->dep_var) );
1538 tab_joint_text (t, nc - 1, 1, nc - 1, 2,
1539 TAB_CENTER | TAT_TITLE, _("Percentage\nCorrect"));
1542 tab_joint_text (t, 1, nr - 1, 2, nr - 1,
1543 TAB_LEFT | TAT_TITLE, _("Overall Percentage"));
1546 tab_hline (t, TAL_1, 1, nc - 1, nr - 1);
1548 var_append_value_name (cmd->dep_var, &res->y0, &sv0);
1549 var_append_value_name (cmd->dep_var, &res->y1, &sv1);
1551 tab_text (t, 2, heading_rows, TAB_LEFT, ds_cstr (&sv0));
1552 tab_text (t, 2, heading_rows + 1, TAB_LEFT, ds_cstr (&sv1));
1554 tab_text (t, heading_columns, 2, 0, ds_cstr (&sv0));
1555 tab_text (t, heading_columns + 1, 2, 0, ds_cstr (&sv1));
1560 tab_double (t, heading_columns, 3, 0, res->tn, wfmt);
1561 tab_double (t, heading_columns + 1, 4, 0, res->tp, wfmt);
1563 tab_double (t, heading_columns + 1, 3, 0, res->fp, wfmt);
1564 tab_double (t, heading_columns, 4, 0, res->fn, wfmt);
1566 tab_double (t, heading_columns + 2, 3, 0, 100 * res->tn / (res->tn + res->fp), 0);
1567 tab_double (t, heading_columns + 2, 4, 0, 100 * res->tp / (res->tp + res->fn), 0);
1569 tab_double (t, heading_columns + 2, 5, 0,
1570 100 * (res->tp + res->tn) / (res->tp + res->tn + res->fp + res->fn), 0);