statsample-ekatena 2.0.2

data/lib/statsample-ekatena/regression/multiple/alglibengine.rb

@@ -0,0 +1,128 @@
+if HAS_ALGIB
+module Statsample
+module Regression
+module Multiple
+# Class for Multiple Regression Analysis
+# Requires Alglib gem and uses a listwise aproach.
+# Faster than GslEngine on massive prediction use, because process is c-based.
+# Prefer GslEngine if you need good memory use.
+# If you need pairwise, use RubyEngine
+# Example:
+#
+#   @a = Daru::Vector.new([1,3,2,4,3,5,4,6,5,7])
+#   @b = Daru::Vector.new([3,3,4,4,5,5,6,6,4,4])
+#   @c = Daru::Vector.new([11,22,30,40,50,65,78,79,99,100])
+#   @y = Daru::Vector.new([3,4,5,6,7,8,9,10,20,30])
+#   ds = Daru::DataFrame.new({:a => @a,:b => @b,:c => @c,:y => @y})
+#   lr=Statsample::Regression::Multiple::AlglibEngine.new(ds, :y)
+#            
+class AlglibEngine < BaseEngine
+  def initialize(ds,y_var, opts=Hash.new)
+    super    
+    @ds       = ds.reject_values(*Daru::MISSING_VALUES)
+    @ds_valid = @ds
+    @dy       = @ds[@y_var]
+    @ds_indep = ds.dup(ds.vectors.to_a - [y_var])
+    # Create a custom matrix
+    columns = []
+    @fields = []
+    @ds.vectors.each do |f|
+      if f != @y_var
+        columns.push(@ds[f].to_a)
+        @fields.push(f)
+      end
+    end
+    @dep_columns = columns.dup
+    columns.push(@ds[@y_var])
+    matrix=Matrix.columns(columns)
+    @lr_s=nil
+    @lr=::Alglib::LinearRegression.build_from_matrix(matrix)
+    @coeffs=assign_names(@lr.coeffs)
+  end
+    
+  def _dump(i)
+    Marshal.dump({'ds'=>@ds,'y_var'=>@y_var})
+  end
+
+  def self._load(data)
+    h=Marshal.load(data)
+    self.new(h['ds'], h['y_var'])
+  end
+      
+  def coeffs
+    @coeffs
+  end
+  # Coefficients using a constant
+  # Based on http://www.xycoon.com/ols1.htm
+  def matrix_resolution
+    mse_p=mse
+    columns=@dep_columns.dup.map {|xi| xi.map{|i| i.to_f}}
+    columns.unshift([1.0]*@ds.cases)
+    y=Matrix.columns([@dy.data.map  {|i| i.to_f}])
+    x=Matrix.columns(columns)
+    xt=x.t
+    matrix=((xt*x)).inverse*xt
+    matrix*y
+  end
+
+  def r2
+    r**2
+  end
+
+  def r
+    Bivariate::pearson(@dy,predicted)
+  end  
+
+  def sst
+    @dy.ss
+  end
+
+  def constant
+    @lr.constant
+  end
+
+  def standarized_coeffs
+    l=lr_s
+    assign_names(l.coeffs)
+  end
+
+  def lr_s
+    if @lr_s.nil?
+      build_standarized
+    end
+    @lr_s
+  end
+
+  def build_standarized
+    @ds_s=@ds.standardize
+    columns=[]
+    @ds_s.vectors.each{|f|
+      columns.push(@ds_s[f].to_a) unless f == @y_var
+    }
+    @dep_columns_s=columns.dup
+    columns.push(@ds_s[@y_var])
+    matrix=Matrix.columns(columns)
+    @lr_s=Alglib::LinearRegression.build_from_matrix(matrix)
+  end
+
+  def process(v)
+    @lr.process(v)
+  end
+
+  def process_s(v)
+    lr_s.process(v)
+  end
+  # ???? Not equal to SPSS output
+  def standarized_residuals
+    res    = residuals
+    red_sd = residuals.sds
+    Daru::Vector.new(res.collect {|v| v.quo(red_sd) })
+  end
+end
+end
+end
+end # for Statsample
+end # for if
+
+        
+

data/lib/statsample-ekatena/regression/multiple/baseengine.rb

