fathom 0.3.0 → 0.3.1

data/lib/fathom/knowledge_base.rb

@@ -1,31 +1,42 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-class Fathom::KnowledgeBase
+require File.expand_path("../../fathom", __FILE__)
+
+require 'rdf'
+require 'knowledge_base/search'
+
+module Fathom
+  class KnowledgeBase
   
-  attr_reader :data_store
+    # =====================
+    # = Module Extensions =
+    # =====================
+    include Search
   
-  def initialize(opts={})
-    opts = OptionsHash.new(opts)
-    @data_store = OpenStruct.new
-  end
-  
-  def []=(key, value)
-    @data_store.table[key] = value
-  end
+    # attr_reader :data_store
   
-  def [](key)
-    @data_store.table[key]
-  end
-  
-  # This is temporary, but useful for now.  After we have the persisted KnowledgeBase, 
-  # we'll create explicit accessor methods or a find syntax.
-  def method_missing(sym, *args, &block)
-    if @data_store.table.keys.include?(sym)
-      @data_store.send(sym)
-    else
-      super
+    def initialize(opts={})
+      # opts = OptionsHash.new(opts)
+      # @data_store = OpenStruct.new
     end
-  end
   
+    # def []=(key, value)
+    #   @data_store.table[key] = value
+    # end
+    # 
+    # def [](key)
+    #   @data_store.table[key]
+    # end
+    # 
+    # # This is temporary, but useful for now.  After we have the persisted KnowledgeBase, 
+    # # we'll create explicit accessor methods or a find syntax.
+    # def method_missing(sym, *args, &block)
+    #   if @data_store.table.keys.include?(sym)
+    #     @data_store.send(sym)
+    #   else
+    #     super
+    #   end
+    # end
+    
+  end
 end
 
 if __FILE__ == $0

data/lib/fathom/knowledge_base/search.rb

@@ -0,0 +1,19 @@
+require 'sparql/algebra'
+
+module Fathom
+  module Search
+    
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      def find(opts={})
+      end
+    end
+    
+    module InstanceMethods
+    end
+  end
+end

data/lib/fathom/node.rb

@@ -1,9 +1,18 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+# TODO: Move this into a proper configuration module
+# require 'spira'
+# @repository = RDF::Repository.new
+# Spira.add_repository(:default, @repository)
+
 class Fathom::Node
 
+  # See notes in the spec about this.
+  # include Spira::Resource
+
   attr_reader :name, :distribution, :description, :values
   
   def initialize(opts={})
+    symbolize_keys!(opts)
     @name = opts[:name]
     assert_distribution(opts)
     @description = opts[:description]
@@ -56,8 +65,31 @@ class Fathom::Node
     true
   end
   
+  def simple_inspect
+    self.name ? "#{self.name} (#{self.class.to_s})" : self.class.to_s
+  end
+  
+  def inspect
+    "#{self.class.to_s}: " +  [
+      self.name,
+      self.description,
+      "children:",
+      self.children.map {|e| e.simple_inspect }.inspect,
+      "parents: ",
+      self.parents.map {|e| e.simple_inspect }.inspect,
+    ].compact.join(", ")
+  end
+  
   protected
   
+    # Quick and dirty extract from ActiveSupport's same method
+    def symbolize_keys!(h)
+      h.keys.each do |key|
+        h[(key.to_sym rescue key) || key] = h.delete(key)
+      end
+      h
+    end
+    
     def add_accessor_for_node(node)
       return false unless node.is_a?(Node) and node.name_sym
       return false if self.respond_to?(node.name_sym)
@@ -77,7 +109,6 @@ class Fathom::Node
         add_parent(parent)
       end
 
-
       found = opts[:children]
       found ||= opts[:child]
       found ||= []

