ruby-spark 1.0.0

data/lib/spark/mllib/regression/common.rb

@@ -0,0 +1,73 @@
+module Spark
+  module Mllib
+    ##
+    # RegressionModel
+    #
+    # A linear model that has a vector of coefficients and an intercept.
+    #
+    class RegressionModel
+
+      attr_reader :weights, :intercept
+
+      def initialize(weights, intercept)
+        @weights = Spark::Mllib::Vectors.to_vector(weights)
+        @intercept = intercept.to_f
+      end
+
+      # Predict the value of the dependent variable given a vector data
+      # containing values for the independent variables.
+      #
+      # == Examples:
+      #   lm = RegressionModel.new([1.0, 2.0], 0.1)
+      #
+      #   lm.predict([-1.03, 7.777]) - 14.624 < 1e-6
+      #   # => true
+      #
+      #   lm.predict(SparseVector.new(2, {0 => -1.03, 1 => 7.777})) - 14.624 < 1e-6
+      #   # => true
+      #
+      def predict(data)
+        data = Spark::Mllib::Vectors.to_vector(data)
+        @weights.dot(data) + @intercept
+      end
+
+    end
+  end
+end
+
+
+module Spark
+  module Mllib
+    ##
+    # RegressionMethodBase
+    #
+    # Parent for regression methods
+    #
+    class RegressionMethodBase
+
+      def self.train(rdd, options)
+        # String keys to symbols
+        options.symbolize_keys!
+
+        # Reverse merge
+        self::DEFAULT_OPTIONS.each do |key, value|
+          if options.has_key?(key)
+            # value from user
+          else
+            options[key] = value
+          end
+        end
+
+        # Validation
+        first = rdd.first
+        unless first.is_a?(LabeledPoint)
+          raise Spark::MllibError, "RDD should contains LabeledPoint, got #{first.class}"
+        end
+
+        # Initial weights is optional for user (not for Spark)
+        options[:initial_weights] = Vectors.to_vector(options[:initial_weights] || [0.0] * first.features.size)
+      end
+
+    end
+  end
+end

data/lib/spark/mllib/regression/labeled_point.rb

@@ -0,0 +1,41 @@
+module Spark
+  module Mllib
+    ##
+    # LabeledPoint
+    #
+    # The features and labels of a data point.
+    #
+    # == Parameters:
+    # label::
+    #   Label for this data point.
+    #
+    # features::
+    #   Vector of features for this point
+    #
+    class LabeledPoint
+
+      attr_reader :label, :features
+
+      def initialize(label, features)
+        @label = label.to_f
+        @features = Spark::Mllib::Vectors.to_vector(features)
+      end
+
+      def self.from_java(object)
+        LabeledPoint.new(
+          object.label,
+          Spark.jb.java_to_ruby(object.features)
+        )
+      end
+
+      def marshal_dump
+        [@label, @features]
+      end
+
+      def marshal_load(array)
+        initialize(array[0], array[1])
+      end
+
+    end
+  end
+end

data/lib/spark/mllib/regression/lasso.rb

