Python 我们能否提供一个自定义指标，用于在H2O中与GLM进行交叉验证？

我试图使用

h2o.glm

通过交叉验证找到最佳惩罚

lambda

。这是一个多项式模型

然而，我看到它是根据多项式偏差进行优化的。我是否可以对其他指标（如误分类错误）进行交叉验证

---

文档中提到了参数

custom\u metric\u func

，但我不清楚它的描述。该指标是否用作交叉验证分数？如果是，文档还声明它仅在

Python

API中可用。这真的是真的吗？

如果你正在研究h2o，那么不离开h2o的R界面的合适选项是使用选项

保持交叉验证模型=真，保持交叉验证预测=真，

。根据这一点，您可以在每个模型上构建每个类别的错误分类错误，该模型配备了lambda的特定值序列。或者，您可以循环或重叠一系列lambda。例如，

对于（lambda_向量中的i）{models[[i]]=h2o.glm（…，lambda=i）}

。每个对象都有一个混淆矩阵，因此您可以自行计算每个类别的分类错误。你可以制定自己的选择标准。自定义度量仅在python中有效

如果您可以仅使用R：

---

为了使多项式模型具有弹性惩罚，如果没有特别的理由将其与h2o绑定，我建议使用提供命令cv.glmnet（）的包，该命令带有选项family=“多项式”和type.measure=“class”。这将产生通过分类误差交叉验证选择的多项式模型

如果您确实在处理h2o，那么不离开h2o的R接口的合适选项是使用选项

保持交叉验证模型=真，保持交叉验证预测=真，

。根据这一点，您可以在每个模型上构建每个类别的错误分类错误，该模型配备了lambda的特定值序列。或者，您可以循环或重叠一系列lambda。例如，

对于（lambda_向量中的i）{models[[i]]=h2o.glm（…，lambda=i）}

。每个对象都有一个混淆矩阵，因此您可以自行计算每个类别的分类错误。你可以制定自己的选择标准。自定义度量仅在python中有效

如果您可以仅使用R：

---

为了使多项式模型具有弹性惩罚，如果没有特别的理由将其与h2o绑定，我建议使用提供命令cv.glmnet（）的包，该命令带有选项family=“多项式”和type.measure=“class”。这将产生通过分类误差交叉验证选择的多项式模型

我编写了

h2o.glm_custom

，作为保留交叉验证模型的

h2o.glm

的“替代品”，这样就可以使用@Diegolog建议的自定义选择标准。我的方法使用

h2o.grid

。我试图包含

h2o.glm

的所有参数，但简化了一些默认值以避免额外的工作

