Description Usage Arguments Details Value Author(s) References See Also Examples
Fit one or a series of Logic Regression models, carry out crossvalidation or permutation tests for such models, or fit Monte Carlo Logic Regression models.
Logic regression is a (generalized) regression methodology that is
primarily applied when most of the covariates in the data to be
analyzed are binary. The goal of logic regression is to find
predictors that are Boolean (logical) combinations of the original
predictors. Currently the Logic Regression methodology has scoring
functions for linear regression (residual sum of squares), logistic
regression (deviance), classification (misclassification),
proportional hazards models (partial likelihood),
and exponential survival models (loglikelihood). A feature of the
Logic Regression methodology is that it is easily possible to extend
the method to write ones own scoring function if you have a different
scoring function. logreg.myown
contains information on how to
do so.
1 2 3 
resp 
vector with the response variables. Let 
bin 
matrix or data frame with binary data. Let 
sep 
(optional) matrix or data frame that is fitted additively
in the logic regression model. 
wgt 
(optional) vector of length 
cens 
(optional) an indicator variable with censoring
indicators if 
type 
type of model to be fit: (1) classification, (2)
regression, (3) logistic regression, (4) proportional hazards model
(Cox regression), (5) exponential
survival model, or (0) your own scoring function. If 
select 
type of model selection to be carried out: (1) fit a single model, (2) fit multiple models, (3) crossvalidation, (4) nullmodel permutation test, (5) conditional permutation test, (6) a greedy stepwise algorithm, or (7) Monte Carlo Logic Regression (using MCMC). See details below. 
ntrees 
number of logic trees to be fit. A single number if you
select to fit a single model ( 
nleaves 
maximum number of leaves to be fit in all trees
combined. A single number if you select to fit a single model
( 
penalty 
specifying the penalty parameter allows you to
penalize the score of larger models. The penalty takes the form

seed 
a seed for the random number generator. The random seed
is taken to be 
kfold 
the number of groups the cases are randomly assigned
to. In turn, the model is trained on 
nrep 
the number of runs on permuted data for each model size.
We recommend first running this program with a small number of
repetitions (e.g. 10 or 25) before sending off a big job. Only
relevant for the nullmodel test ( 
oldfit 
object of class 
anneal.control 
simulated annealing parameters  best set using
the function 
tree.control 
several secondary parameters  best set using the
function 
mc.control 
Markov chain Monte Carlo parameters  best set using the
function 
Logic Regression is an adaptive regression methodology that attempts to construct predictors as Boolean combinations of binary covariates.
In most regression problems a model is developed that only relates the main effects (the predictors or transformations thereof) to the response. Although interactions between predictors are considered sometimes as well, those interactions are usually kept simple (two to threeway interactions at most). But often, especially when all predictors are binary, the interaction between many predictors is what causes the differences in response. This issue often arises in the analysis of SNP microarray data or in data mining problems. Given a set of binary predictors X, we try to create new, better predictors for the response by considering combinations of those binary predictors. For example, if the response is binary as well (which is not required in general), we attempt to find decision rules such as “if X1, X2, X3 and X4 are true”, or “X5 or X6 but not X7 are true”, then the response is more likely to be in class 0. In other words, we try to find Boolean statements involving the binary predictors that enhance the prediction for the response. In more specific terms: Let X1,...,Xk be binary predictors, and let Y be a response variable. We try to fit regression models of the form g(E[Y]) = b0 + b1 L1+ ...+ bn Ln, where Lj is a Boolean expression of the predictors X, such as Lj=[(X2 or X4c) and X7]. The above framework includes many forms of regression, such as linear regression (g(E[Y])=E[Y]) and logistic regression (g(E[Y])=log(E[Y]/(1E[Y]))). For every model type, we define a score function that reflects the “quality” of the model under consideration. For example, for linear regression the score could be the residual sum of squares and for logistic regression the score could be the deviance. We try to find the Boolean expressions in the regression model that minimize the scoring function associated with this model type, estimating the parameters bj simultaneously with the Boolean expressions Lj. In general, any type of model can be considered, as long as a scoring function can be defined. For example, we also implemented the Cox proportional hazards model, using the partial likelihood as the score.
Since the number of possible Logic Models we can construct for a given set of predictors is huge, we have to rely on some search algorithms to help us find the best scoring models. We define the move set by a set of standard operations such as splitting and pruning the tree (similar to the terminology introduced by Breiman et al (1984) for CART). We investigated two types of algorithms: a greedy and a simulated annealing algorithm. While the greedy algorithm is very fast, it does not always find a good scoring model. The simulated annealing algorithm usually does, but computationally it is more expensive. Since we have to be certain to find good scoring models, we usually carry out simulated annealing for our case studies. However, as usual, the best scoring model generally overfits the data, and methods to separate signal and noise are needed. To assess the overfitting of large models, we offer the option to fit a model of a specific size. For the model selection itself we developed and implemented permutation tests and tests using crossvalidation. If sufficient data is available, an analysis using a training and a test set can also be carried out. These tests are rather complicated, so we will not go into detail here and refer you to Ruczinski I, Kooperberg C, LeBlanc ML (2003), cited below.
There are two alternatives to the simulated annealing algorithm. One
is a stepwise greedy selection of models. This is when setting
select = 6
, and yields a sequence of models from size 1 through
a maximum size. At each time among all the models that are one larger
than the current model the best model is selected, yielding a sequence
of models of different sizes. Usually these models are not the best
possible, and, if the simulated annealing chain is long enough, you
should expect that the models selected using select = 2
are better.
The second alternative is to run a Markov Chain Monte Carlo (MCMC) algorithm.
This is what is done in Monte Carlo Logic Regression. The algorithm used
is a reversible jump MCMC algorithm, due to Green (1995). Other than
the length of the Markov chain, the only parameter that needs to be set
is a parameter for the geometric prior on model size. Other than in many
MCMC problems, the goal in Monte Carlo Logic Regression is not to yield
one single best predicting model, but rather to provide summaries of
all models. These are exactly the elements that are shown above as
the output when select = 7
.
MONITORING
The help file for logreg.anneal.control
, contains more
information on how to monitor the simulated annealing optimization for
logreg. Here is some general information.
Find the best scoring model of any size (select = 1)
During the iterations the following information is printed out:
logtemp  current score  best score  acc /  rej /  sing  current parameters 
1.000  1.494  1.494  0( 0)  0  0  2.88 1.99 0.00 
1.120  1.150  1.043  655( 54)  220  71  3.63 0.15 1.82 
1.240  1.226  1.043  555( 49)  316  80  3.83 0.05 1.71 
...  
2.320  0.988  0.980  147( 36)  759  58  3.00 2.11 1.11 
2.440  0.982  0.980  25( 31)  884  60  2.89 2.12 1.24 
2.560  0.988  0.979  35( 61)  850  51  3.00 2.11 1.11 
...  
3.760  0.964  0.964  2( 22)  961  15  2.57 2.15 1.55 
3.880  0.964  0.964  0( 17)  961  22  2.57 2.15 1.55 
4.000  0.964  0.964  0( 13)  970  17  2.57 2.15 1.55 
logtemp:
logarithm (base 10) of the temperature at the last iteration before the print out.
current score:
the score after the last iterations.
best score:
the single lowest score seen at any iteration.
acc:
the number of proposed moves that were accepted since the last print
out for which the model changed, within parenthesis, the number of
those that were identical in score to the move before acceptance.
rej:
the number of proposed moves that gave numerically acceptable results,
but were rejected by the simulated annealing algorithm since the last
print out.
sing:
the number of proposed moves that were rejected because they gave
numerically unacceptable results, for example because they yielded a
singular system.
current parameters:
the values of the coefficients (first for the intercept, then for the
linear (separate) components, then for the logic trees).
This information can be used to judge the convergence of the simulated
annealing algorithm, as described in the help file of
logreg.anneal.control
. Typically we want (i) the number of
acceptances to be high in the beginning, (ii) the number of
acceptances with different scores to be low at the end, and (iii) the
number of iterations when the fraction of acceptances is moderate to
be as large as possible.
Find the best scoring models for various sizes
(select = 2)
During the iterations the same information as for find the best scoring model of any size, for each size model considered.
Carry out crossvalidation for model selection
(select = 3)
Information about the simulated annealing as described above can be printed out. Otherwise, during the crossvalidation process information like
Step 5 of 10 [ 2 trees; 4 leaves] The CV score is 1.127 1.120 1.052 1.122
The first of the four scores is the trainingset score on the current validation sample, the second score is the average of all the trainingset scores that have been processed for this model size, the third is the testset score on the current validation sample, and the fourth score is the average of all the testset scores that have been processed for this model size. Typically we would prefer the model with the lowest testset score average over all crossvalidation steps.
Carry out a permutation test to check for signal in the data
(select = 4)
Information about the simulated annealing as described above can be printed out. Otherwise, first the score of the model of size 0 (typically only fitting an intercept) and the score of the best model are printed out. Then during the permutation lines like
Permutation number 21 out of 50 has score 1.47777
are printed. Each score is the result of fitting a logic tree model, on data where the response has been permuted. Typically we would believe that there is signal in the data if most permutations have worse (higher) scores than the best model, but we may believe that there is substantial overfitting going on if these permutation scores are much better (lower) than the score of the model of size 0.
Carry out a permutation test for model selection
(select = 5)
To be able to run this option, an object of class logreg
that
was run with (select = 2)
needs to be in place. Information
about the simulated annealing as described above can be printed
out. Otherwise, lines like
Permutation number 8 out of 25 has score 1.00767 model size 3 with 2 tree(s)
are printed. We can compare these scores to the tree of the same size
and the best tree. If the scores are about the same as the one for
the best tree, we think that the “true” model size may be the one
that is being tested, while if the scores are much worse, the true
model size may be larger. The comparison with the model of the same
size suggests us again how much overfitting may be going on.
plot.logreg
generates informative histograms.
Greedy stepwise selection of Logic Regression models
(select = 6)
The scores of the best greedy models of each size are printed.
Monte Carlo Logic Regression
(select = 7)
A status line is printed every so many iterations. This information is probably not very useful, other than that it helps you figure out how far the code is.
PARAMETERS
As Logic Regression is written in Fortran 77 some parameters had to be hard coded in. The default values of these parameters are
maximum sample size: 20000
maximum number of columns in the input file: 1000
maximum number of leaves in a logic tree: 128
maximum number of logic trees: 5
maximum number of separate parameters: 50
maximum number of total parameters(separate + trees): 55
If these parameters are not large enough (an error message will let you know this), you need to reset them in slogic.f and recompile. In particular, the statements defining these parameters are
PARAMETER (LGCn1MAX = 20000)
PARAMETER (LGCn2MAX = 1000)
PARAMETER (LGCnknMAX = 128)
PARAMETER (LGCntrMAX = 5)
PARAMETER (LGCnsepMAX = 50)
PARAMETER (LGCbetaMAX = 55)
The unfortunate thing is that you will have to change these parameter definitions several times in the code. So search until you have found them all.
An object of the class logreg
. This contains virtually all
input parameters, and in addition
If select = 1:
an object of class logregmodel
: the Logic
Regression model. This model contains a list of ntrees
objects
of class logregtree
.
If select = 2
or select = 6
:
nmodels:
the number of models fitted.
allscores:
a matrix with 3 columns, containing the scores of all models. Column 1
contains the score, column 2 the number of leaves and column 3 the
number of trees.
alltrees:
a list with nmodels
objects of class logregmodel
.
If select = 3:
cvscores:
a matrix with the results of cross validation. The train.ave
and test.ave
columns for train and test contain running
averages of the scores for individual validation sets. As such these
scores are of most interest for the rows where k=kfold
.
If select = 4:
nullscore:
score of the nullmodel.
bestscore:
score of the best model.
randscores:
scores of the permutations; vector of length nrep
.
If select = 5:
bestscore:
score of the best model.
randscores:
scores of the permutations; each column corresponds to one model
size.
If select = 7:
size:
a matrix with two columns, indicating which size models
were fit how often.
single:
a vector with as many elements as there are binary
predictors. single[i]
shows how often predictor i
is
in any of the MCMC models. Note that when a predictor is twice in the
same model, it is only counted once, thus, in particular,
sum(size[,1]*size[,2]
will typically be slightly larger
than sum(single)
.
double:
square matrix with as size the number of binary predictors.
double[i,j]
shows how often predictors i
and j
are
in the same tree of the same MCMC model if
i>j
, if i<=j
double[i,j]
equals zero. Note that
for models
with several logic trees two predictors can both be in the model but not
be in the same tree.
triple:
square 3D array with as size the number of binary predictors.
See double
, but here triple[i,j,k]
shows how often
three predictors are jointly in one logic tree.
In addition, the file
slogiclisting.tmp
in the current working directory can be
created. This file contains a compact listing of all models visited. Column 1:
proportional to the log posterior probability of the model; column 2: score
(loglikelihood); column 3: how often was this model visited, column 4 through 3 + maximum number
of leaves: summary of the first tree, if there are two trees,
column 4 + maximum number of leaves through 3 + twice the maximum number
of leaves contains the second tree, and so on.
In this compact notation, leaves are in the same sequence as the rows in
a logregtree
object; a zero means that the leave is empty, a
1000 means an “and” and a 2000 an “or”, any other positive number
means a predictor and a negative number means “not” that predictor.
The mc.control
element output
can be used to surppress the
creation of
double
, triple
, and/or slogiclisting.tmp
. There doesn't
seem to be too much use in surppressing double
. Surpressing
triple
speeds up computations a bit (in particular on
machines with limited memory when there are many binary predictors), and reduces the size of
both the code and the object, surppressing slogiclisting.tmp
saves the creation of a possibly very large file, which can slow
down the code considerably. See logreg.mc.control
for details.
Ingo Ruczinski [email protected] and Charles Kooperberg [email protected].
Ruczinski I, Kooperberg C, LeBlanc ML (2003). Logic Regression, Journal of Computational and Graphical Statistics, 12, 475511.
Ruczinski I, Kooperberg C, LeBlanc ML (2002). Logic Regression  methods and software. Proceedings of the MSRI workshop on Nonlinear Estimation and Classification (Eds: D. Denison, M. Hansen, C. Holmes, B. Mallick, B. Yu), Springer: New York, 333344.
Kooperberg C, Ruczinski I, LeBlanc ML, Hsu L (2001). Sequence Analysis using Logic Regression, Genetic Epidemiology, 21, S626S631.
Kooperberg C, Ruczinki I (2005). Identifying interacting SNPs using Monte Carlo Logic Regression, Genetic Epidemiology, 28, 157170.
Selected chapters from the dissertation of Ingo Ruczinski, available from http://kooperberg.fhcrc.org/logic/documents/ingophdlogic.pdf
eval.logreg
,
frame.logreg
,
plot.logreg
,
print.logreg
,
predict.logreg
,
logregtree
,
plot.logregtree
,
print.logregtree
,
logregmodel
,
plot.logregtree
,
print.logregtree
,
logreg.myown
,
logreg.anneal.control
,
logreg.tree.control
,
logreg.mc.control
,
logreg.testdat
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90  data(logreg.savefit1,logreg.savefit2,logreg.savefit3,logreg.savefit4,
logreg.savefit5,logreg.savefit6,logreg.savefit7,logreg.testdat)
myanneal < logreg.anneal.control(start = 1, end = 4, iter = 500, update = 100)
# in practie we would use 25000 iterations or far more  the use of 500 is only
# to have the examples run fast
## Not run: myanneal < logreg.anneal.control(start = 1, end = 4, iter = 25000, update = 500)
fit1 < logreg(resp = logreg.testdat[,1], bin=logreg.testdat[, 2:21], type = 2,
select = 1, ntrees = 2, anneal.control = myanneal)
# the best score should be in the 0.951.10 range
plot(fit1)
# you'll probably see X1X4 as well as a few noise predictors
# use logreg.savefit1 for the results with 25000 iterations
plot(logreg.savefit1)
print(logreg.savefit1)
z < predict(logreg.savefit1)
plot(z, logreg.testdat[,1]z, xlab="fitted values", ylab="residuals")
# there are some streaks, thanks to the very discrete predictions
#
# a bit less output
myanneal2 < logreg.anneal.control(start = 1, end = 4, iter = 500, update = 0)
# in practie we would use 25000 iterations or more  the use of 500 is only
# to have the examples run fast
## Not run: myanneal2 < logreg.anneal.control(start = 1, end = 4, iter = 25000, update = 0)
#
# fit multiple models
fit2 < logreg(resp = logreg.testdat[,1], bin=logreg.testdat[, 2:21], type = 2,
select = 2, ntrees = c(1,2), nleaves =c(1,7), anneal.control = myanneal2)
# equivalent
## Not run: fit2 < logreg(select = 2, ntrees = c(1,2), nleaves =c(1,7), oldfit = fit1,
anneal.control = myanneal2)
## End(Not run)
plot(fit2)
# use logreg.savefit2 for the results with 25000 iterations
plot(logreg.savefit2)
print(logreg.savefit2)
# After an initial steep decline, the scores only get slightly better
# for models with more than four leaves and two trees.
#
# cross validation
fit3 < logreg(resp = logreg.testdat[,1], bin=logreg.testdat[, 2:21], type = 2,
select = 3, ntrees = c(1,2), nleaves=c(1,7), anneal.control = myanneal2)
# equivalent
## Not run: fit3 < logreg(select = 3, oldfit = fit2)
plot(fit3)
# use logreg.savefit3 for the results with 25000 iterations
plot(logreg.savefit3)
# 4 leaves, 2 trees should top
# null model test
fit4 < logreg(resp = logreg.testdat[,1], bin=logreg.testdat[, 2:21], type = 2,
select = 4, ntrees = 2, anneal.control = myanneal2)
# equivalent
## Not run: fit4 < logreg(select = 4, anneal.control = myanneal2, oldfit = fit1)
plot(fit4)
# use logreg.savefit4 for the results with 25000 iterations
plot(logreg.savefit4)
# A histogram of the 25 scores obtained from the permutation test. Also shown
# are the scores for the best scoring model with one logic tree, and the null
# model (no tree). Since the permutation scores are not even close to the score
# of the best model with one tree (fit on the original data), there is overwhelming
# evidence against the null hypothesis that there was no signal in the data.
fit5 < logreg(resp = logreg.testdat[,1], bin=logreg.testdat[, 2:21], type = 2,
select = 5, ntrees = c(1,2), nleaves=c(1,7), anneal.control = myanneal2,
nrep = 10, oldfit = fit2)
# equivalent
## Not run: fit5 < logreg(select = 5, nrep = 10, oldfit = fit2)
plot(fit5)
# use logreg.savefit5 for the results with 25000 iterations and 25 permutations
plot(logreg.savefit5)
# The permutation scores improve until we condition on a model with two trees and
# four leaves, and then do not change very much anymore. This indicates that the
# best model has indeed four leaves.
#
# greedy selection
fit6 < logreg(select = 6, ntrees = 2, nleaves =c(1,12), oldfit = fit1)
plot(fit6)
# use logreg.savefit6 for the results with 25000 iterations
plot(logreg.savefit6)
#
# Monte Carlo Logic Regression
fit7 < logreg(select = 7, oldfit = fit1, mc.control=
logreg.mc.control(nburn=500, niter=2500, hyperpars=log(2)))
# we need many more iterations for reasonable results
## Not run: logreg.savefit7 < logreg(select = 7, oldfit = fit1, mc.control=
logreg.mc.control(nburn=1000, niter=100000, hyperpars=log(2)))
## End(Not run)
#
plot(fit7)
# use logreg.savefit7 for the results with 25000 iterations
plot(logreg.savefit7)

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.