ml4r 0.1.4 → 0.1.5

data/ext/ml4r/MachineLearning/MLData/MLData.cpp

@@ -0,0 +1,232 @@
+#include "MachineLearning/MLData/MLData.h"
+#include "MachineLearning/MLExperiment.h"
+#include "utils/Utils.h"
+
+#include <boost/foreach.hpp>
+#include <boost/lexical_cast.hpp>
+using boost::lexical_cast;
+
+MLData::MLData() : m_missingValueDefined(false)
+{}
+
+MLData::~MLData()
+{}
+
+vector<shared_ptr<MLExperiment> >& MLData::getExperiments()
+{
+    return m_experiments;
+}
+
+vector<shared_ptr<MLExperiment> >& MLData::getTrainingExperiments(int fold)
+{
+    return m_trainingExperiments[fold];
+}
+
+shared_ptr<MLExperiment> MLData::getExperimentWithId(int experimentId)
+{
+    if (m_experimentsById.find(experimentId) == m_experimentsById.end())
+        throw std::runtime_error(string("Could not find experiment with id: " + lexical_cast<string>(experimentId)).c_str());
+
+    return m_experimentsById[experimentId];
+}
+
+void MLData::setExperiments(vector<shared_ptr<MLExperiment> > experiments)
+{
+    m_experiments = experiments;
+    BOOST_FOREACH(shared_ptr<MLExperiment>& experiment, m_experiments)
+        m_experimentsById[experiment->getExperimentId()] = experiment;
+
+    createFolds(1, 0);
+}
+
+vector<string>& MLData::getFeatures()
+{
+    return m_featureNames;
+}
+
+void MLData::setFeatures(vector<string> features)
+{
+    m_featureNames = features;
+    int index = -1;
+    BOOST_FOREACH(string& e, m_featureNames)
+    {
+        ++index;
+        m_featureIndices[e] = index;
+    }
+}
+
+void MLData::constructCategories(vector<string> categoricalFeatures)
+{
+    BOOST_FOREACH(string& categoricalFeature, categoricalFeatures)
+    {
+        if (m_featureIndices.find(categoricalFeature) == m_featureIndices.end())
+            throw std::runtime_error("Could not find categorical feature '" + categoricalFeature + "' in list of features to load or run");
+
+        int featureIndex = m_featureIndices[categoricalFeature];
+        m_categoricalFeatureIndices.insert(featureIndex);
+        
+    }
+}
+
+int MLData::getFeatureIndex(string& feature)
+{
+    const map<string,int>::iterator it = m_featureIndices.find(feature);
+    if (it == m_featureIndices.end())
+        throw std::runtime_error("Cannot get feature index for feature '" + feature + "'. Feature not loaded.");
+
+    return it->second;
+}
+
+set<int>& MLData::getCategoricalFeatureIndices()
+{
+    return m_categoricalFeatureIndices;
+}
+
+void MLData::setInitialPredictionsDefined(bool defined)
+{
+    m_initialPredictionsDefined = defined;
+}
+
+bool MLData::initialPredictionsDefined()
+{
+    return m_initialPredictionsDefined;
+}
+
+void MLData::createFolds(int numFolds, int randomSeed)
+{
+    m_foldNumbers.clear();
+    for (int i = 0; i < numFolds; ++i)
+        m_foldNumbers.push_back(i);
+    
+    m_cvExperiments.clear();
+    m_trainingExperiments.clear();
+
+    if (m_foldNumbers.size() == 1)
+    {    
+        m_trainingExperiments[0] = m_experiments;
+        return;
+    }
+
+    srand(randomSeed);
+    vector<int> folds                   = Utils::vectorRange<int>(0,numFolds-1);
+    vector<int> repeatedFolds           = Utils::vectorRepeat(folds, m_experiments.size());
+    vector<int> randomlySortedFolds     = Utils::vectorShuffle(repeatedFolds);
+        
+
+    int index = -1;
+    BOOST_FOREACH(shared_ptr<MLExperiment> experiment, m_experiments)
+    {
+        ++index;
+        for (int fold = 0; fold < numFolds; ++fold)
+        {
+            if (randomlySortedFolds.at(index) == fold)
+                m_cvExperiments[fold].push_back(experiment);
+            else
+                m_trainingExperiments[fold].push_back(experiment);
+        }
+    }
+}
+
+
+void MLData::setFolds( vector<int> experimentFolds )
+{
+    m_cvExperiments.clear();
+    m_trainingExperiments.clear();
+    m_foldNumbers.clear();
+
+    if (experimentFolds.size() != m_experiments.size())
+        throw std::runtime_error("[MLData::setFolds] to use this method, the list of folds must have the same length as the list of training experiments!");
+    
+    BOOST_FOREACH(int fold, experimentFolds)
+        m_foldNumbers.push_back(fold);
+
+    int index = -1;
+    BOOST_FOREACH(shared_ptr<MLExperiment> experiment, m_experiments)
+    {
+        ++index;
+        BOOST_FOREACH(int fold, m_foldNumbers)
+        {
+            int experimentFold = experimentFolds.at(index);
+            if (fold == experimentFold)
+                m_cvExperiments[fold].push_back(experiment);
+            else
+                m_trainingExperiments[fold].push_back(experiment);
+        }
+    }
+}
+
+int MLData::getNumFolds()
+{
+    return (int) m_foldNumbers.size();
+}
+
+vector<shared_ptr<MLExperiment> >& MLData::getCrossValidationExperiments(int fold)
+{
+    return m_cvExperiments[fold];
+}
+
+void MLData::setMissingValue(double missingValue)
+{
+    m_missingValueDefined = true;
+    m_missingValue = missingValue;
+}
+
+bool MLData::missingValueDefined()
+{
+    return m_missingValueDefined;
+}
+
+double MLData::getMissingValue()
+{
+    if (!m_missingValueDefined)
+        throw std::runtime_error("Cannot ask for missing value when it is not defined!");
+
+    return m_missingValue;
+}
+
+void MLData::setInitialPredictions( vector<double> initialPredictions )
+{
+    if (m_experiments.size() != initialPredictions.size())
+        throw std::runtime_error("Initial predictions are not of the same length as experiments. " +
+                                 lexical_cast<string>(initialPredictions.size()) + " versus " + lexical_cast<string>(m_experiments.size()));
+
+    int index = -1;
+    BOOST_FOREACH(shared_ptr<MLExperiment> experiment, m_experiments)
+    {
+        ++index;
+        experiment->setPrediction(initialPredictions.at(index));
+    }
+    m_initialPredictionsDefined = true;
+}
+
+shared_ptr<MLExperiment> MLData::getExperiment( int experimentIndex )
+{
+    return m_experiments.at(experimentIndex);
+}
+
+vector<int>& MLData::getFoldNumbers()
+{
+    return m_foldNumbers;
+}
+
+vector<int> MLData::getFolds()
+{
+    vector<int> folds(m_experiments.size());
+    
+    typedef pair<int, vector<shared_ptr<MLExperiment> > > ElementType;
+    BOOST_FOREACH(ElementType p, m_cvExperiments)
+    {
+        int fold = p.first;
+        vector<shared_ptr<MLExperiment> > experiments = p.second;
+
+        BOOST_FOREACH(shared_ptr<MLExperiment>& experiment, experiments)
+        {
+            folds.at(experiment->getExperimentIndex()) = fold;
+        }
+    }
+    return folds;
+}
+
+
+
+

