From 6066f3aa8d50f467b694adbd1e48f5d521714ec0 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Fri, 21 Apr 2023 23:38:07 +0300
Subject: [PATCH 01/39] Add files via upload

---
 .../Discreeting/Binarizing.java               |  23 ++
 .../Discreeting/TransferFunction.java         |   8 +
 .../Optimizers/CuckooSearchOptimizer.java     | 196 ++++++++++++++++++
 3 files changed, 227 insertions(+)
 create mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
 create mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
 create mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
new file mode 100644
index 000000000..2a2dc61a0
--- /dev/null
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
@@ -0,0 +1,23 @@
+package FS_Wrapper_Approaches.Discreeting;
+
+import static org.apache.commons.math3.special.Erf.erf;
+
+/**
+ * This interface includes a static method that is utilized to convert continuous value to binary one
+ */
+public interface Binarizing {
+    /**
+     * This method used to convert continuous values to binary ones
+     * @param TF is the type (id) of the transfer function
+     * @param Value is the continuous value to be converted
+     * @return return the converted value based on the selected function
+     */
+    static int discreteValue(TransferFunction TF, double Value) {
+        return switch (TF) {
+            case TFunction_V1 -> Math.abs(erf(Math.sqrt(Math.PI) / 2 * Value)) >= 0.5 ? 1 : 0;
+            case TFunction_V2 -> Math.abs(Math.tan(Value)) >= 0.5 ? 1 : 0;
+            case TFunction_V3 -> Math.abs(Value / Math.abs(1 + Math.pow(Value, 2))) >= 0.5 ? 1 : 0;
+            case TFunction_V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * Value)) >= 0.5 ? 1 : 0;
+        };
+    }
+}
diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
new file mode 100644
index 000000000..8207130d9
--- /dev/null
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
@@ -0,0 +1,8 @@
+package FS_Wrapper_Approaches.Discreeting;
+
+/**
+ * Enumeration that contains the types of transfer functions in which they are used to define the type of transfer function
+ */
+public enum TransferFunction {
+        TFunction_V1, TFunction_V2, TFunction_V3, TFunction_V4
+}
diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
new file mode 100644
index 000000000..6c5b883f4
--- /dev/null
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -0,0 +1,196 @@
+package FS_Wrapper_Approaches.Optimizers;
+
+import FS_Wrapper_Approaches.Discreeting.Binarizing;
+import FS_Wrapper_Approaches.Discreeting.TransferFunction;
+import com.oracle.labs.mlrg.olcut.util.Pair;
+import org.tribuo.*;
+import org.tribuo.classification.Label;
+import org.tribuo.classification.evaluation.LabelEvaluation;
+import org.tribuo.classification.evaluation.LabelEvaluator;
+import org.tribuo.common.nearest.KNNClassifierOptions;
+import org.tribuo.dataset.SelectedFeatureDataset;
+import org.tribuo.evaluation.CrossValidation;
+import org.tribuo.provenance.FeatureSelectorProvenance;
+import org.tribuo.provenance.FeatureSetProvenance;
+import org.tribuo.provenance.impl.FeatureSelectorProvenanceImpl;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.IntStream;
+
+/**
+ * Select features based on Cuckoo Search algorithm with binary transfer functions, KNN classifier and 10-fold cross validation
+ * <p>
+ * see:
+ * <pre>
+ * Xin-She Yang and Suash Deb.
+ * "Cuckoo Search via L´evy Flights", 2010.
+ *
+ * L. A. M. Pereira et al.
+ * "A Binary Cuckoo Search and its Application for Feature Selection", 2014.
+ * </pre>
+ */
+public class CuckooSearchOptimizer implements FeatureSelector<Label> {
+    private final TransferFunction transferFunction;
+    private final double stepSizeScaling;
+    private final double lambda;
+    private final double worstNestProbability;
+    private final double delta;
+    private final int populationSize;
+    private int [][] setOfSolutions;
+    private final int maxIteration;
+
+    /**
+     * The default constructor for feature selection based on Cuckoo Search Algorithm
+     */
+    public CuckooSearchOptimizer() {
+        this.transferFunction = TransferFunction.TFunction_V2;
+        this.populationSize = 50;
+        this.stepSizeScaling = 2D;
+        this.lambda = 2D;
+        this.worstNestProbability = 0.1D;
+        this.delta = 1.5D;
+        this.maxIteration = 30;
+    }
+
+    /**
+     * @param transferFunction The transfer function to convert continuous values to binary ones
+     * @param populationSize The size of the solution in the initial population
+     * @param stepSizeScaling The cuckoo step size
+     * @param lambda The lambda of the levy flight function
+     * @param worstNestProbability The fraction of the nests to be abandoned
+     * @param delta The delta that is used in the abandon nest function
+     * @param maxIteration The number of times that is used to enhance generation
+     */
+    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, int maxIteration) {
+        this.transferFunction = transferFunction;
+        this.populationSize = populationSize;
+        this.stepSizeScaling = stepSizeScaling;
+        this.lambda = lambda;
+        this.worstNestProbability = worstNestProbability;
+        this.delta = delta;
+        this.maxIteration = maxIteration;
+    }
+
+    /**
+     * @param totalNumberOfFeatures The number of features in the given dataset
+     * @return The population of subsets of selected features
+     */
+    private int[][] generatePopulation(int totalNumberOfFeatures) {
+        setOfSolutions = new int[this.populationSize][totalNumberOfFeatures];
+
+        for (int[] subSet : setOfSolutions)
+            System.arraycopy(new Random().ints(totalNumberOfFeatures, 0, 2).toArray(), 0, subSet, 0, setOfSolutions[0].length);
+
+        return setOfSolutions;
+    }
+
+    /**
+     * Does this feature selection algorithm return an ordered feature set?
+     *
+     * @return True if the set is ordered.
+     */
+    @Override
+    public boolean isOrdered() {
+        return true;
+    }
+
+    /**
+     * Selects features according to this selection algorithm from the specified dataset.
+     *
+     * @param dataset The dataset to use.
+     * @return A selected feature set.
+     */
+    @Override
+    public SelectedFeatureSet select(Dataset<Label> dataset) {
+        ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
+
+        setOfSolutions = generatePopulation(dataset.getFeatureMap().size());
+
+        List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
+
+        SelectedFeatureSet selectedFeatureSet = null;
+
+        for (int i = 0; i < maxIteration; i++) {
+            IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
+                AtomicInteger currentIter = new AtomicInteger(subSet);
+
+                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
+                int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
+
+                if (evaluateSolution(dataset, FMap, evolvedSolution) > evaluateSolution(dataset, FMap, randomCuckoo))
+                    System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
+
+                if (new Random().nextDouble() < worstNestProbability) {
+                    int r1 = new Random().nextInt(setOfSolutions.length);
+                    int r2 = new Random().nextInt(setOfSolutions.length);
+
+                    for (var j = 0; j < setOfSolutions[subSet].length; j++)
+                        evolvedSolution[j] = Binarizing.discreteValue(transferFunction, setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
+
+                    if (evaluateSolution(dataset, FMap, evolvedSolution) > evaluateSolution(dataset, FMap, setOfSolutions[subSet]))
+                        System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
+                }
+                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], evaluateSolution(dataset, FMap, setOfSolutions[subSet])));
+
+            });
+            subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
+            selectedFeatureSet = getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
+        }
+        return selectedFeatureSet;
+    }
+
+    /**
+     * This method is used to compute the fitness score of each solution of the population
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of features
+     * @return The fitness score of the given subset
+     */
+    private double evaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
+        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(dataset, Fmap, solution));
+
+        KNNClassifierOptions classifier = new KNNClassifierOptions();
+
+        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
+
+        double avgAccuracy = 0D;
+
+        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
+            avgAccuracy += ACC.getA().accuracy();
+
+        return avgAccuracy + 0.0001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()));
+    }
+
+    /**
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of featurs
+     * @return The selected feature set
+     */
+    private SelectedFeatureSet getSFS(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
+        List<String> names = new ArrayList<>();
+        List<Double> scores = new ArrayList<>();
+
+        for (int i = 0; i < solution.length; i++) {
+            if (solution[i] == 1) {
+                names.add(Fmap.get(i).getName());
+                scores.add(1D);
+            }
+        }
+
+        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(),dataset.getProvenance(),getProvenance());
+
+        return new SelectedFeatureSet(names,scores,isOrdered(),provenance);
+    }
+
+    @Override
+    public FeatureSelectorProvenance getProvenance() {
+        return new FeatureSelectorProvenanceImpl(this);
+    }
+
+    /**
+     * This record is used to hold subset of features with its corresponding fitness score
+     */
+    record FeatureSet_FScore_Container(int[] subSet, double score) { }
+}

From e729e184ccf70c038ac831e184486c3f1edfa623 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 22 Apr 2023 20:06:44 +0300
Subject: [PATCH 02/39] Update TransferFunction.java

---
 .../fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
index 8207130d9..33ce7861e 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
@@ -4,5 +4,5 @@
  * Enumeration that contains the types of transfer functions in which they are used to define the type of transfer function
  */
 public enum TransferFunction {
-        TFunction_V1, TFunction_V2, TFunction_V3, TFunction_V4
+        V1, V2, V3, V4
 }

From e33157e48cd305e6670fb0b91c92bede2c0682de Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 22 Apr 2023 20:08:32 +0300
Subject: [PATCH 03/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java        | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 6c5b883f4..eca6923e2 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -78,10 +78,8 @@ public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSi
      */
     private int[][] generatePopulation(int totalNumberOfFeatures) {
         setOfSolutions = new int[this.populationSize][totalNumberOfFeatures];
-
         for (int[] subSet : setOfSolutions)
             System.arraycopy(new Random().ints(totalNumberOfFeatures, 0, 2).toArray(), 0, subSet, 0, setOfSolutions[0].length);
-
         return setOfSolutions;
     }
 
@@ -104,35 +102,27 @@ public boolean isOrdered() {
     @Override
     public SelectedFeatureSet select(Dataset<Label> dataset) {
         ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
-
         setOfSolutions = generatePopulation(dataset.getFeatureMap().size());
-
         List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
-
         SelectedFeatureSet selectedFeatureSet = null;
 
         for (int i = 0; i < maxIteration; i++) {
             IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
-
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
-
                 if (evaluateSolution(dataset, FMap, evolvedSolution) > evaluateSolution(dataset, FMap, randomCuckoo))
                     System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
 
                 if (new Random().nextDouble() < worstNestProbability) {
                     int r1 = new Random().nextInt(setOfSolutions.length);
                     int r2 = new Random().nextInt(setOfSolutions.length);
-
                     for (var j = 0; j < setOfSolutions[subSet].length; j++)
                         evolvedSolution[j] = Binarizing.discreteValue(transferFunction, setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
-
                     if (evaluateSolution(dataset, FMap, evolvedSolution) > evaluateSolution(dataset, FMap, setOfSolutions[subSet]))
                         System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
                 }
                 subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], evaluateSolution(dataset, FMap, setOfSolutions[subSet])));
-
             });
             subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
             selectedFeatureSet = getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
@@ -149,13 +139,9 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
      */
     private double evaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
         SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(dataset, Fmap, solution));
-
         KNNClassifierOptions classifier = new KNNClassifierOptions();
-
         CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
-
         double avgAccuracy = 0D;
-
         for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
             avgAccuracy += ACC.getA().accuracy();
 
@@ -171,14 +157,12 @@ private double evaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap
     private SelectedFeatureSet getSFS(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
         List<String> names = new ArrayList<>();
         List<Double> scores = new ArrayList<>();
-
         for (int i = 0; i < solution.length; i++) {
             if (solution[i] == 1) {
                 names.add(Fmap.get(i).getName());
                 scores.add(1D);
             }
         }
-
         FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(),dataset.getProvenance(),getProvenance());
 
         return new SelectedFeatureSet(names,scores,isOrdered(),provenance);

From 580fb6a76c6c522c1afb9ef9e2060bd0452823d1 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 22 Apr 2023 20:09:12 +0300
Subject: [PATCH 04/39] Update Binarizing.java

---
 .../fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java  | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
index 2a2dc61a0..1adb617f4 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
@@ -14,10 +14,10 @@ public interface Binarizing {
      */
     static int discreteValue(TransferFunction TF, double Value) {
         return switch (TF) {
-            case TFunction_V1 -> Math.abs(erf(Math.sqrt(Math.PI) / 2 * Value)) >= 0.5 ? 1 : 0;
-            case TFunction_V2 -> Math.abs(Math.tan(Value)) >= 0.5 ? 1 : 0;
-            case TFunction_V3 -> Math.abs(Value / Math.abs(1 + Math.pow(Value, 2))) >= 0.5 ? 1 : 0;
-            case TFunction_V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * Value)) >= 0.5 ? 1 : 0;
+            case V1 -> Math.abs(erf(Math.sqrt(Math.PI) / 2 * Value)) >= 0.5 ? 1 : 0;
+            case V2 -> Math.abs(Math.tan(Value)) >= 0.5 ? 1 : 0;
+            case V3 -> Math.abs(Value / Math.abs(1 + Math.pow(Value, 2))) >= 0.5 ? 1 : 0;
+            case V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * Value)) >= 0.5 ? 1 : 0;
         };
     }
 }

From 02ddebb58ef93109b86ca980d2d1cfa615bd1c8f Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 24 Apr 2023 02:26:34 +0300
Subject: [PATCH 05/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java                     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index eca6923e2..2b79388b9 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -107,7 +107,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
         SelectedFeatureSet selectedFeatureSet = null;
 
         for (int i = 0; i < maxIteration; i++) {
-            IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
+            for (int subSet = 0; subSet < setOfSolutions.length; subSet++) {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
@@ -123,7 +123,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                         System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
                 }
                 subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], evaluateSolution(dataset, FMap, setOfSolutions[subSet])));
-            });
+            }
             subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
             selectedFeatureSet = getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
         }

