hex.glm

Class ComputationState

java.lang.Object

hex.glm.ComputationState

public final class ComputationState
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ComputationState.GLMSubsetGinfo This method will grab a subset of the gradient for each multinomial class.
static class	ComputationState.GramGrad
static class	ComputationState.GramXY Cached state of COD (with covariate updates) solver.

Field Summary

Fields

Modifier and Type	Field and Description
DataInfo[]	_activeDataMultinomial
ConstrainedGLMUtils.ConstraintGLMStates	_csGLMState
boolean	_lsNeeded
boolean	_noReg
GLMModel.GLMParameters	_parms
static double	EPS_CS
static double	EPS_CS_SQUARE

Constructor Summary

Constructors

Constructor and Description
ComputationState(water.Job job, GLMModel.GLMParameters parms, DataInfo dinfo, GLM.BetaConstraint bc, GLM.BetaInfo bi)
ComputationState(water.Job job, GLMModel.GLMParameters parms, DataInfo dinfo, GLM.BetaConstraint bc, GLM.BetaInfo bi, double[][][] penaltyMat, int[][] gamColInd)

Method Summary

Modifier and Type	Method and Description
GLM.BetaConstraint	activeBC()
DataInfo	activeData()
DataInfo	activeDataMultinomial()
DataInfo	activeDataMultinomial(int c)
static double	addConstraintObj(double[] lambda, ConstrainedGLMUtils.LinearConstraints[] constraints, double ckHalf) This method adds to objective function the contribution of transpose(lambda)*constraint vector + ck/2*transpose(constraint vector)*constraint vector
void	addOffset2Cols(int[] cols)
double	alpha()
protected void	applyStrongRules(double lambdaNew, double lambdaOld) Apply strong rules to filter out expected inactive (with zero coefficient) predictors.
protected int	applyStrongRulesMultinomial_old(double lambdaNew, double lambdaOld) Apply strong rules to filter out expected inactive (with zero coefficient) predictors.
protected void	applyStrongRulesMultinomial(double lambdaNew, double lambdaOld) Apply strong rules to filter out expected inactive (with zero coefficient) predictors.
double[]	beta()
double[]	betaMultinomial()
double[]	betaMultinomial(int c, double[] beta)
double[]	betaMultinomialFull(int c, double[] beta)
static ConstrainedGLMUtils.ConstraintsDerivatives[]	calDerivatives(ConstrainedGLMUtils.LinearConstraints[] constraints, java.util.List<java.lang.String> coefNames) This methold will calculate the first derivative of h(beta).
static ConstrainedGLMUtils.ConstraintsGram[]	calGram(ConstrainedGLMUtils.ConstraintsDerivatives[] derivativeEqual) This method to calculate contribution of penalty to gram (d2H/dbidbj), refer to the doc Section VI.II
protected boolean	checkKKTs()
protected boolean	checkKKTsMultinomial()
protected ComputationState.GramGrad	computeGram(double[] beta, GLM.GLMGradientInfo gradientInfo) This function calculates the following values: 1.
ComputationState.GramXY	computeGram(double[] beta, GLMModel.GLMParameters.Solver s)
ComputationState.GramXY	computeGramRCC(double[] beta, GLMModel.GLMParameters.Solver s) This method is used only for multinomial family.
protected ComputationState.GramXY	computeNewGram(DataInfo activeData, double[] beta, GLMModel.GLMParameters.Solver s)
static ConstrainedGLMUtils.ConstraintsGram	constructGram(ConstrainedGLMUtils.ConstraintsDerivatives constDeriv) This method is not called often.
boolean	converged()
double	deviance()
boolean	dispersionEstimated()
void	dropActiveData()
double[]	expandBeta(double[] beta)
static double[]	expandToFullArray(double[] shortenArr, int[] activeCols, int _totalBetaLength, int nclasses, int betaLengthPerClass)
static double[]	extractSubRange(int N, int c, int[] ids, double[] src) This method will return a double array that is extracted from src (which includes active and non-active columns) to only include active columns stated in ids.
static double[]	formXY(double[][] fullGram, double[] beta, double[] grad)
static int[]	genActiveColsAllClass(int activeColsLen, int numBetaPerClass, int[] activeColsOrig, int nclasses)
int[]	genActiveColsIndClass(int activeColsLen, int numBetaPerClass, int[] activeColsOrig, int activeClass, int nclasses)
static ConstrainedGLMUtils.ConstraintsDerivatives	genOneDerivative(ConstrainedGLMUtils.LinearConstraints oneConstraints, java.util.List<java.lang.String> coeffNames) Given a constraint, this method will calculate the first order derivative.
boolean	getLambdaNull()
GLM.GLMGradientInfo	ginfo()
ComputationState.GLMSubsetGinfo	ginfoMultinomial(int c)
ComputationState.GLMSubsetGinfo	ginfoMultinomialRCC(int c)
boolean	ginfoNull()
GLM.GLMGradientSolver	gslvr()
OptimizationUtils.GradientSolver	gslvrMultinomial(int c)
void	initConstraintDerivatives(ConstrainedGLMUtils.LinearConstraints[] equalityConstraints, ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints, java.util.List<java.lang.String> coeffNames) This method calculates 1.
double	l1pen()
double	l2pen()
double	lambda()
double	likelihood()
double	objective()
double	objective(double[] beta, double likelihood)
int[]	removeCols(int[] cols)
void	resizeConstraintInfo(ConstrainedGLMUtils.LinearConstraints[] equalityConstraints, ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints)
void	setActiveClass(int activeClass)
protected void	setActiveDataMultinomialNull()
protected void	setActiveDataNull()
protected void	setAllIn(boolean val)
void	setAlpha(double alpha)
void	setBC(GLM.BetaConstraint bc)
protected void	setBeta(double[] beta)
protected void	setBetaDiff(double betaDiff)
void	setBetaMultinomial(int c, double[] beta, double[] bc)
void	setConstraintInfo(GLM.GLMGradientInfo gradientInfo, ConstrainedGLMUtils.LinearConstraints[] equalityConstraints, ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints, double[] lambdaEqual, double[] lambdaLessThan)
protected void	setGinfo(GLM.GLMGradientInfo ginfo)
void	setgMax(double gmax)
protected void	setGradientErr(double gErr)
protected void	setGslvrNull()
protected void	setIter(int iteration)
void	setLambda(double lambda)
void	setLambdaMax(double lmax)
protected void	setLambdaSimple(double lambda)
protected void	setLikelihood(double llk)
void	setLinearConstraints(ConstrainedGLMUtils.LinearConstraints[] equalityC, ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToC, boolean forBeta)
void	setZValues(double[] zValues, boolean dispersionEstimated)
double[]	shrinkFullArray(double[] fullArray)
java.lang.String	toString()
void	updateConstraintInfo(ConstrainedGLMUtils.LinearConstraints[] equalityConstraints, ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints) Any time when the glm coefficient changes, the constraints values will change and active constraints can be inactive and vice versa.
void	updateDerivativeActive(ConstrainedGLMUtils.ConstraintsDerivatives[] derivativesConst, ConstrainedGLMUtils.ConstraintsGram[] gramConst, ConstrainedGLMUtils.LinearConstraints[] constraints)
protected double	updateState(double[] beta, double likelihood)
double	updateState(double[] beta, GLM.GLMGradientInfo ginfo)
double[]	zValues()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