data/ext/ml4r/MachineLearning/MLData/MLDataFields.cpp

@@ -0,0 +1 @@
+#include "MachineLearning/MLData/MLDataFields.h"

data/ext/ml4r/MachineLearning/MLData/MLDataReader.cpp

@@ -0,0 +1,139 @@
+#include "MachineLearning/MLData/MLDataReader.h"
+#include "MachineLearning/MLData/MLDataFields.h"
+#include "MachineLearning/MLData/MLData.h"
+#include "MachineLearning/MLExperiment.h"
+
+#include <sstream>
+#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
+#include <stdexcept>
+#include <boost/lexical_cast.hpp>
+using std::runtime_error;
+using boost::make_shared;
+using std::ostringstream;
+using boost::lexical_cast;
+#include "sqlite3.h"
+#include "utils/VlcMessage.h"
+
+MLDataReader::MLDataReader()
+{
+    fieldsSpec = make_shared<MLDataFields>();
+    missingValueDefined = false;
+}
+
+MLDataReader::~MLDataReader()
+{
+
+}
+
+void MLDataReader::execute(MLData* mlData)
+{
+    vlcMessage.Begin("Input (sqlite3)");
+    if (tableName.empty())
+        throw runtime_error("tableName not specified for sqlite3 database!");
+
+    sqlite3 *database;
+    sqlite3_open(databaseName.c_str(), &database);
+
+    int experimentIndex    = -1;
+
+    sqlite3_stmt *statement;
+
+    vector<string> featuresToLoad = fieldsSpec->featuresFields;
+
+    vector<shared_ptr<MLExperiment> > experiments;
+    
+    int attributesStartIndex    =  1;
+    int weightIndex             = -1;
+    int initialPredictionsIndex = -1;
+    int responseIndex           = -1;
+
+    if (!fieldsSpec->actualYField.empty())               responseIndex             = attributesStartIndex++;
+    if (!fieldsSpec->weightsField.empty())               weightIndex               = attributesStartIndex++; 
+    if (!fieldsSpec->initialPredictionsField.empty())    initialPredictionsIndex   = attributesStartIndex++;
+    
+    string sql = getSelectSql();
+
+    vector<double> features(featuresToLoad.size());
+
+    if(sqlite3_prepare_v2(database, sql.c_str(), -1, &statement, 0) != SQLITE_OK)
+        throw runtime_error("Couldn't prepare sql: " + sql);
+
+    while(true)
+    {
+        if (sqlite3_step(statement) != SQLITE_ROW) break;
+
+        int     experimentId        = sqlite3_column_int(statement, 0);
+        
+        double  yValue              = responseIndex != -1 ?           sqlite3_column_double(statement, 1) : 0.0;
+        double  weight              = weightIndex != -1 ?             sqlite3_column_double(statement, weightIndex) : 1.0;
+        double  initialPrediction   = initialPredictionsIndex != -1 ? sqlite3_column_double(statement, initialPredictionsIndex) : -1;
+
+        if (responseIndex != -1 && missingValueDefined && yValue == missingValue)
+            continue;
+
+        int index = attributesStartIndex;
+        BOOST_FOREACH(double& f, features)
+        {
+            f = sqlite3_column_double(statement, index++);
+            // attributes.at(i) = q.GetDouble(f_attributes.at(i));
+        }
+
+        // create an MLExperiment
+        ++experimentIndex;
+        shared_ptr<MLExperiment> experiment = 
+            shared_ptr<MLExperiment>(new MLExperiment(experimentId, experimentIndex, yValue, initialPrediction, weight, features));
+
+        experiments.push_back(experiment);
+    }
+
+    sqlite3_finalize(statement);
+    string error = sqlite3_errmsg(database);
+    if (error != "not an error") 
+        vlcMessage.Write("Error: " + sql + "\n" + error, 1);
+
+    // finally, set up our MLData object
+    mlData->setExperiments(experiments);
+    mlData->setFeatures(featuresToLoad);
+    mlData->constructCategories(categoricalFeatures);
+    mlData->setInitialPredictionsDefined(initialPredictionsIndex != -1);
+
+    if (missingValueDefined)
+        mlData->setMissingValue(missingValue);
+
+    reportOnData(mlData, fieldsSpec);
+
+    vlcMessage.End();
+}
+
+string MLDataReader::getSelectSql()
+{
+    ostringstream str;
+    str << "SELECT "    << "tbl.'" << fieldsSpec->experimentIdField << "'";
+
+    if (fieldsSpec->actualYField != "")
+        str << ", tbl.'" << fieldsSpec->actualYField      << "'";
+    
+    if (fieldsSpec->weightsField != "")
+        str << ", tbl.'" << fieldsSpec->weightsField << "'";
+    
+    if (fieldsSpec->initialPredictionsField != "")
+        str << ", tbl.'" << fieldsSpec->initialPredictionsField << "'";
+    
+    vector<string> featuresToLoad = fieldsSpec->featuresFields;
+    
+    for (unsigned int i = 0; i < featuresToLoad.size(); ++i)
+        str << ", tbl.'" << featuresToLoad.at(i) << "'";
+    
+    str << " FROM '" << tableName << "' tbl";
+    str << " ORDER BY tbl.'" << fieldsSpec->experimentIdField << "'";
+    return str.str();
+}
+
+void MLDataReader::reportOnData(MLData* data, shared_ptr<MLDataFields> fieldsSpec)
+{
+    vector<shared_ptr<MLExperiment> > experiments = data->getExperiments();
+    vlcMessage.Write("Successfully read " + lexical_cast<string>(experiments.size()) + " experiments");
+    vlcMessage.Write("Loaded " + lexical_cast<string>(fieldsSpec->featuresFields.size()) + " fields");
+}
+

