[mlpack-git] master: Refactor LogisticRegressionFunction to work with arbitrary matrix types. (bbe9cd1)
gitdub at big.cc.gt.atl.ga.us
gitdub at big.cc.gt.atl.ga.us
Mon Sep 14 22:59:44 EDT 2015
Repository : https://github.com/mlpack/mlpack
On branch : master
Link : https://github.com/mlpack/mlpack/compare/754ff98bb9919959b9a27e8aa75535a02ff0415e...bbe9cd161571c99aca88096b07de61341711c049
>---------------------------------------------------------------
commit bbe9cd161571c99aca88096b07de61341711c049
Author: Ryan Curtin <ryan at ratml.org>
Date: Tue Sep 15 01:15:53 2015 +0000
Refactor LogisticRegressionFunction to work with arbitrary matrix types.
>---------------------------------------------------------------
bbe9cd161571c99aca88096b07de61341711c049
.../methods/logistic_regression/CMakeLists.txt | 2 +-
.../logistic_regression/logistic_regression.hpp | 18 ++---
.../logistic_regression_function.hpp | 24 +++---
.../logistic_regression_function_impl.hpp | 62 ++++++++++------
.../logistic_regression_impl.hpp | 44 ++++++-----
.../logistic_regression_main.cpp | 19 ++---
src/mlpack/tests/logistic_regression_test.cpp | 85 ++++++++++++----------
src/mlpack/tests/serialization_test.cpp | 2 +-
src/mlpack/tests/to_string_test.cpp | 4 +-
9 files changed, 147 insertions(+), 113 deletions(-)
diff --git a/src/mlpack/methods/logistic_regression/CMakeLists.txt b/src/mlpack/methods/logistic_regression/CMakeLists.txt
index e262d2d..d1477ff 100644
--- a/src/mlpack/methods/logistic_regression/CMakeLists.txt
+++ b/src/mlpack/methods/logistic_regression/CMakeLists.txt
@@ -5,7 +5,7 @@ set(SOURCES
logistic_regression.hpp
logistic_regression_impl.hpp
logistic_regression_function.hpp
- logistic_regression_function.cpp
+ logistic_regression_function_impl.hpp
)
# add directory name to sources
diff --git a/src/mlpack/methods/logistic_regression/logistic_regression.hpp b/src/mlpack/methods/logistic_regression/logistic_regression.hpp
index 506678f..417dedf 100644
--- a/src/mlpack/methods/logistic_regression/logistic_regression.hpp
+++ b/src/mlpack/methods/logistic_regression/logistic_regression.hpp
@@ -33,7 +33,7 @@ class LogisticRegression
* @param lambda L2-regularization parameter.
*/
LogisticRegression(const arma::mat& predictors,
- const arma::vec& responses,
+ const arma::Row<size_t>& responses,
const double lambda = 0);
/**
@@ -48,8 +48,8 @@ class LogisticRegression
* @param lambda L2-regularization parameter.
*/
LogisticRegression(const arma::mat& predictors,
- const arma::vec& responses,
- const arma::mat& initialPoint,
+ const arma::Row<size_t>& responses,
+ const arma::vec& initialPoint,
const double lambda = 0);
/**
@@ -63,7 +63,7 @@ class LogisticRegression
*
* @param optimizer Instantiated optimizer with instantiated error function.
*/
- LogisticRegression(OptimizerType<LogisticRegressionFunction>& optimizer);
+ LogisticRegression(OptimizerType<LogisticRegressionFunction<>>& optimizer);
/**
* Construct a logistic regression model from the given parameters, without
@@ -98,7 +98,7 @@ class LogisticRegression
* @param decisionBoundary Decision boundary (default 0.5).
*/
void Predict(const arma::mat& predictors,
- arma::vec& responses,
+ arma::Row<size_t>& responses,
const double decisionBoundary = 0.5) const;
/**
@@ -116,7 +116,7 @@ class LogisticRegression
* @return Percentage of responses that are predicted correctly.
*/
double ComputeAccuracy(const arma::mat& predictors,
- const arma::vec& responses,
+ const arma::Row<size_t>& responses,
const double decisionBoundary = 0.5) const;
/**
@@ -128,7 +128,7 @@ class LogisticRegression
* @param responses Vector of responses.
*/
double ComputeError(const arma::mat& predictors,
- const arma::vec& responses) const;
+ const arma::Row<size_t>& responses) const;
//! Serialize the model.
template<typename Archive>
@@ -144,8 +144,8 @@ class LogisticRegression
double lambda;
};
-}; // namespace regression
-}; // namespace mlpack
+} // namespace regression
+} // namespace mlpack
// Include implementation.
#include "logistic_regression_impl.hpp"
diff --git a/src/mlpack/methods/logistic_regression/logistic_regression_function.hpp b/src/mlpack/methods/logistic_regression/logistic_regression_function.hpp
index c78840c..50ae692 100644
--- a/src/mlpack/methods/logistic_regression/logistic_regression_function.hpp
+++ b/src/mlpack/methods/logistic_regression/logistic_regression_function.hpp
@@ -19,16 +19,17 @@ namespace regression {
* This is used by various mlpack optimizers to train a logistic regression
* model.
*/
+template<typename MatType = arma::mat>
class LogisticRegressionFunction
{
public:
- LogisticRegressionFunction(const arma::mat& predictors,
- const arma::vec& responses,
+ LogisticRegressionFunction(const MatType& predictors,
+ const arma::Row<size_t>& responses,
const double lambda = 0);
- LogisticRegressionFunction(const arma::mat& predictors,
- const arma::vec& responses,
- const arma::mat& initialPoint,
+ LogisticRegressionFunction(const MatType& predictors,
+ const arma::Row<size_t>& responses,
+ const arma::vec& initialPoint,
const double lambda = 0);
//! Return the initial point for the optimization.
@@ -42,7 +43,7 @@ class LogisticRegressionFunction
double& Lambda() { return lambda; }
//! Return the matrix of predictors.
- const arma::mat& Predictors() const { return predictors; }
+ const MatType& Predictors() const { return predictors; }
//! Return the vector of responses.
const arma::vec& Responses() const { return responses; }
@@ -108,14 +109,17 @@ class LogisticRegressionFunction
//! The initial point, from which to start the optimization.
arma::mat initialPoint;
//! The matrix of data points (predictors).
- const arma::mat& predictors;
+ const MatType& predictors;
//! The vector of responses to the input data points.
- const arma::vec& responses;
+ const arma::Row<size_t>& responses;
//! The regularization parameter for L2-regularization.
double lambda;
};
-}; // namespace regression
-}; // namespace mlpack
+} // namespace regression
+} // namespace mlpack
+
+// Include implementation.
+#include "logistic_regression_function_impl.hpp"
#endif // __MLPACK_METHODS_LOGISTIC_REGRESSION_LOGISTIC_REGRESSION_FUNCTION_HPP
diff --git a/src/mlpack/methods/logistic_regression/logistic_regression_function_impl.hpp b/src/mlpack/methods/logistic_regression/logistic_regression_function_impl.hpp
index f815fe0..9a71d67 100644
--- a/src/mlpack/methods/logistic_regression/logistic_regression_function_impl.hpp
+++ b/src/mlpack/methods/logistic_regression/logistic_regression_function_impl.hpp
@@ -2,16 +2,21 @@
* @file logistic_regression_function.cpp
* @author Sumedh Ghaisas
*
- * Implementation of hte LogisticRegressionFunction class.
+ * Implementation of the LogisticRegressionFunction class.
*/
+#ifndef __MLPACK_METHODS_LOGISTIC_REGRESSION_FUNCTION_IMPL_HPP
+#define __MLPACK_METHODS_LOGISTIC_REGRESSION_FUNCTION_IMPL_HPP
+
+// In case it hasn't been included yet.
#include "logistic_regression_function.hpp"
-using namespace mlpack;
-using namespace mlpack::regression;
+namespace mlpack {
+namespace regression {
-LogisticRegressionFunction::LogisticRegressionFunction(
- const arma::mat& predictors,
- const arma::vec& responses,
+template<typename MatType>
+LogisticRegressionFunction<MatType>::LogisticRegressionFunction(
+ const MatType& predictors,
+ const arma::Row<size_t>& responses,
const double lambda) :
predictors(predictors),
responses(responses),
@@ -27,10 +32,11 @@ LogisticRegressionFunction::LogisticRegressionFunction(
<< " " << predictors.n_cols << ")!" << std::endl;
}
-LogisticRegressionFunction::LogisticRegressionFunction(
- const arma::mat& predictors,
- const arma::vec& responses,
- const arma::mat& initialPoint,
+template<typename MatType>
+LogisticRegressionFunction<MatType>::LogisticRegressionFunction(
+ const MatType& predictors,
+ const arma::Row<size_t>& responses,
+ const arma::vec& initialPoint,
const double lambda) :
initialPoint(initialPoint),
predictors(predictors),
@@ -47,8 +53,9 @@ LogisticRegressionFunction::LogisticRegressionFunction(
* Evaluate the logistic regression objective function given the estimated
* parameters.
*/
-double LogisticRegressionFunction::Evaluate(const arma::mat& parameters)
- const
+template<typename MatType>
+double LogisticRegressionFunction<MatType>::Evaluate(
+ const arma::mat& parameters) const
{
// The objective function is the log-likelihood function (w is the parameters
// vector for the model; y is the responses; x is the predictors; sig() is the
@@ -91,8 +98,10 @@ double LogisticRegressionFunction::Evaluate(const arma::mat& parameters)
* This is useful for optimizers that use a separable objective function, such
* as SGD.
*/
-double LogisticRegressionFunction::Evaluate(const arma::mat& parameters,
- const size_t i) const
+template<typename MatType>
+double LogisticRegressionFunction<MatType>::Evaluate(
+ const arma::mat& parameters,
+ const size_t i) const
{
// Calculate the regularization term. We must divide by the number of points,
// so that sum(Evaluate(parameters, [1:points])) == Evaluate(parameters).
@@ -112,20 +121,22 @@ double LogisticRegressionFunction::Evaluate(const arma::mat& parameters,
}
//! Evaluate the gradient of the logistic regression objective function.
-void LogisticRegressionFunction::Gradient(const arma::mat& parameters,
- arma::mat& gradient) const
+template<typename MatType>
+void LogisticRegressionFunction<MatType>::Gradient(
+ const arma::mat& parameters,
+ arma::mat& gradient) const
{
// Regularization term.
arma::mat regularization;
regularization = lambda * parameters.col(0).subvec(1, parameters.n_elem - 1);
- const arma::vec sigmoids = 1 / (1 + arma::exp(-parameters(0, 0)
- - predictors.t() * parameters.col(0).subvec(1, parameters.n_elem - 1)));
+ const arma::rowvec sigmoids = (1 / (1 + arma::exp(-parameters(0, 0)
+ - parameters.col(0).subvec(1, parameters.n_elem - 1).t() * predictors)));
gradient.set_size(parameters.n_elem);
gradient[0] = -arma::accu(responses - sigmoids);
gradient.col(0).subvec(1, parameters.n_elem - 1) = -predictors * (responses -
- sigmoids) + regularization;
+ sigmoids).t() + regularization;
}
/**
@@ -133,9 +144,11 @@ void LogisticRegressionFunction::Gradient(const arma::mat& parameters,
* function with respect to individual points. This is useful for optimizers
* that use a separable objective function, such as SGD.
*/
-void LogisticRegressionFunction::Gradient(const arma::mat& parameters,
- const size_t i,
- arma::mat& gradient) const
+template<typename MatType>
+void LogisticRegressionFunction<MatType>::Gradient(
+ const arma::mat& parameters,
+ const size_t i,
+ arma::mat& gradient) const
{
// Calculate the regularization term.
arma::mat regularization;
@@ -151,3 +164,8 @@ void LogisticRegressionFunction::Gradient(const arma::mat& parameters,
gradient.col(0).subvec(1, parameters.n_elem - 1) = -predictors.col(i)
* (responses[i] - sigmoid) + regularization;
}
+
+} // namespace regression
+} // namespace mlpack
+
+#endif
diff --git a/src/mlpack/methods/logistic_regression/logistic_regression_impl.hpp b/src/mlpack/methods/logistic_regression/logistic_regression_impl.hpp
index 11bfbb7..9d36647 100644
--- a/src/mlpack/methods/logistic_regression/logistic_regression_impl.hpp
+++ b/src/mlpack/methods/logistic_regression/logistic_regression_impl.hpp
@@ -17,13 +17,13 @@ namespace regression {
template<template<typename> class OptimizerType>
LogisticRegression<OptimizerType>::LogisticRegression(
const arma::mat& predictors,
- const arma::vec& responses,
+ const arma::Row<size_t>& responses,
const double lambda) :
parameters(arma::zeros<arma::vec>(predictors.n_rows + 1)),
lambda(lambda)
{
- LogisticRegressionFunction errorFunction(predictors, responses, lambda);
- OptimizerType<LogisticRegressionFunction> optimizer(errorFunction);
+ LogisticRegressionFunction<> errorFunction(predictors, responses, lambda);
+ OptimizerType<LogisticRegressionFunction<>> optimizer(errorFunction);
// Train the model.
Timer::Start("logistic_regression_optimization");
@@ -37,15 +37,15 @@ LogisticRegression<OptimizerType>::LogisticRegression(
template<template<typename> class OptimizerType>
LogisticRegression<OptimizerType>::LogisticRegression(
const arma::mat& predictors,
- const arma::vec& responses,
- const arma::mat& initialPoint,
+ const arma::Row<size_t>& responses,
+ const arma::vec& initialPoint,
const double lambda) :
parameters(arma::zeros<arma::vec>(predictors.n_rows + 1)),
lambda(lambda)
{
- LogisticRegressionFunction errorFunction(predictors, responses, lambda);
+ LogisticRegressionFunction<> errorFunction(predictors, responses, lambda);
errorFunction.InitialPoint() = initialPoint;
- OptimizerType<LogisticRegressionFunction> optimizer(errorFunction);
+ OptimizerType<LogisticRegressionFunction<>> optimizer(errorFunction);
// Train the model.
Timer::Start("logistic_regression_optimization");
@@ -58,7 +58,7 @@ LogisticRegression<OptimizerType>::LogisticRegression(
template<template<typename> class OptimizerType>
LogisticRegression<OptimizerType>::LogisticRegression(
- OptimizerType<LogisticRegressionFunction>& optimizer) :
+ OptimizerType<LogisticRegressionFunction<>>& optimizer) :
parameters(optimizer.Function().GetInitialPoint()),
lambda(optimizer.Function().Lambda())
{
@@ -82,24 +82,25 @@ LogisticRegression<OptimizerType>::LogisticRegression(
template<template<typename> class OptimizerType>
void LogisticRegression<OptimizerType>::Predict(const arma::mat& predictors,
- arma::vec& responses,
+ arma::Row<size_t>& responses,
const double decisionBoundary)
const
{
// Calculate sigmoid function for each point. The (1.0 - decisionBoundary)
// term correctly sets an offset so that floor() returns 0 or 1 correctly.
- responses = arma::floor((1.0 / (1.0 + arma::exp(-parameters(0)
- - predictors.t() * parameters.subvec(1, parameters.n_elem - 1))))
- + (1.0 - decisionBoundary));
+ responses = arma::conv_to<arma::Row<size_t>>::from((1.0 /
+ (1.0 + arma::exp(-parameters(0) - predictors.t() *
+ parameters.subvec(1, parameters.n_elem - 1)))) +
+ (1.0 - decisionBoundary));
}
template<template<typename> class OptimizerType>
double LogisticRegression<OptimizerType>::ComputeError(
const arma::mat& predictors,
- const arma::vec& responses) const
+ const arma::Row<size_t>& responses) const
{
// Construct a new error function.
- LogisticRegressionFunction newErrorFunction(predictors, responses,
+ LogisticRegressionFunction<> newErrorFunction(predictors, responses,
lambda);
return newErrorFunction.Evaluate(parameters);
@@ -108,20 +109,25 @@ double LogisticRegression<OptimizerType>::ComputeError(
template<template<typename> class OptimizerType>
double LogisticRegression<OptimizerType>::ComputeAccuracy(
const arma::mat& predictors,
- const arma::vec& responses,
+ const arma::Row<size_t>& responses,
const double decisionBoundary) const
{
// Predict responses using the current model.
- arma::vec tempResponses;
+ arma::Row<size_t> tempResponses;
Predict(predictors, tempResponses, decisionBoundary);
// Count the number of responses that were correct.
size_t count = 0;
for (size_t i = 0; i < responses.n_elem; i++)
+ {
if (responses(i) == tempResponses(i))
count++;
+ else
+ std::cout << "i " << i << ": " << responses[i] << " vs. predicted " <<
+tempResponses(i) << ".\n";
+ }
- return (double) (count * 100) / responses.n_rows;
+ return (double) (count * 100) / responses.n_elem;
}
template<template<typename> class OptimizerType>
@@ -144,7 +150,7 @@ std::string LogisticRegression<OptimizerType>::ToString() const
return convert.str();
}
-}; // namespace regression
-}; // namespace mlpack
+} // namespace regression
+} // namespace mlpack
#endif // __MLPACK_METHODS_LOGISTIC_REGRESSION_LOGISTIC_REGRESSION_IMPL_HPP
diff --git a/src/mlpack/methods/logistic_regression/logistic_regression_main.cpp b/src/mlpack/methods/logistic_regression/logistic_regression_main.cpp
index 6a053ac..691e3c2 100644
--- a/src/mlpack/methods/logistic_regression/logistic_regression_main.cpp
+++ b/src/mlpack/methods/logistic_regression/logistic_regression_main.cpp
@@ -141,10 +141,10 @@ int main(int argc, char** argv)
// These are the matrices we might use.
arma::mat regressors;
- arma::mat responses;
+ arma::Mat<size_t> responses;
arma::mat model;
arma::mat testSet;
- arma::vec predictions;
+ arma::Row<size_t> predictions;
// Load matrices.
if (!inputFile.empty())
@@ -163,7 +163,8 @@ int main(int argc, char** argv)
else
{
// The initial predictors for y, Nx1.
- responses = trans(regressors.row(regressors.n_rows - 1));
+ responses = arma::conv_to<arma::Row<size_t>>::from(
+ regressors.row(regressors.n_rows - 1));
regressors.shed_row(regressors.n_rows - 1);
}
@@ -187,8 +188,8 @@ int main(int argc, char** argv)
if (!regressors.empty())
{
// We need to train the model. Prepare the optimizers.
- arma::vec responsesVec = responses.unsafe_col(0);
- LogisticRegressionFunction lrf(regressors, responsesVec, lambda);
+ arma::Row<size_t> responsesVec = responses.unsafe_col(0).t();
+ LogisticRegressionFunction<> lrf(regressors, responsesVec, lambda);
// Set the initial point, if necessary.
if (!model.empty())
{
@@ -199,7 +200,7 @@ int main(int argc, char** argv)
if (optimizerType == "lbfgs")
{
- L_BFGS<LogisticRegressionFunction> lbfgsOpt(lrf);
+ L_BFGS<LogisticRegressionFunction<>> lbfgsOpt(lrf);
lbfgsOpt.MaxIterations() = maxIterations;
lbfgsOpt.MinGradientNorm() = tolerance;
Log::Info << "Training model with L-BFGS optimizer." << endl;
@@ -211,7 +212,7 @@ int main(int argc, char** argv)
}
else if (optimizerType == "sgd")
{
- SGD<LogisticRegressionFunction> sgdOpt(lrf);
+ SGD<LogisticRegressionFunction<>> sgdOpt(lrf);
sgdOpt.MaxIterations() = maxIterations;
sgdOpt.Tolerance() = tolerance;
sgdOpt.StepSize() = stepSize;
@@ -234,9 +235,9 @@ int main(int argc, char** argv)
<< endl;
lr.Predict(testSet, predictions, decisionBoundary);
- // Save the results, if necessary. Don't transpose.
+ // Save the results, if necessary.
if (!outputPredictionsFile.empty())
- data::Save(outputPredictionsFile, predictions, false, false);
+ data::Save(outputPredictionsFile, predictions, false);
}
if (!outputFile.empty())
diff --git a/src/mlpack/tests/logistic_regression_test.cpp b/src/mlpack/tests/logistic_regression_test.cpp
index 73c1d55..2e633ca 100644
--- a/src/mlpack/tests/logistic_regression_test.cpp
+++ b/src/mlpack/tests/logistic_regression_test.cpp
@@ -26,10 +26,11 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionEvaluate)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a LogisticRegressionFunction.
- LogisticRegressionFunction lrf(data, responses, 0.0 /* no regularization */);
+ LogisticRegressionFunction<> lrf(data, responses,
+ 0.0 /* no regularization */);
// These were hand-calculated using Octave.
BOOST_REQUIRE_CLOSE(lrf.Evaluate(arma::vec("1 1 1")), 7.0562141665, 1e-5);
@@ -53,11 +54,12 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionRandomEvaluate)
arma::mat data;
data.randu(dimension, points);
// Create random responses.
- arma::vec responses(points);
+ arma::Row<size_t> responses(points);
for (size_t i = 0; i < points; ++i)
responses[i] = math::RandInt(0, 2);
- LogisticRegressionFunction lrf(data, responses, 0.0 /* no regularization */);
+ LogisticRegressionFunction<> lrf(data, responses,
+ 0.0 /* no regularization */);
// Run a bunch of trials.
for (size_t i = 0; i < trials; ++i)
@@ -95,13 +97,13 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionRegularizationEvaluate)
arma::mat data;
data.randu(dimension, points);
// Create random responses.
- arma::vec responses(points);
+ arma::Row<size_t> responses(points);
for (size_t i = 0; i < points; ++i)
responses[i] = math::RandInt(0, 2);
- LogisticRegressionFunction lrfNoReg(data, responses, 0.0);
- LogisticRegressionFunction lrfSmallReg(data, responses, 0.5);
- LogisticRegressionFunction lrfBigReg(data, responses, 20.0);
+ LogisticRegressionFunction<> lrfNoReg(data, responses, 0.0);
+ LogisticRegressionFunction<> lrfSmallReg(data, responses, 0.5);
+ LogisticRegressionFunction<> lrfBigReg(data, responses, 20.0);
for (size_t i = 0; i < trials; ++i)
{
@@ -130,10 +132,11 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionGradient)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a LogisticRegressionFunction.
- LogisticRegressionFunction lrf(data, responses, 0.0 /* no regularization */);
+ LogisticRegressionFunction<> lrf(data, responses,
+ 0.0 /* no regularization */);
arma::vec gradient;
// If the model is at the optimum, then the gradient should be zero.
@@ -179,10 +182,11 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionSeparableEvaluate)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3;");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a LogisticRegressionFunction.
- LogisticRegressionFunction lrf(data, responses, 0.0 /* no regularization */);
+ LogisticRegressionFunction<> lrf(data, responses,
+ 0.0 /* no regularization */);
// These were hand-calculated using Octave.
BOOST_REQUIRE_CLOSE(lrf.Evaluate(arma::vec("1 1 1"), 0), 4.85873516e-2, 1e-5);
@@ -227,13 +231,13 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionRegularizationSeparableEvaluate)
arma::mat data;
data.randu(dimension, points);
// Create random responses.
- arma::vec responses(points);
+ arma::Row<size_t> responses(points);
for (size_t i = 0; i < points; ++i)
responses[i] = math::RandInt(0, 2);
- LogisticRegressionFunction lrfNoReg(data, responses, 0.0);
- LogisticRegressionFunction lrfSmallReg(data, responses, 0.5);
- LogisticRegressionFunction lrfBigReg(data, responses, 20.0);
+ LogisticRegressionFunction<> lrfNoReg(data, responses, 0.0);
+ LogisticRegressionFunction<> lrfSmallReg(data, responses, 0.5);
+ LogisticRegressionFunction<> lrfBigReg(data, responses, 20.0);
// Check that the number of functions is correct.
BOOST_REQUIRE_EQUAL(lrfNoReg.NumFunctions(), points);
@@ -270,10 +274,11 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionSeparableGradient)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a LogisticRegressionFunction.
- LogisticRegressionFunction lrf(data, responses, 0.0 /* no regularization */);
+ LogisticRegressionFunction<> lrf(data, responses,
+ 0.0 /* no regularization */);
arma::vec gradient;
// If the model is at the optimum, then the gradient should be zero.
@@ -350,13 +355,13 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionRegularizationGradient)
arma::mat data;
data.randu(dimension, points);
// Create random responses.
- arma::vec responses(points);
+ arma::Row<size_t> responses(points);
for (size_t i = 0; i < points; ++i)
responses[i] = math::RandInt(0, 2);
- LogisticRegressionFunction lrfNoReg(data, responses, 0.0);
- LogisticRegressionFunction lrfSmallReg(data, responses, 0.5);
- LogisticRegressionFunction lrfBigReg(data, responses, 20.0);
+ LogisticRegressionFunction<> lrfNoReg(data, responses, 0.0);
+ LogisticRegressionFunction<> lrfSmallReg(data, responses, 0.5);
+ LogisticRegressionFunction<> lrfBigReg(data, responses, 20.0);
for (size_t i = 0; i < trials; ++i)
{
@@ -412,13 +417,13 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionFunctionRegularizationSeparableGradient)
arma::mat data;
data.randu(dimension, points);
// Create random responses.
- arma::vec responses(points);
+ arma::Row<size_t> responses(points);
for (size_t i = 0; i < points; ++i)
responses[i] = math::RandInt(0, 2);
- LogisticRegressionFunction lrfNoReg(data, responses, 0.0);
- LogisticRegressionFunction lrfSmallReg(data, responses, 0.5);
- LogisticRegressionFunction lrfBigReg(data, responses, 20.0);
+ LogisticRegressionFunction<> lrfNoReg(data, responses, 0.0);
+ LogisticRegressionFunction<> lrfSmallReg(data, responses, 0.5);
+ LogisticRegressionFunction<> lrfBigReg(data, responses, 20.0);
for (size_t i = 0; i < trials; ++i)
{
@@ -471,7 +476,7 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionLBFGSSimpleTest)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a logistic regression object using L-BFGS (that is the default).
LogisticRegression<> lr(data, responses);
@@ -493,12 +498,12 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionSGDSimpleTest)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a logistic regression object using a custom SGD object with a much
// smaller tolerance.
- LogisticRegressionFunction lrf(data, responses, 0.001);
- SGD<LogisticRegressionFunction> sgd(lrf, 0.005, 500000, 1e-10);
+ LogisticRegressionFunction<> lrf(data, responses, 0.001);
+ SGD<LogisticRegressionFunction<>> sgd(lrf, 0.005, 500000, 1e-10);
LogisticRegression<SGD> lr(sgd);
// Test sigmoid function.
@@ -519,7 +524,7 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionLBFGSRegularizationSimpleTest)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a logistic regression object using L-BFGS (that is the default).
LogisticRegression<> lr(data, responses, 0.001);
@@ -542,12 +547,12 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionSGDRegularizationSimpleTest)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create a logistic regression object using custom SGD with a much smaller
// tolerance.
- LogisticRegressionFunction lrf(data, responses, 0.001);
- SGD<LogisticRegressionFunction> sgd(lrf, 0.005, 500000, 1e-10);
+ LogisticRegressionFunction<> lrf(data, responses, 0.001);
+ SGD<LogisticRegressionFunction<>> sgd(lrf, 0.005, 500000, 1e-10);
LogisticRegression<SGD> lr(sgd);
// Test sigmoid function.
@@ -571,7 +576,7 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionLBFGSGaussianTest)
GaussianDistribution g2(arma::vec("9.0 9.0 9.0"), arma::eye<arma::mat>(3, 3));
arma::mat data(3, 1000);
- arma::vec responses(1000);
+ arma::Row<size_t> responses(1000);
for (size_t i = 0; i < 500; ++i)
{
data.col(i) = g1.Random();
@@ -617,7 +622,7 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionSGDGaussianTest)
GaussianDistribution g2(arma::vec("9.0 9.0 9.0"), arma::eye<arma::mat>(3, 3));
arma::mat data(3, 1000);
- arma::vec responses(1000);
+ arma::Row<size_t> responses(1000);
for (size_t i = 0; i < 500; ++i)
{
data.col(i) = g1.Random();
@@ -663,11 +668,11 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionInstantiatedOptimizer)
// Very simple fake dataset.
arma::mat data("1 2 3;"
"1 2 3");
- arma::vec responses("1 1 0");
+ arma::Row<size_t> responses("1 1 0");
// Create an optimizer and function.
- LogisticRegressionFunction lrf(data, responses, 0.0005);
- L_BFGS<LogisticRegressionFunction> lbfgsOpt(lrf);
+ LogisticRegressionFunction<> lrf(data, responses, 0.0005);
+ L_BFGS<LogisticRegressionFunction<>> lbfgsOpt(lrf);
lbfgsOpt.MinGradientNorm() = 1e-50;
LogisticRegression<L_BFGS> lr(lbfgsOpt);
@@ -681,7 +686,7 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionInstantiatedOptimizer)
BOOST_REQUIRE_SMALL(sigmoids[2], 0.1);
// Now do the same with SGD.
- SGD<LogisticRegressionFunction> sgdOpt(lrf);
+ SGD<LogisticRegressionFunction<>> sgdOpt(lrf);
sgdOpt.StepSize() = 0.15;
sgdOpt.Tolerance() = 1e-75;
LogisticRegression<SGD> lr2(sgdOpt);
diff --git a/src/mlpack/tests/serialization_test.cpp b/src/mlpack/tests/serialization_test.cpp
index df259be..961f0fa 100644
--- a/src/mlpack/tests/serialization_test.cpp
+++ b/src/mlpack/tests/serialization_test.cpp
@@ -726,7 +726,7 @@ BOOST_AUTO_TEST_CASE(LogisticRegressionTest)
{
arma::mat data;
data.randu(3, 100);
- arma::vec responses;
+ arma::Row<size_t> responses;
responses.randu(100);
LogisticRegression<> lr(data, responses, 0.5);
diff --git a/src/mlpack/tests/to_string_test.cpp b/src/mlpack/tests/to_string_test.cpp
index 4018b27..ffd774d 100644
--- a/src/mlpack/tests/to_string_test.cpp
+++ b/src/mlpack/tests/to_string_test.cpp
@@ -419,9 +419,9 @@ BOOST_AUTO_TEST_CASE(LCCString)
BOOST_AUTO_TEST_CASE(LogRegString)
{
arma::mat c(40, 40);
- arma::mat b(40, 1);
+ arma::Row<size_t> b(40);
c.randn();
- b.randn();
+ b.randu();
mlpack::regression::LogisticRegression<> d(c, b);
Log::Debug << d;
testOstream << d;
More information about the mlpack-git
mailing list