h2o.glm_custom <- function(x,
                           y,
                           training_frame,
                           model_id = NULL,
                           validation_frame = NULL,
                           nfolds = 0,
                           seed = -1,
                           keep_cross_validation_models = TRUE,
                           keep_cross_validation_predictions = FALSE,
                           keep_cross_validation_fold_assignment = FALSE,
                           fold_assignment = "AUTO",
                           fold_column = NULL,
                           random_columns = NULL,
                           ignore_const_cols = TRUE,
                           score_each_iteration = FALSE,
                           offset_column = NULL,
                           weights_column = NULL,
                           family = "binomial",
                           rand_family = c("[gaussian]"),
                           tweedie_variance_power = 0,
                           tweedie_link_power = 1,
                           theta = 1e-10,
                           solver = "AUTO",
                           alpha = 0,
                           early_stopping = TRUE,
                           nlambdas = 100,
                           standardize = TRUE,
                           missing_values_handling = "MeanImputation",
                           plug_values = NULL,
                           compute_p_values = FALSE,
                           remove_collinear_columns = FALSE,
                           intercept = TRUE,
                           non_negative = FALSE,
                           max_iterations = -1,
                           objective_epsilon = -1,
                           beta_epsilon = 1e-04,
                           gradient_epsilon = -1,
                           link = "family_default",
                           rand_link = "[identity]",
                           startval = NULL,
                           calc_like = FALSE,
                           HGLM = FALSE,
                           prior = -1,
                           lambda_min_ratio = 0.01,
                           beta_constraints = NULL,
                           max_active_predictors = -1,
                           obj_reg = -1,
                           export_checkpoints_dir = NULL,
                           balance_classes = FALSE,
                           class_sampling_factors = NULL,
                           max_after_balance_size = 5,
                           max_hit_ratio_k = 0,
                           max_runtime_secs = 0,
                           custom_metric_func = NULL) {

  # Find lambda_max
  model <- h2o.glm(x,
                   y,
                   training_frame,
                   model_id,
                   validation_frame,
                   nfolds,
                   seed,
                   keep_cross_validation_models,
                   keep_cross_validation_predictions,
                   keep_cross_validation_fold_assignment,
                   fold_assignment,
                   fold_column,
                   random_columns,
                   ignore_const_cols,
                   score_each_iteration,
                   offset_column,
                   weights_column,
                   family,
                   rand_family,
                   tweedie_variance_power,
                   tweedie_link_power,
                   theta,
                   solver,
                   alpha,
                   NULL, # lambda
                   TRUE, # lambda_search
                   early_stopping,
                   1, # nlambdas
                   standardize,
                   missing_values_handling,
                   plug_values,
                   compute_p_values,
                   remove_collinear_columns,
                   intercept,
                   non_negative,
                   max_iterations,
                   objective_epsilon,
                   beta_epsilon,
                   gradient_epsilon,
                   link,
                   rand_link,
                   startval,
                   calc_like,
                   HGLM,
                   prior,
                   lambda_min_ratio,
                   beta_constraints,
                   max_active_predictors,
                   obj_reg = obj_reg,
                   export_checkpoints_dir = export_checkpoints_dir,
                   balance_classes = balance_classes,
                   class_sampling_factor = class_sampling_factors,
                   max_after_balance_size = max_after_balance_size,
                   max_hit_ratio_k = max_hit_ratio_k,
                   max_runtime_secs = max_runtime_secs,
                   custom_metric_func = custom_metric_func)

  lambda_max <- model@model$lambda_best

  # Perform grid search on lambda, with logarithmic scale
  lambda_min <- lambda_max * lambda_min_ratio
  grid <- exp(seq(log(lambda_max), log(lambda_min), length.out = nlambdas))
  grid_list <- lapply(sapply(grid, list), list)
  hyper_parameters <- list(lambda = grid_list)

  result <- h2o.grid('glm',
                     x = x,
                     y = y,
                     training_frame = training_frame,
                     nfolds = nfolds,
                     family = family,
                     alpha = alpha,
                     ignore_const_cols = ignore_const_cols,
                     hyper_params = hyper_parameters,
                     seed = seed)
}

它可以被绘制，等等

  ggplot() + geom_line(data = tbl[lambda < 0.00001], aes(x = lambda, y = error))

ggplot（）+geom_线（数据=tbl[lambda<0.00001]，aes（x=lambda，y=error））

---

我编写了

h2o.glm_custom

，作为保留交叉验证模型的

h2o.glm

的“替代品”，这样就可以使用@Diegolog建议的自定义选择标准。我的方法使用

h2o.grid

。我试图包含

h2o.glm

的所有参数，但简化了一些默认值以避免额外的工作