data/ext/ml4r/MachineLearning/MLData/ZenithMLData.cpp

@@ -0,0 +1,96 @@
+// #include "MachineLearning/MLData/ZenithMLData.h"
+// #include "MachineLearning/MLData/MLData.h"
+// #include "MachineLearning/MLExperiment.h"
+
+// #include "RubyUtils.h"
+// using namespace RubyUtils;
+
+// void zenith_mldata_Free(void* v)
+// {
+//     delete (reinterpret_cast<MLData*>(v));
+// }
+
+// OtInterface::VALUE zenith_mldata_New(int argc, VALUE* argv, VALUE klass)
+// {
+//     VALUE obj = otRuby->DataWrapStruct(klass, 0, zenith_mldata_Free, 0);
+//     otRuby->rb_obj_call_init(obj, argc, argv);
+//     return obj;
+// }
+
+// OtInterface::VALUE zenith_mldata_Initialize(VALUE self)
+// {
+//     if (otRuby->GetDataPtr(self)) zenith_mldata_Free(otRuby->GetDataPtr(self));
+//     otRuby->SetDataPtr(self, NULL);
+
+//     MLData* mlData = new MLData();
+//     if (mlData == NULL) otRuby->rb_sys_fail("MLData class could not be created");
+//     otRuby->SetDataPtr(self, mlData);
+//     return self;
+// }
+
+// OtInterface::VALUE zenith_mldata_createFolds(VALUE self, VALUE rb_numFolds, VALUE rb_randomSeed)
+// {
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(self);
+//     int numFolds;
+//     int randomSeed;
+//     RubyUtils::fromValue(rb_numFolds, numFolds);
+//     RubyUtils::fromValue(rb_randomSeed, randomSeed);
+//     mlData->createFolds(numFolds, randomSeed);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldata_getResponse(VALUE self)
+// {
+//     vector<double> response;
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(self);
+    
+//     vector<shared_ptr<MLExperiment> >& experiments = mlData->getExperiments();
+//     response.reserve(experiments.size());
+
+//     BOOST_FOREACH(auto& experiment, experiments)
+//     {
+//         response.push_back(experiment->getY());
+//     }
+//     return RubyUtils::toValue(response);
+// }
+
+// OtInterface::VALUE zenith_mldata_getExperimentIds( VALUE self )
+// {
+//     vector<double> response;
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(self);
+
+//     vector<shared_ptr<MLExperiment> >& experiments = mlData->getExperiments();
+//     response.reserve(experiments.size());
+
+//     BOOST_FOREACH(auto& experiment, experiments)
+//     {
+//         response.push_back(experiment->getExperimentId());
+//     }
+//     return RubyUtils::toValue(response);
+// }
+
+// OtInterface::VALUE zenith_mldata_setInitialPredictions( VALUE self, VALUE rb_predictions )
+// {
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(self);
+//     vector<double> predictions;
+//     vlcMessage.Write("Setting predictions");
+//     RubyUtils::fromValue(rb_predictions, predictions);
+//     vlcMessage.Write("Successfully converted to vector");
+//     mlData->setInitialPredictions(predictions);
+//     vlcMessage.Write("Successfully applied to MLData");
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldata_setFolds( VALUE self, VALUE rb_folds )
+// {
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(self);
+//     vector<int> folds = RubyUtils::fromValue<vector<int> >(rb_folds);
+//     mlData->setFolds(folds);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldata_getFolds( VALUE self )
+// {
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(self);
+//     return RubyUtils::toValue(mlData->getFolds());
+// }