From 1079ee743c5042a78e5e4ceb4438ff908f8f6944 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 24 Apr 2023 03:15:02 +0300
Subject: [PATCH 06/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java                     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 2b79388b9..eca6923e2 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -107,7 +107,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
         SelectedFeatureSet selectedFeatureSet = null;
 
         for (int i = 0; i < maxIteration; i++) {
-            for (int subSet = 0; subSet < setOfSolutions.length; subSet++) {
+            IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
@@ -123,7 +123,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                         System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
                 }
                 subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], evaluateSolution(dataset, FMap, setOfSolutions[subSet])));
-            }
+            });
             subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
             selectedFeatureSet = getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
         }

From 1a323c9d03d1b1e276f444b301058a8664cda7bd Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Tue, 25 Apr 2023 03:03:39 +0300
Subject: [PATCH 07/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java              | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index eca6923e2..617a4b741 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -76,7 +76,7 @@ public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSi
      * @param totalNumberOfFeatures The number of features in the given dataset
      * @return The population of subsets of selected features
      */
-    private int[][] generatePopulation(int totalNumberOfFeatures) {
+    private int[][] GeneratePopulation(int totalNumberOfFeatures) {
         setOfSolutions = new int[this.populationSize][totalNumberOfFeatures];
         for (int[] subSet : setOfSolutions)
             System.arraycopy(new Random().ints(totalNumberOfFeatures, 0, 2).toArray(), 0, subSet, 0, setOfSolutions[0].length);
@@ -102,7 +102,7 @@ public boolean isOrdered() {
     @Override
     public SelectedFeatureSet select(Dataset<Label> dataset) {
         ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
-        setOfSolutions = generatePopulation(dataset.getFeatureMap().size());
+        setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
         List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
         SelectedFeatureSet selectedFeatureSet = null;
 
@@ -111,7 +111,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
-                if (evaluateSolution(dataset, FMap, evolvedSolution) > evaluateSolution(dataset, FMap, randomCuckoo))
+                if (EvaluateSolution(dataset, FMap, evolvedSolution) > EvaluateSolution(dataset, FMap, randomCuckoo))
                     System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
 
                 if (new Random().nextDouble() < worstNestProbability) {
@@ -119,10 +119,10 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                     int r2 = new Random().nextInt(setOfSolutions.length);
                     for (var j = 0; j < setOfSolutions[subSet].length; j++)
                         evolvedSolution[j] = Binarizing.discreteValue(transferFunction, setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
-                    if (evaluateSolution(dataset, FMap, evolvedSolution) > evaluateSolution(dataset, FMap, setOfSolutions[subSet]))
+                    if (EvaluateSolution(dataset, FMap, evolvedSolution) > EvaluateSolution(dataset, FMap, setOfSolutions[subSet]))
                         System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
                 }
-                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], evaluateSolution(dataset, FMap, setOfSolutions[subSet])));
+                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], EvaluateSolution(dataset, FMap, setOfSolutions[subSet])));
             });
             subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
             selectedFeatureSet = getSFS(dataset, FMap, subSet_fScores.get(0).subSet);

From 8228ffef4ec8375748e3293cd2872fdf1ff33042 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Thu, 27 Apr 2023 04:28:33 +0300
Subject: [PATCH 08/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java        | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 617a4b741..64b9faa12 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -52,6 +52,22 @@ public CuckooSearchOptimizer() {
         this.delta = 1.5D;
         this.maxIteration = 30;
     }
+    
+    /**
+     * Constructs the wrapper feature selection based on cuckoo search algorithm
+     * @param transferFunction The transfer function to convert continuous values to binary ones
+     * @param populationSize The size of the solution in the initial population
+     * @param maxIteration The number of times that is used to enhance generation
+     */
+    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration) {
+        this.transferFunction = transferFunction;
+        this.populationSize = populationSize;
+        this.stepSizeScaling = 2D;
+        this.lambda = 2D;
+        this.worstNestProbability = 1.5D;
+        this.delta = 1.5D;
+        this.maxIteration = maxIteration;
+    }
 
     /**
      * @param transferFunction The transfer function to convert continuous values to binary ones

From 4f7a25f0f20877baa8bdf0bdd0904ed8311ec66c Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Thu, 27 Apr 2023 04:40:56 +0300
Subject: [PATCH 09/39] Update TransferFunction.java

---
 .../fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
index 33ce7861e..35d97ef09 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
@@ -4,5 +4,5 @@
  * Enumeration that contains the types of transfer functions in which they are used to define the type of transfer function
  */
 public enum TransferFunction {
-        V1, V2, V3, V4
+        V1, V2, V3, V4, S1, S2, S3, S4
 }

From 44a33bdc635707d98c9299804c4d1d3d376bc7ca Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Thu, 27 Apr 2023 04:41:32 +0300
Subject: [PATCH 10/39] Update Binarizing.java

---
 .../fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java      | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
index 1adb617f4..b0e391895 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
@@ -18,6 +18,10 @@ static int discreteValue(TransferFunction TF, double Value) {
             case V2 -> Math.abs(Math.tan(Value)) >= 0.5 ? 1 : 0;
             case V3 -> Math.abs(Value / Math.abs(1 + Math.pow(Value, 2))) >= 0.5 ? 1 : 0;
             case V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * Value)) >= 0.5 ? 1 : 0;
+            case S1 -> 1 / (1 + Math.pow(Math.E, - 2 * Value)) >= 0.5 ? 1 : 0;
+            case S2 -> 1 / (1 + Math.pow(Math.E, - Value)) >= 0.5 ? 1 : 0;
+            case S3 -> 1 / (1 + Math.pow(Math.E, - Value / 2)) >= 0.5 ? 1 : 0;
+            case S4 -> 1 / (1 + Math.pow(Math.E, - Value / 3)) >= 0.5 ? 1 : 0;
         };
     }
 }

From 5d58e5d68c860a5c109af01ee6f5080e6333f4ec Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Fri, 28 Apr 2023 06:47:46 +0300
Subject: [PATCH 11/39] Add files via upload

---
 .../Evaluation/FitnessFunction.java           | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
new file mode 100644
index 000000000..08509a95a
--- /dev/null
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -0,0 +1,62 @@
+package FS_Wrapper_Approaches.Evaluation;
+
+import FS_Wrapper_Approaches.Optimizers.CuckooSearchOptimizer;
+import com.oracle.labs.mlrg.olcut.util.Pair;
+import org.tribuo.Dataset;
+import org.tribuo.ImmutableFeatureMap;
+import org.tribuo.Model;
+import org.tribuo.SelectedFeatureSet;
+import org.tribuo.classification.Label;
+import org.tribuo.classification.evaluation.LabelEvaluation;
+import org.tribuo.classification.evaluation.LabelEvaluator;
+import org.tribuo.common.nearest.KNNClassifierOptions;
+import org.tribuo.dataset.SelectedFeatureDataset;
+import org.tribuo.evaluation.CrossValidation;
+import org.tribuo.provenance.FeatureSetProvenance;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * This interface includes the evaluation function of each solution
+ */
+public interface FitnessFunction {
+    /**
+     * This method is used to compute the fitness score of each solution of the population
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of features
+     * @return The fitness score of the given subset
+     */
+    static double EvaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
+        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(dataset, Fmap, solution));
+        KNNClassifierOptions classifier = new KNNClassifierOptions();
+        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
+        double avgAccuracy = 0D;
+        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
+            avgAccuracy += ACC.getA().accuracy();
+
+        return avgAccuracy + 0.0001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()));
+    }
+
+    /**
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of featurs
+     * @return The selected feature set
+     */
+    static SelectedFeatureSet getSFS(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
+        List<String> names = new ArrayList<>();
+        List<Double> scores = new ArrayList<>();
+        for (int i = 0; i < solution.length; i++) {
+            if (solution[i] == 1) {
+                names.add(Fmap.get(i).getName());
+                scores.add(1D);
+            }
+        }
+        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), new CuckooSearchOptimizer().getProvenance());
+
+        return new SelectedFeatureSet(names, scores, new CuckooSearchOptimizer().isOrdered(), provenance);
+    }
+}

From 39c340bf16edb4c333d57004ffb385ad712accf1 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Fri, 28 Apr 2023 06:49:45 +0300
Subject: [PATCH 12/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 48 ++-----------------
 1 file changed, 5 insertions(+), 43 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 64b9faa12..12a16c795 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -127,7 +127,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
-                if (EvaluateSolution(dataset, FMap, evolvedSolution) > EvaluateSolution(dataset, FMap, randomCuckoo))
+                if (FitnessFunction.EvaluateSolution(dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(dataset, FMap, randomCuckoo))
                     System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
 
                 if (new Random().nextDouble() < worstNestProbability) {
@@ -135,55 +135,17 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                     int r2 = new Random().nextInt(setOfSolutions.length);
                     for (var j = 0; j < setOfSolutions[subSet].length; j++)
                         evolvedSolution[j] = Binarizing.discreteValue(transferFunction, setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
-                    if (EvaluateSolution(dataset, FMap, evolvedSolution) > EvaluateSolution(dataset, FMap, setOfSolutions[subSet]))
+                    if (FitnessFunction.EvaluateSolution(dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(dataset, FMap, setOfSolutions[subSet]))
                         System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
                 }
-                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], EvaluateSolution(dataset, FMap, setOfSolutions[subSet])));
+                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], FitnessFunction.EvaluateSolution(dataset, FMap, setOfSolutions[subSet])));
             });
             subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
-            selectedFeatureSet = getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
+            selectedFeatureSet = FitnessFunction.getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
         }
         return selectedFeatureSet;
     }
-
-    /**
-     * This method is used to compute the fitness score of each solution of the population
-     * @param dataset The dataset to use
-     * @param Fmap The dataset feature map
-     * @param solution The current subset of features
-     * @return The fitness score of the given subset
-     */
-    private double evaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
-        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(dataset, Fmap, solution));
-        KNNClassifierOptions classifier = new KNNClassifierOptions();
-        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
-        double avgAccuracy = 0D;
-        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
-            avgAccuracy += ACC.getA().accuracy();
-
-        return avgAccuracy + 0.0001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()));
-    }
-
-    /**
-     * @param dataset The dataset to use
-     * @param Fmap The dataset feature map
-     * @param solution The current subset of featurs
-     * @return The selected feature set
-     */
-    private SelectedFeatureSet getSFS(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
-        List<String> names = new ArrayList<>();
-        List<Double> scores = new ArrayList<>();
-        for (int i = 0; i < solution.length; i++) {
-            if (solution[i] == 1) {
-                names.add(Fmap.get(i).getName());
-                scores.add(1D);
-            }
-        }
-        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(),dataset.getProvenance(),getProvenance());
-
-        return new SelectedFeatureSet(names,scores,isOrdered(),provenance);
-    }
-
+    
     @Override
     public FeatureSelectorProvenance getProvenance() {
         return new FeatureSelectorProvenanceImpl(this);

From 2f85c7bf5eb0ad669d0391541ff93cc506355274 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 29 Apr 2023 07:55:55 +0300
Subject: [PATCH 13/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java                | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 12a16c795..659d7ede3 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -111,7 +111,6 @@ public boolean isOrdered() {
 
     /**
      * Selects features according to this selection algorithm from the specified dataset.
-     *
      * @param dataset The dataset to use.
      * @return A selected feature set.
      */
@@ -127,7 +126,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
-                if (FitnessFunction.EvaluateSolution(dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(dataset, FMap, randomCuckoo))
+                if (FitnessFunction.EvaluateSolution(this, dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(this, dataset, FMap, randomCuckoo))
                     System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
 
                 if (new Random().nextDouble() < worstNestProbability) {
@@ -135,13 +134,13 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                     int r2 = new Random().nextInt(setOfSolutions.length);
                     for (var j = 0; j < setOfSolutions[subSet].length; j++)
                         evolvedSolution[j] = Binarizing.discreteValue(transferFunction, setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
-                    if (FitnessFunction.EvaluateSolution(dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(dataset, FMap, setOfSolutions[subSet]))
+                    if (FitnessFunction.EvaluateSolution(this, dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet]))
                         System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
                 }
-                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], FitnessFunction.EvaluateSolution(dataset, FMap, setOfSolutions[subSet])));
+                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], FitnessFunction.EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet])));
             });
             subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
-            selectedFeatureSet = FitnessFunction.getSFS(dataset, FMap, subSet_fScores.get(0).subSet);
+            selectedFeatureSet = FitnessFunction.getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
         }
         return selectedFeatureSet;
     }

From 6392dd15a5075d0b3838463095e214a893f23296 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 29 Apr 2023 07:57:02 +0300
Subject: [PATCH 14/39] Update FitnessFunction.java

---
 .../Evaluation/FitnessFunction.java                 | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
index 08509a95a..89b515b1c 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -24,13 +24,14 @@
 public interface FitnessFunction {
     /**
      * This method is used to compute the fitness score of each solution of the population
+     * @param optimizer The optimizer that is used for FS
      * @param dataset The dataset to use
      * @param Fmap The dataset feature map
      * @param solution The current subset of features
      * @return The fitness score of the given subset
      */
-    static double EvaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
-        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(dataset, Fmap, solution));
+    static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
+        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
         KNNClassifierOptions classifier = new KNNClassifierOptions();
         CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
         double avgAccuracy = 0D;
@@ -41,12 +42,14 @@ static double EvaluateSolution(Dataset<Label> dataset, ImmutableFeatureMap Fmap,
     }
 
     /**
+     * This methid is used to return the selected subset of features
+     * @param optimizer The optimizer that is used for FS
      * @param dataset The dataset to use
      * @param Fmap The dataset feature map
      * @param solution The current subset of featurs
      * @return The selected feature set
      */
-    static SelectedFeatureSet getSFS(Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
+    static <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
         List<String> names = new ArrayList<>();
         List<Double> scores = new ArrayList<>();
         for (int i = 0; i < solution.length; i++) {
@@ -55,8 +58,8 @@ static SelectedFeatureSet getSFS(Dataset<Label> dataset, ImmutableFeatureMap Fma
                 scores.add(1D);
             }
         }
-        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), new CuckooSearchOptimizer().getProvenance());
+        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), optimizer.getProvenance());
 
