hex.modelselection

Class ModelSelectionUtils

java.lang.Object

hex.modelselection.ModelSelectionUtils

public class ModelSelectionUtils
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ModelSelectionUtils.SweepVector store information on sweeping actions that are to be performed to new rows/columns added to CPM due to the addition of new predcitors.

Constructor Summary

Constructors

Constructor and Description
ModelSelectionUtils()

Method Summary

Modifier and Type	Method and Description
static double[][]	addNewPred2CPM(double[][] allCPM, double[][] currentCPM, int[] subsetPredIndex, int[][] pred2CPMIndices, boolean hasIntercept) Given current CPM which has been swept already, we need to add the lastest predictor to the current CPM that have not been swept.
static void	applySweepVectors2NewPred(ModelSelectionUtils.SweepVector[][] sweepVec, double[][] subsetCPM, int numNewRows, int[] sweepMat) This method will sweep the rows/columns added to the CPM due to the addition of the new predictor using sweep vector arrays.
static GLM[]	buildGLMBuilders(GLMModel.GLMParameters[] trainingParams)
static double	calR2Scale(water.fvec.Frame train, java.lang.String resp)
static double[][]	createCrossProductMatrix(water.Key jobKey, DataInfo dinfo)
static java.util.List<java.lang.Integer>	extractCPMIndexFromPred(double[][] allCPM, int[][] pred2CPMIndices, int[] newPredList, boolean hasIntercept)
static java.lang.String[]	extractPredictorNames(hex.Model.Parameters parms, DataInfo dinfo, java.lang.String foldColumn)
static double[][]	extractPredSubsetsCPM(double[][] allCPM, int[] predIndices, int[][] pred2CPMIndices, boolean hasIntercept) Given a predictor subset and the complete CPM, we extract the CPM associated with the predictors specified in the predictor subset (predIndices).
static int[]	extractSweepIndices(java.util.List<java.lang.Integer> currSubsetIndices, int predPos, int predRemoved, int[][] predInd2CPMIndices, boolean hasIntercept) Given predRemoved (the predictor that is to be removed and replaced in the forward step), this method will calculate the locations of the CPM rows/columns associated with it.
static java.util.List<java.lang.String>	extraModelColumnNames(java.util.List<java.lang.String> coefNames, GLMModel bestModel)
static GLMModel	findBestModel(GLM[] glmResults) Given GLM run results of a fixed number of predictors, find the model with the best R2 value.
static hex.modelselection.ModelSelectionUtils.PredNameMinZVal	findCatMinZVal(GLMModel model, java.util.List<java.lang.Double> zValList) This method extracts the categorical coefficient z-value by using the following method: 1.
static int	findMinZValue(GLMModel model, java.util.List<java.lang.String> numPredNames, java.util.List<java.lang.String> catPredNames, java.util.List<java.lang.String> predNames)
static hex.modelselection.ModelSelectionUtils.PredNameMinZVal	findNumMinZVal(java.util.List<java.lang.String> numPredNames, java.util.List<java.lang.Double> zValList, java.util.List<java.lang.String> coeffNames)
static void	genBestSweepVector(ModelSelection.SweepModel bestModel, double[][] cpm, int[][] pred2CPMIndices, boolean hasIntercept) Given the predictor subset in bestModel, this method will perform sweeping on the predictor subset, generate new sweep vector arrays and stored the new swept CPM back to bestModel.
static double[]	generateAllErrorVariances(double[][] allCPM, ModelSelectionUtils.SweepVector[][] sweepVec, double[][] prevCPM, java.util.List<java.lang.Integer> currSubsetIndices, java.util.List<java.lang.Integer> validSubsets, java.util.Set<java.util.BitSet> usedCombo, java.util.BitSet tempIndices, int[][] pred2CPMIndices, boolean hasIntercept, int predPos, int removedPred, int[] sweepIndices) Given the prevCPM which contains the CPM generated from the last forward step search, we will add a new predictor from the predictors in validSubsets and calculate its error variances defined in section IV of doc.
static GLMModel.GLMParameters[]	generateGLMParameters(water.fvec.Frame[] trainingFrames, ModelSelectionModel.ModelSelectionParameters parms, int nfolds, java.lang.String foldColumn, hex.Model.Parameters.FoldAssignmentScheme foldAssignment)
static water.fvec.Frame[]	generateMaxRTrainingFrames(ModelSelectionModel.ModelSelectionParameters parms, java.lang.String[] predictorNames, java.lang.String foldColumn, java.util.List<java.lang.Integer> currSubsetIndices, int newPredPos, java.util.List<java.lang.Integer> validSubsets, java.util.Set<java.util.BitSet> usedCombo) double
static water.fvec.Frame	generateOneFrame(int[] predIndices, hex.Model.Parameters parms, java.lang.String[] predNames, java.lang.String foldColumn) Given a predictor indices set, this function will generate a training frame containing the predictors with indices in predIndices.
static water.fvec.Frame[]	generateTrainingFrames(ModelSelectionModel.ModelSelectionParameters parms, int predNum, java.lang.String[] predNames, int numModels, java.lang.String foldColumn)
static void	genMSE1stPred(int[][] pred2CPMIndices, double[][] allCPM, int[] allPreds, double[] subsetMSE, jsr166y.RecursiveAction[] resA, int resCount, boolean hasIntercept)
static void	genMSE4MorePreds(int[][] pred2CPMIndices, double[][] allCPM, ModelSelectionUtils.SweepVector[][] sweepVec, int[] allPreds, double[][] prevCPM, double[] subsetMSE, jsr166y.RecursiveAction[] resA, int resCount, boolean hasIntercept, int predPos, int removedPred, int[] sweepIndices)
static ModelSelectionUtils.SweepVector[]	genNewSV(ModelSelectionUtils.SweepVector[] oldSV, double[][] subsetCPM, int newPredLen, int sweepInd) Giving new subsetCPM with added predictor, we need to go back to all sweep vectors, increase its size to include the newly added predictor and add the correct contents
static java.lang.String	joinDouble(double[] val)
static ModelSelectionUtils.SweepVector[][]	mapBasicVector2Multiple(ModelSelectionUtils.SweepVector[][] sweepVec, int newPredCPMLen) When multiple rows/columns are added to the CPM due to the new predictor being categorical, we need to map the old sweep vector arrays to new bigger sweep vector arrays.
static int[][]	mapPredIndex2CPMIndices(DataInfo dinfo, int predLength)
static ModelSelectionUtils.SweepVector[][]	mergeSV(ModelSelectionUtils.SweepVector[][] sweepVector, ModelSelectionUtils.SweepVector[][] removedPredSV)
static void	oneSweepWSweepVector(ModelSelectionUtils.SweepVector[] sweepVec, double[][] subsetCPM, int sweepIndex, int colRowsAdded) This method perform just one sweep of the sweeping action described in Step 3 of section V.II.IV of doc.
static void	performOneSweep(double[][] subsetCPM, ModelSelectionUtils.SweepVector[] sweepVec, int sweepIndex, boolean genSweepVector) Perform one sweep according to section II of doc and generate sweep vector according to section V.II of doc.
static void	process(hex.modelselection.ModelSelectionUtils.SweepElement currEle, java.util.List<hex.modelselection.ModelSelectionUtils.SweepElement> tempList) This method will generate all the elements that are needed to perform sweeping on the currEle.
static void	removeTrainingFrames(water.fvec.Frame[] trainingFrames)
static double[][]	replaceCPMwNewPred(double[][] cpm, double[][] allCPM, int[][] pred2CPM, int[] oldSweepIndices, int[] newSweepIndices, int[] predSubset, boolean hasIntercept)
static void	replaceSweepVectors(ModelSelectionUtils.SweepVector[][] origSV, ModelSelectionUtils.SweepVector[][] newSV, int startIndex)
static void	setBitSet(java.util.BitSet predBitSet, int[] currIndices)
static void	setParamField(hex.Model.Parameters params, GLMModel.GLMParameters glmParam, boolean superClassParams, java.lang.reflect.Field[] paramFields, java.util.List<java.lang.String> excludeList)
static double[][]	shrinkDoubleArray(double[][] array, int numModels)
static water.Key[]	shrinkKeyArray(water.Key[] array, int numModels)
static java.lang.String[][]	shrinkStringArray(java.lang.String[][] array, int numModels)
static ModelSelectionUtils.SweepVector[][]	sweepCPM(double[][] subsetCPM, int[] sweepIndices, boolean genSweepVector) This method perform the sweeping action described in section II of doc.
static void	sweepCPMElements(java.util.Set<hex.modelselection.ModelSelectionUtils.SweepElement>[] sweepElements, double[][] subsetCPM)
static void	sweepCPMNewPredwSVs(double[][] subsetCPM, int sweepIndex, ModelSelectionUtils.SweepVector[] sv, java.util.List<java.lang.Integer> newSweepIndices) This method will perform sweeping on the rows/columns of CPM corresponding to the newly replaced predictor.
static double	sweepMSE(double[][] subsetCPM, java.util.List<java.lang.Integer> sweepIndices)
static double[][]	unsweptPredAfterReplacedPred(int[] predSubset, double[][] subsetCPM, double[][] origCPM, int[][] predInd2CPMInd, boolean hasIntercept, int predPos, int[] sweepIndicesRemovedPred, java.util.List<java.lang.Integer> newAllSweepIndices)
static void	updateCPMSV(ModelSelection.SweepModel bestModel, double[][] subsetCPM, int[] newSweepIndices, java.util.List<java.lang.Integer> newAllSweepIndices, int[] sweepIndicesRemovedPred) Given CPM, sweep vector from forward model and the new predictor, this function aims to do the following: 1.
static void	updateLaterIndices(int[] currentPredIndices, int indexUpdated, int lastPredInd) Give 5 predictors and say we want the combo of 3 predictors, this function will properly reset the prediction combination indices say from [0, 1, 4] -> [0, 2, 3] or [0, 3, 4] -> [1, 2, 3].
static void	updatePredIndices(int[] currentPredIndices, int[] indicesBounds) Given predictor indices stored in currentPredIndices, we need to find the next combination of predictor indices to use to generate the next combination.
static ModelSelectionUtils.SweepVector[][]	updateSweepVectors(double[][] subsetCPM, ModelSelectionUtils.SweepVector[][] sweepVector, int[] subsetPred, int[][] predInd2CPMInd) Given the predictor subset stored in subsetPred, the newest predictor index is the last element of subsetPred.

