sbn 0.9.0

data/lib/variable.rb

@@ -0,0 +1,224 @@
+class Sbn
+  class Variable
+    attr_reader :name, :states, :parents, :children, :probability_table
+    
+    def initialize(net, name = '', probabilities = [0.5, 0.5], states = [:true, :false])
+      @net = net
+      @@variable_count ||= 0
+      @@variable_count += 1
+      name = "variable_#{@@variable_count}" if name.is_a? String and name.empty?
+      @name = name.to_underscore_sym
+      @children = []
+      @parents = []
+      @states = []
+      @state_frequencies = {} # used for storing sample points
+      set_states(states)
+      set_probabilities(probabilities)
+      net.add_variable(self)
+    end
+    
+    def ==(obj); test_equal(obj); end
+    def eql?(obj); test_equal(obj); end
+    def ===(obj); test_equal(obj); end
+
+    def to_s
+      @name.to_s
+    end
+    
+    def to_xmlbif_variable(xml)
+      xml.variable(:type => "nature") do
+        xml.name(@name.to_s)
+        @states.each {|s| xml.outcome(s.to_s) }
+        xml.property("SbnVariableType = #{self.class.to_s}")
+        yield(xml) if block_given?
+      end
+    end
+    
+    def to_xmlbif_definition(xml)
+      xml.definition do
+        xml.for(@name.to_s)
+        @parents.each {|p| xml.given(p.name.to_s) }
+        xml.table(@probability_table.transpose.last.join(' '))
+        yield(xml) if block_given?
+      end
+    end
+
+    def set_states(states)
+      states.symbolize_values!
+      @states = states
+      generate_probability_table
+    end
+    
+    def set_probability(probability, event)
+      event = @net.symbolize_evidence(event)
+      unless can_be_evaluated?(event)
+        raise "A valid state was not supplied for variable #{@name} and all its parents in call to set_probability()"
+      end
+      combination_for_this_event = []
+      @parents.each {|p| combination_for_this_event << event[p.name] }
+      combination_for_this_event << event[@name]
+      index = state_combinations.index(combination_for_this_event)
+      @probabilities[index] = probability
+      generate_probability_table
+    end
+
+    def add_child(variable)
+      add_child_no_recurse(variable)
+      variable.add_parent_no_recurse(self)
+    end
+
+    def add_parent(variable)
+      add_parent_no_recurse(variable)
+      variable.add_child_no_recurse(self)
+    end
+    
+    def set_probabilities(probs)
+      @probabilities = probs
+      generate_probability_table
+    end
+    
+    def evidence_name # :nodoc:
+      @name
+    end
+    
+    def add_child_no_recurse(variable) # :nodoc:
+      return if variable == self or @children.include?(variable)
+      if variable.is_a?(StringVariable)
+        @children.concat variable.covariables
+      else
+        @children << variable
+      end
+      variable.generate_probability_table
+    end
+    
+    def add_parent_no_recurse(variable) # :nodoc:
+      return if variable == self or @parents.include?(variable)
+      if variable.is_a?(StringVariable)
+        @parents.concat variable.covariables
+      else
+        @parents << variable
+      end
+      generate_probability_table
+    end
+    
+    def set_in_evidence?(evidence) # :nodoc:
+      evidence.has_key?(evidence_name)
+    end
+    
+    def get_observed_state(evidence) # :nodoc:
+      evidence[@name]
+    end
+
+  	# A variable can't be evaluated unless its parents have
+  	# been observed    
+    def can_be_evaluated?(evidence) # :nodoc:
+      returnval = true
+      parents.each {|p| returnval = false unless p.set_in_evidence?(evidence) }
+      returnval
+    end
+    
+  	# In order to draw uniformly from the probabilty space, we can't
+  	# just pick a random state.  Instead we generate a random number
+  	# between zero and one and iterate through the states until the 
+  	# cumulative sum of their probabilities exceeds our random number.    
+    def get_random_state(event = {}) # :nodoc:
+      seek_state {|s| evaluate_marginal(s, event) }
+    end
+    
+  	# similar to get_random_state() except it evaluates a variable's markov
+  	# blanket in addition to the variable itself.
+    def get_random_state_with_markov_blanket(event) # :nodoc:
+      evaluations = []
+      @states.each {|s| evaluations << evaluate_markov_blanket(s, event) }
+      evaluations.normalize!
+      seek_state {|s| evaluations.shift }
+    end
+
+    def generate_probability_table # :nodoc:
+      @probab
+      @probability_table = nil
+      if @probabilities and @probabilities.size == state_combinations.size
+        probs = @probabilities.dup
+        @probability_table = state_combinations.collect {|e| [e, probs.shift] }
+      end
+    end
+
+    def evaluate_marginal(state, event) # :nodoc:
+      temp_probs = @probability_table.dup
+      remove_irrelevant_states(temp_probs, state, event)
+      sum = 0.0
+      temp_probs.each {|e| sum += e[1] }
+      sum
+    end
+    
+    def transform_evidence_value(val) # :nodoc:
+      val.to_underscore_sym       
+    end
+    
+  private
+    def seek_state
+      sum = 0.0
+      num = rand
+      returnval = nil
+      @states.each do |s|
+        returnval = s
+        sum += yield(s)
+        break if num < sum
+      end
+      returnval
+    end
+  
+    def state_combinations
+      all_states = []
+      @parents.each {|p| all_states << p.states }
+      all_states << @states
+      Combination.new(all_states).to_a
+    end
+  
+    def remove_irrelevant_states(probabilities, state, evidence)
+      # remove the states for this variable
+      probabilities.reject! {|e| e.first.last != state }
+      index = 0
+      @parents.each do |parent|
+        unless parent.set_in_evidence?(evidence)
+          raise "Marginal cannot be evaluated because there are unset parent variables"
+        end
+        probabilities.reject! {|e| e.first[index] != parent.get_observed_state(evidence) }
+        index += 1
+      end
+      probabilities
+    end
+    
+    def evaluate_markov_blanket(state, event)
+      returnval = 1.0
+      temp_probs = @probability_table.dup
+      remove_irrelevant_states(temp_probs, state, event)
+      temp = get_observed_state(event)
+      event[@name] = state
+      returnval *= evaluate_marginal(state, event)
+      @children.each {|child| returnval *= child.evaluate_marginal(child.get_observed_state(event), event) }
+      event[@name] = temp
+      returnval
+    end
+
+    def test_equal(variable)
+      returnval = true
+      net_name = variable.instance_eval('@net.name')
+      returnval = false unless @net.name == net_name
+      returnval = false unless variable.class == self.class and self.is_a? Variable
+      returnval = false unless returnval and @name == variable.name
+      if returnval
+        parent_names = []
+        variable.parents.each {|p| parent_names << p.name.to_s }
+        my_parent_names = []
+        @parents.each {|p| my_parent_names << p.name.to_s }
+        returnval = false unless parent_names.sort == my_parent_names.sort
+        returnval = false unless @states == variable.states
+        table = variable.probability_table.transpose.last
+        my_table = @probability_table.transpose.last
+        returnval = false unless table == my_table
+      end
+      returnval
+    end
+  end
+end