-        return new SelectedFeatureSet(names, scores, new CuckooSearchOptimizer().isOrdered(), provenance);
+        return new SelectedFeatureSet(names, scores, optimizer.isOrdered(), provenance);
     }
 }

From e214c10a339a05d81ad5077e2a5987b523923d91 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sun, 30 Apr 2023 15:23:31 +0300
Subject: [PATCH 15/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java                     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 659d7ede3..17ed3c78a 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -120,7 +120,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
         setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
         List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
         SelectedFeatureSet selectedFeatureSet = null;
-
+        // Update the solution based on the levy flight function
         for (int i = 0; i < maxIteration; i++) {
             IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
                 AtomicInteger currentIter = new AtomicInteger(subSet);
@@ -128,7 +128,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
                 if (FitnessFunction.EvaluateSolution(this, dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(this, dataset, FMap, randomCuckoo))
                     System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
-
+                // Update the solution based on the abandone nest function
                 if (new Random().nextDouble() < worstNestProbability) {
                     int r1 = new Random().nextInt(setOfSolutions.length);
                     int r2 = new Random().nextInt(setOfSolutions.length);

From f0a13001252425675acd3bbdb014cbb2d4666d64 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sun, 30 Apr 2023 20:06:58 +0300
Subject: [PATCH 16/39] Update FitnessFunction.java

---
 .../fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java   | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
index 89b515b1c..d4621b72c 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -52,12 +52,11 @@ static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, D
     static <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
         List<String> names = new ArrayList<>();
         List<Double> scores = new ArrayList<>();
-        for (int i = 0; i < solution.length; i++) {
+        for (int i = 0; i < solution.length; i++)
             if (solution[i] == 1) {
                 names.add(Fmap.get(i).getName());
                 scores.add(1D);
             }
-        }
         FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), optimizer.getProvenance());
 
         return new SelectedFeatureSet(names, scores, optimizer.isOrdered(), provenance);

From 2c9c47d283c868988310831d069f140ca5459d45 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sun, 30 Apr 2023 20:27:44 +0300
Subject: [PATCH 17/39] Update FitnessFunction.java

---
 .../fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
index d4621b72c..735edd3db 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -33,6 +33,7 @@ public interface FitnessFunction {
     static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
         SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
         KNNClassifierOptions classifier = new KNNClassifierOptions();
+        classifier.knnK = 5;
         CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
         double avgAccuracy = 0D;
         for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())

From 40da8a8f020dea67c20051aeece0f5bbb7ae9f0c Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 1 May 2023 11:24:54 +0300
Subject: [PATCH 18/39] Update FitnessFunction.java

---
 .../fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
index 735edd3db..d4621b72c 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -33,7 +33,6 @@ public interface FitnessFunction {
     static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
         SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
         KNNClassifierOptions classifier = new KNNClassifierOptions();
-        classifier.knnK = 5;
         CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
         double avgAccuracy = 0D;
         for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())

From b381c2ab7b426ab8869d5f37cfd6365e59e5f82b Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 8 May 2023 01:04:58 +0300
Subject: [PATCH 19/39] Update FitnessFunction.java

---
 .../fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
index d4621b72c..c1826663e 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -37,6 +37,7 @@ static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, D
         double avgAccuracy = 0D;
         for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
             avgAccuracy += ACC.getA().accuracy();
+        avgAccuracy /= crossValidation.getK();
 
         return avgAccuracy + 0.0001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()));
     }

From e05f30d0b7256758ff8535006bfe1b2fdfb88209 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 13 May 2023 23:58:15 +0300
Subject: [PATCH 20/39] Update FitnessFunction.java

---
 .../fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
index c1826663e..96005921e 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
@@ -34,7 +34,7 @@ static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, D
         SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
         KNNClassifierOptions classifier = new KNNClassifierOptions();
         CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
-        double avgAccuracy = 0D;
+        double avgAccuracy = 0d;
         for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
             avgAccuracy += ACC.getA().accuracy();
         avgAccuracy /= crossValidation.getK();

From 5aa563da107b7b1ded3365c9d2188c7310070362 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sat, 13 May 2023 23:59:13 +0300
Subject: [PATCH 21/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java        | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 17ed3c78a..4d6af02d9 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -46,10 +46,10 @@ public class CuckooSearchOptimizer implements FeatureSelector<Label> {
     public CuckooSearchOptimizer() {
         this.transferFunction = TransferFunction.TFunction_V2;
         this.populationSize = 50;
-        this.stepSizeScaling = 2D;
-        this.lambda = 2D;
-        this.worstNestProbability = 0.1D;
-        this.delta = 1.5D;
+        this.stepSizeScaling = 2d;
+        this.lambda = 2d;
+        this.worstNestProbability = 0.1d;
+        this.delta = 1.5d;
         this.maxIteration = 30;
     }
     
@@ -62,10 +62,10 @@ public CuckooSearchOptimizer() {
     public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration) {
         this.transferFunction = transferFunction;
         this.populationSize = populationSize;
-        this.stepSizeScaling = 2D;
-        this.lambda = 2D;
-        this.worstNestProbability = 1.5D;
-        this.delta = 1.5D;
+        this.stepSizeScaling = 2d;
+        this.lambda = 2d;
+        this.worstNestProbability = 1.5d;
+        this.delta = 1.5d;
         this.maxIteration = maxIteration;
     }
 

From c5d5f62d0dc1055517e66045550d88de8a4a6d6f Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 29 May 2023 23:01:32 +0300
Subject: [PATCH 22/39] Add files via upload

---
 .../wrapper/Discreeting/TransferFunction.java |  33 +++
 .../Optimizers/CuckooSearchOptimizer.java     | 230 ++++++++++++++++++
 2 files changed, 263 insertions(+)
 create mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java
 create mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java
new file mode 100644
index 000000000..2eac97fe7
--- /dev/null
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java
@@ -0,0 +1,33 @@
+package org.tribuo.classification.fs.wrapper.Discreeting;
+
+import java.util.function.DoubleUnaryOperator;
+
+import static org.apache.commons.math3.special.Erf.erf;
+
+/**
+ * Enumeration that contains the types of transfer functions in which they are used to define the type of transfer function
+ */
+public enum TransferFunction implements DoubleUnaryOperator {
+        V1, V2, V3, V4, S1, S2, S3, S4;
+
+        /**
+         * Applies this operator to the given value.
+         *
+         * @param value the operand as continuous value to be converted to either 1 or 0
+         * @return the operator result that is a d
+         */
+        @Override
+        public double applyAsDouble(double value) {
+                return switch (this) {
+                        case V1 -> Math.abs(erf(Math.sqrt(Math.PI) / 2 * value)) >= 0.5 ? 1 : 0;
+                        case V2 -> Math.abs(Math.tan(value)) >= 0.5 ? 1 : 0;
+                        case V3 -> Math.abs(value / Math.abs(1 + Math.pow(value, 2))) >= 0.5 ? 1 : 0;
+                        case V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * value)) >= 0.5 ? 1 : 0;
+                        case S1 -> 1 / (1 + Math.pow(Math.E, - 2 * value)) >= 0.5 ? 1 : 0;
+                        case S2 -> 1 / (1 + Math.pow(Math.E, - value)) >= 0.5 ? 1 : 0;
+                        case S3 -> 1 / (1 + Math.pow(Math.E, - value / 2)) >= 0.5 ? 1 : 0;
+                        case S4 -> 1 / (1 + Math.pow(Math.E, - value / 3)) >= 0.5 ? 1 : 0;
+                };
+        }
+}
+
diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java
new file mode 100644
index 000000000..be35d0118
--- /dev/null
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java
@@ -0,0 +1,230 @@
+package org.tribuo.classification.fs.wrapper.Optimizers;
+
+import com.oracle.labs.mlrg.olcut.util.Pair;
+import org.tribuo.*;
+import org.tribuo.classification.Label;
+import org.tribuo.classification.ensemble.VotingCombiner;
+import org.tribuo.classification.evaluation.LabelEvaluation;
+import org.tribuo.classification.evaluation.LabelEvaluator;
+import org.tribuo.classification.fs.wrapper.Discreeting.TransferFunction;
+import org.tribuo.common.nearest.KNNModel;
+import org.tribuo.common.nearest.KNNTrainer;
+import org.tribuo.dataset.SelectedFeatureDataset;
+import org.tribuo.evaluation.CrossValidation;
+import org.tribuo.math.distance.L1Distance;
+import org.tribuo.math.neighbour.NeighboursQueryFactoryType;
+import org.tribuo.provenance.FeatureSelectorProvenance;
+import org.tribuo.provenance.FeatureSetProvenance;
+import org.tribuo.provenance.impl.FeatureSelectorProvenanceImpl;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.IntStream;
+
+/**
+ * Select features based on Cuckoo Search algorithm with binary transfer functions, KNN classifier and 10-fold cross validation
+ * <p>
+ * see:
+ * <pre>
+ * Xin-She Yang and Suash Deb.
+ * "Cuckoo Search via L´evy Flights", 2010.
+ *
+ * L. A. M. Pereira et al.
+ * "A Binary Cuckoo Search and its Application for Feature Selection", 2014.
+ * </pre>
+ */
+public class CuckooSearchOptimizer implements FeatureSelector<Label> {
+    private final TransferFunction transferFunction;
+    private final double stepSizeScaling;
+    private final double lambda;
+    private final double worstNestProbability;
+    private final double delta;
+    private final int populationSize;
+    private int [][] setOfSolutions;
+    private final int maxIteration;
+
+    /**
+     * The default constructor for feature selection based on Cuckoo Search Algorithm
+     */
+    public CuckooSearchOptimizer() {
+        this.transferFunction = TransferFunction.V2;
+        this.populationSize = 50;
+        this.stepSizeScaling = 2d;
+        this.lambda = 2d;
+        this.worstNestProbability = 0.1d;
+        this.delta = 1.5d;
+        this.maxIteration = 30;
+    }
+
+    /**
+     * Constructs the wrapper feature selection based on cuckoo search algorithm
+     * @param transferFunction The transfer function to convert continuous values to binary ones
+     * @param populationSize The size of the solution in the initial population
+     * @param maxIteration The number of times that is used to enhance generation
+     */
+    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration) {
+        this.transferFunction = transferFunction;
+        this.populationSize = populationSize;
+        this.stepSizeScaling = 2d;
+        this.lambda = 2d;
+        this.worstNestProbability = 1.5d;
+        this.delta = 1.5d;
+        this.maxIteration = maxIteration;
+    }
+
+    /**
+     * Constructs the wrapper feature selection based on cuckoo search algorithm
+     * @param transferFunction The transfer function to convert continuous values to binary ones
+     * @param populationSize The size of the solution in the initial population
+     * @param stepSizeScaling The cuckoo step size
+     * @param lambda The lambda of the levy flight function
+     * @param worstNestProbability The fraction of the nests to be abandoned
+     * @param delta The delta that is used in the abandon nest function
+     * @param maxIteration The number of times that is used to enhance generation
+     */
+    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, int maxIteration) {
+        this.transferFunction = transferFunction;
+        this.populationSize = populationSize;
+        this.stepSizeScaling = stepSizeScaling;
+        this.lambda = lambda;
+        this.worstNestProbability = worstNestProbability;
+        this.delta = delta;
+        this.maxIteration = maxIteration;
+    }
+
+    /**
+     * Constructs the wrapper feature selection based on cuckoo search algorithm
+     * @param dataPath The path of the dataset
+     * @param transferFunction The transfer function to convert continuous values to binary ones
+     * @param populationSize The size of the solution in the initial population
+     * @param stepSizeScaling The cuckoo step size
+     * @param lambda The lambda of the levy flight function
+     * @param worstNestProbability The fraction of the nests to be abandoned
+     * @param delta The delta that is used in the abandon nest function
+     * @param maxIteration The number of times that is used to enhance generation
+     */
+    public CuckooSearchOptimizer(String dataPath, TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, int maxIteration) {
+        this.transferFunction = transferFunction;
+        this.populationSize = populationSize;
+        this.stepSizeScaling = stepSizeScaling;
+        this.lambda = lambda;
+        this.worstNestProbability = worstNestProbability;
+        this.delta = delta;
+        this.maxIteration = maxIteration;
+    }
+
+    /**
+     * This method is used to generate the initial population (set of solutions)
+     * @param totalNumberOfFeatures The number of features in the given dataset
+     * @return The population of subsets of selected features
+     */
+    private int[][] GeneratePopulation(int totalNumberOfFeatures) {
+        SplittableRandom sRand = new SplittableRandom(12345);
+        setOfSolutions = new int[this.populationSize][totalNumberOfFeatures];
+        for (int[] subSet : setOfSolutions) {
+            int[] values = new int[subSet.length];
+            for (int i = 0; i < values.length; i++) {
+                values[i] = sRand.nextInt(2);
+            }
+            System.arraycopy(values, 0, subSet, 0, setOfSolutions[0].length);
+        }
+        return setOfSolutions;
+    }
+
+    /**
+     * Does this feature selection algorithm return an ordered feature set?
+     *
+     * @return True if the set is ordered.
+     */
+    @Override
+    public boolean isOrdered() {
+        return true;
+    }
+
+    /**
+     * Selects features according to this selection algorithm from the specified dataset.
+     * @param dataset The dataset to use.
+     * @return A selected feature set.
+     */
+    @Override
+    public SelectedFeatureSet select(Dataset<Label> dataset) {
+        ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
+        setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
+        List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
+        SelectedFeatureSet selectedFeatureSet = null;
+        // Update the solution based on the levy flight function
+        for (int i = 0; i < maxIteration; i++) {
+            IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
+                AtomicInteger currentIter = new AtomicInteger(subSet);
+                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
+                int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
+                if (EvaluateSolution(this, dataset, FMap, evolvedSolution) > EvaluateSolution(this, dataset, FMap, randomCuckoo))
+                    System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
+                // Update the solution based on the abandone nest function
+                if (new Random().nextDouble() < worstNestProbability) {
+                    int r1 = new Random().nextInt(setOfSolutions.length);
+                    int r2 = new Random().nextInt(setOfSolutions.length);
+                    for (var j = 0; j < setOfSolutions[subSet].length; j++)
+                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
+                    if (EvaluateSolution(this, dataset, FMap, evolvedSolution) > EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet]))
+                        System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
+                    }
+                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet])));
+            });
+            subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
+            selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
+        }
+        return selectedFeatureSet;
+    }
+
+    @Override
+    public FeatureSelectorProvenance getProvenance() {
+        return new FeatureSelectorProvenanceImpl(this);
+    }
+    /**
+     * This method is used to compute the fitness score of each solution of the population
+     * @param optimizer The optimizer that is used for FS
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of features
+     * @return The fitness score of the given subset*/
+
+    private  <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
+        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
+        KNNTrainer<Label> KnnTrainer =  new KNNTrainer<Label>(1, new L1Distance(), Runtime.getRuntime().availableProcessors(), new VotingCombiner(), KNNModel.Backend.THREADPOOL, NeighboursQueryFactoryType.BRUTE_FORCE);
+        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(KnnTrainer, selectedFeatureDataset, new LabelEvaluator(), 10);
+        double avgAccuracy = 0D;
+        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate()) {
+            avgAccuracy += ACC.getA().accuracy();}
+        avgAccuracy /= crossValidation.getK();
+        double correlation = 0;
+
+        return avgAccuracy + 0.001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()) - correlation);
+    }
+
+    /**
+     * This methid is used to return the selected subset of features
+     * @param optimizer The optimizer that is used for FS
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of featurs
+     * @return The selected feature set*/
+
+    private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
+        List<String> names = new ArrayList<>();
+        List<Double> scores = new ArrayList<>();
+        for (int i = 0; i < solution.length; i++)
+            if (solution[i] == 1) {
+                names.add(Fmap.get(i).getName());
+                scores.add(1D);
+            }
+        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), optimizer.getProvenance());
+
+        return new SelectedFeatureSet(names, scores, optimizer.isOrdered(), provenance);
+    }
+
+    /**
+     * This record is used to hold subset of features with its corresponding fitness score
+     */
+    record FeatureSet_FScore_Container(int[] subSet, double score) { }
+}
\ No newline at end of file

