rb_probdsl 0.0.1

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2010, Steffen Siering
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Steffen Siering nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/examples/alarm.rb

@@ -0,0 +1,149 @@
+
+require 'rubygems'
+
+require 'probdsl'
+include ProbDSL
+
+# Alarm example from "Artificial Intelligence - A Modern Approach" by Russel
+# and Norvig Page 493 cc.
+#
+# Suppose you have a new fairly reliable burglar alarm at home but occasionally
+# it responds to minor earthquakes. You also have two neighbors John and Mary,
+# who have promised to call you at work when they hear the alarm. John always
+# calls when he hears the alarm, but sometimes confuses the telephone ringing
+# with the alarm and calls then, too. Mary, on the other hand, is too much in
+# loud music and sometimes misses the alarm altogether.
+#
+# So the bayesian network will be:
+#
+#           B         E
+#            \       /
+#            _\|   |/_
+#                A
+#             /    \
+#           |/_    _\|
+#          J          M
+#
+#  with probabilities:
+#  P(B) = 0.001
+#  P(E) = 0.002
+#
+#  P(A| B=true, E=true)   = 0.95
+#  P(A| B=true, E=false)  = 0.94
+#  P(A| B=false, E=true)  = 0.29
+#  P(A| B=false, E=false) = 0.001
+#
+#  P(J| A=true)  = 0.9
+#  P(J| A=false) = 0.05
+#
+#  P(M| A=true)  = 0.7 
+#  P(M| A=false) = 0.01
+#
+#  where B = burglar, E = earthquake, A = alarm, J = John calls and 
+#  M = Mary calls
+#
+
+# first let's encode the probabilities from the network
+# P(B)
+def p_burglary
+    flip(0.001, :B, :notB)
+end
+
+# P(E)
+def p_earthquake
+    flip(0.002, :E, :notE)
+end
+
+# P(A|B = b,E = e)
+def p_alarm(b,e)
+    pAlarmTable = {
+        [:B, :E] => 0.95,
+        [:B, :notE] => 0.94,
+        [:notB, :E] => 0.29,
+        [:notB, :notE] => 0.001
+    }
+    flip(pAlarmTable[[b,e]], :A, :notA)
+end
+
+# P(J|A = a)
+def p_john(a)
+    flip( a == :A ? 0.9 : 0.05, :J, :notJ)
+end
+
+# P(M|A = a)
+def p_mary(a)
+    flip( a == :A ? 0.7 : 0.01, :M, :notM)
+end
+
+p "joint probability:"
+p(prob do
+    b = p_burglary
+    e = p_earthquake
+    a = p_alarm(b,e)
+    [b,e,a,p_john(a), p_mary(a)]
+end)
+
+p "P(B|John=true, Mary=true):"
+p(normalizedProb do
+    b = p_burglary
+    e = p_earthquake
+    a = p_alarm(b,e)
+    if (p_john(a) == :J && p_mary(a) == :M)
+        b
+    else
+        nil
+    end
+end)
+
+p "P(A|John=true, Mary=true)"
+p(normalizedProb do
+    b = p_burglary
+    e = p_earthquake
+    a = p_alarm(b, e)
+    if p_john(a) == :J && p_mary(a) == :M
+        a
+    else
+        nil
+    end
+end)
+
+# john and mary tell us for sure, the alarm went of and we know
+# that is true...
+p "P(B|John=true, Mary=true, Alarm=true)"
+p(normalizedProb do
+    b = p_burglary
+    e = p_earthquake
+    a = p_alarm(b,e)
+    if (a == :A && p_john(a) == :J && p_mary(a) == :M)
+        b
+    else
+        nil
+    end
+end)
+
+# what is the probability john will call, if mary called?
+p "P(John|Mary=true)"
+p(normalizedProb do
+    b = p_burglary
+    e = p_earthquake
+    a = p_alarm(b,e)
+    if (p_mary(a) == :M)
+        p_john(a)
+    else
+        nil
+    end
+end)
+
+# and probability mary will call, if john did
+p "P(Mary|John=true)"
+p(normalizedProb do
+    b = p_burglary
+    e = p_earthquake
+    a = p_alarm(b,e)
+    if (p_john(a) == :J)
+        p_mary(a)
+    else
+        nil
+    end
+end)
+

data/examples/diagnosis.rb

