Lumen refactoring

.cirrus.yml

@@ -1,5 +1,5 @@
 freebsd_instance:
-  image_family: freebsd-14-0
+  image_family: freebsd-14-2
 task:
   name: FreeBSD
   artifacts_cache:

Project.toml

@@ -1,7 +1,12 @@
 name = "SoleModels"
 uuid = "4249d9c7-3290-4ddd-961c-e1d3ec2467f8"
 license = "MIT"
-authors = ["Michele GHIOTTI", "Giovanni PAGLIARINI", "Edoardo PONSANESI", "Eduard I. STAN"]
+authors = [
+    "Michele GHIOTTI",
+    "Giovanni PAGLIARINI",
+    "Edoardo PONSANESI",
+    "Eduard I. STAN",
+]
 version = "0.10.0"
 
 [deps]
@@ -61,9 +66,9 @@ ProgressMeter = "1"
 Random = "1"
 Reexport = "1"
 Revise = "3"
-SoleBase = "0.13"
+SoleBase = "0.11 - 0.13"
 SoleData = "0.15, 0.16"
-SoleLogics = "0.11 - 0.12"
+SoleLogics = "0.11 - 0.13"
 StatsBase = "0.30 - 0.34"
 Suppressor = "0.2"
 Tables = "1"
@@ -89,4 +94,19 @@ SoleData = "123f1ae1-6307-4526-ab5b-aab3a92a2b8c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "DataFrames", "Random", "MLJ", "MLJXGBoostInterface", "MultiData", "Markdown", "InteractiveUtils", "BenchmarkTools", "MLJBase", "XGBoost", "DecisionTree", "MLJDecisionTreeInterface", "SoleData"]
+test = [
+    "Test",
+    "DataFrames",
+    "Random",
+    "MLJ",
+    "MLJXGBoostInterface",
+    "MultiData",
+    "Markdown",
+    "InteractiveUtils",
+    "BenchmarkTools",
+    "MLJBase",
+    "XGBoost",
+    "DecisionTree",
+    "MLJDecisionTreeInterface",
+    "SoleData",
+]

src/SoleModels.jl

@@ -93,7 +93,7 @@ export subtreeheight
 include("symbolic-utils.jl")
 
 export PlainRuleExtractor
-export extractrules, listrules, joinrules
+export modalextractrules, listrules, joinrules
 
 include("rule-extraction.jl")
 

src/evaluate.jl