From 99f83e6ce7f82e138f872a5e59338d1e4d3c353e Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 29 May 2023 23:02:38 +0300
Subject: [PATCH 23/39] Delete
 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper
 directory

---
 .../wrapper/Discreeting/TransferFunction.java |  33 ---
 .../Optimizers/CuckooSearchOptimizer.java     | 230 ------------------
 2 files changed, 263 deletions(-)
 delete mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java
 delete mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java
deleted file mode 100644
index 2eac97fe7..000000000
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Discreeting/TransferFunction.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package org.tribuo.classification.fs.wrapper.Discreeting;
-
-import java.util.function.DoubleUnaryOperator;
-
-import static org.apache.commons.math3.special.Erf.erf;
-
-/**
- * Enumeration that contains the types of transfer functions in which they are used to define the type of transfer function
- */
-public enum TransferFunction implements DoubleUnaryOperator {
-        V1, V2, V3, V4, S1, S2, S3, S4;
-
-        /**
-         * Applies this operator to the given value.
-         *
-         * @param value the operand as continuous value to be converted to either 1 or 0
-         * @return the operator result that is a d
-         */
-        @Override
-        public double applyAsDouble(double value) {
-                return switch (this) {
-                        case V1 -> Math.abs(erf(Math.sqrt(Math.PI) / 2 * value)) >= 0.5 ? 1 : 0;
-                        case V2 -> Math.abs(Math.tan(value)) >= 0.5 ? 1 : 0;
-                        case V3 -> Math.abs(value / Math.abs(1 + Math.pow(value, 2))) >= 0.5 ? 1 : 0;
-                        case V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * value)) >= 0.5 ? 1 : 0;
-                        case S1 -> 1 / (1 + Math.pow(Math.E, - 2 * value)) >= 0.5 ? 1 : 0;
-                        case S2 -> 1 / (1 + Math.pow(Math.E, - value)) >= 0.5 ? 1 : 0;
-                        case S3 -> 1 / (1 + Math.pow(Math.E, - value / 2)) >= 0.5 ? 1 : 0;
-                        case S4 -> 1 / (1 + Math.pow(Math.E, - value / 3)) >= 0.5 ? 1 : 0;
-                };
-        }
-}
-
diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java
deleted file mode 100644
index be35d0118..000000000
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/wrapper/Optimizers/CuckooSearchOptimizer.java
+++ /dev/null
@@ -1,230 +0,0 @@
-package org.tribuo.classification.fs.wrapper.Optimizers;
-
-import com.oracle.labs.mlrg.olcut.util.Pair;
-import org.tribuo.*;
-import org.tribuo.classification.Label;
-import org.tribuo.classification.ensemble.VotingCombiner;
-import org.tribuo.classification.evaluation.LabelEvaluation;
-import org.tribuo.classification.evaluation.LabelEvaluator;
-import org.tribuo.classification.fs.wrapper.Discreeting.TransferFunction;
-import org.tribuo.common.nearest.KNNModel;
-import org.tribuo.common.nearest.KNNTrainer;
-import org.tribuo.dataset.SelectedFeatureDataset;
-import org.tribuo.evaluation.CrossValidation;
-import org.tribuo.math.distance.L1Distance;
-import org.tribuo.math.neighbour.NeighboursQueryFactoryType;
-import org.tribuo.provenance.FeatureSelectorProvenance;
-import org.tribuo.provenance.FeatureSetProvenance;
-import org.tribuo.provenance.impl.FeatureSelectorProvenanceImpl;
-
-import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.IntStream;
-
-/**
- * Select features based on Cuckoo Search algorithm with binary transfer functions, KNN classifier and 10-fold cross validation
- * <p>
- * see:
- * <pre>
- * Xin-She Yang and Suash Deb.
- * "Cuckoo Search via L´evy Flights", 2010.
- *
- * L. A. M. Pereira et al.
- * "A Binary Cuckoo Search and its Application for Feature Selection", 2014.
- * </pre>
- */
-public class CuckooSearchOptimizer implements FeatureSelector<Label> {
-    private final TransferFunction transferFunction;
-    private final double stepSizeScaling;
-    private final double lambda;
-    private final double worstNestProbability;
-    private final double delta;
-    private final int populationSize;
-    private int [][] setOfSolutions;
-    private final int maxIteration;
-
-    /**
-     * The default constructor for feature selection based on Cuckoo Search Algorithm
-     */
-    public CuckooSearchOptimizer() {
-        this.transferFunction = TransferFunction.V2;
-        this.populationSize = 50;
-        this.stepSizeScaling = 2d;
-        this.lambda = 2d;
-        this.worstNestProbability = 0.1d;
-        this.delta = 1.5d;
-        this.maxIteration = 30;
-    }
-
-    /**
-     * Constructs the wrapper feature selection based on cuckoo search algorithm
-     * @param transferFunction The transfer function to convert continuous values to binary ones
-     * @param populationSize The size of the solution in the initial population
-     * @param maxIteration The number of times that is used to enhance generation
-     */
-    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration) {
-        this.transferFunction = transferFunction;
-        this.populationSize = populationSize;
-        this.stepSizeScaling = 2d;
-        this.lambda = 2d;
-        this.worstNestProbability = 1.5d;
-        this.delta = 1.5d;
-        this.maxIteration = maxIteration;
-    }
-
-    /**
-     * Constructs the wrapper feature selection based on cuckoo search algorithm
-     * @param transferFunction The transfer function to convert continuous values to binary ones
-     * @param populationSize The size of the solution in the initial population
-     * @param stepSizeScaling The cuckoo step size
-     * @param lambda The lambda of the levy flight function
-     * @param worstNestProbability The fraction of the nests to be abandoned
-     * @param delta The delta that is used in the abandon nest function
-     * @param maxIteration The number of times that is used to enhance generation
-     */
-    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, int maxIteration) {
-        this.transferFunction = transferFunction;
-        this.populationSize = populationSize;
-        this.stepSizeScaling = stepSizeScaling;
-        this.lambda = lambda;
-        this.worstNestProbability = worstNestProbability;
-        this.delta = delta;
-        this.maxIteration = maxIteration;
-    }
-
-    /**
-     * Constructs the wrapper feature selection based on cuckoo search algorithm
-     * @param dataPath The path of the dataset
-     * @param transferFunction The transfer function to convert continuous values to binary ones
-     * @param populationSize The size of the solution in the initial population
-     * @param stepSizeScaling The cuckoo step size
-     * @param lambda The lambda of the levy flight function
-     * @param worstNestProbability The fraction of the nests to be abandoned
-     * @param delta The delta that is used in the abandon nest function
-     * @param maxIteration The number of times that is used to enhance generation
-     */
-    public CuckooSearchOptimizer(String dataPath, TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, int maxIteration) {
-        this.transferFunction = transferFunction;
-        this.populationSize = populationSize;
-        this.stepSizeScaling = stepSizeScaling;
-        this.lambda = lambda;
-        this.worstNestProbability = worstNestProbability;
-        this.delta = delta;
-        this.maxIteration = maxIteration;
-    }
-
-    /**
-     * This method is used to generate the initial population (set of solutions)
-     * @param totalNumberOfFeatures The number of features in the given dataset
-     * @return The population of subsets of selected features
-     */
-    private int[][] GeneratePopulation(int totalNumberOfFeatures) {
-        SplittableRandom sRand = new SplittableRandom(12345);
-        setOfSolutions = new int[this.populationSize][totalNumberOfFeatures];
-        for (int[] subSet : setOfSolutions) {
-            int[] values = new int[subSet.length];
-            for (int i = 0; i < values.length; i++) {
-                values[i] = sRand.nextInt(2);
-            }
-            System.arraycopy(values, 0, subSet, 0, setOfSolutions[0].length);
-        }
-        return setOfSolutions;
-    }
-
-    /**
-     * Does this feature selection algorithm return an ordered feature set?
-     *
-     * @return True if the set is ordered.
-     */
-    @Override
-    public boolean isOrdered() {
-        return true;
-    }
-
-    /**
-     * Selects features according to this selection algorithm from the specified dataset.
-     * @param dataset The dataset to use.
-     * @return A selected feature set.
-     */
-    @Override
-    public SelectedFeatureSet select(Dataset<Label> dataset) {
-        ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
-        setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
-        List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
-        SelectedFeatureSet selectedFeatureSet = null;
-        // Update the solution based on the levy flight function
-        for (int i = 0; i < maxIteration; i++) {
-            IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
-                AtomicInteger currentIter = new AtomicInteger(subSet);
-                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
-                int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
-                if (EvaluateSolution(this, dataset, FMap, evolvedSolution) > EvaluateSolution(this, dataset, FMap, randomCuckoo))
-                    System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
-                // Update the solution based on the abandone nest function
-                if (new Random().nextDouble() < worstNestProbability) {
-                    int r1 = new Random().nextInt(setOfSolutions.length);
-                    int r2 = new Random().nextInt(setOfSolutions.length);
-                    for (var j = 0; j < setOfSolutions[subSet].length; j++)
-                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
-                    if (EvaluateSolution(this, dataset, FMap, evolvedSolution) > EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet]))
-                        System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
-                    }
-                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet])));
-            });
-            subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
-            selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
-        }
-        return selectedFeatureSet;
-    }
-
-    @Override
-    public FeatureSelectorProvenance getProvenance() {
-        return new FeatureSelectorProvenanceImpl(this);
-    }
-    /**
-     * This method is used to compute the fitness score of each solution of the population
-     * @param optimizer The optimizer that is used for FS
-     * @param dataset The dataset to use
-     * @param Fmap The dataset feature map
-     * @param solution The current subset of features
-     * @return The fitness score of the given subset*/
-
-    private  <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
-        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
-        KNNTrainer<Label> KnnTrainer =  new KNNTrainer<Label>(1, new L1Distance(), Runtime.getRuntime().availableProcessors(), new VotingCombiner(), KNNModel.Backend.THREADPOOL, NeighboursQueryFactoryType.BRUTE_FORCE);
-        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(KnnTrainer, selectedFeatureDataset, new LabelEvaluator(), 10);
-        double avgAccuracy = 0D;
-        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate()) {
-            avgAccuracy += ACC.getA().accuracy();}
-        avgAccuracy /= crossValidation.getK();
-        double correlation = 0;
-
-        return avgAccuracy + 0.001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()) - correlation);
-    }
-
-    /**
-     * This methid is used to return the selected subset of features
-     * @param optimizer The optimizer that is used for FS
-     * @param dataset The dataset to use
-     * @param Fmap The dataset feature map
-     * @param solution The current subset of featurs
-     * @return The selected feature set*/
-
-    private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
-        List<String> names = new ArrayList<>();
-        List<Double> scores = new ArrayList<>();
-        for (int i = 0; i < solution.length; i++)
-            if (solution[i] == 1) {
-                names.add(Fmap.get(i).getName());
-                scores.add(1D);
-            }
-        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), optimizer.getProvenance());
-
-        return new SelectedFeatureSet(names, scores, optimizer.isOrdered(), provenance);
-    }
-
-    /**
-     * This record is used to hold subset of features with its corresponding fitness score
-     */
-    record FeatureSet_FScore_Container(int[] subSet, double score) { }
-}
\ No newline at end of file

From 63e4aa08962806494113ac20e9fa2611db808e1e Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 10 Jul 2023 13:25:35 +0300
Subject: [PATCH 24/39] Delete Binarizing.java

---
 .../Discreeting/Binarizing.java               | 27 -------------------
 1 file changed, 27 deletions(-)
 delete mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
