add support for weighted rules (#16)

* add weighted rule

* parse weighted rule in DSL

* parse weighted rules from FCL and matlab

* rename FuzzyWeightedRule to WeightedFuzzyRule

* test evaluation with weighted rules

* update changelog

Author: lucaferranti

docs/src/changelog.md

@@ -2,6 +2,10 @@
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+- ![](https://img.shields.io/badge/new%20feature-green.svg) support for weighted rules.
+
 ## v0.1.1 -- 2023-02-25
 
 [view release on GitHub](https://github.com/lucaferranti/FuzzyLogic.jl/releases/tag/v0.1.1)

src/InferenceSystem.jl

@@ -56,16 +56,16 @@ fis(service=1, food=2)
 Base.@kwdef struct MamdaniFuzzySystem{And <: AbstractAnd, Or <: AbstractOr,
                                       Impl <: AbstractImplication,
                                       Aggr <: AbstractAggregator,
-                                      Defuzz <: AbstractDefuzzifier} <:
-                   AbstractFuzzySystem
+                                      Defuzz <: AbstractDefuzzifier,
+                                      R <: AbstractRule} <: AbstractFuzzySystem
     "name of the system."
     name::Symbol
     "input variables and corresponding domain."
     inputs::Dictionary{Symbol, Variable} = Dictionary{Symbol, Variable}()
     "output variables and corresponding domain."
     outputs::Dictionary{Symbol, Variable} = Dictionary{Symbol, Variable}()
     "inference rules."
-    rules::Vector{FuzzyRule} = FuzzyRule[]
+    rules::Vector{R} = FuzzyRule[]
     "method used to compute conjuction in rules, default [`MinAnd`](@ref)."
     and::And = MinAnd()
     "method used to compute disjunction in rules, default [`MaxOr`](@ref)."
@@ -134,16 +134,16 @@ The inputs should be given as keyword arguments.
 
 $(TYPEDFIELDS)
 """
-Base.@kwdef struct SugenoFuzzySystem{And <: AbstractAnd, Or <: AbstractOr} <:
-                   AbstractFuzzySystem
+Base.@kwdef struct SugenoFuzzySystem{And <: AbstractAnd, Or <: AbstractOr,
+                                     R <: AbstractRule} <: AbstractFuzzySystem
     "name of the system."
     name::Symbol
     "input variables and corresponding domain."
     inputs::Dictionary{Symbol, Variable} = Dictionary{Symbol, Variable}()
     "output variables and corresponding domain."
     outputs::Dictionary{Symbol, Variable} = Dictionary{Symbol, Variable}()
     "inference rules."
-    rules::Vector{FuzzyRule} = FuzzyRule[]
+    rules::Vector{R} = FuzzyRule[]
     "method used to compute conjuction in rules, default [`MinAnd`](@ref)."
     and::And = ProdAnd()
     "method used to compute disjunction in rules, default [`MaxOr`](@ref)."

src/evaluation.jl

@@ -38,7 +38,7 @@ function (fis::MamdaniFuzzySystem)(inputs::T) where {T <: NamedTuple}
             var = fis.outputs[con.subj]
             l, h = low(var.domain), high(var.domain)
             mf = map(var.mfs[con.prop], LinRange(l, h, Npoints))
-            ruleres = broadcast(implication(fis), w, mf)
+            ruleres = scale(broadcast(implication(fis), w, mf), rule)
             res[con.subj] = broadcast(fis.aggregator, res[con.subj], ruleres)
         end
     end
@@ -56,7 +56,7 @@ function (fis::SugenoFuzzySystem)(inputs::T) where {T <: NamedTuple}
                                 zeros(float(eltype(T)), length(fis.outputs)))
     weights_sum = zero(S)
     for rule in fis.rules
-        w = rule.antecedent(fis, inputs)::S
+        w = scale(rule.antecedent(fis, inputs), rule)::S
         weights_sum += w
         for con in rule.consequent
             res[con.subj] += w * memberships(fis.outputs[con.subj])[con.prop](inputs)

src/parser.jl

@@ -192,7 +192,7 @@ end
 
 function parse_body(body, argsin, argsout, type)
     opts = Expr[]
-    rules = :(FuzzyRule[])
+    rules = Expr(:vect)
     inputs = :(dictionary([]))
     outputs = :(dictionary([]))
     for line in body.args
@@ -212,6 +212,10 @@ function parse_body(body, argsin, argsout, type)
             var in SETTINGS[type] ||
                 throw(ArgumentError("Invalid keyword $var in line $line"))
             push!(opts, Expr(:kw, var, value isa Symbol ? :($value()) : value))
+        elseif @capture(line, ant_-->(cons__,) * w_Number)
+            push!(rules.args, parse_rule(ant, cons, w))
+        elseif @capture(line, ant_-->p_ == q_ * w_Number)
+            push!(rules.args, parse_rule(ant, [:($p == $q)], w))
         elseif @capture(line, ant_-->(cons__,) | cons__)
             push!(rules.args, parse_rule(ant, cons))
         else
@@ -225,6 +229,10 @@ end
 # RULES PARSING #
 #################
 
+function parse_rule(ant, cons, w)
+    Expr(:call, :WeightedFuzzyRule, parse_antecedent(ant), parse_consequents(cons), w)
+end
+
 function parse_rule(ant, cons)
     Expr(:call, :FuzzyRule, parse_antecedent(ant), parse_consequents(cons))
 end

src/parsers/fcl.jl

@@ -23,6 +23,14 @@ function fcl_julia(s::AbstractString)
     haskey(FCL_JULIA, s) ? FCL_JULIA[s] : throw(ArgumentError("Option $s not supported."))
 end
 
+function parse_rule(x)
+    if isempty(x[5])
+        FuzzyLogic.FuzzyRule(x[2], x[4])
+    else
+        FuzzyLogic.WeightedFuzzyRule(x[2], x[4], x[5][1][2])
+    end
+end
+
 @rule id = r"[a-zA-Z_]+[a-zA-z0-9_]*"p |> Symbol
 @rule function_block = r"FUNCTION_BLOCK"p & id & var_input_block & var_output_block &
                        fuzzify_block[1:end] & defuzzify_block[1:end] & rule_block &
@@ -59,7 +67,7 @@ end
 
 @rule rule_block = r"RULEBLOCK"p & id & operator_definition & activation_method[:?] &
                    rule[1:end] & r"END_RULEBLOCK"p |>
-                   x -> (x[3], x[4], Vector{FuzzyLogic.FuzzyRule}(x[5]))
+                   x -> (x[3], x[4], identity.(x[5]))
 
 @rule or_definition = r"OR"p & r":"p & (r"MAX"p, r"ASUM"p, r"BSUM"p) & r";"p
 @rule and_definition = r"AND"p & r":"p & (r"MIN"p, r"PROD"p, r"BDIF"p) & r";"p
@@ -68,8 +76,9 @@ end
 @rule activation_method = r"ACT"p & r":"p & (r"MIN"p, r"PROD"p) & r";"p |>
                           x -> fcl_julia(join([x[1], x[3]]))
 
-@rule rule = r"RULE\s+\d+\s*:\s*IF"p & condition & r"THEN"p & conclusion & r";"p |>
-             x -> FuzzyLogic.FuzzyRule(x[2], x[4])
+@rule rule = r"RULE\s+\d+\s*:\s*IF"p & condition & r"THEN"p & conclusion &
+             (r"WITH"p & numeral)[:?] & r";"p |> parse_rule
+
 @rule relation = negrel, posrel
 @rule posrel = id & r"IS"p & id |> x -> FuzzyLogic.FuzzyRelation(x[1], x[3])
 @rule negrel = (id & r"IS\s+NOT"p & id |> x -> FuzzyLogic.FuzzyNegation(x[1], x[3])),
@@ -97,7 +106,6 @@ Parse a fuzzy inference system from a string representation in Fuzzy Control Lan
 
 The parsers can read FCL comformant to IEC 1131-7, with the following remarks:
 
-- Weighted rules are not supported.
 - Sugeno (system with singleton outputs) shall use COGS as defuzzifier.
 - the `RANGE` keyword is required for both fuzzification and defuzzification blocks.
 - Only the required `MAX` accumulator is supported.

src/parsers/matlab_fis.jl

@@ -3,7 +3,7 @@ module MatlabParser
 using Dictionaries
 using ..FuzzyLogic
 using ..FuzzyLogic: FuzzyAnd, FuzzyOr, FuzzyRule, FuzzyRelation, FuzzyNegation, Domain,
-                    Variable, memberships, AbstractMembershipFunction
+                    WeightedFuzzyRule, Variable, memberships, AbstractMembershipFunction
 
 export parse_matlabfis, @matlabfis_str
 
@@ -58,10 +58,12 @@ function parse_var(var; inputs = nothing)
 end
 
 function parse_rule(line, inputnames, outputnames, inputmfs, outputmfs)
-    ants, cons, op = split(line, r"[,:] ")
+    ants, consw, op = split(line, r"[,:] ")
+    consw = split(consw)
+    considx = parse.(Int, consw[1:length(outputnames)])
+    w = parse(Float64, consw[end][2:(end - 1)])
     antsidx = filter!(!iszero, parse.(Int, split(ants)))
-    considx = filter!(!iszero, parse.(Int, split(cons)[1:length(outputnames)]))
-    # TODO: weighted rules
+    filter!(!iszero, considx)
     op = op == "1" ? FuzzyAnd : FuzzyOr
     length(antsidx) == 1 && (op = identity)
     ant = mapreduce(op, enumerate(antsidx)) do (var, mf)
@@ -74,16 +76,20 @@ function parse_rule(line, inputnames, outputnames, inputmfs, outputmfs)
     con = map(enumerate(considx)) do (var, mf)
         FuzzyRelation(outputnames[var], outputmfs[var][mf])
     end
-    FuzzyRule(ant, con)
+    if isone(w)
+        FuzzyRule(ant, con)
+    else
+        WeightedFuzzyRule(ant, con, w)
+    end
 end
 
 function parse_rules(lines, inputs, outputs)
     inputnames = collect(keys(inputs))
     outputnames = collect(keys(outputs))
     inputmfs = collect.(keys.(memberships.(collect(inputs))))
     outputmfs = collect.(keys.(memberships.(collect(outputs))))
-    FuzzyRule[parse_rule(line, inputnames, outputnames, inputmfs, outputmfs)
-              for line in lines]
+    identity.([parse_rule(line, inputnames, outputnames, inputmfs, outputmfs)
+               for line in lines])
 end
 
 """

src/rules.jl

@@ -48,17 +48,39 @@ struct FuzzyOr{T <: AbstractFuzzyProposition, S <: AbstractFuzzyProposition} <:
 end
 Base.show(io::IO, fo::FuzzyOr) = print(io, '(', fo.left, " ∨ ", fo.right, ')')
 
+abstract type AbstractRule end
+
 """
 Describes a fuzzy implication rule IF antecedent THEN consequent.
 """
-struct FuzzyRule{T <: AbstractFuzzyProposition}
+struct FuzzyRule{T <: AbstractFuzzyProposition} <: AbstractRule
     "premise of the inference rule."
     antecedent::T
-    "consequences of the premise rule."
+    "consequences of the inference rule."
     consequent::Vector{FuzzyRelation}
 end
 Base.show(io::IO, r::FuzzyRule) = print(io, r.antecedent, " --> ", r.consequent...)
 
+"""
+Weighted fuzzy rule. In Mamdani systems, the result of implication is scaled by the weight.
+In Sugeno systems, the result of the antecedent is scaled by the weight.
+"""
+struct WeightedFuzzyRule{T <: AbstractFuzzyProposition, S <: Real} <: AbstractRule
+    "premise of the inference rule."
+    antecedent::T
+    "consequences of the inference rule."
+    consequent::Vector{FuzzyRelation}
+    "weight of the rule."
+    weight::S
+end
+
+function Base.show(io::IO, r::WeightedFuzzyRule)
+    print(io, r.antecedent, " --> ", r.consequent..., " (", r.weight, ")")
+end
+
+@inline scale(w, ::FuzzyRule) = w
+@inline scale(w, r::WeightedFuzzyRule) = w * r.weight
+
 # comparisons (for testing)
 
 Base.:(==)(r1::FuzzyRelation, r2::FuzzyRelation) = r1.subj == r2.subj && r1.prop == r2.prop
@@ -73,6 +95,11 @@ function Base.:(==)(r1::FuzzyRule, r2::FuzzyRule)
     r1.antecedent == r2.antecedent && r1.consequent == r1.consequent
 end
 
+function Base.:(==)(r1::WeightedFuzzyRule, r2::WeightedFuzzyRule)
+    r1.antecedent == r2.antecedent && r1.consequent == r1.consequent &&
+        r1.weight == r2.weight
+end
+
 # utilities
 leaves(fr::Union{FuzzyNegation, FuzzyRelation}) = (fr,)
 leaves(fp::AbstractFuzzyProposition) = [leaves(fp.left)..., leaves(fp.right)...]

test/test_evaluation.jl

@@ -31,6 +31,35 @@ using FuzzyLogic, Test
     @test fis(service = 3, food = 5)[:tip]≈12.21 atol=1e-2
     @test fis(service = 2, food = 7)[:tip]≈7.79 atol=1e-2
     @test fis(service = 3, food = 1)[:tip]≈8.95 atol=1e-2
+
+    # with weighted rule
+    fis = @mamfis function tipper(service, food)::tip
+        service := begin
+            domain = 0:10
+            poor = GaussianMF(0.0, 1.5)
+            good = GaussianMF(5.0, 1.5)
+            excellent = GaussianMF(10.0, 1.5)
+        end
+
+        food := begin
+            domain = 0:10
+            rancid = TrapezoidalMF(-2, 0, 1, 3)
+            delicious = TrapezoidalMF(7, 9, 10, 12)
+        end
+
+        tip := begin
+            domain = 0:30
+            cheap = TriangularMF(0, 5, 10)
+            average = TriangularMF(10, 15, 20)
+            generous = TriangularMF(20, 25, 30)
+        end
+
+        service == poor || food == rancid --> tip == cheap * 0.5
+        service == good --> tip == average
+        service == excellent || food == delicious --> tip == generous
+    end
+
+    @test fis(service = 2, food = 7)[:tip]≈9.36 atol=1e-2
 end
 
 @testset "test Sugeno evaluation" begin
@@ -55,11 +84,11 @@ end
             generous = 24.998
         end
 
-        service == poor || food == rancid --> tip == cheap
+        service == poor || food == rancid --> tip == cheap * 0.5
         service == good --> tip == average
         service == excellent || food == delicious --> tip == generous
     end
-    @test fis(service = 2, food = 3)[:tip]≈7.478 atol=1e-3
+    @test fis(service = 2, food = 3)[:tip]≈8.97 atol=5e-3
 
     fis2 = @sugfis function tipper(service, food)::tip
         service := begin

test/test_parser.jl

@@ -1,5 +1,6 @@
 using Dictionaries, FuzzyLogic, Test
-using FuzzyLogic: FuzzyRelation, FuzzyAnd, FuzzyOr, FuzzyRule, Domain, Variable
+using FuzzyLogic: FuzzyRelation, FuzzyAnd, FuzzyOr, FuzzyRule, WeightedFuzzyRule, Domain,
+                  Variable
 
 # TODO: write more low level tests
 
@@ -29,9 +30,10 @@ using FuzzyLogic: FuzzyRelation, FuzzyAnd, FuzzyOr, FuzzyRule, Domain, Variable
         or = ProbSumOr
         implication = ProdImplication
 
-        service == poor && food == rancid --> tip == cheap
-        service == good --> tip == average
+        service == poor && food == rancid --> tip == cheap * 0.2
+        service == good --> (tip == average, tip == average) * 0.3
         service == excellent || food == delicious --> tip == generous
+        service == excellent || food == delicious --> (tip == generous, tip == generous)
 
         aggregator = ProbSumAggregator
         defuzzifier = BisectorDefuzzifier
@@ -64,12 +66,18 @@ using FuzzyLogic: FuzzyRelation, FuzzyAnd, FuzzyOr, FuzzyRule, Domain, Variable
 
     @test fis.rules ==
           [
-        FuzzyRule(FuzzyAnd(FuzzyRelation(:service, :poor), FuzzyRelation(:food, :rancid)),
-                  [FuzzyRelation(:tip, :cheap)]),
-        FuzzyRule(FuzzyRelation(:service, :good), [FuzzyRelation(:tip, :average)]),
+        WeightedFuzzyRule(FuzzyAnd(FuzzyRelation(:service, :poor),
+                                   FuzzyRelation(:food, :rancid)),
+                          [FuzzyRelation(:tip, :cheap)], 0.2),
+        WeightedFuzzyRule(FuzzyRelation(:service, :good),
+                          [FuzzyRelation(:tip, :average), FuzzyRelation(:tip, :average)],
+                          0.3),
         FuzzyRule(FuzzyOr(FuzzyRelation(:service, :excellent),
                           FuzzyRelation(:food, :delicious)),
                   [FuzzyRelation(:tip, :generous)]),
+        FuzzyRule(FuzzyOr(FuzzyRelation(:service, :excellent),
+                          FuzzyRelation(:food, :delicious)),
+                  [FuzzyRelation(:tip, :generous), FuzzyRelation(:tip, :generous)]),
     ]
 end
 

test/test_parsers/test_fcl.jl

@@ -1,6 +1,6 @@
 using Dictionaries, FuzzyLogic, PEG, Test
 using FuzzyLogic: Variable, Domain, FuzzyRelation, FuzzyAnd, FuzzyOr, FuzzyNegation,
-                  FuzzyRule
+                  FuzzyRule, WeightedFuzzyRule
 
 @testset "parse propositions" begin
     s = [
@@ -144,7 +144,7 @@ end
     RULEBLOCK rules
       OR: ASUM;
       ACT: PROD;
-      RULE 1: IF Ix IS zero AND Iy IS zero THEN Iout IS white;
+      RULE 1: IF Ix IS zero AND Iy IS zero THEN Iout IS white WITH 0.5;
       RULE 2: IF Ix IS NOT zero OR Iy IS NOT zero THEN Iout IS black;
     END_RULEBLOCK
 
@@ -167,8 +167,8 @@ end
                               ]))
 
     @test fis.rules == [
-        FuzzyRule(FuzzyAnd(FuzzyRelation(:Ix, :zero), FuzzyRelation(:Iy, :zero)),
-                  [FuzzyRelation(:Iout, :white)]),
+        WeightedFuzzyRule(FuzzyAnd(FuzzyRelation(:Ix, :zero), FuzzyRelation(:Iy, :zero)),
+                          [FuzzyRelation(:Iout, :white)], 0.5),
         FuzzyRule(FuzzyOr(FuzzyNegation(:Ix, :zero), FuzzyNegation(:Iy, :zero)),
                   [FuzzyRelation(:Iout, :black)]),
     ]