CFXplorer: 生成反事实解释的Python包

pip install CFXplorer

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

from cfxplorer import Focus
from sklearn.datasets import make_classification
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.tree import DecisionTreeClassifier

def generate_example_data(rows: int = 1000):
    """
    Generate random data with a binary target variable and 10 features.

    Args:
        rows (int): The number of rows in the generated dataset.

    Returns:
        pandas.DataFrame: A DataFrame containing the randomly generated data.

    """
    X, y = make_classification(
        n_samples=rows, n_features=10, n_classes=2, random_state=42
    )

    return train_test_split(X, y, test_size=0.2, random_state=42)

def standardize_features(x_train, x_test):
    """
    Standardizes the features of the input data using Min-Max scaling.

    Args:
        x_train (pandas.DataFrame or numpy.ndarray): The training data.
        x_test (pandas.DataFrame or numpy.ndarray): The test data.

    Returns:
        tuple: A tuple containing two pandas DataFrames.
            - The first DataFrame contains the standardized features of the training data.
            - The second DataFrame contains the standardized features of the test data.
    """
    # Create a MinMaxScaler object
    scaler = MinMaxScaler(feature_range=(0, 1))

    # Fit and transform the data to perform feature scaling
    scaler = scaler.fit(x_train)
    scaled_x_train = scaler.transform(x_train)
    scaled_x_test = scaler.transform(x_test)

    # Create a new DataFrame with standardized features
    standardized_train = pd.DataFrame(scaled_x_train)
    standardized_test = pd.DataFrame(scaled_x_test)

    return standardized_train, standardized_test

def train_decision_tree_model(X_train, y_train):
    """
    Train a decision tree model using scikit-learn.

    Args:
        X_train (array-like or sparse matrix of shape (n_samples, n_features)): The training input samples.
        y_train (array-like of shape (n_samples,)): The target values for training.

    Returns:
        sklearn.tree.DecisionTreeClassifier: The trained decision tree model.

    """
    # Create and train the decision tree model
    model = DecisionTreeClassifier(random_state=42)
    model.fit(X_train, y_train)

    return model

  X_train, X_test, y_train, y_test = generate_example_data(1000)
  X_train, X_test = standardize_features(X_train, X_test)
  model = train_decision_tree_model(X_train, y_train)

focus = Focus(
      num_iter=1000,
      distance_function="cosine",
  )

distance_function: str, optional (default="euclidean")
    Distance function - one of followings;
        - "euclidean"
        - "cosine"
        - "l1"
        - "mahalabobis"

optimizer: Keras optimizer, optional (default=tf.keras.optimizers.Adam())
    Optimizer for gradient decent

sigma: float, optional (default=10.0)
    Sigma hyperparameter value for hinge loss

temperature: float, optional (default=1.0)
    Temperature hyperparameter value for hinge loss

distance_weight: float, optional (default=0.01)
    Weight hyperparameter for distance loss

lr: float, optional (default=0.001)
    Learning rate for gradient descent optimization

num_iter: int, optional (default=100)
    Number of iterations for gradient descent optimization

direction: str, optional (default="both")
    Direction of perturbation (e.g. both, positive and negative)

hyperparameter_tuning: bool, optional (default=False)
    if True, generate method returns unchanged_ever and mean_distance

verbose: int, optional (default=1)
    Verbosity mode.
        - 0: silent
        - else: print current number of iterations

perturbed_feats = focus.generate(model, X_test, X_train)

def plot_pca(plot_df, focus_plot_df):
    """
    Plots the PCA-transformed features and corresponding predictions before and after applying FOCUS.

    Args:
        plot_df (pandas.DataFrame): A DataFrame containing the PCA-transformed features and
            predictions before applying FOCUS.
        focus_plot_df (pandas.DataFrame): A DataFrame containing the PCA-transformed features and
            predictions after applying FOCUS.

    Returns:
        None: This function displays the plot but does not return any value.
    """
    fig, axes = plt.subplots(1, 2, figsize=(20, 8))
    sns.scatterplot(
        data=focus_plot_df, x="pca1", y="pca2", hue="predictions", ax=axes[0]
    )
    axes[0].set_title("After applying FOCUS")
    sns.scatterplot(data=plot_df, x="pca1", y="pca2", hue="predictions", ax=axes[1])
    axes[1].set_title("Before applying FOCUS")
    fig.suptitle("Prediction Before and After FOCUS comparison")
    plt.show()


plot_df, focus_plot_df = prepare_plot_df(model, X_test, perturbed_feats)
plot_pca(plot_df, focus_plot_df)

import optuna
import tensorflow as tf

from cfxplorer import Focus


def objective(trial):
    """
    This function is an objective function for
    hyperparameter tuning using optuna.
    It explores the hyperparameter sets and evaluates the result on a
    given model and dataset

    Mean distance and number of unchanged instances are
    used for the evaluation.

    Args:
    trial (optuna.Trial):
    Object that contains information about the current trial,
    including hyperparameters.

    Returns:
    Mean CFE distance + number of unchanged instances squared -
    This is the objective function for hyperparameter optimization

    * Note: typically we want to minimise a number of unchanged first,
        so penalising the score by having squared number.
    Also, to not distort this objective,
    having the mean distance divided by 100.
    """
    X_train, X_test, y_train, y_test = generate_example_data(1000)
    X_train, X_test = standardize_features(X_train, X_test)
    model = train_decision_tree_model(X_train, y_train)

    focus = Focus(
        num_iter=1000,
        distance_function="euclidean",
        sigma=trial.suggest_int("sigma", 1, 20, step=1.0),
        temperature=0,  # DT models do not use temperature
        distance_weight=round(
            trial.suggest_float("distance_weight", 0.01, 0.1, step=0.01), 2
        ),
        lr=round(trial.suggest_float("lr", 0.001, 0.01, step=0.001), 3),
        optimizer=tf.keras.optimizers.Adam(),
        hyperparameter_tuning=True,
        verbose=0,
    )

    best_perturb, unchanged_ever, cfe_distance = focus.generate(model, X_test)

    print(f"Unchanged: {unchanged_ever}")
    print(f"Mean distance: {cfe_distance}")

    return cfe_distance / 100 + pow(unchanged_ever, 2)

if __name__ == "__main__":
    study = optuna.create_study(direction="minimize")
    study.optimize(objective, n_trials=100)

    print(f"Number of finished trials: {len(study.trials)}")

    trial = study.best_trial

    print("Best trial:")
    print("  Value: {}".format(trial.value))
    print("  Params: ")
    for key, value in trial.params.items():
        print("    {}: {}".format(key, value))