@@ -0,0 +1,100 @@
+##
+# LassoModel
+#
+# Train a regression model with L1-regularization using Stochastic Gradient Descent.
+# This solves the l1-regularized least squares regression formulation
+#   f(weights) = 1/2n ||A weights-y||^2^  + regParam ||weights||_1
+# Here the data matrix has n rows, and the input RDD holds the set of rows of A, each with
+# its corresponding right hand side label y.
+# See also the documentation for the precise formulation.
+#
+# == Examples:
+#
+#   Spark::Mllib.import
+#
+#   # Dense vectors
+#   data = [
+#       LabeledPoint.new(0.0, [0.0]),
+#       LabeledPoint.new(1.0, [1.0]),
+#       LabeledPoint.new(3.0, [2.0]),
+#       LabeledPoint.new(2.0, [3.0])
+#   ]
+#   lrm = LassoWithSGD.train($sc.parallelize(data), initial_weights: [1.0])
+#
+#   lrm.predict([0.0]) - 0 < 0.5
+#   # => true
+#
+#   lrm.predict([1.0]) - 1 < 0.5
+#   # => true
+#
+#   lrm.predict(SparseVector.new(1, {0 => 1.0})) - 1 < 0.5
+#   # => true
+#
+#
+#   # Sparse vectors
+#   data = [
+#       LabeledPoint.new(0.0, SparseVector.new(1, {0 => 0.0})),
+#       LabeledPoint.new(1.0, SparseVector.new(1, {0 => 1.0})),
+#       LabeledPoint.new(3.0, SparseVector.new(1, {0 => 2.0})),
+#       LabeledPoint.new(2.0, SparseVector.new(1, {0 => 3.0}))
+#   ]
+#   lrm = LinearRegressionWithSGD.train($sc.parallelize(data), initial_weights: [1.0])
+#
+#   lrm.predict([0.0]) - 0 < 0.5
+#   # => true
+#
+#   lrm.predict(SparseVector.new(1, {0 => 1.0})) - 1 < 0.5
+#   # => true
+#
+class Spark::Mllib::LassoModel < Spark::Mllib::RegressionModel
+end
+
+module Spark
+  module Mllib
+    class LassoWithSGD < RegressionMethodBase
+
+      DEFAULT_OPTIONS = {
+        iterations: 100,
+        step: 1.0,
+        reg_param: 0.01,
+        mini_batch_fraction: 1.0,
+        initial_weights: nil
+      }
+
+      # Train a Lasso regression model on the given data.
+      #
+      # == Parameters:
+      # rdd::
+      #   The training data (RDD instance).
+      #
+      # iterations::
+      #   The number of iterations (default: 100).
+      #
+      # step::
+      #   The step parameter used in SGD (default: 1.0).
+      #
+      # reg_param::
+      #   The regularizer parameter (default: 0.0).
+      #
+      # mini_batch_fraction::
+      #   Fraction of data to be used for each SGD iteration (default: 1.0).
+      #
+      # initial_weights::
+      #   The initial weights (default: nil).
+      #
+      def self.train(rdd, options={})
+        super
+
+        weights, intercept = Spark.jb.call(RubyMLLibAPI.new, 'trainLassoModelWithSGD', rdd,
+                                           options[:iterations].to_i,
+                                           options[:step].to_f,
+                                           options[:reg_param].to_f,
+                                           options[:mini_batch_fraction].to_f,
+                                           options[:initial_weights])
+
+        LassoModel.new(weights, intercept)
+      end
+
+    end
+  end
+end

data/lib/spark/mllib/regression/linear.rb