deleted file mode 100644
index b0e391895..000000000
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/Binarizing.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package FS_Wrapper_Approaches.Discreeting;
-
-import static org.apache.commons.math3.special.Erf.erf;
-
-/**
- * This interface includes a static method that is utilized to convert continuous value to binary one
- */
-public interface Binarizing {
-    /**
-     * This method used to convert continuous values to binary ones
-     * @param TF is the type (id) of the transfer function
-     * @param Value is the continuous value to be converted
-     * @return return the converted value based on the selected function
-     */
-    static int discreteValue(TransferFunction TF, double Value) {
-        return switch (TF) {
-            case V1 -> Math.abs(erf(Math.sqrt(Math.PI) / 2 * Value)) >= 0.5 ? 1 : 0;
-            case V2 -> Math.abs(Math.tan(Value)) >= 0.5 ? 1 : 0;
-            case V3 -> Math.abs(Value / Math.abs(1 + Math.pow(Value, 2))) >= 0.5 ? 1 : 0;
-            case V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * Value)) >= 0.5 ? 1 : 0;
-            case S1 -> 1 / (1 + Math.pow(Math.E, - 2 * Value)) >= 0.5 ? 1 : 0;
-            case S2 -> 1 / (1 + Math.pow(Math.E, - Value)) >= 0.5 ? 1 : 0;
-            case S3 -> 1 / (1 + Math.pow(Math.E, - Value / 2)) >= 0.5 ? 1 : 0;
-            case S4 -> 1 / (1 + Math.pow(Math.E, - Value / 3)) >= 0.5 ? 1 : 0;
-        };
-    }
-}

From 8c9d3e2aacf1ec1e2abfc7a8be1aca124b9616a2 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 10 Jul 2023 13:27:01 +0300
Subject: [PATCH 25/39] Update TransferFunction.java

---
 .../Discreeting/TransferFunction.java         | 28 +++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
index 35d97ef09..de75c2dba 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Discreeting/TransferFunction.java
@@ -1,8 +1,32 @@
 package FS_Wrapper_Approaches.Discreeting;
 
+import org.ojalgo.function.special.ErrorFunction;
+
+import java.util.function.DoubleUnaryOperator;
+
 /**
  * Enumeration that contains the types of transfer functions in which they are used to define the type of transfer function
  */
-public enum TransferFunction {
-        V1, V2, V3, V4, S1, S2, S3, S4
+public enum TransferFunction implements DoubleUnaryOperator {
+        V1, V2, V3, V4, S1, S2, S3, S4;
+
+        /**
+         * Applies this operator to the given value.
+         *
+         * @param value the operand as continuous value to be converted to either 1 or 0
+         * @return the operator result that is a d
+         */
+        @Override
+        public double applyAsDouble(double value) {
+                return switch (this) {
+                        case V1 -> Math.abs(ErrorFunction.erf(Math.sqrt(Math.PI) / 2 * value)) >= 0.5 ? 1 : 0;
+                        case V2 -> Math.abs(Math.tan(value)) >= 0.5 ? 1 : 0;
+                        case V3 -> Math.abs(value / Math.abs(1 + Math.pow(value, 2))) >= 0.5 ? 1 : 0;
+                        case V4 -> Math.abs(2 / Math.PI * Math.atan(Math.PI / 2 * value)) >= 0.5 ? 1 : 0;
+                        case S1 -> 1 / (1 + Math.pow(Math.E, - 2 * value)) >= 0.5 ? 1 : 0;
+                        case S2 -> 1 / (1 + Math.pow(Math.E, - value)) >= 0.5 ? 1 : 0;
+                        case S3 -> 1 / (1 + Math.pow(Math.E, - value / 2)) >= 0.5 ? 1 : 0;
+                        case S4 -> 1 / (1 + Math.pow(Math.E, - value / 3)) >= 0.5 ? 1 : 0;
+                };
+        }
 }

From 6d2f94058856d4ce9b23924d3ee88997d76b7151 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 10 Jul 2023 13:28:27 +0300
Subject: [PATCH 26/39] Delete FitnessFunction.java

---
 .../Evaluation/FitnessFunction.java           | 65 -------------------
 1 file changed, 65 deletions(-)
 delete mode 100644 Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
deleted file mode 100644
index 96005921e..000000000
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Evaluation/FitnessFunction.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package FS_Wrapper_Approaches.Evaluation;
-
-import FS_Wrapper_Approaches.Optimizers.CuckooSearchOptimizer;
-import com.oracle.labs.mlrg.olcut.util.Pair;
-import org.tribuo.Dataset;
-import org.tribuo.ImmutableFeatureMap;
-import org.tribuo.Model;
-import org.tribuo.SelectedFeatureSet;
-import org.tribuo.classification.Label;
-import org.tribuo.classification.evaluation.LabelEvaluation;
-import org.tribuo.classification.evaluation.LabelEvaluator;
-import org.tribuo.common.nearest.KNNClassifierOptions;
-import org.tribuo.dataset.SelectedFeatureDataset;
-import org.tribuo.evaluation.CrossValidation;
-import org.tribuo.provenance.FeatureSetProvenance;
-
-import java.util.ArrayList;
-import java.util.List;
-
-
-/**
- * This interface includes the evaluation function of each solution
- */
-public interface FitnessFunction {
-    /**
-     * This method is used to compute the fitness score of each solution of the population
-     * @param optimizer The optimizer that is used for FS
-     * @param dataset The dataset to use
-     * @param Fmap The dataset feature map
-     * @param solution The current subset of features
-     * @return The fitness score of the given subset
-     */
-    static <T extends FeatureSelector<Label>> double EvaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
-        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
-        KNNClassifierOptions classifier = new KNNClassifierOptions();
-        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(classifier.getTrainer(), selectedFeatureDataset, new LabelEvaluator(), 10);
-        double avgAccuracy = 0d;
-        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate())
-            avgAccuracy += ACC.getA().accuracy();
-        avgAccuracy /= crossValidation.getK();
-
-        return avgAccuracy + 0.0001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()));
-    }
-
-    /**
-     * This methid is used to return the selected subset of features
-     * @param optimizer The optimizer that is used for FS
-     * @param dataset The dataset to use
-     * @param Fmap The dataset feature map
-     * @param solution The current subset of featurs
-     * @return The selected feature set
-     */
-    static <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int[] solution) {
-        List<String> names = new ArrayList<>();
-        List<Double> scores = new ArrayList<>();
-        for (int i = 0; i < solution.length; i++)
-            if (solution[i] == 1) {
-                names.add(Fmap.get(i).getName());
-                scores.add(1D);
-            }
-        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), optimizer.getProvenance());
-
-        return new SelectedFeatureSet(names, scores, optimizer.isOrdered(), provenance);
-    }
-}

From 2df7c7e6c308f1974f970d12d4d3339e4fb22cd6 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 10 Jul 2023 13:30:34 +0300
Subject: [PATCH 27/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 211 ++++++++++++++----
 1 file changed, 167 insertions(+), 44 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 4d6af02d9..8f6a17e87 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -1,101 +1,124 @@
 package FS_Wrapper_Approaches.Optimizers;
 
-import FS_Wrapper_Approaches.Discreeting.Binarizing;
-import FS_Wrapper_Approaches.Discreeting.TransferFunction;
+import FS.Discreeting.TransferFunction;
 import com.oracle.labs.mlrg.olcut.util.Pair;
-import org.tribuo.*;
+import org.tribuo.Dataset;
+import org.tribuo.FeatureSelector;
+import org.tribuo.ImmutableFeatureMap;
+import org.tribuo.Model;
+import org.tribuo.SelectedFeatureSet;
 import org.tribuo.classification.Label;
+import org.tribuo.classification.ensemble.VotingCombiner;
 import org.tribuo.classification.evaluation.LabelEvaluation;
 import org.tribuo.classification.evaluation.LabelEvaluator;
-import org.tribuo.common.nearest.KNNClassifierOptions;
+import org.tribuo.common.nearest.KNNModel;
+import org.tribuo.common.nearest.KNNTrainer;
 import org.tribuo.dataset.SelectedFeatureDataset;
 import org.tribuo.evaluation.CrossValidation;
+import org.tribuo.math.distance.L1Distance;
+import org.tribuo.math.neighbour.NeighboursQueryFactoryType;
 import org.tribuo.provenance.FeatureSelectorProvenance;
 import org.tribuo.provenance.FeatureSetProvenance;
 import org.tribuo.provenance.impl.FeatureSelectorProvenanceImpl;
 
-import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Random;
+import java.util.SplittableRandom;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
-/**
- * Select features based on Cuckoo Search algorithm with binary transfer functions, KNN classifier and 10-fold cross validation
- * <p>
- * see:
- * <pre>
- * Xin-She Yang and Suash Deb.
- * "Cuckoo Search via L´evy Flights", 2010.
- *
- * L. A. M. Pereira et al.
- * "A Binary Cuckoo Search and its Application for Feature Selection", 2014.
- * </pre>
- */
-public class CuckooSearchOptimizer implements FeatureSelector<Label> {
+public  final class CuckooSearchOptimizer implements FeatureSelector<Label> {
     private final TransferFunction transferFunction;
+    private final int populationSize;
     private final double stepSizeScaling;
     private final double lambda;
     private final double worstNestProbability;
     private final double delta;
-    private final int populationSize;
+    private final double mutationRate;
     private int [][] setOfSolutions;
     private final int maxIteration;
+    private final SplittableRandom rng;
+    private final int seed;
 
     /**
      * The default constructor for feature selection based on Cuckoo Search Algorithm
      */
     public CuckooSearchOptimizer() {
-        this.transferFunction = TransferFunction.TFunction_V2;
+        this.transferFunction = TransferFunction.V2;
         this.populationSize = 50;
         this.stepSizeScaling = 2d;
         this.lambda = 2d;
         this.worstNestProbability = 0.1d;
         this.delta = 1.5d;
+        this.mutationRate = 0.2d;
         this.maxIteration = 30;
+        this.seed = 12345;
+        this.rng = new SplittableRandom(seed);
     }
-    
+
     /**
      * Constructs the wrapper feature selection based on cuckoo search algorithm
      * @param transferFunction The transfer function to convert continuous values to binary ones
      * @param populationSize The size of the solution in the initial population
      * @param maxIteration The number of times that is used to enhance generation
+     * @param seed This seed is required for the SplittableRandom
      */
-    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration) {
+    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration, int seed) {
         this.transferFunction = transferFunction;
         this.populationSize = populationSize;
         this.stepSizeScaling = 2d;
         this.lambda = 2d;
         this.worstNestProbability = 1.5d;
         this.delta = 1.5d;
+        this.mutationRate = 0.2d;
         this.maxIteration = maxIteration;
+        this.seed = seed;
+        this.rng = new SplittableRandom(seed);
     }
 
     /**
+     * Constructs the wrapper feature selection based on cuckoo search algorithm
      * @param transferFunction The transfer function to convert continuous values to binary ones
      * @param populationSize The size of the solution in the initial population
      * @param stepSizeScaling The cuckoo step size
      * @param lambda The lambda of the levy flight function
      * @param worstNestProbability The fraction of the nests to be abandoned
      * @param delta The delta that is used in the abandon nest function
+     * @param mutationRate The proportion to apply the mutation operator
      * @param maxIteration The number of times that is used to enhance generation
+     * @param seed This seed is required for the SplittableRandom
      */
-    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, int maxIteration) {
+    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, double mutationRate, int maxIteration, int seed) {
         this.transferFunction = transferFunction;
         this.populationSize = populationSize;
         this.stepSizeScaling = stepSizeScaling;
         this.lambda = lambda;
         this.worstNestProbability = worstNestProbability;
         this.delta = delta;
+        this.mutationRate = mutationRate;
         this.maxIteration = maxIteration;
+        this.seed = seed;
+        this.rng = new SplittableRandom(seed);
     }
 
     /**
+     * This method is used to generate the initial population (set of solutions)
      * @param totalNumberOfFeatures The number of features in the given dataset
      * @return The population of subsets of selected features
      */
     private int[][] GeneratePopulation(int totalNumberOfFeatures) {
         setOfSolutions = new int[this.populationSize][totalNumberOfFeatures];
-        for (int[] subSet : setOfSolutions)
-            System.arraycopy(new Random().ints(totalNumberOfFeatures, 0, 2).toArray(), 0, subSet, 0, setOfSolutions[0].length);
+        for (int[] subSet : setOfSolutions) {
+            int[] values = new int[subSet.length];
+            for (int i = 0; i < values.length; i++) {
+                values[i] = rng.nextInt(2);
+            }
+            System.arraycopy(values, 0, subSet, 0, setOfSolutions[0].length);
+        }
         return setOfSolutions;
     }
 
@@ -118,40 +141,140 @@ public boolean isOrdered() {
     public SelectedFeatureSet select(Dataset<Label> dataset) {
         ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
         setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
-        List<FeatureSet_FScore_Container> subSet_fScores = new ArrayList<>();
+        List<CuckooSearchFeatureSet> subSet_fScores = Arrays.stream(setOfSolutions).map(setOfSolution -> new CuckooSearchFeatureSet(setOfSolution, evaluateSolution(this, dataset, FMap, setOfSolution))).sorted(Comparator.comparing(CuckooSearchFeatureSet::score).reversed()).collect(Collectors.toList());
         SelectedFeatureSet selectedFeatureSet = null;
-        // Update the solution based on the levy flight function
         for (int i = 0; i < maxIteration; i++) {
             IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
-                AtomicInteger currentIter = new AtomicInteger(subSet);
-                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> Binarizing.discreteValue(transferFunction, x + stepSizeScaling * Math.pow(currentIter.get() + 1, -lambda))).toArray();
-                int[] randomCuckoo = setOfSolutions[new Random().nextInt(setOfSolutions.length)];
-                if (FitnessFunction.EvaluateSolution(this, dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(this, dataset, FMap, randomCuckoo))
-                    System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
+                // Update the solution based on the levy flight function
+                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(subSet + 1, -lambda))).toArray();
+                int[] randomCuckoo = setOfSolutions[rng.nextInt(setOfSolutions.length)];
+                keepBestAfterEvaluation(dataset, FMap, evolvedSolution, randomCuckoo);
                 // Update the solution based on the abandone nest function
                 if (new Random().nextDouble() < worstNestProbability) {
-                    int r1 = new Random().nextInt(setOfSolutions.length);
-                    int r2 = new Random().nextInt(setOfSolutions.length);
-                    for (var j = 0; j < setOfSolutions[subSet].length; j++)
-                        evolvedSolution[j] = Binarizing.discreteValue(transferFunction, setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
-                    if (FitnessFunction.EvaluateSolution(this, dataset, FMap, evolvedSolution) > FitnessFunction.EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet]))
-                        System.arraycopy(evolvedSolution, 0, setOfSolutions[subSet], 0, evolvedSolution.length);
+                    int r1 = rng.nextInt(setOfSolutions.length);
+                    int r2 = rng.nextInt(setOfSolutions.length);
+                    for (int j = 0; j < setOfSolutions[subSet].length; j++) {
+                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
+                    }
+                    keepBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[subSet]);
                 }