Methods inherited from class java.lang.Object

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

Constructor Detail

ModelSelectionUtils

public ModelSelectionUtils()

Method Detail

generateTrainingFrames

public static water.fvec.Frame[] generateTrainingFrames(ModelSelectionModel.ModelSelectionParameters parms,
                                                        int predNum,
                                                        java.lang.String[] predNames,
                                                        int numModels,
                                                        java.lang.String foldColumn)

updatePredIndices

public static void updatePredIndices(int[] currentPredIndices,
                                     int[] indicesBounds)

Given predictor indices stored in currentPredIndices, we need to find the next combination of predictor indices to use to generate the next combination. For example, if we have 4 predictors and we are looking to take two predictors, predictor indices can change in the following sequence [0,1]->[0,2]->[0,3]->[1,2]->[1,2]->[2,3].

Parameters:

currentPredIndices -

indicesBounds -

updateLaterIndices

public static void updateLaterIndices(int[] currentPredIndices,
                                      int indexUpdated,
                                      int lastPredInd)

Give 5 predictors and say we want the combo of 3 predictors, this function will properly reset the prediction combination indices say from [0, 1, 4] -> [0, 2, 3] or [0, 3, 4] -> [1, 2, 3]. Given an index that was just updated, it will update the indices that come later in the list correctly.

