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, water.fvec.Frame allCPMFrame, 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[]	dropIgnoredCols(GLMTask.GLMIterationTask gtask, java.util.List<java.lang.Integer> ignoredCols)
static java.util.List<java.lang.Integer>	extractCPMIndexFromPred(int cpmLastIndex, int[][] pred2CPMIndices, int[] newPredList, boolean hasIntercept)
static java.util.List<java.lang.Integer>	extractCPMIndexFromPredOnly(int[][] pred2CPMIndices, int[] newPredList) Given the predictor in subset newPredList, this function will find the rows/columns in the cpm matrix that are contributed by the predictors in subset newPredList.
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 double[][]	extractPredSubsetsCPMFrame(water.fvec.Frame 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 java.util.List<java.lang.Integer>	findFullDupPred(DataInfo dinfo, java.util.List<java.lang.Integer> ignoredCols, java.util.List<java.lang.String> ignoredPredNames, java.util.List<java.lang.String> ignoredCoefNames, java.lang.String[] prednames) The duplicated columns generated by qr-cholesky is at the level of coefficients.
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 double[][]	formCPM(Gram gram, double[] xTransposey, double yy)
static hex.modelselection.ModelSelectionUtils.CPMnPredNames	genCPMPredNamesIndex(water.Key jobKey, DataInfo dinfo, java.lang.String[] predictorNames, ModelSelectionModel.ModelSelectionParameters parms)
static double[]	generateAllErrVar(double[][] allCPM, water.fvec.Frame allCPMFrame, int prevCPMSize, 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) Given the original predictor subset, this function will go into a for loop and choose one predictor out of the remaining predictor set validSubsets and put it into the array allPreds.
static double[]	generateAllErrVarR(double[][] allCPM, water.fvec.Frame allCPMFrame, double[][] prevCPM, int predPos, 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[] removedPredSweepInd, ModelSelectionUtils.SweepVector[][] removedPredSV) Given the original predictor subset, this function will go into a for loop and choose one predictor out of the remaining predictor set validSubsets and put it into the array allPreds.
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 GLMTask.GLMIterationTask	genGramCheckDup(water.Key jobKey, DataInfo dinfo, java.util.ArrayList<java.lang.Integer> ignoredCols, ModelSelectionModel.ModelSelectionParameters parms)
static void	genMSE1stPred(int[][] pred2CPMIndices, double[][] allCPM, water.fvec.Frame allCPMFrame, int[] allPreds, double[] subsetMSE, jsr166y.RecursiveAction[] resA, int resCount, boolean hasIntercept) This method will calculate the variance variance when only one predictor is considered in allPreds.
static void	genMSE4MorePreds(int[][] pred2CPMIndices, double[][] allCPM, water.fvec.Frame allCPMFrame, int[] allPreds, int lastSweepIndex, double[] subsetMSE, jsr166y.RecursiveAction[] resA, int resCount, boolean hasIntercept) This method will calculate the error variance value for all predictors in the allPreds.
static void	genMSE4MorePredsR(int[][] pred2CPMIndices, double[][] allCPM, water.fvec.Frame allCPMFrame, double[][] prevCPM, int[] allPreds, double[] subsetMSE, jsr166y.RecursiveAction[] resA, int resCount, boolean hasIntercept, ModelSelectionUtils.SweepVector[][] removePredSV, int[] removedPredSweepInd) Generate the error variance for one predictor subset setting in allPreds.
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 numPreds, java.util.List<java.lang.Integer> ignoredPredInd) This method attempts to map all predictors into the corresponding cpm indices that refer to that predictor.
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 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	sweepCPMParallel(water.fvec.Frame cpm, int[] sweepIndices, int[] trackPivotSweeps)
static double	sweepMSE(double[][] subsetCPM, java.util.List<java.lang.Integer> sweepIndices) This function performs sweeping on the last row and column only to update the variance error to reduce computation time.
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.

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)

genCPMPredNamesIndex

public static hex.modelselection.ModelSelectionUtils.CPMnPredNames genCPMPredNamesIndex(water.Key jobKey,
                                                                                        DataInfo dinfo,
                                                                                        java.lang.String[] predictorNames,
                                                                                        ModelSelectionModel.ModelSelectionParameters parms)

mapPredIndex2CPMIndices

public static int[][] mapPredIndex2CPMIndices(DataInfo dinfo,
                                              int numPreds,
                                              java.util.List<java.lang.Integer> ignoredPredInd)

This method attempts to map all predictors into the corresponding cpm indices that refer to that predictor. This is complicated by two things: a. the presence of duplicated predictors that are removed; b. the presence of enum predictors that will map one predictor to multiple consecutive cpm indices. Note that ignoredPredInd is at the level of coefficient indexing and not predictor indexing

formCPM

public static double[][] formCPM(Gram gram,
                                 double[] xTransposey,
                                 double yy)

dropIgnoredCols

public static double[] dropIgnoredCols(GLMTask.GLMIterationTask gtask,
                                       java.util.List<java.lang.Integer> ignoredCols)

findFullDupPred

