svmlab 1.0.0

data/lib/svmlab-plot.rb

@@ -0,0 +1,170 @@
+# ---------------------------------------------------------------------------------------
+# Plot methods
+
+require 'gnuplot'
+
+ 
+# Each should be an array giving more than one plot
+def genericplot(plotdata, file, title='Plot', xtitle='X', ytitle='Y')
+  Gnuplot.open do |gp| # This could be either a file or the gnuplot process that we pipe to
+    Gnuplot::Plot.new( gp ) do |plot|
+      plot.title  title
+      plot.xlabel xtitle
+      plot.ylabel ytitle
+      plot.set "grid"
+      if file =~ /(png)|(ps)$/
+        # Remember to add following line to your .baschrc file :
+        # export GDFONTPATH=/usr/share/fonts/truetype/ttf-bitstream-vera/
+        plot.terminal "png size 800,600 font Vera 16" if file =~ /png$/
+        #plot.terminal "png size 800,600 large" if file =~ /png$/
+        plot.terminal "postscript color \"Helvetica\" 16" if file =~ /ps$/          
+        plot.output file
+      end
+      plot.data = plotdata
+    end
+  end
+end
+
+# --- predplot ---
+# PredictionPlot: Plots true value on the X axis vs. predicted value on the Y axis.
+def predplot(predarr, legends = [], title = 'SVM Prediction', err = nil, file = '')
+  predarr = [predarr] if !predarr.is_a? Array
+  dataarr = predarr.map do |predictions|
+    x, y = predictions.inject([[],[]]) { |data,(example,val)|
+      data[0] << val['truth']
+      data[1] << val['pred']
+      data }
+  end
+  
+  from = dataarr.inject(dataarr[0][0][0]) { |m,a|
+    [m, a[0].min, a[1].min].min }.floor
+  to = dataarr.inject(dataarr[0][0][0]) { |m,a|
+    [m, a[0].max, a[1].max].max }.ceil
+  sampleindex = 0
+  # Fiddling with legends
+  legends = dataarr.map{|d| "Sample #{sampleindex+=1}"} if legends.size==0
+  if err
+    legends = legends.zip(predarr).map { | legend, pred |
+      begin
+        #args = if err.split(/,/).size==1 then 'pred'
+        #       else (['pred'] + err.split(/,/)[1..-1]).join(',') end
+        #legend + " (#{err} = ".upcase + "%.2f"%eval("#{err.split(/,/)[0].downcase}(#{args})") + ")"
+        legend + " (#{err} = ".upcase + "%.2f"%eval("pred.#{err}") + ')'
+      rescue
+        legend
+        raise
+      end
+    }
+  end
+  # Setting plotdata
+  plotdata = 
+    [ Gnuplot::DataSet.new( dataarr.first ) { |ds|
+               ds.using = '1:2'
+               ds.with = "points"
+               ds.title = legends.first
+               ds.linewidth = 2
+               ds.matrix = nil } ] +
+    [ Gnuplot::DataSet.new( [[from,to], [from,to]] ) { |ds|
+                 ds.using = '1:2'
+                 ds.with = "lines"
+                 ds.title = "Correct diagonal"
+                 ds.linewidth = 1
+                 ds.matrix = nil } ] +
+    dataarr[1..-1].zip(legends[1..-1]).inject([]) { |arr,((x,y),legend)|
+    arr.push(Gnuplot::DataSet.new( [x,y] ) { |ds|
+               ds.using = '1:2'
+               ds.with = "points"
+               ds.title = legend
+               ds.linewidth = 2
+               ds.matrix = nil }) }
+  genericplot(plotdata, file, title, 'Experimental value', 'Predicted value')
+  nil
+end
+
+class SVMLab
+
+  # --- featurecorrelationplot ---
+  # Plots target feature on the Y axis vs. selected feature on the X axis
+  def featurecorrelationplot( feature, file = '', title = 'Feature correlation')
+    x,y = @examples.inject([[],[]]) do |data,(example,val)|
+      raise "#{feature} outside feature range"if not (0...val.size) === feature
+      data[0].push(val[feature] / @scale[feature] + @center[feature])
+      data[1].push(val[0] / @scale[0] + @center[0]) 
+      data
+    end
+    plotdata = [ Gnuplot::DataSet.new( [x,y] ) { |ds|
+                   ds.using = '1:2'
+                   ds.with = "points"
+                   ds.title = "Feature #{feature} vs target feature"
+                   ds.linewidth = 1
+                   ds.matrix = nil } ]
+    genericplot(plotdata, file, title, "Feature #{feature}", "Target feature")
+  end
+
+  # --- predplotgroups ---
+  def predplotgroups(predarr, file = '', legends = [], title = 'SVM Prediction', err = nil)
+    substr = @cfg['Feature']['Groups']
+    groups = @examples.map{|k,v| k[(eval substr)] }.uniq
+    # For each group
+    groups.each do |group|
+      predarr2 = predarr.map { |preds|
+        preds.find_all { |k,v| k[(eval substr)] == group }.
+          inject({}) { |k,a| k[ a[0] ] = a[1] 
+          k }
+      }
+      predplot(predarr2 ,
+               if file.size==0 then file
+               else [file.split(/\./)[0...-1],group,file.split(/\./).last].join('.') end ,
+               legends, title + " on #{group}", err)
+    end
+  end
+
+
+
+  # --- onefeatureplot ---
+  def onefeatureplot(file='', title = 'SVM Prediction')
+    xp = [] # Don't initialize in one line : x=y=[]
+    yp = [] # If doing that, they will both refer to the same array
+    xt = [] # Don't initialize in one line : x=y=[]
+    yt = [] # If doing that, they will both refer to the same array
+    @examples.each {|example, features|
+      xt.push(features[1].to_f)
+      yt.push(features[0].to_f)
+    }
+    (0..1000).each {|i|
+      x = (i * (xt.max-xt.min) / 1000 + xt.min).to_f
+      xp.push(x)
+      yp.push(@model.predict([x]) / @scale[0] + @center[0])
+    }
+    Gnuplot.open do |gp| # This could be either a file or the gnuplot process that we pipe to
+      Gnuplot::Plot.new( gp ) do |plot|
+        plot.title  title
+        plot.xlabel "Truth"
+        plot.ylabel "Prediction"
+        plot.set "grid"
+        if file =~ /(png)|(ps)$/
+          plot.terminal "png size 800,600 small" if file =~ /png$/
+          plot.terminal "postscript" if file =~ /ps$/          
+          plot.output file
+        end
+        plot.data = [
+                     Gnuplot::DataSet.new( [xp,yp] ) { |ds|
+                       ds.using = '1:2'
+                       ds.with = "lines"
+                       ds.title = "SVM prediction"
+                       ds.linewidth = 1
+                       ds.matrix = nil
+                     },    
+                     Gnuplot::DataSet.new( [xt, yt] ) { |ds|
+                       ds.using = '1:2'
+                       ds.with = "points"
+                       ds.title = "Correct prediction"
+                       ds.linewidth = 1
+                       ds.matrix = nil
+                     }
+                    ]
+      end
+    end
+  end
+
+end