EPS_CS

public static final double EPS_CS

See Also:

Constant Field Values

EPS_CS_SQUARE

public static final double EPS_CS_SQUARE

See Also:

Constant Field Values

_parms

public final GLMModel.GLMParameters _parms

_noReg

public boolean _noReg

_csGLMState

public ConstrainedGLMUtils.ConstraintGLMStates _csGLMState

_lsNeeded

public boolean _lsNeeded

_activeDataMultinomial

public DataInfo[] _activeDataMultinomial

Constructor Detail

ComputationState

public ComputationState(water.Job job,
                        GLMModel.GLMParameters parms,
                        DataInfo dinfo,
                        GLM.BetaConstraint bc,
                        GLM.BetaInfo bi)

ComputationState

public ComputationState(water.Job job,
                        GLMModel.GLMParameters parms,
                        DataInfo dinfo,
                        GLM.BetaConstraint bc,
                        GLM.BetaInfo bi,
                        double[][][] penaltyMat,
                        int[][] gamColInd)

Method Detail

initConstraintDerivatives

public void initConstraintDerivatives(ConstrainedGLMUtils.LinearConstraints[] equalityConstraints,
                                      ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints,
                                      java.util.List<java.lang.String> coeffNames)

This method calculates 1. the contribution of constraints to the gradient; 2. the contribution of ||h(beta)||^2 to the gradient and the hessian. Note that this calculation is only needed once since the contributions to the derivative and hessian depends only on the value of linear constraint coefficients and not the actual glm model parameters. Refer to the doc, section VI.

updateConstraintInfo

public void updateConstraintInfo(ConstrainedGLMUtils.LinearConstraints[] equalityConstraints,
                                 ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints)