@@ -0,0 +1,251 @@
+module Statsample
+  module Regression
+    module Multiple
+      # Base class for Multiple Regression Engines
+      class BaseEngine
+        include Statsample::Summarizable
+        # Name of analysis
+        attr_accessor :name
+        # Minimum number of  valid case for pairs of correlation
+        attr_reader :cases
+        # Number of valid cases (listwise)
+        attr_reader :valid_cases
+        # Number of total cases (dataset.cases)
+        attr_reader :total_cases
+        
+        attr_accessor :digits
+        def self.univariate?
+          true
+        end
+        def initialize(ds, y_var, opts = Hash.new)
+          @ds=ds
+          @predictors_n=@ds.vectors.size-1
+          @total_cases=@ds.nrows
+          @cases=@ds.nrows
+          @y_var=y_var
+          @r2=nil
+          @name=_("Multiple Regression:  %s over %s") % [ ds.vectors.to_a.join(",") , @y_var]
+          
+          opts_default={:digits=>3}
+          @opts=opts_default.merge opts
+          
+          @opts.each{|k,v|
+            self.send("#{k}=",v) if self.respond_to? k
+          }
+        end
+        # Calculate F Test
+        def anova
+          @anova||=Statsample::Anova::OneWay.new(:ss_num=>ssr, :ss_den=>sse, :df_num=>df_r, :df_den=>df_e, :name_numerator=>_("Regression"), :name_denominator=>_("Error"), :name=>"ANOVA")
+        end
+        # Standard error of estimate
+        def se_estimate
+          Math::sqrt(sse.quo(df_e))
+        end
+        # Retrieves a vector with predicted values for y
+        def predicted
+          Daru::Vector.new(
+            @total_cases.times.collect do |i|
+              invalid = false
+              vect = @dep_columns.collect {|v| invalid = true if v[i].nil?; v[i]}
+              if invalid
+                nil
+              else
+                process(vect)
+              end
+            end
+          )
+        end
+        # Retrieves a vector with standarized values for y
+        def standarized_predicted
+          predicted.standarized
+        end
+        # Retrieves a vector with residuals values for y
+        def residuals
+          Daru::Vector.new(
+            (0...@total_cases).collect do |i|
+              invalid=false
+              vect=@dep_columns.collect{|v| invalid=true if v[i].nil?; v[i]}
+              if invalid or @ds[@y_var][i].nil?
+                nil
+              else
+                @ds[@y_var][i] - process(vect)
+              end
+            end
+          )
+        end
+        # R Multiple
+        def r
+          raise "You should implement this"
+        end
+        # Sum of squares Total
+        def sst
+          raise "You should implement this"
+        end
+        # R^2 Adjusted.
+        # Estimate Population R^2 usign Ezequiel formula.
+        # Always lower than sample R^2
+        # == Reference:
+        # * Leach, L. & Henson, R. (2007). The Use and Impact of Adjusted R2 Effects in Published Regression Research. Multiple Linear Regression Viewpoints, 33(1), 1-11.
+        def r2_adjusted
+          r2-((1-r2)*@predictors_n).quo(df_e)
+        end
+        # Sum of squares (regression)
+        def ssr
+          r2*sst
+        end
+        # Sum of squares (Error)
+        def sse
+          sst - ssr
+        end
+        # T values for coeffs
+        def coeffs_t
+          out={}
+          se=coeffs_se
+          coeffs.each do |k,v|
+            out[k]=v / se[k]
+          end
+          out
+        end
+        # Mean square Regression
+        def msr
+          ssr.quo(df_r)
+        end
+        # Mean Square Error
+        def mse
+          sse.quo(df_e)
+        end
+        # Degrees of freedom for regression
+        def df_r
+          @predictors_n
+        end
+        # Degrees of freedom for error
+        def df_e
+          @valid_cases-@predictors_n-1
+        end
+        # Fisher for Anova
+        def f
+          anova.f
+        end
+        # p-value of Fisher
+        def probability
+          anova.probability
+        end
+        # Tolerance for a given variable
+        # http://talkstats.com/showthread.php?t=5056
+        def tolerance(var)
+          ds = assign_names(@dep_columns)
+          ds.each { |k,v| ds[k] = Daru::Vector.new(v) }
+          lr = self.class.new(Daru::DataFrame.new(ds),var)
+          1 - lr.r2
+        end
+        # Tolerances for each coefficient
+        def coeffs_tolerances
+          @fields.inject({}) {|a,f|
+          a[f]=tolerance(f);
+            a
+          }
+        end
+        # Standard Error for coefficients
+        def coeffs_se
+          out={}
+          mse=sse.quo(df_e)
+          coeffs.each {|k,v|
+            out[k]=Math::sqrt(mse/(@ds[k].sum_of_squares * tolerance(k)))
+          }
+          out
+        end
+        # Estandar error of R^2
+        # ????
+        def se_r2
+          Math::sqrt((4*r2*(1-r2)**2*(df_e)**2).quo((@cases**2-1)*(@cases+3)))
+        end
+         
+        # Estimated Variance-Covariance Matrix
+        # Used for calculation of se of constant
+        def estimated_variance_covariance_matrix
+          #mse_p=mse
+          columns=[]
+          @ds_valid.vectors.each{|k|
+            v = @ds_valid[k]
+            columns.push(v.to_a) unless k == @y_var
+          }
+          columns.unshift([1.0]*@valid_cases)
+          x=::Matrix.columns(columns)
+          matrix=((x.t*x)).inverse * mse
+          matrix.collect {|i| Math::sqrt(i) if i>=0 }
+        end
+        # T for constant
+        def constant_t
+          constant.to_f/constant_se
+        end
+        # Standard error for constant
+        def constant_se
+          estimated_variance_covariance_matrix[0,0]
+        end
+        def report_building(b)
+          di="%0.#{digits}f"
+          b.section(:name=>@name) do |g|
+            c=coeffs
+            g.text _("Engine: %s") % self.class
+            g.text(_("Cases(listwise)=%d(%d)") % [@total_cases, @valid_cases])
+            g.text _("R=")+(di % r)
+            g.text _("R^2=")+(di % r2)
+            g.text _("R^2 Adj=")+(di % r2_adjusted)
+            g.text _("Std.Error R=")+ (di % se_estimate)
+            
+            g.text(_("Equation")+"="+ sprintf(di,constant) +" + "+ @fields.collect {|k| sprintf("#{di}%s",c[k],k)}.join(' + ') )
+            
+            g.parse_element(anova)
+            sc=standarized_coeffs
+            
+            cse=coeffs_se
+            g.table(:name=>_("Beta coefficients"), :header=>%w{coeff b beta se t}.collect{|field| _(field)} ) do |t|
+				t.row([_("Constant"), sprintf(di, constant), "-", constant_se.nil? ? "": sprintf(di, constant_se), constant_t.nil? ? "" : sprintf(di, constant_t)])
+              @fields.each do |f|
+                t.row([f, sprintf(di, c[f]), sprintf(di, sc[f]), sprintf(di, cse[f]), sprintf(di, c[f].quo(cse[f]))])
+              end  
+            end
+          end
+        end
+        
+        
+        def assign_names(c)
+          a={}
+          @fields.each_index {|i|
+            a[@fields[i]]=c[i]
+          }
+          a
+        end
+
+        # Sum of squares of regression
+        # using the predicted value minus y mean
+        def ssr_direct
+          mean=@dy.mean
+          cases=0
+          ssr=(0...@ds.cases).inject(0) {|a,i|
+            invalid=false
+            v=@dep_columns.collect{|c| invalid=true if c[i].nil?; c[i]}
+            if !invalid
+              cases+=1
+              a+((process(v)-mean)**2)
+            else
+              a
+            end
+          }
+          ssr
+        end
+        def sse_direct
+          sst-ssr
+        end
+        def process(v)
+          c=coeffs
+          total=constant
+          @fields.each_index{|i|
+            total+=c[@fields[i]]*v[i]
+          }
+          total
+        end
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/regression/multiple/gslengine.rb

