bn4r 0.1.0 → 0.1.2

data/lib/bn4r/bn.rb

@@ -25,8 +25,11 @@ class BayesNet < DirectedAdjacencyGraph
 # with tag ( if tag is included, othewise the label is nil ).
   def add_edge(parent, child, tag=nil)
     raise "Nodes must be of the class BayesNetNodes" if parent.class != BayesNetNode or child.class != BayesNetNode
+    raise "Self relations not allowed in BayesNet" if parent == child
+    raise "Diferent BayesNetNodes with equal name: " + parent.name if parent.name == child.name
+    
     edge = super(parent, child)
-    child.parents << parent
+    child.parents << parent unless child.parents.include? parent
     child.relations << tag if !tag.nil?
     edge
   end
@@ -142,6 +145,12 @@ class BayesNetNode
     parents.size
   end
   
+  # Function not implemented yet
+  def deep(visited_nodes=[])
+    #TODO: Make deep function
+    raise "Function not implemented yet"
+  end
+  
   # Returns true if the node is a root node ( doesn't have parents ).
   def root?
     return true if num_parents == 0
@@ -157,6 +166,8 @@ class BayesNetNode
     return name + (value.nil? ? "" : (" = " + value.to_s))
   end
 
+  # If givens don't exist, it adds them
+  # 
   # if givens is nil, then internal givens is assumed
   # table must have probability values in order like BAD!!!
   # [g0=pos0 & g1=pos0 & ... & node_value=pos0, ..., g0=pos0 & g1=pos0 & ... & node_value=posN,

data/lib/bn4r/bn_algorithms.rb

@@ -107,24 +107,27 @@ class BayesNet < DirectedAdjacencyGraph
   # 
   # <b>x</b> --> query variable
   # 
-  # <b>e</b> --> variables with observed values
+  # <b>e</b> --> variables with observed values, must be a copy of the nodes
+  # in bn ( Can't be the BayesNetNodes instaces that are in bn ).
   # 
   # <b>n</b> --> Number of samples generated
-  #  
+  # 
+  # WARNING: Clears the values of current bn!
   def likelihood_weighting( x, e, n, bn = self )
   
     retval = [0.0, 0.0]
     n.times {
-      w_sample, w = weighted_sample(e)
-      value = w_sample.select { |v| v.name == x.name }[0].value
-      #p value
-      if value == x.value
+      w_sample, w = weighted_sample(e) # ask for a weighted_sample with given evidences
+      value = w_sample.select { |v| v.name == x.name }[0].value # select the value for the query variable
+
+      if value == (x.value || true) # if no value for x, ask for true
         retval[1] += w
       else
         retval[0] += w
       end
     }
   
+    # Normalize results
     norm = retval[1].to_f / (retval[0]+retval[1]).to_f
 
     return [norm, 1-norm]
@@ -164,6 +167,7 @@ class BayesNet < DirectedAdjacencyGraph
   # 
   # <b>e</b> --> variables with observed values
   # 
+  # WARNING: Clears the values of current bn!
   def weighted_sample(e, bn = self)
     
     nodes_ordered = bn.nodes_ordered_by_dependencies

data/lib/bn4r/bn_export.rb