@@ -0,0 +1,124 @@
+##
+# LinearRegressionModel
+#
+# Train a linear regression model with no regularization using Stochastic Gradient Descent.
+# This solves the least squares regression formulation
+#   f(weights) = 1/n ||A weights-y||^2^
+# (which is the mean squared error).
+# Here the data matrix has n rows, and the input RDD holds the set of rows of A, each with
+# its corresponding right hand side label y.
+# See also the documentation for the precise formulation.
+#
+# == Examples:
+#
+#   Spark::Mllib.import
+#
+#   # Dense vectors
+#   data = [
+#     LabeledPoint.new(0.0, [0.0]),
+#     LabeledPoint.new(1.0, [1.0]),
+#     LabeledPoint.new(3.0, [2.0]),
+#     LabeledPoint.new(2.0, [3.0])
+#   ]
+#   lrm = LinearRegressionWithSGD.train($sc.parallelize(data), initial_weights: [1.0])
+#
+#   lrm.intercept # => 0.0
+#   lrm.weights   # => [0.9285714285714286]
+#
+#   lrm.predict([0.0]) < 0.5
+#   # => true
+#
+#   lrm.predict([1.0]) - 1 < 0.5
+#   # => true
+#
+#   lrm.predict(SparseVector.new(1, {0 => 1.0})) - 1 < 0.5
+#   # => true
+#
+#   # Sparse vectors
+#   data = [
+#     LabeledPoint.new(0.0, SparseVector.new(1, {0 => 0.0})),
+#     LabeledPoint.new(1.0, SparseVector.new(1, {0 => 1.0})),
+#     LabeledPoint.new(3.0, SparseVector.new(1, {0 => 2.0})),
+#     LabeledPoint.new(2.0, SparseVector.new(1, {0 => 3.0}))
+#   ]
+#   lrm = LinearRegressionWithSGD.train($sc.parallelize(data), initial_weights: [1.0])
+#
+#   lrm.intercept # => 0.0
+#   lrm.weights   # => [0.9285714285714286]
+#
+#   lrm.predict([0.0]) < 0.5
+#   # => true
+#
+#   lrm.predict(SparseVector.new(1, {0 => 1.0})) - 1 < 0.5
+#   # => true
+#
+class Spark::Mllib::LinearRegressionModel < Spark::Mllib::RegressionModel
+end
+
+module Spark
+  module Mllib
+    class LinearRegressionWithSGD < RegressionMethodBase
+
+      DEFAULT_OPTIONS = {
+        iterations: 100,
+        step: 1.0,
+        mini_batch_fraction: 1.0,
+        initial_weights: nil,
+        reg_param: 0.0,
+        reg_type: nil,
+        intercept: false
+      }
+
+      # Train a linear regression model on the given data.
+      #
+      # == Parameters:
+      # rdd::
+      #   The training data (RDD instance).
+      #
+      # iterations::
+      #   The number of iterations (default: 100).
+      #
+      # step::
+      #   The step parameter used in SGD (default: 1.0).
+      #
+      # mini_batch_fraction::
+      #   Fraction of data to be used for each SGD iteration (default: 1.0).
+      #
+      # initial_weights::
+      #   The initial weights (default: nil).
+      #
+      # reg_param::
+      #   The regularizer parameter (default: 0.0).
+      #
+      # reg_type::
+      #   The type of regularizer used for training our model (default: nil).
+      #
+      #   Allowed values:
+      #   - "l1" for using L1 regularization (lasso),
+      #   - "l2" for using L2 regularization (ridge),
+      #   - None for no regularization
+      #
+      # intercept::
+      #   Boolean parameter which indicates the use
+      #   or not of the augmented representation for
+      #   training data (i.e. whether bias features
+      #   are activated or not). (default: False)
+      #
+      def self.train(rdd, options={})
+        super
+
+        weights, intercept = Spark.jb.call(RubyMLLibAPI.new, 'trainLinearRegressionModelWithSGD', rdd,
+                                           options[:iterations].to_i,
+                                           options[:step].to_f,
+                                           options[:mini_batch_fraction].to_f,
+                                           options[:initial_weights],
+                                           options[:reg_param].to_f,
+                                           options[:reg_type],
+                                           options[:intercept])
+
+        LinearRegressionModel.new(weights, intercept)
+      end
+
+    end
+  end
+end

data/lib/spark/mllib/regression/ridge.rb

