private double[] setNewBeta(final double[] newBeta) {
final double[] fullBeta;
if (_activeCols != null) {
fullBeta = MemoryManager.malloc8d(_dinfo.fullN() + 1);
int j = 0;
for (int i : _activeCols) fullBeta[i] = newBeta[j++];
assert j == newBeta.length - 1;
fullBeta[fullBeta.length - 1] = newBeta[j];
} else {
assert newBeta.length == _dinfo.fullN() + 1;
fullBeta = newBeta;
}
final double[] newBetaDeNorm;
if (_dinfo._standardize) {
newBetaDeNorm = fullBeta.clone();
double norm = 0.0; // Reverse any normalization on the intercept
// denormalize only the numeric coefs (categoricals are not normalized)
final int numoff = _dinfo.numStart();
for (int i = numoff; i < fullBeta.length - 1; i++) {
double b = newBetaDeNorm[i] * _dinfo._normMul[i - numoff];
norm += b * _dinfo._normSub[i - numoff]; // Also accumulate the intercept adjustment
newBetaDeNorm[i] = b;
}
newBetaDeNorm[newBetaDeNorm.length - 1] -= norm;
} else newBetaDeNorm = null;
_model.setLambdaSubmodel(
_lambdaIdx,
newBetaDeNorm == null ? fullBeta : newBetaDeNorm,
newBetaDeNorm == null ? null : fullBeta,
(_iter + 1));
_model.clone().update(self());
return fullBeta;
}
private void run(final double ymu, final long nobs, LMAXTask lmaxt) {
String[] warns = null;
if ((!lambda_search || !strong_rules_enabled) && (_dinfo.fullN() > MAX_PREDICTORS))
throw new IllegalArgumentException(
"Too many predictors! GLM can only handle "
+ MAX_PREDICTORS
+ " predictors, got "
+ _dinfo.fullN()
+ ", try to run with strong_rules enabled.");
if (lambda_search) {
max_iter = Math.max(300, max_iter);
assert lmaxt != null : "running lambda search, but don't know what is the lambda max!";
final double lmax = lmaxt.lmax();
final double lambda_min_ratio =
_dinfo._adaptedFrame.numRows() > _dinfo.fullN() ? 0.0001 : 0.01;
final double d = Math.pow(lambda_min_ratio, 0.01);
lambda = new double[100];
lambda[0] = lmax;
for (int i = 1; i < lambda.length; ++i) lambda[i] = lambda[i - 1] * d;
_runAllLambdas = false;
} else if (alpha[0] > 0
&& lmaxt
!= null) { // make sure we start with lambda max (and discard all lambda > lambda max)
final double lmax = lmaxt.lmax();
int i = 0;
while (i < lambda.length && lambda[i] > lmax) ++i;
if (i != 0) {
Log.info(
"GLM: removing "
+ i
+ " lambdas > lambda_max: "
+ Arrays.toString(Arrays.copyOf(lambda, i)));
warns =
i == lambda.length
? new String[] {
"Removed " + i + " lambdas > lambda_max",
"No lambdas < lambda_max, returning null model."
}
: new String[] {"Removed " + i + " lambdas > lambda_max"};
}
lambda =
i == lambda.length
? new double[] {lambda_max}
: Arrays.copyOfRange(lambda, i, lambda.length);
}
_model =
new GLMModel(
GLM2.this,
dest(),
_dinfo,
_glm,
beta_epsilon,
alpha[0],
lambda_max,
lambda,
ymu,
prior);
_model.warnings = warns;
_model.clone().delete_and_lock(self());
if (lambda[0] == lambda_max && alpha[0] > 0) { // fill-in trivial solution for lambda max
_beta = MemoryManager.malloc8d(_dinfo.fullN() + 1);
_beta[_beta.length - 1] = _glm.link(ymu) + _iceptAdjust;
_model.setLambdaSubmodel(0, _beta, _beta, 0);
if (lmaxt != null) _model.setAndTestValidation(0, lmaxt._val);
_lambdaIdx = 1;
}
if (_lambdaIdx == lambda.length) // ran only with one lambda > lambda_max => return null model
GLM2.this.complete(); // signal we're done to anyone waiting for the job
else {
++_iter;
if (lmaxt != null && strong_rules_enabled)
activeCols(lambda[_lambdaIdx], lmaxt.lmax(), lmaxt.gradient(l2pen()));
Log.info(
"GLM2 staring GLM after "
+ (System.currentTimeMillis() - start)
+ "ms of preprocessing (mean/lmax/strong rules computation)");
new GLMIterationTask(
GLM2.this,
_activeData,
_glm,
true,
false,
false,
null,
_ymu = ymu,
_reg = 1.0 / nobs,
new Iteration())
.asyncExec(_activeData._adaptedFrame);
}
}