use of hex.deeplearning.DeepLearningModel.DeepLearningParameters in project h2o-3 by h2oai.
the class DeepLearningSpiralsTest method run.
@Test
public void run() {
Scope.enter();
NFSFileVec nfs = TestUtil.makeNfsFileVec("smalldata/junit/two_spiral.csv");
Frame frame = ParseDataset.parse(Key.make(), nfs._key);
Log.info(frame);
int resp = frame.names().length - 1;
for (boolean sparse : new boolean[] { true, false }) {
for (boolean col_major : new boolean[] { false }) {
if (!sparse && col_major)
continue;
Key model_id = Key.make();
// build the model
{
DeepLearningParameters p = new DeepLearningParameters();
p._epochs = 5000;
p._hidden = new int[] { 100 };
p._sparse = sparse;
p._col_major = col_major;
p._activation = DeepLearningParameters.Activation.Tanh;
p._initial_weight_distribution = DeepLearningParameters.InitialWeightDistribution.Normal;
p._initial_weight_scale = 2.5;
p._loss = DeepLearningParameters.Loss.CrossEntropy;
p._train = frame._key;
p._response_column = frame.names()[resp];
// Convert response to categorical
Scope.track(frame.replace(resp, frame.vecs()[resp].toCategoricalVec()));
DKV.put(frame);
p._rho = 0.99;
p._epsilon = 5e-3;
//stop when reaching 0 classification error on training data
p._classification_stop = 0;
p._train_samples_per_iteration = 10000;
p._stopping_rounds = 5;
p._stopping_metric = ScoreKeeper.StoppingMetric.misclassification;
p._score_each_iteration = true;
p._reproducible = true;
p._seed = 1234;
new DeepLearning(p, model_id).trainModel().get();
}
// score and check result
{
DeepLearningModel mymodel = DKV.getGet(model_id);
Frame pred = mymodel.score(frame);
ModelMetricsBinomial mm = ModelMetricsBinomial.getFromDKV(mymodel, frame);
double error = mm._auc.defaultErr();
Log.info("Error: " + error);
if (error > 0.1) {
Assert.fail("Test classification error is not <= 0.1, but " + error + ".");
}
Assert.assertTrue(mymodel.testJavaScoring(frame, pred, 1e-6));
pred.delete();
mymodel.delete();
}
}
}
frame.delete();
Scope.exit();
}
use of hex.deeplearning.DeepLearningModel.DeepLearningParameters in project h2o-3 by h2oai.
the class DeepLearningCheckpointReporting method run.
@Test
public void run() {
Scope.enter();
Frame frame = null;
try {
NFSFileVec trainfv = TestUtil.makeNfsFileVec("smalldata/logreg/prostate.csv");
frame = ParseDataset.parse(Key.make(), trainfv._key);
DeepLearningParameters p = new DeepLearningParameters();
// populate model parameters
p._train = frame._key;
// last column is the response
p._response_column = "CAPSULE";
p._activation = DeepLearningParameters.Activation.Rectifier;
p._epochs = 4;
p._train_samples_per_iteration = -1;
p._score_duty_cycle = 1;
p._score_interval = 0;
p._overwrite_with_best_model = false;
p._classification_stop = -1;
p._seed = 1234;
p._reproducible = true;
// Convert response 'C785' to categorical (digits 1 to 10)
int ci = frame.find("CAPSULE");
Scope.track(frame.replace(ci, frame.vecs()[ci].toCategoricalVec()));
DKV.put(frame);
long start = System.currentTimeMillis();
//to avoid rounding issues with printed time stamp (1 second resolution)
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
}
DeepLearningModel model = new DeepLearning(p).trainModel().get();
//seconds
long sleepTime = 5;
try {
Thread.sleep(sleepTime * 1000);
} catch (InterruptedException ex) {
}
// checkpoint restart after sleep
DeepLearningParameters p2 = (DeepLearningParameters) p.clone();
p2._checkpoint = model._key;
p2._epochs *= 2;
DeepLearningModel model2 = null;
try {
model2 = new DeepLearning(p2).trainModel().get();
long end = System.currentTimeMillis();
TwoDimTable table = model2._output._scoring_history;
double priorDurationDouble = 0;
long priorTimeStampLong = 0;
DateTimeFormatter fmt = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
for (int i = 0; i < table.getRowDim(); ++i) {
// Check that timestamp is correct, and growing monotonically
String timestamp = (String) table.get(i, 0);
long timeStampLong = fmt.parseMillis(timestamp);
Assert.assertTrue("Timestamp must be later than outside timer start", timeStampLong >= start);
Assert.assertTrue("Timestamp must be earlier than outside timer end", timeStampLong <= end);
Assert.assertTrue("Timestamp must increase", timeStampLong >= priorTimeStampLong);
priorTimeStampLong = timeStampLong;
// Check that duration is growing monotonically
String duration = (String) table.get(i, 1);
//"x.xxxx sec"
duration = duration.substring(0, duration.length() - 4);
try {
double durationDouble = Double.parseDouble(duration);
Assert.assertTrue("Duration must be >0: " + durationDouble, durationDouble >= 0);
Assert.assertTrue("Duration must increase: " + priorDurationDouble + " -> " + durationDouble, durationDouble >= priorDurationDouble);
Assert.assertTrue("Duration cannot be more than outside timer delta", durationDouble <= (end - start) / 1e3);
priorDurationDouble = durationDouble;
} catch (NumberFormatException ex) {
//skip
}
// Check that epoch counting is good
//1 epoch per step
Assert.assertTrue("Epoch counter must be contiguous", (Double) table.get(i, 3) == i);
//1 iteration per step
Assert.assertTrue("Iteration counter must match epochs", (Integer) table.get(i, 4) == i);
}
try {
// Check that duration doesn't see the sleep
String durationBefore = (String) table.get((int) (p._epochs), 1);
durationBefore = durationBefore.substring(0, durationBefore.length() - 4);
String durationAfter = (String) table.get((int) (p._epochs + 1), 1);
durationAfter = durationAfter.substring(0, durationAfter.length() - 4);
double diff = Double.parseDouble(durationAfter) - Double.parseDouble(durationBefore);
Assert.assertTrue("Duration must be smooth; actual " + diff + ", expected at most " + sleepTime + " (before=" + durationBefore + ", after=" + durationAfter + ")", diff < sleepTime + 1);
// Check that time stamp does see the sleep
String timeStampBefore = (String) table.get((int) (p._epochs), 0);
long timeStampBeforeLong = fmt.parseMillis(timeStampBefore);
String timeStampAfter = (String) table.get((int) (p._epochs + 1), 0);
long timeStampAfterLong = fmt.parseMillis(timeStampAfter);
Assert.assertTrue("Time stamp must experience a delay", timeStampAfterLong - timeStampBeforeLong >= (sleepTime - 1) * 1000);
// Check that the training speed is similar before and after checkpoint restart
String speedBefore = (String) table.get((int) (p._epochs), 2);
speedBefore = speedBefore.substring(0, speedBefore.length() - 9);
double speedBeforeDouble = Double.parseDouble(speedBefore);
String speedAfter = (String) table.get((int) (p._epochs + 1), 2);
speedAfter = speedAfter.substring(0, speedAfter.length() - 9);
double speedAfterDouble = Double.parseDouble(speedAfter);
//expect less than 50% change in speed
Assert.assertTrue("Speed shouldn't change more than 50%", Math.abs(speedAfterDouble - speedBeforeDouble) / speedBeforeDouble < 0.5);
} catch (NumberFormatException ex) {
//skip runtimes > 1 minute (too hard to parse into seconds here...).
}
} finally {
if (model != null)
model.delete();
if (model2 != null)
model2.delete();
}
} finally {
if (frame != null)
frame.remove();
Scope.exit();
}
}
use of hex.deeplearning.DeepLearningModel.DeepLearningParameters in project h2o-3 by h2oai.
the class DeepLearningGradientCheck method gradientCheck.
@Test
public void gradientCheck() {
Frame tfr = null;
DeepLearningModel dl = null;
try {
tfr = parse_test_file("smalldata/glm_test/cancar_logIn.csv");
for (String s : new String[] { "Merit", "Class" }) {
Vec f = tfr.vec(s).toCategoricalVec();
tfr.remove(s).remove();
tfr.add(s, f);
}
DKV.put(tfr);
tfr.add("Binary", tfr.anyVec().makeZero());
new MRTask() {
public void map(Chunk[] c) {
for (int i = 0; i < c[0]._len; ++i) if (c[0].at8(i) == 1)
c[1].set(i, 1);
}
}.doAll(tfr.vecs(new String[] { "Class", "Binary" }));
Vec cv = tfr.vec("Binary").toCategoricalVec();
tfr.remove("Binary").remove();
tfr.add("Binary", cv);
DKV.put(tfr);
Random rng = new Random(0xDECAF);
int count = 0;
int failedcount = 0;
double maxRelErr = 0;
double meanRelErr = 0;
for (DistributionFamily dist : new DistributionFamily[] { DistributionFamily.gaussian, DistributionFamily.laplace, DistributionFamily.quantile, DistributionFamily.huber, // DistributionFamily.modified_huber,
DistributionFamily.gamma, DistributionFamily.poisson, DistributionFamily.AUTO, DistributionFamily.tweedie, DistributionFamily.multinomial, DistributionFamily.bernoulli }) {
for (DeepLearningParameters.Activation act : new DeepLearningParameters.Activation[] { // DeepLearningParameters.Activation.ExpRectifier,
DeepLearningParameters.Activation.Tanh, DeepLearningParameters.Activation.Rectifier }) {
for (String response : new String[] { //binary classification
"Binary", //multi-class
"Class", //regression
"Cost" }) {
for (boolean adaptive : new boolean[] { true, false }) {
for (int miniBatchSize : new int[] { 1 }) {
if (response.equals("Class")) {
if (dist != DistributionFamily.multinomial && dist != DistributionFamily.AUTO)
continue;
} else if (response.equals("Binary")) {
if (dist != DistributionFamily.modified_huber && dist != DistributionFamily.bernoulli && dist != DistributionFamily.AUTO)
continue;
} else {
if (dist == DistributionFamily.multinomial || dist == DistributionFamily.modified_huber || dist == DistributionFamily.bernoulli)
continue;
}
DeepLearningParameters parms = new DeepLearningParameters();
parms._huber_alpha = rng.nextDouble() + 0.1;
parms._tweedie_power = 1.01 + rng.nextDouble() * 0.9;
parms._quantile_alpha = 0.05 + rng.nextDouble() * 0.9;
parms._train = tfr._key;
//converge to a reasonable model to avoid too large gradients
parms._epochs = 100;
parms._l1 = 1e-3;
parms._l2 = 1e-3;
parms._force_load_balance = false;
parms._hidden = new int[] { 10, 10, 10 };
//otherwise we introduce small bprop errors
parms._fast_mode = false;
parms._response_column = response;
parms._distribution = dist;
parms._max_w2 = 10;
parms._seed = 0xaaabbb;
parms._activation = act;
parms._adaptive_rate = adaptive;
parms._rate = 1e-4;
parms._momentum_start = 0.9;
parms._momentum_stable = 0.99;
parms._mini_batch_size = miniBatchSize;
// DeepLearningModelInfo.gradientCheck = null;
//tell it what gradient to collect
DeepLearningModelInfo.gradientCheck = new DeepLearningModelInfo.GradientCheck(0, 0, 0);
// Build a first model; all remaining models should be equal
DeepLearning job = new DeepLearning(parms);
try {
dl = job.trainModel().get();
boolean classification = response.equals("Class") || response.equals("Binary");
if (!classification) {
Frame p = dl.score(tfr);
hex.ModelMetrics mm = hex.ModelMetrics.getFromDKV(dl, tfr);
double resdev = ((ModelMetricsRegression) mm)._mean_residual_deviance;
Log.info("Mean residual deviance: " + resdev);
p.delete();
}
//golden version
DeepLearningModelInfo modelInfo = IcedUtils.deepCopy(dl.model_info());
// Log.info(modelInfo.toStringAll());
long before = dl.model_info().checksum_impl();
float meanLoss = 0;
// loop over every row in the dataset and check that the predictions
for (int rId = 0; rId < tfr.numRows(); rId += 1) /*miniBatchSize*/
{
// start from scratch - with a clean model
dl.set_model_info(IcedUtils.deepCopy(modelInfo));
final DataInfo di = dl.model_info().data_info();
// populate miniBatch (consecutive rows)
final DataInfo.Row[] rowsMiniBatch = new DataInfo.Row[miniBatchSize];
for (int i = 0; i < rowsMiniBatch.length; ++i) {
if (0 <= rId + i && rId + i < tfr.numRows()) {
rowsMiniBatch[i] = new FrameTask.ExtractDenseRow(di, rId + i).doAll(di._adaptedFrame)._row;
}
}
// loss at weight
long cs = dl.model_info().checksum_impl();
double loss = dl.meanLoss(rowsMiniBatch);
assert (cs == before);
assert (before == dl.model_info().checksum_impl());
meanLoss += loss;
for (int layer = 0; layer <= parms._hidden.length; ++layer) {
int rows = dl.model_info().get_weights(layer).rows();
assert (dl.model_info().get_biases(layer).size() == rows);
for (int row = 0; row < rows; ++row) {
//check bias
if (true) {
// start from scratch - with a clean model
dl.set_model_info(IcedUtils.deepCopy(modelInfo));
// do one forward propagation pass (and fill the mini-batch gradients -> set training=true)
Neurons[] neurons = DeepLearningTask.makeNeuronsForTraining(dl.model_info());
double[] responses = new double[miniBatchSize];
double[] offsets = new double[miniBatchSize];
int n = 0;
for (DataInfo.Row myRow : rowsMiniBatch) {
if (myRow == null)
continue;
((Neurons.Input) neurons[0]).setInput(-1, myRow.numIds, myRow.numVals, myRow.nBins, myRow.binIds, n);
responses[n] = myRow.response(0);
offsets[n] = myRow.offset;
n++;
}
DeepLearningTask.fpropMiniBatch(-1, /*seed doesn't matter*/
neurons, dl.model_info(), null, true, /*training*/
responses, offsets, n);
// check that we didn't change the model's weights/biases
long after = dl.model_info().checksum_impl();
assert (after == before);
// record the gradient since gradientChecking is enabled
//tell it what gradient to collect
DeepLearningModelInfo.gradientCheck = new DeepLearningModelInfo.GradientCheck(layer, row, -1);
//update the weights and biases
DeepLearningTask.bpropMiniBatch(neurons, n);
assert (before != dl.model_info().checksum_impl());
// reset the model back to the trained model
dl.set_model_info(IcedUtils.deepCopy(modelInfo));
assert (before == dl.model_info().checksum_impl());
double bpropGradient = DeepLearningModelInfo.gradientCheck.gradient;
// FIXME: re-enable this once the loss is computed from the de-standardized prediction/response
// double actualResponse=myRow.response[0];
// double predResponseLinkSpace = neurons[neurons.length-1]._a.get(0);
// if (di._normRespMul != null) {
// bpropGradient /= di._normRespMul[0]; //no shift for gradient
// actualResponse = (actualResponse / di._normRespMul[0] + di._normRespSub[0]);
// predResponseLinkSpace = (predResponseLinkSpace / di._normRespMul[0] + di._normRespSub[0]);
// }
// bpropGradient *= new Distribution(parms._distribution).gradient(actualResponse, predResponseLinkSpace);
final double bias = dl.model_info().get_biases(layer).get(row);
//don't make the weight deltas too small, or the float weights "won't notice"
double eps = 1e-4 * Math.abs(bias);
if (eps == 0)
eps = 1e-6;
// loss at bias + eps
dl.model_info().get_biases(layer).set(row, bias + eps);
double up = dl.meanLoss(rowsMiniBatch);
// loss at bias - eps
dl.model_info().get_biases(layer).set(row, bias - eps);
double down = dl.meanLoss(rowsMiniBatch);
if (Math.abs(up - down) / Math.abs(up + down) < 1e-8) {
//relative change in loss function is too small -> skip
continue;
}
double gradient = ((up - down) / (2. * eps));
double relError = 2 * Math.abs(bpropGradient - gradient) / (Math.abs(gradient) + Math.abs(bpropGradient));
count++;
// if either gradient is tiny, check if both are tiny
if (Math.abs(gradient) < 1e-7 || Math.abs(bpropGradient) < 1e-7) {
//all good
if (Math.abs(bpropGradient - gradient) < 1e-7)
continue;
}
meanRelErr += relError;
if (relError > MAX_TOLERANCE) {
Log.info("\nDistribution: " + dl._parms._distribution);
Log.info("\nRow: " + rId);
Log.info("bias (layer " + layer + ", row " + row + "): " + bias + " +/- " + eps);
Log.info("loss: " + loss);
Log.info("losses up/down: " + up + " / " + down);
Log.info("=> Finite differences gradient: " + gradient);
Log.info("=> Back-propagation gradient : " + bpropGradient);
Log.info("=> Relative error : " + PrettyPrint.formatPct(relError));
failedcount++;
}
}
int cols = dl.model_info().get_weights(layer).cols();
for (int col = 0; col < cols; ++col) {
if (rng.nextFloat() >= SAMPLE_RATE)
continue;
// start from scratch - with a clean model
dl.set_model_info(IcedUtils.deepCopy(modelInfo));
// do one forward propagation pass (and fill the mini-batch gradients -> set training=true)
Neurons[] neurons = DeepLearningTask.makeNeuronsForTraining(dl.model_info());
double[] responses = new double[miniBatchSize];
double[] offsets = new double[miniBatchSize];
int n = 0;
for (DataInfo.Row myRow : rowsMiniBatch) {
if (myRow == null)
continue;
((Neurons.Input) neurons[0]).setInput(-1, myRow.numIds, myRow.numVals, myRow.nBins, myRow.binIds, n);
responses[n] = myRow.response(0);
offsets[n] = myRow.offset;
n++;
}
DeepLearningTask.fpropMiniBatch(-1, /*seed doesn't matter*/
neurons, dl.model_info(), null, true, /*training*/
responses, offsets, n);
// check that we didn't change the model's weights/biases
long after = dl.model_info().checksum_impl();
assert (after == before);
// record the gradient since gradientChecking is enabled
//tell it what gradient to collect
DeepLearningModelInfo.gradientCheck = new DeepLearningModelInfo.GradientCheck(layer, row, col);
//update the weights
DeepLearningTask.bpropMiniBatch(neurons, n);
assert (before != dl.model_info().checksum_impl());
// reset the model back to the trained model
dl.set_model_info(IcedUtils.deepCopy(modelInfo));
assert (before == dl.model_info().checksum_impl());
double bpropGradient = DeepLearningModelInfo.gradientCheck.gradient;
// FIXME: re-enable this once the loss is computed from the de-standardized prediction/response
// double actualResponse=myRow.response[0];
// double predResponseLinkSpace = neurons[neurons.length-1]._a.get(0);
// if (di._normRespMul != null) {
// bpropGradient /= di._normRespMul[0]; //no shift for gradient
// actualResponse = (actualResponse / di._normRespMul[0] + di._normRespSub[0]);
// predResponseLinkSpace = (predResponseLinkSpace / di._normRespMul[0] + di._normRespSub[0]);
// }
// bpropGradient *= new Distribution(parms._distribution).gradient(actualResponse, predResponseLinkSpace);
final float weight = dl.model_info().get_weights(layer).get(row, col);
//don't make the weight deltas too small, or the float weights "won't notice"
double eps = 1e-4 * Math.abs(weight);
if (eps == 0)
eps = 1e-6;
// loss at weight + eps
dl.model_info().get_weights(layer).set(row, col, (float) (weight + eps));
double up = dl.meanLoss(rowsMiniBatch);
// loss at weight - eps
dl.model_info().get_weights(layer).set(row, col, (float) (weight - eps));
double down = dl.meanLoss(rowsMiniBatch);
if (Math.abs(up - down) / Math.abs(up + down) < 1e-8) {
//relative change in loss function is too small -> skip
continue;
}
double gradient = ((up - down) / (2. * eps));
double relError = 2 * Math.abs(bpropGradient - gradient) / (Math.abs(gradient) + Math.abs(bpropGradient));
count++;
// if either gradient is tiny, check if both are tiny
if (Math.abs(gradient) < 1e-7 || Math.abs(bpropGradient) < 1e-7) {
//all good
if (Math.abs(bpropGradient - gradient) < 1e-7)
continue;
}
meanRelErr += relError;
if (relError > MAX_TOLERANCE) {
Log.info("\nDistribution: " + dl._parms._distribution);
Log.info("\nRow: " + rId);
Log.info("weight (layer " + layer + ", row " + row + ", col " + col + "): " + weight + " +/- " + eps);
Log.info("loss: " + loss);
Log.info("losses up/down: " + up + " / " + down);
Log.info("=> Finite differences gradient: " + gradient);
Log.info("=> Back-propagation gradient : " + bpropGradient);
Log.info("=> Relative error : " + PrettyPrint.formatPct(relError));
failedcount++;
}
// Assert.assertTrue(failedcount==0);
maxRelErr = Math.max(maxRelErr, relError);
assert (!Double.isNaN(maxRelErr));
}
}
}
}
meanLoss /= tfr.numRows();
Log.info("Mean loss: " + meanLoss);
// // FIXME: re-enable this
// if (parms._l1 == 0 && parms._l2 == 0) {
// assert(Math.abs(meanLoss-resdev)/Math.abs(resdev) < 1e-5);
// }
} catch (RuntimeException ex) {
dl = DKV.getGet(job.dest());
if (dl != null)
Assert.assertTrue(dl.model_info().isUnstable());
else
Assert.assertTrue(job.isStopped());
} finally {
if (dl != null)
dl.delete();
}
}
}
}
}
}
Log.info("Number of tests: " + count);
Log.info("Number of failed tests: " + failedcount);
Log.info("Mean. relative error: " + meanRelErr / count);
Log.info("Max. relative error: " + PrettyPrint.formatPct(maxRelErr));
Assert.assertTrue("Error too large: " + maxRelErr + " >= " + MAX_TOLERANCE, maxRelErr < MAX_TOLERANCE);
Assert.assertTrue("Failed count too large: " + failedcount + " > " + MAX_FAILED_COUNT, failedcount <= MAX_FAILED_COUNT);
} finally {
if (tfr != null)
tfr.remove();
}
}
use of hex.deeplearning.DeepLearningModel.DeepLearningParameters in project h2o-3 by h2oai.
the class DeepLearningTest method testHuberDeltaTiny.
@Test
public void testHuberDeltaTiny() {
Frame tfr = null;
DeepLearningModel dl = null;
try {
tfr = parse_test_file("./smalldata/gbm_test/BostonHousing.csv");
DeepLearningParameters parms = new DeepLearningParameters();
parms._train = tfr._key;
parms._response_column = tfr.lastVecName();
parms._reproducible = true;
parms._hidden = new int[] { 20, 20 };
parms._seed = 0xdecaf;
parms._distribution = huber;
parms._huber_alpha = 1e-2;
// more like Laplace, but different slope and different prefactor -> so can't compare deviance 1:1
dl = new DeepLearning(parms).trainModel().get();
double delta = 0.011996;
// can compute huber loss from MAE since no obs weights
Assert.assertEquals((2 * 2.31398 - /*MAE*/
delta) * delta, ((ModelMetricsRegression) dl._output._training_metrics)._mean_residual_deviance, 2e-2);
Assert.assertEquals(19.856, ((ModelMetricsRegression) dl._output._training_metrics)._MSE, 1e-3);
} finally {
if (tfr != null)
tfr.delete();
if (dl != null)
dl.deleteCrossValidationModels();
if (dl != null)
dl.delete();
}
}
use of hex.deeplearning.DeepLearningModel.DeepLearningParameters in project h2o-3 by h2oai.
the class DeepLearningTest method testCategoricalEncodingBinary.
@Test
public void testCategoricalEncodingBinary() {
Frame tfr = null;
DeepLearningModel dl = null;
try {
String response = "survived";
tfr = parse_test_file("./smalldata/junit/titanic_alt.csv");
if (tfr.vec(response).isBinary()) {
Vec v = tfr.remove(response);
tfr.add(response, v.toCategoricalVec());
v.remove();
}
DKV.put(tfr);
DeepLearningParameters parms = new DeepLearningParameters();
parms._train = tfr._key;
parms._valid = tfr._key;
parms._response_column = response;
parms._reproducible = true;
parms._hidden = new int[] { 20, 20 };
parms._seed = 0xdecaf;
parms._nfolds = 3;
parms._categorical_encoding = Model.Parameters.CategoricalEncodingScheme.Binary;
dl = new DeepLearning(parms).trainModel().get();
Assert.assertEquals(0.94696, ((ModelMetricsBinomial) dl._output._training_metrics)._auc._auc, 1e-4);
Assert.assertEquals(0.94696, ((ModelMetricsBinomial) dl._output._validation_metrics)._auc._auc, 1e-4);
Assert.assertEquals(0.86556613, ((ModelMetricsBinomial) dl._output._cross_validation_metrics)._auc._auc, 1e-4);
Assert.assertEquals(0.86556613, Double.parseDouble((String) (dl._output._cross_validation_metrics_summary).get(1, 0)), 1e-2);
} finally {
if (tfr != null)
tfr.remove();
if (dl != null)
dl.deleteCrossValidationModels();
if (dl != null)
dl.delete();
}
}
Aggregations