rsvm 0.0.1

data/ext/libsvm/svm.h

@@ -0,0 +1,102 @@
+#ifndef _LIBSVM_H
+#define _LIBSVM_H
+
+#define LIBSVM_VERSION 312
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int libsvm_version;
+
+struct svm_node
+{
+	int index;
+	double value;
+};
+
+struct svm_problem
+{
+	int l;
+	double *y;
+	struct svm_node **x;
+	double *W; /* instance weight */
+};
+
+enum { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR };	/* svm_type */
+enum { LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED }; /* kernel_type */
+
+struct svm_parameter
+{
+	int svm_type;
+	int kernel_type;
+	int degree;	/* for poly */
+	double gamma;	/* for poly/rbf/sigmoid */
+	double coef0;	/* for poly/sigmoid */
+
+	/* these are for training only */
+	double cache_size; /* in MB */
+	double eps;	/* stopping criteria */
+	double C;	/* for C_SVC, EPSILON_SVR and NU_SVR */
+	int nr_weight;		/* for C_SVC */
+	int *weight_label;	/* for C_SVC */
+	double* weight;		/* for C_SVC */
+	double nu;	/* for NU_SVC, ONE_CLASS, and NU_SVR */
+	double p;	/* for EPSILON_SVR */
+	int shrinking;	/* use the shrinking heuristics */
+	int probability; /* do probability estimates */
+};
+
+//
+// svm_model
+// 
+struct svm_model
+{
+	struct svm_parameter param;	/* parameter */
+	int nr_class;		/* number of classes, = 2 in regression/one class svm */
+	int l;			/* total #SV */
+	struct svm_node **SV;		/* SVs (SV[l]) */
+	double **sv_coef;	/* coefficients for SVs in decision functions (sv_coef[k-1][l]) */
+	double *rho;		/* constants in decision functions (rho[k*(k-1)/2]) */
+	double *probA;		/* pariwise probability information */
+	double *probB;
+
+	/* for classification only */
+
+	int *label;		/* label of each class (label[k]) */
+	int *nSV;		/* number of SVs for each class (nSV[k]) */
+				/* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
+	/* XXX */
+	int free_sv;		/* 1 if svm_model is created by svm_load_model*/
+				/* 0 if svm_model is created by svm_train */
+};
+
+struct svm_model *svm_train(const struct svm_problem *prob, const struct svm_parameter *param);
+void svm_cross_validation(const struct svm_problem *prob, const struct svm_parameter *param, int nr_fold, double *target);
+
+int svm_save_model(const char *model_file_name, const struct svm_model *model);
+struct svm_model *svm_load_model(const char *model_file_name);
+
+int svm_get_svm_type(const struct svm_model *model);
+int svm_get_nr_class(const struct svm_model *model);
+void svm_get_labels(const struct svm_model *model, int *label);
+double svm_get_svr_probability(const struct svm_model *model);
+
+double svm_predict_values(const struct svm_model *model, const struct svm_node *x, double* dec_values);
+double svm_predict(const struct svm_model *model, const struct svm_node *x);
+double svm_predict_probability(const struct svm_model *model, const struct svm_node *x, double* prob_estimates);
+
+void svm_free_model_content(struct svm_model *model_ptr);
+void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);
+void svm_destroy_param(struct svm_parameter *param);
+
+const char *svm_check_parameter(const struct svm_problem *prob, const struct svm_parameter *param);
+int svm_check_probability_model(const struct svm_model *model);
+
+void svm_set_print_string_function(void (*print_func)(const char *));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBSVM_H */

data/lib/svm.rb

