ml4r 0.1.2 → 0.1.4

data/ext/ml4r/MachineLearning/RandomForest/RandomForestParameters.h

@@ -0,0 +1,32 @@
+#ifndef RandomForestParameters_h__
+#define RandomForestParameters_h__
+
+#include <vector>
+#include <string>
+#include <limits>
+using std::string;
+using std::vector;
+
+class RandomForestParameters
+{
+public:
+    RandomForestParameters() 
+    : minObservations(1), tryMVariables(100), numIterations(200), bagFraction(0.3), verbose(false),
+      withReplacement(false),scale(std::numeric_limits<double>::infinity())
+    {};
+    ~RandomForestParameters() {};
+
+    int             minObservations;
+    int             tryMVariables;
+    vector<string>  featuresToRun;
+    int             numIterations;
+    double          bagFraction;
+    bool            verbose;
+    bool            withReplacement;
+    double          scale;
+protected:
+	
+private:
+};
+
+#endif // RandomForestParameters_h__

data/ext/ml4r/MachineLearning/RandomForest/RandomForestRunner.h

@@ -0,0 +1,34 @@
+#ifndef RandomForest_h__
+#define RandomForest_h__
+
+#include "MachineLearning/MLRunner.h"
+
+#include <boost/shared_ptr.hpp>
+#include <vector>
+using std::vector;
+using boost::shared_ptr;
+
+class MLData;
+class MLExperiment;
+class MLEstimator;
+class RandomForestParameters;
+
+class RandomForestRunner : public MLRunner
+{
+public:
+	RandomForestRunner();
+	~RandomForestRunner();
+
+    void estimateMore(int numTrees);
+    
+    shared_ptr<RandomForestParameters> parameters;
+
+    shared_ptr<MLEstimator> createEstimator(MLData* data, vector<shared_ptr<MLExperiment> > trainingExperiments);
+
+protected:
+    void config();
+    
+private:
+};
+
+#endif // RandomForest_h__

data/ext/ml4r/extconf.rb

@@ -1,7 +1,20 @@
 require 'mkmf'
 
-$libs += " -lstdc++ --std=c++0x"
-# $CPPFLAGS += " --std=c++0x"
+$libs += " -lstdc++ "
+
+# The following spam out the console with hard to read error messages, obscuring any real problems
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement',   '')
+CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
+CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '')
 
 dir_config('boost')
-create_makefile('ml4r/ml4r')
+
+$srcs = Dir.glob("**/*.c*")
+$objs = $srcs.map { |e| e.gsub(/cpp$/, "o") }
+
+create_makefile('ml4r/ml4r')
+
+dat = IO.readlines("Makefile")
+File.open("Makefile", 'w') { |f|
+  dat.each { |line| f.puts(line.gsub(/\$\</, "$< -o $@")) }
+}

data/ext/ml4r/utils/StochasticUtils.h

@@ -0,0 +1,33 @@
+#ifndef __STOCHASTIC_UTILS_H__
+#define __STOCHASTIC_UTILS_H__
+
+#include <cstdlib>
+#include <vector>
+#include <string>
+#include <map>
+#include <stdexcept>
+using std::runtime_error;
+using std::map;
+using std::string;
+using std::vector;
+
+#define RAND_MAX_FLOAT ((float)RAND_MAX)
+
+namespace StochasticUtils
+{
+	vector<double> convertPdfToCumulativeSum(std::vector<double> pdf);
+    vector<float> convertHistogramToPdf(vector<float> histogram);
+                        int chooseCategoryFromCdf(float * cumulativeProbabilities, int N);
+                        int chooseCategoryFromCdf(vector<float>& cumulativeProbabilities);
+                        int chooseCategoryFromCdf(float qot, vector<float>& cumulativeProbabilities);
+						int chooseCategoryFromPdf(vector<float>& probabilities, string categoryType = "object");
+                        int chooseCategoryFromPdf(double qot, vector<float>& probabilities, string categoryType);
+    template<class T>   T   chooseCategoryFromPdf(map<T,float>& probabilities);
+    template<class T>   T   chooseCategoryFromPdf(double qot, map<T,float>& probabilities);
+    inline double getQot()
+    {
+        return (double)rand() / ((double)(RAND_MAX)+(double)(1));
+    }
+};
+
+#endif // __STOCHASTIC_UTILS_H__

