pgm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8801783d85c563cfc9bdbf262d6ebf52db065a1
+  data.tar.gz: d60116e3e47e50f95fa90de363ff2aa36a58f60f
+SHA512:
+  metadata.gz: df4d59efac1f7cc6912c4f2f5c163dfd6428e271b7991a8e46f2756fe3fcf057dfc872812620cc39138b6fb9bf55f03c923b68d3184b49db66c3deb54490e9a5
+  data.tar.gz: 294e6adb7dabe1aafc2726bbb92612b6666a7794b47792d563ea14a18a934bc96781a3013606c819655c68d689657f041f908739e3800a1dc5d2896ea6d3d866

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'rgl'

data/README.md

@@ -0,0 +1,15 @@
+# PGM: Probabilistic Graphical Model Library
+
+[![Bitbucket](https://img.shields.io/badge/bitbucket-natapol--pmg-blue.svg)](https://bitbucket.org/natapol/pgm)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://rubydoc.org/gems/pgm/frames)
+[![Gem Version](https://badge.fury.io/rb/pgm.svg)](https://bitbucket.org/natapol/pgm/releases)
+[![License](http://img.shields.io/badge/license-GPL--3-yellowgreen.svg)](#license)
+
+## Synopsis
+This library is expected to provide basic functions for Probabilistic Graphical Model analysis. However, the library is still in development process. Only Bayesian network with discrete random variable module is available at this time.
+
+## Feature List
+**1. Bayesian network with discrete random variable**
+
+## Design principles
+The model library is derived from

data/contributors.txt

@@ -0,0 +1 @@
+Natapol Pornputtapong

data/lib/pgm.rb

@@ -0,0 +1,44 @@
+# Probabilistic Graphical Model Library
+#
+# Copyright (C) 2016
+#
+# author: Natapol Pornputtapong <natapol.por@gmail.com>
+#
+# Documentation: Natapol Pornputtapong
+#
+
+raise "Please, use ruby 1.9.0 or later." if RUBY_VERSION < "1.9.0"
+
+$: << File.join(File.expand_path(File.dirname(__FILE__)))
+
+#Internal library
+require 'i18n'
+
+#External library
+
+
+I18n.enforce_available_locales = false
+
+
+
+#library
+require 'pgm/model'
+
+# A ruby library for probabilistic graphical model
+module PGM
+
+  # version of the library
+  VERSION = "0.0.1"
+
+  # Exception class for NotDirectedError
+  class NotDirectedError < RuntimeError; end
+
+  # Exception class for NotUndirectedError
+  class NotUndirectedError < RuntimeError; end
+
+  # Exception class for NoVertexError
+  class NoVertexError < IndexError; end
+
+  # Exception class for NoEdgeError
+  class NoEdgeError < IndexError; end
+end

data/lib/pgm/bidirectional.rb

@@ -0,0 +1,126 @@
+# Probabilistic Graphical Model Library
+#
+# Copyright (C) 2016
+#
+# author: Natapol Pornputtapong <natapol.por@gmail.com>
+#
+# Documentation: Natapol Pornputtapong
+#
+
+module PGM
+
+  # describe bidirectionally function to Graph
+  module Bidirectional
+
+    # Instantiate DiscreateVariable
+    #
+    # @param edgelist_class [Object] Object to store edge class
+    # @param other_graphs [PGM::BayesianNet] List of variable states
+    def initialize(edgelist_class = Set, *other_graphs)
+      @vertices_rev_dict = Hash.new
+      @variables = Hash.new
+      super
+    end
+
+    # Copy internal vertices_dict
+    #
+    # @param orig [PGM::BayesianNet] Copy from other graph
+    def initialize_copy(orig)
+      super
+      @vertices_rev_dict = orig.instance_eval { @vertices_rev_dict }.dup
+      @vertices_rev_dict.keys.each do |v|
+        @vertices_rev_dict[v] = @vertices_rev_dict[v].dup
+      end
+      @variables = orig.instance_eval { @variables }.dup
+    end
+
+    # Return variable with the name
+    #
+    # @param name [String, Symbol] The name of variable
+    # @return [PGM::Variable] Variable object
+    def var(name=nil)
+      if nil
+        return @variables
+      else
+        return @variables[name.to_sym]
+      end
+    end
+
+    # Create variable
+    #
+    # @param name [String, Symbol] Name of variable
+    # @param states [Array<String, Symbol>] List of variable states
+    # @param parents [Array<PGM::Variable>] List of parent variable
+    # @param type [PGM::Variable] type of variable
+    def create_var(name, states, parents: [], type: PGM::DiscreateVariable)
+      add_vertex(name)
+      @variables[name.to_sym] = type.new(self, name, states, parents: parents)
+    end
+
+    # Check if model has the variable named as input
+    #
+    # @param name [String, Symbol] Name of variable
+    # @return [Boolean] if model has the variable
+    def has_var?(name)
+      return @variables.has_key?(name.to_sym)
+    end
+
+    # assign link from u to v
+    #
+    # @param u [PGM::Variable] Variable to be linked
+    # @param v [PGM::Variable] Variable to be linked
+    def create_link(u, v)
+      if has_var?(u) && has_var?(v)
+        var(v).to(var(u))
+      end
+    end
+
+    protected
+
+    def basic_add_edge(u, v)
+      super
+      @vertices_rev_dict[v].add(u)
+    end
+
+    # See MutableGraph#add_vertex.
+    #
+    # If the vertex is already in the graph (using eql?), the method does
+    # nothing.
+    #
+    def add_vertex(v)
+      super
+      @vertices_rev_dict[v] ||= @edgelist_class.new
+    end
+
+    # See MutableGraph#remove_vertex.
+    #
+    def remove_vertex(v)
+      super
+      @vertices_rev_dict.delete(v)
+      # remove v from all adjacency lists
+      @vertices_rev_dict.each_value { |adjList| adjList.delete(v) }
+    end
+
+    # See MutableGraph::remove_edge.
+    #
+    # Also removes (v,u)
+    #
+    def remove_edge(u, v)
+      super
+      @vertices_rev_dict[v].delete(u) unless @vertices_dict[v].nil?
+    end
+
+    def each_parent(v, &b) # :nodoc:
+      parent_list = (@vertices_rev_dict[v] or raise NoVertexError, "No vertex #{v}.")
+      parent_list.each(&b)
+    end
+
+    def parent_vertices(v)
+      r = []
+      each_parent(v) { |u| r << u }
+      r
+    end
+
+  end
+
+end

data/lib/pgm/model.rb

@@ -0,0 +1,209 @@
+# Probabilistic Graphical Model Library
+#
+# Copyright (C) 2016
+#
+# author: Natapol Pornputtapong <natapol.por@gmail.com>
+#
+# Documentation: Natapol Pornputtapong
+#
+
+require 'rgl/adjacency'
+require 'rgl/topsort'
+require 'rgl/dot'
+
+require 'pgm/variable'
+require 'pgm/bidirectional'
+
+module PGM
+  # Bayesian Network Class
+  #
+  # Example:
+  #
+  # create model
+  #   bayenet = PGM::BayesianNet.new()
+  #   bayenet.create_var(:cloudy, [:t, :f])
+  #   bayenet.create_var(:sprinkler, [:t, :f])
+  #   bayenet.create_var(:rain, [:t, :f])
+  #   bayenet.create_var(:grass_wet, [:t, :f])
+  #   bayenet.create_link(:cloudy, :sprinkler)
+  #   bayenet.create_link(:cloudy, :rain)
+  #   bayenet.create_link(:sprinkler, :grass_wet)
+  #   bayenet.create_link(:rain, :grass_wet)
+  #
+  # learn with data
+  #   bayenet.learn([
+  #     {:cloudy => :t, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+  #     {:cloudy => :t, :sprinkler => :t, :rain => :f, :grass_wet => :t},
+  #     {:cloudy => :f, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+  #     {:cloudy => :t, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+  #     {:cloudy => :f, :sprinkler => :t, :rain => :f, :grass_wet => :f},
+  #     {:cloudy => :f, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+  #     {:cloudy => :f, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+  #     {:cloudy => :t, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+  #     {:cloudy => :t, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+  #     {:cloudy => :f, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+  #   ])
+  #
+  # print out the conditional_probability_table
+  #   bayenet.puts_conditional_probability_table
+  #
+  # create graph from model
+  #   bayenet.write_to_graphic_file('jpg')
+  class BayesianNet < RGL::DirectedAdjacencyGraph
+
+    include PGM::Bidirectional
+
+    # Find common parents of input nodes
+    #
+    # @param vs [Array<PGM::Variable>] List of vertices
+    # @return [Array<PGM::Variable>] List parent vertices
+    def common_parents(*vs)
+      r = nil
+      vs.each do |v|
+        if r
+          r &= parent_vertices(v)
+        else
+          r = parent_vertices(v)
+        end
+      end
+      r ||= []
+    end
+
+    # Check if there are common parents of input vertices
+    #
+    # @param vs [Array<PGM::Variable>] List of variables
+    # @return [Boolean] Is there common parents
+    def common_parents?(*vs)
+      return !common_parents(*vs).empty?
+    end
+
+    # Find common children of input vertices
+    #
+    # @param vs [Array<PGM::Variable>] List of vertices
+    # @return [Array<PGM::Variable>] List child vertices
+    def common_children(*vs)
+      r = nil
+      vs.each do |v|
+        if r
+          r &= adjacent_vertices(v)
+        else
+          r = adjacent_vertices(v)
+        end
+      end
+      r ||= []
+    end
+
+    # Check if there are common children of input vertices
+    #
+    # @param vs [Array<PGM::Variable>] List of vertices
+    # @return [Boolean] Is there common children
+    def common_children?(*vs)
+      return !common_children(*vs).empty?
+    end
+
+    # Check if vertices are in cascading topology
+    #
+    # @param vs [Array<PGM::Variable>] List of vertices
+    # @return [Boolean] Are vertices in cascading topology
+    def cascade?(*vs)
+      prev_children = nil
+      r = true
+      if vs.length > 2
+        vs.each do |v|
+          prev_children ||= [v]
+          if !prev_children.include?(v)
+            r = false
+            break
+          else
+            prev_children = adjacent_vertices(v)
+          end
+        end
+      else
+        r = false
+      end
+      return r
+    end
+
+    # Check if vertices are in V-Structure
+    #
+    # @param vs [Array<PGM::Variable>] List of vertices
+    # @return [Boolean] Are vertices in V-Structure
+    def v_tructure?(*vs)
+      if vs.length == 3
+        return parent_vertices(vs[0]).sort == vs[1..-1].sort
+      else
+        return false
+      end
+    end
+
+    # Generate string notation of Baysian Network
+    #
+    # @return [String] Model notation
+    def model_notation
+      line = []
+      each_vertex do |v|
+        parents = parent_vertices(v)
+        line.push("P(#{v}#{parents.empty? ? '' : "|#{parents.join(',')}"})")
+      end
+      return "P(#{vertices.sort.join(',')}) = #{line.sort.join('')}"
+    end
+
+    # learn model from array of condition and automatically calculate the
+    # conditional probability table. Condition is in a Hash format { var_name1: state_name1, var_name2: state_name2 }
+    #
+    # @param arr [Array<Hash{Symbol => Symbol,String}>] Array of data for learning in Hash objects
+    def learn(arr)
+      @variables.each_value do |var|
+        var.learn(arr)
+      end
+    end
+
+    # Learn the model with discrete data.
+    # Condition is in a Hash format { var_name1: state_name1, var_name2: state_name2 }
+    #
+    # @param condition [Hash{Symbol => Symbol,String}] Data for learning in a Hash objects
+    def add_data(condition)
+      @variables.each_value do |var|
+        var.add_data(condition)
+      end
+    end
+
+    # Set conditional probability to a random variable
+    # Condition is in a Hash format { var_name1: state_name1, var_name2: state_name2 }
+    #
+    # @param varname [String, Symbol] Random variable name
+    # @param prob [Float] Probability
+    # @param condition [Hash{Symbol => Symbol,String}] Data for learning in Hash objects
+    def set_conditional_probability(varname, prob, condition)
+      var(varname.to_sym).set_conditional_probability(prob, condition)
+    end
+
+    # Calculate conditional probability table from learned data
+    #
+    def calculate_conditional_probability_table
+      @variables.each_value do |var|
+        var.calculate_conditional_probability_table
+      end
+    end
+
+    alias_method :cal_cpt, :calculate_conditional_probability_table
+
+    # puts conditional probability table on the screen
+    #
+    # @param cellsize [Integer] Size of each cell
+    def puts_conditional_probability_table(cellsize = 25)
+      @variables.each_value do |val|
+        val.puts_conditional_probability_table(cellsize)
+      end
+    end
+
+    alias_method :puts_cpt, :puts_conditional_probability_table
+
+    # Order random variable by ancestral order
+    #
+    def ancestral_ordering
+      return self.topsort_iterator.to_a
+    end
+  end
+
+end

data/lib/pgm/variable.rb

@@ -0,0 +1,180 @@
+# Probabilistic Graphical Model Library
+#
+# Copyright (C) 2016
+#
+# author: Natapol Pornputtapong <natapol.por@gmail.com>
+#
+# Documentation: Natapol Pornputtapong
+#
+
+require 'narray'
+
+module PGM
+
+  # Most ancestral class for Random variable
+  class Variable
+    def initialize
+      raise NotImplementedError
+    end
+  end
+
+  # A class for discrete random variable
+  class DiscreateVariable < Variable
+
+    attr_reader :name, :model, :states, :parents, :children
+
+    # Instantiate DiscreateVariable
+    #
+    # @param model [PGM::BayesianNet] Model for variable to be added
+    # @param name [String, Symbol] Name of variable
+    # @param states [Array<String, Symbol>] List of variable states
+    # @param parents [Array<PGM::Variable>] List of parent vertices
+    # @param children [Array<PGM::Variable>] List of child vertices
+    def initialize(model, name, states, parents: [], children: [])
+      @name = name.to_sym
+      @model = model
+      @states = states.map{|x| x.to_sym}.sort
+      @parents = parents
+      @children = children
+      self.create_conditional_probability_table
+    end
+
+    # compare variables
+    #
+    # @param other [PGM::Variable] Model for variable to be added
+    # @return [Integer] List of child vertices
+    def <=>(other)
+      if other.is_a?(PGM::Variable)
+        if @model == other.model
+          return @name <=> other.name
+        else
+          return @model <=> other.model
+        end
+      else
+        raise TypeError, "#{other} is not PGM::Variable"
+      end
+    end
+
+    # assign link from self to other
+    #
+    # @param other [PGM::Variable] Variable to be linked
+    def to(other)
+      other.add_parent(self)
+      self.add_child(other)
+      @model.add_edge(@name, other.name)
+    end
+
+    # learn model from array of condition and automatically calculate the
+    # conditional probability table
+    #
+    # @param arr [Array<Hash{Symbol => Symbol,String}>] Array of data for learning in Hash objects
+    def learn(arr)
+      arr.each do |item|
+        self.add_data(item)
+      end
+      self.calculate_conditional_probability_table
+    end
+
+    # learn model from data.
+    # Condition is in a Hash format { var_name1: state_name1, var_name2: state_name2 }
+    #
+    # @param condition [Hash{Symbol => Symbol,String}] Data for learning in Hash objects
+    def add_data(condition)
+      @count_table[*self.data_coor(condition)] += 1
+    end
+
+    # calculate conditional probability table
+    def calculate_conditional_probability_table
+      @probability_table = @count_table.floor / @count_table.sum(1).to_f
+    end
+
+    alias_method :cal_cpt, :calculate_conditional_probability_table
+
+    # puts conditional probability table on the screen
+    #
+    # @param cellsize [Integer] Size of each cell
+    def puts_conditional_probability_table(cellsize = 25)
+      puts "#{@name.to_s.center(cellsize)}|#{@adjoint_var_list.map{|x| "P(#{x})".center(cellsize)}.join('|')}"
+      0.upto(@states.length - 1).each do |ind|
+        puts "#{@states[ind].to_s.rjust(cellsize)}|#{@probability_table[true, ind].to_a.map{|x| x.round(5).to_s.rjust(cellsize)}.join('|')}"
+      end
+    end
+
+    alias_method :puts_cpt, :puts_conditional_probability_table
+
+    # assign conditional probability for specified condition.
+    # Condition is in a Hash format { var_name1: state_name1, var_name2: state_name2 }
+    #
+    # @param prob [Float] probability
+    # @param condition [Hash{Symbol => Symbol,String}] condition in Hash objects
+    def set_conditional_probability(prob, condition)
+      @probability_table[*self.data_coor(condition)] = prob
+    end
+
+    alias_method :set_cp, :set_conditional_probability
+
+    # return conditional probability of the specified condition.
+    # Condition is in a Hash format { var_name1: state_name1, var_name2: state_name2 }
+    #
+    # @param condition [Hash{Symbol => Symbol,String}] condition in Hash objects
+    # @return [Float] probability
+    def conditional_probability(condition)
+      return @probability_table[*self.data_coor(condition)]
+    end
+
+    protected
+
+    def data_coor(condition)
+      #[column, row]
+      notation = []
+      @parents.map{|x| x.name.to_sym}.each do |name|
+        notation.push("#{name}=#{condition[name]}")
+      end
+      return [
+                @adjoint_var_list.include?(notation.join(',')) ? @adjoint_var_list.index(notation.join(',')) : true,
+                @states.include?(condition[@name]) ? @states.index(condition[@name]) : true
+              ]
+    end
+
+    def state_notation
+      notations = []
+      self.states.each do |state|
+        notations.push("#{name}=#{state}")
+      end
+      return notations
+    end
+
+    def create_conditional_probability_table
+      list = []
+      @parents.each do |parent|
+        list.push(parent.state_notation)
+      end
+      if list.length == 0
+        @adjoint_var_list = [@name]
+      elsif list.length == 1
+        @adjoint_var_list = list[0]
+      else
+        @adjoint_var_list = list[0].product(*list[1..-1]).map{|x| x.join(',')}
+      end
+      @count_table = NArray.sfloat(@adjoint_var_list.length, @states.length).fill(0.0000001)
+      @probability_table = NArray.sfloat(@adjoint_var_list.length, @states.length)
+    end
+
+    def add_parent(var)
+      @parents.push(var)
+      @parents.sort!
+      self.create_conditional_probability_table
+    end
+
+    def add_child(var)
+      @children.push(var)
+      @children.sort!
+    end
+
+  end
+
+  # A class for concrete random variable
+  class ConcreteVariable < Variable
+
+  end
+end

data/pgm.gemspec

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'pgm'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name          = 'pgm'
+  s.version       = PGM::VERSION
+  s.date          = Date.today.strftime('%Y-%m-%d')
+  s.platform      = Gem::Platform::RUBY
+
+  s.summary       = "A ruby library for probabilistic graphical model"
+  s.description   = "A ruby library for probabilistic graphical model"
+  s.authors       = ["Natapol Pornputtapong"]
+  s.email         = ['natapol.por@gmail.com']
+
+  s.homepage      = 'http://rubygems.org/gems/pgm'
+  s.licenses      = ['GPL-3.0']
+
+#    s.rubyforge_project = "neography"
+
+  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']
+  s.bindir        = 'bin'
+
+  s.add_dependency "rgl", "~> 0.5"
+  s.add_dependency "narray", "~> 0.6"
+#    s.add_dependency "bson_ext", "~> 1.9"
+#    s.add_dependency "rdf", "~> 1.1"
+
+
+  s.add_development_dependency "rspec", ">= 3.4"
+
+    #### Documentation and testing.
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.md']
+  s.rdoc_options += [
+    '--title', 'PGM - Probabilistic Graphical Model Library',
+    '--main', 'README.md',
+    '--line-numbers'
+  ]
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,150 @@
+# in spec/calculator_spec.rb
+# - RSpec adds ./lib to the $LOAD_PATH
+require "pgm/model"
+
+RSpec.describe PGM::BayesianNet do
+
+  context "test graph module" do
+    def build_model
+      PGM::BayesianNet[*'ACCFBDBEDFEHFHFG'.chars]
+    end
+
+    before(:example) do
+      @model = build_model
+    end
+
+    describe '#common_parents' do
+      it 'returns the blank array' do
+        expect(@model.common_parents).to eq([])
+      end
+
+      it 'returns the common parent list' do
+        expect(@model.common_parents(*'GH'.chars)).to eq(['F'])
+      end
+    end
+
+    describe '#common_parents?' do
+      it 'returns false when blank input' do
+        expect(@model.common_parents?).to eq(false)
+      end
+
+      it 'returns false when no common parents' do
+        expect(@model.common_parents?(*'CD'.chars)).to eq(false)
+        expect(@model.common_parents?(*'CDE'.chars)).to eq(false)
+      end
+
+      it 'returns true when there are common parents' do
+        expect(@model.common_parents?(*'GH'.chars)).to eq(true)
+      end
+    end
+
+    describe '#common_children' do
+      it 'returns the blank array' do
+        expect(@model.common_children).to eq([])
+      end
+
+      it 'returns the common child list' do
+        expect(@model.common_children(*'CD'.chars)).to eq(['F'])
+      end
+    end
+
+    describe '#common_children?' do
+      it 'returns false when blank input' do
+        expect(@model.common_children?).to eq(false)
+      end
+
+      it 'returns false when no common children' do
+        expect(@model.common_children?(*'CE'.chars)).to eq(false)
+        expect(@model.common_children?(*'CDE'.chars)).to eq(false)
+      end
+
+      it 'returns true when there are common children' do
+        expect(@model.common_children?(*'CD'.chars)).to eq(true)
+      end
+    end
+
+    describe '#cascade?' do
+      it 'returns false when blank inputs' do
+        expect(@model.cascade?).to eq(false)
+      end
+
+      it 'returns false when not cascading' do
+        expect(@model.cascade?(*'AC'.chars)).to eq(false)
+        expect(@model.cascade?(*'ACH'.chars)).to eq(false)
+        expect(@model.cascade?(*'ADE'.chars)).to eq(false)
+      end
+
+      it 'returns true when cascading' do
+        expect(@model.cascade?(*'ACF'.chars)).to eq(true)
+        expect(@model.cascade?(*'ACFH'.chars)).to eq(true)
+      end
+    end
+
+    describe '#v_tructure?' do
+      it 'returns false when wrong number of node' do
+        expect(@model.v_tructure?).to eq(false)
+        expect(@model.v_tructure?(*'AC'.chars)).to eq(false)
+        expect(@model.v_tructure?(*'FCDB'.chars)).to eq(false)
+      end
+
+      it 'returns false when not in v-structure' do
+        expect(@model.v_tructure?(*'CFD'.chars)).to eq(false)
+        expect(@model.v_tructure?(*'BDE'.chars)).to eq(false)
+        expect(@model.v_tructure?(*'FAB'.chars)).to eq(false)
+      end
+
+      it 'returns true when v-structure' do
+        expect(@model.v_tructure?(*'FCD'.chars)).to eq(true)
+      end
+    end
+
+    describe '#model_notation' do
+      it 'returns a joint ditribution string' do
+        expect(@model.model_notation).to eq('P(A,B,C,D,E,F,G,H) = P(A)P(B)P(C|A)P(D|B)P(E|B)P(F|C,D)P(G|F)P(H|E,F)')
+      end
+    end
+  end
+
+  context "testing probability net" do
+    def build_model
+      a = PGM::BayesianNet.new()
+      a.create_var(:cloudy, [:t, :f])
+      a.create_var(:sprinkler, [:t, :f])
+      a.create_var(:rain, [:t, :f])
+      a.create_var(:grass_wet, [:t, :f])
+      a.create_link(:cloudy, :sprinkler)
+      a.create_link(:cloudy, :rain)
+      a.create_link(:sprinkler, :grass_wet)
+      a.create_link(:rain, :grass_wet)
+      return a
+    end
+
+    before(:example) do
+      @model = build_model
+    end
+
+    describe '#model_notation' do
+      it 'returns a model notation string' do
+        expect(@model.model_notation).to eq("P(cloudy,grass_wet,rain,sprinkler) = P(cloudy|sprinkler,rain)P(grass_wet)P(rain|grass_wet)P(sprinkler|grass_wet)")
+      end
+    end
+
+    describe '#learning' do
+      it 'returns a joint ditribution string' do
+        @model.learn([
+          {:cloudy => :t, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+          {:cloudy => :t, :sprinkler => :t, :rain => :f, :grass_wet => :t},
+          {:cloudy => :f, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+          {:cloudy => :t, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+          {:cloudy => :f, :sprinkler => :t, :rain => :f, :grass_wet => :f},
+          {:cloudy => :f, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+          {:cloudy => :f, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+          {:cloudy => :t, :sprinkler => :f, :rain => :t, :grass_wet => :t},
+          {:cloudy => :t, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+          {:cloudy => :f, :sprinkler => :f, :rain => :f, :grass_wet => :f},
+        ])
+        expect(@model.var(:cloudy).conditional_probability({:cloudy => :f}).to_a).to eq([0.75, 0.4999999403953552, 0.25, 0.0])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+RSpec.configure do |config|
+  # use color in STDOUT
+  config.color_enabled = true
+
+  config.tty = true
+
+  config.formatter = :documentation
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: pgm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Natapol Pornputtapong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rgl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: A ruby library for probabilistic graphical model
+email:
+- natapol.por@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- README.md
+- contributors.txt
+- lib/pgm.rb
+- lib/pgm/bidirectional.rb
+- lib/pgm/model.rb
+- lib/pgm/variable.rb
+- pgm.gemspec
+- spec/model_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/pgm
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--title"
+- PGM - Probabilistic Graphical Model Library
+- "--main"
+- README.md
+- "--line-numbers"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: A ruby library for probabilistic graphical model
+test_files:
+- spec/model_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true