I'm running H2O on docker, using centos 7

When I upload a csv file, parse and run auto ml, the first column of my mojo has a BOM character - Zero Width No-Break Space (BOM, ZWNBSP)

This only happens when I'm running on docker. If I run directly on my machine, this character does not show up.

I've tried passing the parameter -Dfile.encoding=utf-8 on startup, but it didn't affect it. Also tried changing the container locale to en_US.utf8, no effect.

We need a utility like this so that we can retrain “optimized” models (found via grid or AutoML, etc) on new data. For example, the full dataset.

In R:

{noformat}h2o.retrain(model, params, training_frame, ...){noformat}

In Python it’s a little different because you can use the existing model object directly which stores the params, and you’d just change the data args in the new {{.retrain()}} method.

{noformat}model = H2OGradientBoostingEstimator(..)
model.train(...)

model.retrain(training_frame, ...){noformat}

It seems that there is an inconsistency and possible inaccuracy in the calculation of variable importance for regression models.

Based on the documentation [here|https://docs.h2o.ai/h2o/latest-stable/h2o-docs/variable-importance.html#variable-importance-calculation-gbm-drf], the variable importance should be the decrease in squared error from a node and it's children nodes. When I try to recreate that calculation using a simple decision stump, I cannot reconcile the values.

Additionally, there seems to be an inconsistency as well compared to the output of h2o.feature_interaction. For a single split tree, I would have expected the metrics to be the same, however they are different, and oddly, the gain value is negative which seems incorrect. Please find the code with a reprex below.

Please let me know if anything about my approach is wrong. Thank you!

# set up
library(data.table)
library(h2o) # 3.36.1.4
h2o.init()
set.seed(12345)

# create dummy data
train_data <- data.frame(x1 = runif(n = 100, min = 1, max = 100), x2 = runif(n = 100, min = 1, max = 100))
train_data$y <- runif(n = 100)*10 + train_data$x1 * 1.5 +  train_data$x2 * -2 
train_data_h2o <- as.h2o(train_data)

# build dummy GBM model (decision tree)
gbm_model <- h2o.gbm(training_frame = train_data_h2o, x = c("x1","x2"), y = "y", ntrees = 1, max_depth = 1, min_rows = 1, seed = 12345)
# look at variable importance table
gbm_model@model$variable_importances

# generate predictions 
train_data_h2o <- h2o.cbind(train_data_h2o, h2o.predict(gbm_model, train_data_h2o))

# get single tree in GBM
tree <- h2o.getModelTree(model = gbm_model, tree_number = 1)

# calculate predictions after first split on x2
train_data_h2o$first_split_pred <- h2o.ifelse(train_data_h2o$x2 >= tree@thresholds[1], gbm_model@model$init_f + tree@predictions[[3]], gbm_model@model$init_f + tree@predictions[[2]])


########### Attempt to calculate relative_importance values from gbm_model@model$variable_importances
# first calculate each node's SSE 
# get SSE of root node
init_f_sse <- sum( (train_data_h2o$y - gbm_model@model$init_f)^2 ) # 518029.3

# calculate SSE from x2's child nodes
x2_right_sse <- sum((train_data_h2o[train_data_h2o$x2 >= tree@thresholds[1],]$y - train_data_h2o[train_data_h2o$x2 >= tree@thresholds[1],]$first_split_pred)^2) # 225849
x2_left_sse <- sum((train_data_h2o[train_data_h2o$x2 < tree@thresholds[1],]$y - train_data_h2o[train_data_h2o$x2 < tree@thresholds[1],]$first_split_pred)^2) # 244693.2

# x2's relative_importance manual calculation
init_f_sse - x2_right_sse - x2_left_sse # 47487.08

# compare to variable_importances table
gbm_model@model$variable_importances[1,2] # 249932 -- doesn't match above

feat_int <- h2o.feature_interaction(gbm_model)

feat_int[[1]]$gain # -0.0078125 

When writing tests for [https://h2oai.atlassian.net/browse/PUBDEV-8876|https://h2oai.atlassian.net/browse/PUBDEV-8876|smart-link], encountered this issue:

{noformat} ~/repos/h2o/h2o-3/h2o-py/h2o/h2o.py in parse_setup(raw_frames, destination_frame, header, separator, column_names, column_types, na_strings, skipped_columns, custom_non_data_line_markers, partition_by, quotechar, escapechar)
874 if len(column_names) != len(j["column_types"]): raise ValueError(
875 "length of col_names should be equal to the number of columns: %d vs %d"
--> 876 % (len(column_names), len(j["column_types"])))
877 j["column_names"] = column_names
878 counter = 0

ValueError: length of col_names should be equal to the number of columns: 1000000 vs 331186{noformat}

Hi!

This ticket is the follow-up ticket to: https://h2oai.atlassian.net/browse/PUBDEV-8960
(The old bug-ticket can be deleted).

The Dataset I am using has the following structure:
time,(CH20 MIN) Flow Speed (m/s),...,(CH24 SAMPLE COUNT) Conductivity,id,classes
(36 columns, time series, name=paradox dataset)

This is my code, which causes the error (shortened):

{code:python}

def jifa():
// x_test is a pandas dataframe
features = create_features(x_test, column_id=automl_model.params.get('column_id'),
column_value=automl_model.params.get('column_value'),
column_kind=automl_model.params.get('column_kind'),
column_sort=automl_model.params.get('column_sort'),
settings=automl_model.feature_settings)

    features = convert_h2oframe_to_numeric(features, features.columns)
    *y_pre = automl_model.model.predict(features)['predict'].as_data_frame()*
    // This line triggers the error in h20

def create_features(data, column_id=None, column_value=None, column_kind=None,
settings=None):
"""Load features."""
//extract_features is a method from ts-fresh to extract important features.
features = extract_features(data, column_id=column_id,
column_value=column_value,
column_kind=column_kind,
kind_to_fc_parameters=settings,
impute_function=impute)
features = h2o.H2OFrame(features).drop([0], axis=0)
return features
{code}

The traceback in h20 is the following:

{panel:title=Traceback in h20}
File “/src/model_selection/model_selection.py”, line 79, in compute_metrics y_pre = automl_model.model.predict(features)['predict'].as_data_frame() {color:#14892c}<-- Still my code{color}

File "/usr/local/lib/python3.8/site-packages/h2o/model/model_base.py", line 280, in predict j = H2OJob(h2o.api("POST /4/Predictions/models/%s/frames/%s" % (self.model_id, test_data.frame_id), data = {'custom_metric_func': custom_metric_func}),

File "/usr/local/lib/python3.8/site-packages/h2o/frame.py", line 415, in frame_id return self._frame()._ex._cache._id

File "/usr/local/lib/python3.8/site-packages/h2o/frame.py", line 735, in _frame self._ex._eager_frame()

File "/usr/local/lib/python3.8/site-packages/h2o/expr.py", line 90, in _eager_frame self._eval_driver('frame')

File "/usr/local/lib/python3.8/site-packages/h2o/expr.py", line 113, in _eval_driver exec_str = self._get_ast_str(top)

File "/usr/local/lib/python3.8/site-packages/h2o/expr.py", line 151, in _get_ast_str exec_str = "({} {})".format(self._op, " ".join([ExprNode._arg_to_expr(ast) for ast in self._children]))

File "/usr/local/lib/python3.8/site-packages/h2o/expr.py", line 151, in exec_str = "({} {})".format(self._op, " ".join([ExprNode._arg_to_expr(ast) for ast in self._children]))

{color:#14892c}Afterwards it reaches the maximum recursion depth. It jumps back and forth between the mehtodes, until the mrd.{color}
{panel}

If the _children of the ExpressionNode consist only out of ExpressionNodes and their children as well. Then it jumps between those mehtodes until the maximum recursion depth.

It is related to this ticket, which tries to replace the recursive build:
https://h2oai.atlassian.net/browse/PUBDEV-8252

(This would solve the problem.)

If the _children of the ExpressionNode consist only out of ExpressionNodes and their children as well. Then it jumps between the methodes __arg_to_expr() _and _get_ast_str()

I cannot upload the dataset to this bug-ticket, please send a mail to: [mailto:[email protected]]. And I'll send the dataset to you.

Using an offset column in a GLM model in combination with lambda search sometimes delivers incorrect results. The maximum starting value of lambda is too high when an offset is used (calculation of lambda max is incorrect in case of offset), which causes the algorithm to stop too early.

An example is added where the GLM algorithm has been performed with and without offset. In this case the offset column contains only zero's. Therefore the model results should be exactly the same for both models.

• The GLM with offset starts with a lambda_max of 1.9928.
• The GLM without offset starts with a lambda_max of 0.05458.

Both models should start with a lambda_max of 0.05458

This difference in lambda_max leads to different model outcomes where the model with offset contains no coefficients and the model without offset contains one coefficient.

During development of negative binomial dispersion using maximum likelihood I noticed that some times I get the following error.

{noformat}java.lang.ArrayIndexOutOfBoundsException: -1
at hex.gram.Gram.dropCols(Gram.java:364)
at hex.glm.ComputationState.computeNewGram(ComputationState.java:1030)
at hex.glm.ComputationState.computeGram(ComputationState.java:1064)
at hex.glm.GLM$GLMDriver.fitIRLSMML(GLM.java:2156)
at hex.glm.GLM$GLMDriver.fitModel(GLM.java:2539)
at hex.glm.GLM$GLMDriver.computeSubmodel(GLM.java:3022)
at hex.glm.GLM$GLMDriver.doCompute(GLM.java:3163)
at hex.glm.GLM$GLMDriver.computeImpl(GLM.java:3057)
at hex.ModelBuilder$Driver.compute2(ModelBuilder.java:252)
at hex.glm.GLM$GLMDriver.compute2(GLM.java:1508)
at water.H2O$H2OCountedCompleter.compute(H2O.java:1677)
at jsr166y.CountedCompleter.exec(CountedCompleter.java:468)
at jsr166y.ForkJoinTask.doExec(ForkJoinTask.java:263)
at jsr166y.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:976)
at jsr166y.ForkJoinPool.runWorker(ForkJoinPool.java:1479)
at jsr166y.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:104)
{noformat}

In negative binomial case, this could be partially solved by not removing columns containing zeros if there would be none left ([here|https://github.com/h2oai/h2o-3/blob/fb295a39f9731cd69ff32b40fd1f224c2b4d1913/h2o-algos/src/main/java/hex/glm/ComputationState.java#L1029]) but this often leads to {{NonSPDMatrix}} exception. This can also be partially solved by limiting/truncating {{d}} in [here|https://github.com/h2oai/h2o-3/blob/fb295a39f9731cd69ff32b40fd1f224c2b4d1913/h2o-algos/src/main/java/hex/glm/GLMModel.java#L1163-L1167].

To reproduce you can use the attached file and run the following code:

{code:r}df <- read.csv("95-1477-8.csv")

summary(MASS::glm.nb(result~., df))

hdf <- as.h2o(df)
m <- h2o.glm(y = "result", training_frame = hdf,
family = "negativebinomial", link = "log",
dispersion_parameter_method = "ml", standardize = FALSE,
seed = 95){code}

When using an integer column in pandas it will get converted to a float column in h2o ({{H2OFrame(df)}}) due to using {{df.value.tolist()}} which will create a {{numpy}} {{ndarray}} and from that a list that contains floats instead of ints (if any other column was a float column) this then gets uploaded to the backend as CSV. This could be solved by using pandas' {{to_csv}} instead.

For long running jobs like AutoML runs, showing only percentage in the progress bar looks very insufficient (especially if the job doesn’t have a time limit provided by the user) as the percentage estimation provided by the progress bar logic is often inaccurate (the progress speed being non-linear, it can get stuck to a certain percentage for a long time).

To provide better feedback to the user, I suggest to add a timer (in seconds) next to this percentage.
For example:

{noformat}AutoML progress: |███████▎ | 19% | 3:54{noformat}

On top of this, the percentage doesn’t seem to be rendered in Jupyter notebooks, let’s fix this at the same time.

https://h2oai.atlassian.net/browse/PUBDEV-8989

I have exposed auto_rebalance parameter. It is available for testing now.

I am using h2o 3.34.0.7 version with python. I tried to find a h2o defined method to write data to snowflake table but was not able to find it. Is there a h2o defined way to do it? If not, can I expect for that functionality to be added in a future version release?

I train GBM models with H2O and want to use them in my backend (not Java). To do so, I download the MOJOs, convert it to ONNX and run it in my apps.

In order to make inference, I need to know how categorical columns transformed to their one-hot encoded versions. I was able to find it in the POJO:

{code:java}
static final void fill(String[] sa) {
sa[0] = "Age";
sa[1] = "Fare";
sa[2] = "Pclass.1";
sa[3] = "Pclass.2";
sa[4] = "Pclass.3";
sa[5] = "Pclass.missing(NA)";
sa[6] = "Sex.female";
sa[7] = "Sex.male";
sa[8] = "Sex.missing(NA)";
}
{code}

So, here is the workflow for non-Java backend as I see it:

Encode categorical features with OneHotExplicit.

Train GBM model.

Download MOJO and convert to ONNX.

Download POJO and find feature alignment in the source code.

Implement the inference in your backend.

Is it the most straightforward and correct way?

I am using h2o 3.34.0.7 version with python. I tried to find a h2o defined method to write data to snowflake table, but was not able to find it. Is there a h2o defined way to do it? If not, can I expect for that functionality to be added in a future version release?

h2o version '3.32.1.3'

I created a GLM model using the 'Test_Model = H2OGeneralizedLinearEstimator.makeGLMModel(model = GLM_model, coefs = coeff)"
And this model works fine while predicting "pred_valid = Test_Model .predict(valid)"
I was able to save this model in a mojo format as well,
"modelfile = Test_Model .download_mojo(path=r"temp/Model")
print("Model saved to " + modelfile)"
Model saved to temp/aa6519371d527ad213332499b9654416.zip

But when I tried to load the model and do predictions,
imported_model = h2o.import_mojo('temp/aa6519371d527ad213332499b9654416.zip')
Error happened.

generic Model Build progress: | (failed)

OSError Traceback (most recent call last)
in
1 #uploaded_model = h2o.upload_model(modelfile)
----> 2 imported_model = h2o.import_mojo('temp/aa6519371d527ad213332499b9654416.zip')

~/.local/lib/python3.7/site-packages/h2o/h2o.py in import_mojo(mojo_path)
2250 if mojo_path == None:
2251 raise TypeError("MOJO path may not be None")
-> 2252 mojo_estimator = H2OGenericEstimator.from_file(mojo_path)
2253 print(mojo_estimator)
2254 return mojo_estimator

~/.local/lib/python3.7/site-packages/h2o/estimators/generic.py in from_file(file)
122 """
123 model = H2OGenericEstimator(path = file)
--> 124 model.train()
125
126 return model

~/.local/lib/python3.7/site-packages/h2o/estimators/estimator_base.py in train(self, x, y, training_frame, offset_column, fold_column, weights_column, validation_frame, max_runtime_secs, ignored_columns, model_id, verbose)
113 validation_frame=validation_frame, max_runtime_secs=max_runtime_secs,
114 ignored_columns=ignored_columns, model_id=model_id, verbose=verbose)
--> 115 self._train(parms, verbose=verbose)
116
117 def train_segments(self, x=None, y=None, training_frame=None, offset_column=None, fold_column=None,

~/.local/lib/python3.7/site-packages/h2o/estimators/estimator_base.py in _train(self, parms, verbose)
205 return
206
--> 207 job.poll(poll_updates=self._print_model_scoring_history if verbose else None)
208 model_json = h2o.api("GET /%d/Models/%s" % (rest_ver, job.dest_key))["models"][0]
209 self._resolve_model(job.dest_key, model_json)

~/.local/lib/python3.7/site-packages/h2o/job.py in poll(self, poll_updates)
78 if (isinstance(self.job, dict)) and ("stacktrace" in list(self.job)):
79 raise EnvironmentError("Job with key {} failed with an exception: {}\nstacktrace: "
---> 80 "\n{}".format(self.job_key, self.exception, self.job["stacktrace"]))
81 else:
82 raise EnvironmentError("Job with key %s failed with an exception: %s" % (self.job_key, self.exception))

OSError: Job with key $03017f00000138d4ffffffff$_9d4bdc44f080e644f672efad9a654323 failed with an exception: java.lang.ClassCastException: com.google.gson.JsonNull cannot be cast to com.google.gson.JsonArray
stacktrace:
java.lang.ClassCastException: com.google.gson.JsonNull cannot be cast to com.google.gson.JsonArray
at hex.genmodel.attributes.ModelJsonReader.readTableArray(ModelJsonReader.java:53)
at hex.genmodel.ModelMojoReader.readReproducibilityInformation(ModelMojoReader.java:251)
at hex.genmodel.ModelMojoReader.readAll(ModelMojoReader.java:245)
at hex.genmodel.ModelMojoReader.readFrom(ModelMojoReader.java:65)
at hex.generic.Generic$MojoDelegatingModelDriver.computeImpl(Generic.java:94)
at hex.ModelBuilder$Driver.compute2(ModelBuilder.java:246)
at hex.generic.Generic$MojoDelegatingModelDriver.compute2(Generic.java:79)
at water.H2O$H2OCountedCompleter.compute(H2O.java:1637)
at jsr166y.CountedCompleter.exec(CountedCompleter.java:468)
at jsr166y.ForkJoinTask.doExec(ForkJoinTask.java:263)
at jsr166y.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:974)
at jsr166y.ForkJoinPool.runWorker(ForkJoinPool.java:1477)
at jsr166y.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:104)

These approaches are often used in financial ML. Can benefit a wide variety of ML tasks though.

In short: Adding a safety gap between the k-folds or train-, test- and validation splits.

These articles explain it in detail:
[
https://medium.com/mlearning-ai/why-k-fold-cross-validation-is-failing-in-finance-65c895e83fdf|
https://medium.com/mlearning-ai/why-k-fold-cross-validation-is-failing-in-finance-65c895e83fdf]

[https://blog.quantinsti.com/cross-validation-embargo-purging-combinatorial/|https://blog.quantinsti.com/cross-validation-embargo-purging-combinatorial/]

The Combinatorial Purged Cross Validation mentioned there (it is a little better explained here: [https://towardsai.net/p/l/the-combinatorial-purged-cross-validation-method|https://towardsai.net/p/l/the-combinatorial-purged-cross-validation-method]) helps creating more walk-forward paths that are purely out-of-sample for increased statistical significance. This was proposed by Marcos Lopez de Prado in the “Advances in financial machine learning”.

Would be great to have this out-of-the box or being able to pass the cross validation folds / index with gaps.

So I have an application running Ruby 2.7.6 and Rails 6.1. Also using rom and from-HTTP for API calls. We have suddenly started to see our URLs in the browser, as well as server-side API request parameters, get overwritten with one of the symbols we use to represent an ID in the code:

[Ruby on Rails Course|https://www.igmguru.com/digital-marketing-programming/ruby-on-rails-certification-training/],

[Ruby on Rails Training|https://www.igmguru.com/digital-marketing-programming/ruby-on-rails-certification-training/]

We need an interface, similar to the grid API, for doing BO in H2O.

This task is composed of

• #15834
• #15835
• #15836

I have a tree-like structure of the Web Content Accessibility Guidelines (WCAG) with my model wcag_elements. I have no idea whether there's any benefit from that. I already looked into friendly_id gem, but this feels over-engineered for my specific use case:

[Ruby on Rails Course|https://www.igmguru.com/digital-marketing-programming/ruby-on-rails-certification-training/]

The following example shows that if you try to import a {{.csv.gz}} file created by {{data.table}} , {{h2o}} does not import the full file, whereas it will if you do the {{gzip}} as a separate step. I’m guessing there’s a difference in the header which messes up the import logic. Also reproduced this issue on a linux machine.

{code:r}library(data.table)
library(h2o)

sessionInfo()
R version 4.2.2 (2022-10-31 ucrt)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 10 x64 (build 22621)

Matrix products: default

locale:
[1] LC_COLLATE=English_United States.utf8 LC_CTYPE=English_United States.utf8 LC_MONETARY=English_United States.utf8
[4] LC_NUMERIC=C LC_TIME=English_United States.utf8

attached base packages:
[1] stats graphics grDevices utils datasets methods base

other attached packages:
[1] h2o_3.38.0.1 data.table_1.14.6

loaded via a namespace (and not attached):
[1] Rcpp_1.0.9 compiler_4.2.2 later_1.3.0 urlchecker_1.0.1 bitops_1.0-7 prettyunits_1.1.1 profvis_0.3.7
[8] remotes_2.4.2 tools_4.2.2 digest_0.6.30 pkgbuild_1.4.0 pkgload_1.3.2 jsonlite_1.8.4 memoise_2.0.1
[15] lifecycle_1.0.3 rlang_1.0.6 shiny_1.7.3 cli_3.4.1 rstudioapi_0.14 fastmap_1.1.0 stringr_1.5.0
[22] fs_1.5.2 htmlwidgets_1.5.4 devtools_2.4.5 glue_1.6.2 R6_2.5.1 processx_3.8.0 sessioninfo_1.2.2
[29] callr_3.7.3 purrr_0.3.5 magrittr_2.0.3 ps_1.7.2 promises_1.2.0.1 ellipsis_0.3.2 htmltools_0.5.4
[36] usethis_2.1.6 mime_0.12 xtable_1.8-4 httpuv_1.6.6 stringi_1.7.8 miniUI_0.1.1.1 RCurl_1.98-1.9
[43] cachem_1.0.6 crayon_1.5.2

h2o.init()

set.seed(87)
dt <- data.table(a = rnorm(1e6),
b = sample(x = 0:1, size = 1e6, replace = TRUE))

write a .csv using data.table's gzip

uses zlib, I believe, due to SystemRequirements in DESCRIPTION

fwrite(x = dt, file = "fake_data1.csv.gz")

same as

fwrite(x = dt, file = "fake_data1.csv", compress = "gzip")

export a normal .csv, then use builtin gzip

fwrite(x = dt, file = "fake_data2.csv")
system2(command = "gzip", args = "fake_data2.csv")

no "error" but only imports ~6k rows

h2oframe <- h2o.importFile(normalizePath("~/fake_data1.csv.gz"))
nrow(h2oframe)

[1] 6197

imports full file correctly

h2oframe <- h2o.importFile(normalizePath("~/fake_data2.csv.gz"))
nrow(h2oframe)

[1] 1000000{code}

Currently GBM monotone constraints exist for gaussian, bernoulli and tweedie (for power strictly between 1 and 2) families only. Extending this functionality to include Poisson and Gamma will be useful in financial services applications where regulation and/or client expectation dictates monotonic behaviour in response to certain factors

Previously raised by another user on h2ostream: [Poisson/Gamma GBM with monotonicity|https://groups.google.com/g/h2ostream/c/BEwC2iVZvgY?pli=1]

When running a RGS, we may want to privilege some parameters values over others.
This can be “partly done” today by duplicating a parameter value for example, but the result is not 100% as expected:

• when trying to generate new random hyper-parameters, duplicates from previous parameters permutations are checked based on index, not on value, therefore if we use the hyper-param {{param_dummy = ['A', 'A', 'B']}} then we effectively double the probability to use value {{'A'}} but as {{'A'}} (idx 0 ) is different from {{'A'}} (idx 1) then the walker considers that we have 2 different parameters and then {{GridSearch}} may try to train 2 models with exactly the same hyper-parameters.
• to avoid training duplicates (and also to resume an existing grid), {{GridSearch}} first tries to find an existing model by {{checksum}} . However, even when found this way, the model is added to the grid and counted as an additional model (also impacting the {{max_models}} behaviour).

To avoid the issues above, I suggest to offer the possibility to provide explicit weights to some parameters through a {{meta}} parameter:

{code:none}param_dummy = ['A', 'B']
param_dummy$weights = [2, 1]{code}

the walkers supporting weights (currently only {{RandomDiscreteValueWalker}}) will then be able to extract those meta-params, validate them (ensure ints, same size as corresponding param…), and use them to tweak the random hyper-param selector.

h4. Benefits of this syntax (meta-param) over additional method parameter:

• doesn’t require any API change.
• hyper-params are always passed as strings so we can use the {{$}} separator without risk of conflict.
• weights can be easily declared right below the corresponding param on any client (including when creating a Java HashMap) for clarity/visibility.
• can also be extracted easily from sub-groups (hyper-parameters support parameters grouping for related params).

h4. Drawbacks of this syntax:

• mixes up {{true}} param with {{meta}} params.

See related issue.

H2O XGBoost needs CUDA capability 3.5 or higher. I noticed that H2O will crash if it is run on card that doesn’t support the minimal version:

{noformat}[10:10:55] WARNING: /dot/src/gbm/gbtree.cc:73: DANGER AHEAD: You have manually specified updater parameter. The tree_method parameter will be ignored. Incorrect sequence of updaters will produce undefined behavior. For common uses, we recommend usingtree_method parameter instead.
[10:10:55] WARNING: /dot/src/tree/../common/device_helpers.cuh:178: CUDA Capability Major/Minor version number: 3.0 is insufficient. Need >=3.5 for device: 0
terminate called after throwing an instance of 'thrust::system::system_error'
what(): parallel_for failed: no kernel image is available for execution on the device

Process finished with exit code 134 (interrupted by signal 6: SIGABRT){noformat}

This happens with default settings - the GPU is autodetected and prefered to CPU, however, at actual training time (first actual iteration) the training crashes and takes down the whole JVM.

The real life impact of this issue is small because it affects cards release 10+ years ago. The solution is to manually specify CPU backend for XGBoost training (this might not be easy to do in all cases, eg. in AutoML).

Other option is to specify environment variable {{CUDA_VISIBLE_DEVICES}} to make the GPU invisible to CUDA and to H2O.

{noformat}CUDA_VISIBLE_DEVICES=-1{noformat}

Perhaps this could be in H2O documentation?

Document that max_runtime_secs cannot produce reproducible model all the time for GBM, DRF, XGBoost, Isolation Forest, and Uplift DRF.