FAI-916: Fixed Categorical/CatNum feature casting issues

src/trustyai/explainers/counterfactuals.py

@@ -28,6 +28,7 @@
     OneOutputUnionType,
     data_conversion_docstring,
     one_input_convert,
+    java_string_capture,
 )
 
 from org.kie.trustyai.explainability.local.counterfactual import (
@@ -79,6 +80,13 @@ def proposed_features_dataframe(self):
             [PredictionInput([entity.as_feature() for entity in self._result.entities])]
         )
 
+    def _get_feature_difference(self, value_pair):
+        proposed, original = value_pair
+        try:
+            return proposed - original
+        except TypeError:
+            return f"{original} -> {proposed}"
+
     def as_dataframe(self) -> pd.DataFrame:
         """
         Return the counterfactual result as a dataframe
@@ -99,15 +107,21 @@ def as_dataframe(self) -> pd.DataFrame:
         features = self._result.getFeatures()
 
         data = {}
-        data["features"] = [f"{entity.as_feature().getName()}" for entity in entities]
-        data["proposed"] = [entity.as_feature().value.as_obj() for entity in entities]
-        data["original"] = [
-            feature.getValue().getUnderlyingObject() for feature in features
+        data["Features"] = [f"{entity.as_feature().getName()}" for entity in entities]
+        data["Proposed"] = [
+            java_string_capture(entity.as_feature().value.as_obj())
+            for entity in entities
+        ]
+        data["Original"] = [
+            java_string_capture(feature.getValue().getUnderlyingObject())
+            for feature in features
         ]
         data["constrained"] = [feature.is_constrained for feature in features]
 
         dfr = pd.DataFrame.from_dict(data)
-        dfr["difference"] = dfr.proposed - dfr.original
+        dfr["Difference"] = dfr[["Proposed", "Original"]].apply(
+            self._get_feature_difference, 1
+        )
         return dfr
 
     def as_html(self) -> pd.io.formats.style.Styler:
@@ -128,7 +142,7 @@ def plot(self, block=True) -> None:
         Plot the counterfactual result.
         """
         _df = self.as_dataframe().copy()
-        _df = _df[_df["difference"] != 0.0]
+        _df = _df[_df["Difference"] != 0.0]
 
         def change_colour(value):
             if value == 0.0:
@@ -140,9 +154,9 @@ def change_colour(value):
             return colour
 
         with mpl.rc_context(drcp):
-            colour = _df["difference"].transform(change_colour)
-            plot = _df[["features", "proposed", "original"]].plot.barh(
-                x="features", color={"proposed": colour, "original": "black"}
+            colour = _df["Difference"].transform(change_colour)
+            plot = _df[["Features", "Proposed", "Original"]].plot.barh(
+                x="Features", color={"Proposed": colour, "Original": "black"}
             )
             plot.set_title("Counterfactual")
             plt.show(block=block)

src/trustyai/metrics/fairness/group.py

@@ -12,6 +12,7 @@
     OneOutputUnionType,
     one_output_convert,
     to_trusty_dataframe,
+    python_int_capture,
 )
 
 ColumSelector = Union[List[int], List[str]]
@@ -59,7 +60,7 @@ def statistical_parity_difference_model(
 ) -> float:
     """Calculate Statistical Parity Difference using a samples dataframe and a model"""
     favorable_prediction_object = one_output_convert(favorable)
-    _privilege_values = [Value(v) for v in privilege_values]
+    _privilege_values = [Value(python_int_capture(v)) for v in privilege_values]
     _jsamples = to_trusty_dataframe(
         data=samples, no_outputs=True, feature_names=feature_names
     )
@@ -103,7 +104,7 @@ def disparate_impact_ratio_model(
 ) -> float:
     """Calculate Disparate Impact Ration using a samples dataframe and a model"""
     favorable_prediction_object = one_output_convert(favorable)
-    _privilege_values = [Value(v) for v in privilege_values]
+    _privilege_values = [Value(python_int_capture(v)) for v in privilege_values]
     _jsamples = to_trusty_dataframe(
         data=samples, no_outputs=True, feature_names=feature_names
     )