@@ -0,0 +1,119 @@
+require "svm/version"
+require 'ffi'
+
+require_relative 'svm/debug'
+
+module Svm
+  extend FFI::Library
+  extend Svm::Debug
+
+  ffi_lib File.join(File.dirname(__FILE__), "libsvm/libsvm.#{RbConfig::CONFIG['DLEXT']}")
+
+  enum :svm_type, [:c_svc, :nu_svc, :one_class, :epsilon_svr, :nu_svr]
+  enum :kernel_type, [:linear, :poly, :rbf, :sigmoid, :precomputed]
+
+  class NodeStruct < FFI::Struct
+    layout :index, :int,
+           :value, :double
+
+    def self.node_array_from(sample_xs)
+      num_features = sample_xs.size
+
+      nodes_ptr = FFI::MemoryPointer.new(NodeStruct, num_features + 1)
+
+      num_features.times.each do |j|
+        node = NodeStruct.new(nodes_ptr + j * NodeStruct.size)
+        node[:index] = j
+        node[:value] = sample_xs[j].to_f
+      end
+
+      # Last node is a terminator. See libsvm README.
+      node = NodeStruct.new(nodes_ptr + num_features * NodeStruct.size)
+      node[:index] = -1
+      node[:value] = 0
+
+      nodes_ptr
+    end
+  end
+
+  class ProblemStruct < FFI::Struct
+    layout  :l,         :int,
+            :y,         :pointer,
+            :svm_node,  :pointer,
+            :W,         :pointer
+  end
+
+  class ParameterStruct < FFI::Struct
+    layout :svm_type,     :svm_type,
+           :kernel_type,  :kernel_type,
+           :degree,       :int,
+           :gamma,        :double,
+           :coef0,        :double,
+           :cache_size,   :double,
+           :eps,          :double,
+           :c,            :double,
+           :nr_weight,    :int,
+           :weight_label, :pointer,
+           :weight,       :pointer,
+           :nu,           :double,
+           :p,            :double,
+           :shrinking,    :int,
+           :probability,  :int
+  end
+
+  class ModelStruct < FFI::ManagedStruct
+    layout :param,       ParameterStruct,
+           :nr_class,    :int,
+           :l,           :int,
+           :svm_node,    :pointer,
+           :sv_coef,     :pointer,
+           :rho,         :pointer,
+           :probA,       :pointer,
+           :probB,       :pointer,
+           :label,       :pointer,
+           :nSV,         :pointer,
+           :free_sv,     :int
+
+    def self.release(ptr)
+      Svm.svm_free_model_content(ptr)
+    end
+  end
+
+  attach_function 'svm_train', [:pointer, :pointer], :pointer
+
+  attach_function 'svm_cross_validation', [:pointer, :pointer, :int, :pointer], :void
+  attach_function 'svm_save_model', [:string, :pointer], :int
+  attach_function 'svm_load_model', [:string], :pointer
+  attach_function 'svm_get_svm_type', [:pointer], :int
+  attach_function 'svm_get_nr_class', [ :pointer], :int
+  attach_function 'svm_get_labels', [:pointer, :pointer], :void
+  attach_function 'svm_get_svr_probability', [:pointer], :double
+
+  attach_function 'svm_predict_values', [:pointer, :pointer, :pointer], :double
+  attach_function 'svm_predict', [:pointer, :pointer], :double
+  attach_function 'svm_predict_probability', [:pointer, :pointer, :pointer], :double
+
+  attach_function 'svm_free_model_content', [:pointer], :void
+  attach_function 'svm_free_and_destroy_model', [:pointer], :void
+  attach_function 'svm_destroy_param', [:pointer], :void
+
+  attach_function 'svm_check_parameter', [:pointer, :pointer ], :string
+  attach_function 'svm_check_probability_model', [:pointer,], :int
+  attach_function 'svm_set_print_string_function', [:pointer,], :void
+
+
+  DebugCallback = FFI::Function.new(:void, [:string]) do |message|
+    print message if Svm.debug
+  end
+
+  Svm.svm_set_print_string_function(DebugCallback)
+  Svm.debug = false
+end
+
+
+
+require_relative 'svm/cross_validation'
+require_relative 'svm/options'
+require_relative 'svm/problem'
+require_relative 'svm/model'
+require_relative 'svm/scaler'

data/lib/svm/cross_validation.rb

@@ -0,0 +1,39 @@
+module Svm
+  module CrossValidation
+    
+    def results_for_cross_validation(n_folds = 5, custom_options = nil)
+      results = cross_validate(n_folds, custom_options)
+      
+      num_samples.times.collect { |i| value(i) == results[i] ? weight_for(i) : 0 }.inject(:+)
+    end
+    
+    def cross_validate(n_folds = 5, more_options = nil)
+      set(more_options) if more_options
+      
+      predicted_results_pointer = FFI::MemoryPointer.new(:double, num_samples)
+      
+      Svm.svm_cross_validation(problem_struct, options.parameter_struct, n_folds, predicted_results_pointer)
+      
+      predicted_results_pointer.read_array_of_double(num_samples)
+    end
+    
+    def find_best_parameters(n_folds = 5)
+      c_exponents = (-1..14).to_a
+      gamma_exponents = (-13..-1).to_a
+      
+      combinations = c_exponents.product(gamma_exponents)
+      
+      max = combinations.max_by do |comb|
+        c = 2 ** comb[0]
+        gamma = 2 ** comb[1]
+        
+        results_for_cross_validation(n_folds, :c => c, :gamma => gamma)
+      end
+      
+      c     = 2**max[0]
+      gamma = 2**max[1]
+      
+      {:c => c, :gamma => gamma}
+    end
+  end
+end

