refactor: (drop TensorFlow) Remove TensorFlow-related code

Author: CT

README.md

@@ -156,7 +156,7 @@ data_name = "adult"
 dataset = DataCatalog(data_name, "mlp", 0.8)
 
 # load artificial neural network from catalog
-model = ModelCatalog(dataset, "mlp", "tensorflow")
+model = ModelCatalog(dataset, "mlp", "pytorch")
 
 # get factuals from the data to generate counterfactual examples
 factuals = (dataset._df_train).sample(n=10, random_state=RANDOM_SEED)

assignment/assignment.py

@@ -15,7 +15,6 @@
 
 import numpy as np
 import pandas as pd
-import tensorflow as tf
 import torch
 import yaml
 
@@ -27,22 +26,18 @@
 from models.negative_instances import predict_negative_instances
 from tools.log import log
 
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 warnings.simplefilter(action="ignore", category=FutureWarning)
 
 RANDOM_SEED = 54321
 NUMBER_OF_SAMPLES = 20
-BACKEND = (
-    "tensorflow"  # TO-DO: Replace with backend type of the implemented recourse method
-)
+BACKEND = "pytorch"  # TO-DO: Replace with backend type of the implemented recourse method
 DATA_NAME = "adult"
 METHOD_NAME = "dice"  # TO-DO: Replace with implemented recourse method
 MODEL_NAME = "linear"
 TRAIN_SPLIT = 0.7
 
 seed(RANDOM_SEED)
 np.random.seed(RANDOM_SEED)
-tf.set_random_seed(RANDOM_SEED)
 torch.manual_seed(RANDOM_SEED)
 
 

data/causal_model/causal_model.py

@@ -1,6 +1,16 @@
 from typing import List
 
+import collections
 import networkx as nx
+
+try:
+    from collections.abc import Iterable
+
+    if not hasattr(collections, "Iterable"):
+        collections.Iterable = Iterable
+except Exception:
+    pass
+
 from causalgraphicalmodels import CausalGraphicalModel, StructuralCausalModel
 
 from data.causal_model.synthethic_data import ScmDataset

evaluation/catalog/distance.py

@@ -26,7 +26,7 @@ def l0_distance(delta: np.ndarray) -> List[float]:
     num_feature_changes = np.sum(
         difference_mask,
         axis=1,
-        dtype=np.float,
+        dtype=float,
     )
     distance = num_feature_changes.tolist()
     return distance
@@ -46,7 +46,7 @@ def l1_distance(delta: np.ndarray) -> List[float]:
     List[float]
     """
     absolute_difference = np.abs(delta)
-    distance = np.sum(absolute_difference, axis=1, dtype=np.float).tolist()
+    distance = np.sum(absolute_difference, axis=1, dtype=float).tolist()
     return distance
 
 
@@ -64,7 +64,7 @@ def l2_distance(delta: np.ndarray) -> List[float]:
     List[float]
     """
     squared_difference = np.square(np.abs(delta))
-    distance = np.sum(squared_difference, axis=1, dtype=np.float).tolist()
+    distance = np.sum(squared_difference, axis=1, dtype=float).tolist()
     return distance
 
 

experiments/run_experiment.py

@@ -7,11 +7,8 @@
 
 import numpy as np
 import pandas as pd
-import tensorflow as tf
 import torch
 import yaml
-from tensorflow import Graph, Session
-from tensorflow.python.keras.backend import set_session
 
 import evaluation.catalog as evaluation_catalog
 from data.api import Data
@@ -27,11 +24,9 @@
 RANDOM_SEED = 54321
 
 np.random.seed(RANDOM_SEED)
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 seed(
     RANDOM_SEED
 )  # set the random seed so that the random permutations can be reproduced again
-tf.set_random_seed(RANDOM_SEED)
 torch.manual_seed(RANDOM_SEED)
 warnings.simplefilter(action="ignore", category=FutureWarning)
 
