libmf 0.1.3 → 0.2.0

data/vendor/libmf/demo/demo.bat

@@ -1,40 +0,0 @@
-SET train=..\windows\mf-train
-SET predict=..\windows\mf-predict
-
-::#########################################################################
-:: Real-valued matrix factorization (RVMF)
-::#########################################################################
-echo "Real-valued matrix factorization"
-:: In-memory training with holdout valudation
-%train% -f 0 -l2 0.05 -k 100 -t 10 -p real_matrix.te.txt real_matrix.tr.txt rvmf_model.txt
-:: Do prediction and show MAE
-%predict% -e 1 real_matrix.te.txt rvmf_model.txt rvmf_output.txt
-
-::#########################################################################
-:: Binary matrix factorization (BMF)
-::#########################################################################
-echo "binary matrix factorization"
-:: In-memory training with holdout valudation
-%train% -f 5 -l2 0.01 -k 64 -p binary_matrix.te.txt binary_matrix.tr.txt bmf_model.txt
-:: Do prediction and show accuracy
-%predict% -e 6 binary_matrix.te.txt bmf_model.txt bmf_output.txt
-
-::#########################################################################
-:: One-class matrix factorization (OCMF)
-::#########################################################################
-echo "one-class matrix factorization using a stochastic gradient method"
-:: In-memory training with holdout validation
-%train% -f 10 -l2 0.01 -k 32 -p all_one_matrix.te.txt all_one_matrix.tr.txt ocmf_model.txt
-:: Do prediction and show row-oriented MPR
-%predict% -e 10 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-:: Do prediction and show row-oriented AUC
-%predict% -e 12 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-
-echo "one-class matrix factorization using a coordinate descent method"
-:: In-memory training with holdout validation
-%train% -f 12 -l2 0.01 -k 32 -a 0.001 -c 0.0001 -p all_one_matrix.te.txt all_one_matrix.tr.txt ocmf_model.txt
-:: Do prediction and show row-oriented MPR
-%predict% -e 10 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-:: Do prediction and show row-oriented AUC
-%predict% -e 12 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-)

data/vendor/libmf/demo/demo.sh

@@ -1,58 +0,0 @@
-#!/bin/sh
-train=../mf-train
-predict=../mf-predict
-
-##########################################################################
-# Build package if no binary found and this script is exectuted via the
-# following command.
-#  libmf/demo > sh demo.sh
-##########################################################################
-if [ ! -s $train ] || [ ! -s $predict ]
-then
-    (cd .. && make)
-fi
-
-##########################################################################
-# Real-valued matrix factorization (RVMF)
-##########################################################################
-echo "--------------------------------"
-echo "Real-valued matrix factorization"
-echo "--------------------------------"
-# In-memory training with holdout valudation
-$train -f 0 -l2 0.05 -k 100 -t 10 -p real_matrix.te.txt real_matrix.tr.txt rvmf_model.txt
-# Do prediction and show MAE
-$predict -e 1 real_matrix.te.txt rvmf_model.txt rvmf_output.txt
-
-##########################################################################
-# Binary matrix factorization (BMF)
-##########################################################################
-echo "---------------------------"
-echo "binary matrix factorization"
-echo "---------------------------"
-# In-memory training with holdout valudation
-$train -f 5 -l2 0.01 -k 64 -p binary_matrix.te.txt binary_matrix.tr.txt bmf_model.txt
-# Do prediction and show accuracy
-$predict -e 6 binary_matrix.te.txt bmf_model.txt bmf_output.txt
-
-##########################################################################
-# One-class matrix factorization (OCMF)
-##########################################################################
-echo "-----------------------------------------------------------------"
-echo "one-class matrix factorization using a stochastic gradient method"
-echo "-----------------------------------------------------------------"
-# In-memory training with holdout validation
-$train -f 10 -l2 0.01 -k 32 -p all_one_matrix.te.txt all_one_matrix.tr.txt ocmf_model.txt
-# Do prediction and show row-oriented MPR
-$predict -e 10 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-# Do prediction and show row-oriented AUC
-$predict -e 12 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-
-echo "----------------------------------------------------------------"
-echo "one-class matrix factorization using a coordinate descent method"
-echo "----------------------------------------------------------------"
-# In-memory training with holdout validation
-$train -f 12 -l2 0.01 -k 32 -a 0.001 -c 0.0001 -p all_one_matrix.te.txt all_one_matrix.tr.txt ocmf_model.txt
-# Do prediction and show row-oriented MPR
-$predict -e 10 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt
-# Do prediction and show row-oriented AUC
-$predict -e 12 all_one_matrix.te.txt ocmf_model.txt ocmf_output.txt

data/vendor/libmf/mf-predict.cpp

@@ -1,207 +0,0 @@
-#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

@@ -1,378 +0,0 @@
-#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;
-}