mini_pgm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 371cafde1b4a0699d5150dbeee1c502abdfa4f01b1b02b3c5c1ee9921de430e8
+  data.tar.gz: 557de3515a26ed7ff51883d93927255aa5f61e1cfbb786f1054d09787639b62e
+SHA512:
+  metadata.gz: d4587b67bacb38663fbcd0ac05ad98cc5e6659eba4fb7af44f0b7ffbe01ae0bb817b756571d6b9f9c7cf5801fdc9f667b1cbc6b7a70efb1b95035f5510e78aba
+  data.tar.gz: 80a6468b078c223fd16092947501517114969980d0fc1af38499c0f39920984d451ba8bef7b96ce54f000a4154e2d3dbffb8db8482c3118af400c2e6a02bb58e

data/lib/mini_pgm.rb

@@ -0,0 +1,6 @@
+require 'mini_pgm/edge'
+require 'mini_pgm/model'
+require 'mini_pgm/node'
+require 'mini_pgm/printer'
+require 'mini_pgm/tabular_cpd'
+require 'mini_pgm/variable'

data/lib/mini_pgm/edge.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MiniPGM
+  #
+  # Represents a directed edge between two nodes in a PGM
+  #
+  Edge = Struct.new(:from, :to) do
+    def to_s
+      "#{from} -> #{to}"
+    end
+  end
+end

data/lib/mini_pgm/model.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module MiniPGM
+  #
+  # Represents a Probabilistic Graphical Model (PGM)
+  #
+  class Model
+    class ModelError < StandardError; end
+
+    #
+    # Edges between individual nodes, sorted by label of the outgoing edge, e.g:
+    #
+    #   Pollution -> Cancer
+    #   Smoker -> Cancer
+    #
+    attr_reader :edges
+
+    #
+    # Lookup table of labelled nodes, each associated with a set of labels for all incoming edges, e.g:
+    #
+    #   { Pollution, Smoker } -> Cancer -> { }
+    #   { } -> Pollution -> { Cancer }
+    #   { } -> Smoker -> { Cancer }
+    #
+    attr_reader :nodes
+
+    # most recent error after calling `valid?`
+    attr_reader :error
+
+    def initialize(*edges)
+      @edges = sort_edges(edges)
+      @nodes = reduce_edges(edges)
+    end
+
+    def add_cpd(cpd)
+      node = @nodes[cpd.variable.label]
+      raise ArgumentError, "node does not exist for label #{node.label}" unless node
+
+      check_cpd_evidence!(cpd.evidence.map(&:label), node.incoming_edges)
+      node.cpd = cpd
+    end
+
+    def to_s
+      ['Edges:', edges_to_s, '', 'Nodes:', nodes_to_s, '', 'Valid:', valid?, ''].join("\n")
+    end
+
+    def validate!
+      @nodes.each_value do |node|
+        raise ModelError, "node '#{node.label}' does not have a CPD" unless node.cpd
+      end
+
+      # validate cardinality between nodes for each edge
+      @edges.each do |edge|
+        validate_cardinality!(@nodes[edge.to], @nodes[edge.from])
+      end
+    end
+
+    def valid?
+      @error = nil
+      validate!
+      true
+    rescue ModelError => e
+      @error = e
+      false
+    end
+
+    private
+
+    def check_cpd_evidence!(cpd_evidence, node_dependencies)
+      cpd_evidence.each do |evidence|
+        raise ArgumentError, "node is missing dependency for CPD evidence '#{evidence}'" \
+          unless node_dependencies.include?(evidence)
+      end
+
+      node_dependencies.each do |dependency|
+        raise ArgumentError, "CPD is missing evidence for node dependency '#{dependency}'" \
+          unless cpd_evidence.include?(dependency)
+      end
+    end
+
+    def edges_to_s
+      @edges.map(&:to_s).join("\n")
+    end
+
+    def nodes_to_s
+      @nodes.keys.sort.map { |key| @nodes[key].to_s }.join("\n")
+    end
+
+    def reduce_edges(edges)
+      edges.each_with_object({}) do |edge, reduced|
+        # create node for incoming edge
+        (reduced[edge.to] ||= MiniPGM::Node.new(edge.to)).incoming_edges.add(edge.from)
+
+        # create node for outgoing edge
+        (reduced[edge.from] ||= MiniPGM::Node.new(edge.from)).outgoing_edges.add(edge.to)
+      end
+    end
+
+    def sort_edges(edges)
+      edges.sort_by(&:from)
+    end
+
+    def validate_cardinality!(to, from)
+      expected = to.cpd.evidence.find { |ev| ev.label == from.label }.cardinality
+      actual = from.cpd.variable.cardinality
+
+      raise ModelError, "cardinality mismatch in CPDs of '#{from.label}' (#{actual}) and '#{to.label}' (#{expected})" \
+        unless expected == actual
+    end
+  end
+end