Parameters:

currentPredIndices -

indexUpdated -

lastPredInd -

generateOneFrame

public static water.fvec.Frame generateOneFrame(int[] predIndices,
                                                hex.Model.Parameters parms,
                                                java.lang.String[] predNames,
                                                java.lang.String foldColumn)

Given a predictor indices set, this function will generate a training frame containing the predictors with indices in predIndices.

Parameters:

predIndices -

parms -

predNames -

Returns:

setBitSet

public static void setBitSet(java.util.BitSet predBitSet,
                             int[] currIndices)

mapPredIndex2CPMIndices

public static int[][] mapPredIndex2CPMIndices(DataInfo dinfo,
                                              int predLength)

createCrossProductMatrix

public static double[][] createCrossProductMatrix(water.Key jobKey,
                                                  DataInfo dinfo)

calR2Scale

public static double calR2Scale(water.fvec.Frame train,
                                java.lang.String resp)

generateMaxRTrainingFrames

public static water.fvec.Frame[] generateMaxRTrainingFrames(ModelSelectionModel.ModelSelectionParameters parms,
                                                            java.lang.String[] predictorNames,
                                                            java.lang.String foldColumn,
                                                            java.util.List<java.lang.Integer> currSubsetIndices,
                                                            int newPredPos,
                                                            java.util.List<java.lang.Integer> validSubsets,
                                                            java.util.Set<java.util.BitSet> usedCombo)

