Fix rule extraction to handle constant factors

docs/src/usage/analysis.md

@@ -393,8 +393,8 @@ median outcome temporal variability:
 ```julia
 # Find Time Series Clusters
 s_tac = ADRIA.metrics.scenario_total_cover(rs)
-num_clusters = 6
-clusters = ADRIA.analysis.cluster_scenarios(s_tac, num_clusters)
+n_clusters = 6
+clusters = ADRIA.analysis.cluster_scenarios(s_tac, n_clusters)
 
 # Target scenarios
 target_clusters = ADRIA.analysis.target_clusters(clusters, s_tac)
@@ -405,18 +405,20 @@ scenario, it is possible to use a Rule Induction algorithm (SIRUS) and plot each
 rule as a scatter graph:
 
 ```julia
-# Select only desired features
-fields_iv = ADRIA.component_params(rs, [Intervention, CriteriaWeights]).fieldname
-scenarios_iv = scens[:, fields_iv]
+# Select features of interest
+foi = ADRIA.component_params(rs, [Intervention, SeedCriteriaWeights]).fieldname
 
-# Use SIRUS algorithm to extract rules
+# Use SIRUS algorithm to extract rules.
 max_rules = 10
-rules_iv = ADRIA.analysis.cluster_rules(target_clusters, scenarios_iv, max_rules)
+rules_iv = ADRIA.analysis.cluster_rules(
+    rs, target_clusters, scens, foi, max_rules; remove_duplicates=true
+)
+
 
 # Plot scatters for each rule highlighting the area selected them
 rules_scatter_fig = ADRIA.viz.rules_scatter(
     rs,
-    scenarios_iv,
+    scens,
     target_clusters,
     rules_iv;
     fig_opts=fig_opts,

src/analysis/rule_extraction.jl

@@ -109,16 +109,18 @@ function print_rules(rules::Vector{Rule{Vector{Vector},Vector{Float64}}})::Nothi
 end
 
 """
-    cluster_rules(clusters::Vector{T}, X::DataFrame, max_rules::T; seed::Int64=123, remove_duplicates::Bool=true, kwargs...)::Vector{Rule{Vector{Vector},Vector{Float64}}} where {T<:Int64}
-    cluster_rules(clusters::Union{BitVector,Vector{Bool}}, X::DataFrame, max_rules::T; seed::Int64=123, remove_duplicates::Bool=true, kwargs...)::Vector{Rule{Vector{Vector},Vector{Float64}}} where {T<:Int64}
+    cluster_rules(result_set::ResultSet, clusters::Vector{T}, scenarios::DataFrame, factors::Vector{Symbol}, max_rules::T; seed::Int64=123, remove_duplicates::Bool=true, kwargs...)::Vector{Rule{Vector{Vector},Vector{Float64}}} where {T<:Int64}
+    cluster_rules(result_set::ResultSet, clusters::Union{BitVector,Vector{Bool}}, scenarios::DataFrame, factors::Vector{Symbol}, max_rules::T; seed::Int64=123, remove_duplicates::Bool=true, kwargs...)::Vector{Rule{Vector{Vector},Vector{Float64}}} where {T<:Int64}
 
 Use SIRUS package to extract rules from time series clusters based on some summary metric
 (default is median). More information about the keyword arguments accepeted can be found in
 MLJ's doc (https://juliaai.github.io/MLJ.jl/dev/models/StableRulesClassifier_SIRUS/).
 
 # Arguments
+- `result_set` : ResultSet.
 - `clusters` : Vector of cluster indexes for each scenario outcome.
-- `X` : Features to be used as input by SIRUS.
+- `scenarios` : Scenarios DataFrame.
+- `factors` : Vector of factors of interest.
 - `max_rules` : Maximum number of rules, to be used as input by SIRUS.
 - `seed` : Seed to be used by RGN. Defaults to 123.
 - `remove_duplicates` : If true, duplicate rules will be removed from resulting ruleset. In
@@ -139,9 +141,26 @@ A StableRules object (implemented by SIRUS).
    https://doi.org//10.1214/20-EJS1792
 """
 function cluster_rules(
-    clusters::Vector{T}, X::DataFrame, max_rules::T;
-    seed::Int64=123, remove_duplicates::Bool=true, kwargs...
+    result_set::ResultSet,
+    clusters::Vector{T},
+    scenarios::DataFrame,
+    factors::Vector{Symbol},
+    max_rules::T;
+    seed::Int64=123,
+    remove_duplicates::Bool=true,
+    kwargs...
 )::Vector{Rule{Vector{Vector},Vector{Float64}}} where {T<:Int64}
+    ms = ADRIA.model_spec(result_set)
+
+    variable_factors_filter::BitVector = .!ms[ms.fieldname .∈ [factors], :is_constant]
+    variable_factors::Vector{Symbol} = factors[variable_factors_filter]
+
+    if isempty(variable_factors)
+        throw(ArgumentError("Factors of interest cannot be constant"))
+    end
+
+    X = scenarios[:, variable_factors]
+
     # Set seed and Random Number Generator
     rng = StableRNG(seed)
 
@@ -166,11 +185,17 @@ function cluster_rules(
     end
 end
 function cluster_rules(
-    clusters::Union{BitVector,Vector{Bool}}, X::DataFrame, max_rules::T;
-    seed::Int64=123, remove_duplicates::Bool=true, kwargs...
+    result_set::ResultSet,
+    clusters::Union{BitVector,Vector{Bool}},
+    scenarios::DataFrame,
+    factors::Vector{Symbol},
+    max_rules::T;
+    seed::Int64=123,
+    remove_duplicates::Bool=true,
+    kwargs...
 )::Vector{Rule{Vector{Vector},Vector{Float64}}} where {T<:Int64}
     return cluster_rules(
-        convert.(Int64, clusters), X, max_rules;
+        result_set, convert.(Int64, clusters), scenarios, factors, max_rules;
         seed=seed, remove_duplicates=remove_duplicates, kwargs...
     )
 end

test/analysis.jl

@@ -243,23 +243,23 @@ function test_rs_w_fig(rs::ADRIA.ResultSet, scens::ADRIA.DataFrame)
         ADRIA.component_params(
             rs, [Intervention, FogCriteriaWeights, SeedCriteriaWeights]
         ).fieldname
-    scenarios_iv = scens[:, fields_iv]
 
     # Use SIRUS algorithm to extract rules
+
     max_rules = 10
     rules_iv = ADRIA.analysis.cluster_rules(
-        target_clusters, scenarios_iv, max_rules; remove_duplicates=true
+        rs, target_clusters, scens, fields_iv, max_rules; remove_duplicates=true
     )
     rules_iv_duplicates = ADRIA.analysis.cluster_rules(
-        target_clusters, scenarios_iv, max_rules; remove_duplicates=false
+        rs, target_clusters, scens, fields_iv, max_rules; remove_duplicates=false
     )
     ADRIA.analysis.print_rules(rules_iv)
     ADRIA.analysis.print_rules(rules_iv_duplicates)
 
     # Plot scatters for each rule highlighting the area selected them
     rules_scatter_fig = ADRIA.viz.rules_scatter(
         rs,
-        scenarios_iv,
+        scens,
         target_clusters,
         rules_iv;
         fig_opts=fig_opts,
@@ -268,7 +268,7 @@ function test_rs_w_fig(rs::ADRIA.ResultSet, scens::ADRIA.DataFrame)
 
     ADRIA.viz.rules_scatter(
         rs,
-        scenarios_iv,
+        scens,
         target_clusters,
         rules_iv_duplicates;
         fig_opts=fig_opts,