@@ -323,7 +323,20 @@ function evaluaterule(
     checkmask, explanations = begin
         if compute_explanations
             # Note: This is kind of quick and dirty.
-            disjs = SoleLogics.disjuncts(SoleLogics.LeftmostDisjunctiveForm(antecedent(rule)))
+
+            #disjs = SoleLogics.disjuncts(SoleLogics.LeftmostDisjunctiveForm(antecedent(rule)))
+
+            ante = antecedent(rule)
+            if (ante isa SyntaxBranch)
+                # Radice disgiuntiva: trasformiamo in forma “disjunctive” e poi estraiamo i disgiunti
+                dnf = SoleLogics.LeftmostDisjunctiveForm(ante)
+                disjs = SoleLogics.disjuncts(dnf)
+            else
+                # Non è un OR in radice → un singolo disgiunto
+                disjs = [ante] 
+            end
+
+
             checkmatrix = hcat([check(disj, X; kwargs...) for disj in disjs]...)
             # @show checkmatrix
             checkmask = map(any, eachrow(checkmatrix))
@@ -337,11 +350,24 @@ function evaluaterule(
     end
     pos_checkmask = checkmask[classmask]
     neg_checkmask = checkmask[(!).(classmask)]
+
+    #=
+    println("pos_checkmask: ",pos_checkmask)
+    println("neg_checkmask: ",neg_checkmask)
+
+    println("lgh pos_checkmask ",length(pos_checkmask))
+    println("lgh neg_checkmask ",length(neg_checkmask))
+    =#
+
+    # Controlli per array vuoti
+    sensitivity = length(pos_checkmask) > 0 ? sum(pos_checkmask)/length(pos_checkmask) : 0.0
+    specificity = length(neg_checkmask) > 0 ? 1-(sum(neg_checkmask)/length(neg_checkmask)) : 1.0
+
     out = (;
         classmask = classmask,
         checkmask = checkmask,
-        sensitivity = sum(pos_checkmask)/length(pos_checkmask),
-        specificity = 1-(sum(neg_checkmask)/length(neg_checkmask)),
+        sensitivity = sensitivity,
+        specificity = specificity,
         explanations = explanations,
     )
     return out

src/rule-extraction.jl

@@ -6,7 +6,7 @@ An exact or heuristic logical method for extracting logical rule from symbolic m
 
 Refer to [SolePostHoc](https://github.com/aclai-lab/SolePostHoc.jl) for rule extraction methods.
 
-See also [`extractrules`](@ref), [`Rule`](@ref)], [`issymbolicmodel`](@ref).
+See also [`modalextractrules`](@ref), [`Rule`](@ref)], [`issymbolicmodel`](@ref).
 """
 abstract type RuleExtractor end
 
@@ -16,33 +16,33 @@ Return whether a rule extraction method is known to be exact (as opposed to heur
 isexact(::RuleExtractor) = false
 
 """
-    extractrules(re::RuleExtractor, m, args...; kwargs...)
+    modalextractrules(re::RuleExtractor, m, args...; kwargs...)
 
 Extract rules from symbolic model `m`, using a rule extraction method `re`.
 """
-function extractrules(re::RuleExtractor, m, args...; kwargs...)
-    return error("Please, provide method extractrules(::$(typeof(m)), args...; kwargs...).")
+function modalextractrules(re::RuleExtractor, m, args...; kwargs...)
+    return error("Please, provide method modalextractrules(::$(typeof(m)), args...; kwargs...).")
 end
 
 # Helpers
 function (RE::Type{<:RuleExtractor})(args...; kwargs...)
-    return extractrules(RE(), args...; kwargs...)
+    return modalextractrules(RE(), args...; kwargs...)
 end
 
 # Helpers
 function (re::RuleExtractor)(args...; kwargs...)
-    return extractrules(re, args...; kwargs...)
+    return modalextractrules(re, args...; kwargs...)
 end
 
 """
 Plain extraction method involves listing one rule per each possible symbolic path within the model.
-With this method, [`extractrules`](@ref) redirects to [`listrules`](@ref).
+With this method, [`modalextractrules`](@ref) redirects to [`listrules`](@ref).
 
 See also [`listrules`](@ref), [`Rule`](@ref)], [`issymbolicmodel`](@ref).
 """
 struct PlainRuleExtractor <: RuleExtractor end
 isexact(::PlainRuleExtractor) = true
-function extractrules(::PlainRuleExtractor, m, args...; kwargs...)
+function modalextractrules(::PlainRuleExtractor, m, args...; kwargs...)
     if haslistrules(m)
         listrules(m, args...; kwargs...)
     else

src/utils/models/ensembles.jl

@@ -95,7 +95,6 @@ struct DecisionEnsemble{O,T<:AbstractModel,A<:Base.Callable,W<:Union{Nothing,Abs
         O = Union{outcometype.(models)...}
         DecisionEnsemble{O}(models, args...; kwargs...)
     end
-
 end
 
 
@@ -105,6 +104,8 @@ modelstype(m::DecisionEnsemble{O,T}) where {O,T} = T
 models(m::DecisionEnsemble) = m.models
 nmodels(m::DecisionEnsemble) = length(models(m))
 
+iscomplete(m::DecisionEnsemble) = any(iscomplete.(models(m)))
+
 aggregation(m::DecisionEnsemble) = m.aggregation
 weights(m::DecisionEnsemble) = m.weights
 # Returns the aggregation function, patched by weights if the model has them.

src/utils/models/other.jl

@@ -361,7 +361,7 @@ iscomplete(m::DecisionSet) = m.iscomplete
 isnonoverlapping(m::DecisionSet) = m.isnonoverlapping
 
 function listrules(m::DecisionSet)
-    isnonoverlapping || error("Cannot listrules from non-overlapping decision set. Try `extractrules` with heuristics, instead.")
+    isnonoverlapping || error("Cannot listrules from non-overlapping decision set. Try `modalextractrules` with heuristics, instead.")
     rules(m)
 end
 

test/misc.jl

@@ -11,7 +11,6 @@ using SoleModels: listrules, displaymodel, submodels
 
 io = IOBuffer()
 
-# parse_other_kind_of_formula = SoleLogics.parsebaseformula
 parse_other_kind_of_formula = SoleLogics.parseformula
 
 ################################### LeafModel #############################################

test/runtests.jl

@@ -15,7 +15,7 @@ end
 println("Julia version: ", VERSION)
 
 test_suites = [
-    ("Models", ["base.jl", ]),
+    ("Models", ["base.jl", "test_tree.jl"]),
     ("Miscellaneous", ["misc.jl", ]),
     ("Parse", ["parse.jl", ]),
     ("Rules", ["juliacon2024.jl", ]),

test/test_tree.jl

@@ -0,0 +1,30 @@
+################################################
+        #              p
+        #      ┌───────┴─────────────┐
+        #      │                     r
+        #      q                 ┌───┴───┐
+        #      │                 s      "yes"
+        #  ┌───┴───┐         ┌───┴───┐
+        # "yes"   "no"      "yes"   "no"
+##################################################
+
+using SoleLogics
+using SoleModels
+
+formula_p = SoleLogics.parseformula("p")
+formula_q = SoleLogics.parseformula("q")
+formula_r = SoleLogics.parseformula("r")
+formula_s = SoleLogics.parseformula("s")
+
+branch_q = Branch(formula_q,("yes","no"),(;))
+branch_s = Branch(formula_s,("yes","no"),(;))
+branch_r = Branch(formula_r,(branch_s,"yes"),(;))
+
+#dt_q = DecisionTree(branch_r,(;))
+
+
+#Possibile path
+path_all = [formula_p,formula_q,formula_s,formula_r,"yes"]
+path_2 = [formula_p,formula_q,"yes"]
+path_1 = [formula_p,"yes"]
+path_0 = ["yes"]