data/ext/ml4r/utils/Utils.h

@@ -0,0 +1,147 @@
+#ifndef __Utils_h__
+#define __Utils_h__
+
+#include <vector>
+#include <stdexcept>
+#include <map>
+#include <boost/foreach.hpp>
+using std::map;
+using std::vector;
+
+namespace Utils
+{
+    template<class Container, class T>
+    bool hasElement(const Container& m, T element)
+    {
+        return find(m.begin(), m.end(), element) != m.end();
+    }
+
+    template<class T, class U>
+    bool hasElement(const std::map<T,U>& m, T element)
+    {
+        return m.find(element) != m.end();
+    }
+
+    template<typename T> 
+    int vectorIndex(vector<T>& c, T element)
+    {
+        if (find(c.begin(), c.end(), element) == c.end())
+            return -1;
+        return (int) (find(c.begin(), c.end(), element) - c.begin()); 
+    }
+
+    template<typename T>
+    T vectorSum(const std::vector<T>& vec)
+    {
+        if (vec.size() == 0)
+            return 0.0;
+
+        T sum = vec.front();
+        for (unsigned int i=1; i < vec.size(); ++i)
+            sum += vec.at(i);
+
+        return sum;
+    }
+
+    template<class T> vector<T>
+    vectorRange(T start, T end, T stepSize = 1)
+    {
+        int numSteps = (end - start) / stepSize + 1;
+        vector<T> returnValue;
+        returnValue.resize(numSteps);
+
+        for (int i = 0; i < numSteps; ++i)
+            returnValue.at(i) = start + i * stepSize; 
+
+        return returnValue;
+    }
+
+    template<class T> vector<T>
+    vectorRepeat(vector<T>& vec, int totalDesiredLength)
+    {
+        vector<T> returnValue;
+        returnValue.resize(totalDesiredLength);
+        int vectorSize = vec.size();
+
+        for (int i = 0; i < totalDesiredLength; ++i)
+        {
+            int index = i % vectorSize;
+            returnValue.at(i) = vec.at(index);
+        }
+        return returnValue;
+    }
+
+    template<class T> vector<T>
+    vectorShuffle(vector<T>& vec)
+    {
+
+        vector<int> sortVector = vectorOfRandomInt(vec.size());
+        vector<T> returnValue  = vectorSortUsingOtherVector(vec, sortVector);
+        return returnValue;
+    }
+
+    vector<int> vectorOfRandomInt(int length);
+    
+    template<class T, class U>
+    vector<T> vectorSortUsingOtherVector(vector<T>& vec, vector<U>& otherVector)
+    {
+        if (otherVector.size() != vec.size())
+            throw std::runtime_error("[] - vec and otherVector must be of equal size.");
+
+        vector<U> otherVectorSorted = otherVector;
+        sort(otherVectorSorted.begin(), otherVectorSorted.end());
+        map<U, int> newPosition;
+        int index = -1;
+        BOOST_FOREACH(U& e, otherVectorSorted)
+        {
+            ++index;
+            if (index == 0 || e != otherVectorSorted.at(index-1))
+                newPosition[e] = index;
+        }
+
+        vector<T> returnValue;
+        returnValue.resize(vec.size());
+
+        index = -1;
+        BOOST_FOREACH(T& e, vec)
+        {
+            ++index;
+            U sortValue = otherVector.at(index);
+            int newIndex = newPosition[sortValue]++; // ++ happens after newIndex is assigned
+            returnValue[newIndex] = e;
+        }
+        return returnValue;
+    }
+    
+    template<class T>
+    std::vector<T> vectorAbs(const std::vector<T>& vec)
+    {
+        std::vector<T> absVec;
+        absVec.reserve(vec.size());
+
+        for (unsigned int i=0; i < vec.size(); ++i)
+        {
+            absVec.push_back((T)abs(vec.at(i))); 
+        }
+        return absVec; 
+    }
+
+    template<class T> std::vector<T>& operator+=(std::vector<T>& vec, const std::vector<T>& vec2)
+    {
+        if (vec.size() != vec2.size())
+            throw std::runtime_error("Can't add vectors of different sizes");
+        for (unsigned int i=0; i < vec.size(); ++i)
+            vec.at(i) += vec2.at(i);
+        return vec;
+    }
+
+    template <class T> 
+    std::vector<T>& operator+=(std::vector<T>& vec, const float offset)
+    {
+        for (unsigned int i=0; i < vec.size(); ++i)
+            vec.at(i) += offset;
+        return vec;
+    }
+};
+
+#endif 

