Minor adjustments to listrules

Author: giopaglia

src/evaluate.jl

@@ -134,7 +134,7 @@ function readmetrics(m::Rule{L}; round_digits = nothing, class_share_map = nothi
         coverage = cons_metrics.coverage * (length(_gts_leaf)/length(_gts))
         confidence = cons_metrics.confidence
         metrics = (;
-            ninstances = length(_gts),
+            ninstances  = length(_gts),
             ncovered = length(_gts_leaf),
             coverage = _metround(coverage, round_digits),
             confidence = confidence,
@@ -149,8 +149,8 @@ function readmetrics(m::Rule{L}; round_digits = nothing, class_share_map = nothi
         metrics
     elseif haskey(info(m), :supporting_labels)
         return (; ninstances = length(info(m).supporting_labels), additional_metrics...)
-    elseif haskey(info(consequent(m)), :supporting_labels)
-        return (; ninstances = length(info(m).supporting_labels), additional_metrics...)
+    # elseif haskey(info(consequent(m)), :supporting_labels)
+    #     return (; ninstances = length(info(consequent(m)).supporting_labels), additional_metrics...)
     else
         return (;)
     end
@@ -196,7 +196,7 @@ metricstable(
     )
 
 Compute metrics for a rule with respect to a labeled dataset and returns a `NamedTuple` consisting of:
-- `support`: number of instances satisfying the antecedent of the rule divided by
+- `coverage`: number of instances satisfying the antecedent of the rule divided by
     the total number of instances;
 - `error`:
     - For classification problems: number of instances that were not classified
@@ -218,13 +218,12 @@ function rulemetrics(
     Y::AbstractVector{<:Label};
     kwargs...,
 )
-    eval_result = evaluaterule(rule, X, Y; kwargs...)
     ys = apply(rule,X)
-    checkmask = eval_result[:checkmask]
+    checkmask = checkantecedent(rule, X; kwargs...)
     n_instances = ninstances(X)
     n_satisfy = sum(checkmask)
 
-    rule_support =  n_satisfy / n_instances
+    rule_coverage =  n_satisfy / n_instances
 
     rule_error = begin
         if outcometype(consequent(rule)) <: CLabel
@@ -241,9 +240,9 @@ function rulemetrics(
 
     return (;
         checkmask    = checkmask,
-        support   = rule_support,
+        coverage   = rule_coverage,
         error     = rule_error,
-        length    = natoms(antecedent(rule)),
+        natoms    = natoms(antecedent(rule)),
     )
 end
 

src/rule-extraction.jl

@@ -71,6 +71,9 @@ function join_antecedents(assumed_formulas::Vector{<:SoleLogics.Formula})
                     push!(new_assumed_formulas, φ)
                 end
             end
+            # @show typeof.(new_assumed_formulas)
+            # @show syntaxstring.(new_assumed_formulas)
+            # @show LeftmostConjunctiveForm(new_assumed_formulas)
             LeftmostConjunctiveForm(new_assumed_formulas)
         else
             (length(assumed_formulas) == 1 ? first(assumed_formulas) : ∧(filter(!istop, assumed_formulas)...))
@@ -252,22 +255,24 @@ function _listrules(
     min_confidence::Union{Nothing,Number} = nothing,
     min_coverage::Union{Nothing,Number} = nothing,
     min_ninstances::Union{Nothing,Number} = nothing,
+    flip_atoms::Bool = true,
     kwargs...,
 ) where {O}
     use_leftmostlinearform = !isnothing(use_leftmostlinearform) ? use_leftmostlinearform : (antecedent(m) isa SoleLogics.AbstractSyntaxStructure) # TODO default to true
 
     subkwargs = (;
         use_shortforms = use_shortforms,
         use_leftmostlinearform = use_leftmostlinearform,
-        normalize = false,
+        # normalize = false, TODO?
+        normalize = normalize,
         normalize_kwargs = normalize_kwargs,
         scalar_simplification = false,
         force_syntaxtree = force_syntaxtree,
         min_confidence = min_confidence,
         min_coverage = min_coverage,
         min_ninstances = min_ninstances,
         kwargs...)
-
+    # @show normalize, normalize_kwargs
     _subrules = []
     if isnothing(min_ninstances) || (haskey(info(m), :supporting_labels) && length(info(m, :supporting_labels)) >= min_ninstances)
     # if (haskey(info(m), :supporting_labels) && length(info(m, :supporting_labels)) >= min_ninstances) &&
@@ -303,7 +308,10 @@ function _listrules(
                 if (use_shortforms && haskey(info(subrule), :shortform))
                     info(subrule)[:shortform], true
                 else
-                    (flag ? antecedent(m) : ¬antecedent(m)), false
+                    # Automatic flip.
+                    smart_neg(f) = (f isa Atom && flip_atoms && SoleLogics.hasdual(f) ? SoleLogics.dual(f) : ¬f)
+                    _antd = antecedent(m)
+                    (flag ? _antd : smart_neg(_antd)), false
                 end
             end
             antformula = force_syntaxtree ? tree(antformula) : antformula
@@ -334,9 +342,14 @@ function _listrules(
                         φ
                     end
                 end
+                # @show normalize, normalize_kwargs
                 normalize && (ant = SoleLogics.normalize(ant; normalize_kwargs...))
+                # @show 1
                 # @show ant
                 ant = _scalar_simplification(ant, scalar_simplification)
+                # @show 2
+                # @show ant
+                # readline()
                 Rule(ant, consequent(subrule), merge(info(subrule), _info))
             else
                 error("Unexpected rule type: $(typeof(subrule)).")

src/types/api.jl

@@ -19,10 +19,10 @@ This function translates a symbolic model to a symbolic model using the structur
 See also [`AbstractModel`](@ref), [`ConstantModel`](@ref), [`FunctionModel`](@ref),
 [`LeafModel`](@ref).
 """
-function solemodel(o::Any, args...; kwargs...)
+function solemodel(o::Any, FM::Type{<:AbstractModel} = AbstractModel, args...; kwargs...)
     try
-        convert(FM, wrap(o))
         # FM TODO
+        convert(FM, wrap(o))
     catch e
         if e isa MethodError
             throw(MethodError("Please, provide solemodel(::$(typeof(o)))"))

src/utils/models/other.jl

@@ -106,18 +106,24 @@ function listimmediaterules(
         ant = antecedent(rule)
         force_syntaxtree && (ant = tree(ant))
         # @show ant
-        nant = SoleLogics.NEGATION(ant)
+        # println()
+        # @show typeof(ant)
+        nant = SoleLogics.NEGATION(tree(ant))
+        # @show typeof(nant)
         # @show typeof(nant)
         normalize && (nant = SoleLogics.normalize(nant; normalize_kwargs...))
         # @show typeof(nant)
         nant = _scalar_simplification(nant, scalar_simplification)
         # @show typeof(nant)
+        # readline()
         assumed_formulas = push!(assumed_formulas, nant)
     end
     # @show eltype(assumed_formulas)
+    # @show assumed_formulas
     default_φ = join_antecedents(assumed_formulas)
     # @show default_φ
     default_φ = _scalar_simplification(default_φ, scalar_simplification)
+    # @show default_φ
     # normalize && (default_φ = SoleLogics.normalize(default_φ; normalize_kwargs...))
     push!(normalized_rules, Rule(default_φ, defaultconsequent(m), info(defaultconsequent(m))))
     normalized_rules