@@ -0,0 +1,62 @@
+
+require 'rubygems'
+
+require 'probdsl'
+include ProbDSL
+
+# 
+# Problem: 
+# Given a positive or negative test for a specific illness we want to know the
+# probability for being ill or healthy.
+#
+# Suppose the random variables I and T are given with I = {Ill, Healthy}
+# being the health status and T = {Negative, Positive} the test result.
+#
+# It is known that the probability of being 'ill' is 1 in a 1000,
+# thus:
+# P(I = Ill) = 0.001 and P(I = Healthy) = 0.999
+#
+# Furthermore we do know that the test has an accuracy of 99%, thus
+# P(T = Positive | I = Ill ) = 0.99
+# P(T = Negative | I = Ill ) = 0.01
+# P(T = Positive | I = Healthy ) = 0.01
+# P(T = Negative | I = Healthy ) = 0.99
+#
+# Task:
+# compute the probability of being 'ill', given the test was positive.
+# Using bayes rule:
+#
+# P(T, I) = P(T|I) * P(I) = P(I|T) * P(T)
+#
+# =>
+#
+#           P(T |I) * P(I)
+# P(I|T) = ---------------- = < P(T|I) * P(I) >
+#                P(T)
+#
+#
+
+PFalseNegative = 0.01 # constant for P( T | I = Ill)
+PFalsePositive = 0.01 # constant for P( T | I = Healthy)
+
+# define: P(I)
+def p_disease
+    flip 0.001, :ILL, :HEALTHY
+end
+
+# P(T|I)
+def p_test(i)
+    flip(i == :ILL ? PFalseNegative : 1 - PFalsePositive,
+           :Negative, :Positive)
+end
+
+p "P(I|T=Positive)"
+p normalizedProb {
+    i = p_disease
+    if p_test(i) == :Positive
+        i
+    else
+        nil
+    end
+}
+

data/examples/montyhall.rb

@@ -0,0 +1,105 @@
+
+require 'rubygems'
+
+require 'probdsl'
+include ProbDSL
+
+# the monty hall problem is a simple game show based probability puzzle with
+# a puzzling outcome :)
+#
+# Suppose you are on a game show and you are given the choice of 3 doors.
+# Behind one of these doors is the price and behind the others a goat. Only the
+# moderator knows behind which door the price is and will open one door with a
+# goat after you did your first choice. Next you can choose if you want to
+# switch doors or not.
+#
+# Question:
+# What is the best strategie? Stay or switch?
+# What are the probabilities of winning for each of these strategies?
+#
+
+# first we want to encode our state.
+#
+# these are the doors one can choose from: 
+$doors = [:A, :B, :C]
+
+# and this the game's current state
+class State
+    attr_accessor :prize, # door the prize is behind
+                  :open,  # door opened by host
+                  :chosen # door currently chosen by player
+
+    def initialize(p,c,o)
+        @prize  = p
+        @chosen = c
+        @open   = o
+    end
+
+    def testWinner 
+        if @prize == @chosen 
+            :Winner
+        else
+            :Looser
+        end
+    end
+end
+
+# Let us encode the problem with random variables:
+#
+# P  = doors : door prize was put behind
+# C1 = doors : the door chosen in the first round by player
+# O  = doors :  the door opened by show's host
+#
+
+# first step: let's hide the price
+# P(P = A) = 1/3
+# P(P = B) = 1/3
+# P(P = C) = 1/3
+def hide
+    uniform $doors
+end
+
+# and then let the player choose one door:
+# P(C1 = A) = 1/3
+# P(C1 = B) = 1/3
+# P(C1 = C) = 1/3
+def choose
+    uniform $doors
+end
+
+# compute probability distribution of host opening a specific door
+# given the event P and C1:
+# P(O|C1,P)
+# with O != C1 and O != P
+def open(hidden, chosen)
+    uniform($doors - [hidden, chosen])
+end
+
+# play the first round (until game host will open a door)
+def firstRound
+    p = hide
+    c = choose
+    State.new p, c, open(p,c)
+end
+
+# finally implement strategie 'stay'
+def stay(s)
+    s
+end
+
+# and strategy 'switch' choosing a door C2 with
+# C2 != O and C2 != C1.
+# find P(C2|O, C1, P)
+def switch(s)
+    uniform(($doors - [s.open, s.chosen]).map {|d| 
+        State.new s.prize, d, s.open
+    })
+end
+
+# print some results
+p 'strategy stay:'
+p(prob { stay(firstRound).testWinner })
+
+p 'strategy switch:'
+p(prob { switch(firstRound).testWinner })
+

data/examples/paradox.rb