data/ext/ml4r/MachineLearning/MLData/ZenithMLDataReader.cpp

@@ -0,0 +1,113 @@
+// #include "MachineLearning/MLData/ZenithMLDataReader.h"
+// #include "MachineLearning/MLData/MLDataReader.h"
+// #include "MachineLearning/MLData/MLDataFields.h"
+// #include "MachineLearning/MLData/ZenithMLData.h"
+
+// #include "RubyUtils.h"
+// using namespace RubyUtils;
+
+// void zenith_mldatareader_Free(void* v)
+// {
+//     delete (reinterpret_cast<MLDataReader*>(v));
+// }
+
+// OtInterface::VALUE zenith_mldatareader_New(int argc, VALUE* argv, VALUE klass)
+// {
+//     VALUE obj = otRuby->DataWrapStruct(klass, 0, zenith_mldatareader_Free, 0);
+//     otRuby->rb_obj_call_init(obj, argc, argv);
+//     return obj;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_Initialize(VALUE self)
+// {
+//     if (otRuby->GetDataPtr(self)) zenith_mldatareader_Free(otRuby->GetDataPtr(self));
+//     otRuby->SetDataPtr(self, NULL);
+
+//     MLDataReader* mlDataReader = new MLDataReader();
+//     if (mlDataReader == NULL) otRuby->rb_sys_fail("ZenithMLDataReader class could not be created");
+//     otRuby->SetDataPtr(self, mlDataReader);
+//     return self;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_execute(VALUE self)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     VALUE obj = zenith_mldata_New(0, 0, rb_cMLData);
+//     MLData* mlData = (MLData*)otRuby->GetDataPtr(obj);
+
+//     try
+//     {
+//         mlDataReader->execute(mlData);
+//     }
+//     catch (std::exception e)
+//     {
+//         vlcMessage.Raise((string("Caught error: ") + e.what()).c_str());
+//     }
+
+//     return obj;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setDatabaseName(VALUE self, VALUE databaseNameValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->databaseName = RubyUtils::fromValue<string>(databaseNameValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setTableName(VALUE self, VALUE tableNameValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->tableName = RubyUtils::fromValue<string>(tableNameValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setFeaturesToLoad(VALUE self, VALUE featuresValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->fieldsSpec->featuresFields = RubyUtils::fromValue<vector<string> >(featuresValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setCategoricalFeatures(VALUE self, VALUE categoricalFeaturesValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->categoricalFeatures = RubyUtils::fromValue<vector<string> >(categoricalFeaturesValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setActualYField(VALUE self, VALUE yFieldValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->fieldsSpec->actualYField = RubyUtils::fromValue<string>(yFieldValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setExperimentIdField(VALUE self, VALUE experimentIdFieldValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->fieldsSpec->experimentIdField = RubyUtils::fromValue<string>(experimentIdFieldValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setWeightsField(VALUE self, VALUE weightsFieldValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->fieldsSpec->weightsField = RubyUtils::fromValue<string>(weightsFieldValue);
+//     return TOtRubyInterface::Qnil;
+
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setInitialPredictionsField(VALUE self, VALUE initialEstimatesFieldValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->fieldsSpec->initialPredictionsField = RubyUtils::fromValue<string>(initialEstimatesFieldValue);
+//     return TOtRubyInterface::Qnil;
+// }
+
+// OtInterface::VALUE zenith_mldatareader_setMissingValue(VALUE self, VALUE missingValue)
+// {
+//     MLDataReader* mlDataReader = (MLDataReader*)otRuby->GetDataPtr(self);
+//     mlDataReader->missingValue = RubyUtils::fromValue<double>(missingValue);
+//     mlDataReader->missingValueDefined = true;
+//     return TOtRubyInterface::Qnil;
+// }

data/ext/ml4r/MachineLearning/MLExperiment.cpp

@@ -0,0 +1,69 @@
+#include "MachineLearning/MLExperiment.h"
+
+MLExperiment::MLExperiment(int experimentId, int experimentIndex, double y, double initialPrediction,
+                            double weight, vector<double> features)
+ : m_experimentId(experimentId), m_experimentIndex(experimentIndex), m_yValue(y), m_prediction(initialPrediction),
+   m_weight(weight), m_features(features)
+{
+    
+}
+
+MLExperiment::MLExperiment(shared_ptr<MLExperiment> mlExperiment)
+  : m_yValue(mlExperiment->getY()), 
+    m_experimentId(mlExperiment->getExperimentId()),
+    m_experimentIndex(mlExperiment->getExperimentIndex()),
+    m_prediction(mlExperiment->getPrediction()),
+    m_weight(mlExperiment->getWeight()),
+    m_features(mlExperiment->getFeatureValues())
+{
+}
+
+MLExperiment::MLExperiment()
+{
+
+}
+
+MLExperiment::~MLExperiment()
+{
+
+}
+
+double MLExperiment::getY()
+{
+    return m_yValue;
+}
+
+int MLExperiment::getExperimentId()
+{
+    return m_experimentId;
+}
+
+int MLExperiment::getExperimentIndex()
+{
+    return m_experimentIndex;
+}
+
+double MLExperiment::getPrediction()
+{
+    return m_prediction;
+}
+
+double MLExperiment::getWeight()
+{
+    return m_weight;
+}
+
+vector<double>& MLExperiment::getFeatureValues()
+{
+    return m_features;
+}
+
+double MLExperiment::getFeatureValue(int featureIndex)
+{
+    return m_features.at(featureIndex);
+}
+
+void MLExperiment::setPrediction(double prediction)
+{
+    m_prediction = prediction;
+}