fuzzy_associative_memory 1.1.1 → 1.2.0

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog for fuzzy-associative-memory
 
+## 1.2, 23 August 2013
+* RuleSet::calculate() gets a refactor / efficiency rewrite
+* Argument sanity-checking
+* Improvements to Gnuplot visualization (logarithmic axis, return filename to caller)
+
 ## 1.1, 26 July 2013
 * Fuzzy Linguistic Variables are hard to visualize, especially when they get complex. To remedy that, you can now instruct an FLV to shell out to your installed Gnuplot and plot itself. The images are saved in your system's tmpdir.
 

data/bin/hvac_system_example.rb

@@ -32,7 +32,7 @@ hot        = FuzzyAssociativeMemory::Trapezoid.new(80, 90, 90, 90) # 20 deg wide
 
 temperature_in.sets = [cold, cool, just_right, warm, hot]
 # Comment out if you don't have Gnuplot installed:
-temperature_in.gnuplot
+temperature_in.gnuplot({:logarithmic_x=>false})
 
 # The output side -- the consequent -- expressed as a number of fuzzy sets,
 # with each set representing a natural-language description. The 'resultant
@@ -47,7 +47,7 @@ blast  = FuzzyAssociativeMemory::Triangle.new(70, 100, 130) # 60 CFM wide
 
 fan_speed.sets = [stop, slow, medium, fast, blast]
 # Comment out if you don't have Gnuplot installed:
-fan_speed.gnuplot
+fan_speed.gnuplot({:logarithmic_x=>false})
 
 # Natural-language marriage of the inputs to the outputs, e.g.
 # "If the temperature is cool, the fan motor speed should be slow."

data/lib/fuzzy_associative_memory/linguistic_variable.rb

@@ -21,9 +21,19 @@ class FuzzyAssociativeMemory::LinguisticVariable
     @sets << set
   end
 
-  def gnuplot
+  # Shell out to your system's installed Gnuplot binary to create a graphical depiction
+  # of this FLV.
+  #
+  # * *Args*    :
+  #   - +options+ -> a hash of options; see below
+  #
+  def gnuplot(options = {})
     return if @sets.empty?
 
+    opts = {
+      :logarithmic_x => false # Default to non-log X axis
+    }.merge(options)
+
     datafile = Tempfile.new('fam_')
     begin
       @sets.each_with_index do |s, i|