data/lib/mini_pgm/node.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module MiniPGM
+  #
+  # Represents an individual node, or random variable, in a model
+  #
+  # Example string representation for a node with two incoming edges, and no outgoing edges:
+  #
+  #   { Pollution, Smoker } -> Cancer -> { }
+  #
+  # Or for nodes with no incoming edges and only outgoing edges:
+  #
+  #   { } -> Pollution -> { Cancer }
+  #   { } -> Smoker -> { Cancer }
+  #
+  class Node
+    attr_accessor :cpd
+    attr_reader :label, :incoming_edges, :outgoing_edges
+
+    def initialize(label)
+      @label = label
+      @incoming_edges = Set.new
+      @outgoing_edges = Set.new
+    end
+
+    def to_s
+      [write_set(@incoming_edges), @label, write_set(@outgoing_edges)].join(' -> ')
+    end
+
+    def write_set(set)
+      set.empty? ? '{ }' : "{ #{set.to_a.sort.join(', ')} }"
+    end
+  end
+end

data/lib/mini_pgm/printer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MiniPGM
+  #
+  # Helper class for printing data in an easily readable ASCII format
+  #
+  # Example output:
+  #
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Smoker    | Smoker_0    | Smoker_0    | Smoker_1    | Smoker_1    |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Pollution | Pollution_0 | Pollution_1 | Pollution_0 | Pollution_1 |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Cancer_0  | 0.03        | 0.05        | 0.001       | 0.02        |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Cancer_1  | 0.97        | 0.95        | 0.999       | 0.98        |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #
+  class Printer
+    class << self
+      def print(rows)
+        # calculate column widths
+        num_columns = rows[0].length
+        column_widths = (0...num_columns).map { |col| max_width(rows, col) }
+
+        # write table
+        div = write_divider(column_widths)
+        rows.flat_map { |row| [write_row(column_widths, row), div] }
+            .unshift(div)
+            .join("\n")
+      end
+
+      private
+
+      def max_width(rows, column)
+        rows.map { |row| row[column].length }.max
+      end
+
+      def write_divider(column_widths)
+        "+-#{column_widths.map { |g| '-' * g }.join('-+-')}-+"
+      end
+
+      def write_row(column_widths, values)
+        "| #{values.map.with_index { |value, i| value.ljust(column_widths[i]) }.join(' | ')} |"
+      end
+    end
+  end
+end

data/lib/mini_pgm/tabular_cpd.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'printer'
+
+module MiniPGM
+  #
+  # Represents a tabular Conditional Probability Distribution (CPD)
+  #
+  # The CPD defines the probabilities of particular outcomes for a variable, given observations
+  # of the variables that it is dependent on (i.e. the evidence).
+  #
+  # For example, assuming the variable 'Cancer' is dependent on 'Pollution' and 'Smoker', each of
+  # which have two outcomes. Then if 'Cancer' also has two outcomes, then the string representation
+  # of the table could look like this:
+  #
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Smoker    | Smoker_0    | Smoker_0    | Smoker_1    | Smoker_1    |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Pollution | Pollution_0 | Pollution_1 | Pollution_0 | Pollution_1 |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Cancer_0  | 0.03        | 0.05        | 0.001       | 0.02        |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #   | Cancer_1  | 0.97        | 0.95        | 0.999       | 0.98        |
+  #   +-----------+-------------+-------------+-------------+-------------+
+  #
+  class TabularCPD
+    attr_reader :evidence, :variable
+
+    def initialize(variable, evidence, data)
+      expected_rows = variable.cardinality
+      raise ArgumentError, "wrong number of rows; expected #{expected_rows}" unless data.length == expected_rows
+
+      expected_cols = combinations(evidence)
+      data.each.with_index do |row, index|
+        raise ArgumentError, "wrong number of columns in row #{index}; expected #{expected_cols}" \
+          unless row.length == expected_cols
+      end
+
+      @variable = variable
+      @evidence = evidence
+      @data = data
+    end
+
+    def to_s
+      MiniPGM::Printer.print(header(@evidence) + body(@data, @variable.label))
+    end
+
+    private
+
+    def body(data, label)
+      data.map.with_index do |row, index|
+        row.map(&:to_s).unshift("#{label}_#{index}")
+      end
+    end
+
+    def combinations(variables)
+      variables.map(&:cardinality).inject(:*) || 1
+    end
+
+    def header(parents, cycles = 1)
+      head, *tail = parents
+
+      # base case
+      return [] unless head
+
+      # generate a row of data, including a label and a sequence of observations
+      repeats = combinations(tail)
+      cardinality = head.cardinality
+      label = head.label
+      row = [label] + sequence(cardinality, label, repeats) * cycles
+
+      # recurse and prepend row
+      header(tail, cycles * cardinality).unshift(row)
+    end
+
+    def sequence(cardinality, label, repeats)
+      (0...cardinality).flat_map do |index|
+        Array.new(repeats, "#{label}_#{index}")
+      end
+    end
+  end
+end

data/lib/mini_pgm/variable.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MiniPGM
+  #
+  # Represents a variable in a tabular CPD
+  #
+  Variable = Struct.new(:label, :cardinality)
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: mini_pgm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tristan Penman
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+description: A minimal Probabilistic Graphical Model library for Ruby (very experimental)
+email: tristan@tristanpenman.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mini_pgm.rb
+- lib/mini_pgm/edge.rb
+- lib/mini_pgm/model.rb
+- lib/mini_pgm/node.rb
+- lib/mini_pgm/printer.rb
+- lib/mini_pgm/tabular_cpd.rb
+- lib/mini_pgm/variable.rb
+homepage: https://github.com/tristanpenman/mini-pgm
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+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: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Minimal PGM library for Ruby
+test_files: []