libmf 0.1.0

data/vendor/libmf/mf-predict.cpp

@@ -0,0 +1,207 @@
+#include <cstring>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <iomanip>
+#include <stdexcept>
+#include <vector>
+
+#include "mf.h"
+
+using namespace std;
+using namespace mf;
+
+struct Option
+{
+    Option() : eval(RMSE) {}
+    string test_path, model_path, output_path;
+    mf_int eval;
+};
+
+string predict_help()
+{
+    return string(
+"usage: mf-predict [options] test_file model_file [output_file]\n"
+"\n"
+"options:\n"
+"-e <eval>: specify the evaluation criterion (default 0)\n"
+"\t 0 -- root mean square error\n"
+"\t 1 -- mean absolute error\n"
+"\t 2 -- generalized KL-divergence\n"
+"\t 5 -- logarithmic error\n"
+"\t 6 -- accuracy\n"
+"\t10 -- row-wise mean percentile rank\n"
+"\t11 -- column-wise mean percentile rank\n"
+"\t12 -- row-wise area under the curve\n"
+"\t13 -- column-wise area under the curve\n");
+}
+
+Option parse_option(int argc, char **argv)
+{
+    vector<string> args;
+    for(int i = 0; i < argc; i++)
+        args.push_back(string(argv[i]));
+
+    if(argc == 1)
+        throw invalid_argument(predict_help());
+
+    Option option;
+
+    mf_int i;
+    for(i = 1; i < argc; i++)
+    {
+        if(args[i].compare("-e") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify evaluation criterion after -e");
+            i++;
+            option.eval = atoi(argv[i]);
+            if(option.eval != RMSE &&
+               option.eval != MAE &&
+               option.eval != GKL &&
+               option.eval != LOGLOSS &&
+               option.eval != ACC &&
+               option.eval != ROW_AUC &&
+               option.eval != COL_AUC &&
+               option.eval != ROW_MPR &&
+               option.eval != COL_MPR)
+                throw invalid_argument("unknown evaluation criterion");
+        }
+        else
+            break;
+    }
+    if(i >= argc-1)
+        throw invalid_argument("testing data and model file not specified");
+    option.test_path = string(args[i++]);
+    option.model_path = string(args[i++]);
+
+    if(i < argc)
+    {
+        option.output_path = string(args[i]);
+    }
+    else if(i == argc)
+    {
+        const char *ptr = strrchr(&*option.test_path.begin(), '/');
+        if(!ptr)
+            ptr = option.test_path.c_str();
+        else
+            ++ptr;
+        option.output_path = string(ptr) + ".out";
+    }
+    else
+    {
+        throw invalid_argument("invalid argument");
+    }
+
+    return option;
+}
+
+void predict(string test_path, string model_path, string output_path, mf_int eval)
+{
+    mf_problem prob = read_problem(test_path);
+
+    ofstream f_out(output_path);
+    if(!f_out.is_open())
+        throw runtime_error("cannot open " + output_path);
+
+    mf_model *model = mf_load_model(model_path.c_str());
+    if(model == nullptr)
+        throw runtime_error("cannot load model from " + model_path);
+
+    for(mf_int i = 0; i < prob.nnz; i++)
+    {
+        mf_float r = mf_predict(model, prob.R[i].u, prob.R[i].v);
+        f_out << r << endl;
+    }
+
+    switch(eval)
+    {
+        case RMSE:
+        {
+            auto rmse = calc_rmse(&prob, model);
+            cout << fixed << setprecision(4) << "RMSE = " << rmse << endl;
+            break;
+        }
+        case MAE:
+        {
+            auto mae = calc_mae(&prob, model);
+            cout << fixed << setprecision(4) << "MAE = " << mae << endl;
+            break;
+        }
+        case GKL:
+        {
+            auto gkl = calc_gkl(&prob, model);
+            cout << fixed << setprecision(4) << "GKL = " << gkl << endl;
+            break;
+        }
+        case LOGLOSS:
+        {
+            auto logloss = calc_logloss(&prob, model);
+            cout << fixed << setprecision(4) << "LOGLOSS = " << logloss << endl;
+            break;
+        }
+        case ACC:
+        {
+            auto acc = calc_accuracy(&prob, model);
+            cout << fixed << setprecision(4) << "ACCURACY = " << acc << endl;
+            break;
+        }
+        case ROW_AUC:
+        {
+            auto row_wise_auc = calc_auc(&prob, model, false);
+            cout << fixed << setprecision(4) <<  "Row-wise AUC = " << row_wise_auc << endl;
+            break;
+        }
+        case COL_AUC:
+        {
+            auto col_wise_auc = calc_auc(&prob, model, true);
+            cout << fixed << setprecision(4) <<  "Colmn-wise AUC = " << col_wise_auc << endl;
+            break;
+        }
+        case ROW_MPR:
+        {
+            auto row_wise_mpr = calc_mpr(&prob, model, false);
+            cout << fixed << setprecision(4) <<  "Row-wise MPR = " << row_wise_mpr << endl;
+            break;
+        }
+        case COL_MPR:
+        {
+            auto col_wise_mpr = calc_mpr(&prob, model, true);
+            cout << fixed << setprecision(4) <<  "Column-wise MPR = " << col_wise_mpr << endl;
+            break;
+        }
+        default:
+        {
+            throw invalid_argument("unknown evaluation criterion");
+            break;
+        }
+    }
+    mf_destroy_model(&model);
+}
+
+int main(int argc, char **argv)
+{
+    Option option;
+    try
+    {
+        option = parse_option(argc, argv);
+    }
+    catch(invalid_argument &e)
+    {
+        cout << e.what() << endl;
+        return 1;
+    }
+
+    try
+    {
+        predict(option.test_path, option.model_path, option.output_path, option.eval);
+    }
+    catch(runtime_error &e)
+    {
+        cout << e.what() << endl;
+        return 1;
+    }
+
+    return 0;
+}