@@ -0,0 +1,156 @@
+##############################################################
+#
+#  Export fuctions of Bayesian Network Library for Ruby
+#  
+#  Author: Sergio Espeja ( http://www.upf.edu/pdi/iula/sergio.espeja, sergio.espeja at gmail.com )
+#  
+#  Developed in: IULA ( http://www.iula.upf.es ) and 
+#  in bee.com.es ( http://bee.com.es )
+#  
+#  == Export formats implemented
+#  * dot (Graphviz .dot files)  
+#  * xbn (Microsoft Belief Networks)
+#
+##############################################################
+
+
+#
+class BayesNet < DirectedAdjacencyGraph
+
+def to_dot(bn = self)
+  #TODO: label relations between nodes
+  #TODO: �print information about probabilities tables?
+  bn.to_dot_graph.to_s
+end
+
+def to_xbn(bn = self)
+  #TODO beautify code using REXML
+  xbn_str = "<?xml version=\"1.0\"?>\n"
+  xbn_str += "<ANALYSISNOTEBOOK NAME=\"Notebook.bndefault\" ROOT=\"bndefault\">\n"
+  xbn_str += "<BNMODEL NAME=\"bndefault\"><STATICPROPERTIES><FORMAT>MSR DTAS XML</FORMAT>\n"
+  xbn_str += "      <VERSION>1.0</VERSION>\n"
+  xbn_str += "        <CREATOR>Microsoft Research DTAS</CREATOR>\n"
+  xbn_str += "        </STATICPROPERTIES>\n"
+  xbn_str += "      <DYNAMICPROPERTIES><PROPERTYTYPE NAME=\"DTASDG_Notes\" TYPE=\"stringarray\"><COMMENT>Notes on the diagram</COMMENT>\n"
+  xbn_str += "          </PROPERTYTYPE>\n"
+  xbn_str += "        <PROPERTYTYPE NAME=\"MS_Addins\" TYPE=\"stringarray\"/>\n"
+  xbn_str += "        </DYNAMICPROPERTIES>\n"
+
+  xbn_str += xbn_variables(bn)
+  xbn_str += xbn_structure(bn)
+  xbn_str += xbn_distributions(bn)
+  
+  xbn_str += "  </BNMODEL>\n"
+  xbn_str += "</ANALYSISNOTEBOOK>\n"
+  
+end
+
+private
+def xbn_variables(bn = self)
+  xbn_str = "<VARIABLES>\n" 
+  #<VAR NAME=\"N_intr_le\" TYPE=\"discrete\" XPOS=\"17589\" YPOS=\"6435\">
+  # <FULLNAME>n_intr_le</FULLNAME>
+  # <STATENAME>Yes</STATENAME>
+  # <STATENAME>No</STATENAME>
+  #</VAR>
+  x_pos_index = 0; y_pos_index = 0 #; actual_deep = 0
+  bn.nodes_ordered_by_dependencies.each { |node|
+    if !node.root? and (y_pos_index == 0)
+      x_pos_index = 0; y_pos_index = 1
+    end    
+    x_pos = 1000 + (6500*x_pos_index)
+    y_pos = 2500 + (5000*y_pos_index)
+    x_pos_index += 1
+    xbn_str += "<VAR NAME=\"#{node.name}\" TYPE=\"discrete\" XPOS=\"#{x_pos}\" YPOS=\"#{y_pos}\">\n" 
+    xbn_str += "<FULLNAME>#{node.name}</FULLNAME>\n"
+    # TODO: Make statename match with node.outcomes
+    xbn_str += "<STATENAME>Yes</STATENAME>\n"
+    xbn_str += "<STATENAME>No</STATENAME>\n"
+    xbn_str += "</VAR>\n"
+  }
+  xbn_str += "</VARIABLES>\n" 
+end
+
+def xbn_structure(bn = self)
+  xbn_str = "<STRUCTURE>\n"
+  bn.nodes_ordered_by_dependencies.each { |node|
+    next if node.root? #node.num_parents > 0
+    node.parents.each { |parent|
+      xbn_str += "<ARC PARENT=\"#{parent.name}\" CHILD=\"#{node.name}\"/>\n"
+    }
+  }
+  #      	<ARC PARENT=\"N_mass_le\" CHILD=\"Count\"/>
+  #        <ARC PARENT=\"N_mass_count_le\" CHILD=\"Count\"/>
+  #        <ARC PARENT=\"N_intr_le\" CHILD=\"Count\"/>
+  #        <ARC PARENT=\"N_mass_le\" CHILD=\"Mass\"/>
+  #        <ARC PARENT=\"N_mass_count_le\" CHILD=\"Mass\"/>
+  #        <ARC PARENT=\"N_intr_le\" CHILD=\"Mass\"/>
+  xbn_str += "</STRUCTURE>\n"
+end
+
+def xbn_distributions(bn = self)
+ xbn_str = "<DISTRIBUTIONS>\n"
+# With parents
+#      	<DIST TYPE=\"discrete\">
+#      			<CONDSET>
+#      				<CONDELEM NAME=\"N_mass_le\"/>
+#            	<CONDELEM NAME=\"N_mass_count_le\"/>
+#            	<CONDELEM NAME=\"N_intr_le\"/>
+#            </CONDSET>
+#          	<PRIVATE NAME=\"Count\"/>
+#          	<DPIS>
+#          		<DPI INDEXES=\"0 0 0 \">0.7 0.3 </DPI>
+#	            <DPI INDEXES=\"0 0 1 \">0.3 0.7 </DPI>
+#	            <DPI INDEXES=\"0 1 0 \">0.3 0.7 </DPI>
+#	            <DPI INDEXES=\"0 1 1 \">0 1 </DPI>
+#	            <DPI INDEXES=\"1 0 0 \">1 0 </DPI>
+#	            <DPI INDEXES=\"1 0 1 \">0.7 0.3 </DPI>
+#	            <DPI INDEXES=\"1 1 0 \">0.7 0.3 </DPI>
+#	            <DPI INDEXES=\"1 1 1 \">0.3 0.7 </DPI>
+#            </DPIS>
+#	    </DIST>
+bn.nodes_ordered_by_dependencies.each { |node|
+  next if node.root?
+  xbn_str += "<DIST TYPE=\"discrete\">\n"
+  xbn_str += "  <PRIVATE NAME=\"#{node.name}\"/>\n"
+  
+  xbn_str += "  <CONDSET>\n"
+  node.parents.each { |parent| xbn_str += "    <CONDELEM NAME=\"#{parent.name}\"/>" }
+  xbn_str += "  </CONDSET>\n"
+
+  xbn_str += "  <DPIS>\n"
+  boolean_combinations = generate_boolean_combinations(node.num_parents)
+  boolean_combinations.each { |boolean_combination|
+    # TODO: Make probs based on outcomes
+    probs = [true, false].collect { |n_assignment| node.get_probability(n_assignment, boolean_combination) }
+    bc_str = boolean_combination.collect {|b| (b)?"0":"1"}.join(" ")
+    xbn_str += "  <DPI INDEXES=\"#{bc_str} \">" + probs.join(" ") + " </DPI>\n"
+    #<DPI INDEXES=\"0 0 0 \">0.7 0.3 </DPI>
+  }
+  xbn_str += "  </DPIS>\n"
+  xbn_str += "</DIST>\n"
+}
+
+
+# Without parents
+#      <DIST TYPE=\"discrete\">
+#        	<PRIVATE NAME=\"N_intr_le\"/>
+#          <DPIS>
+#          	<DPI>0.3 0.7 </DPI>
+#          </DPIS>
+#        </DIST>
+bn.nodes_ordered_by_dependencies.each { |node|
+  next unless node.root?
+  xbn_str += "<DIST TYPE=\"discrete\">\n"
+  xbn_str += "  <PRIVATE NAME=\"#{node.name}\"/>\n"
+  xbn_str += "  <DPIS>\n"
+  probs = [true, false].collect { |n_assignment| node.get_probability(n_assignment) }
+  xbn_str += "  <DPI>" + probs.join(" ") + " </DPI>\n"
+  xbn_str += "  </DPIS>\n"
+  xbn_str += "</DIST>\n"
+}
+
+xbn_str += "</DISTRIBUTIONS>\n"
+end
+
+end