data/lib/fathom/node/belief_node.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
+class Fathom::BeliefNode < DiscreteNode
+  
+  attr_reader :probabilities, :likelihoods, :precision_threshold
+  
+  def initialize(opts={})
+    super(opts)
+    assert_probabilities(opts)
+    assert_liklihoods(opts)
+    @precision_threshold = opts.fetch(:precision_threshold, 0.00001)
+  end
+
+  def add_child(child)
+    if child.is_a?(BeliefNode)
+      cpm = CPMNode.new(:parent => self, :child => child)
+      # self.children << cpm
+      self.add_accessor_for_cpm(cpm, child)
+      self.add_accessor_for_node(child)
+      # cpm.register_parent(self)
+      self.children << child
+      child.register_parent(self)
+      child.add_accessor_for_cpm(cpm, self)
+    else
+      super(child)
+    end
+  end
+  
+  def add_parent(parent)
+    if parent.is_a?(BeliefNode)
+      cpm = CPMNode.new(:parent => parent, :child => self)
+      # self.parents << cpm
+      self.add_accessor_for_cpm(cpm, parent)
+      self.add_accessor_for_node(parent)
+      # cpm.register_child(self)
+      self.parents << parent
+      parent.register_child(self)
+      parent.add_accessor_for_cpm(cpm, self)
+    else
+      super(parent)
+    end
+  end
+  
+  def inspect
+    "#{self.class.to_s}: " +  [
+      self.name,
+      self.description,
+      "children:",
+      self.children.map {|e| e.is_a?(CPMNode) ? e.child.simple_inspect : e.simple_inspect }.inspect,
+      "parents: ",
+      self.parents.map {|e| e.is_a?(CPMNode) ? e.parent.simple_inspect : e.simple_inspect }.inspect,
+    ].compact.join(", ")
+  end
+  
+  def add_accessor_for_cpm(cpm, node)
+    return false unless cpm.is_a?(CPMNode) and cpm.name_sym
+    method_name = ("cpm_for_" + node.name_sym.to_s).to_sym
+    return false if self.respond_to?(method_name)
+    (class << self; self; end).module_eval do
+      define_method method_name do
+        cpm
+      end
+    end
+  end
+  
+  def likelihood(label)
+    OpenStruct.new
+  end
+
+  protected
+    
+
+    def assert_probabilities(opts)
+      return assert_probabilities_and_labels_from_values_hash(opts[:values]) if 
+        opts[:values] and opts[:values].is_a?(Hash)
+        
+      unnormalized_obj = opts.fetch(:probabilities, Array.new(self.size, 1.0))
+      unnormalized_vector = case unnormalized_obj
+      when Array
+        GSL::Vector.ary_to_gv(unnormalized_obj)
+      when GSL::Vector
+        unnormalized_obj
+      else
+        GSL::Vector[unnormalized_obj]
+      end
+
+      raise ArgumentError, "Probabilities must be #{self.size} items long" unless
+        unnormalized_vector.size == self.size
+
+      sum = unnormalized_vector.sum
+      @probabilities = unnormalized_vector.map {|e| e / sum }
+    end
+    
+    def assert_probabilities_and_labels_from_values_hash(values)
+      @labels, probabilities = values.inject([[], []]) do |list, e|
+        list.first << e.first
+        list.last << e.last
+        list
+      end
+      @probabilities = GSL::Vector.ary_to_gv(probabilities)
+    end
+    
+    def assert_liklihoods(opts)
+      likelihoods = opts.fetch(:likelihoods, Array.new(self.size, 1.0))
+      @likelihoods = case likelihoods
+      when Array
+        GSL::Vector.ary_to_gv(likelihoods)
+      when GSL::Vector
+        likelihoods
+      else
+        GSL::Vector[likelihoods]
+      end
+      raise ArgumentError, "Likelihoods must be #{self.size} items long" unless
+        likelihoods.size == self.size
+    end
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # BeliefNode.new
+end