data/lib/svmlab.rb

@@ -0,0 +1,365 @@
+require 'SVM'
+require 'yaml'
+require 'rubygems'
+require 'tempfile'
+#require 'forkoff'
+
+require 'svmfeature.rb'
+require 'svmlab-optim.rb'
+require 'svmlab-plot.rb'
+require 'svmprediction.rb'
+require 'svmlab-config.rb'
+
+# An SVMLab object is created giving the configuration either as a file
+# object or as a string. The configuration is in YAML format: 
+#
+# ---
+# Feature:
+#   <See SVMFeature class documentation>
+# SVM:
+#   C: <parameter C>
+#   g: <RBF kernel's gamma>
+#   e: <epsilon for regression>
+#   Scale:
+#     <Feature1>: 
+#     - <Scale1>
+#     - <Scale2>
+#     - ...
+#     - <ScaleN>
+#     <Feature2>: <Scale>
+#
+# The Scale setup has to match the features given in Feature configuration
+# and each scale can be given as scalar or as array.
+#
+
+class SVMLab
+  
+  attr_reader :cfg, :pslog, :features
+
+  # All examples are centered and scaled and the centered/scaled examples are stored
+  # in the object variable @examples. Information about the centering/scaling
+  # is stored in the @cfg['SVM'] part of the configuration hash
+  # There are three ways to initialize. 
+  #  1) With an SVMLabConfig object
+  #  2) With a configuration file File object
+  #  3) With a string giving the configuration
+  def initialize(cfg)
+    @cfg = if cfg.is_a? SVMLabConfig then cfg
+           else SVMLabConfig.new(cfg) end
+    @features = SVMFeature.new(@cfg['Feature'].to_yaml)
+    @examples = @features.getAllFeatures
+    @ndimensions = nil
+
+    checkScales(@cfg)
+    checkOptimization(@cfg)
+    scaleExamples
+    @groups = setGroups()
+    #puts 'Groups:', @groups.map{ |group,members| {group => members.map{|name,feat| name}.size} }.to_yaml
+  end
+
+  # --- setGroups ---
+  # Return value:
+  #  groups hash:
+  #     key : group name
+  #     value : array of example names
+  # Returns nil if @cfg['Feature']['Groups'] is not set
+  def setGroups()
+    if groups = @cfg['Feature']['Groups']
+      # If using the (n1..n2) syntax
+      if groups =~ /^\(\d(\.{2}|\.{3})\d\)$/
+        hashkeys = @examples.map{|k,v| k[eval(groups)] }.uniq
+        hashkeys.inject({}) { |hash,key| 
+          hash[key] = @examples.find_all{ |exname,val| exname[eval(groups)]==key }.map{|i| i[0]} 
+          hash }
+      # If using the file prefix syntax 
+      elsif (gfiles = Dir::entries(@cfg['Feature']['BaseDir']).grep(/^#{groups}\d+$/)).size>0
+        hashkeys = gfiles.map { |file| file.split(groups).last }
+        #puts '---','Groups :',hashkeys,'---'
+        hashkeys.inject({}) { |hash,key| 
+          hash[key] = open(@cfg['Feature']['BaseDir']+groups+key){|f| f.read}.split(/\n/)
+          hash }
+      end
+    else # If no groups set, use leave-one-out crossvalidation
+      @examples.inject({}) { |hash,(key, value)|
+        hash[key] = [ key ]
+        hash
+      }
+    end
+  end
+
+  # Set the penalty factor C.
+  def C=(arg)
+    @cfg['SVM']['C'] = arg.to_f
+  end
+      
+  # Set epsilon for Support Vector Regression.
+  def e=(arg)
+    @cfg['SVM']['e'] = arg.to_f
+  end
+      
+  # Set gamma for the RBF kernel.
+  def g=(arg)
+    @cfg['SVM']['g'] = arg.to_f
+  end
+
+  # Returns the n closest neighbors of the @example hash to example
+  # Possibly broken - check @feature hash if an erranous example
+  def getNeighbors(example, n = 1)
+    arr = @examples[example]
+    distance = @examples.sort_by { |a| 
+      dist(arr[1...arr.size],a[1][1...a[1].size]) }
+    distance[0..n].map { |a| 
+      i = 0
+      a[0] + ' : ' +   # Name
+      "%.3f \n"%dist(arr[1...arr.size], a[1][1...a[1].size]) + # Distance
+      #" : %.3f\n"%(a[1][0] - arr[0]) + # Distance in target value
+      @cfg['Feature']['Features'].inject('') { |string,feature|
+        nvector = @features.getExFeature(a[0],feature)
+        featdist = dist(arr[i...i+nvector.size], 
+                        @examples[a[0]][i...i+nvector.size])
+        i += nvector.size
+        pretty = if feature==@cfg['Feature']['Features'][0] then ' *** ' else ' --- ' end
+        string += pretty + "(%.2f)"%featdist + pretty +
+        feature + " :  " +
+        nvector.join(' ') + "\n"
+      }
+    }
+  end
+
+  def dist(a,b)
+    raise "Cannot calculate distance" if a.size != b.size
+    Math.sqrt(a.zip(b).inject(0){|d,(ai,bi)| d+(ai-bi).abs**2})
+  end
+
+  # Finds those examples that have been predicted most far off
+  # the correct value. Returns a string consisting of those
+  # examples along with the closest neighbors.
+  def getOutliers(n = (1..1), n2 = 3, predictions = nil)
+    if !predictions
+      predictions = self.crossvalidate
+    end
+    sortedpred = predictions.sort_by { |(k,v)| 
+      - (v['pred'] - v['truth']).abs }
+    n = if n.is_a? Fixnum then (n..n) else n end
+    n.map do |i|
+      "OUTLIER %d : \n"%i + 
+        sortedpred[i-1][0] + " was predicted %.3f"%sortedpred[i-1][1]['pred'] +
+        " but the truth is %.3f :\n"%sortedpred[i-1][1]['truth'] +
+        getNeighbors(sortedpred[i-1][0],n2).join('')
+    end.join("\n")
+  end
+
+  # Returns a String of all examples with features.
+  def printExamples
+    @examples.inject('') do |str,(exname,vector)|
+      str += vector.map{|v| v.to_s}.join(' ') + "\n"
+    end
+  end
+
+  # An outer binding for the RubySVM predict function. This binding introduces
+  # inverse centering and scaling of the predicted value. This in order
+  # to give a real prediction value.
+  def predict(examples, model = nil)
+    if !model then model = self.train end
+    examples = [ examples ] if examples.is_a? String
+    predictions = examples.map do |example|
+      begin
+        vector = 
+          if !@examples[example]
+            fcfg = Marshal.load(Marshal.dump(@cfg['Feature']))
+            fcfg.delete('DataSet')
+            fcfg['Example'] = example
+              scaleExample(SVMFeature.new(fcfg.to_yaml).getExAllFeatures(example))
+          else
+            @examples[example]
+          end
+        if @cfg['Feature']['PosClassFrom']
+          model.predict(vector[1..-1]).round
+        else
+          model.predict(vector[1..-1]) / 
+            @cfg['SVM']['Scale'][ @cfg['Feature']['Features'][0] ][0] + 
+            @cfg['SVM']['Center'][ @cfg['Feature']['Features'][0] ][0]
+        end
+      rescue
+        $!
+      end
+    end
+    if predictions.size==1 then predictions[0]
+    else predictions end
+  end
+
+  # An outer binding for the RubySVM training function.
+  # If no training examples given, it will train on all data in the dataset.
+  def train(examples = nil)
+    svm = SVM::Problem.new
+    if examples then examples.each { |exname|
+        @ndimensions = @examples[exname].size - 1 if !@ndimensions
+        if @examples[exname]
+          svm.addExample( @examples[exname][0], @examples[exname][1..-1] )
+        end }
+    else @examples.each { |name,vector|
+        @ndimensions = vector.size-1 if !@ndimensions
+        svm.addExample( vector[0], vector[1..-1] ) }
+    end
+    begin
+      errout = STDERR.clone
+      out = STDOUT.clone
+      STDERR.reopen(File.open('/dev/null','w'))
+      STDOUT.reopen(File.open('/dev/null','w'))
+      @par = SVM::Parameter.new
+      @par.svm_type = @cfg['Feature']['PosClassFrom'] ? 0 : 3
+      if c=@cfg['SVM']['C'] then @par.C = c.to_f end
+      if e=@cfg['SVM']['e'] then @par.eps = e.to_f end
+      @par.gamma = if g=@cfg['SVM']['g'] then g.to_f 
+                   else 1.0 / @ndimensions end
+      SVM::Model.new(svm,@par)
+    ensure
+      STDERR.reopen(errout)
+      STDOUT.reopen(out)
+    end
+  end
+
+  # crossvalidation on a grouping made from "Groups" in cfg
+  # Return values:
+  # - Predictions hash :
+  #     key : example name
+  #     value : 'truth' => the true value
+  #              'pred' => the predicted value
+  #--
+  # Remaining issues:
+  #  2) No of parallel computations should be in cfg
+  #++
+  def crossvalidate()
+    #parr = @groups.keys.forkoff do |group|
+    parr = @groups.keys.map do |group|
+      members = @groups[group]
+      trainingex = @groups.inject([]){ |exarr,(trgroup,trmem)|
+        (trgroup == group) ? exarr : exarr + trmem }
+      model = self.train(trainingex)
+      # Predict each member of the group left out of training
+      pred = members.inject({}) do |p,predname|
+        p[predname] = {
+          'truth' => if @cfg['Feature']['PosClassFrom'] 
+                       @examples[predname][0].round
+                     else @examples[predname][0] / 
+                           @cfg['SVM']['Scale'][@cfg['Feature']['Features'][0]][0] + 
+                           @cfg['SVM']['Center'][@cfg['Feature']['Features'][0]][0]
+                     end,
+          'pred' => self.predict(predname,model) } if @examples[predname]
+        p
+      end
+    end
+    predictions = parr.inject SVMPrediction.new do |p,predhash|
+      predhash.each { |exname,phash| p[exname] = phash } ; p
+    end
+  end
+      
+  # Same as crossvalidate, but also outputs configuration and result
+  # to a file.
+  def publish_crossvalidate(path)
+    predictions = self.crossvalidate
+    time = DateTime.now
+    info = {
+      'Time' => time,
+      'Evaluation' => {
+        'RMSD' => predictions.rmsd,
+        #'MeanErr' => predictions.meanerr,
+        'CC' => predictions.cc },
+        #'AUC' => auc(predictions,1),
+        #'PBRMSD' => pbrmsd(predictions, @cfg['Feature']['Groups']),      
+        #'WRMSD' => wrmsd(predictions,1), 
+        #'F1' => f1(predictions,2) },
+      'Configuration' => @cfg,
+      'Predictions' => predictions.predictions
+    }
+    pdepth = 0
+    (patharr = path.split(/\//))[1...-1].each do
+      dir = patharr[0..pdepth+=1].join('/')
+      Dir.mkdir dir if !File.exists?(dir)
+    end
+    File.open(path,'w') { |f| YAML.dump(info,f) }
+    return predictions
+  end
+
+  private
+
+  # Go through each feature and check its centering
+  # and scaling instructions.
+  def checkScales(cfg)
+    cfg['SVM']['Center'] = {} if !cfg['SVM']['Center']
+    cfg['SVM']['Scale'] = {} if !cfg['SVM']['Scale']
+    dim0 = 0
+    cfg['Feature']['Features'].each_with_index do |feature, index|
+      dim = @cfg['Feature'][feature]['Dimensions']
+      dim ||= 1 # If Dimensions not given
+      cfg['SVM']['Center'][feature] ||= []
+      cfg['SVM']['Scale'][feature] ||= []
+      sc = cfg['SVM']['Scale'][feature]
+      (0...dim).each do |i|
+        #Check centering
+        cfg['SVM']['Center'][feature][i] =
+          if index==0 and @cfg['Feature']['PosClassFrom']
+            0
+          elsif !cfg['SVM']['Center'][feature][i]
+            sum = @examples.inject(0) { |s,(exname,vector)| s + vector[dim0+i] }
+            sum / @examples.size
+          else
+            cfg['SVM']['Center'][feature][i]
+          end
+        #Check scaling
+        if index==0 and @cfg['Feature']['PosClassFrom']
+          sc[i] = 1
+        elsif !sc[i] or (sc[i].is_a? String and sc[i] =~ /max/)
+          absmax = @examples.inject(0) { |s,(exname,vector)|
+            [s, (vector[dim0+i] - cfg['SVM']['Center'][feature][i]).abs].max }
+          scale = if absmax!=0 then 1/absmax else 1 end
+          if sc[i] =~ /max/ then sc[i].sub!('max', scale.to_s)
+          else sc[i] = scale end
+          sc[i] = sc[i].to_f if sc[i] =~ /^\d+\.*\d*$/
+        elsif (sc[i].is_a? String and sc[i] =~ /avg/)
+          abssum = @examples.inject(0) { |s,(exname,vector)| 
+            s + (vector[dim0+i] - cfg['SVM']['Center'][feature][i]).abs }
+          scale = @examples.size / abssum
+          if sc[i] =~ /avg/ then sc[i].sub!('avg', scale.to_s)
+          else sc[i] = scale end
+          sc[i] = sc[i].to_f if sc[i] =~ /^\d+\.*\d*$/
+        elsif (sc[i].is_a? String and sc[i] =~ /std/)
+          sqsum = @examples.inject(0) { |s,(exname,vector)| 
+            s + (vector[dim0+i] - cfg['SVM']['Center'][feature][i])**2 }
+          scale = Math::sqrt( @examples.size / sqsum )
+          if sc[i] =~ /std/ then sc[i].sub!('std', scale.to_s)
+          else sc[i] = scale end
+          sc[i] = sc[i].to_f if sc[i] =~ /^\d+\.*\d*$/
+        end
+      end
+      dim0 += dim
+    end
+    #puts 'CENTER',@cfg['SVM']['Center'].to_yaml
+    #puts 'SCALE',@cfg['SVM']['Scale'].to_yaml
+  end
+
+  # The object variable @examples's features are centered around zero and scaled
+  # according to the configuration. I.e. each feature has a center term and a scaling 
+  # factor. 
+  def scaleExamples()
+    @examples.each do |name, vector|
+      @examples[name] = scaleExample(vector)
+    end
+  end
+
+  def scaleExample(vector)
+    scaledvector = []
+    @cfg['Feature']['Features'].inject(0) { |i,feature|
+      dim = @cfg['Feature'][feature]['Dimensions']
+      dim = 1 if !dim
+      (0...dim).each { |j| 
+        scaledvector[i+j] = 
+          (vector[i+j] - @cfg['SVM']['Center'][feature][j]) * 
+          @cfg['SVM']['Scale'][feature][j].to_f }
+      i + dim
+    }
+    scaledvector
+  end
+
+end
+