bayesnet 0.0.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f17178cdfa472aea14e7769f1831f1903ceee2613b6e7b71e1135990dc974ab
-  data.tar.gz: c55cb95134d4dbb479e89839be7a4634b6bc6a8be52c5c066f1cc1ad21c584a7
+  metadata.gz: 7591665046345784f55275c06d1129fd91ee3f098f3800b2c03b6f9bbfd8e172
+  data.tar.gz: ec9009ab90593d42fa2506a230e5900d5a39bebb1a7fbd874953d6c86022b2eb
 SHA512:
-  metadata.gz: fda426d9dd319b2ad8300a8ba59acae511740cc271729f40b36ce7a7765d8019a901d9d83a2e955ccd964901ee604a3ad96fba092ce41394da5980a77d1bb198
-  data.tar.gz: 03d4beb66b11ba684007dd49f67ef2ae085ecd5c6e5ca9b8b63327eee109ada3b1f389731543fa6d970bff110230231bc1533022640367a906f57dec1c41bc6d
+  metadata.gz: 5e668b431f55f9239ad3ae06cdc020098ff4a8b68f7934283d6f77a3969a014aa17f68df12b23013d1681e79fdecd8f4c8e4da105e9430a16d2ab8075bbcca7b
+  data.tar.gz: 75eceac300152cfa8d0ce736b16939e779f127dc844ea0c8ce8e1d0f363b04048107533f64c744420b2631fd3e8678d6812e15c6b770e2b37a598ae290af773a

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.6.0] - 2022-06-26
+- Using variables elimination algorithm to build a distribution
+
+## [0.5.0] - 2022-02-26
+
+- Constructing networks out of the `.BIF` ([Interchange Format for Bayesian Networks](https://www.cs.washington.edu/dm/vfml/appendixes/bif.htm)) files.
+- Fixing inference bug
+- Network children nodes could be specified ***before** their parents
+
+## [0.0.3] - 2021-12-29
+
+- Fixing terminology used in Factor class
+
 ## [0.0.2] - 2021-12-28
 
 - README, CI/CD for Ruby 2.6, 2.7, 3.1 added

data/Gemfile

@@ -6,10 +6,10 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
+gem "treetop", "~> 1.6"
 
 group :development, :test do
   gem "m", "~> 1.5.0"
   gem "minitest", "~> 5.0"
   gem "pry-byebug", "~> 3.9.0"
-  gem "standard", "~> 1.3"
 end

data/Gemfile.lock

@@ -1,12 +1,11 @@
 PATH
   remote: .
   specs:
-    bayesnet (0.0.2)
+    bayesnet (0.6.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.4.2)
     byebug (11.1.3)
     coderay (1.1.3)
     m (1.5.1)
@@ -14,38 +13,16 @@ GEM
       rake (>= 0.9.2.2)
     method_source (1.0.0)
     minitest (5.15.0)
-    parallel (1.21.0)
-    parser (3.0.3.2)
-      ast (~> 2.4.1)
+    polyglot (0.3.5)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
     pry-byebug (3.9.0)
       byebug (~> 11.0)
       pry (~> 0.13.0)
-    rainbow (3.0.0)
     rake (13.0.6)
-    regexp_parser (2.2.0)
-    rexml (3.2.5)
-    rubocop (1.23.0)
-      parallel (~> 1.10)
-      parser (>= 3.0.0.0)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.12.0, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.15.0)
-      parser (>= 3.0.1.1)
-    rubocop-performance (1.12.0)
-      rubocop (>= 1.7.0, < 2.0)
-      rubocop-ast (>= 0.4.0)
-    ruby-progressbar (1.11.0)
-    standard (1.5.0)
-      rubocop (= 1.23.0)
-      rubocop-performance (= 1.12.0)
-    unicode-display_width (2.1.0)
+    treetop (1.6.11)
+      polyglot (~> 0.3)
 
 PLATFORMS
   x86_64-darwin-19
@@ -57,7 +34,7 @@ DEPENDENCIES
   minitest (~> 5.0)
   pry-byebug (~> 3.9.0)
   rake (~> 13.0)
-  standard (~> 1.3)
+  treetop (~> 1.6)
 
 BUNDLED WITH
-   2.2.32
+   2.3.3

data/README.md

@@ -1,6 +1,7 @@
 # Bayesnet
 
-This gem provides an API for building a Bayesian network and executing some queries against it.
+This gem provides an DSL for constructing Bayesian networks and let to execute basic inference queries. It is also capable of parsing .BIF format ([The Interchange Format for Bayesian Networks](https://www.cs.washington.edu/dm/vfml/appendixes/bif.htm)).
+
 
 ### Example:
 
@@ -66,12 +67,14 @@ The inference is based on summing over joint distribution, i.e. it is the simple
 most expensive way to calculate it. No optimization is implemented in this version; the code
 is more a proof of API.
 
+### [Another example](https://afurmanov.com/reducing-anxiety-with-bayesian-network) of using this gem
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'bayesnet'
+em 'bayesnet'
 ```
 
 And then execute:

data/Rakefile

@@ -9,6 +9,9 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-require "standard/rake"
+Rake::TestTask.new("regen-bif") do |t|
+  `rm ./lib/bayesnet/parsers/bif.rb`
+  `tt ./lib/bayesnet/parsers/bif.treetop`
+end
 
-task default: %i[test standard]
+task default: %i[test]

data/bayesnet.gemspec

@@ -34,7 +34,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "m", "~> 1.5.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "pry-byebug", "~> 3.9.0"
-  spec.add_development_dependency "standard", "~> 1.3"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/bayesnet/dsl.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 require "bayesnet/graph"
 
 module Bayesnet
+  # Bayesnet::DSL.define ...
   module DSL
     def define(&block)
       graph = Graph.new
       graph.instance_eval(&block) if block
+      graph.resolve_factors
       graph
     end
   end

data/lib/bayesnet/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bayesnet
   class Error < StandardError
   end

data/lib/bayesnet/factor.rb

@@ -1,89 +1,186 @@
+# frozen_string_literal: true
+
 module Bayesnet
-  # Factor if a function of sevaral variables (A, B, ...) each defined on values from finite set
+  # Factor if a function of several variables (A, B, ...), where
+  # every variable cold take values from some finite set
   class Factor
+    # +++ Factor DSL +++
+    #
+    # Factor DSL entry point:
     def self.build(&block)
       factor = new
       factor.instance_eval(&block)
       factor
     end
 
-    # Specifies variable name together with its values
-    def var(var_name_to_values)
-      @vars.merge!(var_name_to_values)
+    # Factor DSL
+    # Defining variable with list of its possible values looks like:
+    # ```
+    # Bayesnet::Factor.build do
+    #   scope weather: %i[sunny cloudy]
+    #   scope mood: %i[bad good]
+    #   ...
+    # ```
+    # ^ this code defines to variables `weather` and `mood`, where
+    # `weather` could be :sunny or :cloudy, and
+    # `mood` could be :bad or :good
+    def scope(var_name_to_values = nil)
+      if var_name_to_values
+        @scope.merge!(var_name_to_values)
+      else
+        @scope
+      end
     end
 
-    # Specifies function values for args. Latest args is an function value, all previous are argument values
-    def val(*args)
-      args = args[0] if args.size == 1 && args[0].is_a?(Array)
-      @vals[args[0..-2]] = args[-1]
+    # Factor DSL
+    # Specifies factor value for some set of variable values, i.e.
+    # ```
+    # Bayesnet::Factor.build do
+    #   scope weather: %i[sunny cloudy]
+    #   scope mood: %i[bad good]
+    #   val :sunny, :bad, 0.1
+    #   ...
+    # ```
+    # ^ this code says the value of factor for [weather == :sunny, mood == :bad] is 0.1
+    def val(*context_and_val)
+      context_and_val = context_and_val[0] if context_and_val.size == 1 && context_and_val[0].is_a?(Array)
+      @vals[context_and_val[0..-2]] = context_and_val[-1]
     end
+    # --- Factor DSL ---
 
+    # List of variable names
     def var_names
-      @vars.keys
+      @scope.keys
     end
 
-    def [](*args)
-      key = if args.size == 1 && args[0].is_a?(Hash)
-        args[0].slice(*var_names).values
-      else
-        args
-      end
+    # accessor factor value, i.e
+    # ```
+    # factor = Bayesnet::Factor.build do
+    #   scope weather: %i[sunny cloudy]
+    #   scope mood: %i[bad good]
+    #   val :sunny, :bad, 0.1
+    #   ...
+    # end
+    # factor[:sunny, :bad] # 0.1
+    # ```
+    def [](*context)
+      key = if context.size == 1 && context[0].is_a?(Hash)
+              context[0].slice(*var_names).values
+            else
+              context
+            end
       @vals[key]
     end
 
-    def self.from_distribution(var_distribution)
-      self.class.new(var_distribution.keys, var_distribution.values.map(&:to_a))
-    end
-
-    def args(*var_names)
+    # returns all combinations of values of `var_names`
+    def contextes(*var_names)
       return [] if var_names.empty?
-      @vars[var_names[0]].product(*var_names[1..].map { |var_name| @vars[var_name] })
+
+      @scope[var_names[0]].product(*var_names[1..].map { |var_name| @scope[var_name] })
     end
 
+    # returns all possible values
     def values
       @vals.values
     end
 
+    # returns new normalized factor, i.e. where sum of all values is 1.0
     def normalize
       vals = @vals.clone
       norm_factor = vals.map(&:last).sum * 1.0
-      vals.each { |k, v| vals[k] /= norm_factor }
-      self.class.new(@vars.clone, vals)
+      vals.each { |k, _v| vals[k] /= norm_factor }
+      self.class.new(@scope.clone, vals)
     end
 
-    def limit_by(evidence)
-      # todo: use Hash#except when Ruby 2.6 support no longer needed
-      evidence_keys_set = evidence.keys.to_set
-      vars = @vars.reject { |k, _| evidence_keys_set.include?(k) }
+    # Returns factor built as follows:
+    # 1. Original factor gets filtered out by variables having values compatible with `context`
+    # 2. Returned factor does not have any variables from `context` (because they have
+    # same values, after step 1)
+    # The `context` argument supposed to be an evidence, somewhat like
+    # `{weather: :sunny}`
+    def reduce_to(context)
+      limited_context = context.slice(*scope.keys)
+      return self.class.new(@scope, @vals) if limited_context.empty?
+      limited_scope = @scope.slice(*(@scope.keys - limited_context.keys))
 
-      evidence_vals = evidence.values
-      indices = evidence.keys.map { |k| index_by_var_name[k] }
-      vals = @vals.select { |k, v| indices.map { |i| k[i] } == evidence_vals }
-      vals.transform_keys! { |k| k - evidence_vals }
+      context_vals = limited_context.values
+      indices = limited_context.keys.map { |k| index_by_var_name[k] }
+      vals = @vals.select { |k, _v| indices.map { |i| k[i] } == context_vals }
+      vals.transform_keys! { |k| delete_by_indices(k, indices) }
 
-      self.class.new(vars, vals)
+      self.class.new(limited_scope, vals)
     end
 
-    def reduce(over_vars)
-      vars = @vars.slice(*over_vars)
-      indices = vars.keys.map { |k| index_by_var_name[k] }
-      vals = @vals.group_by { |args, val| indices.map { |i| args[i] } }
+    # Returns new context defined over `var_names`, all other variables
+    # get eliminated. For every combination of `var_names`'s values
+    # the value of new factor is defined by summing up values in original factor
+    # having compatible value
+    def marginalize(var_names)
+      scope = @scope.slice(*var_names)
+
+      indices = scope.keys.map { |k| index_by_var_name[k] }
+      vals = @vals.group_by { |context, _val| indices.map { |i| context[i] } }
       vals.transform_values! { |v| v.map(&:last).sum }
-      reduced = self.class.new(vars, vals)
-      reduced.normalize
+
+      self.class.new(scope, vals)
+    end
+
+    def eliminate(var_name)
+      keep_var_names = var_names
+      keep_var_names.delete(var_name)
+      marginalize(keep_var_names)
+    end
+
+    def select(subcontext)
+      @vals.select do |context, _|
+        var_names.zip(context).slice(subcontext.keys) == subcontext
+      end
+    end
+
+    def *(other)
+      common_scope = @scope.keys & other.scope.keys
+      new_scope = scope.merge(other.scope)
+      new_vals = {}
+      group1 = group_by_scope_values(common_scope)
+      group2 = other.group_by_scope_values(common_scope)
+      group1.each do |scope, vals1|
+        combo = vals1.product(group2[scope])
+        combo.each do |(val1, val2)|
+          # values in scope must match variables order in new_scope, i.e.
+          # they must match `new_scope.var_names`
+          # The code bellow ensures it by merging two hashes in the same
+          # wasy as `new_scope`` is constructed above
+          val_by_name1 = var_names.zip(val1.first).to_h
+          val_by_name2 = other.var_names.zip(val2.first).to_h
+          new_vals[val_by_name1.merge(val_by_name2).values] = val1.last*val2.last
+        end
+      end
+      Factor.new(new_scope, new_vals)
+    end
+
+    def group_by_scope_values(scope_keys)
+      indices = scope_keys.map { |k| index_by_var_name[k] }
+      @vals.group_by { |context, _val| indices.map { |i| context[i] } }
     end
 
     private
 
-    def initialize(vars = {}, vals = {})
-      @vars = vars
+    def delete_by_indices(array, indices)
+      result = array.dup
+      indices.map { |i| result[i] = nil }
+      result.compact
+    end
+
+    def initialize(scope = {}, vals = {})
+      @scope = scope
       @vals = vals
     end
 
     def index_by_var_name
       return @index_by_var_name if @index_by_var_name
+
       @index_by_var_name = {}
-      @vars.each_with_index { |(k, v), i| @index_by_var_name[k] = i }
+      @scope.each_with_index { |(k, _v), i| @index_by_var_name[k] = i }
       @index_by_var_name
     end
   end

data/lib/bayesnet/graph.rb

@@ -1,33 +1,123 @@
+# frozen_string_literal: true
+
 require "bayesnet/node"
 
 module Bayesnet
+  # Acyclic graph
   class Graph
+    include Bayesnet::Logging
+
     attr_reader :nodes
 
     def initialize
       @nodes = {}
     end
 
-    def var_names
-      nodes.keys
-    end
-
+    # +++ Graph DSL +++
     def node(name, parents: [], &block)
       raise Error, "DSL error, #node requires a &block" unless block
-      node = Node.new(name, @nodes.slice(*parents))
+
+      node = Node.new(name, parents)
       node.instance_eval(&block)
       @nodes[name] = node
     end
+    # --- Graph DSL ---
+
+    # returns names of all nodes
+    def var_names
+      nodes.keys
+    end
+
+    # returns normalized distribution reduced to `evidence`
+    # and marginalized over `over`
+    def distribution(over: [], evidence: {}, algorithm: :variables_elimination)
+      case algorithm
+      when :brute_force
+        joint_distribution
+          .reduce_to(evidence)
+          .marginalize(over)
+          .normalize
+      when :variables_elimination
+        reduced_factors = nodes.values.map(&:factor).map { |f| f.reduce_to(evidence) }
+        not_include_in_order = evidence.keys.to_set + over.to_set
+        variables_order = elimination_order.reject { |v| not_include_in_order.include?(v) }
+        distribution = eliminate_variables(variables_order, reduced_factors)
+        distribution.normalize
+      else
+        raise "Uknown algorithm #{algorithm}"
+      end
+    end
+
+    def elimination_order
+      return @order if @order
+      @order = []
+      edges = Set.new
+      @nodes.each do |name, node|
+        parents = node.parent_nodes.keys
+        parents.each { |p| edges.add([name, p].to_set) }
+        parents.combination(2) { |p1, p2| edges.add([p1, p2].to_set) }
+      end
+      # edges now are moralized graph of `self`, just represented differently as
+      # set of edges
+
+      remaining_nodes = nodes.keys.to_set
+      until remaining_nodes.empty?
+        best_node = find_min_neighbor(remaining_nodes, edges)
+        remaining_nodes.delete(best_node)
+        @order.push(best_node)
+        clique = edges.select { |e| e.include?(best_node) }
+        edges -= clique
+        if edges.empty? #i.e. clique is the last edge
+          @order += remaining_nodes.to_a
+          remaining_nodes = Set.new
+        end
+        clique.
+          map { |e| e.delete(best_node) }.
+          map(&:first).
+          combination(2) { |p1, p2| edges.add([p1,p2].to_set) }
+      end
+      @order
+    end
 
-    def distribution(over: [], evidence: {})
-      limited = joint_distribution.limit_by(evidence)
-      limited.reduce(over)
+    def find_min_neighbor(remaining_nodes, edges)
+      result = nil
+      min_neighbors = nil
+      remaining_nodes.each do |name, _|
+        neighbors = edges.count { |e| e.include?(name) }
+        if min_neighbors.nil? || neighbors < min_neighbors
+          min_neighbors = neighbors
+          result = name
+        end
+      end
+      result
+    end
+
+    def eliminate_variables(variables_order, factors)
+      logger.debug "Eliminating variables #{variables_order} from #{factors.size} factors #{factors.map(&:var_names)}"
+      remaining_factors = factors.to_set
+      variables_order.each do |var_name|
+        logger.debug "Eliminating '#{var_name}'..."
+        grouped_factors = remaining_factors.select { |f| f.var_names.include?(var_name) }
+        remaining_factors -= grouped_factors
+        logger.debug "Building new factor out of #{grouped_factors.size} factors having '#{var_name}' - #{grouped_factors.map(&:var_names)}"
+        product_factor = grouped_factors.reduce(&:*)
+        logger.debug "Removing variable from new factor"
+        new_factor = product_factor.eliminate(var_name)
+        logger.debug "New factor variables are #{new_factor.var_names}"
+        remaining_factors.add(new_factor)
+        logger.debug "The variable '#{var_name}' is elminated"
+      end
+      logger.debug "Non-eliminated variables are #{remaining_factors.map(&:var_names).flatten.uniq}"
+      result = remaining_factors.reduce(&:*)
+      logger.debug "Eliminating is done"
+      result
     end
 
     # This is MAP query, i.e. Maximum a Posteriory
+    # returns value of `var_name` having maximum likelihood, when `evidence` is observed
     def most_likely_value(var_name, evidence:)
       posterior_distribution = distribution(over: [var_name], evidence: evidence)
-      mode = posterior_distribution.args(var_name).zip(posterior_distribution.values).max_by(&:last)
+      mode = posterior_distribution.contextes(var_name).zip(posterior_distribution.values).max_by(&:last)
       mode.first.first
     end
 
@@ -37,6 +127,7 @@ module Bayesnet
       posterior_distribution[*over_vars.values]
     end
 
+    # Essentially it builds product of all node's factors
     def joint_distribution
       return @joint_distribution if @joint_distribution
 
@@ -47,17 +138,27 @@ module Bayesnet
 
       factor = Factor.new
       @nodes.each do |node_name, node|
-        factor.var node_name => node.values
+        factor.scope node_name => node.values
       end
 
-      factor.args(*var_names).each do |args|
-        val_by_name = var_names.zip(args).to_h
+      factor.contextes(*var_names).each do |context|
+        val_by_name = var_names.zip(context).to_h
         val = nodes.values.reduce(1.0) do |prob, node|
           prob * node.factor[val_by_name]
         end
-        factor.val args + [val]
+        factor.val context + [val]
       end
       @joint_distribution = factor.normalize
     end
+
+    def parameters
+      nodes.values.map(&:parameters).sum
+    end
+
+    def resolve_factors
+      @nodes.values.each do |node|
+        node.resolve_factor(@nodes.slice(*node.parent_nodes))
+      end
+    end
   end
 end

data/lib/bayesnet/logging.rb

@@ -0,0 +1,13 @@
+# lib/logging.rb
+
+module Bayesnet
+  def self.logger
+    @logger ||= Logger.new(STDOUT).tap { |l| l.level = :debug }
+  end
+
+  module Logging
+    def logger
+      Bayesnet.logger
+    end
+  end
+end

data/lib/bayesnet/node.rb

@@ -6,8 +6,10 @@ module Bayesnet
       @name = name
       @parent_nodes = parent_nodes
       @values = []
+      @factor = Factor.new
     end
 
+    # +++ Node DSL +++
     def values(hash_or_array = nil, &block)
       case hash_or_array
       when NilClass
@@ -16,7 +18,7 @@ module Bayesnet
         @values = hash_or_array.keys
         node = self
         @factor = Factor.build do
-          var node.name => node.values
+          scope node.name => node.values
           hash_or_array.each do |value, probability|
             val [value, probability]
           end
@@ -24,25 +26,39 @@ module Bayesnet
       when Array
         raise Error, "DSL error, #values requires a &block when first argument is an Array" unless block
         @values = hash_or_array
-        node = self
-        @factor = Factor.build do
-          var node.name => node.values
-          node.parent_nodes.each do |parent_node_name, parent_node|
-            var parent_node_name => parent_node.values
-          end
-        end
-        instance_eval(&block)
+        @factor = block
       end
     end
 
     def distributions(&block)
       instance_eval(&block)
     end
+    # --- Node DSL ---
+
+    def parameters
+      (values.size - 1) * parent_nodes.values.reduce(1) { |mul, n| mul * n.values.size }
+    end
 
     def as(distribution, given:)
       @values.zip(distribution).each do |value, probability|
         @factor.val [value] + given + [probability]
       end
     end
+
+    def resolve_factor(parent_nodes)
+      @parent_nodes = parent_nodes
+      if @factor.is_a?(Proc)
+        proc = @factor
+        node = self
+        @factor = Factor.build do
+          scope node.name => node.values
+          node.parent_nodes.each do |parent_node_name, parent_node|
+            scope parent_node_name => parent_node.values
+          end
+        end
+        instance_eval(&proc)
+      end
+    end
+
   end
 end