Any time when the glm coefficient changes, the constraints values will change and active constraints can be inactive and vice versa. In addition, the active status of the derivatives and 2nd derivatives can change as well. The derivative and 2nd derivatives are part of the ComputationState. It is the purpose of this method to change the active status of the constraint derivatives (transpose(lambda)*h(beta)) and the 2nd order derivatives of (ck/2*transpose(h(beta))*h(beta)).

updateDerivativeActive

public void updateDerivativeActive(ConstrainedGLMUtils.ConstraintsDerivatives[] derivativesConst,
                                   ConstrainedGLMUtils.ConstraintsGram[] gramConst,
                                   ConstrainedGLMUtils.LinearConstraints[] constraints)

resizeConstraintInfo

public void resizeConstraintInfo(ConstrainedGLMUtils.LinearConstraints[] equalityConstraints,
                                 ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints)

setZValues

public void setZValues(double[] zValues,
                       boolean dispersionEstimated)

getLambdaNull

public boolean getLambdaNull()

gslvr

public GLM.GLMGradientSolver gslvr()

lambda

public double lambda()

alpha

public double alpha()

zValues

public double[] zValues()

dispersionEstimated

public boolean dispersionEstimated()

setLambdaMax

public void setLambdaMax(double lmax)

setgMax

public void setgMax(double gmax)

setAlpha

public void setAlpha(double alpha)

setLambda

public void setLambda(double lambda)

beta

public double[] beta()

ginfo

public GLM.GLMGradientInfo ginfo()

activeBC

public GLM.BetaConstraint activeBC()

likelihood

public double likelihood()

ginfoNull

public boolean ginfoNull()

activeData

public DataInfo activeData()

activeDataMultinomial

public DataInfo activeDataMultinomial()

dropActiveData

public void dropActiveData()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

l1pen

public double l1pen()

l2pen

public double l2pen()

applyStrongRules

protected void applyStrongRules(double lambdaNew,
                                double lambdaOld)

Apply strong rules to filter out expected inactive (with zero coefficient) predictors.

activeDataMultinomial

public DataInfo activeDataMultinomial(int c)

extractSubRange

public static double[] extractSubRange(int N,
                                       int c,
                                       int[] ids,
                                       double[] src)

This method will return a double array that is extracted from src (which includes active and non-active columns) to only include active columns stated in ids.

Parameters:

N -

c -

ids -

src -

Returns:

betaMultinomial

public double[] betaMultinomial()

betaMultinomial

public double[] betaMultinomial(int c,
                                double[] beta)

betaMultinomialFull

public double[] betaMultinomialFull(int c,
                                    double[] beta)

shrinkFullArray

public double[] shrinkFullArray(double[] fullArray)

expandToFullArray

public static double[] expandToFullArray(double[] shortenArr,
                                         int[] activeCols,
                                         int _totalBetaLength,
                                         int nclasses,
                                         int betaLengthPerClass)

genActiveColsAllClass

public static int[] genActiveColsAllClass(int activeColsLen,
                                          int numBetaPerClass,
                                          int[] activeColsOrig,
                                          int nclasses)

genActiveColsIndClass

public int[] genActiveColsIndClass(int activeColsLen,
                                   int numBetaPerClass,
                                   int[] activeColsOrig,
                                   int activeClass,
                                   int nclasses)

ginfoMultinomial

public ComputationState.GLMSubsetGinfo ginfoMultinomial(int c)

ginfoMultinomialRCC

public ComputationState.GLMSubsetGinfo ginfoMultinomialRCC(int c)

setBC

public void setBC(GLM.BetaConstraint bc)

setLinearConstraints

public void setLinearConstraints(ConstrainedGLMUtils.LinearConstraints[] equalityC,
                                 ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToC,
                                 boolean forBeta)

setActiveClass

public void setActiveClass(int activeClass)

deviance

public double deviance()

gslvrMultinomial

public OptimizationUtils.GradientSolver gslvrMultinomial(int c)

setBetaMultinomial

public void setBetaMultinomial(int c,
                               double[] beta,
                               double[] bc)

applyStrongRulesMultinomial_old

protected int applyStrongRulesMultinomial_old(double lambdaNew,
                                              double lambdaOld)

Apply strong rules to filter out expected inactive (with zero coefficient) predictors.

Returns:

indices of expected active predictors.

applyStrongRulesMultinomial

protected void applyStrongRulesMultinomial(double lambdaNew,
                                           double lambdaOld)

Apply strong rules to filter out expected inactive (with zero coefficient) predictors.

checkKKTsMultinomial

