Introduction

A partykit::mob() object contains a fitted model for each terminal node, and comparing those node-specific models is often easier in table form than by staring at the printed tree. The main job is to extract the fitted model object from each terminal node, turn its coefficients into a tidy structure, and then reshape that structure into a side-by-side table.

What a mob() Tree Stores

Model-based recursive partitioning fits a separate model in each terminal node. That means the tree is not only a set of splits. It also contains node-level model objects.

In practice, the workflow is:

1. identify terminal node IDs
2. extract each node's fitted model
3. obtain the coefficients or summary you want
4. bind the results into a table

The extraction step is the part most users need help with.

Assume You Already Have a mob Object

To keep the example focused, assume you already fitted a tree and stored it in tree.

1library(partykit)
2
3# Assume this already exists.
4# tree <- mob(...)

Now get the terminal node IDs:

terminal_ids <- nodeids(tree, terminal = TRUE)
print(terminal_ids)

This gives the node numbers you will use for extraction.

Extract the Fitted Model from Each Terminal Node

nodeapply() is the most useful helper here.

1models <- nodeapply(
2  tree,
3  ids = terminal_ids,
4  FUN = function(node) info_node(node)$object
5)

Each element of models is the fitted model for one terminal node. If the mob() tree used linear models, coef() will usually give the node-specific coefficients directly.

Build a Long Table First

A long table is easier to build and debug before reshaping wide.

1coef_table <- do.call(
2  rbind,
3  lapply(names(models), function(id) {
4    coefs <- coef(models[[id]])
5    data.frame(
6      node = as.integer(id),
7      term = names(coefs),
8      estimate = unname(coefs),
9      row.names = NULL
10    )
11  })
12)
13
14print(coef_table)

This produces a tidy table with one row per node-term pair.

Example structure:

1  node        term  estimate
21    3 (Intercept)   12.4000
32    3        x1      0.8200
43    4 (Intercept)   15.1000
54    4        x1      1.7300

That is already useful, but the question asks for side-by-side node models.

Reshape into a Side-by-Side Table

To place each node in its own column, reshape by term.

Using base R:

1wide_table <- reshape(
2  coef_table,
3  idvar = "term",
4  timevar = "node",
5  direction = "wide"
6)
7
8print(wide_table)

The result will look something like:

         term estimate.3 estimate.4
1 (Intercept)      12.40      15.10
2          x1       0.82       1.73

This is the side-by-side comparison most people want for reporting or review.

Use tidyr If You Prefer a Clearer Reshape API

If you are already using tidyverse tooling, pivot_wider() is often easier to read.

1library(tidyr)
2
3wide_table <- pivot_wider(
4  coef_table,
5  names_from = node,
6  values_from = estimate,
7  names_prefix = "node_"
8)
9
10print(wide_table)

This gives a similar wide table with columns such as node_3, node_4, and so on.

Include More Than Coefficients If Needed

Sometimes coefficients are not enough. You may also want:

• residual standard error
• number of observations in the node
• p-values
• fitted formula details

In that case, extract a richer summary per node.

1summary_table <- do.call(
2  rbind,
3  lapply(names(models), function(id) {
4    data.frame(
5      node = as.integer(id),
6      nobs = nobs(models[[id]]),
7      stringsAsFactors = FALSE
8    )
9  })
10)
11
12print(summary_table)

The same long-then-wide pattern still applies.

Export the Table for Reporting

Once the wide table exists, you can send it to Markdown, HTML, or CSV output.

write.csv(wide_table, "node_models.csv", row.names = FALSE)

Or, if you want a report-friendly table in an R Markdown workflow, pass it to knitr::kable().

knitr::kable(wide_table)

That is often the easiest way to place the side-by-side node models into documentation.

Common Pitfalls

• Trying to build a wide table first instead of extracting a tidy long structure and reshaping later.
• Forgetting to restrict extraction to terminal nodes when that is where the fitted node models live.
• Assuming every mob() node model exposes identical coefficients without checking for model differences.
• Using printed tree output as if it were already a table-ready data structure.
• Mixing coefficient extraction with presentation logic before verifying that the raw node model objects were extracted correctly.

Summary

• A mob() object stores fitted model objects in its terminal nodes.
• Use nodeids() and nodeapply() to extract those node-specific models.
• Build a long coefficient table first, then reshape it into a side-by-side wide table.
• 'coef() is often enough for coefficient comparison, but you can extract richer summaries if needed.'
• Reporting becomes much easier once the node models are converted into an ordinary data frame.