data/lib/bn4r/bn_import.rb

@@ -0,0 +1,65 @@
+##############################################################
+#
+#  Import fuctions of Bayesian Network Library for Ruby
+#  
+#  Author: Sergio Espeja ( http://www.upf.edu/pdi/iula/sergio.espeja, sergio.espeja at gmail.com )
+#  
+#  Developed in: IULA ( http://www.iula.upf.es ) and 
+#  in bee.com.es ( http://bee.com.es )
+#
+#  Based on work by Ryan Dahl in 
+#  http://www.math.rochester.edu/people/grads/rld/bayesnets  
+#  
+#  == Import formats implemented
+#  * XML BIF ( XML-based BayesNets Interchange Format , 
+#  http://www.cs.cmu.edu/afs/cs/user/fgcozman/www/Research/InterchangeFormat/ )  
+#
+#
+#
+##############################################################
+require 'rexml/document'
+include REXML
+
+#
+class BayesNet < DirectedAdjacencyGraph
+
+def create_from_xmlbif(file, bn=self)
+    doc = Document.new File.open(file, "r")
+
+    # first go through and add the variables
+    doc.elements.each("BIF/NETWORK/VARIABLE") { |variable|
+
+      name = variable.elements["NAME"]
+
+      outcomes = []
+      variable.elements.each("OUTCOME") { |outcome|
+        outcomes << outcome.text
+      }
+      # transform from text to boolean
+      if outcomes.size == 2 and outcomes.include?("true") and outcomes.include?("false")
+        outcomes = outcomes.collect {|o| o == "true"}
+      end
+      node = BayesNetNode.new( name.text, outcomes )
+      bn.add_vertex(node)
+    }
+
+    # for each variable we list, we will look up 
+    # the conditional probability table for it.
+
+    doc.elements.each("BIF/NETWORK/DEFINITION/") { |definition|
+      node = get_variable( definition.elements["FOR"].text )
+      givens_array = []
+      definition.elements.each("GIVEN") { |given|
+        givens_array << get_variable( given.text )
+      }
+
+      table = definition.elements["TABLE"].text.split
+
+      givens_array.each { |g| bn.add_edge(g, node) }
+
+      node.set_probability_table(givens_array, table)      
+    }
+    bn
+end
+
+end