@@ -67,11 +62,11 @@ def initialize_recourse_method(
     data_name: str,
     model_type: str,
     setup: Dict,
-    sess: Session = None,
+    sess=None,
 ) -> RecourseMethod:
     """
     Initializes and returns an instance of a recourse method based on the specified recourse method,
-    machine learning model, data, and an optional TensorFlow session.
+    machine learning model, data, and an optional session parameter.
 
     Parameters
     ----------
@@ -81,7 +76,7 @@ def initialize_recourse_method(
     data_name (str): The name of the dataset.
     model_type (str): The type of machine learning model.
     setup (Dict): The experimental setup containing hyperparameters for the recourse methods.
-    sess (Session, optional): Optional TensorFlow session. Defaults to None.
+    sess (optional): Optional session parameter. Defaults to None.
 
     Returns
     -------
@@ -101,13 +96,27 @@ def initialize_recourse_method(
     elif method == "ar":
         coeffs, intercepts = None, None
         if model_type == "linear":
-            # get weights and bias of linear layer for negative class 0
-            coeffs_neg = mlmodel.raw_model.layers[0].get_weights()[0][:, 0]
-            intercepts_neg = np.array(mlmodel.raw_model.layers[0].get_weights()[1][0])
+            if hasattr(mlmodel.raw_model, "layers"):
+                # Keras-style
+                coeffs_neg = mlmodel.raw_model.layers[0].get_weights()[0][:, 0]
+                intercepts_neg = np.array(
+                    mlmodel.raw_model.layers[0].get_weights()[1][0]
+                )
 
-            # get weights and bias of linear layer for positive class 1
-            coeffs_pos = mlmodel.raw_model.layers[0].get_weights()[0][:, 1]
-            intercepts_pos = np.array(mlmodel.raw_model.layers[0].get_weights()[1][1])
+                coeffs_pos = mlmodel.raw_model.layers[0].get_weights()[0][:, 1]
+                intercepts_pos = np.array(
+                    mlmodel.raw_model.layers[0].get_weights()[1][1]
+                )
+            elif hasattr(mlmodel.raw_model, "linear"):
+                # PyTorch-style
+                weights = mlmodel.raw_model.linear.weight.detach().cpu().numpy()
+                bias = mlmodel.raw_model.linear.bias.detach().cpu().numpy()
+                coeffs_neg = weights[0]
+                intercepts_neg = np.array(bias[0])
+                coeffs_pos = weights[1]
+                intercepts_pos = np.array(bias[1])
+            else:
+                raise ValueError("Unsupported linear model for AR coefficients.")
 
             coeffs = -(coeffs_neg - coeffs_pos)
             intercepts = -(intercepts_neg - intercepts_pos)
@@ -175,7 +184,7 @@ def initialize_recourse_method(
     elif method == "larr":
         return Larr(mlmodel, hyperparams)
     elif method == "rbr":
-        hyperparams["train_data"] = data.df_train.drop(columns=["y"], axis=1)
+        hyperparams["train_data"] = data.df_train.drop(columns=["y"])
         dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         hyperparams["device"] = dev
         return RBR(mlmodel, hyperparams)
@@ -420,8 +429,7 @@ def _append_to_csv(path: str, df: pd.DataFrame):
             ]
         )
 
-    session_models = ["cem", "cem_vae", "greedy"]
-    torch_methods = [
+    pytorch_methods = [
         "cchvae",
         "claproar",
         "clue",
@@ -437,14 +445,27 @@ def _append_to_csv(path: str, df: pd.DataFrame):
         "rbr",
     ]
     sklearn_methods = ["feature_tweak", "focus", "mace"]
+    common_methods = ["ar", "dice", "face", "face_knn", "face_epsilon", "gs"]
+    disabled_methods = {
+        "cem",  # tensorflow
+        "cem_vae",  # tensorflow
+        "greedy",  # tensorflow
+        "causal_recourse",  # causal
+    }
 
     for method_name in args.recourse_method:
-        if method_name in torch_methods:
+        if method_name in disabled_methods:
+            log.info("Skipping disabled recourse method: {}".format(method_name))
+            continue
+        if method_name in pytorch_methods:
             backend = "pytorch"
         elif method_name in sklearn_methods:
             backend = "sklearn"
+        elif method_name in common_methods:
+            backend = "pytorch"  # pytorch by default
         else:
-            backend = "tensorflow"
+            log.warning("Skipping unknown recourse method: {}".format(method_name))
+            continue
         log.info("Recourse method: {}".format(method_name))
         for data_name in args.dataset:
             for model_name in args.type:
@@ -467,91 +488,43 @@ def _append_to_csv(path: str, df: pd.DataFrame):
                     and (data_name == "mortgage" or data_name == "twomoon")
                 ):
                     continue
+                # feature_tweak requires forest model
+                if method_name == "feature_tweak" and model_name != "forest":
+                    log.info(
+                        "Skipping feature_tweak for non-forest model: {}".format(
+                            model_name
+                        )
+                    )
+                    continue
 
                 dataset = DataCatalog(data_name, model_name, args.train_split)
 
-                if method_name in session_models:
-                    graph = Graph()
-                    ann_sess = Session()
-                    session_graph = tf.get_default_graph()
-                    init = tf.global_variables_initializer()
-                    ann_sess.run(init)
-                    with graph.as_default():
-                        with session_graph.as_default():
-                            set_session(ann_sess)
-                            mlmodel_sess = ModelCatalog(dataset, model_name, backend)
-
-                            factuals_sess = predict_negative_instances(
-                                mlmodel_sess, dataset
-                            )
-
-                            recourse_method_sess = initialize_recourse_method(
-                                method_name,
-                                mlmodel_sess,
-                                dataset,
-                                data_name,
-                                model_name,
-                                setup,
-                                sess=ann_sess,
-                            )
-                            factuals_len = len(factuals_sess)
-                            if factuals_len == 0:
-                                continue
-                            elif factuals_len > args.number_of_samples:
-                                factuals_sess = factuals_sess.sample(
-                                    n=args.number_of_samples, random_state=RANDOM_SEED
-                                )
-
-                            factuals_sess = factuals_sess.reset_index(drop=True)
-                            benchmark = Benchmark(
-                                mlmodel_sess, recourse_method_sess, factuals_sess
-                            )
-                            evaluation_measures = [
-                                evaluation_catalog.YNN(
-                                    benchmark.mlmodel, {"y": 5, "cf_label": 1}
-                                ),
-                                evaluation_catalog.Distance(benchmark.mlmodel),
-                                evaluation_catalog.SuccessRate(),
-                                evaluation_catalog.Redundancy(
-                                    benchmark.mlmodel, {"cf_label": 1}
-                                ),
-                                evaluation_catalog.ConstraintViolation(
-                                    benchmark.mlmodel
-                                ),
-                                evaluation_catalog.AvgTime({"time": benchmark.timer}),
-                            ]
-                            df_benchmark = benchmark.run_benchmark(evaluation_measures)
-                else:
-                    mlmodel = ModelCatalog(dataset, model_name, backend)
-                    factuals = predict_negative_instances(mlmodel, dataset)
-
-                    factuals_len = len(factuals)
-                    if factuals_len == 0:
-                        continue
-                    elif factuals_len > args.number_of_samples:
-                        factuals = factuals.sample(
-                            n=args.number_of_samples, random_state=RANDOM_SEED
-                        )
+                mlmodel = ModelCatalog(dataset, model_name, backend)
+                factuals = predict_negative_instances(mlmodel, dataset)
 
-                    factuals = factuals.reset_index(drop=True)
-                    recourse_method = initialize_recourse_method(
-                        method_name, mlmodel, dataset, data_name, model_name, setup
+                factuals_len = len(factuals)
+                if factuals_len == 0:
+                    continue
+                elif factuals_len > args.number_of_samples:
+                    factuals = factuals.sample(
+                        n=args.number_of_samples, random_state=RANDOM_SEED
                     )
 
-                    benchmark = Benchmark(mlmodel, recourse_method, factuals)
-                    evaluation_measures = [
-                        evaluation_catalog.YNN(
-                            benchmark.mlmodel, {"y": 5, "cf_label": 1}
-                        ),
-                        evaluation_catalog.Distance(benchmark.mlmodel),
-                        evaluation_catalog.SuccessRate(),
-                        evaluation_catalog.Redundancy(
-                            benchmark.mlmodel, {"cf_label": 1}
-                        ),
-                        evaluation_catalog.ConstraintViolation(benchmark.mlmodel),
-                        evaluation_catalog.AvgTime({"time": benchmark.timer}),
-                    ]
-                    df_benchmark = benchmark.run_benchmark(evaluation_measures)
+                factuals = factuals.reset_index(drop=True)
+                recourse_method = initialize_recourse_method(
+                    method_name, mlmodel, dataset, data_name, model_name, setup
+                )
+
+                benchmark = Benchmark(mlmodel, recourse_method, factuals)
+                evaluation_measures = [
+                    evaluation_catalog.YNN(benchmark.mlmodel, {"y": 5, "cf_label": 1}),
+                    evaluation_catalog.Distance(benchmark.mlmodel),
+                    evaluation_catalog.SuccessRate(),
+                    evaluation_catalog.Redundancy(benchmark.mlmodel, {"cf_label": 1}),
+                    evaluation_catalog.ConstraintViolation(benchmark.mlmodel),
+                    evaluation_catalog.AvgTime({"time": benchmark.timer}),
+                ]
+                df_benchmark = benchmark.run_benchmark(evaluation_measures)
 
                 df_benchmark["Recourse_Method"] = method_name
                 df_benchmark["Dataset"] = data_name

methods/autoencoder/losses/losses.py

@@ -1,17 +1,32 @@
 import numpy as np
-import tensorflow as tf
 import torch
 import torch.distributions as dists
-from keras import backend as K
+import torch.nn.functional as F
 from torch import nn
 
 
 def binary_crossentropy(y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:
-    return K.sum(K.binary_crossentropy(y_true, y_pred), axis=-1)
+    if torch.is_tensor(y_true) or torch.is_tensor(y_pred):
+        y_true_t = y_true if torch.is_tensor(y_true) else torch.tensor(y_true)
+        y_pred_t = y_pred if torch.is_tensor(y_pred) else torch.tensor(y_pred)
+        return torch.sum(
+            F.binary_cross_entropy(y_pred_t, y_true_t, reduction="none"), dim=-1
+        )
+
+    y_true_np = np.asarray(y_true)
+    y_pred_np = np.asarray(y_pred)
+    eps = 1e-7
+    y_pred_np = np.clip(y_pred_np, eps, 1 - eps)
+    return np.sum(
+        -(y_true_np * np.log(y_pred_np) + (1 - y_true_np) * np.log(1 - y_pred_np)),
+        axis=-1,
+    )
 
 
 def mse(y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:
-    return tf.keras.losses.mean_squared_error(y_true, y_pred)
+    if torch.is_tensor(y_true) or torch.is_tensor(y_pred):
+        return torch.mean((y_true - y_pred) ** 2, dim=-1)
+    return np.mean(np.square(y_true - y_pred), axis=-1)
 
 
 def csvae_loss(csvae, x_train, y_train):