data/vendor/libmf/mf-train.cpp

@@ -0,0 +1,378 @@
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstring>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "mf.h"
+
+using namespace std;
+using namespace mf;
+
+struct Option
+{
+    Option() : param(mf_get_default_param()), nr_folds(1), on_disk(false), do_cv(false) {}
+    string tr_path, va_path, model_path;
+    mf_parameter param;
+    mf_int nr_folds;
+    bool on_disk;
+    bool do_cv;
+};
+
+string train_help()
+{
+    return string(
+"usage: mf-train [options] training_set_file [model_file]\n"
+"\n"
+"options:\n"
+"-l1 <lambda>,<lambda>: set L1-regularization parameters for P and Q (default 0)\n"
+"  P and Q share the same lambda if only one lambda is specified\n"
+"-l2 <lambda>,<lambda>: set L2-regularization parameters for P and Q (default 0.1)\n"
+"  P and Q share the same lambda if only one lambda is specified\n"
+"-f <loss>: set loss function (default 0)\n"
+"  for real-valued matrix factorization\n"
+"\t 0 -- squared error (L2-norm)\n"
+"\t 1 -- absolute error (L1-norm)\n"
+"\t 2 -- generalized KL-divergence\n"
+"  for binary matrix factorization\n"
+"\t 5 -- logarithmic loss\n"
+"\t 6 -- squared hinge loss\n"
+"\t 7 -- hinge loss\n"
+"  for one-class matrix factorization\n"
+"\t10 -- row-oriented pairwise logarithmic loss\n"
+"\t11 -- column-oriented pairwise logarithmic loss\n"
+"\t12 -- squared error (L2-norm)\n"
+"-k <dimensions>: set number of dimensions (default 8)\n"
+"-t <iter>: set number of iterations (default 20)\n"
+"-r <eta>: set learning rate (default 0.1)\n"
+"-a <alpha>: set coefficient of negative entries' loss (default 1)\n"
+"-c <c>: set value of negative entries (default 0.0001). Positive entry is always 1.\n"
+"-s <threads>: set number of threads (default 12)\n"
+"-n <bins>: set number of bins (may be adjusted by LIBMF)\n"
+"-p <path>: set path to the validation set\n"
+"-v <fold>: set number of folds for cross validation\n"
+"--quiet: quiet mode (no outputs)\n"
+"--nmf: perform non-negative matrix factorization\n"
+"--disk: perform disk-level training (will generate a buffer file)\n");
+}
+
+bool is_numerical(char *str)
+{
+    int c = 0;
+    while(*str != '\0')
+    {
+        if(isdigit(*str))
+            c++;
+        str++;
+    }
+    return c > 0;
+}
+
+Option parse_option(int argc, char **argv)
+{
+    vector<string> args;
+    for(int i = 0; i < argc; i++)
+        args.push_back(string(argv[i]));
+
+    if(argc == 1)
+        throw invalid_argument(train_help());
+
+    Option option;
+
+    mf_int i;
+    for(i = 1; i < argc; i++)
+    {
+        if(args[i].compare("-l1") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify lambda after -l1");
+            i++;
+
+            char *pch = strtok(argv[i], ",");
+            if(!is_numerical(pch))
+                throw invalid_argument("regularization coefficient\
+                                        should be a number");
+            option.param.lambda_p1 = (mf_float)strtod(pch, NULL);
+            option.param.lambda_q1 = (mf_float)strtod(pch, NULL);
+            pch = strtok(NULL, ",");
+            if(pch != NULL)
+            {
+                if(!is_numerical(pch))
+                    throw invalid_argument("regularization coefficient\
+                                            should be a number");
+                option.param.lambda_q1 = (mf_float)strtod(pch, NULL);
+            }
+        }
+        else if(args[i].compare("-l2") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify lambda after -l2");
+            i++;
+
+            char *pch = strtok(argv[i], ",");
+            if(!is_numerical(pch))
+                throw invalid_argument("regularization coefficient\
+                                        should be a number");
+            option.param.lambda_p2 = (mf_float)strtod(pch, NULL);
+            option.param.lambda_q2 = (mf_float)strtod(pch, NULL);
+            pch = strtok(NULL, ",");
+            if(pch != NULL)
+            {
+                if(!is_numerical(pch))
+                    throw invalid_argument("regularization coefficient\
+                                            should be a number");
+                option.param.lambda_q2 = (mf_float)strtod(pch, NULL);
+            }
+        }
+        else if(args[i].compare("-k") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify number of factors\
+                                        after -k");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-k should be followed by a number");
+            option.param.k = atoi(argv[i]);
+        }
+        else if(args[i].compare("-t") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify number of iterations\
+                                        after -t");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-i should be followed by a number");
+            option.param.nr_iters = atoi(argv[i]);
+        }
+        else if(args[i].compare("-r") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify eta after -r");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-r should be followed by a number");
+            option.param.eta = (mf_float)atof(argv[i]);
+        }
+        else if(args[i].compare("-s") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify number of threads\
+                                        after -s");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-s should be followed by a number");
+            option.param.nr_threads = atoi(argv[i]);
+        }
+        else if(args[i].compare("-a") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify negative weight\
+                                        after -a");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-a should be followed by a number");
+            option.param.alpha = static_cast<mf_float>(atof(argv[i]));
+        }
+        else if(args[i].compare("-c") == 0)
+        {
+            if((i+1) >= argc)
+                throw invalid_argument("need to specify negative rating\
+                                        after -c");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-c should be followed by a number");
+
+            if (argv[i][0] == '-')
+                // Negative number starts with - but atof only recognize numbers.
+                // Thus, we pass all but the first symbol to atof.
+                option.param.c = -static_cast<mf_float>(atof(argv[i] + 1));
+            else
+                // Non-negative numbers such as 0 and 0.5 can be handled by atof.
+                option.param.c = static_cast<mf_float>(atof(argv[i]));
+        }
+        else if(args[i].compare("-p") == 0)
+        {
+            if(i == argc-1)
+                throw invalid_argument("need to specify path after -p");
+            i++;
+
+            option.va_path = string(args[i]);
+        }
+        else if(args[i].compare("-v") == 0)
+        {
+            if(i == argc-1)
+                throw invalid_argument("need to specify number of folds\
+                                        after -v");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-v should be followed by a number");
+            option.nr_folds = atoi(argv[i]);
+
+            if(option.nr_folds < 2)
+                throw invalid_argument("number of folds\
+                                        must be greater than one");
+            option.do_cv = true;
+        }
+        else if(args[i].compare("-f") == 0)
+        {
+            if(i == argc-1)
+                throw invalid_argument("need to specify loss function\
+                                        after -f");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-f should be followed by a number");
+            option.param.fun = atoi(argv[i]);
+        }
+        else if(args[i].compare("-n") == 0)
+        {
+            if(i == argc-1)
+                throw invalid_argument("need to specify the number of blocks\
+                                        after -n");
+            i++;
+
+            if(!is_numerical(argv[i]))
+                throw invalid_argument("-n should be followed by a number");
+            option.param.nr_bins = atoi(argv[i]);
+        }
+        else if(args[i].compare("--nmf") == 0)
+        {
+            option.param.do_nmf = true;
+        }
+        else if(args[i].compare("--quiet") == 0)
+        {
+            option.param.quiet = true;
+        }
+        else if(args[i].compare("--disk") == 0)
+        {
+            option.on_disk = true;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    if(option.nr_folds > 1 && !option.va_path.empty())
+        throw invalid_argument("cannot specify both -p and -v");
+
+    if(i >= argc)
+        throw invalid_argument("training data not specified");
+
+    option.tr_path = string(args[i++]);
+
+    if(i < argc)
+    {
+        option.model_path = string(args[i]);
+    }
+    else if(i == argc)
+    {
+        const char *ptr = strrchr(&*option.tr_path.begin(), '/');
+        if(!ptr)
+            ptr = option.tr_path.c_str();
+        else
+            ++ptr;
+        option.model_path = string(ptr) + ".model";
+    }
+    else
+    {
+        throw invalid_argument("invalid argument");
+    }
+
+    option.param.nr_bins = max(option.param.nr_bins,
+                               2*option.param.nr_threads+1);
+    option.param.copy_data = false;
+
+    return option;
+}
+
+int main(int argc, char **argv)
+{
+    Option option;
+    try
+    {
+        option = parse_option(argc, argv);
+    }
+    catch(invalid_argument &e)
+    {
+        cout << e.what() << endl;
+        return 1;
+    }
+
+    mf_problem tr = {};
+    mf_problem va = {};
+    if(!option.on_disk)
+    {
+        try
+        {
+            tr = read_problem(option.tr_path);
+            va = read_problem(option.va_path);
+        }
+        catch(runtime_error &e)
+        {
+            cout << e.what() << endl;
+            return 1;
+        }
+    }
+
+    if(option.do_cv)
+    {
+        if(!option.on_disk)
+            mf_cross_validation(&tr, option.nr_folds, option.param);
+        else
+            mf_cross_validation_on_disk(
+                option.tr_path.c_str(), option.nr_folds, option.param);
+    }
+    else
+    {
+        mf_model *model;
+        if(!option.on_disk)
+            model = mf_train_with_validation(&tr, &va, option.param);
+        else
+            model = mf_train_with_validation_on_disk(option.tr_path.c_str(),
+                                                     option.va_path.c_str(),
+                                                     option.param);
+
+        // use the following function if you do not have a validation set
+
+        // mf_model model =
+        //     mf_train_with_validation(&tr, option.param);
+
+        mf_int status = mf_save_model(model, option.model_path.c_str());
+
+        mf_destroy_model(&model);
+
+        if(status != 0)
+        {
+            cout << "cannot save model to " << option.model_path << endl;
+
+            if(!option.on_disk)
+            {
+                delete[] tr.R;
+                delete[] va.R;
+            }
+
+            return 1;
+        }
+    }
+
+    if(!option.on_disk)
+    {
+        delete[] tr.R;
+        delete[] va.R;
+    }
+
+    return 0;
+}