double

Parameters:

predictorNames -

foldColumn -

currSubsetIndices -

validSubsets - Lists containing only valid predictor indices to choose from

Returns:

unsweptPredAfterReplacedPred

public static double[][] unsweptPredAfterReplacedPred(int[] predSubset,
                                                      double[][] subsetCPM,
                                                      double[][] origCPM,
                                                      int[][] predInd2CPMInd,
                                                      boolean hasIntercept,
                                                      int predPos,
                                                      int[] sweepIndicesRemovedPred,
                                                      java.util.List<java.lang.Integer> newAllSweepIndices)

generateAllErrorVariances

public static double[] generateAllErrorVariances(double[][] allCPM,
                                                 ModelSelectionUtils.SweepVector[][] sweepVec,
                                                 double[][] prevCPM,
                                                 java.util.List<java.lang.Integer> currSubsetIndices,
                                                 java.util.List<java.lang.Integer> validSubsets,
                                                 java.util.Set<java.util.BitSet> usedCombo,
                                                 java.util.BitSet tempIndices,
                                                 int[][] pred2CPMIndices,
                                                 boolean hasIntercept,
                                                 int predPos,
                                                 int removedPred,
                                                 int[] sweepIndices)

Given the prevCPM which contains the CPM generated from the last forward step search, we will add a new predictor from the predictors in validSubsets and calculate its error variances defined in section IV of doc. If we are at the first step of forward search, prevCPM will be null. In this case, we just loop through the validSubsets to pick a predictor, generate the CPM and perform sweeping to generate an error variances. The list of error variances will be returned. See section V.I of doc. for maxrsweep2

genMSE4MorePreds

public static void genMSE4MorePreds(int[][] pred2CPMIndices,
                                    double[][] allCPM,
                                    ModelSelectionUtils.SweepVector[][] sweepVec,
                                    int[] allPreds,
                                    double[][] prevCPM,
                                    double[] subsetMSE,
                                    jsr166y.RecursiveAction[] resA,
                                    int resCount,
                                    boolean hasIntercept,
                                    int predPos,
                                    int removedPred,
                                    int[] sweepIndices)