h2o.glm_custom <- function(x,
                           y,
                           training_frame,
                           model_id = NULL,
                           validation_frame = NULL,
                           nfolds = 0,
                           seed = -1,
                           keep_cross_validation_models = TRUE,
                           keep_cross_validation_predictions = FALSE,
                           keep_cross_validation_fold_assignment = FALSE,
                           fold_assignment = "AUTO",
                           fold_column = NULL,
                           random_columns = NULL,
                           ignore_const_cols = TRUE,
                           score_each_iteration = FALSE,
                           offset_column = NULL,
                           weights_column = NULL,
                           family = "binomial",
                           rand_family = c("[gaussian]"),
                           tweedie_variance_power = 0,
                           tweedie_link_power = 1,
                           theta = 1e-10,
                           solver = "AUTO",
                           alpha = 0,
                           early_stopping = TRUE,
                           nlambdas = 100,
                           standardize = TRUE,
                           missing_values_handling = "MeanImputation",
                           plug_values = NULL,
                           compute_p_values = FALSE,
                           remove_collinear_columns = FALSE,
                           intercept = TRUE,
                           non_negative = FALSE,
                           max_iterations = -1,
                           objective_epsilon = -1,
                           beta_epsilon = 1e-04,
                           gradient_epsilon = -1,
                           link = "family_default",
                           rand_link = "[identity]",
                           startval = NULL,
                           calc_like = FALSE,
                           HGLM = FALSE,
                           prior = -1,
                           lambda_min_ratio = 0.01,
                           beta_constraints = NULL,
                           max_active_predictors = -1,
                           obj_reg = -1,
                           export_checkpoints_dir = NULL,
                           balance_classes = FALSE,
                           class_sampling_factors = NULL,
                           max_after_balance_size = 5,
                           max_hit_ratio_k = 0,
                           max_runtime_secs = 0,
                           custom_metric_func = NULL) {

  # Find lambda_max
  model <- h2o.glm(x,
                   y,
                   training_frame,
                   model_id,
                   validation_frame,
                   nfolds,
                   seed,
                   keep_cross_validation_models,
                   keep_cross_validation_predictions,
                   keep_cross_validation_fold_assignment,
                   fold_assignment,
                   fold_column,
                   random_columns,
                   ignore_const_cols,
                   score_each_iteration,
                   offset_column,
                   weights_column,
                   family,
                   rand_family,
                   tweedie_variance_power,
                   tweedie_link_power,
                   theta,
                   solver,
                   alpha,
                   NULL, # lambda
                   TRUE, # lambda_search
                   early_stopping,
                   1, # nlambdas
                   standardize,
                   missing_values_handling,
                   plug_values,
                   compute_p_values,
                   remove_collinear_columns,
                   intercept,
                   non_negative,
                   max_iterations,
                   objective_epsilon,
                   beta_epsilon,
                   gradient_epsilon,
                   link,
                   rand_link,
                   startval,
                   calc_like,
                   HGLM,
                   prior,
                   lambda_min_ratio,
                   beta_constraints,
                   max_active_predictors,
                   obj_reg = obj_reg,
                   export_checkpoints_dir = export_checkpoints_dir,
                   balance_classes = balance_classes,
                   class_sampling_factor = class_sampling_factors,
                   max_after_balance_size = max_after_balance_size,
                   max_hit_ratio_k = max_hit_ratio_k,
                   max_runtime_secs = max_runtime_secs,
                   custom_metric_func = custom_metric_func)

  lambda_max <- model@model$lambda_best

  # Perform grid search on lambda, with logarithmic scale
  lambda_min <- lambda_max * lambda_min_ratio
  grid <- exp(seq(log(lambda_max), log(lambda_min), length.out = nlambdas))
  grid_list <- lapply(sapply(grid, list), list)
  hyper_parameters <- list(lambda = grid_list)

  result <- h2o.grid('glm',
                     x = x,
                     y = y,
                     training_frame = training_frame,
                     nfolds = nfolds,
                     family = family,
                     alpha = alpha,
                     ignore_const_cols = ignore_const_cols,
                     hyper_params = hyper_parameters,
                     seed = seed)
}

它可以被绘制，等等

  ggplot() + geom_line(data = tbl[lambda < 0.00001], aes(x = lambda, y = error))

ggplot（）+geom_线（数据=tbl[lambda<0.00001]，aes（x=lambda，y=error））

---

这些都是有助于克服R API局限性的建议。但是，我想确认一下：您是说在Python API中，

custom\u metric\u func

将以我希望的方式进行交叉验证吗？文档中不清楚此选项的具体用途。是的，我需要使用R，因为它的文档生成能力。另一种可能的解决方法是使用

networkite

从R调用Python API。是的，我已经使用了

glmnet

，但是H2O对于功能重要性有额外的统计信息，而

glmnet

是缺乏的，我不确定他们的公式是什么。免责声明我没有在R中尝试过这一点。您可以在script.py中编写一个自定义度量：

mymetric

，并将其上传到集群，如中所示，然后指定选项

custom\u metric\u function=mymetric

。这一点肯定适用于。您可以在R中测试它。由于该函数在集群中，我想您应该可以在R中访问它。但这只是一个猜测。我无法理解您提供的链接中的自定义度量代码。例如，他们对

map

、

reduce

和

metric

的描述根本不清楚。所以我实现了我自己的lambda循环，类似于您所描述的，但是使用

h2o.grid

在labmda上进行网格搜索。我将在另一个答案中发布这篇文章。很好，我很高兴你找到了答案。谢谢，但最好是找到如何使用他们的

自定义度量函数

。这些都是解决R API局限性的有用建议。但是，我想确认一下：您是说在Python API中，

custom\u metric\u func

将以我希望的方式进行交叉验证吗？文档中不清楚此选项的具体用途。是的，我需要使用R，因为它的文档生成能力。另一种可能的解决方法是使用

networkite

从R调用Python API。是的，我已经使用了

glmnet

，但是H2O有额外的统计数据

  ggplot() + geom_line(data = tbl[lambda < 0.00001], aes(x = lambda, y = error))