@@ -0,0 +1,97 @@
+##
+# RidgeRegressionModel
+#
+# Train a regression model with L2-regularization using Stochastic Gradient Descent.
+# This solves the l1-regularized least squares regression formulation
+#   f(weights) = 1/2n ||A weights-y||^2^  + regParam/2 ||weights||^2^
+# Here the data matrix has n rows, and the input RDD holds the set of rows of A, each with
+# its corresponding right hand side label y.
+# See also the documentation for the precise formulation.
+#
+# == Examples:
+#
+#   Spark::Mllib.import
+#
+#   data = [
+#       LabeledPoint.new(0.0, [0.0]),
+#       LabeledPoint.new(1.0, [1.0]),
+#       LabeledPoint.new(3.0, [2.0]),
+#       LabeledPoint.new(2.0, [3.0])
+#   ]
+#   lrm = RidgeRegressionWithSGD.train($sc.parallelize(data), initial_weights: [1.0])
+#
+#   lrm.predict([0.0]) - 0 < 0.5
+#   # => true
+#
+#   lrm.predict([1.0]) - 1 < 0.5
+#   # => true
+#
+#   lrm.predict(SparseVector.new(1, {0 => 1.0})) - 1 < 0.5
+#   # => true
+#
+#   data = [
+#       LabeledPoint.new(0.0, SparseVector.new(1, {0 => 0.0})),
+#       LabeledPoint.new(1.0, SparseVector.new(1, {0 => 1.0})),
+#       LabeledPoint.new(3.0, SparseVector.new(1, {0 => 2.0})),
+#       LabeledPoint.new(2.0, SparseVector.new(1, {0 => 3.0}))
+#   ]
+#   lrm = LinearRegressionWithSGD.train($sc.parallelize(data), initial_weights: [1.0])
+#
+#   lrm.predict([0.0]) - 0 < 0.5
+#   # => true
+#
+#   lrm.predict(SparseVector.new(1, {0 => 1.0})) - 1 < 0.5
+#   # => true
+#
+class Spark::Mllib::RidgeRegressionModel < Spark::Mllib::RegressionModel
+end
+
+module Spark
+  module Mllib
+    class RidgeRegressionWithSGD < RegressionMethodBase
+
+      DEFAULT_OPTIONS = {
+        iterations: 100,
+        step: 1.0,
+        reg_param: 0.01,
+        mini_batch_fraction: 1.0,
+        initial_weights: nil
+      }
+
+      # Train a ridge regression model on the given data.
+      #
+      # == Parameters:
+      # rdd::
+      #   The training data (RDD instance).
+      #
+      # iterations::
+      #   The number of iterations (default: 100).
+      #
+      # step::
+      #   The step parameter used in SGD (default: 1.0).
+      #
+      # reg_param::
+      #   The regularizer parameter (default: 0.0).
+      #
+      # mini_batch_fraction::
+      #   Fraction of data to be used for each SGD iteration (default: 1.0).
+      #
+      # initial_weights::
+      #   The initial weights (default: nil).
+      #
+      def self.train(rdd, options={})
+        super
+
+        weights, intercept = Spark.jb.call(RubyMLLibAPI.new, 'trainRidgeModelWithSGD', rdd,
+                                           options[:iterations].to_i,
+                                           options[:step].to_f,
+                                           options[:reg_param].to_f,
+                                           options[:mini_batch_fraction].to_f,
+                                           options[:initial_weights])
+
+        RidgeRegressionModel.new(weights, intercept)
+      end
+
+    end
+  end
+end

data/lib/spark/mllib/ruby_matrix/matrix_adapter.rb

@@ -0,0 +1,53 @@
+require 'matrix'
+
+module Spark
+  module Mllib
+    class MatrixAdapter < ::Matrix
+
+      def self.new(*args)
+        object = self.allocate
+
+        if args.size == 2
+          # Matrix is initialized from Matrix
+          # Arguments: rows, column count
+          object.__send__(:original_initialize, *args)
+        else
+          object.__send__(:initialize, *args)
+        end
+
+        object
+      end
+
+      alias_method :original_initialize, :initialize
+
+      def initialize(type, rows, cols, values=nil)
+        case type
+        when :dense
+          values = values.dup
+          if rows * cols == values.size
+            # Values are on one row
+            # 2x2 => [1,2,3,4]
+            values = values.each_slice(cols).to_a
+          else
+            # 2x2 => [[1,2], [3,4]]
+          end
+        when :sparse
+          values = Array.new(rows) { Array.new(cols) { 0.0 } }
+        else
+          raise Spark::MllibError, 'Unknow vector type.'
+        end
+
+        super(values, cols)
+      end
+
+      def shape
+        [row_count, column_count]
+      end
+
+      def values
+        @values || to_a
+      end
+
+    end
+  end
+end