data/lib/bn4r/bn_table_probabilities.rb

@@ -56,10 +56,24 @@ class BNTPGFromPositiveNegativeRelations < BnTableProbabilitiesGenerator
   def self.get_node_probability_from_boolean_combination(boolean_combination, type_of_position_impact)
     num_eq = 0.0
     boolean_combination.size.times { |i|
-      num_eq = num_eq + 1.0 if type_of_position_impact[i] && boolean_combination[i]
-      num_eq = num_eq + 1.0 if !type_of_position_impact[i] && !boolean_combination[i]
+      num_eq += 1.0 if type_of_position_impact[i] && boolean_combination[i]
+      num_eq += 1.0 if !type_of_position_impact[i] && !boolean_combination[i]
     }
     num_eq / boolean_combination.size.to_f
   end
 end
 
+def generate_boolean_combinations(num)
+    boolean_combinations = []
+    (2**num).times { |i|
+      boolean_combination = Array.new(num, false)
+      actual_value = i
+      (num).times { |j|
+        boolean_combination[j] = !(actual_value%2 == 1)
+        actual_value = actual_value / 2
+      }
+      boolean_combinations << boolean_combination.reverse
+    }
+  boolean_combinations
+end
+

data/lib/bn4r/version.rb

@@ -2,7 +2,7 @@ module Bn4r #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 0
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/bn4r_test.rb

@@ -1,96 +1,8 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
+require 'bn_test_models'
 
 class Bn4rTest < Test::Unit::TestCase
 
-  # Returns the BayesNet used as example in "Artificial Intelligence A 
-  # Modern Approach, Rusell & Norvig, 2nd Ed." pp.494
-  def self.bayes_net_aima
-    bn_aima = BayesNet.new
-    
-    b = BayesNetNode.new("Burglary")
-    e = BayesNetNode.new("Earthquake")
-    a = BayesNetNode.new("Alarm")
-    j = BayesNetNode.new("JohnCalls")
-    m = BayesNetNode.new("MaryCalls")
-
-    bn_aima.add_vertex(b)
-    bn_aima.add_vertex(e)
-    bn_aima.add_vertex(a)
-    bn_aima.add_vertex(j)
-    bn_aima.add_vertex(m)
-    
-    bn_aima.add_edge(b,a)
-    bn_aima.add_edge(e,a)
-    bn_aima.add_edge(a,j)
-    bn_aima.add_edge(a,m)
-    
-    b.set_probability_table([], [0.001, 0.999] )
-    e.set_probability_table([], [0.002, 0.998] )
-    
-    a.set_probability_table([b,e], [0.95, 0.05, 0.94, 0.06, 0.29, 0.61, 0.001,0.999] )
-    
-    j.set_probability_table([a], [0.90,0.10,0.05,0.95])
-    m.set_probability_table([a], [0.70,0.30,0.01,0.99])
-    
-    bn_aima
-  end
-
-  # Returns the BayesNet used as example in "Artificial Intelligence A 
-  # Modern Approach, Rusell & Norvig, 2nd Ed." pp.510
-  def self.bayes_net_aima2
-    bn_aima = BayesNet.new
-
-    cloudy = BayesNetNode.new("Cloudy")
-    sprinkler = BayesNetNode.new("Sprinkler")
-    rain = BayesNetNode.new("Rain")
-    wetgrass = BayesNetNode.new("WetGrass")
-
-    bn_aima.add_vertex(cloudy)
-    bn_aima.add_vertex(sprinkler)
-    bn_aima.add_vertex(rain)
-    bn_aima.add_vertex(wetgrass)
-    
-    bn_aima.add_edge(cloudy,sprinkler)
-    bn_aima.add_edge(cloudy,rain)
-    bn_aima.add_edge(sprinkler,wetgrass)
-    bn_aima.add_edge(rain,wetgrass)
-    
-    cloudy.set_probability_table([], [0.5, 0.5] )
-
-    sprinkler.set_probability_table([cloudy], [0.1, 0.9, 0.5, 0.5] )
-    rain.set_probability_table([cloudy], [0.8, 0.2, 0.2, 0.8] )
-    
-    wetgrass.set_probability_table([sprinkler, rain], [0.99, 0.01, 0.9, 0.1, 0.9, 0.1, 0.0, 1.0] )
-    bn_aima
-  end
-
-  def bayes_net_aaile
-    bn = BayesNet.new
-    rel = BayesNetNode.new("relational")
-    q = BayesNetNode.new("qualificative")
-    a = BayesNetNode.new("Adverbial")
-    bn.add_vertex(rel)
-    bn.add_vertex(q)
-    bn.add_vertex(a)
-
-#    ["preN", ...]    
-    preN = BayesNetNode.new("preN")
-    bn.add_vertex(preN)
-    
-    postN = BayesNetNode.new("postN")
-    bn.add_vertex(postN)
-    
- #   bn.add_edge("ser")
- #   bn.add_edge("G")
- #   bn.add_edge("prep")
-    
-    bn.add_edge(rel, preN)
-    bn.add_edge(q, preN)
-    bn.add_edge(a, preN)
-    bn.add_edge(q, postN)
-    
-    bn
-  end
 
   def setup
   end