data/test/sbn.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+files = Dir[File.dirname(__FILE__) + '/*.rb']
+files.each do |f|
+  require f unless f =~ /sbn/
+end

data/test/test_combination.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sbn'
+
+class TestCombination < Test::Unit::TestCase # :nodoc:
+  def setup
+    @c = Combination.new([[1, 2], [3, 4, 5]])
+  end
+
+  def test_current
+    test_first
+    test_last
+  end
+
+  def test_each
+    @c.first
+    combinations = [[1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5]]
+    index = 0
+    @c.each do |comb|
+      assert_equal combinations[index], comb
+      index += 1
+    end
+  end
+
+  def test_first
+    @c.first
+    assert_equal @c.current, [1, 3]
+  end
+
+  def test_last
+    @c.last
+    assert_equal @c.current, [2, 5]
+  end
+
+  def test_next_combination
+    @c.first
+    assert_equal @c.next_combination, [1, 4]
+    assert_equal @c.next_combination, [1, 5]
+    assert_equal @c.next_combination, [2, 3]
+    assert_equal @c.next_combination, [2, 4]
+    assert_equal @c.next_combination, [2, 5]
+  end
+
+  def test_prev_combination
+    @c.last
+    assert_equal @c.prev_combination, [2, 4]
+    assert_equal @c.prev_combination, [2, 3]
+    assert_equal @c.prev_combination, [1, 5]
+    assert_equal @c.prev_combination, [1, 4]
+    assert_equal @c.prev_combination, [1, 3]
+  end
+end