data/ext/ml4r/utils/VlcMessage.h

@@ -0,0 +1,44 @@
+#ifndef __VLC_MESSAGE_H__
+#define __VLC_MESSAGE_H__
+
+#include <iostream>
+#include <boost/lexical_cast.hpp>
+using boost::lexical_cast;
+using std::cout;
+using std::endl;
+
+class VlcMessage
+{
+public: 
+
+    VlcMessage() : indentLevel(0) {}
+    ~VlcMessage() {}
+
+	void Write(std::string message, int level = 0) 
+	{
+		for (int i=0; i<indentLevel; ++i)
+			cout << "    ";
+		if (level > 1) cout << "*** ";
+		cout << message;
+		if (level > 1) cout << " ***";
+		cout << endl;
+	}
+
+	void Begin(std::string message)
+	{
+		cout << message << endl;
+		++indentLevel;
+	}
+
+	void End()
+	{
+		cout << endl;
+		--indentLevel;
+	}
+
+	int indentLevel;
+};
+
+extern VlcMessage vlcMessage;
+
+#endif // __VLC_MESSAGE_H__

data/lib/ml4r/linear_regression.rb

@@ -0,0 +1,7 @@
+module Ml4r
+  class OLSLinearRegression
+    def i nitialize
+
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ml4r
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-24 00:00:00.000000000Z
+date: 2012-06-24 00:00:00.000000000 Z
 dependencies: []
 description: A ruby based library of Maching Learning (ML) algorithms
 email:
@@ -21,18 +21,50 @@ extensions:
 - ext/ml4r/extconf.rb
 extra_rdoc_files: []
 files:
+- lib/ml4r/linear_regression.rb
 - lib/ml4r.rb
 - lib/test_cpp_extension.rb
