use of org.kie.kogito.explainability.model.Value in project kogito-apps by kiegroup.
the class CounterfactualExplainerTest method testCounterfactualConstrainedMatchUnscaled.
@ParameterizedTest
@ValueSource(ints = { 0, 1, 2 })
void testCounterfactualConstrainedMatchUnscaled(int seed) throws ExecutionException, InterruptedException, TimeoutException {
Random random = new Random();
random.setSeed(seed);
final List<Output> goal = List.of(new Output("inside", Type.BOOLEAN, new Value(true), 0.0));
List<Feature> features = new LinkedList<>();
features.add(FeatureFactory.newNumericalFeature("f-num1", 100.0));
features.add(FeatureFactory.newNumericalFeature("f-num2", 100.0, NumericalFeatureDomain.create(0.0, 1000.0)));
features.add(FeatureFactory.newNumericalFeature("f-num3", 100.0, NumericalFeatureDomain.create(0.0, 1000.0)));
features.add(FeatureFactory.newNumericalFeature("f-num4", 100.0));
final double center = 500.0;
final double epsilon = 10.0;
final CounterfactualResult result = runCounterfactualSearch((long) seed, goal, features, TestUtils.getSumThresholdModel(center, epsilon), DEFAULT_GOAL_THRESHOLD);
final List<CounterfactualEntity> counterfactualEntities = result.getEntities();
double totalSum = 0;
for (CounterfactualEntity entity : counterfactualEntities) {
totalSum += entity.asFeature().getValue().asNumber();
logger.debug("Entity: {}", entity);
}
assertFalse(counterfactualEntities.get(0).isChanged());
assertFalse(counterfactualEntities.get(3).isChanged());
assertTrue(totalSum <= center + epsilon);
assertTrue(totalSum >= center - epsilon);
assertTrue(result.isValid());
}
use of org.kie.kogito.explainability.model.Value in project kogito-apps by kiegroup.
the class CounterfactualExplainerTest method testCounterfactualConstrainedMatchScaled.
@ParameterizedTest
@ValueSource(ints = { 0, 1, 2 })
void testCounterfactualConstrainedMatchScaled(int seed) throws ExecutionException, InterruptedException, TimeoutException {
Random random = new Random();
random.setSeed(seed);
final List<Output> goal = List.of(new Output("inside", Type.BOOLEAN, new Value(true), 0.0d));
List<Feature> features = new LinkedList<>();
List<FeatureDistribution> featureDistributions = new LinkedList<>();
final Feature fnum1 = FeatureFactory.newNumericalFeature("f-num1", 100.0);
features.add(fnum1);
featureDistributions.add(new NumericFeatureDistribution(fnum1, (new NormalDistribution(500, 1.1)).sample(1000)));
final Feature fnum2 = FeatureFactory.newNumericalFeature("f-num2", 100.0, NumericalFeatureDomain.create(0.0, 1000.0));
features.add(fnum2);
featureDistributions.add(new NumericFeatureDistribution(fnum2, (new NormalDistribution(430.0, 1.7)).sample(1000)));
final Feature fnum3 = FeatureFactory.newNumericalFeature("f-num3", 100.0, NumericalFeatureDomain.create(0.0, 1000.0));
features.add(fnum3);
featureDistributions.add(new NumericFeatureDistribution(fnum3, (new NormalDistribution(470.0, 2.9)).sample(1000)));
final Feature fnum4 = FeatureFactory.newNumericalFeature("f-num4", 100.0);
features.add(fnum4);
featureDistributions.add(new NumericFeatureDistribution(fnum4, (new NormalDistribution(2390.0, 0.3)).sample(1000)));
final double center = 500.0;
final double epsilon = 10.0;
final CounterfactualResult result = runCounterfactualSearch((long) seed, goal, features, TestUtils.getSumThresholdModel(center, epsilon), DEFAULT_GOAL_THRESHOLD);
final List<CounterfactualEntity> counterfactualEntities = result.getEntities();
double totalSum = 0;
for (CounterfactualEntity entity : counterfactualEntities) {
totalSum += entity.asFeature().getValue().asNumber();
logger.debug("Entity: {}", entity);
}
assertFalse(counterfactualEntities.get(0).isChanged());
assertFalse(counterfactualEntities.get(3).isChanged());
assertTrue(totalSum <= center + epsilon);
assertTrue(totalSum >= center - epsilon);
assertTrue(result.isValid());
}
use of org.kie.kogito.explainability.model.Value in project kogito-apps by kiegroup.
the class CounterfactualExplainerTest method testCounterfactualBoolean.
@ParameterizedTest
@ValueSource(ints = { 0, 1, 2 })
void testCounterfactualBoolean(int seed) throws ExecutionException, InterruptedException, TimeoutException {
Random random = new Random();
random.setSeed(seed);
final List<Output> goal = List.of(new Output("inside", Type.BOOLEAN, new Value(true), 0.0d));
List<Feature> features = new LinkedList<>();
for (int i = 0; i < 4; i++) {
if (i == 2) {
features.add(FeatureFactory.newNumericalFeature("f-" + i, random.nextDouble()));
} else {
features.add(FeatureFactory.newNumericalFeature("f-" + i, random.nextDouble(), NumericalFeatureDomain.create(0.0, 1000.0)));
}
}
features.add(FeatureFactory.newBooleanFeature("f-bool", true, EmptyFeatureDomain.create()));
final double center = 500.0;
final double epsilon = 10.0;
final CounterfactualResult result = runCounterfactualSearch((long) seed, goal, features, TestUtils.getSumThresholdModel(center, epsilon), DEFAULT_GOAL_THRESHOLD);
final List<CounterfactualEntity> counterfactualEntities = result.getEntities();
double totalSum = 0;
for (CounterfactualEntity entity : counterfactualEntities) {
totalSum += entity.asFeature().getValue().asNumber();
logger.debug("Entity: {}", entity);
}
assertFalse(counterfactualEntities.get(2).isChanged());
assertTrue(totalSum <= center + epsilon);
assertTrue(totalSum >= center - epsilon);
assertTrue(result.isValid());
}
use of org.kie.kogito.explainability.model.Value in project kogito-apps by kiegroup.
the class CounterfactualExplainerTest method testCounterfactualMatch.
@ParameterizedTest
@ValueSource(ints = { 0, 1, 2 })
void testCounterfactualMatch(int seed) throws ExecutionException, InterruptedException, TimeoutException {
Random random = new Random();
random.setSeed(seed);
final List<Output> goal = List.of(new Output("inside", Type.BOOLEAN, new Value(true), 0.0d));
List<Feature> features = new LinkedList<>();
features.add(FeatureFactory.newNumericalFeature("f-num1", 100.0, NumericalFeatureDomain.create(0.0, 1000.0)));
features.add(FeatureFactory.newNumericalFeature("f-num2", 150.0, NumericalFeatureDomain.create(0.0, 1000.0)));
features.add(FeatureFactory.newNumericalFeature("f-num3", 1.0, NumericalFeatureDomain.create(0.0, 1000.0)));
features.add(FeatureFactory.newNumericalFeature("f-num4", 2.0, NumericalFeatureDomain.create(0.0, 1000.0)));
final double center = 500.0;
final double epsilon = 10.0;
final CounterfactualResult result = runCounterfactualSearch((long) seed, goal, features, TestUtils.getSumThresholdModel(center, epsilon), DEFAULT_GOAL_THRESHOLD);
double totalSum = 0;
for (CounterfactualEntity entity : result.getEntities()) {
totalSum += entity.asFeature().getValue().asNumber();
logger.debug("Entity: {}", entity);
}
logger.debug("Outputs: {}", result.getOutput().get(0).getOutputs());
assertTrue(totalSum <= center + epsilon);
assertTrue(totalSum >= center - epsilon);
assertTrue(result.isValid());
}
use of org.kie.kogito.explainability.model.Value in project kogito-apps by kiegroup.
the class CounterfactualExplainerTest method testCounterfactualCategoricalNotStrict.
/**
* Search for a counterfactual using categorical features with the Symbolic arithmetic model.
* The outcome match is not strict (goal threshold of 0.01).
* The CF should be valid with this number of iterations.
*
* @param seed
* @throws ExecutionException
* @throws InterruptedException
* @throws TimeoutException
*/
@ParameterizedTest
@ValueSource(ints = { 0, 1, 2 })
void testCounterfactualCategoricalNotStrict(int seed) throws ExecutionException, InterruptedException, TimeoutException {
Random random = new Random();
random.setSeed(seed);
final List<Output> goal = List.of(new Output("result", Type.NUMBER, new Value(25.0), 0.0d));
List<Feature> features = new LinkedList<>();
features.add(FeatureFactory.newNumericalFeature("x-1", 5.0, NumericalFeatureDomain.create(0.0, 100.0)));
features.add(FeatureFactory.newNumericalFeature("x-2", 40.0, NumericalFeatureDomain.create(0.0, 100.0)));
features.add(FeatureFactory.newCategoricalFeature("operand", "*", CategoricalFeatureDomain.create("+", "-", "/", "*")));
final CounterfactualResult result = runCounterfactualSearch((long) seed, goal, features, TestUtils.getSymbolicArithmeticModel(), 0.01);
final List<CounterfactualEntity> counterfactualEntities = result.getEntities();
Stream<Feature> counterfactualFeatures = counterfactualEntities.stream().map(CounterfactualEntity::asFeature);
String operand = counterfactualFeatures.filter(feature -> feature.getName().equals("operand")).findFirst().get().getValue().asString();
List<Feature> numericalFeatures = counterfactualEntities.stream().map(CounterfactualEntity::asFeature).filter(feature -> !feature.getName().equals("operand")).collect(Collectors.toList());
double opResult = 0.0;
for (Feature feature : numericalFeatures) {
switch(operand) {
case "+":
opResult += feature.getValue().asNumber();
break;
case "-":
opResult -= feature.getValue().asNumber();
break;
case "*":
opResult *= feature.getValue().asNumber();
break;
case "/":
opResult /= feature.getValue().asNumber();
break;
}
}
final double epsilon = 0.5;
assertTrue(result.isValid());
assertTrue(opResult <= 25.0 + epsilon);
assertTrue(opResult >= 25.0 - epsilon);
}
Aggregations