data/test/test_helpers.rb

@@ -0,0 +1,80 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sbn'
+
+class EnumsTester
+  enums %w(FOO BAR BAZ)
+  bitwise_enums %w(ONE TWO FOUR EIGHT)  
+end
+
+class TestHelpers < Test::Unit::TestCase # :nodoc:
+  # Tests for Enumerable helpers
+  def test_sum
+    assert_equal 45, (1..9).sum
+  end
+
+  def test_average
+    # Ranges don't have a length
+    assert_in_delta 5.0, (1..9).to_a.average, 0.01
+  end
+
+  def test_sample_variance
+    assert_in_delta 6.6666, (1..9).to_a.sample_variance, 0.0001
+  end
+
+  def test_standard_deviation
+    assert_in_delta 2.5819, (1..9).to_a.standard_deviation, 0.0001
+  end
+  
+  def test_enums
+    assert_equal EnumsTester::FOO, 0
+    assert_equal EnumsTester::BAR, 1
+    assert_equal EnumsTester::BAZ, 2
+    assert_equal EnumsTester::ONE, 1
+    assert_equal EnumsTester::TWO, 2
+    assert_equal EnumsTester::FOUR, 4
+    assert_equal EnumsTester::EIGHT, 8
+  end
+  
+  def test_to_underscore_sym
+    assert_equal 'THIS IS AN UGLY STRING'.to_underscore_sym, :this_is_an_ugly_string
+    assert_equal 'this is an ugly string'.to_underscore_sym, :this_is_an_ugly_string
+    assert_equal :"this is an ugly string".to_underscore_sym, :this_is_an_ugly_string
+    assert_equal :"THIS IS AN UGLY STRING".to_underscore_sym, :this_is_an_ugly_string
+  end
+  
+  def test_symbolize_values
+    assert_not_equal %w(one two three), [:one, :two, :three]
+    assert_equal %w(one two three).symbolize_values, [:one, :two, :three]
+    arr = %w(one two three)
+    arr.symbolize_values!
+    assert_equal arr, [:one, :two, :three]
+  end
+  
+  def test_symbolize_keys_and_values
+    assert_not_equal({"one" => "two", "three" => "four"}, {:one => :two, :three => :four})
+    assert_equal({"one" => "two", "three" => "four"}.symbolize_keys_and_values, {:one => :two, :three => :four})
+    h = {"one" => "two", "three" => "four"}
+    h.symbolize_keys_and_values!
+    assert_equal(h, {:one => :two, :three => :four})
+  end
+  
+  def test_normalize
+    assert_equal [0.1, 0.1].normalize, [0.5, 0.5]
+    assert_equal [2, 2, 4].normalize, [0.25, 0.25, 0.5]
+    assert_equal [1, 1, 1, 1, 1].normalize, [0.2, 0.2, 0.2, 0.2, 0.2]
+    arr = [1, 1, 1, 1, 1]
+    arr.normalize!
+    assert_equal arr, [0.2, 0.2, 0.2, 0.2, 0.2]
+  end
+  
+  def test_ngrams
+    two_ngram_array = ["TH", "HI", "IS", "S ", " I", "IS", "S ", " A", "A ", " S", "ST", "TR", "RI", "IN", "NG"]
+    assert_equal "THIS IS A STRING".ngrams(2), two_ngram_array
+    three_ngram_array = ["THI", "HIS", "IS ", "S I", " IS", "IS ", "S A", " A ", "A S", " ST", "STR", "TRI", "RIN", "ING"]
+    assert_equal "THIS IS A STRING".ngrams(3), three_ngram_array
+    four_ngram_array = ["THIS", "HIS ", "IS I", "S IS", " IS ", "IS A", "S A ", " A S", "A ST", " STR", "STRI", "TRIN", "RING"]
+    assert_equal "THIS IS A STRING".ngrams(4), four_ngram_array
+    five_ngram_array = ["THIS ", "HIS I", "IS IS", "S IS ", " IS A", "IS A ", "S A S", " A ST", "A STR", " STRI", "STRIN", "TRING"]
+    assert_equal "THIS IS A STRING".ngrams(5), five_ngram_array
+  end
+end