@@ -113,7 +25,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
   
   def test_probability_assingment
-    bn_aima = Bn4rTest.bayes_net_aima
+    bn_aima = bayes_net_aima
     b = bn_aima.get_variable("Burglary")
     a = bn_aima.get_variable("Alarm")
     j = bn_aima.get_variable("JohnCalls")
@@ -133,7 +45,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
   
   def test_CPT_size
-    bn_aima = Bn4rTest.bayes_net_aima
+    bn_aima = bayes_net_aima
     b = bn_aima.get_variable("Burglary")
     a = bn_aima.get_variable("Alarm")
     j = bn_aima.get_variable("JohnCalls")
@@ -146,7 +58,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
   
   def test_base_methods
-    bn_aima = Bn4rTest.bayes_net_aima
+    bn_aima = bayes_net_aima
     b = bn_aima.get_variable("Burglary")
     a = bn_aima.get_variable("Alarm")
     assert bn_aima.root?(b)
@@ -155,7 +67,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
   
   def test_inference_by_enumeration
-    bn_aima = Bn4rTest.bayes_net_aima
+    bn_aima = bayes_net_aima
     b = bn_aima.get_variable("Burglary")
     e = bn_aima.get_variable("Earthquake")
     a = bn_aima.get_variable("Alarm")
@@ -183,7 +95,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
   
   def test_inference_by_enumeration_ask
-    bn_aima = Bn4rTest.bayes_net_aima
+    bn_aima = bayes_net_aima
     b = bn_aima.get_variable("Burglary")
     e = bn_aima.get_variable("Earthquake")
     a = bn_aima.get_variable("Alarm")
@@ -209,7 +121,7 @@ class Bn4rTest < Test::Unit::TestCase
   
   
   def test_table_probabilities_for_node
-    bn_aima = Bn4rTest.bayes_net_aima
+    bn_aima = bayes_net_aima
     b = bn_aima.get_variable("Burglary")
     e = bn_aima.get_variable("Earthquake")
     a = bn_aima.get_variable("Alarm")
@@ -221,7 +133,7 @@ class Bn4rTest < Test::Unit::TestCase
 
   def test_prior_sampling
 
-    bn = Bn4rTest.bayes_net_aima2
+    bn = bayes_net_aima2
 
     hash = Hash.new(0)
     nodes_ordered = bn.nodes_ordered_by_dependencies
@@ -238,7 +150,7 @@ class Bn4rTest < Test::Unit::TestCase
         when "WetGrass"
           true
         else
-          raise "Incorrect BayesNet created at Bn4rTest.bayes_net_aima2"
+          raise "Incorrect BayesNet created at bayes_net_aima2"
       end
     }
     
@@ -251,7 +163,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
 
   def test_rejection_sampling
-    bn = Bn4rTest.bayes_net_aima2
+    bn = bayes_net_aima2
 
     rain = bn.get_variable("Rain").copy
     sprinkler = bn.get_variable("Sprinkler").copy
@@ -269,7 +181,7 @@ class Bn4rTest < Test::Unit::TestCase
   end
 
   def test_likelihood_weighting