-                subSet_fScores.add(new FeatureSet_FScore_Container(setOfSolutions[subSet], FitnessFunction.EvaluateSolution(this, dataset, FMap, setOfSolutions[subSet])));
+                // Update the solution based on mutation operator
+                int[] mutedSolution = mutation(setOfSolutions[subSet]);
+                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet]);
+                // Update the solution based on inversion mutation
+                mutedSolution = inversionMutation(setOfSolutions[subSet]);
+                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet]);
+                // Updata the solution based on mutation operator
+                int[] jayaSolution = jayaOperator(setOfSolutions[subSet], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
+                keepBestAfterEvaluation(dataset, FMap, jayaSolution, setOfSolutions[subSet]);
             });
-            subSet_fScores.sort(Comparator.comparing(FeatureSet_FScore_Container::score).reversed());
-            selectedFeatureSet = FitnessFunction.getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
+            Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, evaluateSolution(this, dataset, FMap, subSet))).forEach(subSet_fScores::add);
+            subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
+            selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
         }
         return selectedFeatureSet;
     }
-    
+
     @Override
     public FeatureSelectorProvenance getProvenance() {
         return new FeatureSelectorProvenanceImpl(this);
     }
 
+    /**
+     * This method is used to compute the fitness score of each solution of the population
+     * @param optimizer The optimizer that is used for FS
+     * @param dataset The dataset to use
+     * @param Fmap The dataset feature map
+     * @param solution The current subset of features
+     * @return The fitness score of the given subset*/
+
+    private  <T extends FeatureSelector<Label>> double evaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
+        SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
+        KNNTrainer<Label> KnnTrainer =  new KNNTrainer<>(1, new L1Distance(), Runtime.getRuntime().availableProcessors(), new VotingCombiner(), KNNModel.Backend.THREADPOOL, NeighboursQueryFactoryType.BRUTE_FORCE);
+        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(KnnTrainer, selectedFeatureDataset, new LabelEvaluator(), 10);
+        double avgAccuracy = 0d;
+        for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate()) {
+            avgAccuracy += ACC.getA().accuracy();
+        }
+        avgAccuracy /= crossValidation.getK();
+
+        return avgAccuracy + 0.001 * (1 - ((double) selectedFeatureDataset.getSelectedFeatures().size() / Fmap.size()));
+    }
+
+    /**
+     * This methid is used to return the selected subset of features
+     * @param optimizer The optimizer that is used for FS
+     * @param dataset The dataset to use
+     * @param featureMap The dataset feature map
+     * @param solution The current subset of featurs
+     * @return The selected feature set*/
+
+    private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap featureMap, int... solution) {
+        List<String> names = new ArrayList<>();
+        List<Double> scores = new ArrayList<>();
+        for (int i = 0; i < solution.length; i++) {
+            if (solution[i] == 1) {
+                names.add(featureMap.get(i).getName());
+                scores.add(1d);
+            }
+        }
+        FeatureSetProvenance provenance = new FeatureSetProvenance(SelectedFeatureSet.class.getName(), dataset.getProvenance(), optimizer.getProvenance());
+
+        return new SelectedFeatureSet(names, scores, optimizer.isOrdered(), provenance);
+    }
+
+    /**
+     * @param dataset The dataset to use
+     * @param FMap The map of selected features
+     * @param alteredSolution The modified solution
+     * @param oldSolution The old solution
+     */
+    private void keepBestAfterEvaluation(Dataset<Label> dataset, ImmutableFeatureMap FMap, int[] alteredSolution, int[] oldSolution) {
+        if (evaluateSolution(this, dataset, FMap, alteredSolution) > evaluateSolution(this, dataset, FMap, oldSolution)) {
+            System.arraycopy(alteredSolution, 0, oldSolution, 0, alteredSolution.length);
+        }
+    }
+
+    /**
+     * @param currentSolution The solution to be altered by the mutation operator
+     * @return The altered solution after mutation
+     */
+    private int[] mutation(int[] currentSolution) {
+        return Arrays.stream(currentSolution).map(x -> ThreadLocalRandom.current().nextDouble() < mutationRate ? 1 - x : x).toArray();
+    }
+
+    /**
+     * @param currentSolution The solution to be altered by the mutation operator
+     * @return The altered solution after inversion mutation
+     */
+    private int[] inversionMutation(int[] currentSolution) {
+        int rand1 = new Random().nextInt(currentSolution.length);
+        int rand2 = new Random().nextInt(currentSolution.length);
+        while (rand1 >= rand2) {
+            rand1 = new Random().nextInt(currentSolution.length);
+            rand2 = new Random().nextInt(currentSolution.length);
+        }
+        for (; rand1 < rand2; rand1++) {
+            currentSolution[rand1] = 1 - currentSolution[rand1];
+        }
+        return currentSolution;
+    }
+
+    /**
+     * @param currentSolution The solution to be altered by the jaya operator
+     * @param currentBest The best solution in the current generation
+     * @param currentWorst The worst solution in the current generation
+     * @return The altered solution after appling jaya operator
+     */
+    private int[] jayaOperator(int[] currentSolution, int[] currentBest, int[] currentWorst) {
+        int[] newSolution = new int[currentSolution.length];
+        Arrays.setAll(newSolution, i -> (int) transferFunction.applyAsDouble(currentSolution[i] + new Random().nextDouble() * (currentBest[i] - currentSolution[i]) -
+                new Random().nextDouble() * (currentWorst[i] - currentSolution[i])));
+        return newSolution;
+    }
+
     /**
      * This record is used to hold subset of features with its corresponding fitness score
      */
-    record FeatureSet_FScore_Container(int[] subSet, double score) { }
+    record CuckooSearchFeatureSet(int[] subSet, double score) { }
 }