@@ -0,0 +1,129 @@
+if Statsample.has_gsl?
+  module Statsample
+    module Regression
+      module Multiple
+        # Class for Multiple Regression Analysis
+        # Requires rbgsl and uses a listwise aproach.
+        # Slower on prediction of values than Alglib, because predict is ruby based.
+        # Better memory management on multiple (+1000) series of regression.
+        # If you need pairwise, use RubyEngine
+        # Example:
+        #
+        #   @a = Daru::Vector.new([1,3,2,4,3,5,4,6,5,7])
+        #   @b = Daru::Vector.new([3,3,4,4,5,5,6,6,4,4])
+        #   @c = Daru::Vector.new([11,22,30,40,50,65,78,79,99,100])
+        #   @y = Daru::Vector.new([3,4,5,6,7,8,9,10,20,30])
+        #   ds = Daru::DataFrame.new({:a => @a,:b => @b,:c => @c,:y => @y})
+        #   lr=Statsample::Regression::Multiple::GslEngine.new(ds,:y)
+        #
+        class GslEngine < BaseEngine
+          def initialize(ds,y_var, opts=Hash.new)
+            super
+            @ds          = ds.reject_values(*Daru::MISSING_VALUES)
+            @ds_valid    = @ds
+            @valid_cases = @ds_valid.nrows
+            @dy          = @ds[@y_var]
+            @ds_indep    = ds.dup(ds.vectors.to_a - [y_var])
+            # Create a custom matrix
+            columns=[]
+            @fields=[]
+            max_deps = GSL::Matrix.alloc(@ds.nrows, @ds.vectors.size)
+            constant_col=@ds.vectors.size-1
+            for i in 0...@ds.nrows
+              max_deps.set(i,constant_col,1)
+            end
+            j = 0
+            @ds.vectors.each do |f|
+              if f != @y_var
+                @ds[f].each_index do |i1|
+                  max_deps.set(i1,j,@ds[f][i1])
+                end
+
+                columns.push(@ds[f].to_a)
+                @fields.push(f)
+                j += 1
+              end
+            end
+            @dep_columns = columns.dup
+            @lr_s        = nil
+            c, @cov, @chisq, @status = GSL::MultiFit.linear(max_deps, @dy.to_gsl)
+            @constant=c[constant_col]
+            @coeffs_a=c.to_a.slice(0...constant_col)
+            @coeffs=assign_names(@coeffs_a)
+            c=nil
+          end
+
+          def _dump(i)
+            Marshal.dump({'ds'=>@ds,'y_var'=>@y_var})
+          end
+          def self._load(data)
+            h=Marshal.load(data)
+            self.new(h['ds'], h['y_var'])
+          end
+
+          def coeffs
+            @coeffs
+          end
+          # Coefficients using a constant
+          # Based on http://www.xycoon.com/ols1.htm
+          def matrix_resolution
+            columns=@dep_columns.dup.map {|xi| xi.map{|i| i.to_f}}
+            columns.unshift([1.0]*@ds.cases)
+            y=Matrix.columns([@dy.data.map  {|i| i.to_f}])
+            x=Matrix.columns(columns)
+            xt=x.t
+            matrix=((xt*x)).inverse*xt
+            matrix*y
+          end
+          def r2
+            r**2
+          end
+          def r
+            Bivariate::pearson(@dy, predicted)
+          end
+          def sst
+            @dy.ss
+          end
+          def constant
+            @constant
+          end
+          def standarized_coeffs
+            l=lr_s
+            l.coeffs
+          end
+          def lr_s
+            if @lr_s.nil?
+              build_standarized
+            end
+            @lr_s
+          end
+          def build_standarized
+            @ds_s=@ds.standardize
+            @lr_s=GslEngine.new(@ds_s,@y_var)
+          end
+          def process_s(v)
+            lr_s.process(v)
+          end
+          # ???? Not equal to SPSS output
+          def standarized_residuals
+            res=residuals
+            red_sd=residuals.sds
+            Daru::Vector.new(res.collect {|v| v.quo(red_sd) })
+          end
+
+          # Standard error for coeffs
+          def coeffs_se
+            out  = {}
+            evcm = estimated_variance_covariance_matrix
+            @ds_valid.vectors.to_a.each_with_index do |f,i|
+              mi = i+1
+              next if f == @y_var
+              out[f] = evcm[mi,mi]
+            end
+            out
+          end
+        end
+      end
+    end
+  end # for Statsample
+end # for if