data/test/test_learning.rb

@@ -0,0 +1,104 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sbn'
+
+class TestLearning < Test::Unit::TestCase # :nodoc:
+  def setup
+    @net = Sbn::Net.new("Categorization")
+    @category = Sbn::Variable.new(@net, :category, [0.33, 0.33, 0.33], [:food, :groceries, :gas])
+    @text = Sbn::StringVariable.new(@net, :text)
+    @category.add_child(@text)
+  end
+  
+  def test_string_learning
+    @net.learn([
+      {:category => :food, :text => 'foo'},
+      {:category => :food, :text => 'gro'},
+      {:category => :food, :text => 'foo'},
+      {:category => :food, :text => 'foo'},
+      {:category => :groceries, :text => 'gro'},
+      {:category => :groceries, :text => 'gro'},
+      {:category => :groceries, :text => 'foo'},
+      {:category => :groceries, :text => 'gro'},
+      {:category => :gas, :text => 'gas'},
+      {:category => :gas, :text => 'gas'},
+      {:category => :gas, :text => 'gas'},
+      {:category => :gas, :text => 'gas'}
+    ])
+    probs = @category.probability_table.dup
+    food_prob = probs.shift.pop
+    groceries_prob = probs.shift.pop
+    gas_prob = probs.shift.pop
+    assert_in_delta food_prob, 0.333, 0.001
+    assert_in_delta groceries_prob, 0.333, 0.001
+    assert_in_delta gas_prob, 0.333, 0.001
+  end
+  
+  def test_is_complete_evidence_eh
+    assert !@text.is_complete_evidence?({})
+    assert !@text.is_complete_evidence?(:text => "doughnuts")
+    assert @text.is_complete_evidence?(:text => "doughnuts", :category => :food)    
+  end
+
+  def test_var_add_sample_point
+    assert_raise(RuntimeError) { @category.add_sample_point(:text => "apples") }
+    
+    # we have to add at least one sample point to initialize the container
+    @category.add_sample_point(:category => :groceries, :text => "albertsons")
+    sample_point = {:category => :gas, :text => "gas n go"}
+    sample_points = @category.instance_variable_get('@sample_points')
+    assert !sample_points.include?(sample_point)
+    @category.add_sample_point(sample_point)
+    assert sample_points.include?(sample_point)
+  end
+
+  def test_var_set_probabilities_from_sample_points
+    # test regular variable
+    @category.add_sample_point(:category => :food, :text => "foo")
+    @category.add_sample_point(:category => :food, :text => "foo")
+    @category.add_sample_point(:category => :groceries, :text => 'gro')
+    @category.add_sample_point(:category => :gas, :text => 'gas')
+    @category.set_probabilities_from_sample_points!
+    prob_table = @category.instance_variable_get('@probability_table')
+    assert_equal prob_table.transpose.last, [0.4999, 0.2499, 0.2499]
+    
+    # test numeric variable
+    basicvar = Sbn::Variable.new(@net, :basicvar)
+    numvar = Sbn::NumericVariable.new(@net, :numvar)
+    numvar.add_parent(basicvar)
+    numvar.add_sample_point(:basicvar => :true, :numvar => 1.0)
+    numvar.add_sample_point(:basicvar => :false, :numvar => 2.0)
+    numvar.add_sample_point(:basicvar => :true, :numvar => 3.0)
+    numvar.add_sample_point(:basicvar => :false, :numvar => 4.0)
+    numvar.add_sample_point(:basicvar => :true, :numvar => 5.0)
+    numvar.set_probabilities_from_sample_points!
+    prob_table = numvar.instance_variable_get('@probability_table')
+    probs = prob_table.transpose.last
+    expected_probs = [0.0001, 0.0001, 0.333233333333333, 0.0001, 0.0001,
+      0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.333233333333333, 0.0001,
+      0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.333233333333333,
+      0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.4999,
+      0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001,
+      0.4999, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001]
+    probs.each {|p| assert_in_delta(p, expected_probs.shift, 0.001) }
+  end
+
+  def test_accumulate_state_frequencies
+    @category.add_sample_point(:category => :food, :text => "foo")
+    @category.add_sample_point(:category => :food, :text => "foo")
+    @category.add_sample_point(:category => :groceries, :text => 'gro')
+    @category.add_sample_point(:category => :gas, :text => 'gas')
+    @category.instance_eval('accumulate_state_frequencies')
+    freq = @category.instance_variable_get('@state_frequencies')
+    assert_equal(freq, {[:groceries] => 1, [:gas] => 1, [:food] => 2})
+  end
+
+  def test_net_add_sample_point
+    set = {:category => :food, :text => "foo"}
+    @net.add_sample_point(set)
+    variables = @net.instance_variable_get('@variables')
+    variables.each do |key, var|
+      sample_points = var.instance_variable_get('@sample_points')
+      assert sample_points.include?(set) if sample_points
+    end
+  end
+end