From 50be1fb63666815e1b052f07bc44cd250f45ba2f Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 10 Jul 2023 13:57:23 +0300
Subject: [PATCH 28/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 8f6a17e87..bfb05a6e6 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -31,6 +31,19 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+/**
+ * Select features based on Cuckoo Search algorithm with binary transfer functions, KNN classifier and 10-fold cross validation
+ * <p>
+ * see:
+ * <pre>
+ * Xin-She Yang and Suash Deb.
+ * "Cuckoo Search via L´evy Flights", 2010.
+ *
+ * L. A. M. Pereira et al.
+ * "A Binary Cuckoo Search and its Application for Feature Selection", 2014.
+ * </pre>
+ */
+
 public  final class CuckooSearchOptimizer implements FeatureSelector<Label> {
     private final TransferFunction transferFunction;
     private final int populationSize;
@@ -236,6 +249,13 @@ private void keepBestAfterEvaluation(Dataset<Label> dataset, ImmutableFeatureMap
     }
 
     /**
+     * The simple mutation method of Genetic algorithm
+     * <p>
+     * see:
+     * <pre>
+     * Steven Bayer and Lui Wang.
+     * "A Genetic Algorithm Programming Environment: Splicer", 1991.
+     * </pre>
      * @param currentSolution The solution to be altered by the mutation operator
      * @return The altered solution after mutation
      */
@@ -244,6 +264,13 @@ private int[] mutation(int[] currentSolution) {
     }
 
     /**
+     * The inversion mutation
+     * <p>
+     * see:
+     * <pre>
+     * Nitashs Soni and Tapsa Kumar.
+     * "Study of Various Mutation Operators in Genetic Algorithms", 2014.
+     * </pre>
      * @param currentSolution The solution to be altered by the mutation operator
      * @return The altered solution after inversion mutation
      */
@@ -261,6 +288,13 @@ private int[] inversionMutation(int[] currentSolution) {
     }
 
     /**
+     * The main equation of Jaya optimization algorithm
+     * <p>
+     * see:
+     * <pre>
+     * Venkata Rao.
+     * "Jaya: A simple and new optimization algorithm for solving constrained and unconstrained optimization problems", 2016.
+     * </pre>
      * @param currentSolution The solution to be altered by the jaya operator
      * @param currentBest The best solution in the current generation
      * @param currentWorst The worst solution in the current generation

From 96ecc6b5f72924c724927f5ecd2bf4724971b70d Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Mon, 10 Jul 2023 14:12:50 +0300
Subject: [PATCH 29/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 25 ++++++++++---------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index bfb05a6e6..64bfc06f6 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -157,30 +157,31 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
         List<CuckooSearchFeatureSet> subSet_fScores = Arrays.stream(setOfSolutions).map(setOfSolution -> new CuckooSearchFeatureSet(setOfSolution, evaluateSolution(this, dataset, FMap, setOfSolution))).sorted(Comparator.comparing(CuckooSearchFeatureSet::score).reversed()).collect(Collectors.toList());
         SelectedFeatureSet selectedFeatureSet = null;
         for (int i = 0; i < maxIteration; i++) {
-            IntStream.range(0, setOfSolutions.length).parallel().forEach(subSet -> {
+            for (int solution = 0; solution < populationSize; solution++) {
+                AtomicInteger subSet = new AtomicInteger(solution);
                 // Update the solution based on the levy flight function
-                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(subSet + 1, -lambda))).toArray();
+                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet.get()]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(subSet.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[rng.nextInt(setOfSolutions.length)];
                 keepBestAfterEvaluation(dataset, FMap, evolvedSolution, randomCuckoo);
                 // Update the solution based on the abandone nest function
                 if (new Random().nextDouble() < worstNestProbability) {
                     int r1 = rng.nextInt(setOfSolutions.length);
                     int r2 = rng.nextInt(setOfSolutions.length);
-                    for (int j = 0; j < setOfSolutions[subSet].length; j++) {
-                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
+                    for (int j = 0; j < setOfSolutions[subSet.get()].length; j++) {
+                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet.get()][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
                     }
-                    keepBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[subSet]);
+                    keepBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[subSet.get()]);
                 }
                 // Update the solution based on mutation operator
-                int[] mutedSolution = mutation(setOfSolutions[subSet]);
-                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet]);
+                int[] mutedSolution = mutation(setOfSolutions[subSet.get()]);
+                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Update the solution based on inversion mutation
-                mutedSolution = inversionMutation(setOfSolutions[subSet]);
-                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet]);
+                mutedSolution = inversionMutation(setOfSolutions[subSet.get()]);
+                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Updata the solution based on mutation operator
-                int[] jayaSolution = jayaOperator(setOfSolutions[subSet], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
-                keepBestAfterEvaluation(dataset, FMap, jayaSolution, setOfSolutions[subSet]);
-            });
+                int[] jayaSolution = jayaOperator(setOfSolutions[subSet.get()], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
+                keepBestAfterEvaluation(dataset, FMap, jayaSolution, setOfSolutions[subSet.get()]);
+            }
             Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, evaluateSolution(this, dataset, FMap, subSet))).forEach(subSet_fScores::add);
             subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
             selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);

From 21a9c3fe605313fb9f5eff2787725dfbf2f901a0 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Tue, 11 Jul 2023 20:46:56 +0300
Subject: [PATCH 30/39] Update pom.xml

---
 Classification/FeatureSelection/pom.xml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Classification/FeatureSelection/pom.xml b/Classification/FeatureSelection/pom.xml
index bc1e72b94..c59237139 100644
--- a/Classification/FeatureSelection/pom.xml
+++ b/Classification/FeatureSelection/pom.xml
@@ -32,6 +32,11 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>org.ojalgo</groupId>
+            <artifactId>ojalgo</artifactId>
+            <version>53.0.0</version>
+        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>tribuo-core</artifactId>

From fe512aea6e020fe3cf10a027a0897b8bc62b53b2 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Tue, 11 Jul 2023 21:04:33 +0300
Subject: [PATCH 31/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 41 ++++++++++---------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 64bfc06f6..d74046617 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -43,8 +43,8 @@
  * "A Binary Cuckoo Search and its Application for Feature Selection", 2014.
  * </pre>
  */
-
 public  final class CuckooSearchOptimizer implements FeatureSelector<Label> {
+    private final Trainer<Label> trainer;
     private final TransferFunction transferFunction;
     private final int populationSize;
     private final double stepSizeScaling;
@@ -61,6 +61,7 @@ public  final class CuckooSearchOptimizer implements FeatureSelector<Label> {
      * The default constructor for feature selection based on Cuckoo Search Algorithm
      */
     public CuckooSearchOptimizer() {
+        this.trainer =  new KNNTrainer<>(1, new L1Distance(), Runtime.getRuntime().availableProcessors(), new VotingCombiner(), KNNModel.Backend.THREADPOOL, NeighboursQueryFactoryType.BRUTE_FORCE);
         this.transferFunction = TransferFunction.V2;
         this.populationSize = 50;
         this.stepSizeScaling = 2d;
@@ -80,7 +81,8 @@ public CuckooSearchOptimizer() {
      * @param maxIteration The number of times that is used to enhance generation
      * @param seed This seed is required for the SplittableRandom
      */
-    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, int maxIteration, int seed) {
+    public CuckooSearchOptimizer(Trainer<Label> trainer, TransferFunction transferFunction, int populationSize, int maxIteration, int seed) {
+        this.trainer = trainer;
         this.transferFunction = transferFunction;
         this.populationSize = populationSize;
         this.stepSizeScaling = 2d;
@@ -105,7 +107,8 @@ public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSi
      * @param maxIteration The number of times that is used to enhance generation
      * @param seed This seed is required for the SplittableRandom
      */
-    public CuckooSearchOptimizer(TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, double mutationRate, int maxIteration, int seed) {
+    public CuckooSearchOptimizer(Trainer<Label> trainer, TransferFunction transferFunction, int populationSize, double stepSizeScaling, double lambda, double worstNestProbability, double delta, double mutationRate, int maxIteration, int seed) {
+        this.trainer = trainer;
         this.transferFunction = transferFunction;
         this.populationSize = populationSize;
         this.stepSizeScaling = stepSizeScaling;
@@ -137,7 +140,6 @@ private int[][] GeneratePopulation(int totalNumberOfFeatures) {
 
     /**
      * Does this feature selection algorithm return an ordered feature set?
-     *
      * @return True if the set is ordered.
      */
     @Override
@@ -154,7 +156,7 @@ public boolean isOrdered() {
     public SelectedFeatureSet select(Dataset<Label> dataset) {
         ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
         setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
-        List<CuckooSearchFeatureSet> subSet_fScores = Arrays.stream(setOfSolutions).map(setOfSolution -> new CuckooSearchFeatureSet(setOfSolution, evaluateSolution(this, dataset, FMap, setOfSolution))).sorted(Comparator.comparing(CuckooSearchFeatureSet::score).reversed()).collect(Collectors.toList());
+        List<CuckooSearchFeatureSet> subSet_fScores = Arrays.stream(setOfSolutions).map(setOfSolution -> new CuckooSearchFeatureSet(setOfSolution, evaluateSolution(this, trainer,dataset, FMap, setOfSolution))).sorted(Comparator.comparing(CuckooSearchFeatureSet::score).reversed()).collect(Collectors.toList());
         SelectedFeatureSet selectedFeatureSet = null;
         for (int i = 0; i < maxIteration; i++) {
             for (int solution = 0; solution < populationSize; solution++) {
@@ -162,7 +164,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 // Update the solution based on the levy flight function
                 int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet.get()]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(subSet.get() + 1, -lambda))).toArray();
                 int[] randomCuckoo = setOfSolutions[rng.nextInt(setOfSolutions.length)];
-                keepBestAfterEvaluation(dataset, FMap, evolvedSolution, randomCuckoo);
+                keepBestAfterEvaluation(dataset, trainer, FMap, evolvedSolution, randomCuckoo);
                 // Update the solution based on the abandone nest function
                 if (new Random().nextDouble() < worstNestProbability) {
                     int r1 = rng.nextInt(setOfSolutions.length);
@@ -170,19 +172,19 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                     for (int j = 0; j < setOfSolutions[subSet.get()].length; j++) {
                         evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet.get()][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
                     }
-                    keepBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[subSet.get()]);
+                    keepBestAfterEvaluation(dataset, trainer, FMap, evolvedSolution, setOfSolutions[subSet.get()]);
                 }
                 // Update the solution based on mutation operator
                 int[] mutedSolution = mutation(setOfSolutions[subSet.get()]);
-                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Update the solution based on inversion mutation
                 mutedSolution = inversionMutation(setOfSolutions[subSet.get()]);
-                keepBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Updata the solution based on mutation operator
                 int[] jayaSolution = jayaOperator(setOfSolutions[subSet.get()], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
-                keepBestAfterEvaluation(dataset, FMap, jayaSolution, setOfSolutions[subSet.get()]);
+                keepBestAfterEvaluation(dataset, trainer, FMap, jayaSolution, setOfSolutions[subSet.get()]);
             }
-            Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, evaluateSolution(this, dataset, FMap, subSet))).forEach(subSet_fScores::add);
+            Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, evaluateSolution(this, trainer, dataset, FMap, subSet))).forEach(subSet_fScores::add);
             subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
             selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
         }
@@ -200,12 +202,11 @@ public FeatureSelectorProvenance getProvenance() {
      * @param dataset The dataset to use
      * @param Fmap The dataset feature map
      * @param solution The current subset of features
-     * @return The fitness score of the given subset*/
-
-    private  <T extends FeatureSelector<Label>> double evaluateSolution(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
+     * @return The fitness score of the given subset
+     */
+    private  <T extends FeatureSelector<Label>> double evaluateSolution(T optimizer, Trainer<Label> trainer, Dataset<Label> dataset, ImmutableFeatureMap Fmap, int... solution) {
         SelectedFeatureDataset<Label> selectedFeatureDataset = new SelectedFeatureDataset<>(dataset,getSFS(optimizer, dataset, Fmap, solution));
-        KNNTrainer<Label> KnnTrainer =  new KNNTrainer<>(1, new L1Distance(), Runtime.getRuntime().availableProcessors(), new VotingCombiner(), KNNModel.Backend.THREADPOOL, NeighboursQueryFactoryType.BRUTE_FORCE);
-        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(KnnTrainer, selectedFeatureDataset, new LabelEvaluator(), 10);
+        CrossValidation<Label, LabelEvaluation> crossValidation = new CrossValidation<>(trainer, selectedFeatureDataset, new LabelEvaluator(), 10);
         double avgAccuracy = 0d;
         for (Pair<LabelEvaluation, Model<Label>> ACC : crossValidation.evaluate()) {
             avgAccuracy += ACC.getA().accuracy();
@@ -221,8 +222,8 @@ private  <T extends FeatureSelector<Label>> double evaluateSolution(T optimizer,
      * @param dataset The dataset to use
      * @param featureMap The dataset feature map
      * @param solution The current subset of featurs
-     * @return The selected feature set*/
-
+     * @return The selected feature set
+     */
     private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimizer, Dataset<Label> dataset, ImmutableFeatureMap featureMap, int... solution) {
         List<String> names = new ArrayList<>();
         List<Double> scores = new ArrayList<>();
@@ -243,8 +244,8 @@ private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimize
      * @param alteredSolution The modified solution
      * @param oldSolution The old solution
      */
-    private void keepBestAfterEvaluation(Dataset<Label> dataset, ImmutableFeatureMap FMap, int[] alteredSolution, int[] oldSolution) {
-        if (evaluateSolution(this, dataset, FMap, alteredSolution) > evaluateSolution(this, dataset, FMap, oldSolution)) {
+    private void keepBestAfterEvaluation(Dataset<Label> dataset, Trainer<Label> trainer, ImmutableFeatureMap FMap, int[] alteredSolution, int[] oldSolution) {
+        if (evaluateSolution(this, trainer, dataset, FMap, alteredSolution) > evaluateSolution(this, trainer, dataset, FMap, oldSolution)) {
             System.arraycopy(alteredSolution, 0, oldSolution, 0, alteredSolution.length);
         }
     }

From d4a11db650058a954828d059ff38e346d07248f7 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Tue, 11 Jul 2023 22:13:37 +0300
Subject: [PATCH 32/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java                    | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index d74046617..37931f01a 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -76,6 +76,7 @@ public CuckooSearchOptimizer() {
 
     /**
      * Constructs the wrapper feature selection based on cuckoo search algorithm
+     * @param trainer The used trainer in the evaluation process
      * @param transferFunction The transfer function to convert continuous values to binary ones
      * @param populationSize The size of the solution in the initial population
      * @param maxIteration The number of times that is used to enhance generation
@@ -97,13 +98,13 @@ public CuckooSearchOptimizer(Trainer<Label> trainer, TransferFunction transferFu
 
     /**
      * Constructs the wrapper feature selection based on cuckoo search algorithm
+     * @param trainer The used trainer in the evaluation process
      * @param transferFunction The transfer function to convert continuous values to binary ones
      * @param populationSize The size of the solution in the initial population
      * @param stepSizeScaling The cuckoo step size
      * @param lambda The lambda of the levy flight function
      * @param worstNestProbability The fraction of the nests to be abandoned
      * @param delta The delta that is used in the abandon nest function
-     * @param mutationRate The proportion to apply the mutation operator
      * @param maxIteration The number of times that is used to enhance generation
      * @param seed This seed is required for the SplittableRandom
      */
@@ -199,6 +200,7 @@ public FeatureSelectorProvenance getProvenance() {
     /**
      * This method is used to compute the fitness score of each solution of the population
      * @param optimizer The optimizer that is used for FS
+     * @param trainer The used trainer in the evaluation process
      * @param dataset The dataset to use
      * @param Fmap The dataset feature map
      * @param solution The current subset of features
@@ -240,6 +242,7 @@ private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimize
 
     /**
      * @param dataset The dataset to use
+     * @param trainer The used trainer in the evaluation process
      * @param FMap The map of selected features
      * @param alteredSolution The modified solution
      * @param oldSolution The old solution

From f45bde5d60ab3b83a55f7425a1562efd5ec891d2 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Wed, 12 Jul 2023 11:53:26 +0300
Subject: [PATCH 33/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 37 +++++++++++++++----
 1 file changed, 30 insertions(+), 7 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 37931f01a..aaf668d6d 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -69,7 +69,7 @@ public CuckooSearchOptimizer() {
         this.worstNestProbability = 0.1d;
         this.delta = 1.5d;
         this.mutationRate = 0.2d;
-        this.maxIteration = 30;
+        this.maxIteration = 3;
         this.seed = 12345;
         this.rng = new SplittableRandom(seed);
     }
@@ -105,6 +105,7 @@ public CuckooSearchOptimizer(Trainer<Label> trainer, TransferFunction transferFu
      * @param lambda The lambda of the levy flight function
      * @param worstNestProbability The fraction of the nests to be abandoned
      * @param delta The delta that is used in the abandon nest function
+     * @param mutationRate The proportion to apply the mutation operator
      * @param maxIteration The number of times that is used to enhance generation
      * @param seed This seed is required for the SplittableRandom
      */
@@ -167,7 +168,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 int[] randomCuckoo = setOfSolutions[rng.nextInt(setOfSolutions.length)];
                 keepBestAfterEvaluation(dataset, trainer, FMap, evolvedSolution, randomCuckoo);
                 // Update the solution based on the abandone nest function
-                if (new Random().nextDouble() < worstNestProbability) {
+                if (rng.nextDouble() < worstNestProbability) {
                     int r1 = rng.nextInt(setOfSolutions.length);
                     int r2 = rng.nextInt(setOfSolutions.length);
                     for (int j = 0; j < setOfSolutions[subSet.get()].length; j++) {
@@ -181,7 +182,10 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 // Update the solution based on inversion mutation
                 mutedSolution = inversionMutation(setOfSolutions[subSet.get()]);
                 keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
-                // Updata the solution based on mutation operator
+                // Update the solution based on swapped mutation
+                mutedSolution = swappedMutation(setOfSolutions[subSet.get()]);
+                keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                // Updata the solution based on Jaya operator
                 int[] jayaSolution = jayaOperator(setOfSolutions[subSet.get()], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
                 keepBestAfterEvaluation(dataset, trainer, FMap, jayaSolution, setOfSolutions[subSet.get()]);
             }
@@ -264,7 +268,7 @@ private void keepBestAfterEvaluation(Dataset<Label> dataset, Trainer<Label> trai
      * @param currentSolution The solution to be altered by the mutation operator
      * @return The altered solution after mutation
      */
-    private int[] mutation(int[] currentSolution) {
+    private int[] mutation(int... currentSolution) {
         return Arrays.stream(currentSolution).map(x -> ThreadLocalRandom.current().nextDouble() < mutationRate ? 1 - x : x).toArray();
     }
 
@@ -279,7 +283,7 @@ private int[] mutation(int[] currentSolution) {
      * @param currentSolution The solution to be altered by the mutation operator
      * @return The altered solution after inversion mutation
      */
-    private int[] inversionMutation(int[] currentSolution) {
+    private int[] inversionMutation(int... currentSolution) {
         int rand1 = new Random().nextInt(currentSolution.length);
         int rand2 = new Random().nextInt(currentSolution.length);
         while (rand1 >= rand2) {
@@ -292,6 +296,26 @@ private int[] inversionMutation(int[] currentSolution) {
         return currentSolution;
     }
 
+    /**
+     * Sswapped mutation
+     * <p>
+     * see:
+     * <pre>
+     * Ming-Wen Tsai et al.
+     * "A Two-Dimensional Genetic Algorithm and Its Application to Aircraft Scheduling Problem", 2015.
+     * </pre>
+     * @param currentSolution The solution to be altered by the mutation operator
+     * @return The altered solution after swapped mutation
+     */
+    private int[] swappedMutation(int... currentSolution) {
+        int firstGeneIndex = new Random().nextInt(currentSolution.length);
+        int secondGeneIndex = new Random().nextInt(currentSolution.length);
+        int secondGene = currentSolution[secondGeneIndex];
+        currentSolution[secondGeneIndex] = currentSolution[firstGeneIndex];
+        currentSolution[firstGeneIndex] = secondGene;
+        return currentSolution;
+    }
+
     /**
      * The main equation of Jaya optimization algorithm
      * <p>
@@ -307,8 +331,7 @@ private int[] inversionMutation(int[] currentSolution) {
      */
     private int[] jayaOperator(int[] currentSolution, int[] currentBest, int[] currentWorst) {
         int[] newSolution = new int[currentSolution.length];
-        Arrays.setAll(newSolution, i -> (int) transferFunction.applyAsDouble(currentSolution[i] + new Random().nextDouble() * (currentBest[i] - currentSolution[i]) -
-                new Random().nextDouble() * (currentWorst[i] - currentSolution[i])));
+        Arrays.setAll(newSolution, i -> (int) transferFunction.applyAsDouble(currentSolution[i] + new Random().nextDouble() * (currentBest[i] - currentSolution[i]) - new Random().nextDouble() * (currentWorst[i] - currentSolution[i])));
         return newSolution;
     }
 

From 7670a28f974649ed1dafaea1edccda1bcd4b89f7 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sun, 16 Jul 2023 10:20:50 +0300
Subject: [PATCH 34/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java                     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index aaf668d6d..737807fa4 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -190,9 +190,9 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
                 keepBestAfterEvaluation(dataset, trainer, FMap, jayaSolution, setOfSolutions[subSet.get()]);
             }
             Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, evaluateSolution(this, trainer, dataset, FMap, subSet))).forEach(subSet_fScores::add);
-            subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
-            selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
         }
+         subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
+         selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
         return selectedFeatureSet;
     }
 

From 0993bc0b92e71aedaa593d8aeff191e5cf3e0bda Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Sun, 23 Jul 2023 23:22:51 +0300
Subject: [PATCH 35/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 24 +++++++++++--------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 737807fa4..bcd495549 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -284,16 +284,18 @@ private int[] mutation(int... currentSolution) {
      * @return The altered solution after inversion mutation
      */
     private int[] inversionMutation(int... currentSolution) {
-        int rand1 = new Random().nextInt(currentSolution.length);
-        int rand2 = new Random().nextInt(currentSolution.length);
+        int[] solution = new int[currentSolution.length];
+        System.arraycopy(currentSolution, 0, solution, 0, solution.length);
+        int rand1 = new Random().nextInt(solution.length);
+        int rand2 = new Random().nextInt(solution.length);
         while (rand1 >= rand2) {
-            rand1 = new Random().nextInt(currentSolution.length);
-            rand2 = new Random().nextInt(currentSolution.length);
+            rand1 = new Random().nextInt(solution.length);
+            rand2 = new Random().nextInt(solution.length);
         }
         for (; rand1 < rand2; rand1++) {
-            currentSolution[rand1] = 1 - currentSolution[rand1];
+            solution[rand1] = 1 - solution[rand1];
         }
-        return currentSolution;
+        return solution;
     }
 
     /**
@@ -308,12 +310,14 @@ private int[] inversionMutation(int... currentSolution) {
      * @return The altered solution after swapped mutation
      */
     private int[] swappedMutation(int... currentSolution) {
+        int[] solution = new int[currentSolution.length];
+        System.arraycopy(currentSolution, 0, solution, 0, solution.length);
         int firstGeneIndex = new Random().nextInt(currentSolution.length);
         int secondGeneIndex = new Random().nextInt(currentSolution.length);
-        int secondGene = currentSolution[secondGeneIndex];
-        currentSolution[secondGeneIndex] = currentSolution[firstGeneIndex];
-        currentSolution[firstGeneIndex] = secondGene;
-        return currentSolution;
+        int secondGene = solution[secondGeneIndex];
+        solution[secondGeneIndex] = solution[firstGeneIndex];
+        solution[firstGeneIndex] = secondGene;
+        return solution;
     }
 
     /**

From 9038ef4550e010873f5c920d87807a466250e289 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Wed, 9 Aug 2023 01:11:25 +0300
Subject: [PATCH 36/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 45 ++++++++++---------
 1 file changed, 25 insertions(+), 20 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index bcd495549..f3bc9d227 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -157,42 +157,45 @@ public boolean isOrdered() {
     @Override
     public SelectedFeatureSet select(Dataset<Label> dataset) {
         ImmutableFeatureMap FMap = new ImmutableFeatureMap(dataset.getFeatureMap());
-        setOfSolutions = GeneratePopulation(dataset.getFeatureMap().size());
-        List<CuckooSearchFeatureSet> subSet_fScores = Arrays.stream(setOfSolutions).map(setOfSolution -> new CuckooSearchFeatureSet(setOfSolution, evaluateSolution(this, trainer,dataset, FMap, setOfSolution))).sorted(Comparator.comparing(CuckooSearchFeatureSet::score).reversed()).collect(Collectors.toList());
-        SelectedFeatureSet selectedFeatureSet = null;
-        for (int i = 0; i < maxIteration; i++) {
-            for (int solution = 0; solution < populationSize; solution++) {
+        setOfSolutions = generatePopulation(FMap.size());
+        List<CuckooSearchFeatureSet> subSet_fScores = new ArrayList<>();
+        SelectedFeatureSet selectedFeatureSet;
+        for (int iter = 0; iter < maxIteration; iter++) {
+            for (int solution = 0; solution < setOfSolutions.length; solution++) {
                 AtomicInteger subSet = new AtomicInteger(solution);
+                int[] evolvedSolution = new int[setOfSolutions[0].length];
                 // Update the solution based on the levy flight function
-                int[] evolvedSolution = Arrays.stream(setOfSolutions[subSet.get()]).map(x -> (int) transferFunction.applyAsDouble(x + stepSizeScaling * Math.pow(subSet.get() + 1, -lambda))).toArray();
+                for (int i = 0; i < setOfSolutions[0].length; i++) {
+                    evolvedSolution[i] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet.get()][i] + stepSizeScaling * Math.pow(subSet.get() + 1, -lambda));
+                }
                 int[] randomCuckoo = setOfSolutions[rng.nextInt(setOfSolutions.length)];
-                keepBestAfterEvaluation(dataset, trainer, FMap, evolvedSolution, randomCuckoo);
+                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, FMap, evolvedSolution, randomCuckoo);
                 // Update the solution based on the abandone nest function
-                if (rng.nextDouble() < worstNestProbability) {
+                if (new Random().nextDouble() < worstNestProbability) {
                     int r1 = rng.nextInt(setOfSolutions.length);
                     int r2 = rng.nextInt(setOfSolutions.length);
-                    for (int j = 0; j < setOfSolutions[subSet.get()].length; j++) {
+                    for (int j = 0; j < setOfSolutions[0].length; j++) {
                         evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet.get()][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
                     }
-                    keepBestAfterEvaluation(dataset, trainer, FMap, evolvedSolution, setOfSolutions[subSet.get()]);
+                    setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[subSet.get()]);
                 }
                 // Update the solution based on mutation operator
                 int[] mutedSolution = mutation(setOfSolutions[subSet.get()]);
-                keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                 setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Update the solution based on inversion mutation
                 mutedSolution = inversionMutation(setOfSolutions[subSet.get()]);
-                keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Update the solution based on swapped mutation
                 mutedSolution = swappedMutation(setOfSolutions[subSet.get()]);
-                keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
                 // Updata the solution based on Jaya operator
                 int[] jayaSolution = jayaOperator(setOfSolutions[subSet.get()], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
-                keepBestAfterEvaluation(dataset, trainer, FMap, jayaSolution, setOfSolutions[subSet.get()]);
+                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, jayaSolution, setOfSolutions[subSet.get()]);
             }
-            Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, evaluateSolution(this, trainer, dataset, FMap, subSet))).forEach(subSet_fScores::add);
+            Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, FN.EvaluateSolution(this, dataset, FMap, subSet))).forEach(subSet_fScores::add);
         }
-         subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
-         selectedFeatureSet = getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
+        subSet_fScores.sort(Comparator.comparing(CuckooSearchFeatureSet::score).reversed());
+        selectedFeatureSet = FN.getSFS(this, dataset, FMap, subSet_fScores.get(0).subSet);
         return selectedFeatureSet;
     }
 
@@ -251,10 +254,12 @@ private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimize
      * @param alteredSolution The modified solution
      * @param oldSolution The old solution
      */
-    private void keepBestAfterEvaluation(Dataset<Label> dataset, Trainer<Label> trainer, ImmutableFeatureMap FMap, int[] alteredSolution, int[] oldSolution) {
-        if (evaluateSolution(this, trainer, dataset, FMap, alteredSolution) > evaluateSolution(this, trainer, dataset, FMap, oldSolution)) {
-            System.arraycopy(alteredSolution, 0, oldSolution, 0, alteredSolution.length);
+   public int[] keepBestAfterEvaluation(Dataset<Label> dataset, ImmutableFeatureMap FMap, int[] alteredSolution, int... oldSolution) {
+        if (FN.EvaluateSolution(this, dataset, FMap, alteredSolution) > FN.EvaluateSolution(this, dataset, FMap, oldSolution)) {
+            return alteredSolution;
         }
+        else
+            return oldSolution;
     }
 
     /**

From 76dc7154b40ac40e9e46331e83724bb8d032b781 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Thu, 10 Aug 2023 01:40:22 +0300
Subject: [PATCH 37/39] Update CuckooSearchOptimizer.java

---
 .../Optimizers/CuckooSearchOptimizer.java     | 23 +++++++++----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index f3bc9d227..226edb042 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -162,35 +162,34 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
         SelectedFeatureSet selectedFeatureSet;
         for (int iter = 0; iter < maxIteration; iter++) {
             for (int solution = 0; solution < setOfSolutions.length; solution++) {
-                AtomicInteger subSet = new AtomicInteger(solution);
                 int[] evolvedSolution = new int[setOfSolutions[0].length];
-                // Update the solution based on the levy flight function
+                // Update the solution based on the levy flight function 0.5 + 0.8 * (new Random().nextGaussian() / Math.pow(Math.abs(new Random().nextGaussian()), 1.0 / 3.0))
                 for (int i = 0; i < setOfSolutions[0].length; i++) {
-                    evolvedSolution[i] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet.get()][i] + stepSizeScaling * Math.pow(subSet.get() + 1, -lambda));
+                    evolvedSolution[i] = (int) transferFunction.applyAsDouble(setOfSolutions[solution][i] + stepSizeScaling * Math.pow(solution + 1, -lambda));
                 }
-                int[] randomCuckoo = setOfSolutions[rng.nextInt(setOfSolutions.length)];
-                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, FMap, evolvedSolution, randomCuckoo);
+                int randomCuckooIndex = rng.nextInt(setOfSolutions.length);
+                System.arraycopy(retrieveBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[randomCuckooIndex]), 0, setOfSolutions[randomCuckooIndex], 0, setOfSolutions[randomCuckooIndex].length);
                 // Update the solution based on the abandone nest function
                 if (new Random().nextDouble() < worstNestProbability) {
                     int r1 = rng.nextInt(setOfSolutions.length);
                     int r2 = rng.nextInt(setOfSolutions.length);
                     for (int j = 0; j < setOfSolutions[0].length; j++) {
-                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[subSet.get()][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
+                        evolvedSolution[j] = (int) transferFunction.applyAsDouble(setOfSolutions[solution][j] + delta * (setOfSolutions[r1][j] - setOfSolutions[r2][j]));
                     }
-                    setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[subSet.get()]);
+                    System.arraycopy(retrieveBestAfterEvaluation(dataset, FMap, evolvedSolution, setOfSolutions[solution]), 0, setOfSolutions[solution], 0, setOfSolutions[solution].length);
                 }
                 // Update the solution based on mutation operator
                 int[] mutedSolution = mutation(setOfSolutions[subSet.get()]);
-                 setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                System.arraycopy(retrieveBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[solution]), 0, setOfSolutions[solution], 0, setOfSolutions[solution].length);
                 // Update the solution based on inversion mutation
                 mutedSolution = inversionMutation(setOfSolutions[subSet.get()]);
-                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                System.arraycopy(retrieveBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[solution]), 0, setOfSolutions[solution], 0, setOfSolutions[solution].length);
                 // Update the solution based on swapped mutation
                 mutedSolution = swappedMutation(setOfSolutions[subSet.get()]);
-                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, mutedSolution, setOfSolutions[subSet.get()]);
+                System.arraycopy(retrieveBestAfterEvaluation(dataset, FMap, mutedSolution, setOfSolutions[solution]), 0, setOfSolutions[solution], 0, setOfSolutions[solution].length);
                 // Updata the solution based on Jaya operator
                 int[] jayaSolution = jayaOperator(setOfSolutions[subSet.get()], subSet_fScores.get(0).subSet(), subSet_fScores.get(subSet_fScores.size() - 1).subSet());
-                setOfSolutions[subSet.get()] = keepBestAfterEvaluation(dataset, trainer, FMap, jayaSolution, setOfSolutions[subSet.get()]);
+                System.arraycopy(retrieveBestAfterEvaluation(dataset, FMap, jayaSolution, setOfSolutions[solution]), 0, setOfSolutions[solution], 0, setOfSolutions[solution].length);
             }
             Arrays.stream(setOfSolutions).map(subSet -> new CuckooSearchFeatureSet(subSet, FN.EvaluateSolution(this, dataset, FMap, subSet))).forEach(subSet_fScores::add);
         }
@@ -254,7 +253,7 @@ private  <T extends FeatureSelector<Label>> SelectedFeatureSet getSFS(T optimize
      * @param alteredSolution The modified solution
      * @param oldSolution The old solution
      */
-   public int[] keepBestAfterEvaluation(Dataset<Label> dataset, ImmutableFeatureMap FMap, int[] alteredSolution, int... oldSolution) {
+   public int[] retrieveBestAfterEvaluation(Dataset<Label> dataset, ImmutableFeatureMap FMap, int[] alteredSolution, int... oldSolution) {
         if (FN.EvaluateSolution(this, dataset, FMap, alteredSolution) > FN.EvaluateSolution(this, dataset, FMap, oldSolution)) {
             return alteredSolution;
         }

From 28509c025a66b52c70ccd6c0e33ffd21c529f464 Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Thu, 10 Aug 2023 01:40:51 +0300
Subject: [PATCH 38/39] Update CuckooSearchOptimizer.java


From 2910d99bfd03e5fee853cf0813ca7cf42b3bb16b Mon Sep 17 00:00:00 2001
From: Mohammed Al-Eiadeh
 <93108547+Mohammed-Ryiad-Eiadeh@users.noreply.github.com>
Date: Fri, 11 Aug 2023 00:13:43 +0300
Subject: [PATCH 39/39] Update CuckooSearchOptimizer.java

---
 .../FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
index 226edb042..2c6a80492 100644
--- a/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
+++ b/Classification/FeatureSelection/src/main/java/org/tribuo/classification/fs/FS_Wrapper_Approaches/Optimizers/CuckooSearchOptimizer.java
@@ -163,7 +163,7 @@ public SelectedFeatureSet select(Dataset<Label> dataset) {
         for (int iter = 0; iter < maxIteration; iter++) {
             for (int solution = 0; solution < setOfSolutions.length; solution++) {
                 int[] evolvedSolution = new int[setOfSolutions[0].length];
-                // Update the solution based on the levy flight function 0.5 + 0.8 * (new Random().nextGaussian() / Math.pow(Math.abs(new Random().nextGaussian()), 1.0 / 3.0))
+                // Update the solution based on the levy flight function
                 for (int i = 0; i < setOfSolutions[0].length; i++) {
                     evolvedSolution[i] = (int) transferFunction.applyAsDouble(setOfSolutions[solution][i] + stepSizeScaling * Math.pow(solution + 1, -lambda));
                 }