Introduction

In H2O, you cannot take two already trained random forest models and physically combine their trees into one new random forest object. If your goal is to get a larger forest, the supported options are to retrain a bigger model, continue training from a checkpoint when applicable, or combine model predictions at a higher level.

Why Direct Tree Merging Is Not a Supported Operation

A trained H2O random forest is not exposed as a simple editable list of trees. The model also contains training metadata, sampling decisions, scoring history, and internal state tied to the original training run.

That means the following idea is not supported as an API workflow:

1. train model A with 100 trees
2. train model B with 100 trees
3. append B's trees into A and save a 200-tree combined model

Even if both models were trained on the same columns with the same parameters, H2O does not provide a tree-splicing interface for DRF models. In practice, you need a different strategy.

Best Option: Train One Larger Forest

If you simply want more trees, the cleanest solution is usually to train a single forest with the final ntrees value you actually want.

1library(h2o)
2h2o.init()
3
4train <- h2o.importFile("train.csv")
5y <- "target"
6x <- setdiff(colnames(train), y)
7
8rf_big <- h2o.randomForest(
9  x = x,
10  y = y,
11  training_frame = train,
12  ntrees = 200,
13  max_depth = 20,
14  sample_rate = 0.8,
15  seed = 42
16)
17
18print(rf_big)

This gives you one coherent deployment artifact, one scoring history, and one model object that H2O fully understands.

Continue Training with a Checkpoint

If you already have one H2O random forest and want to add more trees to that same training lineage, check whether checkpointing fits your workflow. In H2O, some algorithms support a checkpoint parameter that resumes training from an existing model rather than starting over.

1library(h2o)
2h2o.init()
3
4train <- h2o.importFile("train.csv")
5y <- "target"
6x <- setdiff(colnames(train), y)
7
8rf_100 <- h2o.randomForest(
9  x = x,
10  y = y,
11  training_frame = train,
12  ntrees = 100,
13  seed = 42,
14  model_id = "rf_100"
15)
16
17rf_200 <- h2o.randomForest(
18  x = x,
19  y = y,
20  training_frame = train,
21  ntrees = 200,
22  seed = 42,
23  checkpoint = "rf_100"
24)
25
26print(rf_200)

Conceptually, this is not the same as merging two arbitrary forests. It is extending one model run so that the later model contains more trees than the earlier checkpoint.

Reuse Existing Models by Blending Predictions

If the two forests are already trained and you do not want to retrain, combine them at prediction time instead of trying to merge their internals.

For regression, average the predictions:

1rf_a <- h2o.loadModel("/models/rf_a")
2rf_b <- h2o.loadModel("/models/rf_b")
3new_data <- h2o.importFile("scoring.csv")
4
5pred_a <- h2o.predict(rf_a, new_data)
6pred_b <- h2o.predict(rf_b, new_data)
7
8blended <- (pred_a + pred_b) / 2
9head(blended)

For classification, average class probabilities rather than final labels:

1pred_a <- h2o.predict(rf_a, new_data)
2pred_b <- h2o.predict(rf_b, new_data)
3
4avg_p1 <- (pred_a$p1 + pred_b$p1) / 2
5predicted_class <- ifelse(avg_p1 > 0.5, "yes", "no")
6head(predicted_class)

Averaging probabilities preserves more information than voting on already-decided class labels.

Use a Stacked Ensemble When You Want a Supported Combination

If you want H2O itself to combine multiple base models, a stacked ensemble is usually the most natural supported tool.

1library(h2o)
2h2o.init()
3
4train <- h2o.importFile("train.csv")
5y <- "target"
6x <- setdiff(colnames(train), y)
7
8rf1 <- h2o.randomForest(x = x, y = y, training_frame = train, ntrees = 100, seed = 1)
9rf2 <- h2o.randomForest(x = x, y = y, training_frame = train, ntrees = 100, max_depth = 25, seed = 2)
10
11ensemble <- h2o.stackedEnsemble(
12  x = x,
13  y = y,
14  training_frame = train,
15  base_models = list(rf1, rf2)
16)
17
18print(ensemble)

This is not a single merged forest internally, but it is a supported way to combine model signal inside the H2O ecosystem.

Choosing Between the Options

Use a larger retrained forest when you want one simple model artifact and a workflow that is easy to explain and deploy.

Use checkpointing when you want to continue growing one existing forest rather than starting over.

Use blending or stacking when you already have trained models and want to reuse them without retraining from scratch.

Before combining anything, make sure the models share the same feature definitions and compatible preprocessing. If the input schema differs, the combined result is not meaningful.

Common Pitfalls

A common mistake is assuming a random forest is just a bag of independent trees that can be concatenated after training. H2O does not expose DRF models that way.

Another issue is averaging classification labels instead of class probabilities. That throws away confidence information and can distort the final decision.

Developers also sometimes miss the distinction between checkpointing and merging. Checkpointing extends one training line; it does not stitch together two unrelated trained models.

Finally, always compare strategies on the same holdout set. A more complex combination method is only useful if it improves real evaluation metrics.

Summary

• H2O does not support direct tree-level merging of two trained random forest models.
• Training one larger forest is the simplest supported solution.
• Checkpointing can extend one existing forest with more trees.
• Existing models can be combined by averaging predictions or with stacked ensembles.
• Keep features and preprocessing aligned before combining model outputs.