public static java.util.List<java.lang.Integer> findFullDupPred(DataInfo dinfo,
                                                                java.util.List<java.lang.Integer> ignoredCols,
                                                                java.util.List<java.lang.String> ignoredPredNames,
                                                                java.util.List<java.lang.String> ignoredCoefNames,
                                                                java.lang.String[] prednames)

The duplicated columns generated by qr-cholesky is at the level of coefficients. This means for enum predictors there could be multiple coefficients, one for each level of the enum level. For enum predictors, I will remove the predictor only if all its columns are duplicated. This make it a little more complicated. The returned ignored list is at the level of coefficients.

genGramCheckDup

public static GLMTask.GLMIterationTask genGramCheckDup(water.Key jobKey,
                                                       DataInfo dinfo,
                                                       java.util.ArrayList<java.lang.Integer> ignoredCols,
                                                       ModelSelectionModel.ModelSelectionParameters parms)

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:

generateAllErrVarR

public static double[] generateAllErrVarR(double[][] allCPM,
                                          water.fvec.Frame allCPMFrame,
                                          double[][] prevCPM,
                                          int predPos,
                                          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[] removedPredSweepInd,
                                          ModelSelectionUtils.SweepVector[][] removedPredSV)

Given the original predictor subset, this function will go into a for loop and choose one predictor out of the remaining predictor set validSubsets and put it into the array allPreds. Then, it will spin off a process to calculation the error variance with the addition of the new predictor. All error variances will be stored in an array and returned for further processing. This is very similar to generateAllErrVar but they are not the same. For starters, the replaced predictors are included in the predictor subset allPreds. For details, refer to https://github.com/h2oai/h2o-3/issues/6538, section VI.

genMSE4MorePredsR

public static void genMSE4MorePredsR(int[][] pred2CPMIndices,
                                     double[][] allCPM,
                                     water.fvec.Frame allCPMFrame,
                                     double[][] prevCPM,
                                     int[] allPreds,
                                     double[] subsetMSE,
                                     jsr166y.RecursiveAction[] resA,
                                     int resCount,
                                     boolean hasIntercept,
                                     ModelSelectionUtils.SweepVector[][] removePredSV,
                                     int[] removedPredSweepInd)

Generate the error variance for one predictor subset setting in allPreds. It will do the following: 1. add rows/columns corresponding to new predictor and store the partial CPM in subsetCPM; 2. sweep the new rows/columns from 1 with the sweep vectors generated for the removed predictor and store everything in subsetCPM; 3. sweep the subsetCPM with rows/columns associated with the new predictor; 4. record the new error variance. For details, refer to https://github.com/h2oai/h2o-3/issues/6538, section VI.

generateAllErrVar

public static double[] generateAllErrVar(double[][] allCPM,
                                         water.fvec.Frame allCPMFrame,
                                         int prevCPMSize,
                                         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)

Given the original predictor subset, this function will go into a for loop and choose one predictor out of the remaining predictor set validSubsets and put it into the array allPreds. Then, it will spin off a process to calculation the error variance with the addition of the new predictor. All error variances will be stored in an array and returned for further processing. For details, refer to https://github.com/h2oai/h2o-3/issues/6538, section V.

genMSE4MorePreds

public static void genMSE4MorePreds(int[][] pred2CPMIndices,
                                    double[][] allCPM,
                                    water.fvec.Frame allCPMFrame,
                                    int[] allPreds,
                                    int lastSweepIndex,
                                    double[] subsetMSE,
                                    jsr166y.RecursiveAction[] resA,
                                    int resCount,
                                    boolean hasIntercept)

This method will calculate the error variance value for all predictors in the allPreds. For details, refer to https://github.com/h2oai/h2o-3/issues/6538, section V.

sweepMSE

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

This function performs sweeping on the last row and column only to update the variance error to reduce computation time.

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,
                                 water.fvec.Frame allCPMFrame,
                                 int[] allPreds,
                                 double[] subsetMSE,
                                 jsr166y.RecursiveAction[] resA,
                                 int resCount,
                                 boolean hasIntercept)

This method will calculate the variance variance when only one predictor is considered in allPreds. For details, refer to https://github.com/h2oai/h2o-3/issues/6538, section V.

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,
                                        water.fvec.Frame allCPMFrame,
                                        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.

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. CurrSubsetIndices contains the original predictor subsets.

extractCPMIndexFromPred

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

extractCPMIndexFromPredOnly

public static java.util.List<java.lang.Integer> extractCPMIndexFromPredOnly(int[][] pred2CPMIndices,
                                                                            int[] newPredList)

Given the predictor in subset newPredList, this function will find the rows/columns in the cpm matrix that are contributed by the predictors in subset newPredList.

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.

sweepCPMParallel

public static void sweepCPMParallel(water.fvec.Frame cpm,
                                    int[] sweepIndices,
                                    int[] trackPivotSweeps)

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). If there is intercept, it will be moved to the first row and column.

extractPredSubsetsCPMFrame

public static double[][] extractPredSubsetsCPMFrame(water.fvec.Frame 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). If there is intercept, it will be moved to the first row and column.