updateCPMSV

public static void updateCPMSV(ModelSelection.SweepModel bestModel,
                               double[][] subsetCPM,
                               int[] newSweepIndices,
                               java.util.List<java.lang.Integer> newAllSweepIndices,
                               int[] sweepIndicesRemovedPred)

Given CPM, sweep vector from forward model and the new predictor, this function aims to do the following: 1. Replace CPM with new predictor at the locations in the sweepIndicesRemovedPred; 2. Going into a for loop over all the sweep vectors to do the following: - update sweep vector for sweep index specified by the for loop; - use the updated sweep vector to sweep the replaced cols/rows of CPM due to the replaced pred;

replaceSweepVectors

public static void replaceSweepVectors(ModelSelectionUtils.SweepVector[][] origSV,
                                       ModelSelectionUtils.SweepVector[][] newSV,
                                       int startIndex)

sweepCPMNewPredwSVs

public static void sweepCPMNewPredwSVs(double[][] subsetCPM,
                                       int sweepIndex,
                                       ModelSelectionUtils.SweepVector[] sv,
                                       java.util.List<java.lang.Integer> newSweepIndices)

This method will perform sweeping on the rows/columns of CPM corresponding to the newly replaced predictor. sv is longer than the sweepvector we need by 2.

replaceCPMwNewPred

public static double[][] replaceCPMwNewPred(double[][] cpm,
                                            double[][] allCPM,
                                            int[][] pred2CPM,
                                            int[] oldSweepIndices,
                                            int[] newSweepIndices,
                                            int[] predSubset,
                                            boolean hasIntercept)

sweepMSE

public static double sweepMSE(double[][] subsetCPM,
                              java.util.List<java.lang.Integer> sweepIndices)

sweepCPMElements

public static void sweepCPMElements(java.util.Set<hex.modelselection.ModelSelectionUtils.SweepElement>[] sweepElements,
                                    double[][] subsetCPM)

process

public static void process(hex.modelselection.ModelSelectionUtils.SweepElement currEle,
                           java.util.List<hex.modelselection.ModelSelectionUtils.SweepElement> tempList)

This method will generate all the elements that are needed to perform sweeping on the currEle. The formula for sweeping is: subsetCPM[row][col] = subsetCPM[row][col]-subsetCPM[row][sweepInd]*subsetCPM[sweepInd][row]/subsetCPM[sweepInd][sweepInd] We are not performing the actual sweeping here but rather to remember the elements of subsetCPM that we need to perform sweeping on. From the formula, each currEle will generate three more new SweepElements

genMSE1stPred

public static void genMSE1stPred(int[][] pred2CPMIndices,
                                 double[][] allCPM,
                                 int[] allPreds,
                                 double[] subsetMSE,
                                 jsr166y.RecursiveAction[] resA,
                                 int resCount,
                                 boolean hasIntercept)

mapBasicVector2Multiple

public static ModelSelectionUtils.SweepVector[][] mapBasicVector2Multiple(ModelSelectionUtils.SweepVector[][] sweepVec,
                                                                          int newPredCPMLen)

When multiple rows/columns are added to the CPM due to the new predictor being categorical, we need to map the old sweep vector arrays to new bigger sweep vector arrays. See section V.II.V of doc.

applySweepVectors2NewPred

public static void applySweepVectors2NewPred(ModelSelectionUtils.SweepVector[][] sweepVec,
                                             double[][] subsetCPM,
                                             int numNewRows,
                                             int[] sweepMat)

This method will sweep the rows/columns added to the CPM due to the addition of the new predictor using sweep vector arrays. See Step 3 of section V.II.IV of doc. The sweep vectors should contain sweeping for predictor 0, for predictor 2, .... predictor s of the predictor subset.

oneSweepWSweepVector

public static void oneSweepWSweepVector(ModelSelectionUtils.SweepVector[] sweepVec,
                                        double[][] subsetCPM,
                                        int sweepIndex,
                                        int colRowsAdded)

