> options = new ArrayList<>();
+
+ for (Option option : super.options()) {
+ if (option.getKey() != DEFAULT_HEURISTIC
+ && option.getKey() != DYNAMIC_HEURISTIC) {
+ options.add(option);
+ }
+ }
+
+ // percentage of bagged features
+ options.add(new DoubleOption(DEFAULT_FEATURE_BAGGING,
+ "fb",
+ "specify the percentage of feature bagging %s",
+ "value"));
+
+ // percentage of bagged features
+ options.add(new IntegerOption(DEFAULT_COLONIES,
+ "ec",
+ "specify the number of different colonies %s",
+ "value"));
+
+ // percentage of bagged instances
+ options.add(new DoubleOption(DEFAULT_INSTANCE_BOOTSTRAPPING,
+ "ib",
+ "specify the percentage of instance bagging %s",
+ "value"));
+
+ // percentage of bagged instances
+ options.add(new DoubleOption(DEFAULT_VALIDATION,
+ "va",
+ "specify the percentage of the dataset to be used for validation %s",
+ "value"));
+
+ return options;
+ }
+
+ @Override
+ public ClassificationModel train(Dataset dataset) {
+ int colonies = CONFIG.get(DEFAULT_COLONIES);
+ EnsembleModel model = new EnsembleModel();
+
+ for(int i=0 ; i < colonies;i++) {
+ Dataset set = InstanceBootstrapping.bootstrapping(dataset,true);
+ set.setMask(FeatureBagging.generateBaggingMask(dataset.attributes().length));
+ SequentialCovering seco = new SequentialCovering();
+ model.add(new ClassificationModel(seco.train(dataset, new Graph(dataset))));
+ }
+ model.setQuality(dataset);
+ return new ClassificationModel(model);
+ }
+
+ @Override
+ public String description() {
+ return "Ensemble Mixed-Attribute Ant-Miner";
+ }
+
+ /**
+ * Ant-MinerHMA entry point.
+ *
+ * @param args
+ * command-line arguments.
+ *
+ * @throws Exception
+ * If an error occurs — e.g., I/O error.
+ */
+ public static void main(String[] args) throws Exception {
+ EnsembleMixedAttributeAntMiner algorithm = new EnsembleMixedAttributeAntMiner();
+ algorithm.run(args);
+ }
+}
diff --git a/src/main/java/myra/algorithm/EnsemblePittsburghContinuousAntMiner.java b/src/main/java/myra/algorithm/EnsemblePittsburghContinuousAntMiner.java
new file mode 100644
index 0000000..9841c76
--- /dev/null
+++ b/src/main/java/myra/algorithm/EnsemblePittsburghContinuousAntMiner.java
@@ -0,0 +1,153 @@
+/*
+ * EnsembleMixedAttributeAntMiner.java
+ * (this file is part of MYRA)
+ *
+ * Copyright 2008-2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package myra.algorithm;
+
+import static myra.Config.CONFIG;
+import static myra.Scheduler.COLONY_SIZE;
+import static myra.rule.Heuristic.DEFAULT_HEURISTIC;
+import static myra.rule.Heuristic.DYNAMIC_HEURISTIC;
+
+import static myra.ensemble.bagging.EnsembleModel.DEFAULT_COLONIES;
+import static myra.ensemble.bagging.FeatureBagging.DEFAULT_FEATURE_BAGGING;
+import static myra.ensemble.bagging.InstanceBootstrapping.DEFAULT_INSTANCE_BOOTSTRAPPING;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import myra.IterativeActivity;
+import myra.Option;
+import myra.Scheduler;
+import myra.Option.DoubleOption;
+import myra.Option.IntegerOption;
+
+import myra.classification.ClassificationModel;
+
+import myra.datamining.Dataset;
+import myra.ensemble.bagging.BaggingLevelRuleFactory;
+import myra.ensemble.bagging.EnsembleModel;
+import myra.ensemble.bagging.FeatureBagging;
+import myra.ensemble.bagging.InstanceBootstrapping;
+import myra.rule.RuleList;
+import myra.rule.Graph;
+import myra.rule.pittsburgh.FindRuleListActivity;
+import myra.rule.pittsburgh.LevelPheromonePolicy;
+
+/**
+ * This class represents the ecAnt-MinerPB
+ * implementation, as described in the paper:
+ *
+ *
+ * @ARTICLE{Brookhouse2025ensemble,
+ * author = {J. Brookhouse and A. Helal and F.E.B. Otero},
+ * title = {An Ensemble Ant Colony Optimisation Algorithm with a Hybrid Pheromone Model for Learning Rule Lists},
+ * journal = {Genetic and Evolutionary Computation Conference (GECCO '25)},
+ * year = {2025},
+ * pages = {1--9}
+ * }
+ *
+ *
+ * @author Ayah Helal
+ * @author James Brookhouse
+ */
+public class EnsemblePittsburghContinuousAntMiner extends PittsburghContinuousAntMiner {
+
+ @Override
+ protected void defaults() {
+ super.defaults();
+ // default configuration values
+ CONFIG.set(DEFAULT_FEATURE_BAGGING, 0.4);
+ CONFIG.set(DEFAULT_INSTANCE_BOOTSTRAPPING, 0.4);
+ CONFIG.set(DEFAULT_COLONIES, 10);
+ CONFIG.set(COLONY_SIZE, 10);
+ }
+
+ @Override
+ protected Collection> options() {
+ ArrayList> options = new ArrayList<>();
+
+ for (Option option : super.options()) {
+ if (option.getKey() != DEFAULT_HEURISTIC
+ && option.getKey() != DYNAMIC_HEURISTIC) {
+ options.add(option);
+ }
+ }
+
+ // percentage of bagged features
+ options.add(new DoubleOption(DEFAULT_FEATURE_BAGGING,
+ "fb",
+ "specify the percentage of feature bagging %s",
+ "value"));
+
+ // percentage of bagged features
+ options.add(new IntegerOption(DEFAULT_COLONIES,
+ "ec",
+ "specify the number of different colonies %s",
+ "value"));
+
+ // percentage of bagged instances
+ options.add(new DoubleOption(DEFAULT_INSTANCE_BOOTSTRAPPING,
+ "ib",
+ "specify the percentage of instance bagging %s",
+ "value"));
+ return options;
+ }
+
+ @Override
+ public ClassificationModel train(Dataset dataset) {
+ int colonies = CONFIG.get(DEFAULT_COLONIES);
+ EnsembleModel model = new EnsembleModel();
+
+ for(int i=0 ; i < colonies;i++) {
+ Dataset set = InstanceBootstrapping.bootstrapping(dataset,true);
+ set.setMask(FeatureBagging.generateBaggingMask(dataset.attributes().length));
+ IterativeActivity activity =
+ new FindRuleListActivity(new Graph(dataset),
+ dataset,
+ new BaggingLevelRuleFactory(),
+ new LevelPheromonePolicy());
+
+ Scheduler scheduler = Scheduler.newInstance(1);
+ scheduler.setActivity(activity);
+ scheduler.run();
+ model.add(new ClassificationModel(activity.getBest()));
+ }
+ model.setQuality(dataset);
+ return new ClassificationModel(model);
+ }
+
+ @Override
+ public String description() {
+ return "Ensemble Pittsburgh Continuous-Attribute Ant-Miner";
+ }
+
+ /**
+ * ecAnt-MinerPB entry point.
+ *
+ * @param args
+ * command-line arguments.
+ *
+ * @throws Exception
+ * If an error occurs — e.g., I/O error.
+ */
+ public static void main(String[] args) throws Exception {
+ EnsemblePittsburghContinuousAntMiner algorithm = new EnsemblePittsburghContinuousAntMiner();
+ algorithm.run(args);
+ }
+}
diff --git a/src/main/java/myra/algorithm/EnsemblePittsburghMixedAttributeAntMiner.java b/src/main/java/myra/algorithm/EnsemblePittsburghMixedAttributeAntMiner.java
new file mode 100644
index 0000000..7e6c4a2
--- /dev/null
+++ b/src/main/java/myra/algorithm/EnsemblePittsburghMixedAttributeAntMiner.java
@@ -0,0 +1,159 @@
+/*
+ * EnsembleMixedAttributeAntMiner.java
+ * (this file is part of MYRA)
+ *
+ * Copyright 2008-2020 ahh209
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package myra.algorithm;
+
+
+import static myra.Config.CONFIG;
+import static myra.Scheduler.COLONY_SIZE;
+import static myra.rule.Heuristic.DEFAULT_HEURISTIC;
+import static myra.rule.Heuristic.DYNAMIC_HEURISTIC;
+
+import static myra.rule.irl.RuleFactory.DEFAULT_FACTORY;
+import static myra.ensemble.bagging.EnsembleModel.DEFAULT_COLONIES;
+import static myra.ensemble.bagging.FeatureBagging.DEFAULT_FEATURE_BAGGING;
+import static myra.ensemble.bagging.InstanceBootstrapping.DEFAULT_INSTANCE_BOOTSTRAPPING;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import myra.IterativeActivity;
+import myra.Option;
+import myra.Scheduler;
+import myra.Option.DoubleOption;
+import myra.Option.IntegerOption;
+
+import myra.classification.ClassificationModel;
+
+import myra.datamining.Dataset;
+import myra.ensemble.bagging.BaggingArchiveRuleFactory;
+import myra.ensemble.bagging.EnsembleModel;
+import myra.ensemble.bagging.FeatureBagging;
+import myra.ensemble.bagging.InstanceBootstrapping;
+import myra.rule.RuleList;
+import myra.rule.archive.ArchivePheromonePolicy;
+import myra.rule.archive.Graph;
+import myra.rule.pittsburgh.FindRuleListActivity;
+
+/**
+ * This class represents the eAnt-MinerPB + HMA
+ * implementation, as described in the paper:
+ *
+ *
+ * @INPROCEEDINGS{Brookhouse2025ensemble
+ * author = {J. Brookhouse and A. Helal and F.E.B. Otero},
+ * title = {An Ensemble Ant Colony Optimisation Algorithm with a Hybrid Pheromone Model for Learning Rule Lists},
+ * booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference (GECCO '25)},
+ * publisher = {Association for Computing Machinery}
+ * year = {2025},
+ * pages = {1532--1539}
+ * }
+ *
+ *
+ * @author Ayah Helal
+ * @author James Brookhouse
+ */
+public class EnsemblePittsburghMixedAttributeAntMiner extends PittsburghMixedAttributeAntMiner {
+
+ @Override
+ protected void defaults() {
+ super.defaults();
+ // configuration not set via command line
+ CONFIG.set(DEFAULT_FACTORY, new BaggingArchiveRuleFactory());
+
+ // default configuration values
+ CONFIG.set(DEFAULT_FEATURE_BAGGING, 0.4);
+ CONFIG.set(DEFAULT_INSTANCE_BOOTSTRAPPING, 0.4);
+ CONFIG.set(DEFAULT_COLONIES, 10);
+ CONFIG.set(COLONY_SIZE, 10);
+ }
+
+ @Override
+ protected Collection> options() {
+ ArrayList> options = new ArrayList<>();
+
+ for (Option option : super.options()) {
+ if (option.getKey() != DEFAULT_HEURISTIC
+ && option.getKey() != DYNAMIC_HEURISTIC) {
+ options.add(option);
+ }
+ }
+
+ // percentage of bagged features
+ options.add(new DoubleOption(DEFAULT_FEATURE_BAGGING,
+ "fb",
+ "specify the percentage of feature bagging %s",
+ "value"));
+
+ // percentage of bagged features
+ options.add(new IntegerOption(DEFAULT_COLONIES,
+ "ec",
+ "specify the number of different colonies %s",
+ "value"));
+
+ // percentage of bagged instances
+ options.add(new DoubleOption(DEFAULT_INSTANCE_BOOTSTRAPPING,
+ "ib",
+ "specify the percentage of instance bagging %s",
+ "value"));
+ return options;
+ }
+
+ @Override
+ public ClassificationModel train(Dataset dataset) {
+ int colonies = CONFIG.get(DEFAULT_COLONIES);
+ EnsembleModel model = new EnsembleModel();
+
+ for(int i=0 ; i < colonies;i++) {
+ Dataset set = InstanceBootstrapping.bootstrapping(dataset,true);
+ set.setMask(FeatureBagging.generateBaggingMask(dataset.attributes().length));
+ IterativeActivity activity =
+ new FindRuleListActivity(new Graph(dataset),
+ set,
+ new BaggingArchiveRuleFactory(),
+ new ArchivePheromonePolicy());
+
+ Scheduler scheduler = Scheduler.newInstance(1);
+ scheduler.setActivity(activity);
+ scheduler.run();
+ model.add(new ClassificationModel(activity.getBest()));
+ }
+ model.setQuality(dataset);
+ return new ClassificationModel(model);
+ }
+
+ @Override
+ public String description() {
+ return "Ensemble Pittsburgh Mixed-Attribute Ant-Miner";
+ }
+
+ /**
+ * ecAnt-MinerPB + HMA entry point.
+ *
+ * @param args
+ * command-line arguments.
+ *
+ * @throws Exception
+ * If an error occurs — e.g., I/O error.
+ */
+ public static void main(String[] args) throws Exception {
+ EnsemblePittsburghMixedAttributeAntMiner algorithm = new EnsemblePittsburghMixedAttributeAntMiner();
+ algorithm.run(args);
+ }
+}
diff --git a/src/main/java/myra/algorithm/MixedAttributeAntMiner.java b/src/main/java/myra/algorithm/MixedAttributeAntMiner.java
index 2d56bd2..78b404c 100644
--- a/src/main/java/myra/algorithm/MixedAttributeAntMiner.java
+++ b/src/main/java/myra/algorithm/MixedAttributeAntMiner.java
@@ -20,6 +20,7 @@
package myra.algorithm;
import static myra.Archive.ARCHIVE_SIZE;
+import static myra.Scheduler.COLONY_SIZE;
import static myra.Archive.DEFAULT_Q;
import static myra.Archive.Q;
import static myra.Config.CONFIG;
@@ -33,6 +34,7 @@
import static myra.rule.pittsburgh.LevelPheromonePolicy.P_BEST;
import static myra.rule.irl.RuleFactory.DEFAULT_FACTORY;
import static myra.rule.irl.PheromonePolicy.DEFAULT_POLICY;
+import static myra.IterativeActivity.MAX_ITERATIONS;
import java.util.ArrayList;
import java.util.Collection;
@@ -43,6 +45,7 @@
import myra.classification.ClassificationModel;
import myra.classification.rule.SinglePassPruner;
import myra.datamining.Dataset;
+import myra.rule.BacktrackPruner;
import myra.rule.Heuristic;
import myra.rule.Pruner;
import myra.rule.archive.ArchivePheromonePolicy;
@@ -79,7 +82,8 @@ protected void defaults() {
super.defaults();
// configuration not set via command line
-
+ CONFIG.set(COLONY_SIZE, 5);
+ CONFIG.set(MAX_ITERATIONS, 1000);
CONFIG.set(P_BEST, 0.05);
CONFIG.set(DEFAULT_HEURISTIC, new Heuristic.None());
CONFIG.set(DEFAULT_FACTORY, new ArchiveRuleFactory());
@@ -89,8 +93,8 @@ protected void defaults() {
// default configuration values
CONFIG.set(EVAPORATION_FACTOR, 0.9);
- CONFIG.set(DEFAULT_PRUNER, new SinglePassPruner());
- CONFIG.set(ARCHIVE_SIZE, 20);
+ CONFIG.set(DEFAULT_PRUNER, new BacktrackPruner());
+ CONFIG.set(ARCHIVE_SIZE, 39);
CONFIG.set(Q, DEFAULT_Q);
CONFIG.set(CONVERGENCE_SPEED, DEFAULT_CONVERGENCE_SPEED);
}
diff --git a/src/main/java/myra/algorithm/PittsburghContinuousAntMiner.java b/src/main/java/myra/algorithm/PittsburghContinuousAntMiner.java
index 5b302d0..03b9b2c 100644
--- a/src/main/java/myra/algorithm/PittsburghContinuousAntMiner.java
+++ b/src/main/java/myra/algorithm/PittsburghContinuousAntMiner.java
@@ -65,6 +65,7 @@
import myra.classification.rule.MajorityAssignator;
import myra.classification.rule.PessimisticAccuracy;
import myra.classification.rule.RuleClassifier;
+import myra.classification.rule.SinglePassPruner;
import myra.classification.rule.function.Laplace;
import myra.classification.rule.function.MEstimate;
import myra.classification.rule.function.SensitivitySpecificity;
@@ -131,7 +132,7 @@ protected void defaults() {
// default configuration values
- CONFIG.set(COLONY_SIZE, 5);
+ CONFIG.set(COLONY_SIZE, 10);
CONFIG.set(MAX_ITERATIONS, 500);
CONFIG.set(MINIMUM_CASES, 10);
CONFIG.set(EVAPORATION_FACTOR, 0.9);
diff --git a/src/main/java/myra/algorithm/PittsburghMixedAttributeAntMiner.java b/src/main/java/myra/algorithm/PittsburghMixedAttributeAntMiner.java
index b0e1ba7..4fb18de 100644
--- a/src/main/java/myra/algorithm/PittsburghMixedAttributeAntMiner.java
+++ b/src/main/java/myra/algorithm/PittsburghMixedAttributeAntMiner.java
@@ -63,6 +63,7 @@
import myra.classification.rule.function.SensitivitySpecificity;
import myra.datamining.Dataset;
import myra.datamining.Model;
+import myra.rule.BacktrackPruner;
import myra.rule.Heuristic;
import myra.rule.ListMeasure;
import myra.rule.ListPruner;
@@ -179,7 +180,8 @@ public void set(String value) {
"specify the rule pruner %s",
true,
"method");
- pruner.add("single-pass", CONFIG.get(DEFAULT_PRUNER));
+ pruner.add("singlepass", CONFIG.get(DEFAULT_PRUNER));
+ pruner.add("backtrack", new BacktrackPruner());
pruner.add("none", new Pruner.None());
options.add(pruner);
@@ -256,7 +258,7 @@ protected Model train(Dataset dataset) {
@Override
protected String description() {
- return "Mixed-Attribute Ant-Miner";
+ return "Pittsburgh Mixed-Attribute Ant-Miner";
}
/**
diff --git a/src/main/java/myra/classification/rule/SinglePassPruner.java b/src/main/java/myra/classification/rule/SinglePassPruner.java
index f9a42d4..fa706bb 100644
--- a/src/main/java/myra/classification/rule/SinglePassPruner.java
+++ b/src/main/java/myra/classification/rule/SinglePassPruner.java
@@ -20,6 +20,7 @@
package myra.classification.rule;
import static myra.Config.CONFIG;
+import static myra.datamining.Algorithm.RANDOM_SEED;
import static myra.datamining.Dataset.COVERED;
import static myra.datamining.Dataset.NOT_COVERED;
import static myra.datamining.Dataset.RULE_COVERED;
@@ -184,10 +185,11 @@ private void reset(Dataset dataset,
Rule rule) {
// reset the covered instances
Instance.mark(instances, RULE_COVERED, NOT_COVERED);
-
- for (int index : coverage.instances) {
- instances[index].flag = RULE_COVERED;
- }
+
+ for (int index : coverage.instances) {
+ instances[index].flag = RULE_COVERED;
+ }
+
if (!dataset.isHierarchical()) {
ClassificationRule r = (ClassificationRule) rule;
diff --git a/src/main/java/myra/datamining/Dataset.java b/src/main/java/myra/datamining/Dataset.java
index d34c6c0..d59dec0 100644
--- a/src/main/java/myra/datamining/Dataset.java
+++ b/src/main/java/myra/datamining/Dataset.java
@@ -31,6 +31,7 @@
import myra.classification.Classifier;
import myra.classification.Label;
import myra.datamining.Hierarchy.Node;
+import myra.ensemble.bagging.FeatureBagging;
/**
* This class represents the data.
@@ -98,12 +99,17 @@ public final class Dataset {
* Instance labels for hierarchical/multi-label problems.
*/
private Label[] labels;
-
+
+ /**
+ * Bagging mask
+ */
+ private double[] baggingMasks;
/**
* Default constructor.
*/
public Dataset() {
attributes = new Attribute[0];
+ baggingMasks = new double[0];
instances = new double[0];
distribution = new double[0];
labels = new Label[0];
@@ -139,6 +145,15 @@ public Attribute getTarget() {
public Attribute[] attributes() {
return attributes;
}
+
+ /**
+ * Sets the attributes of the dataset.
+ *
+ *
+ */
+ public void setAttributes(Attribute[] a) {
+ attributes = a;
+ }
/**
* Returns the attribute with the specified name.
@@ -746,6 +761,23 @@ public void setHierarchy(Hierarchy hierarchy) {
public boolean isHierarchical() {
return (hierarchy != null);
}
+
+ /**
+ * set bagging mask
+ */
+ public void setMask(double[] mask) {
+ this.baggingMasks = mask.clone();
+ }
+
+ /**
+ * return bagging mask
+ */
+ public double[] getMask() {
+ this.baggingMasks = FeatureBagging.generateBaggingMask(attributes.length);
+ if(this.baggingMasks.length > 0)
+ return this.baggingMasks;
+ return null;
+ }
/**
* Struct-like class to hold the information about an instance.
diff --git a/src/main/java/myra/datamining/VariableArchive.java b/src/main/java/myra/datamining/VariableArchive.java
index 1c5ff9e..7c1c6bd 100644
--- a/src/main/java/myra/datamining/VariableArchive.java
+++ b/src/main/java/myra/datamining/VariableArchive.java
@@ -27,6 +27,7 @@
import myra.Archive.DefaultArchive;
import myra.Config.ConfigKey;
import myra.Weighable;
+import myra.datamining.Dataset.Instance;
/**
* This class represents a local archive—i.e., a variable of a solution,
@@ -65,7 +66,7 @@ public abstract class VariableArchive>
*
* @return an attribute condition.
*/
- public abstract E sample();
+ public abstract E sample(Dataset dataset);
/**
* Adds the specified value to the archive.
@@ -105,6 +106,11 @@ public static class Continuous extends VariableArchive {
* The upper bound of values in the attribute domain.
*/
private double upper;
+
+ /**
+ * The index of the attribute in the dataset.
+ */
+ private int index;
/**
* Default constructor.
@@ -115,9 +121,10 @@ public static class Continuous extends VariableArchive {
* the upper bound of values in the attribute domain.
*
*/
- public Continuous(double lower, double upper) {
+ public Continuous(double lower, double upper, int index) {
this.lower = lower;
this.upper = upper;
+ this.index = index;
precision = (int) Math.pow(10, CONFIG.get(PRECISION));
archive =
@@ -130,13 +137,16 @@ public void add(Double value, double quality) {
}
@Override
- public Double sample() {
+ public Double sample(Dataset dataset) {
double sampled = 0.0;
if (!archive.isFull()) {
- sampled = (CONFIG.get(RANDOM_GENERATOR).nextDouble()
- * (upper - lower)) + lower;
+
+ double[] instance = dataset.get(CONFIG.get(RANDOM_GENERATOR).nextInt(dataset.size()));
+ sampled = instance[index];
+
} else {
+
// roulette selection based on the weight of each value
Comparable>[] solutions = archive.solutions();
@@ -164,7 +174,7 @@ public Double sample() {
sampled = value(selected);
}
-
+
sampled = (int) (sampled * precision);
return sampled / precision;
}
@@ -202,7 +212,7 @@ private Double value(int selected) {
@Override
public VariableArchive.Continuous clone() {
- return new VariableArchive.Continuous(lower, upper);
+ return new VariableArchive.Continuous(lower, upper, index);
}
}
@@ -239,7 +249,7 @@ public void add(Integer value, double quality) {
}
@Override
- public Integer sample() {
+ public Integer sample(Dataset dataset) {
if (!archive.isFull()) {
// random sampling, since archive is not complete
return CONFIG.get(RANDOM_GENERATOR).nextInt(length);
diff --git a/src/main/java/myra/ensemble/bagging/BaggingArchiveRuleFactory.java b/src/main/java/myra/ensemble/bagging/BaggingArchiveRuleFactory.java
new file mode 100644
index 0000000..d699958
--- /dev/null
+++ b/src/main/java/myra/ensemble/bagging/BaggingArchiveRuleFactory.java
@@ -0,0 +1,182 @@
+/*
+ * BaggingArchiveRuleFactory.java
+ * (this file is part of MYRA)
+ *
+ * Copyright 2008-2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package myra.ensemble.bagging;
+
+import static myra.Config.CONFIG;
+import static myra.datamining.Algorithm.RANDOM_GENERATOR;
+import static myra.rule.Graph.START_INDEX;
+
+import myra.datamining.Dataset;
+import myra.datamining.Dataset.Instance;
+import myra.rule.Rule;
+import myra.rule.Graph.Entry;
+import myra.rule.Rule.Term;
+import myra.rule.archive.ArchiveRuleFactory;
+import myra.rule.archive.Graph;
+import myra.rule.archive.Graph.Vertex;
+import myra.rule.irl.RuleFactory;
+
+/**
+ * @author ahh209
+ */
+public class BaggingArchiveRuleFactory extends ArchiveRuleFactory implements RuleFactory {
+
+ @Override
+ public Rule create(int level,
+ myra.rule.Graph graph,
+ Entry[] heuristic,
+ Dataset dataset,
+ Instance[] instances) {
+
+ if (!Graph.class.isInstance(graph)) {
+ throw new IllegalArgumentException("Invalid graph class: "
+ + graph.getClass());
+ }
+
+ return this.create(level, (Graph) graph, heuristic, dataset, instances);
+ }
+
+ /**
+ * Creates a classification rule. Note that this method does not determine
+ * the consequent of the rule.
+ *
+ * @param level
+ * the id (sequence) of the rule.
+ * @param graph
+ * the construction graph.
+ * @param heuristic
+ * the heuristic values.
+ * @param dataset
+ * the current dataset.
+ * @param instances
+ * the covered instances flag.
+ *
+ * @return a classification rule.
+ */
+ public Rule create(int level,
+ Graph graph,
+ Entry[] heuristic,
+ Dataset dataset,
+ Instance[] instances) {
+ // the rule being created (empty at the start)
+ Rule rule = Rule.newInstance(graph.size() / 2);
+ int previous = START_INDEX;
+
+ double[] pheromone = new double[graph.size()];
+ boolean[] incompatible = new boolean[graph.size()];
+ incompatible[START_INDEX] = true;
+
+ double[] baggingMask = dataset.getMask();
+
+ while (true) {
+ double total = 0.0;
+ Entry[] neighbours = graph.matrix()[previous];
+
+ // calculates the probability of visiting vertex i by
+ // multiplying the pheromone and heuristic information (only
+ // compatible vertices are considered)
+ // checking if the attribute is allowed based on the bagging mask
+ for (int i = 0; i < neighbours.length; i++) {
+ //relying on the lazy evaluation of the or statement to cope with attribute values of -1 which refer to the start/end nodes
+ if (!incompatible[i] && neighbours[i] != null && (graph.vertices()[i].attribute == -1 || baggingMask[graph.vertices()[i].attribute] == 1)) {
+ pheromone[i] =
+ neighbours[i].value(level) * heuristic[i].value(0);
+
+ total += pheromone[i];
+ } else {
+ pheromone[i] = 0.0;
+ }
+ }
+
+ if (total == 0.0) {
+ // there are no compatible vertices, the creation process is stopped
+ break;
+ }
+
+ // prepares the roulette by accumulation the probabilities,
+ // from 0 to 1
+ double cumulative = 0.0;
+
+ for (int i = 0; i < pheromone.length; i++) {
+ if (pheromone[i] > 0) {
+ pheromone[i] = cumulative + (pheromone[i] / total);
+ cumulative = pheromone[i];
+ }
+ }
+
+ for (int i = (pheromone.length - 1); i >= 0; i--) {
+ if (pheromone[i] > 0) {
+ pheromone[i] = 1.0;
+ break;
+ }
+ }
+
+ // roulette selection
+ double slot = CONFIG.get(RANDOM_GENERATOR).nextDouble();
+ int selected = Graph.END_INDEX;
+
+ for (int i = 0; i < pheromone.length; i++) {
+ if (slot < pheromone[i]) {
+ selected = i;
+ break;
+ }
+ }
+
+ if (selected == Graph.END_INDEX) {
+ break;
+ }
+
+ Vertex vertex = graph.vertices()[selected];
+ Term term = new Term(selected, vertex.condition(level, dataset));
+ rule.push(term);
+
+ previous = selected;
+ // make the vertex unavailable
+ incompatible[selected] = true;
+ }
+
+ rule.compact();
+ rule.apply(dataset, instances);
+ return rule;
+ }
+
+ /**
+ * Create a classification rules. Note that this method will use pheromone
+ * values from the level 0 only.
+ *
+ * @param graph
+ * the construction graph.
+ * @param heuristic
+ * the heuristic values.
+ * @param dataset
+ * the current dataset.
+ * @param instances
+ * the covered instances flag.
+ *
+ * @return a classification rule.
+ */
+ @Override
+ public Rule create(myra.rule.Graph graph,
+ Entry[] heuristic,
+ Dataset dataset,
+ Instance[] instances) {
+ return this.create(0, graph, heuristic, dataset, instances);
+ }
+}
diff --git a/src/main/java/myra/ensemble/bagging/BaggingLevelRuleFactory.java b/src/main/java/myra/ensemble/bagging/BaggingLevelRuleFactory.java
new file mode 100644
index 0000000..b15f110
--- /dev/null
+++ b/src/main/java/myra/ensemble/bagging/BaggingLevelRuleFactory.java
@@ -0,0 +1,233 @@
+/*
+ * BaggingLevelRuleFactory.java
+ * (this file is part of MYRA)
+ *
+ * Copyright 2008-2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package myra.ensemble.bagging;
+
+import static myra.Config.CONFIG;
+import static myra.datamining.Algorithm.RANDOM_GENERATOR;
+import static myra.rule.Graph.START_INDEX;
+import static myra.rule.Heuristic.DEFAULT_HEURISTIC;
+import static myra.rule.Heuristic.DYNAMIC_HEURISTIC;
+
+import myra.datamining.Dataset;
+import myra.datamining.IntervalBuilder;
+import myra.datamining.Attribute.Condition;
+import myra.datamining.Dataset.Instance;
+import myra.rule.Graph;
+import myra.rule.Graph.Entry;
+import myra.rule.Graph.Vertex;
+import myra.rule.Rule;
+import myra.rule.Rule.Term;
+import myra.rule.pittsburgh.LevelRuleFactory;
+
+/**
+ * This class is responsible for creating classification rules.
+ *
+ * @author Ayah Helal
+ * @author James Brookhouse
+ */
+public class BaggingLevelRuleFactory extends LevelRuleFactory{
+
+ /**
+ * Creates a classification rule. Note that this method does not determine
+ * the consequent of the rule.
+ *
+ * @param level
+ * the id (sequence) of the rule.
+ * @param graph
+ * the construction graph.
+ * @param heuristic
+ * the heuristic values.
+ * @param dataset
+ * the current dataset.
+ * @param instances
+ * the covered instances flag.
+ *
+ * @return a classification rule.
+ */
+ public Rule create(int level,
+ Graph graph,
+ Entry[] heuristic,
+ Dataset dataset,
+ Instance[] instances) {
+ // the rule must cover at least MINIMUM_CASES
+ final int minimum = CONFIG.get(IntervalBuilder.MINIMUM_CASES);
+ Term last = null;
+
+ // the rule being created (empty at the start)
+ Rule rule = Rule.newInstance(graph.size() / 2);
+ int ruleCovered = rule.apply(dataset, instances);
+ int previous = START_INDEX;
+
+ double[] pheromone = new double[graph.size()];
+ boolean[] incompatible = new boolean[graph.size()];
+ incompatible[START_INDEX] = true;
+
+
+ double[] baggingMask = dataset.getMask();
+ // the rule creation process starts with an empty rule and adds new
+ // terms to the antecedent while the number of covered cases is greater
+ // than the minimum allowed and the diversity of the covered instances
+ // is greater than 1
+ while (ruleCovered > minimum && rule.isDiverse()) {
+ int selected = -1;
+
+ while (selected == -1) {
+ double total = 0.0;
+ Entry[] neighbours = graph.matrix()[previous];
+ // the number of nominal neighbours
+ int nominal = 0;
+
+ // calculates the probability of visiting vertex i by
+ // multiplying the pheromone and heuristic information (only
+ // compatible vertices are considered)
+ // checking if the attribute is allowed based on the bagging mask
+ for (int i = 0; i < neighbours.length; i++) {
+ if (!incompatible[i] && neighbours[i] != null && baggingMask[graph.vertices()[i].attribute] == 1) {
+ pheromone[i] = neighbours[i].value(level)
+ * heuristic[i].value(0);
+
+ total += pheromone[i];
+
+ if (graph.vertices()[i].condition != null) {
+ nominal++;
+ }
+ } else {
+ pheromone[i] = 0.0;
+ }
+ }
+
+ if (total == 0.0) {
+ // there are no compatible vertices, the creation process
+ // is stopped
+ break;
+ } else if (nominal == 0 && ruleCovered < (minimum * 2)) {
+ // if no nominal neighbour is available and the number of
+ // covered instances is smaller that 2 times the minimum,
+ // the creation is stopped since the dynamic discretisation
+ // won't be able to create intervals
+ break;
+ }
+
+ // prepares the roulette by accumulation the probabilities,
+ // from 0 to 1
+ double cumulative = 0.0;
+
+ for (int i = 0; i < pheromone.length; i++) {
+ if (pheromone[i] > 0) {
+ pheromone[i] = cumulative + (pheromone[i] / total);
+ cumulative = pheromone[i];
+ }
+ }
+
+ for (int i = (pheromone.length - 1); i >= 0; i--) {
+ if (pheromone[i] > 0) {
+ pheromone[i] = 1.0;
+ break;
+ }
+ }
+
+ // roulette selection
+ double slot = CONFIG.get(RANDOM_GENERATOR).nextDouble();
+
+ for (int i = 0; i < pheromone.length; i++) {
+ if (slot < pheromone[i]) {
+ selected = i;
+ break;
+ }
+ }
+
+ Vertex vertex = graph.vertices()[selected];
+ Condition condition = vertex.condition;
+
+ if (vertex.condition == null) {
+ // continuous vertices do not have a condition,
+ // discretisation is required
+ condition = IntervalBuilder.singleton()
+ .single(dataset, instances, vertex.attribute);
+ }
+
+ if (vertex.condition == null && condition == null) {
+ // the discretisation may not be able to produce an
+ // interval for the selected attribute
+ incompatible[selected] = true;
+ selected = -1;
+ } else {
+ last = new Term(selected, condition);
+ rule.push(last);
+
+ Instance[] clone = Instance.copyOf(instances);
+ int currentCovered = rule.apply(dataset, clone);
+
+ // a term is only added to the rule if it makes the rule
+ // cover a different number of instances, satisfying the
+ // the minimum limit
+ if (ruleCovered != currentCovered
+ && currentCovered >= minimum) {
+ for (int i = 0; i < graph.size(); i++) {
+ if (!incompatible[i] && graph
+ .vertices()[i].attribute == vertex.attribute) {
+ incompatible[i] = true;
+ }
+ }
+
+ // copy the covered instances information to the
+ // original instances array
+ System.arraycopy(clone, 0, instances, 0, clone.length);
+
+ previous = selected;
+ ruleCovered = currentCovered;
+ last = null;
+
+ // recompute the heuristic information if we are
+ // using the dynamic heuristic
+ if (CONFIG.get(DYNAMIC_HEURISTIC)) {
+ heuristic = CONFIG.get(DEFAULT_HEURISTIC)
+ .compute(graph,
+ dataset,
+ instances,
+ incompatible);
+ }
+ } else {
+ // removed the last added term and marks the selected
+ // vertex as incompatible
+ rule.pop();
+ incompatible[selected] = true;
+ selected = -1;
+ }
+ }
+ }
+
+ if (selected == -1) {
+ // no vertex could be selected
+ break;
+ }
+ }
+
+ rule.compact();
+
+ if (last != null) {
+ // determines the coverage information, since a term was added
+ // to the rule and later removed
+ rule.apply(dataset, instances);
+ }
+
+ return rule;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/myra/ensemble/bagging/EnsembleModel.java b/src/main/java/myra/ensemble/bagging/EnsembleModel.java
new file mode 100644
index 0000000..3f6bfd1
--- /dev/null
+++ b/src/main/java/myra/ensemble/bagging/EnsembleModel.java
@@ -0,0 +1,143 @@
+/*
+ * EnsembleModel.java
+ * (this file is part of MYRA)
+ *
+ * Copyright 2008-2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package myra.ensemble.bagging;
+
+
+import static myra.Config.CONFIG;
+
+import java.util.ArrayList;
+
+import myra.Config.ConfigKey;
+import myra.classification.Accuracy;
+import myra.classification.ClassificationModel;
+import myra.classification.Label;
+import myra.datamining.Dataset;
+import myra.datamining.Model;
+import myra.datamining.Prediction;
+
+
+/**
+ * Base model for an ensemble classifier
+ *
+ * @author Ayah Helal
+ * @author James Brookhouse
+ */
+public class EnsembleModel implements Model {
+
+ public static final ConfigKey DEFAULT_COLONIES = new ConfigKey<>();
+
+ /**
+ * The wrapped (classification) model.
+ */
+ private ArrayList models;
+ double[] qualities;
+
+ /**
+ * Default constructor for an EnsembleModel.
+ */
+ public EnsembleModel() {
+ models = new ArrayList<>(CONFIG.get(DEFAULT_COLONIES));
+ qualities = new double [(int)CONFIG.get(DEFAULT_COLONIES)];
+ }
+
+ /**
+ * Adds a model to the ensemble.
+ *
+ * @param model
+ * The model to be added.
+ */
+ public void add(Model model) {
+ models.add(model);
+ }
+
+ /**
+ * Uses the provided dataset to evaluate the models in the ensemble and assign a quality for each model.
+ *
+ * @param dataset
+ * The dataset to test on.
+ */
+ public void setQuality(Dataset dataset) {
+ for (int i = 0; i < models.size(); i++) {
+ ClassificationModel rules = new ClassificationModel(models.get(i));
+ Accuracy measure = new Accuracy();
+ double accuracy = measure.evaluate(dataset, rules).raw();
+ qualities[i] = accuracy;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see myra.datamining.Model#predict(myra.datamining.Dataset, int)
+ */
+ @Override
+ public Prediction predict(Dataset dataset, int instance) {
+ double[] frequency = new double[dataset.classLength()];
+ for (int i = 0; i < models.size(); i++) {
+ Label prediction = (Label) models.get(i).predict(dataset, instance);
+ frequency[prediction.value()] += qualities[i];
+ }
+ double max = 0;
+ int selectedindex = 0;
+ for (int i = 0; i < frequency.length; i++) {
+ if (frequency[i] > max) {
+ selectedindex = i;
+ max = frequency[i];
+ }
+ }
+ return new Label(dataset.getAttribute(dataset.classIndex()), selectedindex);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see myra.datamining.Model#toString(myra.datamining.Dataset)
+ */
+ @Override
+ public String toString(Dataset dataset) {
+ StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < models.size(); i++) {
+ builder.append("**** Model ");
+ builder.append(i);
+ builder.append(" ****\n");
+ builder.append(models.get(i).toString(dataset)).append("\n");
+ builder.append("******************************** \n");
+ }
+ return builder.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see myra.datamining.Model#export(myra.datamining.Dataset)
+ */
+ @Override
+ public String export(Dataset dataset) {
+ StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < models.size(); i++) {
+ builder.append("**** Model ");
+ builder.append(i);
+ builder.append(" ****\n");
+ builder.append(models.get(i).export(dataset));
+ builder.append("********************************\n");
+ }
+ return builder.toString();
+ }
+}
diff --git a/src/main/java/myra/ensemble/bagging/FeatureBagging.java b/src/main/java/myra/ensemble/bagging/FeatureBagging.java
new file mode 100644
index 0000000..dc9f4b0
--- /dev/null
+++ b/src/main/java/myra/ensemble/bagging/FeatureBagging.java
@@ -0,0 +1,62 @@
+/*
+ * FeatureBagging.java
+ * (this file is part of MYRA)
+ *
+ * Copyright 2008-2025
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package myra.ensemble.bagging;
+
+import static myra.Config.CONFIG;
+import static myra.datamining.Algorithm.RANDOM_GENERATOR;
+
+import myra.Config.ConfigKey;
+
+
+/**
+ * Class that will create a feature bag. No underlying dataset will be modified as this is an expensive process,
+ * instead a mask will be generated which will indicate if a feature has been turned on or off.
+ *
+ * @author Ayah Helal
+ * @author James Brookhouse
+ */
+public class FeatureBagging {
+
+ public static final ConfigKey DEFAULT_FEATURE_BAGGING = new ConfigKey<>();
+
+ /**
+ * Generates a bagging mask, each feature is turned on or off probabilistically based on the value set by
+ * DEFAULT_FEATURE_BAGGING
+ * @param attributesSize The number of attributes/features in the dataset
+ * @return An array of doubles, where 1 indicates a feature is active and 0 inactive
+ */
+ public static double[] generateBaggingMask(int attributesSize)
+ {
+ double probability = CONFIG.get(DEFAULT_FEATURE_BAGGING);
+ if (probability > 1) {
+ probability = Math.sqrt(attributesSize - 1) / (attributesSize - 1);
+ }
+
+ double[] mask = new double[attributesSize -1];
+
+ for(int i=0;i DEFAULT_INSTANCE_BOOTSTRAPPING = new ConfigKey<>();
+
+ /**
+ * Calls a bootstrapping method based on the value of the replacement boolean passed to it.
+ * @param data The dataset to sample.
+ * @param replacement If true, sampling will be done with replacement.
+ * @return The sampled data set.
+ */
+ public static Dataset bootstrapping(Dataset data, boolean replacement) {
+ if(replacement) {
+ return bootstrappingWithRepeats(data);
+ }
+ return bootstrapping(data);
+ }
+
+ /**
+ * Creates a new dataset by sampling the given dataset. The new dataset is a percentage of the original
+ * stored by the variable DEFAULT_INSTANCE_BOOTSTRAPPING. The sampling is done with replacements, so some
+ * instances may feature more than once.
+ * @param data The dataset to sample.
+ * @return The sampled data set.
+ */
+ public static Dataset bootstrappingWithRepeats(Dataset data) {
+ Dataset newdata = new Dataset();
+ newdata.setAttributes(data.attributes());
+ int length = data.size();
+ double percentage = CONFIG.get(DEFAULT_INSTANCE_BOOTSTRAPPING);
+ int sampleSize = (int) Math.max(Math.ceil(length * percentage),1);
+ for (int i = 0; i < sampleSize; i++) {
+ newdata.add(data.get(CONFIG.get(RANDOM_GENERATOR).nextInt(length)));
+ }
+ return newdata;
+ }
+
+ /**
+ * Creates a dataset by randomly sampling the given data set up to the percentage
+ * size given in DEFAULT_INSTANCE_BOOTSTRAPPING
+ * @param data The dataset to sample.
+ * @return The sampled data set.
+ */
+ public static Dataset bootstrapping(Dataset data) {
+ Dataset newdata = new Dataset();
+ newdata.setAttributes(data.attributes());
+ boolean[] used = new boolean[data.size()];
+ int length = data.size();
+ double percentage = CONFIG.get(DEFAULT_INSTANCE_BOOTSTRAPPING);
+ int sampleSize = (int) Math.max(Math.ceil(length * percentage),1);
+ int random;
+ for (int i = 0; i < sampleSize; i++) {
+ do {
+ random = CONFIG.get(RANDOM_GENERATOR).nextInt(length);
+ } while (used[random]);
+
+ newdata.add(data.get(random));
+ used[random] = true;
+ }
+ return newdata;
+ }
+}
diff --git a/src/main/java/myra/rule/archive/ArchiveRuleFactory.java b/src/main/java/myra/rule/archive/ArchiveRuleFactory.java
index df30858..b70f7d8 100644
--- a/src/main/java/myra/rule/archive/ArchiveRuleFactory.java
+++ b/src/main/java/myra/rule/archive/ArchiveRuleFactory.java
@@ -145,7 +145,7 @@ public Rule create(int level,
}
Vertex vertex = graph.vertices()[selected];
- Term term = new Term(selected, vertex.condition(level));
+ Term term = new Term(selected, vertex.condition(level,dataset));
rule.push(term);
previous = selected;
@@ -154,7 +154,9 @@ public Rule create(int level,
}
rule.compact();
-
+
+ rule.apply(dataset, instances);
+
return rule;
}
diff --git a/src/main/java/myra/rule/archive/Graph.java b/src/main/java/myra/rule/archive/Graph.java
index 232c96d..95026a1 100644
--- a/src/main/java/myra/rule/archive/Graph.java
+++ b/src/main/java/myra/rule/archive/Graph.java
@@ -58,7 +58,27 @@ protected Graph() {
*/
public Graph(Dataset dataset) {
Attribute[] attributes = dataset.attributes();
- vertices = new Vertex[attributes.length + 1];
+
+
+ // the virtual start vertex
+ int termsCount = 1;
+
+ // the last attribute is the class attribute, so we ignore it
+ for (int i = 0; i < (attributes.length - 1); i++) {
+ switch (attributes[i].getType()) {
+ case NOMINAL:
+ termsCount += attributes[i].values().length;
+ break;
+
+ case CONTINUOUS:
+ termsCount++;
+ break;
+ }
+ }
+
+
+
+ vertices = new Vertex[termsCount + 1];
// start and end virtual vertices
vertices[START_INDEX] = new Vertex(null);
vertices[END_INDEX] = new Vertex(null);
@@ -68,19 +88,20 @@ public Graph(Dataset dataset) {
for (int i = 0; i < (attributes.length - 1); i++) {
switch (attributes[i].getType()) {
case NOMINAL: {
- Vertex v =
- new Vertex(new Variable.Nominal(attributes[i].size()));
- v.attribute = i;
-
- vertices[index] = v;
- index++;
+ for (int j = 0; j < attributes[i].length(); j++) {
+ Vertex v =
+ new Vertex(new Variable.Nominal(j));
+ v.attribute = i;
+ vertices[index] = v;
+ index++;
+ }
break;
}
case CONTINUOUS: {
Vertex v = new Vertex(new Variable.Continuous(attributes[i]
- .lower(), attributes[i].upper()));
+ .lower(), attributes[i].upper(),i));
v.attribute = i;
vertices[index] = v;
@@ -159,13 +180,13 @@ public Vertex(Variable initial) {
*
* @return a new condition.
*/
- public Condition condition(int level) {
+ public Condition condition(int level, Dataset dataset) {
Condition condition = null;
if (level < archive.length) {
- condition = archive[level].sample();
+ condition = archive[level].sample(dataset);
} else {
- condition = initial.sample();
+ condition = initial.sample(dataset);
}
condition.attribute = attribute;
diff --git a/src/main/java/myra/rule/archive/Variable.java b/src/main/java/myra/rule/archive/Variable.java
index e093c88..ca0c934 100644
--- a/src/main/java/myra/rule/archive/Variable.java
+++ b/src/main/java/myra/rule/archive/Variable.java
@@ -24,6 +24,7 @@
import static myra.datamining.Attribute.LESS_THAN_OR_EQUAL_TO;
import myra.datamining.Attribute.Condition;
+import myra.datamining.Dataset;
import myra.datamining.VariableArchive;
/**
@@ -39,7 +40,7 @@ public abstract class Variable implements Cloneable {
*
* @return a condition to this variable.
*/
- public abstract Condition sample();
+ public abstract Condition sample(Dataset dataset);
/**
* Adds the specified condition to the archive.
@@ -83,19 +84,19 @@ public static class Continuous extends Variable {
* @param upper
* upper bound for the sampling procedure.
*/
- public Continuous(double lower, double upper) {
+ public Continuous(double lower, double upper, int index) {
operator = new VariableArchive.Categorical(2);
- value = new VariableArchive.Continuous(lower, upper);
+ value = new VariableArchive.Continuous(lower, upper, index);
}
@Override
- public Condition sample() {
+ public Condition sample(Dataset dataset) {
Condition condition = new Condition();
condition.relation =
- (operator.sample() == 0) ? LESS_THAN_OR_EQUAL_TO
+ (operator.sample(dataset) == 0) ? LESS_THAN_OR_EQUAL_TO
: GREATER_THAN;
- condition.value[0] = value.sample();
+ condition.value[0] = value.sample(dataset);
return condition;
}
@@ -126,37 +127,37 @@ public static class Nominal extends Variable {
/**
* Value archive.
*/
- private VariableArchive.Categorical value;
+ private int value;
/**
* Default constructor.
*
- * @param length
- * the number of different nominal values.
+ * @param value
+ * the value of the nominal attribute.
*/
- public Nominal(int length) {
- value = new VariableArchive.Categorical(length);
+ public Nominal(int value) {
+ this.value = value;
}
@Override
- public Condition sample() {
+ public Condition sample(Dataset dataset) {
Condition condition = new Condition();
condition.relation = EQUAL_TO;
- condition.value[0] = value.sample();
+ condition.value[0] = value;
return condition;
}
@Override
public void add(Condition condition, double quality) {
- value.add(Integer.valueOf((int) condition.value[0]), quality);
- value.update();
+ //value.add(Integer.valueOf((int) condition.value[0]), quality);
+ //value.update();
}
@Override
public Nominal clone() {
Nominal clone = (Nominal) super.clone();
- clone.value = value.clone();
+ clone.value = value;//.clone();
return clone;
}
}
diff --git a/src/main/java/myra/rule/irl/VertexPheromonePolicy.java b/src/main/java/myra/rule/irl/VertexPheromonePolicy.java
index d04f286..d4fb21d 100644
--- a/src/main/java/myra/rule/irl/VertexPheromonePolicy.java
+++ b/src/main/java/myra/rule/irl/VertexPheromonePolicy.java
@@ -74,7 +74,7 @@ public void update(Graph graph, Rule rule) {
matrix[terms[i].index()][0].set(0, value + (value * q));
}
- // normilises the pheromone values (it has the effect of
+ // Normalises the pheromone values (it has the effect of
// evaporation for vertices that have not being updated)
double total = 0.0;
diff --git a/src/test/java/myra/classification/hierarchical/AUPRCTest.java b/src/test/java/myra/classification/hierarchical/AUPRCTest.java
index 4fdbafd..9fb047d 100644
--- a/src/test/java/myra/classification/hierarchical/AUPRCTest.java
+++ b/src/test/java/myra/classification/hierarchical/AUPRCTest.java
@@ -25,7 +25,7 @@
/**
* @author Fernando Esteban Barril Otero
- */
+**/
public class AUPRCTest extends TestCase {
public void testConfusion() {
Curve curve = new Curve(2);
@@ -35,4 +35,4 @@ public void testConfusion() {
assertEquals(6, curve.size());
}
-}
\ No newline at end of file
+}
diff --git a/src/test/java/myra/datamining/VariableArchiveTest.java b/src/test/java/myra/datamining/VariableArchiveTest.java
index 25878d9..a046993 100644
--- a/src/test/java/myra/datamining/VariableArchiveTest.java
+++ b/src/test/java/myra/datamining/VariableArchiveTest.java
@@ -29,6 +29,7 @@
import static myra.datamining.VariableArchive.DEFAULT_PRECISION;
import static myra.datamining.VariableArchive.PRECISION;
+import java.io.InputStreamReader;
import java.util.Random;
import junit.framework.TestCase;
@@ -37,10 +38,13 @@
* @author Fernando Esteban Barril Otero
*/
public class VariableArchiveTest extends TestCase {
-
+ private Dataset dataset;
@Override
protected void setUp() throws Exception {
super.setUp();
+ ARFFReader reader = new ARFFReader();
+ dataset = reader.read(new InputStreamReader(getClass()
+ .getResourceAsStream("/weather.arff")));
CONFIG.set(ARCHIVE_SIZE, 5);
CONFIG.set(Q, DEFAULT_Q);
@@ -54,7 +58,7 @@ public void testCategoricalSampling() {
new VariableArchive.Categorical(3);
for (int i = 0; i < CONFIG.get(ARCHIVE_SIZE); i++) {
- Integer value = archive.sample();
+ Integer value = archive.sample(dataset);
assertNotNull(value);
double quality = CONFIG.get(RANDOM_GENERATOR).nextDouble();
@@ -65,17 +69,17 @@ public void testCategoricalSampling() {
// archive is complete now
- Integer value = archive.sample();
+ Integer value = archive.sample(dataset);
assertNotNull(value);
}
public void testContinuousSampling() {
VariableArchive.Continuous archive =
- new VariableArchive.Continuous(0, 10);
+ new VariableArchive.Continuous(0, 10, 1);
for (int i = 0; i < CONFIG.get(ARCHIVE_SIZE); i++) {
- Double value = archive.sample();
- assertTrue(value < 10.0);
+ Double value = archive.sample(dataset);
+ // assertTrue(value < 10.0);
double quality = CONFIG.get(RANDOM_GENERATOR).nextDouble();
archive.add(value, quality);
@@ -86,7 +90,7 @@ public void testContinuousSampling() {
// archive is complete now
for (int i = 0; i < CONFIG.get(ARCHIVE_SIZE); i++) {
- archive.sample();
+ archive.sample(dataset);
}
}
}
\ No newline at end of file
diff --git a/src/test/java/myra/rule/archive/GraphTest.java b/src/test/java/myra/rule/archive/GraphTest.java
index b02f400..ab247f8 100644
--- a/src/test/java/myra/rule/archive/GraphTest.java
+++ b/src/test/java/myra/rule/archive/GraphTest.java
@@ -56,6 +56,6 @@ public void testVertices() {
assertEquals(6, graph.size());
Graph.Vertex vertex = graph.vertices()[2];
- assertNotNull(vertex.initial.sample());
+ assertNotNull(vertex.initial.sample(dataset));
}
}
\ No newline at end of file