c++ - 如何在 Matlab 中训练模型，将其保存到磁盘，并加载到 C++ 程序中？

Question

我使用的是 libsvm 3.16 版。我在 Matlab 中进行了一些培训，并创建了一个模型。现在我想将这个模型保存到磁盘并在我的 C++ 程序中加载这个模型。到目前为止，我已经找到了以下替代方案:

1. 这个答案解释了 how to save a model来自 C++，基于 this网站。不完全是我需要的，但可以进行调整。 (这需要开发时间)。
2. 我可以在 Matlab 中找到最好的训练参数(内核、C)，然后用 C++ 重新训练所有内容。 (每次更改参数时都需要用 C++ 进行训练。它不可扩展)。

因此，这两个选项都不令人满意，

有没有人有想法？

Answer 1

我的解决方案是用 C++ 重新训练，因为我找不到直接保存模型的好方法。这是我的代码。您需要对其进行调整并稍微清理一下。最大的改变是你必须让它不像我那样硬编码 svm_parameter 值。您还必须将 FilePath 替换为 std::string。我在 SO 中复制、粘贴和进行小的编辑，因此格式不会完美:

这样使用:

    auto targetsPath = FilePath("targets.txt");
    auto observationsPath = FilePath("observations.txt");

    auto targetsMat = MatlabMatrixFileReader::Read(targetsPath, ',');
    auto observationsMat = MatlabMatrixFileReader::Read(observationsPath, ',');
    auto v = MiscVector::ConvertVecOfVecToVec(targetsMat);
    auto model = SupportVectorRegressionModel{ observationsMat, v };

    std::vector<double> observation{ { // 32 feature observation
        0.883575729725847,0.919446119013878,0.95359403450317,
        0.968233630936732,0.91891307107125,0.887897763183844,
        0.937588566544751,0.920582702918882,0.888864454119387,
        0.890066735260163,0.87911085669864,0.903745573664995,
        0.861069296586979,0.838606194934074,0.856376230548304,
        0.863011311537075,0.807688936997926,0.740434984165146,
        0.738498042748759,0.736410940165691,0.697228384912424,
        0.608527698289016,0.632994967880269,0.66935784966765,
        0.647761430696238,0.745961037635717,0.560761134660957,
        0.545498063585615,0.590854855113663,0.486827902942118,
        0.187128866890822,- 0.0746523069562551
    } };

    double prediction = model.Predict(observation);

miscvector.h

    static vector<double> ConvertVecOfVecToVec(const vector<vector<double>> &mat)
    {
        vector<double> targetsVec;
        targetsVec.reserve(mat.size());
        for (size_t i = 0; i < mat.size(); i++)
        {
            targetsVec.push_back(mat[i][0]);
        }
        return targetsVec;
    }

libsvmtargetobjectconvertor.h

#pragma once

#include "machinelearning.h"

struct svm_node;

class LibSvmTargetObservationConvertor
{
public:
    svm_node ** LibSvmTargetObservationConvertor::ConvertObservations(const vector<MlObservation> &observations, size_t numFeatures) const
{
    svm_node **svmObservations = (svm_node **)malloc(sizeof(svm_node *) * observations.size());
    for (size_t rowI = 0; rowI < observations.size(); rowI++)
    {
        svm_node *row = (svm_node *)malloc(sizeof(svm_node) * numFeatures);
        for (size_t colI = 0; colI < numFeatures; colI++)
        {
            row[colI].index = colI;
            row[colI].value = observations[rowI][colI];
        }
        row[numFeatures].index = -1; // apparently needed
        svmObservations[rowI] = row;
    }
    return svmObservations;
}

svm_node* LibSvmTargetObservationConvertor::ConvertMatToSvmNode(const MlObservation &observation) const
{
    size_t numFeatures = observation.size();
    svm_node *obsNode = (svm_node *)malloc(sizeof(svm_node) * numFeatures);
    for (size_t rowI = 0; rowI < numFeatures; rowI++)
    {
        obsNode[rowI].index = rowI;
        obsNode[rowI].value = observation[rowI];
    }
    obsNode[numFeatures].index = -1; // apparently needed
    return obsNode;
}
};