data/lib/svm/debug.rb

@@ -0,0 +1,12 @@
+module Svm
+  module Debug
+    
+    def debug
+      defined?(@debug) && @debug
+    end
+
+    def debug=(do_debug)
+      @debug = do_debug
+    end
+  end
+end

data/lib/svm/model.rb

@@ -0,0 +1,68 @@
+module Svm
+  class ModelSerializationError < StandardError; end
+  class ModelError < StandardError; end
+  
+  class Model
+    attr_reader   :model_struct
+    attr_accessor :scaler
+    
+    def initialize(model_struct)
+      @model_struct = model_struct
+    end
+    
+    def save(path)
+      result = Svm.svm_save_model(path, model_struct.pointer)
+      raise ModelSerializationError.new("Unable to save model to file. Error: #{result}") unless result == 0
+    end
+    
+    def self.load(path)
+      model_struct_pointer = Svm.svm_load_model(path)
+      raise ModelSerializationError.new("Unable to load model from file. Error: #{result}") unless model_struct_pointer != FFI::Pointer::NULL
+      
+      model_struct = ModelStruct.new(model_struct_pointer)
+      self.new(model_struct)
+    end
+    
+    def number_of_classes
+      Svm.svm_get_nr_class(model_struct)
+    end
+    
+    def labels
+      labels_array = FFI::MemoryPointer.new(:int, number_of_classes)
+      
+      Svm.svm_get_labels(model_struct, labels_array)
+      
+      labels_array.read_array_of_int(number_of_classes)
+    end
+    
+    def predict(sample)
+      scaler.scale(sample) if scaler
+      
+      nodes_ptr = NodeStruct.node_array_from(sample)
+      Svm.svm_predict(model_struct, nodes_ptr)
+    end
+    
+    def predict_probabilities(sample)
+      unless Svm.svm_check_probability_model(model_struct) == 1
+        raise ModelError.new("Model doesn't have probability info")
+      end
+      
+      scaler.scale(sample) if scaler
+      
+      nodes_ptr = NodeStruct.node_array_from(sample)
+      
+      prob_array = FFI::MemoryPointer.new(:double, number_of_classes)
+      
+      Svm.svm_predict_probability(model_struct, nodes_ptr, prob_array)
+      probabilities = prob_array.read_array_of_double(number_of_classes)
+      
+      number_of_classes.times.inject({}) do |hash, index|
+        label = labels[index]
+        prob  = probabilities[index]
+        
+        hash[label] = prob
+        hash
+      end
+    end
+  end
+end

data/lib/svm/options.rb

@@ -0,0 +1,69 @@
+module Svm
+  class ParameterError < StandardError; end
+  
+  class Options
+    attr_reader :parameter_struct
+    
+    DEFAULT_OPTIONS = {
+      :svm_type         => :c_svc,
+      :kernel_type      => :rbf,
+      :degree           => 3,
+      :gamma            => 0,
+      :coef0            => 0,
+      :nu               => 0.5,
+      :cache_size       => 100.0,
+      :c                => 1,
+      :eps              => 0.001,
+      :p                => 0.1,
+      :shrinking        => 1,
+      :probability      => 0,
+      :nr_weight        => 0,
+      :cross_validation => 0,
+      :nr_fold          => 0,
+      :scale            => true
+    }
+    
+    def initialize(user_options = {})
+      @parameter_struct = ParameterStruct.new
+      add(DEFAULT_OPTIONS.merge(user_options))
+    end
+    
+    def add(more_options)
+      options_hash.merge!(more_options)
+      
+      more_options.each do |key, value|
+        parameter_struct[key] = value if parameter_struct.members.include?(key)
+      end
+    end
+    
+    def label_weights=(weights)
+      @weights = weights
+      
+      num_labels = weights.keys.size
+      
+      parameter_struct[:nr_weight] = num_labels
+      
+      parameter_struct[:weight_label] = FFI::MemoryPointer.new(:int, num_labels)
+      parameter_struct[:weight]       = FFI::MemoryPointer.new(:double, num_labels)
+      
+      labels_array = weights.keys.collect(&:to_i)
+      
+      parameter_struct[:weight_label].write_array_of_int(labels_array)
+      parameter_struct[:weight].write_array_of_double(weights.values) 
+    end
+    
+    def weights
+      @weights ||= Hash.new(1.0)
+    end
+    
+    def [](option)
+      options_hash[option]
+    end
+    
+    private
+    
+    def options_hash
+      @options_hash ||= {}
+    end
+  end
+end