-    bn = Bn4rTest.bayes_net_aima2
+    bn = bayes_net_aima2
 
     rain = bn.get_variable("Rain").copy
     sprinkler = bn.get_variable("Sprinkler").copy

data/test/bn_test_models.rb

@@ -0,0 +1,95 @@
+  # Returns the BayesNet used as example in "Artificial Intelligence A 
+  # Modern Approach, Rusell & Norvig, 2nd Ed." pp.494
+  def bayes_net_aima
+    # Create BayesNet
+    bn_aima = BayesNet.new
+    
+    # Create nodes for the Bayes Net (BayesNetNodes)
+    burglary = BayesNetNode.new("Burglary")
+    earthquake = BayesNetNode.new("Earthquake")
+    alarm = BayesNetNode.new("Alarm")
+    john_calls = BayesNetNode.new("JohnCalls")
+    mary_calls = BayesNetNode.new("MaryCalls")
+
+    # Add nodes ( vertex ) to the BayesNet
+    bn_aima.add_vertex(burglary)
+    bn_aima.add_vertex(earthquake)
+    bn_aima.add_vertex(alarm)
+    bn_aima.add_vertex(john_calls)
+    bn_aima.add_vertex(mary_calls)
+    
+    # Add relations ( edges ) between nodes in the BayesNet
+    bn_aima.add_edge(burglary,alarm)
+    bn_aima.add_edge(earthquake,alarm)
+    bn_aima.add_edge(alarm,john_calls)
+    bn_aima.add_edge(alarm,mary_calls)
+    
+    # Assign probabilities to each node
+    burglary.set_probability_table([], [0.001, 0.999] )
+    earthquake.set_probability_table([], [0.002, 0.998] )
+    
+    alarm.set_probability_table([burglary,earthquake], [0.95, 0.05, 0.94, 0.06, 0.29, 0.61, 0.001,0.999] )
+    
+    john_calls.set_probability_table([alarm], [0.90,0.10,0.05,0.95])
+    mary_calls.set_probability_table([alarm], [0.70,0.30,0.01,0.99])
+    
+    bn_aima
+  end
+
+  # Returns the BayesNet used as example in "Artificial Intelligence A 
+  # Modern Approach, Rusell & Norvig, 2nd Ed." pp.510
+  def bayes_net_aima2
+    bn_aima = BayesNet.new
+
+    cloudy = BayesNetNode.new("Cloudy")
+    sprinkler = BayesNetNode.new("Sprinkler")
+    rain = BayesNetNode.new("Rain")
+    wetgrass = BayesNetNode.new("WetGrass")
+
+    bn_aima.add_vertex(cloudy)
+    bn_aima.add_vertex(sprinkler)
+    bn_aima.add_vertex(rain)
+    bn_aima.add_vertex(wetgrass)
+    
+    bn_aima.add_edge(cloudy,sprinkler)
+    bn_aima.add_edge(cloudy,rain)
+    bn_aima.add_edge(sprinkler,wetgrass)
+    bn_aima.add_edge(rain,wetgrass)
+    
+    cloudy.set_probability_table([], [0.5, 0.5] )
+
+    sprinkler.set_probability_table([cloudy], [0.1, 0.9, 0.5, 0.5] )
+    rain.set_probability_table([cloudy], [0.8, 0.2, 0.2, 0.8] )
+    
+    wetgrass.set_probability_table([sprinkler, rain], [0.99, 0.01, 0.9, 0.1, 0.9, 0.1, 0.0, 1.0] )
+    bn_aima
+  end
+
+    def bayes_net_aaile
+    bn = BayesNet.new
+    rel = BayesNetNode.new("relational")
+    q = BayesNetNode.new("qualificative")
+    a = BayesNetNode.new("Adverbial")
+    bn.add_vertex(rel)
+    bn.add_vertex(q)
+    bn.add_vertex(a)
+
+#    ["preN", ...]    
+    preN = BayesNetNode.new("preN")
+    bn.add_vertex(preN)
+    
+    postN = BayesNetNode.new("postN")
+    bn.add_vertex(postN)
+    
+ #   bn.add_edge("ser")
+ #   bn.add_edge("G")
+ #   bn.add_edge("prep")
+    
+    bn.add_edge(rel, preN)
+    bn.add_edge(q, preN)
+    bn.add_edge(a, preN)
+    bn.add_edge(q, postN)
+    
+    bn
+  end
+