4a Walk Through Analyses with Binary TaCo¶

Imports & path variables etc

from pathlib import Path

import numpy as np
import pandas as pd

import matplotlib as mpl
import matplotlib.pyplot as plt
from sciplotlib import style
import seaborn as sns
from dtreeviz.trees import dtreeviz

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.metrics import make_scorer, roc_auc_score

from julearn.transformers.confounds import DataFrameConfoundRemover

from PIL import Image
from cairosvg import svg2png

from leakconfound.analyses.utils import save_paper_val
from leakconfound.plotting import mm_to_inch
from leakconfound.transformers import Shuffle
import warnings

warnings.filterwarnings("ignore", category=UserWarning)
warnings.filterwarnings("ignore", category=FutureWarning)

mpl.style.use(style.get_style("nature-reviews"))
mpl.rc("xtick", labelsize=11)
mpl.rc("ytick", labelsize=11)
mpl.rc("axes", labelsize=12, titlesize=12)
mpl.rc("figure", dpi=300)
mpl.rc("figure.subplot", wspace=mm_to_inch(4), hspace=mm_to_inch(7))
mpl.rc("lines", linewidth=1)

colors = [
    "#E64B35",
    "#4DBBD5",
    "#00A087",
    "#3C5488",
    "#F39B7F",
    "#8491B4",
    "#91D1C2FF",
    "#DC0000",
    "#7E6148",
    "#B09C85",
]
red = colors[0]
blue = colors[1]
green = colors[2]
purple = colors[5]

project_base = "../../"
out_base = f"{project_base}analyses/content/saved_figures/"
base_save_paper = "./paper_val/"

dt_colors = [
    None,  # 0 classes
    None,  # 1 class
    [purple, green],  # 2 classes
]

Define functions for plotting:

def plot_scatter(x, y, df, threshold, ax=None, **kwargs):
    if ax is None:
        _, ax = plt.subplots()
    sns.stripplot(
        x=x,
        y=y,
        data=df,
        orient="h",
        **kwargs,
        ax=ax,
        edgecolor="w",
        linewidth=0.05,
        palette=[purple, green],
    )
    ax.set_xlabel(f"{x}")
    ax.set_ylabel("")
    ax.legend(loc="upper right")

    ax.axvline(x=threshold, color="grey", linestyle="--", lw=3)
    ax.annotate(
        f"{threshold:.3f}",
        xy=(threshold, 0.01),
        xytext=(threshold, -0.045),
        xycoords=ax.get_xaxis_transform(),
        verticalalignment="top",
        ha="center",
        arrowprops=dict(arrowstyle="->", color="grey", linewidth=1),
        bbox=dict(boxstyle="round", fc="w", color="grey"),
        fontsize=15,
        weight="semibold",
    )
    ax.tick_params(axis="both", which="major", labelsize=20)


def plot_discont(X, hue, data, left_lim, right_lim, colors=None, title=""):
    palette = [purple, green] if colors is None else colors
    y = hue
    df_left = data.query(f"{X} < {left_lim[1]}").copy()
    df_right = data.query(f"{X} > {right_lim[0]}").copy()
    assert len(df_left) + len(df_right) == len(data)
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=[10, 5], sharey=True)
    fig.subplots_adjust(wspace=0.05)
    fig.suptitle(title)
    sns.stripplot(
        x=X,
        y=y,
        data=df_left,
        ax=ax1,
        palette=palette,
        orient="h",
        edgecolor="w",
        linewidth=0.05,
    )
    sns.stripplot(
        x=X,
        y=y,
        data=df_right,
        edgecolor="w",
        orient="h",
        linewidth=0.05,
        ax=ax2,
        palette=palette,
    )

    ax1.axvline(x=left_lim[1], color="grey", linestyle="--", lw=3)
    ax1.set_xlim(left_lim[0], left_lim[1])
    ax1.spines.right.set_visible(False)
    ax1.set_yticklabels([])
    ax1.set_ylabel("")
    ax1.tick_params(left=False)

    # ax2
    ax2.spines.left.set_visible(False)
    ax2.yaxis.tick_left()
    ax2.tick_params(left=False)
    ax2.set_xlim(right_lim[0], right_lim[1])

    d = 1.5  # proportion of vertical to horizontal extent of the slanted line
    kwargs = dict(
        marker=[(-1, -d), (1, d)],
        markersize=12,
        linestyle="none",
        color="k",
        mec="k",
        mew=1,
        clip_on=False,
    )
    ax1.plot([1], [0], transform=ax1.transAxes, **kwargs)
    ax2.plot([0], [0], transform=ax2.transAxes, **kwargs)

    # titles
    ax1.set_xlabel("")
    ax2.set_xlabel("")

    return fig, (ax1, ax2)

Prepare data

np.random.seed(3240987)
auc_scorer = make_scorer(roc_auc_score)
df = pd.read_csv(f"{project_base}data/uci_datasets/bank.csv")


col_names = [col.split("__")[0] for col in df.columns.tolist()]
df.columns = col_names
X_train, X_test, y_train, y_test = train_test_split(
    df.iloc[:, :-1], df.iloc[:, -1], train_size=0.7, stratify=df.iloc[:, -1]
)

Standardize, Shuffle, add Noise for Suppression

zscore = StandardScaler().fit(X_train, y_train)
X_train = pd.DataFrame(zscore.transform(X_train), columns=col_names[:-1])
X_test = pd.DataFrame(zscore.transform(X_test), columns=col_names[:-1])
shuffler = Shuffle().fit(X_train)
X_train_shuffled = shuffler.transform(X_train)
zscore_shuffled = StandardScaler().fit(X_train_shuffled, y_train)
X_train_shuffled = pd.DataFrame(
    zscore.transform(X_train_shuffled), columns=col_names[:-1]
)
X_test_shuffled = shuffler.transform(X_test)
X_test_shuffled = pd.DataFrame(
    zscore.transform(X_test_shuffled), columns=col_names[:-1]
)

noise = np.random.normal(scale=2, size=(len(X_train), 1))
X_train_suppression = X_train + noise

shuffler_suppression = Shuffle().fit(X_train_suppression)
X_train_suppression_shuffled = shuffler_suppression.transform(X_train_suppression)
zscore_supression_shuffled = StandardScaler().fit(X_train_suppression_shuffled, y_train)
X_train_suppression_shuffled = (
    pd.DataFrame(zscore.transform(X_train_suppression_shuffled), columns=col_names[:-1])
    + noise
)

X_train_suppression["noise__:type:__confound"] = noise
X_train_suppression_shuffled["noise__:type:__confound"] = noise


noise = np.random.normal(scale=2, size=(len(X_test), 1))


X_test_suppression = X_test + noise

X_test_suppression_shuffled = shuffler_suppression.transform(X_test_suppression)
X_test_suppression_shuffled = (
    pd.DataFrame(zscore.transform(X_test_suppression_shuffled), columns=col_names[:-1])
    + noise
)

X_test_suppression["noise__:type:__confound"] = noise
X_test_suppression_shuffled["noise__:type:__confound"] = noise