statsample 0.3.0 → 0.3.1

data/lib/statsample/regression/multiple.rb

@@ -0,0 +1,259 @@
+module Statsample
+module Regression
+        # Module for Multiple Regression Analysis
+        # You can call Regression::Multiple.listwise or Regression::Multiple.pairwise or instance directly the engines
+        # Example.
+        #
+        #  require 'statsample'
+        #  @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
+        #  @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
+        #  @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
+        #  @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
+        #  ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
+        #  lr=Statsample::Regression::Multiple.listwise(ds,'y')        
+        #  #<Statsample::Regression::Multiple::AlglibEngine:0x7f21912e4758 @ds_valid=#<Statsample::Dataset:69891073182680 @fields=[a,b,c,y] labels={"a"=>nil, "b"=>nil, "y"=>nil, "c"=>nil} cases=10, @lr=#<Alglib::LinearRegression:0x7f21912df118 @model=#<Alglib_ext::LinearModel:0x7f21912df708>, @ivars=3, @cases=10, @report=#<Alglib_ext::LrReport:0x7f21912df168>>, @y_var="y", @ds=#<Statsample::Dataset:69891073182680 @fields=[a,b,c,y] labels={"a"=>nil, "b"=>nil, "y"=>nil, "c"=>nil} cases=10, @fields=["a", "b", "c"], @lr_s=nil, @dep_columns=[[1, 3, 2, 4, 3, 5, 4, 6, 5, 7], [3, 3, 4, 4, 5, 5, 6, 6, 4, 4], [11, 22, 30, 40, 50, 65, 78, 79, 99, 100]], @ds_indep=#<Statsample::Dataset:69891073180060 @fields=[a,b,c] labels={"a"=>nil, "b"=>nil, "c"=>nil} cases=10, @dy=Vector(type:scale, n:10)[3,4,5,6,7,8,9,10,20,30]>
+        
+        
+module Multiple
+    # Creates an object for listwise regression. According to resources
+    # select the best engine
+    #   lr=Statsample::Regression::Multiple.listwise(ds,'y')
+    def self.listwise(ds,y_var)
+        if HAS_ALGIB
+            AlglibEngine.new(ds,y_var)
+        else
+            ds2=ds.dup_only_valid
+            RubyEngine.new(ds2,y_var)
+        end
+    end
+    
+    # Creates an object for pairwise regression
+    # For now, always retrieves a RubyEngine
+    #    lr=Statsample::Regression::Multiple.listwise(ds,'y')
+    def self.pairwise(ds,y_var)
+        RubyEngine.new(ds,y_var)
+    end
+
+    # Base class for Multiple Regression Engines
+    class BaseEngine
+    def initialize(ds,y_var)
+        @ds=ds
+        @y_var=y_var
+        @r2=nil
+    end
+    
+    # Retrieves a vector with predicted values for y
+    def predicted
+        (0...@ds.cases).collect { |i|
+            invalid=false
+            vect=@dep_columns.collect {|v| invalid=true if v[i].nil?; v[i]}
+            if invalid
+                nil
+            else
+                process(vect)
+            end
+        }.to_vector(:scale)
+    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
+        (0...@ds.cases).collect{|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
+        }.to_vector(:scale)
+    end
+    # R Multiple
+    def r
+        raise "You should implement this"
+    end
+    # Sum of squares Total
+    def sst
+        raise "You should implement this"
+    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{|k,v|
+            out[k]=v / se[k] 
+        }
+        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
+        @dep_columns.size
+    end
+    # Degrees of freedom for error
+    def df_e
+        @ds_valid.cases-@dep_columns.size-1
+    end
+    # Fisher for Anova
+    def f
+        (ssr.quo(df_r)).quo(sse.quo(df_e))
+    end
+    # Significance of Fisher
+    def significance
+        if HAS_GSL
+            GSL::Cdf.fdist_Q(f,df_r,df_e)
+        else
+            raise "Need Ruby/GSL"
+        end
+    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]=v.to_vector(:scale)
+            }
+    if HAS_ALGIB
+        lr_class=AlglibEngine
+        ds=ds.to_dataset
+    else
+        lr_class=RubyEngine
+        ds=ds.to_dataset.dup_only_valid
+    end
+    lr=lr_class.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
+        # Estimated Variance-Covariance Matrix
+        # Used for calculation of se of constant 
+        def estimated_variance_covariance_matrix
+            mse_p=mse
+            columns=[]
+            @ds_valid.each_vector{|k,v|
+                columns.push(v.data) unless k==@y_var
+            }
+            columns.unshift([1.0]*@ds_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
+        # Retrieves a summary for Regression
+        def summary(report_type=ConsoleSummary)
+            c=coeffs
+            out=""
+            out.extend report_type
+out.add <<HEREDOC
+Summary for regression of #{@fields.join(',')} over #{@y_var}
+*************************************************************
+Engine: #{self.class}
+Cases(listwise)=#{@ds.cases}(#{@ds_valid.cases})
+r=#{sprintf("%0.3f",r)}
+r2=#{sprintf("%0.3f",r2)}
+Equation=#{sprintf("%0.3f",constant)}+#{@fields.collect {|k| sprintf("%0.3f%s",c[k],k)}.join(' + ')}
+HEREDOC
+
+out.add_line
+out.add "ANOVA TABLE"
+
+t=Statsample::ReportTable.new(%w{source ss df ms f s})
+t.add_row(["Regression", sprintf("%0.3f",ssr), df_r, sprintf("%0.3f",msr), sprintf("%0.3f",f), sprintf("%0.3f",significance)])
+
+t.add_row(["Error", sprintf("%0.3f",sse), df_e, sprintf("%0.3f",mse)])
+
+t.add_row(["Total", sprintf("%0.3f",sst), df_r+df_e])
+
+out.parse_table(t)
+out
+end
+    def assign_names(c)
+            a={}
+            @fields.each_index {|i|
+                a[@fields[i]]=c[i]
+            }
+            a
+    end
+
+        
+    # Deprecated
+    # Sum of squares of error (manual calculation)
+    # using the predicted value minus the y_i value
+    def sse_manual
+        pr=predicted
+        cases=0
+        sse=(0...@ds.cases).inject(0) {|a,i|
+            if !@dy.data_with_nils[i].nil? and !pr[i].nil?
+                cases+=1
+                a+((pr[i]-@dy[i])**2)
+            else
+                a
+            end
+        }
+        sse*(min_n_valid-1.0).quo(cases-1)
+    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
+end
+end
+end
+end

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

@@ -0,0 +1,117 @@
+if HAS_ALGIB
+module Statsample
+module Regression
+module Multiple
+# Class for Multiple Regression Analysis
+# Requires Alglib gem and uses a listwise aproach.
+# If you need pairwise, use RubyEngine
+# Example:
+#
+#   @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
+#   @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
+#   @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
+#   @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
+#   ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
+#   lr=Statsample::Regression::Multiple::AlglibEngine.new(ds,'y')
+#            
+class AlglibEngine < BaseEngine
+    def initialize(ds,y_var)
+        @ds=ds.dup_only_valid
+        @ds_valid=@ds
+        @y_var=y_var
+        @dy=@ds[@y_var]
+        @ds_indep=ds.dup(ds.fields-[y_var])
+        # Create a custom matrix
+        columns=[]
+        @fields=[]
+        @ds.fields.each{|f|
+            if f!=@y_var
+                columns.push(@ds[f].to_a)
+                @fields.push(f)
+            end
+        }
+        @dep_columns=columns.dup
+        columns.push(@ds[@y_var])
+        matrix=Matrix.columns(columns)
+        @lr_s=nil
+        @lr=::Alglib::LinearRegression.build_from_matrix(matrix)
+    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
+        assign_names(@lr.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.standarize
+        columns=[]
+        @ds_s.fields.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
+        res.collect {|v|
+            v.quo(red_sd)
+        }.to_vector(:scale)
+    end
+end
+end
+end
+end # for Statsample
+end # for if
+
+        
+

data/lib/statsample/regression/multiple/rubyengine.rb

@@ -0,0 +1,140 @@
+module Statsample
+module Regression
+module Multiple
+# Pure Ruby Class for Multiple Regression Analysis.
+# Slower than AlglibEngine, but is pure ruby and uses a pairwise aproach for missing values. 
+# If you need listwise aproach for missing values, use AlglibEngine, because is faster.
+# 
+# Example:
+#
+#   @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
+#   @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
+#   @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
+#   @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
+#   ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
+#   lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
+
+class RubyEngine < BaseEngine 
+    def initialize(ds,y_var)
+    super
+        @dy=ds[@y_var]
+        @ds_valid=ds.dup_only_valid
+        @ds_indep=ds.dup(ds.fields-[y_var])
+        @fields=@ds_indep.fields
+        set_dep_columns
+        obtain_y_vector
+        @matrix_x = Bivariate.correlation_matrix(@ds_indep)
+        @coeffs_stan=(@matrix_x.inverse * @matrix_y).column(0).to_a
+@min_n_valid=nil
+    end
+    def min_n_valid
+        if @min_n_valid.nil?
+            min=@ds.cases
+            m=Bivariate::n_valid_matrix(@ds)
+            for x in 0...m.row_size
+                for y in 0...m.column_size
+                    min=m[x,y] if m[x,y] < min
+                end
+            end
+            @min_n_valid=min
+        end
+        @min_n_valid
+    end
+    def set_dep_columns
+        @dep_columns=[]
+        @ds_indep.each_vector{|k,v|
+            @dep_columns.push(v.data_with_nils)
+        }                
+    end
+    # Sum of square total
+    def sst
+        #if @sst.nil?
+        @sst=@dy.variance*(min_n_valid-1.0)
+        #end
+        @sst
+    end
+    def r2
+        if @r2.nil?
+        c=@matrix_y
+        rxx=obtain_predictor_matrix
+        matrix=(c.t*rxx.inverse*c)
+        @r2=matrix[0,0]
+        end
+        @r2
+    end
+    def r
+        Math::sqrt(r2)
+    end
+
+    def df_e
+        min_n_valid-@dep_columns.size-1
+    end
+    def fix_with_mean
+        i=0
+        @ds_indep.each{|row|
+            empty=[]
+            row.each{|k,v|
+                empty.push(k) if v.nil?
+            }
+            if empty.size==1
+                @ds_indep[empty[0]][i]=@ds[empty[0]].mean
+            end
+            i+=1
+        }
+        @ds_indep.update_valid_data
+        set_dep_columns
+    end
+    def fix_with_regression
+        i=0
+        @ds_indep.each{|row|
+            empty=[]
+            row.each{|k,v|
+                empty.push(k) if v.nil?
+            }
+            if empty.size==1
+                field=empty[0]
+                lr=MultipleRegression.new(@ds_indep,field)
+                fields=[]
+                @ds_indep.fields.each{|f|
+                    fields.push(row[f]) unless f==field
+                }
+                @ds_indep[field][i]=lr.process(fields)
+            end
+            i+=1
+        }
+        @ds_indep.update_valid_data
+        set_dep_columns
+    end
+    def obtain_y_vector
+        @matrix_y=Matrix.columns([@ds_indep.fields.collect{|f|
+                Bivariate.pearson(@dy, @ds_indep[f])
+        }])
+    end
+    def obtain_predictor_matrix
+        Bivariate::correlation_matrix(@ds_indep)
+    end
+    def constant
+        c=coeffs
+        @dy.mean-@fields.inject(0){|a,k| a+(c[k] * @ds_indep[k].mean)}
+    end
+    def process(v)
+        c=coeffs
+        total=constant
+        @fields.each_index{|i|
+        total+=c[@fields[i]]*v[i]
+        }
+        total
+    end
+    def coeffs
+        sc=standarized_coeffs
+        assign_names(@fields.collect{|f|
+            (sc[f]*@dy.sds).quo(@ds_indep[f].sds)
+        })
+    end
+    def standarized_coeffs
+        assign_names(@coeffs_stan)
+    end
+end
+end
+end
+end