Graph与Graph Learner的区别及功能边界技术问询

Great question! You're right that GraphLearner acts as a wrapper to make your pipeline compatible with mlr3's core Learner interface (enabling row selection, scoring, integration with resampling, etc.). But there are several key operations that only a raw Graph can handle—here are the most common ones:

1. Dynamic Pipeline Structure Modifications #

A Graph lets you directly modify its structure after creation: adding/removing operators, reordering nodes, or adjusting connections. Once you wrap a Graph into a GraphLearner, you can't alter the underlying pipeline structure directly (you'd have to rebuild the GraphLearner from a modified Graph).

Example:

# Original Graph from your code
gr = po(lrn("classif.kknn", predict_type = "prob"), param_vals = list(k = 10, distance=2, kernel='rectangular' )) %>% po("threshold", param_vals = list(thresholds = 0.6))

# Graph: Add a new preprocessing operator (e.g., scaling) directly
gr_with_scaling = gr %>>% po("scale")
gr_with_scaling$plot()  # Visualize the updated pipeline

# GraphLearner: Cannot modify internal structure directly—you have to rebuild
# This won't work: glrn$graph %>>% po("scale")
glrn_with_scaling = GraphLearner$new(gr_with_scaling)

2. Execute Individual Pipeline Nodes #

You can run specific nodes in a Graph independently (e.g., test a single preprocessing step or model training without running the entire pipeline). GraphLearner only supports full pipeline execution via $train() and $predict().

Example:

task_subset = task$clone()$filter(1:300)

# Graph: Train just the kknn node and inspect its output
kknn_output = gr$train_single("classif.kknn", inputs = list(task = task_subset))
print(kknn_output$model)  # View the trained kknn model directly

# GraphLearner: No equivalent method for single-node execution
# glrn$train_single("classif.kknn", ...)  # Throws an error

3. Handle Non-Task Inputs/Outputs #

Graph is flexible enough to work with non-Task objects (e.g., raw data frames, trained models). GraphLearner strictly adheres to the Learner interface, which requires Task inputs and produces Prediction outputs exclusively.

Example:

# Train a standalone kknn model
standalone_model = lrn("classif.kknn")$train(task_subset)

# Graph: Pass a pre-trained model directly to the threshold node
threshold_only_graph = po("threshold", param_vals = list(thresholds = 0.6))
thresholded_preds = threshold_only_graph$predict_single(
  "threshold",
  inputs = list(model = standalone_model, task = task_subset)
)

# GraphLearner: Cannot accept raw model objects—must start with a Task
# glrn$predict(model = standalone_model)  # Violates Learner interface

4. Direct Node Parameter Adjustments #

While both let you tweak parameters, Graph lets you modify individual node parameters directly via its node list. GraphLearner requires using a more indirect syntax (prefixing parameters with node IDs) since it exposes a unified parameter set for the entire pipeline.

Example:

# Graph: Modify kknn's k parameter directly on the node
gr$nodes$classif.kknn$param_set$values$k = 15

# GraphLearner: Must use the prefixed parameter name
glrn$param_set$values$classif.kknn.k = 15

Summary #

To put it simply:

• Use Graph when you need to build, test, or modify your pipeline's structure, debug individual nodes, or work with non-standard inputs.
• Use GraphLearner when you want to integrate your pipeline with mlr3's ecosystem (resampling, benchmarking, hyperparameter tuning) and use Learner-specific features like row selection.

内容的提问来源于stack exchange，提问作者ds_col