data/lib/fathom/node/cpm_node.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
+
+# Conditional Probability Matrix to join two nodes
+class Fathom::CPMNode < Node
+  
+  def initialize(opts={})
+    ensure_belief_nodes(opts)
+    super(opts)
+    assert_name
+    assert_description
+    assert_cpm
+  end
+  
+  def parent
+    parents.first
+  end
+  
+  def child
+    children.first
+  end
+  
+  alias :matrix :values
+  
+  # Filter values from the matrix.  Allows us to grab multiple rows and columns if desired.
+  # If the rows or columns aren't filtered, all values are assumed to be desired.
+  #
+  # @cpm.probability :child_node_name => [:desired, :values], :parent_node_name => :value
+  # This filters both the child columns and the parent rows
+  # 
+  # @cpm.probability :child_node_name => [:desired, :values]
+  # This only filters the child columns
+  def probability(opts={})
+    # Are we using long descriptions for the return value?
+    # If so, we'll use a hash to describe it without having to parse the value out of a string later.
+    describe = opts.delete(:describe) || false
+    
+    # Is something unknown being asked for?
+    allowed = [parent.name_sym, child.name_sym]
+    unknown_keys = opts.reject {|k, v| allowed.include?(k)}
+    raise ArgumentError, "Unknown node: #{unknown_keys.inspect}" unless unknown_keys.empty?
+
+    # Values for the desired child and parent values
+    child_values = Array(opts[self.child.name_sym] || self.child.labels)
+    parent_values = Array(opts[self.parent.name_sym] || self.parent.labels)
+    
+    # Indices in the matrix for the desired values
+    child_indices = child_values.map {|c| self.child.labels.index(c)}
+    parent_indices = parent_values.map {|c| self.parent.labels.index(c)}
+
+    # Collect the filtered values from the matrix
+    value = parent_indices.inject(0.0) do |sum, row|
+      sum += child_indices.inject(0.0) do |s, col|
+        s += matrix.get(row, col)
+      end
+    end
+    
+    return value unless describe
+
+    label = "P(" + 
+      child_values.map(&:to_s).join(" or ") + 
+      " | " + 
+      parent_values.map(&:to_s).join(" or ") + 
+      ")"
+    { label => value }
+
+  end
+  alias :p :probability
+  
+  def odds(opts={})
+    p = probability(opts)
+    return p / (1 - p)
+  end
+  alias :o :odds
+  
+  # Returns a vector of likelihoods for each parent value, given the child value
+  def likelihood(value)
+    GSL::Vector.alloc(
+      *parent.labels.map {|parent_label| probability(parent.name_sym => parent_label, child.name_sym => value)}
+    )
+  end
+  alias :l :likelihood
+  
+  protected
+    def assert_name
+      @name ||= :cpm
+    end
+    
+    def assert_description
+      @description ||= "Conditional Probability Matrix from #{parent.name.to_s} to #{child.name.to_s}."
+    end
+  
+    def ensure_belief_nodes(opts)
+      raise ArgumentError, "The child must be a BeliefNode" unless opts[:child].is_a?(BeliefNode)
+      raise ArgumentError, "The parent must be a BeliefNode" unless opts[:parent].is_a?(BeliefNode)
+    end
+    
+    def assert_cpm
+      @values = self.parent.probabilities.col * self.child.probabilities
+    end
+end

data/lib/fathom/node/data_collection.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
+
+=begin
+  This class uses SQLite for in-memory set operations.  It is based on a discrete variable
+  which can be translated into fields in a table.  For now, I am just using float data
+  types for the fields.  This will evolve as needs drive it into a more robust data set.
+  
+  It turns out that SQLite set operations are quite fast and speed things up pretty well.
+  So, to use this class, you'll need to have sqlite3-ruby SQLite3 bindings installed.
+  
+  This also uses uuid to enforce a node name, an additional dependency.
+=end
+
+require 'uuid'
+
+class Fathom::DataCollection < DiscreteNode
+
+  def initialize(opts={})
+    opts = extract_labels(opts)
+    opts[:name] ||= UUID.generate
+    super(opts)
+  end
+
+  
+  protected
+  
+    # Looking for labels.
+    # Using :labels, then :parents, then :parent, looking for the first node with labels defined
+    def extract_labels(opts)
+      return opts if opts[:labels]
+      parents = opts[:parents]
+      parents ||= opts[:parent]
+      parents = Array[parents] if parents and not parents.is_a?(Array)
+      parents.each do |parent|
+        if parent.respond_to?(:labels)
+          opts[:labels] = parent.labels
+          return opts
+        end
+      end
+      opts
+    end
+  
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # DataCollection.new
+end
+
+
+# J2: Some bare-minimum sqlite3 stuff
+# See: http://sqlite-ruby.rubyforge.org/
+# require 'rubygems'
+# require 'sqlite3'
+# 
+# def prepare_database(table_name)
+#   @db = SQLite3::Database.new(":memory:")
+#   # @db = SQLite3::Database.new("/tmp/j2.db")
+# 
+#   create_sql = <<-SQL
+#   
+#   CREATE TABLE "#{table_name}" (
+#     "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, 
+#     "field1" FLOAT);
+#   SQL
+#     @db.execute_batch(create_sql)
+# 
+#   insert_sql = <<-SQL
+#     INSERT INTO #{table_name} 
+#       ("field1")
+#     VALUES
+#       (:field1);
+#   SQL
+#   @insert_record = @db.prepare(insert_sql)
+# 
+#   # select_sql = <<-SQL
+#   #   "select * from 'asdf';"
+#   # SQL
+#   # @select_record = @db.prepare(select_sql)
+#   @select_record = @db.prepare( "select * from asdf" )
+# end
+# 
+# def insert_record(opts)
+#   @insert_record.bind_params(:field1 => opts[:field1])
+#   @insert_record.execute
+# end
+# 
+# def select_record(opts={})
+#   # @db.execute( "select * from 'asdf'" )
+#   @select_record.execute.entries
+# end
+# 
+# prepare_database('asdf')
+# insert_record :field1 => 123.1
+# insert_record :field1 => 122.2
+# @a = select_record