@@ -55,21 +65,26 @@ class FuzzyAssociativeMemory::LinguisticVariable
 
       # set term dumb
       commands = %Q(
-        set terminal svg
-        set autoscale
+        set terminal svg size 1024,400
         set xlabel 'value'
         set ylabel 'membership'
-        set xtic auto
-        set ytic auto
+        set xtics autofreq
+        set ytics autofreq
         set output "#{fn}"
         set title "Fuzzy sets for #{name}"
         set mytics 4
         set mxtics 4
-        set size ratio 0.35
-        set grid x y
-        set xr [#{min}:#{max}]
+        set size ratio 0.25
+        set grid mxtics xtics ytics
+
       )
 
+      if opts[:logarithmic_x]
+        commands += "set xr [[#{[min, 1].max}:#{max}]\nset logscale x\n"
+      else
+        commands += "set xr [#{min}:#{max}]\n"
+      end
+
       #         plot "#{datafile.path}" using 2:3 notitle with linespoints lw 2
 
       plotarr=[]
@@ -92,6 +107,7 @@ class FuzzyAssociativeMemory::LinguisticVariable
       datafile.unlink
     end
 
+    return fn if defined?(fn)
   end
 
   def [](n)

data/lib/fuzzy_associative_memory/rule.rb

@@ -15,7 +15,7 @@ class FuzzyAssociativeMemory::Rule
   #
   # * *Args*    :
   #   - +antecedent_array+ -> an array of one or more input fuzzy sets
-  #   - +boolean+ -> term to join the antecedents, may be: nil, 'AND', 'OR'
+  #   - +boolean+ -> term to join the antecedents, may be: nil, :and, :or
   #   - +consequent+ -> the output fuzzy set
   #   - +natural_language+ -> a rule description (your own words), useful in output
   #
@@ -28,9 +28,9 @@ class FuzzyAssociativeMemory::Rule
     raise ArgumentError, "Consequent must be provided" unless consequent
 
     if antecedent_array.size > 1
-      raise ArgumentError, "boolean must be sym :and or :or" unless [:and, :or].include? boolean
+      raise ArgumentError, "boolean must be sym :and or :or for multi-element antecedent arrays" unless [:and, :or].include? boolean
     else
-      raise ArgumentError, "boolean must be nil" unless boolean.nil?
+      raise ArgumentError, "boolean must be nil for single-element antecedent arrays" unless boolean.nil?
     end
 
     @natural_language = natural_language
@@ -48,8 +48,12 @@ class FuzzyAssociativeMemory::Rule
   #   - the degree of fit for this rule
   #
   def fire(value_array)
-    mus = Array.new
+    raise ArgumentError, "value array passed to Rule::fire() cannot be nil" if value_array.nil?
+    raise ArgumentError, "value array must be an collection of inputs but is a #{value_array.class}" unless value_array.is_a? Enumerable
+    raise ArgumentError, "value array passed to Rule::fire() cannot be empty" if value_array.empty?
 
+    mus = Array.new
+    # puts value_array.join(", ")
     @antecedents.each_with_index do |antecedent, index|
       mus[index] = antecedent.mu(value_array[index])
     end

data/lib/fuzzy_associative_memory/ruleset.rb

@@ -25,7 +25,6 @@ class FuzzyAssociativeMemory::Ruleset
 
   def calculate(*input_values)
     @consequent_mus   = {}
-    @kept_consequents = {}
     @consequents      = []
 
     puts ">>> Firing all rules..." if $verbosity
@@ -35,26 +34,25 @@ class FuzzyAssociativeMemory::Ruleset
       # have been fired more than once and we'll need that knowledge in a
       # moment...
       cons, mu = rule.fire(input_values)
+
+      # Since any given consequent may have been activated more than once, we
+      # need to get just a single µ value out -- we only care about the 'best'
+      # µ. A popular way of doing so is to OR the values together, i.e. keep the
+      # maximum µ value and discard the others.
       if @consequent_mus.has_key?(cons)
-        @consequent_mus[cons] << mu
+        if mu > @consequent_mus[cons]
+          @consequent_mus[cons] = mu
+        end
       else
-        @consequent_mus[cons] = [mu]
+        @consequent_mus[cons] = mu
       end
     end
 
-    # Since any given consequent may have been activated more than once, we
-    # need to get just a single µ value out -- we only care about the 'best'
-    # µ. A popular way of doing so is to OR the values together, i.e. keep the
-    # maximum µ value and discard the others.
-    @consequent_mus.each do |cons, mu_array|
-      @kept_consequents[cons] = mu_array.max
-    end
-
     # Using each µ value, alter the consequent fuzzy set's polgyon. This is
     # called implication, and 'weights' the consequents properly. There are
     # several common ways of doing it, such as Larsen (scaling) and Mamdani
     # (clipping).
-    @kept_consequents.each do |cons, mu|
+    @consequent_mus.each do |cons, mu|
       case @implication
       when :mamdani
         @consequents << cons.mamdani(mu)
@@ -72,8 +70,18 @@ class FuzzyAssociativeMemory::Ruleset
     # of Maxima" summation mechanism. MaxAv is defined as:
     # (∑ representative value * height) / (∑ height) for all output sets
     # where 'representative value' is shape-dependent.
-    numerator_terms   = @consequents.map { |set| set.centroid_x * set.height }
-    denominator_terms = @consequents.map { |set| set.height }
-    numerator_terms.inject{|sum,x| sum + x } / denominator_terms.inject{|sum,x| sum + x }
+    numerator=0
+    denominator=0
+
+    @consequents.each do |cons|
+      numerator += cons.centroid_x * cons.height
+      denominator += cons.height
+    end
+
+    return numerator/denominator
+
+    # numerator_terms   = @consequents.map { |set| set.centroid_x * set.height }
+    # denominator_terms = @consequents.map { |set| set.height }
+    # numerator_terms.inject{|sum,x| sum + x } / denominator_terms.inject{|sum,x| sum + x }
   end
 end

data/lib/fuzzy_associative_memory/set.rb

@@ -31,4 +31,8 @@ class FuzzyAssociativeMemory::FuzzySet
     raise "Subclass must define!"
   end
 
+  def mamdani(ratio)
+    raise "Subclass must define!"
+  end
+
 end

data/lib/fuzzy_associative_memory/trapezoid.rb

@@ -22,6 +22,7 @@ class FuzzyAssociativeMemory::Trapezoid < FuzzyAssociativeMemory::FuzzySet
   end
 
   def mu(value)
+    raise ArgumentError, "value passed to Trapezoid::mu() cannot be nil" if value.nil?
     if value < @left || value > @right
       0.0
     elsif value >= @left && value < @top_left

data/lib/fuzzy_associative_memory/triangle.rb

@@ -21,6 +21,7 @@ class FuzzyAssociativeMemory::Triangle < FuzzyAssociativeMemory::FuzzySet
   end
 
   def mu(value)
+    raise ArgumentError, "value passed to Triangle::mu() cannot be nil" if value.nil?
     if value < @left || value > @right
       0.0
     else

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: fuzzy_associative_memory
 version: !ruby/object:Gem::Version
+  version: 1.2.0
   prerelease:
-  version: 1.1.1
 platform: ruby
 authors:
 - Chris Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-26 00:00:00.000000000 Z
+date: 2013-08-23 00:00:00.000000000 Z
 dependencies: []
 description: |2
       A Fuzzy Associative Memory (FAM for short) is a Fuzzy Logic tool for decision making. Fuzzy logic FAMs have a wide range of practical applications: Control systems, such as governing a fan to keep a room at the "just right" temperature; Game AI, such as imbuing bots with human-like decision-making behavior; Prediction systems, linking causes with effects. A FAM uses Fuzzy Sets to establish a set of rules that are linguistic in nature. The linguistic rules, and the fuzzy sets they contain, are defined by a human "expert" (presumably, you). The rules therefore codify intelligence and map this knowledge from the human domain to the digital.