@@ -131,8 +132,8 @@ def average_odds_difference(
         raise ValueError(
             f"Dataframes have different shapes ({test.shape} and {truth.shape})"
         )
-    _privilege_values = [Value(v) for v in privilege_values]
-    _positive_class = [Value(v) for v in positive_class]
+    _privilege_values = [Value(python_int_capture(v)) for v in privilege_values]
+    _positive_class = [Value(python_int_capture(v)) for v in positive_class]
     # determine privileged columns
     _privilege_columns = _column_selector_to_index(privilege_columns, test)
     return FairnessMetrics.groupAverageOddsDifference(
@@ -156,8 +157,8 @@ def average_odds_difference_model(
     _jsamples = to_trusty_dataframe(
         data=samples, no_outputs=True, feature_names=feature_names
     )
-    _privilege_values = [Value(v) for v in privilege_values]
-    _positive_class = [Value(v) for v in positive_class]
+    _privilege_values = [Value(python_int_capture(v)) for v in privilege_values]
+    _positive_class = [Value(python_int_capture(v)) for v in positive_class]
     # determine privileged columns
     _privilege_columns = _column_selector_to_index(privilege_columns, samples)
     return FairnessMetrics.groupAverageOddsDifference(
@@ -179,9 +180,10 @@ def average_predictive_value_difference(
         raise ValueError(
             f"Dataframes have different shapes ({test.shape} and {truth.shape})"
         )
-    _privilege_values = [Value(v) for v in privilege_values]
-    _positive_class = [Value(v) for v in positive_class]
+    _privilege_values = [Value(python_int_capture(v)) for v in privilege_values]
+    _positive_class = [Value(python_int_capture(v)) for v in positive_class]
     _privilege_columns = _column_selector_to_index(privilege_columns, test)
+
     return FairnessMetrics.groupAveragePredictiveValueDifference(
         to_trusty_dataframe(data=test, outputs=outputs, feature_names=feature_names),
         to_trusty_dataframe(data=truth, outputs=outputs, feature_names=feature_names),
@@ -201,8 +203,8 @@ def average_predictive_value_difference_model(
 ) -> float:
     """Calculate Average Predictive Value Difference for a sample dataframe using the provided model"""
     _jsamples = to_trusty_dataframe(samples, no_outputs=True)
-    _privilege_values = [Value(v) for v in privilege_values]
-    _positive_class = [Value(v) for v in positive_class]
+    _privilege_values = [Value(python_int_capture(v)) for v in privilege_values]
+    _positive_class = [Value(python_int_capture(v)) for v in positive_class]
     # determine privileged columns
     _privilege_columns = _column_selector_to_index(privilege_columns, samples)
     return FairnessMetrics.groupAveragePredictiveValueDifference(

src/trustyai/model/__init__.py

@@ -7,6 +7,8 @@
 import uuid as _uuid
 from abc import ABC
 from typing import List, Optional, Union, Callable, Tuple
+
+import jpype
 import pandas as pd
 import pyarrow as pa
 import numpy as np
@@ -23,6 +25,7 @@
     prediction_object_to_numpy,
     prediction_object_to_pandas,
     data_conversion_docstring,
+    python_int_capture,
 )
 from trustyai.model.domain import feature_domain
 
@@ -810,7 +813,8 @@ def output(name, dtype, value=None, score=1.0) -> _Output:
         _type = Type.CATEGORICAL
     else:
         _type = Type.UNDEFINED
-    return _Output(name, _type, Value(value), score)
+
+    return _Output(name, _type, Value(python_int_capture(value)), score)
 
 
 def full_text_feature(
@@ -859,12 +863,14 @@ def feature(
     """
 
     if dtype == "categorical":
-        if isinstance(value, int):
+        if isinstance(value, (np.int64, int)):
             _factory = FeatureFactory.newCategoricalNumericalFeature
             value = JInt(value)
-        else:
+        elif isinstance(value, str):
             _factory = FeatureFactory.newCategoricalFeature
             value = JString(value)
+        else:
+            _factory = FeatureFactory.newObjectFeature
     elif dtype == "number":
         _factory = FeatureFactory.newNumericalFeature
     elif dtype == "bool":

src/trustyai/model/domain.py

@@ -1,13 +1,14 @@
-# pylint: disable = import-error
+# pylint: disable = import-error, unidiomatic-typecheck
 """Conversion method between Python and TrustyAI Java types"""
 from typing import Optional, Tuple, List, Union
 
+import jpype
+import numpy as np
 from jpype import _jclass
 
 from org.kie.trustyai.explainability.model.domain import (
     FeatureDomain,
     NumericalFeatureDomain,
-    CategoricalFeatureDomain,
     CategoricalNumericalFeatureDomain,
     ObjectFeatureDomain,
     EmptyFeatureDomain,
@@ -60,16 +61,21 @@ def feature_domain(values: Optional[Union[Tuple, List]]) -> Optional[FeatureDoma
             domain = NumericalFeatureDomain.create(values[0], values[1])
 
         elif isinstance(values, list):
-            java_array = _jclass.JClass("java.util.Arrays").asList(values)
-            if isinstance(values[0], bool) and isinstance(values[1], bool):
+            if type(values[0]) == bool and type(values[1]) == bool:
+                java_values = [jpype.JBoolean(v) for v in values]
+                java_array = _jclass.JClass("java.util.Arrays").asList(java_values)
                 domain = ObjectFeatureDomain.create(java_array)
-            elif isinstance(values[0], (float, int)) and isinstance(
-                values[1], (float, int)
+            elif isinstance(values[0], (float, int, np.number)) and isinstance(
+                values[1], (float, int, np.number)
             ):
+                if isinstance(values[0], (int, np.int64)):
+                    java_values = [jpype.JInt(v) for v in values]
+                else:
+                    java_values = [jpype.JDouble(v) for v in values]
+                java_array = _jclass.JClass("java.util.Arrays").asList(java_values)
                 domain = CategoricalNumericalFeatureDomain.create(java_array)
-            elif isinstance(values[0], str):
-                domain = CategoricalFeatureDomain.create(java_array)
             else:
+                java_array = _jclass.JClass("java.util.Arrays").asList(values)
                 domain = ObjectFeatureDomain.create(java_array)
 
         else: