glymour 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in glymour.gemspec
+gemspec

data/README

@@ -0,0 +1,5 @@
+Installation
+
+This gem requires a copy of the R interpreter and the vcd library in R.
+
+Install the packages in required_r_packages with "R CMD INSTALL [package name]".

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/glymour.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "glymour/version"
+
+Gem::Specification.new do |s|
+  s.name        = "glymour"
+  s.version     = Glymour::VERSION
+  s.authors     = ["Brian Stanwyck"]
+  s.email       = ["brian.stanwyck@ncf.edu"]
+  s.homepage    = ""
+  s.summary     = %q{A gem for supervised Bayesian net structure learning}
+  s.description = %q{Implements supervised Bayesian structure learning, as well as extra tools to help train a Bayesian net using ActiveRecord data}
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "ruby-debug"
+  
+  s.add_dependency 'rgl'
+  s.add_dependency 'sbn'
+  s.add_dependency 'rinruby'
+
+  s.rubyforge_project = "glymour"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/glymour/version.rb

@@ -0,0 +1,3 @@
+module Glymour
+  VERSION = "0.0.1"
+end

data/lib/glymour.rb

@@ -0,0 +1,241 @@
+require "glymour"
+require "pry"
+require "rinruby"
+require "rgl/adjacency"
+require "rgl/topsort"
+require "stats_module"
+
+# Generates the complete graph on n vertices if n is an integer, otherwise
+# the complete graph on the vertices in the enumerable given
+def complete_graph(n)
+  set = (Integer === n) ? 1..n : n
+  RGL::ImplicitGraph.new do |g|
+    g.vertex_iterator { |b| set.each(&b) }
+    g.adjacent_iterator do |x, b|
+      set.each { |y| b.call(y) unless x == y }
+    end
+  end
+end
+
+def remove_edge(orig, e)
+  new_graph = RGL::ImplicitGraph.new do |g|
+    g.vertex_iterator { |b| orig.vertices.each(&b) }
+    g.adjacent_iterator do |x, b|
+      new_adj = orig.adjacent_vertices(x).reject { |v| e.source == v or e.target == v }
+      new_adj.each { |y| b.call(y) }
+    end
+  end
+  new_graph
+end
+
+# Takes a list of vertices and a hash of source => [targets] pairs and generates a directed graph
+def make_directed(vertices, directed_edges)
+  g = RGL::DirectedAdjacencyGraph.new
+  
+  vertices.each { |v| g.add_vertex(v) }
+  
+  directed_edges.each do |source, targets|
+    targets.each { |target| g.add_edge(source, target) }
+  end
+  
+  g
+end
+
+# Takes a list of vertices and a hash of source => [targets] pairs and generates an implicit (undirected) graph
+def make_implicit(vertices, edges)
+  RGL::ImplicitGraph.new do |g|
+    edges.default = []
+    g.vertex_iterator { |b| vertices.each(&b) }
+    g.adjacent_iterator do |x, b|
+      vertices.each {|y| b.call(y) if edges[x].include? y}
+    end
+  end
+end
+
+def cartprod(*args)
+  result = [[]]
+  while [] != args
+    t, result = result, []
+    b, *args = args
+    t.each do |a|
+      b.each do |n|
+        result << a + [n]
+      end
+    end
+  end
+  result
+end
+
+module Glymour
+  # Provides graph structures and algorithms for determining edge structure of a Bayesian net
+  module StructureLearning
+    module PowerSet
+      # Sets an array to its "power array" (array of subarrays)
+      def power_set!
+        return [[]] if empty?
+        first = shift
+        rest = power_set!
+        
+        rest + rest.map {|subset| [first] + subset }
+      end
+
+      def power_set
+        return clone.power_set!
+      end
+    end
+
+    module GraphAlgorithms
+      def has_edge?(e)
+        self.edges.include? e
+      end
+      
+      # Returns a (unique) list of vertices adjacent to vertex a or b.
+      # This is denoted "Aab" in Spirtes-Glymour's paper.
+      def adjacent_either(a, b)
+        (adjacent_undirected(a) + adjacent_undirected(b)).uniq
+      end
+      
+      def adjacent_undirected(vertex)
+        adjacent_sources = vertices.select { |w| adjacent_vertices(w).include?(vertex) }
+        adjacent_vertices(vertex) + adjacent_sources
+      end
+
+      # Returns an array of all vertices on undirected simple paths between s and t.
+      # Modified breadth-first search: keep track of current path, and when t is found, add it to paths.
+      # This is denoted "Uab" in Spirtes-Glymour's paper.
+      def verts_on_paths(current_vertex, t, current_path=[], paths=[])
+        if current_vertex == t
+          paths << current_path + [current_vertex]
+        else
+          adjacent_undirected(current_vertex).each do |v|
+            # Don't recur if we're repeating vertices (i.e. reject non-simple paths)
+            verts_on_paths(v, t, current_path + [current_vertex], paths) if current_path.count(current_vertex) == 0
+          end
+        end
+        
+        paths.flatten.uniq
+      end
+
+      # Returns a list of _ordered_ 3-tuples (a, b, c) of vertices such that
+      # (a, b) are adjacent and (b,c) are adjacent, but (a,c) are not.
+      def non_transitive
+        triples = vertices.product(vertices, vertices)
+        
+        adjacent_triples = triples.select do |triple|
+          adjacent_undirected(triple.first).include?(triple[1]) && adjacent_undirected(triple[1]).include?(triple.last)
+        end
+        
+        adjacent_triples.reject do |triple|
+          (adjacent_undirected(triple.first).include? triple.last) || (triple.first == triple.last)
+        end
+      end
+    end
+    
+    class LearningNet
+      include Glymour::Statistics
+      attr_accessor :net, :directed_edges, :n
+      attr_reader :p_value
+      
+      def initialize(variable_container, p_value = 0.05)
+        @net = complete_graph(variable_container.variables).extend(GraphAlgorithms)
+        @directed_edges = {}
+        @directed_edges.default = []
+        @n = -1
+        @p_value = p_value
+      end
+      
+      # Perform one step of the PC algorithm
+      def step
+        any_independent = false
+        net.edges.each do |e|
+          a, b = e.source, e.target
+          intersect = (@net.adjacent_either(a, b) & @net.verts_on_paths(a, b)).extend(PowerSet)
+          
+          # Is |Aab ^ Uab| > n? 
+          if intersect.length <= n
+            next
+          else
+            # Are a and b independent conditioned on any subsets of Aab ^ Uab of cardinality n+1?
+            valid_intersects = intersect.power_set.select {|s| s.length == n+1}.reject { |subset| subset.include?(a) || subset.include?(b) }
+            if valid_intersects.any? { |subset|
+              print "Testing independence between #{a.name} and #{b.name}, conditioning on #{(subset.any? ? subset.map(&:name).join(', ') : 'nothing') + '...'}"
+              print (coindependent?(p_value, a, b, *subset) ? "[+]\n" : "[-]\n")
+              coindependent?(p_value, a, b, *subset)
+            }
+              @net = remove_edge(net, e)
+              net.edges.each do |e|
+                puts "#{e.source.name} => #{e.target.name}"
+              end
+              any_independent = true
+            end
+          end
+        end
+        @n += 1
+        any_independent
+      end
+      
+      # Perform the PC algorithm in full
+      def learn_structure
+        puts "Learning undirected net structure..."
+        # Perform step until every pair of adjacent variables is dependent, and
+        # set final_net to the _second-to-last_ state of @net
+        begin
+          puts "n = #{n}"
+          final_net = net
+          step
+        end while n < 1
+        
+        net = final_net
+        
+        direct_edges
+      end
+      
+      # Direct remaining edges in @net as much as possible
+      def direct_edges
+        puts "Directing edges where possible..."
+        
+        net.non_transitive.each do |triple|
+          a, b, c = *triple
+          
+          intersect = (net.adjacent_either(a, c) & net.verts_on_paths(a, c)).extend(PowerSet)
+          if intersect.power_set.select {|s| s.include? b}.none? { |subset| 
+            coindependent?(p_value, a, c, *subset)
+          }
+            puts "Adding directed edge #{a.name} => #{b.name}..."
+            @directed_edges[a] = (@directed_edges[a] << b).uniq
+            
+            puts "Adding directed edge #{c.name} => #{b.name}..."
+            @directed_edges[c] = (@directed_edges[c] << b).uniq
+          end
+        end
+      end
+      
+      
+      # Gives a list of all orientations of @net compatible with @directed_edges
+      # (i.e., all directed acyclic graphs with edge structure given partially by @directed_edges)
+      def compatible_orientations
+        compat_list = []
+        edges = net.edges.extend(PowerSet)
+        
+        # Every orientation of net corresponds to a subset of its edges
+        edges.power_set.each do |subset|
+          # Orient edges in subset as source => target, outside of it as target => source
+          # Any edges conflicting with directed_edges will be cyclic and therefore not counted
+          current_orientation = make_directed(net.vertices, @directed_edges)
+          
+          edges.each do |e|
+            if subset.include? e
+              current_orientation.add_edge(e.source, e.target)
+            else
+              current_orientation.add_edge(e.target, e.source)
+            end
+          end
+          
+          compat_list << current_orientation if current_orientation.acyclic?
+        end
+        
+        compat_list
+      end
+    end
+  end
+end

data/lib/scratch.rb

@@ -0,0 +1,23 @@
+class WeightNet
+  attr_accessor :net
+  
+  # Use a DAG generated by StructureLearning to create an unweighted Bayes net
+  def initialize(dag)
+    vars = {}
+    @net = Sbn::Net.new(title)
+    
+    vertices.each do |v|
+      vars[v] = Sbn::Variable.new(@net, v.name.to_sym)
+    end
+    
+    edges.each do |e|
+      vars[e.source].add_child(vars[e.target])
+    end
+  end
+end
+
+R.eval <<-EOF
+  partial_table <- t[,,#{value.join(',')}]
+  chisq <- chisq.test(partial_table)
+  s <- chisq$statistic
+EOF

data/lib/stats_module.rb

@@ -0,0 +1,116 @@
+module Glymour
+  module Statistics
+    class VariableContainer
+      attr_reader :table, :number_unnamed
+      attr_accessor :variables
+      
+      def initialize(table, variables=[])
+        number_unnamed = 0
+        @table = table
+        @variables = variables
+        @variables.each do |var|
+          var.variable_container = self
+          var.set_intervals if var.num_classes
+          var.name ||= "unnamed_variable#{number_unnamed += 1}"
+        end
+      end
+    end
+    
+    class Variable
+      attr_accessor :intervals, :variable_container, :name, :num_classes
+      
+      def initialize(name = nil, num_classes = nil, &block)
+        @block = Proc.new &block
+        @num_classes = num_classes
+        @intervals = num_classes && variable_container ? set_intervals : nil
+        
+        # names are used as variable names in R, so make sure there's no whitespace
+        @name = name.gsub(/\s+/, '_') if name
+      end
+      
+      # Apply @block to each column value, and 
+      # return a list of evenly divided intervals [x1, x2, ..., x(n_classes)]
+      # So that x1 is the minimum, xn is the max
+      def set_intervals
+        vals = self.values
+        step = (vals.max - vals.min)/(num_classes-1).to_f
+        @intervals = (0..(num_classes-1)).map { |k| vals.min + k*step }
+      end
+      
+      def value_at(row)
+        intervals ? location_in_interval(row) : @block.call(row)
+      end
+      
+      # Gives an array of all variable values in table
+      def values
+        intervals ? variable_container.table.map { |row| location_in_interval(row) } : variable_container.table.map(&@block)
+      end
+      
+      # Gives the location of a column value within a finite set of interval values (i.e. gives discrete state after classing a continuous variable)
+      def location_in_interval(row)
+        intervals.each_with_index do |x, i|
+          return i if @block.call(row) <= x
+        end
+
+        # Return -1 if value is not within intervals
+        -1
+      end
+    end
+    
+    # Takes two or more Variables
+    # Returns true if first two variables are coindependent given the rest
+    def coindependent?(p_val, *variables)
+      #TODO: Raise an exception if variables have different tables?
+      R.echo(false)
+      # Push variable data into R
+      variables.each do |var|
+        # Rinruby can't handle true and false values, so use 1 and 0 resp. instead
+        sanitized_values = var.values.map do |value|
+          case value
+            when true  then 1
+            when false then 0
+            else value
+          end
+        end
+        
+        R.assign var.name, sanitized_values
+      end
+      
+      R.eval <<-EOF
+        cond_data <- data.frame(#{variables.map(&:name).join(', ')})
+        t <-table(cond_data)
+      EOF
+      
+      cond_vars = variables[2..(variables.length-1)]
+      
+      # If no conditioning variables are given, just return the chi square test for the first two
+      if cond_vars.empty?
+        R.eval "chisq <- chisq.test(t)"
+        observed_p = R.pull "chisq$p.value"
+        return observed_p > p_val
+      end
+      
+      cond_values = cond_vars.map { |var| (1..var.values.uniq.length).collect }
+      
+      # Find the chi-squared statistic for every state of the conditioning variables and sum them
+      chisq_sum = 0
+      df = 0
+      cond_values.inject!(&:product).map(&:flatten)
+      cond_values.each do |value|
+        R.eval <<-EOF
+          partial_table <- t[,,#{value.join(',')}]
+          table_without_zero_columns <- partial_table[,-(which(colSums(partial_table) == 0))]
+          chisq <- chisq.test(table_without_zero_columns)
+          s <- chisq$statistic
+        EOF
+        
+        observed_s = R.pull("s").to_f
+        chisq_sum += observed_s
+        df += R.pull("chisq$parameter").to_i
+      end
+      # Compute the p-value of the sum of statistics
+      observed_p = 1 - R.pull("pchisq(#{chisq_sum}, #{df})").to_f
+      observed_p > p_val
+    end
+  end
+end

data/spec/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+require "glymour"
+
+class StatsDummy
+  include Glymour::Statistics
+end
+
+# Returns true with probability p
+def prob(p)
+  rand < p
+end
+
+def alarm_init
+  @alarm_data = []
+  100000.times do
+    earthquake = prob(0.01)
+    burglary = prob(0.007)
+  
+    if burglary
+      alarm = earthquake ? prob(0.95) : prob(0.94)
+    else
+      alarm = earthquake ? prob(0.29) : prob(0.001)
+    end
+  
+    john_calls = alarm ? prob(0.90) : prob(0.05)
+    mary_calls = alarm ? prob(0.70) : prob(0.01)
+    
+    alarm_continuous = rand(50)
+  
+    @alarm_data << { :e => earthquake, :b => burglary, :a => alarm, :j => john_calls, :m => mary_calls, :ac => alarm_continuous }
+  end
+  @e = Glymour::Statistics::Variable.new("Earthquake") { |r| r[:e] }
+  @b = Glymour::Statistics::Variable.new("Burglary") { |r| r[:b] }
+  @a = Glymour::Statistics::Variable.new("Alarm") { |r| r[:a] }
+  @j = Glymour::Statistics::Variable.new("John Calls") { |r| r[:j] }
+  @m = Glymour::Statistics::Variable.new("Mary Calls") { |r| r[:m] }
+  
+  @ac = Glymour::Statistics::Variable.new("Alarm Continuous", 10) { |r| r[:ac] }
+  
+  alarm_vars = [@e, @b, @a, @j, @m, @ac]
+
+  alarm_container = Glymour::Statistics::VariableContainer.new(@alarm_data, alarm_vars)
+  @alarm_net = Glymour::StructureLearning::LearningNet.new(alarm_container)
+end
+
+def coin_init
+  # Highly simplified test net
+  # Only edges should be @h pointing to @red and @blue
+  @coin_data = []
+  10000.times do
+    h = prob(0.5)
+    red = h ? prob(0.2) : prob(0.7)
+    blue = h ? prob(0.4) : prob(0.9)
+    @coin_data << { :h => h, :red => red, :blue => blue }
+  end
+  
+  @h = Glymour::Statistics::Variable.new("Heads") { |r| r[:h] }
+  @red = Glymour::Statistics::Variable.new("Red") { |r| r[:red] }
+  @blue = Glymour::Statistics::Variable.new("Blue") { |r| r[:blue] }
+  
+  coin_container = Glymour::Statistics::VariableContainer.new(@coin_data, [@h, @red, @blue])
+  @coin_net = Glymour::StructureLearning::LearningNet.new(coin_container)
+end

data/spec/statistics_spec.rb

@@ -0,0 +1,39 @@
+require 'glymour'
+require 'rgl/implicit'
+require 'rgl/dot'
+require 'spec_helper'
+
+describe Glymour::Statistics do
+  before(:all) do
+    R.echo(true)
+    Stats = StatsDummy.new
+    
+    alarm_init
+    coin_init
+  end
+  
+  it 'should give chi square independence data for two variables' do
+    Stats.coindependent?(0.05, @h, @red).should be_false
+    Stats.coindependent?(0.05, @e, @b).should be_true
+  end
+  
+  it 'should give conditional independence data for several variables' do
+    Stats.coindependent?(0.05, @red, @blue, @h).should be_true
+    Stats.coindependent?(0.05, @j, @m, @a).should be_true
+    Stats.coindependent?(0.05, @b, @ac, @a).should be_true
+  end
+  
+  describe Glymour::Statistics::VariableContainer
+    it 'should set variable name when nil' do
+      var = Glymour::Statistics::Variable.new {|r| r}
+      container = Glymour::Statistics::VariableContainer.new([], [var])
+      var.name.should_not be_nil
+    end
+      
+    it 'should create unique names for variables' do
+      var1 = Glymour::Statistics::Variable.new {|r| r}
+      var2 = Glymour::Statistics::Variable.new {|r| r}
+      container = Glymour::Statistics::VariableContainer.new([], [var1, var2])
+      var1.name.should_not eq var2.name
+    end
+end

data/spec/structure_learning_spec.rb

@@ -0,0 +1,82 @@
+require 'glymour'
+require 'rgl/implicit'
+require 'rgl/dot'
+require 'spec_helper'
+
+describe Glymour::StructureLearning do
+  before(:each) do 
+    extend Glymour::StructureLearning
+  end
+  
+  it 'should compute the power set of an array' do
+    ary = [1, :two, "three"].extend(Glymour::StructureLearning::PowerSet)
+    result = ary.power_set
+    
+    [[], [1, :two], [:two, "three"], ary].each do |set|
+      result.should include set
+    end
+  end
+  
+  describe 'Within GraphAlgorithms' do
+    before(:each) do
+      class RGL::ImplicitGraph
+        include Glymour::StructureLearning::GraphAlgorithms
+      end
+      
+      # Create a graph for graph algorithm tests
+      # (Unfortunately we need something a little complicated for some tests)
+      vertices = (1..8).collect
+      edges = {1 => [2], 2 => [3], 3 => [1, 7], 4 => [3], 7 => [5, 8], 5 => [6], 6 => [7]}
+      
+      @g = make_implicit(vertices, edges)
+    end
+    
+    it 'should remove an edge from a graph' do
+      g = complete_graph(4)
+      orig_edge_count = g.edges.length
+      remove_edge(g, g.edges.first).edges.length.should_not eq orig_edge_count
+    end
+    
+    it 'should compute the vertices on all paths between two vertices' do
+      path_verts = @g.verts_on_paths(4, 6)
+      [4, 3, 7, 5, 6].each { |v| path_verts.should include v }
+    end
+    
+    it 'should compute non-transitive vertices of a graph' do
+      [[4, 3, 1], [4, 3, 7], [3, 7, 8]].each do |triple|
+        @g.non_transitive.should include triple
+      end
+    end
+    
+    it 'should compute a complete graph on any vertex set' do
+      vert_set = [1, :two, "three", [5]]
+      complete = complete_graph vert_set
+      
+      vert_set.each do |v|
+        complete.adjacent_vertices(v).should eq vert_set - [v]
+      end
+    end
+  end
+  
+  describe Glymour::StructureLearning::LearningNet do
+    before(:all) do
+      alarm_init
+    end
+    
+    it 'should perform the structure learning algorithm' do
+      prev_n_edges = @alarm_net.net.edges.length
+      
+      @alarm_net.learn_structure
+      
+      @alarm_net.net.edges.length.should be < prev_n_edges
+      
+      @alarm_net.net.edges.each do |e|
+        puts "#{e.source.name} => #{e.target.name}"
+      end
+    end
+    
+    it 'should produce orientations compatible with learn_structure output' do
+      orientations = @alarm_net.compatible_orientations
+    end
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification 
+name: glymour
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Stanwyck
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rgl
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sbn
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rinruby
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+description: Implements supervised Bayesian structure learning, as well as extra tools to help train a Bayesian net using ActiveRecord data
+email: 
+- brian.stanwyck@ncf.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README
+- Rakefile
+- glymour.gemspec
+- lib/glymour.rb
+- lib/glymour/version.rb
+- lib/scratch.rb
+- lib/stats_module.rb
+- required_r_packages/colorspace_1.1-0.tgz
+- required_r_packages/vcd_1.2-11.tgz
+- spec/.rspec
+- spec/spec_helper.rb
+- spec/statistics_spec.rb
+- spec/structure_learning_spec.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: glymour
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: A gem for supervised Bayesian net structure learning
+test_files: 
+- spec/spec_helper.rb
+- spec/statistics_spec.rb
+- spec/structure_learning_spec.rb