protected boolean checkKKTsMultinomial()

checkKKTs

protected boolean checkKKTs()

addOffset2Cols

public void addOffset2Cols(int[] cols)

removeCols

public int[] removeCols(int[] cols)

objective

public double objective()

objective

public double objective(double[] beta,
                        double likelihood)

calDerivatives

public static ConstrainedGLMUtils.ConstraintsDerivatives[] calDerivatives(ConstrainedGLMUtils.LinearConstraints[] constraints,
                                                                          java.util.List<java.lang.String> coefNames)

This methold will calculate the first derivative of h(beta). Refer to the doc, section VI.I

genOneDerivative

public static ConstrainedGLMUtils.ConstraintsDerivatives genOneDerivative(ConstrainedGLMUtils.LinearConstraints oneConstraints,
                                                                          java.util.List<java.lang.String> coeffNames)

Given a constraint, this method will calculate the first order derivative. Note that this derivative does not depend on the lambda applied to the constraint. It only changes when the number of coefficients in beta changes and it needs to be called again.

calGram

public static ConstrainedGLMUtils.ConstraintsGram[] calGram(ConstrainedGLMUtils.ConstraintsDerivatives[] derivativeEqual)

This method to calculate contribution of penalty to gram (d2H/dbidbj), refer to the doc Section VI.II

constructGram

public static ConstrainedGLMUtils.ConstraintsGram constructGram(ConstrainedGLMUtils.ConstraintsDerivatives constDeriv)

This method is not called often. If called, it will calculate the contribution of constraints to the hessian. Whenever there is a predictor number change, this function should be called again as it only looks at the predictor index. This predictor index will change when the number of predictors change. It calculates the second derivative regardless of the active status because an inactive constraint may become active in the future. Note that here, only half of the 2nd derivatives are calculated, namely d(tranpose(h(beta))*h(beta)/dCidCj and not d(tranpose(h(beta))*h(beta)/dCjdCi since they are symmetric.

updateState

protected double updateState(double[] beta,
                             double likelihood)

converged

public boolean converged()

updateState

public double updateState(double[] beta,
                          GLM.GLMGradientInfo ginfo)

setBetaDiff

protected void setBetaDiff(double betaDiff)

setGradientErr

protected void setGradientErr(double gErr)

setGinfo

protected void setGinfo(GLM.GLMGradientInfo ginfo)

setBeta

protected void setBeta(double[] beta)

setIter

protected void setIter(int iteration)

setLikelihood

protected void setLikelihood(double llk)

setAllIn

protected void setAllIn(boolean val)

setGslvrNull

protected void setGslvrNull()

setActiveDataMultinomialNull

protected void setActiveDataMultinomialNull()

setActiveDataNull

protected void setActiveDataNull()

setLambdaSimple

protected void setLambdaSimple(double lambda)

expandBeta

public double[] expandBeta(double[] beta)

computeNewGram

protected ComputationState.GramXY computeNewGram(DataInfo activeData,
                                                 double[] beta,
                                                 GLMModel.GLMParameters.Solver s)

computeGramRCC

public ComputationState.GramXY computeGramRCC(double[] beta,
                                              GLMModel.GLMParameters.Solver s)

This method is used only for multinomial family. It differs from computeGram because it calls on _activeData which only contains only active columns in its _adaptedFrame. Note activeDataMultinomial(_activeClass) will always contains all predictors in its _adaptedFrame.

Parameters:

beta -

s -

Returns:

computeGram

protected ComputationState.GramGrad computeGram(double[] beta,
                                                GLM.GLMGradientInfo gradientInfo)

This function calculates the following values: 1. the hessian 2. the xy which is basically (hessian * old_beta + gradient)

addConstraintObj

public static double addConstraintObj(double[] lambda,
                                      ConstrainedGLMUtils.LinearConstraints[] constraints,
                                      double ckHalf)

This method adds to objective function the contribution of transpose(lambda)*constraint vector + ck/2*transpose(constraint vector)*constraint vector

formXY

public static double[] formXY(double[][] fullGram,
                              double[] beta,
                              double[] grad)

computeGram

public ComputationState.GramXY computeGram(double[] beta,
                                           GLMModel.GLMParameters.Solver s)

setConstraintInfo

public void setConstraintInfo(GLM.GLMGradientInfo gradientInfo,
                              ConstrainedGLMUtils.LinearConstraints[] equalityConstraints,
                              ConstrainedGLMUtils.LinearConstraints[] lessThanEqualToConstraints,
                              double[] lambdaEqual,
                              double[] lambdaLessThan)