This method perform just one sweep of the sweeping action described in Step 3 of section V.II.IV of doc. Note that for a sweep vector array of 2*(N+1), the first N+1 elements describe the changes to the new column. The last N+1 elements describing changes to the new row. The sweep vector arrays will contain changes to the same element multiple times. I only change each new element once by using elementAccessCount to keep track of which elements have been changed already. See Step 3 of section V.II.IV of doc for details. In addition, I did not use two arrays to implement the changes. Hence, the order of change is important here. I used temporary variable to store element changes that are used by other element updates. I copied the temporary elements back to the CPM at the end.

addNewPred2CPM

public static double[][] addNewPred2CPM(double[][] allCPM,
                                        double[][] currentCPM,
                                        int[] subsetPredIndex,
                                        int[][] pred2CPMIndices,
                                        boolean hasIntercept)

Given current CPM which has been swept already, we need to add the lastest predictor to the current CPM that have not been swept. The new elements belonging to the newest predictor is extracted from the original allCPM. Basically, I just extract the CPM from the original non-swept CPM that contains rows/columns of CPM corresponding to the predictors in subsetPredIndex. Next, I copied over the swept rows/columns of CPM corresponding to the previous predictor subset while leaving the rows/columns corresponding to the new rows/ columns due to the new predictor unchanged. See Step 2 in section V.II.IV of doc.

updateSweepVectors

public static ModelSelectionUtils.SweepVector[][] updateSweepVectors(double[][] subsetCPM,
                                                                     ModelSelectionUtils.SweepVector[][] sweepVector,
                                                                     int[] subsetPred,
                                                                     int[][] predInd2CPMInd)

Given the predictor subset stored in subsetPred, the newest predictor index is the last element of subsetPred. The subsetCPM contains the swept rows/cols corresponding to the predictors stored in subsetPred except the last predictor. Here, we need to update the sweep vectors for the sweeping of a new predictor in the future.

extractSweepIndices

public static int[] extractSweepIndices(java.util.List<java.lang.Integer> currSubsetIndices,
                                        int predPos,
                                        int predRemoved,
                                        int[][] predInd2CPMIndices,
                                        boolean hasIntercept)

Given predRemoved (the predictor that is to be removed and replaced in the forward step), this method will calculate the locations of the CPM rows/columns associated with it.

mergeSV

public static ModelSelectionUtils.SweepVector[][] mergeSV(ModelSelectionUtils.SweepVector[][] sweepVector,
                                                          ModelSelectionUtils.SweepVector[][] removedPredSV)

genNewSV

public static ModelSelectionUtils.SweepVector[] genNewSV(ModelSelectionUtils.SweepVector[] oldSV,
                                                         double[][] subsetCPM,
                                                         int newPredLen,
                                                         int sweepInd)

Giving new subsetCPM with added predictor, we need to go back to all sweep vectors, increase its size to include the newly added predictor and add the correct contents

extractCPMIndexFromPred

public static java.util.List<java.lang.Integer> extractCPMIndexFromPred(double[][] allCPM,
                                                                        int[][] pred2CPMIndices,
                                                                        int[] newPredList,
                                                                        boolean hasIntercept)

genBestSweepVector

public static void genBestSweepVector(ModelSelection.SweepModel bestModel,
                                      double[][] cpm,
                                      int[][] pred2CPMIndices,
                                      boolean hasIntercept)

Given the predictor subset in bestModel, this method will perform sweeping on the predictor subset, generate new sweep vector arrays and stored the new swept CPM back to bestModel. Note that the Sweep Vectors generated are from predictor 0, predictor 1, ... , predictor s in the predictor subset.

sweepCPM

public static ModelSelectionUtils.SweepVector[][] sweepCPM(double[][] subsetCPM,
                                                           int[] sweepIndices,
                                                           boolean genSweepVector)