data/lib/svm/problem.rb

@@ -0,0 +1,151 @@
+require 'csv'
+
+module Svm
+  class Problem
+    include CrossValidation
+
+    attr_reader :num_samples
+    attr_reader :num_features
+    attr_reader :options
+
+    attr_accessor :scaler
+
+    def self.load_from_csv(csv_path, options = {})
+      data = CSV.read(csv_path).collect do |row|
+        row.collect { |field| field.to_f }
+      end
+
+      instance = self.new(options)
+      instance.data = data
+
+      instance
+    end
+
+    def initialize(user_options = {})
+      @nodes_pointers = []
+      @options = Options.new(user_options)
+    end
+
+    def data=(samples, weights = nil)
+      @num_samples    = samples.size
+      @num_features   = samples.first.size - 1
+      @sample_weights = weights if weights
+
+      if options[:scale]
+        self.scaler = Scaler.scale(samples)
+        scaler.release_data!
+      end
+
+      problem_struct[:l] = num_samples
+      problem_struct[:svm_node] = FFI::MemoryPointer.new(FFI::Pointer, num_samples)
+      problem_struct[:y] = FFI::MemoryPointer.new(FFI::Type::DOUBLE, num_samples)
+      problem_struct[:W] = FFI::MemoryPointer.new(FFI::Type::DOUBLE, num_samples)
+
+      # Allocate memory for the samples
+      # There are num_samples each with num_features nodes
+
+      num_samples.times.each do |i|
+        sample = samples[i].collect(&:to_f)
+
+        sample_value  = sample.first
+        sample_xs     = sample[1..sample.size-1]
+        sample_weight = sample_weights[i]
+
+        problem_struct[:y].put_double(FFI::Type::DOUBLE.size * i, sample_value)
+        problem_struct[:W].put_double(FFI::Type::DOUBLE.size * i, sample_weight)
+
+        # Allocate memory for the sample
+        nodes_ptr = NodeStruct.node_array_from(sample_xs)
+        problem_struct[:svm_node].put_pointer(FFI::Pointer.size*i, nodes_ptr)
+
+        # We have to keep a reference to the pointer so it is not gargabe collected
+        @nodes_pointers << nodes_ptr
+      end
+    end
+
+    def sample(index)
+      sample_ptr = @nodes_pointers[index]
+
+      num_features.times.collect do |j|
+        node = NodeStruct.new(sample_ptr + NodeStruct.size * j)
+        node[:value]
+      end
+    end
+
+    def value(index)
+      problem_struct[:y].get_double(FFI::Type::DOUBLE.size * index)
+    end
+
+    def length
+      problem_struct[:l]
+    end
+
+    def generate_model(more_options = {})
+      set(more_options)
+
+      model_pointer = Svm.svm_train(problem_struct.pointer, options.parameter_struct.pointer)
+      model_struct = ModelStruct.new(model_pointer)
+
+      model = Model.new(model_struct)
+      model.scaler = scaler
+
+      model
+    end
+
+    def suggested_labels_weights
+      labels.inject({}) do |hash, label|
+        num = num_samples_for(label).to_f
+        hash[label.to_i] = num/num_samples
+        hash
+      end
+    end
+
+    def num_samples_for(label)
+      num_samples.times.count { |i| value(i) == label }
+    end
+
+    def labels
+      num_samples.times.collect { |i| value(i) }.uniq
+    end
+
+    def label_weights=(weights)
+      options.label_weights = weights
+      check_parameters!
+    end
+
+    def weight_for(i)
+      sample_weights[i] || 1.0
+    end
+
+    def sample_weights=(weights)
+      @sample_weights = weights
+    end
+
+    def sample_weights
+      @sample_weights ||= Array.new(num_samples, 1.0)
+    end
+
+    def estimate_probabilities=(option)
+      value = option ? 1 : 0
+
+      options.parameter_struct[:probability] = value
+    end
+
+    def set(custom_options)
+      options.add(custom_options)
+      check_parameters!
+    end
+
+    private
+
+    def problem_struct
+      @problem_struct ||= ProblemStruct.new
+    end
+
+    def check_parameters!
+      error = Svm.svm_check_parameter(problem_struct, options.parameter_struct)
+      raise ParameterError.new("The provided options are not valid: #{error}") if error
+    end
+
+  end
+end