机器学习.h

#pragma once

#include <vector>
using std::vector;

using MlObservation = vector<double>;
using MlTarget = double;

//machinelearningmodel.h
#pragma once

#include <vector>
#include "machinelearning.h"
class MachineLearningModel
{
public:
    virtual ~MachineLearningModel() {}
    virtual double Predict(const MlObservation &observation) const = 0;
};

matlabmatrixfilereader.h

#pragma once

#include <vector>
using std::vector;

class FilePath;
// Matrix created with command:
// dlmwrite('my_matrix.txt', somematrix, 'delimiter', ',', 'precision', 15);
// In these files, each row is a matrix row. Commas separate elements on a row.
// There is no space at the end of a row. There is a blank line at the bottom of the file.
// File format:
// 0.4,0.7,0.8
// 0.9,0.3,0.5
// etc.
static class MatlabMatrixFileReader
{
public:
    static vector<vector<double>> Read(const FilePath &asciiFilePath, char delimiter)
{

    vector<vector<double>> values;
    vector<double> valueline;
    std::ifstream fin(asciiFilePath.Path());
    string item, line;
    while (getline(fin, line))
    {
        std::istringstream in(line);

        while (getline(in, item, delimiter))
        {
            valueline.push_back(atof(item.c_str()));
        }           
        values.push_back(valueline);
        valueline.clear();
    }
    fin.close();
    return values;
}

};

supportvectorregressionmodel.h

#pragma once

#include <vector>
using std::vector;
#include "machinelearningmodel.h"

#include "svm.h" // libsvm

class FilePath;

class SupportVectorRegressionModel : public MachineLearningModel
{
public:
    SupportVectorRegressionModel::~SupportVectorRegressionModel()
{
    svm_free_model_content(model_);
    svm_destroy_param(&param_);
    svm_free_and_destroy_model(&model_);
}

SupportVectorRegressionModel::SupportVectorRegressionModel(const vector<MlObservation>& observations, const vector<MlTarget>& targets)
{
    // assumes all observations have same number of features
    size_t numFeatures = observations[0].size();

    //setup targets
    //auto v = ConvertVecOfVecToVec(targetsMat);
    double *targetsPtr = const_cast<double *>(&targets[0]); // why aren't the targets const?

    LibSvmTargetObservationConvertor conv;
    svm_node **observationsPtr = conv.ConvertObservations(observations, numFeatures);

    // setup observations
    //svm_node **observations = BuildObservations(observationsMat, numFeatures);

    // setup problem
    svm_problem problem;
    problem.l = targets.size();
    problem.y = targetsPtr;
    problem.x = observationsPtr;

    // specific to out training sets
    // TODO:    This is hard coded. 
    //          Bust out these values for use in constructor
    param_.C = 0.4;                 // cost
    param_.svm_type = 4;            // SVR
    param_.kernel_type = 2;         // radial
    param_.nu = 0.6;                // SVR nu
                                    // These values are the defaults used in the Matlab version
                                    // as found in svm_model_matlab.c
    param_.gamma = 1.0 / (double)numFeatures;
    param_.coef0 = 0;
    param_.cache_size = 100;        // in MB
    param_.shrinking = 1;
    param_.probability = 0;
    param_.degree = 3;
    param_.eps = 1e-3;
    param_.p = 0.1;
    param_.shrinking = 1;
    param_.probability = 0;
    param_.nr_weight = 0;
    param_.weight_label = NULL;
    param_.weight = NULL;

    // suppress command line output
    svm_set_print_string_function([](auto c) {});

    model_ = svm_train(&problem, &param_);
}

double SupportVectorRegressionModel::Predict(const vector<double>& observation) const
{
    LibSvmTargetObservationConvertor conv;
    svm_node *obsNode = conv.ConvertMatToSvmNode(observation);
    double prediction = svm_predict(model_, obsNode);
    return prediction;
}

SupportVectorRegressionModel::SupportVectorRegressionModel(const FilePath & modelFile)
{
    model_ = svm_load_model(modelFile.Path().c_str());
}
private:
    svm_model *model_;
    svm_parameter param_;
};