This method perform the sweeping action described in section II of doc. In addition, if genSweepVector is set to true, it will also generate the corresponding sweep vector arrays described in section V.II of doc.

performOneSweep

public static void performOneSweep(double[][] subsetCPM,
                                   ModelSelectionUtils.SweepVector[] sweepVec,
                                   int sweepIndex,
                                   boolean genSweepVector)

Perform one sweep according to section II of doc and generate sweep vector according to section V.II of doc.

shrinkStringArray

public static java.lang.String[][] shrinkStringArray(java.lang.String[][] array,
                                                     int numModels)

shrinkDoubleArray

public static double[][] shrinkDoubleArray(double[][] array,
                                           int numModels)

shrinkKeyArray

public static water.Key[] shrinkKeyArray(water.Key[] array,
                                         int numModels)

joinDouble

public static java.lang.String joinDouble(double[] val)

generateGLMParameters

public static GLMModel.GLMParameters[] generateGLMParameters(water.fvec.Frame[] trainingFrames,
                                                             ModelSelectionModel.ModelSelectionParameters parms,
                                                             int nfolds,
                                                             java.lang.String foldColumn,
                                                             hex.Model.Parameters.FoldAssignmentScheme foldAssignment)

setParamField

public static void setParamField(hex.Model.Parameters params,
                                 GLMModel.GLMParameters glmParam,
                                 boolean superClassParams,
                                 java.lang.reflect.Field[] paramFields,
                                 java.util.List<java.lang.String> excludeList)

buildGLMBuilders

public static GLM[] buildGLMBuilders(GLMModel.GLMParameters[] trainingParams)

removeTrainingFrames

public static void removeTrainingFrames(water.fvec.Frame[] trainingFrames)

findBestModel

public static GLMModel findBestModel(GLM[] glmResults)

Given GLM run results of a fixed number of predictors, find the model with the best R2 value.

Parameters:

glmResults -

extractPredictorNames

public static java.lang.String[] extractPredictorNames(hex.Model.Parameters parms,
                                                       DataInfo dinfo,
                                                       java.lang.String foldColumn)

findMinZValue

public static int findMinZValue(GLMModel model,
                                java.util.List<java.lang.String> numPredNames,
                                java.util.List<java.lang.String> catPredNames,
                                java.util.List<java.lang.String> predNames)

findNumMinZVal

public static hex.modelselection.ModelSelectionUtils.PredNameMinZVal findNumMinZVal(java.util.List<java.lang.String> numPredNames,
                                                                                    java.util.List<java.lang.Double> zValList,
                                                                                    java.util.List<java.lang.String> coeffNames)

findCatMinZVal

public static hex.modelselection.ModelSelectionUtils.PredNameMinZVal findCatMinZVal(GLMModel model,
                                                                                    java.util.List<java.lang.Double> zValList)

This method extracts the categorical coefficient z-value by using the following method: 1. From GLMModel model, it extracts the column names of the dinfo._adaptedFrame that is used to build the glm model and generate the glm coefficients. The column names will be in exactly the same order as the coefficient names with the exception that each enum levels will not be given a name in the column names. 2. To figure out which coefficient name corresponds to which column name, we use the catOffsets which will tell us how many enum levels are used in the glm model coefficients. If the catOffset for the first coefficient says 3, that means that column will have three enum levels represented in the glm model coefficients.

extraModelColumnNames

public static java.util.List<java.lang.String> extraModelColumnNames(java.util.List<java.lang.String> coefNames,
                                                                     GLMModel bestModel)

extractPredSubsetsCPM

public static double[][] extractPredSubsetsCPM(double[][] allCPM,
                                               int[] predIndices,
                                               int[][] pred2CPMIndices,
                                               boolean hasIntercept)

Given a predictor subset and the complete CPM, we extract the CPM associated with the predictors specified in the predictor subset (predIndices).