data/test/test_net.rb

@@ -0,0 +1,136 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sbn'
+
+class TestNet < Test::Unit::TestCase # :nodoc:
+  def setup
+    @net       = Sbn::Net.new("Grass Wetness Belief Net")
+    @cloudy    = Sbn::Variable.new(@net, :cloudy, [0.5, 0.5])
+    @sprinkler = Sbn::Variable.new(@net, :sprinkler, [0.1, 0.9, 0.5, 0.5])
+    @rain      = Sbn::Variable.new(@net, :rain, [0.8, 0.2, 0.2, 0.8])
+    @grass_wet = Sbn::Variable.new(@net, :grass_wet, [0.99, 0.01, 0.9, 0.1, 0.9, 0.1, 0.0, 1.0])
+    @cloudy.add_child(@sprinkler)
+    @cloudy.add_child(@rain)
+    @sprinkler.add_child(@grass_wet)
+    @rain.add_child(@grass_wet)
+    @evidence = {:sprinkler => :false, :rain => :true}
+  end
+  
+  def generate_simple_network
+    net = Sbn::Net.new("Test")
+    var1 = Sbn::Variable.new(net, :var1)
+    var2 = Sbn::Variable.new(net, :var2, [0.25, 0.75, 0.75, 0.25])
+    var2.add_parent(var1)
+    net
+  end
+  
+  def test_inference_on_grasswet_with_evidence_querying_grasswet
+    @net.set_evidence @evidence
+    probs = @net.query_variable(:grass_wet)
+    assert_in_delta(probs[:true], 0.9, 0.1)
+    assert_in_delta(probs[:false], 0.1, 0.1)
+  end
+
+  def test_inference_on_grasswet_with_evidence_querying_cloudy
+    @net.set_evidence @evidence
+    probs = @net.query_variable(:cloudy)
+    assert_in_delta(probs[:true], 0.8780487804878049, 0.1)
+    assert_in_delta(probs[:false], 0.12195121951219512, 0.1)
+  end
+
+  def test_inference_on_grasswet_without_evidence_querying_cloudy
+    @net.set_evidence({})
+    probs = @net.query_variable(:cloudy)
+    assert_in_delta(probs[:true], 0.5, 0.1)
+    assert_in_delta(probs[:false], 0.5, 0.1)
+  end
+
+  def test_inference_on_grasswet_without_evidence_querying_sprinkler
+    @net.set_evidence({})
+    probs = @net.query_variable(:sprinkler)
+    assert_in_delta(probs[:true], 0.3, 0.1)
+    assert_in_delta(probs[:false], 0.7, 0.1)
+  end
+
+  def test_inference_on_grasswet_without_evidence_querying_rain
+    @net.set_evidence({})
+    probs = @net.query_variable(:rain)
+    assert_in_delta(probs[:true], 0.5, 0.1)
+    assert_in_delta(probs[:false], 0.5, 0.1)
+  end
+
+  def test_inference_on_grasswet_without_evidence_querying_grasswet
+    @net.set_evidence({})
+    probs = @net.query_variable(:grass_wet)
+    assert_in_delta(probs[:true], 0.6471, 0.1)
+    assert_in_delta(probs[:false], 0.3529, 0.1)
+  end
+  
+  def test_import_export
+    output = @net.to_xmlbif
+    newnet = Sbn::Net.from_xmlbif(output)
+    assert_equal @net, newnet
+  end
+  
+  def test_equality
+    net1 = generate_simple_network
+    net2 = generate_simple_network
+    net3 = Sbn::Net.new('Another Net')
+    assert_equal net1, net2
+    assert_not_equal net1, net3
+  end
+  
+  def test_add_variable
+    net = generate_simple_network
+    assert net.instance_variable_get('@variables').has_key?(:var1)
+    assert net.instance_variable_get('@variables').has_key?(:var2)
+  end
+  
+  def test_query_variable
+    net = generate_simple_network
+    net.set_evidence :var1 => :true
+    probs = net.query_variable(:var2)
+    assert probs.has_key?(:true)
+    assert probs.has_key?(:false)
+    assert_in_delta(probs[:true], 0.25, 0.1)
+    assert_in_delta(probs[:false], 0.75, 0.1)
+  end
+  
+  def test_set_evidence
+    net = generate_simple_network
+    net.set_evidence :var2 => :false
+    variables = net.instance_variable_get('@variables')
+    evidence = net.instance_variable_get('@evidence')
+    assert variables[:var2].set_in_evidence?(evidence)
+    assert !variables[:var1].set_in_evidence?(evidence)
+  end
+  
+  def test_symbolize_evidence
+    # Create a network with each kind of variable and make sure evidence
+    # transformation works.
+    net = Sbn::Net.new("Test")
+    basic_var = Sbn::Variable.new(net, :basic_var)
+    string_var = Sbn::StringVariable.new(net, :string_var)
+    num_var = Sbn::NumericVariable.new(net, :num_var, [0.5, 0.5], [1.0])
+    string_var.add_sample_point({:basic_var => :true, :string_var => "test", :num_var => 1.5})
+    
+    # should not be able to set covariables directly
+    assert_raise(RuntimeError) { net.set_evidence({:string_var_covar_1 => :true}) }
+    
+    net.set_evidence 'BASIC VAR' => 'true', 'string_var' => "TesT", 'num_var' => 3
+    evidence = net.instance_variable_get('@evidence')
+    assert evidence.has_key?(:basic_var)
+    assert !evidence.has_key?('BASIC VAR')
+    assert evidence[:basic_var].is_a?(Symbol)
+    assert_equal evidence[:basic_var], :true
+    
+    assert evidence.has_key?(:string_var)
+    assert !evidence.has_key?('string_var')
+    assert evidence[:string_var].is_a?(String)
+    assert_equal evidence[:string_var], evidence[:string_var].downcase
+    
+    assert evidence.has_key?(:num_var)
+    assert !evidence.has_key?('num_var')
+    assert evidence[:num_var].is_a?(Float)
+    assert_equal evidence[:num_var], 3.0
+  end
+end