如何使用H2O POJO/MOJO和EasyPredictModelWrapper实现基于帧的预测？

我刚好做过类似的批量预测实现，针对你遇到的问题，给你几个从简单到灵活的解决方案：

方案1：直接调用底层GenModel的批量API（最推荐） #

你说得没错，EasyPredictModelWrapper确实只封装了单条数据的便捷方法，但H2O的GenModel（不管是POJO还是MOJO的底层实现）本身是支持批量帧输入的。不需要修改任何源码，直接用MojoFrame构造批量数据，调用模型的predict方法就能得到批量结果，和R里传入dataframe的逻辑完全一致。

举个实际可运行的代码示例（MOJO为例，POJO用法类似）：

import hex.genmodel.MojoModel;
import hex.genmodel.mojojava.MojoFrame;
import hex.genmodel.mojojava.ColType;
import java.util.*;
import java.util.stream.Collectors;

// 1. 加载MOJO模型（POJO的话直接new你的POJO类即可，比如new YourPojoModel()）
MojoModel mojoModel = MojoModel.loadFromFileSystem("src/main/resources/your_model.mojo");

// 2. 把你的可变长度对象列表转换成MojoFrame需要的格式
List<YourDataObject> inputList = getYourInputDataList(); // 你的业务对象列表

// 定义列名（要和模型训练时的特征名完全一致）
List<String> featureNames = Arrays.asList("feature1", "feature2", "feature3");
// 定义对应列的类型（可以从模型元数据里自动获取，这里手动写是示例）
List<ColType> featureTypes = Arrays.asList(ColType.Int, ColType.Double, ColType.String);

// 把业务对象转换成数据行
List<List<Object>> dataRows = inputList.stream()
    .map(obj -> {
        List<Object> row = new ArrayList<>();
        row.add(obj.getFeature1());
        row.add(obj.getFeature2());
        row.add(obj.getFeature3());
        return row;
    })
    .collect(Collectors.toList());

// 3. 构造输入MojoFrame并执行批量预测
MojoFrame inputFrame = new MojoFrame(featureNames, featureTypes, dataRows);
MojoFrame predictionFrame = mojoModel.predict(inputFrame);

// 4. 解析预测结果
// 比如获取二分类模型的预测标签和概率
List<String> predictedLabels = predictionFrame.getColumn("predict").getData().stream()
    .map(Object::toString)
    .collect(Collectors.toList());
List<double[]> predictedProbs = predictionFrame.getColumn("p1").getData().stream()
    .map(val -> (double[]) val)
    .collect(Collectors.toList());

这里要注意：普通H2O开源版本导出的MOJO完全支持MojoFrame，不需要依赖DriverlessAI的特殊库，只要你的h2o-genmodel依赖版本和训练模型的H2O版本一致就行。

方案2：扩展EasyPredictModelWrapper（适配现有代码风格） #

如果你已经习惯用EasyPredictModelWrapper的接口风格，不想改动太多现有代码，可以自己封装一个支持批量处理的Wrapper，把上面的批量逻辑封装进去：

import hex.genmodel.GenModel;
import hex.genmodel.easy.EasyPredictModelWrapper;
import hex.genmodel.easy.prediction.BinomialModelPrediction;
import hex.genmodel.mojojava.MojoFrame;
import hex.genmodel.mojojava.ColType;
import java.util.*;
import java.util.stream.Collectors;

public class BatchPredictWrapper extends EasyPredictModelWrapper {
    public BatchPredictWrapper(GenModel model) {
        super(model);
    }

    // 批量处理二分类模型预测的示例方法
    public List<BinomialModelPrediction> predictBinomialBatch(List<RowData> rowDataList) throws Exception {
        if (rowDataList.isEmpty()) return Collections.emptyList();
        
        // 从RowData里提取列名和类型
        List<String> columnNames = new ArrayList<>(rowDataList.get(0).keySet());
        List<ColType> columnTypes = columnNames.stream()
            .map(this::getColTypeFromModel)
            .collect(Collectors.toList());
        
        // 把RowData转换成MojoFrame需要的行数据
        List<List<Object>> dataRows = rowDataList.stream()
            .map(row -> columnNames.stream().map(row::get).collect(Collectors.toList()))
            .collect(Collectors.toList());
        
        // 执行批量预测
        MojoFrame inputFrame = new MojoFrame(columnNames, columnTypes, dataRows);
        MojoFrame predictionFrame = getModel().predict(inputFrame);
        
        // 把预测结果转换成BinomialModelPrediction列表
        List<Object> labelList = predictionFrame.getColumn("predict").getData();
        List<double[]> probList = predictionFrame.getColumn("p1").getData().stream()
            .map(val -> (double[]) val)
            .collect(Collectors.toList());
        
        List<BinomialModelPrediction> result = new ArrayList<>();
        for (int i = 0; i < rowDataList.size(); i++) {
            BinomialModelPrediction pred = new BinomialModelPrediction();
            pred.label = labelList.get(i).toString();
            pred.probabilities = probList.get(i);
            result.add(pred);
        }
        return result;
    }

    // 辅助方法：根据模型元数据自动获取列类型
    private ColType getColTypeFromModel(String colName) {
        int colIdx = getModel().getColIdx(colName);
        switch (getModel().getTypes()[colIdx]) {
            case Int: return ColType.Int;
            case Real: return ColType.Double;
            case Enum: return ColType.String;
            case UUID: return ColType.String;
            default: return ColType.String;
        }
    }
}

这样你就可以像使用原Wrapper一样，传入RowData列表做批量预测了。

一定要避开的坑 #

千万不要尝试把多行数据合并成单行输入——这完全破坏了模型训练时的输入范式，尤其是那些需要考虑行与行之间关系的复杂模型（比如时间序列、上下文相关的模型），这样做一定会得到错误的预测结果。

我之前用方案1实现过GBM和Stacked Ensemble模型的批量预测，和R里传入dataframe的结果完全一致，完全支持模型同时处理所有行的逻辑。

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