@@ -0,0 +1,42 @@
+
+require 'rubygems'
+require 'probdsl'
+include ProbDSL
+
+#
+# found here: http://heath.hrsoftworks.net/archives/000036.html
+#
+
+def die
+    uniform 1..6
+end
+
+puts <<HERE
+Two dice are rolled simultaneously. Given that one die shows a "4", what is
+the probability that the total on the uppermost faces of the two dice is "7"?
+
+Answear (2/11):
+HERE
+
+p normalizedProb {
+    d1 = die; d2 = die
+    if d1 == 4 || d2 == 4
+        d1 + d2 == 7
+    else
+        nil
+    end
+}.probability(true)
+
+puts <<HERE
+
+The same experiment using a simulation (t = 10s):
+HERE
+p collecting(loop_t 10) {
+    d1 = die; d2 = die
+    if d1 == 4 || d2 == 4
+        d1 + d2 == 7
+    else
+        nil
+    end
+}.normalize.probability(true)
+

data/examples/test.rb

@@ -0,0 +1,68 @@
+
+require 'rubygems'
+
+require 'probdsl'
+include ProbDSL
+
+p 'test1'
+
+p(prob {
+    d = uniform [1,2,3,4,5,6]
+    d
+})
+
+p 'test2'
+
+def die
+    uniform 1..6
+end
+
+def dice
+    d1 = die
+    d2 = die
+    [d1, d2]
+end
+
+p(prob {
+    d1 = die
+    d2 = die
+    d1 + d2
+})
+
+p 'test3'
+
+p(prob{ die + die })
+
+p 'test4'
+
+p(pick {
+    dice
+})
+
+p 'test5'
+
+p(prob {
+    d1, d2 = dice
+    d1 + d2
+})
+
+p 'test6'
+tmp = prob{ dice }
+
+p(prob {
+    d1, d2 = dist(tmp) # this time use already evaluated distribution
+    d1 + d2
+})
+
+p 'test7'
+
+p(collecting(loop_k 1000) {
+    die + die
+})
+
+p 'test8'
+
+p(collecting(loop_t 30) {
+    die + die
+})
+

data/lib/probdsl.rb

@@ -0,0 +1,129 @@
+
+require 'rubygems'
+
+require 'delimcc'
+require 'prob'
+
+module ProbDSL
+    include DelimCC
+    include Probably
+
+    class PValue
+        def initialize(v)
+            @value = v
+        end
+
+        def reify
+            Probably.mkState @value
+        end
+
+        def pick
+            @value
+        end
+    end
+
+    class PChoice
+        def initialize(&blk)
+            @fn = blk
+        end
+
+        def reify
+            d = @fn.call
+            d.dep do |m|
+                k = m[0]
+                v = m[1]
+                tmp = k.call(v)
+                tmp.reify
+            end
+        end
+
+        def pick
+            d = @fn.call
+            m,p = d.pick
+            k = m[0]
+            v = m[1]
+            tmp = k.call v
+            tmp.pick
+        end
+    end
+
+    def run_prob(&blk)
+        reset {
+            v = blk.call
+            PValue.new v
+        }
+    end
+
+    def prob(&blk)
+        run_prob(&blk).reify
+    end
+
+    def normalizedProb(&blk)
+        prob(&blk).normalize
+    end
+
+    def pick(&blk)
+        run_prob(&blk).pick
+    end
+
+    def collect(pred, tree)
+        m = Hash.new(0)
+        while (pred.call)
+            x = tree.pick
+            m[x] += 1.0
+        end
+        Distribution.new :MAP, m
+    end
+
+    def collecting(pred, &blk)
+        collect(pred, run_prob(&blk))
+    end
+
+    def loop_k(k)
+        tmp = k
+        proc {
+            r = tmp > 0
+            tmp-=1
+            r
+        }
+    end
+
+    def loop_t(s)
+        start = Time.now
+        proc {
+            (Time.now - start) < s
+        }
+    end
+
+    def dist(data)
+        shift { |k|
+            PChoice.new do
+                m = Hash.new(0)
+                data.each do |p,d|
+                    tmp = [k,d]
+                    m[tmp] += p
+                end
+
+                Distribution.new :MAP, m
+            end
+        }
+    end
+
+    def uniform(data)
+        dist(data.map {|x| [1, x]})
+    end
+
+    def flip(x, *data)
+        case data.length
+        when 0
+            dist [[x, true], [1 - x, false]]
+        when 1
+            dist [[x, data[0]], [1 - x, nil]]
+        when 2
+            dist [[x, data[0]], [1 - x, data[1]]]
+        else
+            raise 'illegal number of arguments'
+        end
+    end
+end
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: rb_probdsl
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Steffen Siering
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-23 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rb_prob
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rb_delimcc
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: steffen <dot> siering -> gmail <dot> com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/probdsl.rb
+- examples/alarm.rb
+- examples/diagnosis.rb
+- examples/montyhall.rb
+- examples/paradox.rb
+- examples/test.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/urso/rb_probdsl
+licenses: 
+- BDS3
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: do probabilistic programming in ruby
+test_files: []
+