first commit

Author: Hiroki-Shiraishi

README.md

@@ -3,9 +3,9 @@
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13968099.svg)](https://doi.org/10.5281/zenodo.13968099)
 
 
-The jUCS implementation includes UCS <sup><a id="ref1"></a>[[1]](#1)</sup> and Fuzzy-UCS <sup><a id="ref2"></a>[[2]](#2)</sup> codified in Julia, as described in the *ACM Transactions on Evolutionary Learning and Optimization* (TELO) article:
+The jUCS implementation includes UCS <sup><a id="ref1"></a>[[1]](#1)</sup> and Fuzzy-UCS <sup><a id="ref2"></a>[[2]](#2)</sup> codified in Julia, as described in the ACM Transactions on Evolutionary Learning and Optimization (TELO) article:
 
->Hiroki Shiraishi, Hisao Ishibuchi, and Masaya Nakata. "**A Class Inference Scheme With Dempster-Shafer Theory for Learning Fuzzy-Classifier Systems**." ACM Transactions on Evolutionary Learning and Optimization (2025).
+>Hiroki Shiraishi, Hisao Ishibuchi, and Masaya Nakata. 2025. **A Class Inference Scheme With Dempster-Shafer Theory for Learning Fuzzy-Classifier Systems**. ACM Trans. Evol. Learn. Optim. Just Accepted (February 2025). https://doi.org/10.1145/3717613
 
 In this article, we propose a novel class inference scheme for Learning Fuzzy-Classifier Systems (a.k.a. evolutionary fuzzy rule-based classification systems) based on the Dempster-Shafer Theory of Evidence. Our scheme enhances the handling of uncertainty in classification by calculating belief masses for each class and an *"I don't know"* state, then combining them to infer a class. When applied to the Fuzzy-UCS classifier system, our scheme improves classification performance on 30 real-world datasets compared to conventional voting- and single-winner-based class inference schemes.
 
@@ -399,18 +399,19 @@ These codes will run experiments on the 30 datasets used in the main article and
 
 The copyright of jUCS belongs to the authors in the [Evolutionary Intelligence Research Group](http://www.nkt.ynu.ac.jp/en/) (Nakata Lab) at Yokohama National University, Japan. You are free to use this code for research purposes. In such cases, we kindly request that you cite the following article:
 
->Hiroki Shiraishi, Hisao Ishibuchi, and Masaya Nakata. "**A Class Inference Scheme With Dempster-Shafer Theory for Learning Fuzzy-Classifier Systems**." ACM Transactions on Evolutionary Learning and Optimization (2025).
+>Hiroki Shiraishi, Hisao Ishibuchi, and Masaya Nakata. 2025. **A Class Inference Scheme With Dempster-Shafer Theory for Learning Fuzzy-Classifier Systems**. ACM Trans. Evol. Learn. Optim. Just Accepted (February 2025). https://doi.org/10.1145/3717613
 
 ```bibtex
 @article{shiraishi2025class,
-  title={A Class Inference Scheme With Dempster-Shafer Theory for Learning Fuzzy-Classifier Systems},
-  author={Shiraishi, Hiroki and Ishibuchi, Hisao and Nakata, Masaya},
-  journal={ACM Transactions on Evolutionary Learning and Optimization},
-  volume={},
-  number={},
-  pages={},
-  year={2025},
-  publisher={ACM New York, NY}
+author = {Shiraishi, Hiroki and Ishibuchi, Hisao and Nakata, Masaya},
+title = {A Class Inference Scheme With Dempster-Shafer Theory for Learning Fuzzy-Classifier Systems},
+year = {2025},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+doi = {10.1145/3717613},
+note = {Just Accepted},
+journal = {ACM Trans. Evol. Learn. Optim.},
+month = feb
 }
 ```
 
@@ -426,13 +427,13 @@ The copyright of jUCS belongs to the authors in the [Evolutionary Intelligence R
 [3] Christopher Stone and Larry Bull. "**For real! XCS with continuous-valued inputs**." Evolutionary Computation 11.3 (2003): 299-336. https://doi.org/10.1162/106365603322365315 [[↑]](#ref3)  
 
 <a id="4"></a>
-[4] Andras Bardossy, and Lucien Duckstein. **Fuzzy rule-based modeling with applications to geophysical, biological, and engineering systems**. CRC press, 1995. https://doi.org/10.1201/9780138755133 [[↑]](#ref4)  
+[4] Andras Bardossy and Lucien Duckstein. **Fuzzy rule-based modeling with applications to geophysical, biological, and engineering systems**. CRC press, 1995. https://doi.org/10.1201/9780138755133 [[↑]](#ref4)  
 
 <a id="5"></a>
 [5] Hisao Ishibuchi, Tomoharu Nakashima, and Tadahiko Murata. "**Performance evaluation of fuzzy classifier systems for multidimensional pattern classification problems**." IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics) 29.5 (1999): 601-618. https://doi.org/10.1109/3477.790443 [[↑]](#ref5)  
 
 <a id="6"></a>
-[6] Ryan J. Urbanowicz, and Will N. Browne. **Introduction to learning classifier systems**. Springer, 2017. https://books.google.co.jp/books?id=C6QxDwAAQBAJ [[↑]](#ref6) 
+[6] Ryan J. Urbanowicz and Will N. Browne. **Introduction to learning classifier systems**. Springer, 2017. https://books.google.co.jp/books?id=C6QxDwAAQBAJ [[↑]](#ref6) 
 
 <a id="7"></a> 
 [7] Manuel Valenzuela-Rendón. "**The fuzzy classifier system: Motivations and first results**." Parallel Problem Solving from Nature: 1st Workshop, PPSN I Dortmund, FRG, October 1–3, 1990 Proceedings 1. Springer Berlin Heidelberg, 1991. https://doi.org/10.1007/BFb0029774 [[↑]](#ref7)  

environment/real_world.jl

@@ -110,7 +110,7 @@ function shuffle_train_and_test_data!(self::Environment)
 
 end
 
-function state(self::Environment)::Vector{Union{Float64, String}}
+function state(self::Environment)::Vector{Union{Float64, Int64, String}}
     if self.is_exploit == false
         # Use train data
         shuffle_index_array_and_reset_row_index!(self)
@@ -121,7 +121,7 @@ function state(self::Environment)::Vector{Union{Float64, String}}
     end
 end
 
-function answer(self::Environment, state::Vector{Union{Float64, String}})::Int64
+function answer(self::Environment, state::Vector{Union{Float64, Int64, String}})::Int64
     if self.is_exploit == false
         # Use train data
         return Int64(self.train_data[self.index_array[self.row_index], size(self.train_data, 2)])

fuzzy-ucs/fcondition.jl

@@ -13,7 +13,7 @@ function CNF(vs, s, m, l, vl)
 end
 
 "Calculate the membership value for a given input"
-function get_membership_value(self::CNF, x::Union{Float64, String})::Float64
+function get_membership_value(self::CNF, x::Union{Float64, Int64, String})::Float64
     vs, s, m, l, vl = self.vs, self.s, self.m, self.l, self.vl
 
     # If input is "?", return full membership

fuzzy-ucs/fhelper.jl

@@ -186,9 +186,9 @@ function output_full_score_for_csv(current_epoch::Int64, num_epoch::Int64, env::
 end
 
 "Get Accuracy, Precision, Recall, and F1"
-function get_scores_per_epoch(seed::Int64, fucs::FUCS, data::Array{Union{Float64, Int64, String}, 2}, changed_data::Array{Union{Float64, String}, 2}, inference::String)::Tuple{Float64, Float64, Float64, Float64}
+function get_scores_per_epoch(seed::Int64, fucs::FUCS, data::Array{Union{Float64, Int64, String}, 2}, inference::String)::Tuple{Float64, Float64, Float64, Float64}
     true_labels::Vector{Int64} = [Int64(data[row_index, size(data, 2)]) for row_index in 1:size(data, 1)]
-    predicted_labels::Vector{Int64} = [class_inference(seed, fucs, changed_data[row_index, 1:size(changed_data, 2)], inference) for row_index in 1:size(changed_data, 1)]
+    predicted_labels::Vector{Int64} = [class_inference(seed, fucs, data[row_index, 1:(size(data, 2)-1)], inference) for row_index in 1:size(data, 1)]
 
     # Determine the common levels
     all_levels = unique([true_labels; predicted_labels])
@@ -197,7 +197,7 @@ function get_scores_per_epoch(seed::Int64, fucs::FUCS, data::Array{Union{Float64
     cat_predicted_labels = categorical(predicted_labels, levels=all_levels, ordered=true)
 
     # Step 1: Calculate confusion matrix
-    cm = confusion_matrix(cat_true_labels, cat_predicted_labels)
+    cm = confusion_matrix(cat_predicted_labels, cat_true_labels)
 
     # Step 2: Calculate precision, recall, and F1 for each class
     precision_per_class = Dict{Int64, Float64}()
@@ -223,21 +223,21 @@ function get_scores_per_epoch(seed::Int64, fucs::FUCS, data::Array{Union{Float64
         f1_per_class[c] = isnan(f1) ? 0 : f1
     end
 
-    # Step 3: Calculate Macro Accuracy, Precision, Recall, and F1
-    macro_accuracy = accuracy(true_labels, predicted_labels) * 100
+    # Step 3: Calculate Accuracy, Precision, Recall, and F1
+    overall_accuracy = accuracy(true_labels, predicted_labels) * 100
     macro_precision = mean(values(precision_per_class)) * 100
     macro_recall = mean(values(recall_per_class)) * 100
     macro_f1 = mean(values(f1_per_class)) * 100
 
-    return macro_accuracy, macro_precision, macro_recall, macro_f1
+    return overall_accuracy, macro_precision, macro_recall, macro_f1
 end
 
-function get_idk_per_epoch(fucs::FUCS, data::Array{Union{Float64, Int64, String}, 2}, changed_data::Array{Union{Float64, String}, 2})::Float64
-    idk_array::Vector{Float64} = [calculate_idk(fucs, changed_data[row_index, 1:size(changed_data, 2)]) for row_index in 1:size(changed_data, 1)]
+function get_idk_per_epoch(fucs::FUCS, data::Array{Union{Float64, Int64, String}, 2})::Float64
+    idk_array::Vector{Float64} = [calculate_idk(fucs, data[row_index, 1:(size(data, 2)-1)]) for row_index in 1:size(data, 1)]
     return mean(idk_array)
 end
 
-function calculate_idk(fucs::FUCS, state::Vector{Union{Float64, String}})::Float64
+function calculate_idk(fucs::FUCS, state::Vector{Union{Float64, Int64, String}})::Float64
     match_set::Vector{FClassifier} = @views generate_match_set(fucs, state, -1, true)
     css = @views generate_conjunctive_sum_set(fucs, match_set)
     if css[end-1] != 1
@@ -305,9 +305,9 @@ function conjunctive_masses(mass_all::Vector{Float64}, mass_clas::Vector{Float64
 end
 
 # {Float64, Int64, String} -> {Float64, String}
-function change_array_type(original_array::Array{Union{Float64, Int64, String}, 2})::Array{Union{Float64, String}, 2}
+function change_array_type(original_array::Array{Union{Float64, Int64, String}, 2})::Array{Union{Float64, Int64, String}, 2}
     original_array = original_array[:, 1:end-1]
-    converted_array = Array{Union{Float64, String}, 2}(undef, size(original_array))
+    converted_array = Array{Union{Float64, Int64, String}, 2}(undef, size(original_array))
 
     for i in 1:size(original_array, 1)
         for j in 1:size(original_array, 2)
@@ -324,7 +324,7 @@ function change_array_type(original_array::Array{Union{Float64, Int64, String},
     return converted_array
 end
 
-function class_inference(seed::Int64, fucs::FUCS, state::Vector{Union{Float64, String}}, inference::String)
+function class_inference(seed::Int64, fucs::FUCS, state::Vector{Union{Float64, Int64, String}}, inference::String)
     match_set::Vector{FClassifier} = @views generate_match_set(fucs, state, -1, true)
 
     if inference == "vote"

fuzzy-ucs/fucs.jl

@@ -19,7 +19,7 @@ end
 "Main experiment loop for Fuzzy-UCS"
 function run_experiment(self::FUCS)
     # Get current state and correct answer from environment
-    curr_state::Vector{Union{Float64, String}} = state(self.env)
+    curr_state::Vector{Union{Float64, Int64, String}} = state(self.env)
     curr_answer::Int64 = answer(self.env, curr_state)
 
     # Generate match set based on current state
@@ -126,7 +126,7 @@ function set_mass(experienced_match_set::Vector{FClassifier})
 end
 
 "Generate the match set for a given state and answer"
-function generate_match_set(self::FUCS, state::Vector{Union{Float64, String}}, answer::Int64, do_exploit=false)::Vector{FClassifier}
+function generate_match_set(self::FUCS, state::Vector{Union{Float64, Int64, String}}, answer::Int64, do_exploit=false)::Vector{FClassifier}
     # Calculate matching degrees for all classifiers
     set_matching_degree(self, state)
 
@@ -152,14 +152,14 @@ function generate_match_set(self::FUCS, state::Vector{Union{Float64, String}}, a
 end
 
 "Set the matching degree for all classifiers in the population"
-function set_matching_degree(self::FUCS, state::Vector{Union{Float64, String}})
+function set_matching_degree(self::FUCS, state::Vector{Union{Float64, Int64, String}})
     @simd for clas in self.population
         clas.matching_degree = get_matching_degree(clas, state)
     end
 end
 
 "Calculate the matching degree of a classifier for a given state"
-function get_matching_degree(clas::FClassifier, state::Vector{Union{Float64, String}})::Float64
+function get_matching_degree(clas::FClassifier, state::Vector{Union{Float64, Int64, String}})::Float64
     matching_degree::Float64 = 1.0
     @simd for i in 1:length(state)
         # Multiply membership values for each attribute
@@ -192,7 +192,7 @@ function do_covering(self::FUCS, match_set::Vector{FClassifier}, answer::Int64):
 end
 
 "Generate a covering classifier for the current state and answer"
-function generate_covering_classifier(self::FUCS, state::Vector{Union{Float64, String}}, answer::Int64)::FClassifier
+function generate_covering_classifier(self::FUCS, state::Vector{Union{Float64, Int64, String}}, answer::Int64)::FClassifier
     # Create a new fuzzy classifier
     clas::FClassifier = FClassifier(self.parameters, self.env, state)
     # Set the weight for the correct action to 1

fuzzy-ucs/main.jl

@@ -5,7 +5,7 @@ using DataFrames
 using Dates
 
 function parse_commandline()
-    s = ArgParseSettings(description="Fuzzy-UCS Classifier System")
+    s = ArgParseSettings(description="The Fuzzy-UCS classifier system")
     @add_arg_table s begin
         "--num_trials"
             help = "The number of trials"
@@ -156,11 +156,11 @@ function main_csv(args; now_str=Dates.format(Dates.now(), "Y-m-d-H-M-S"))
 
             # Test Phase
             env.is_exploit = true
-            train_accuracy::Float64, train_precision::Float64, train_recall::Float64, train_f1::Float64 = get_scores_per_epoch(env.seed, fucs, env.train_data, change_array_type(env.train_data), args["inference"])
-            test_accuracy::Float64, test_precision::Float64, test_recall::Float64, test_f1::Float64 = get_scores_per_epoch(env.seed, fucs, env.test_data, change_array_type(env.test_data), args["inference"])
+            train_accuracy::Float64, train_precision::Float64, train_recall::Float64, train_f1::Float64 = get_scores_per_epoch(env.seed, fucs, env.train_data, args["inference"])
+            test_accuracy::Float64, test_precision::Float64, test_recall::Float64, test_f1::Float64 = get_scores_per_epoch(env.seed, fucs, env.test_data, args["inference"])
             if args["inference"] == "ds" && args["idk"]
-                train_idk::Float64 = get_idk_per_epoch(fucs, env.train_data, change_array_type(env.train_data))
-                test_idk::Float64 = get_idk_per_epoch(fucs, env.test_data, change_array_type(env.test_data))
+                train_idk::Float64 = get_idk_per_epoch(fucs, env.train_data)
+                test_idk::Float64 = get_idk_per_epoch(fucs, env.test_data)
                 train_idk_list[e] = train_idk
                 test_idk_list[e] = test_idk
             end

ucs/classifier.jl

@@ -41,7 +41,7 @@ function Classifier(parameters, env, state)
 end
 
 "Check if a classifier's condition matches a given state"
-function does_match(condition::Vector{UBR}, state::Vector{Union{Float64, String}})::Bool
+function does_match(condition::Vector{UBR}, state::Vector{Union{Float64, Int64, String}})::Bool
     for i in 1:length(state)
         if state[i] == "?"
             continue

ucs/helper.jl

@@ -173,9 +173,9 @@ end
 
 
 "Get Accuracy, Precision, Recall, and F1"
-function get_scores_per_epoch(seed::Int64, ucs::UCS, data::Array{Union{Float64, Int64, String}, 2}, changed_data::Array{Union{Float64, String}, 2})::Tuple{Float64, Float64, Float64, Float64}
+function get_scores_per_epoch(seed::Int64, ucs::UCS, data::Array{Union{Float64, Int64, String}, 2})::Tuple{Float64, Float64, Float64, Float64}
     true_labels::Vector{Int64} = [Int64(data[row_index, size(data, 2)]) for row_index in 1:size(data, 1)]
-    predicted_labels::Vector{Int64} = [class_inference(seed, ucs, changed_data[row_index, 1:size(changed_data, 2)]) for row_index in 1:size(changed_data, 1)]
+    predicted_labels::Vector{Int64} = [class_inference(seed, ucs, data[row_index, 1:(size(data, 2)-1)]) for row_index in 1:size(data, 1)]
 
     # Determine the common levels
     all_levels = unique([true_labels; predicted_labels])
@@ -184,7 +184,7 @@ function get_scores_per_epoch(seed::Int64, ucs::UCS, data::Array{Union{Float64,
     cat_predicted_labels = categorical(predicted_labels, levels=all_levels, ordered=true)
 
     # Step 1: Calculate confusion matrix
-    cm = confusion_matrix(cat_true_labels, cat_predicted_labels)
+    cm = confusion_matrix(cat_predicted_labels, cat_true_labels)
 
     # Step 2: Calculate precision, recall, and F1 for each class
     precision_per_class = Dict{Int64, Float64}()
@@ -210,35 +210,16 @@ function get_scores_per_epoch(seed::Int64, ucs::UCS, data::Array{Union{Float64,
         f1_per_class[c] = isnan(f1) ? 0 : f1
     end
 
-    # Step 3: Calculate Macro Accuracy, Precision, Recall, and F1
-    macro_accuracy = accuracy(true_labels, predicted_labels) * 100
+    # Step 3: Calculate Accuracy, Precision, Recall, and F1
+    overall_accuracy = accuracy(true_labels, predicted_labels) * 100
     macro_precision = mean(values(precision_per_class)) * 100
     macro_recall = mean(values(recall_per_class)) * 100
     macro_f1 = mean(values(f1_per_class)) * 100
 
-    return macro_accuracy, macro_precision, macro_recall, macro_f1
+    return overall_accuracy, macro_precision, macro_recall, macro_f1
 end
 
-function change_array_type(original_array::Array{Union{Float64, Int64, String}, 2})::Array{Union{Float64, String}, 2}
-    original_array = original_array[:, 1:end-1]
-    converted_array = Array{Union{Float64, String}, 2}(undef, size(original_array))
-
-    for i in 1:size(original_array, 1)
-        for j in 1:size(original_array, 2)
-            element = original_array[i, j]
-            if element isa Int
-                # Convert Int64 to Float64
-                converted_array[i, j] = float(element)
-            else
-                # Keep Float64 and String as they are
-                converted_array[i, j] = element
-            end
-        end
-    end
-    return converted_array
-end
-
-function class_inference(seed::Int64, ucs::UCS, state::Vector{Union{Float64, String}})::Int64
+function class_inference(seed::Int64, ucs::UCS, state::Vector{Union{Float64, Int64, String}})::Int64
     match_set::Vector{Classifier} = @views generate_match_set(ucs, state, -1, true)
     fitness_sum_array::Vector{Float64} = @views generate_fitness_sum_array(ucs, match_set)
     action::Int64 = random_max_index(seed, fitness_sum_array) - 1

ucs/main.jl

@@ -1,7 +1,7 @@
 using ArgParse, Random, CSV, DataFrames, Dates
 
 function parse_commandline()
-    s = ArgParseSettings(description="UCS Classifier System")
+    s = ArgParseSettings(description="The UCS classifier system")
     @add_arg_table s begin
         "--num_trials"
             help = "The number of trials"
@@ -150,8 +150,8 @@ function main_csv(args; now_str=Dates.format(Dates.now(), "Y-m-d-H-M-S"))
 
             # Test Phase
             env.is_exploit = true
-            train_accuracy::Float64, train_precision::Float64, train_recall::Float64, train_f1::Float64 = get_scores_per_epoch(env.seed, ucs, env.train_data, change_array_type(env.train_data))
-            test_accuracy::Float64, test_precision::Float64, test_recall::Float64, test_f1::Float64 = get_scores_per_epoch(env.seed, ucs, env.test_data, change_array_type(env.test_data))
+            train_accuracy::Float64, train_precision::Float64, train_recall::Float64, train_f1::Float64 = get_scores_per_epoch(env.seed, ucs, env.train_data)
+            test_accuracy::Float64, test_precision::Float64, test_recall::Float64, test_f1::Float64 = get_scores_per_epoch(env.seed, ucs, env.test_data)
             popsize::Int64 = length(ucs.population)
 
             # Output log
@@ -213,7 +213,7 @@ function main_all_csv(args)
         "wpbc",
         "yeast",
 
-        # 7 datasets used in the supplementary material
+        # 7 datasets used in the appendix
         "12carry",
         "11mop",
         "11mux",