-- ext/ml4r/swig/example_wrap.c
-- ext/ml4r/example.h
-- ext/ml4r/LinearRegression/ZenithRegression.h
-- ext/ml4r/LinearRegression.h
-- ext/ml4r/MathUtils.h
-- ext/ml4r/MatrixInversion.h
-- ext/ml4r/OLSLinearRegression.h
-- ext/ml4r/swig/example.h
-- ext/ml4r/utils/RubyUtils.h
-- ext/ml4r/Utils.h
+- ext/ml4r/LinearRegression/LinearRegression.h
+- ext/ml4r/LinearRegression/OLSLinearRegression.h
+- ext/ml4r/MachineLearning/DecisionTree/CategoryInfo.h
+- ext/ml4r/MachineLearning/DecisionTree/DecisionTreeExperiment.h
+- ext/ml4r/MachineLearning/DecisionTree/DecisionTreeNode.h
+- ext/ml4r/MachineLearning/DecisionTree/FeatureInteraction.h
+- ext/ml4r/MachineLearning/DecisionTree/NodeSplitter.h
+- ext/ml4r/MachineLearning/DecisionTree/NodeSplitterCategorical.h
+- ext/ml4r/MachineLearning/DecisionTree/NodeSplitterContinuous.h
+- ext/ml4r/MachineLearning/DecisionTree/SplitDefinition.h
+- ext/ml4r/MachineLearning/GBM/BernoulliCalculator.h
+- ext/ml4r/MachineLearning/GBM/GaussianCalculator.h
+- ext/ml4r/MachineLearning/GBM/GBM.h
+- ext/ml4r/MachineLearning/GBM/GBMCalculator.h
+- ext/ml4r/MachineLearning/GBM/GBMData.h
+- ext/ml4r/MachineLearning/GBM/GBMEstimator.h
+- ext/ml4r/MachineLearning/GBM/GBMOutput.h
+- ext/ml4r/MachineLearning/GBM/GBMParameters.h
+- ext/ml4r/MachineLearning/GBM/GBMRunner.h
+- ext/ml4r/MachineLearning/GBM/ZenithGBM.h
+- ext/ml4r/MachineLearning/MLData/MLData.h
+- ext/ml4r/MachineLearning/MLData/MLDataFields.h
+- ext/ml4r/MachineLearning/MLData/MLDataReader.h
+- ext/ml4r/MachineLearning/MLData/ZenithMLData.h
+- ext/ml4r/MachineLearning/MLData/ZenithMLDataReader.h
+- ext/ml4r/MachineLearning/MLEstimator.h
+- ext/ml4r/MachineLearning/MLEstimatorFactory.h
+- ext/ml4r/MachineLearning/MLExperiment.h
+- ext/ml4r/MachineLearning/MLOutput.h
+- ext/ml4r/MachineLearning/MLParameters.h
+- ext/ml4r/MachineLearning/MLRunner.h
+- ext/ml4r/MachineLearning/MLUtils.h
+- ext/ml4r/MachineLearning/RandomForest/RandomForestEstimator.h
+- ext/ml4r/MachineLearning/RandomForest/RandomForestOutput.h
+- ext/ml4r/MachineLearning/RandomForest/RandomForestParameters.h
+- ext/ml4r/MachineLearning/RandomForest/RandomForestRunner.h
+- ext/ml4r/utils/MathUtils.h
+- ext/ml4r/utils/MatrixInversion.h
+- ext/ml4r/utils/StochasticUtils.h
+- ext/ml4r/utils/Utils.h
+- ext/ml4r/utils/VlcMessage.h
 - ext/ml4r/extconf.rb
 homepage: https://github.com/vlc/ml4r
 licenses: []
@@ -54,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A ruby based library of Maching Learning (ML) algorithms

data/ext/ml4r/LinearRegression/ZenithRegression.h

@@ -1,17 +0,0 @@
-#ifndef ZenithRegression_h__
-#define ZenithRegression_h__
-
-// ruby interface methods
-void  zenith_regression_Free(void* v);
-static VALUE zenith_regression_New(int argc, VALUE* argv, VALUE klass);
-static VALUE zenith_regression_Initialize(VALUE self);
-
-static VALUE zenith_regression_observations(VALUE self, VALUE obs);
-static VALUE zenith_regression_weights(VALUE self, VALUE wgts);
-static VALUE zenith_regression_setFixedConstant(VALUE self, VALUE obs);
-static VALUE zenith_regression_execute(VALUE self);
-static VALUE zenith_regression_getFittedYs(VALUE self);
-static VALUE zenith_regression_getPredictedYs(VALUE self);
-static VALUE zenith_regression_getRegressionStatistics(VALUE self);
-
-#endif // ZenithRegression_h__

data/ext/ml4r/OLSLinearRegression.h

@@ -1,23 +0,0 @@
-#ifndef OLSLinearRegression_h__
-#define OLSLinearRegression_h__
-
-#include "LinearRegression.h"
-
-class OLSLinearRegression : public LinearRegression
-{
-public:
-	OLSLinearRegression();
-	~OLSLinearRegression();
-
-    void Execute();
-
-    void EstimateBs();
-
-protected:
-	
-private:
-};
-
-
-
-#endif // OLSLinearRegression_h__