可解释的AI：用LIME解释扑克游戏

 from ctypes import alignment from functools import partial
 import matplotlib.pyplot as plt import numpy as np import pandas as pd from hyperopt import STATUS_OK, Trials, fmin, hp, space_eval, tpe from hyperopt.pyll import scope from lime import lime_tabular from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import f1_score

 def objective(params:dict, X_train:pd.DataFrame, y_train:pd.DataFrame, X_val:pd.DataFrame, y_val:pd.DataFrame)->dict:    """This function is used as objecive for the hyperparameter tuning    Parameters    ----------    params : dict        parameters for the model    X_train : pd.Dataframe        Feature dataset for training    y_train : pd.DataFrame        Target variable for training    X_val : pd.DataFrame          Feature dataset for validation    y_val : pd.DataFrame        Target variable for validation    Returns    -------    dict        loss and status for hyperopt    """
    # define the model    model = RandomForestClassifier(random_state=1, **params)
    # train the model    model.fit(X_train,y_train)
    # validate and get the score    score = model.score(X_val, y_val)
    return {"loss": -score, "status": STATUS_OK}
 def find_best_parameters(seed:int=2, **kwargs)->dict:    """In this function hpo is performed    Parameters    ----------    seed : int, optional        random seed, by default 2    Returns    -------    dict        best paramers found by hyperopt    """
    # initialize trials    trial = Trials()
    # initialize the objetve function    partial_objective = partial(            objective,            X_train=kwargs['X_train'],            y_train=kwargs['y_train'],            X_val=kwargs['X_val'],            y_val=kwargs['y_val']        )
    # initialize the search space for hyperopt    params = {'n_estimators': scope.int(hp.quniform('n_estimators', 100, 500, 10)),              'max_depth': scope.int(hp.quniform('max_depth', 5, 60, 2)),              'min_samples_leaf': scope.int(hp.quniform('min_samples_leaf', 1, 10, 1)),              'min_samples_split': scope.int(hp.quniform('min_samples_split', 2, 10, 1))}
    # find best params    best_argmin = fmin(            fn=partial_objective,            space=params,            algo=tpe.suggest,            max_evals=50,            trials=trial,            rstate=np.random.default_rng(seed),        )  
    best_params = space_eval(params, best_argmin)
    return best_params
 # Tweak the output to make it look nicer def as_pyplot_figure(    exp, classif, classes_names, instance_to_explain, label:int=1, figsize=(4, 4) ):    """This function has been taked from the lime package and tweaked for this particular use case    Parameters    ----------    exp : _type_        lime explanation of the instance to explain    classif : _type_        clssification type    classes_names : _type_        names of the classrs    instance_to_explain : _type_        the instance of the data which should be explained    label : int, optional        label for protting - of the explanation instance, by default 1    figsize : tuple, optional        desired size of pyplot in tuple format, defaults to (4,4).    Returns    -------    _type_        figure with the explanations    """

    # find the explanation for a particular label    exp_list = exp.as_list(label=label)      fig, ax = plt.subplots(figsize=figsize)    vals = [x[1] for x in exp_list]    names = [x[0] for x in exp_list]
    # plot the contributions    vals.reverse()    names.reverse()    colors = ["green" if x > 0 else "red" for x in vals]    pos = np.arange(len(exp_list)) + 0.5    ax.barh(pos, vals, align="center", color=colors)    ax.set_yticks(pos, labels=names)    limit = max(abs(min(vals)), abs(max(vals)))    ax.set_xlim(left=-limit, right=limit)    ax.set_xticks([])    ax.set_xlabel("Contribution")
    # Add second axis with the values of the cards    suits = {1: "\u2661", 2: "\u2660", 3: "\u2662", 4: "\u2663"}    ranks = {        1: "Ace",        2: "Two",        3: "Three",        4: "Four",        5: "Five",        6: "Six",        7: "Seven",        8: "Eight",        9: "Nine",        10: "Ten",        11: "Jack",        12: "Queen",        13: "King",    }
    # etract the data from the explanation    list_figures = []    for i in exp_list:

        if "S" in i[0]:            if '=' in i[0]:
                # logic for categorical                new_string = i[0][i[0].index("S") :]                extract = int(new_string[ new_string.index("=")+1:])                list_figures.append(suits[extract])
            else:
                # logic for continuous variables                new_string = i[0][i[0].index("S") :]                extract = new_string[: new_string.index(" ")]                list_figures.append(suits[instance_to_explain.loc[extract]])
        elif "R" in i[0]:
            if '=' in i[0]:
                # logic for categorical                new_string = i[0][i[0].index("R") :]                extract = int(new_string[ new_string.index("=")+1:])                list_figures.append(ranks[extract])
            else:
                # logic for continous variables                new_string = i[0][i[0].index("R") :]                extract = new_string[: new_string.index(" ")]                list_figures.append(ranks[instance_to_explain.loc[extract]])
    # create second axis    ax2 = ax.twinx()    ax2.set_yticks(ticks=np.arange(len(exp_list)) + 0.5, labels=list_figures[::-1])    ax2.barh(pos, vals, align="center", color=colors)
    # add title    if classif == "classification":        title = f"Why {classes_names[label][4:]}?"    else:        title = "Local explanation"    plt.title(title)    plt.tight_layout()
    return fig

 # Read dataset df_test = pd.read_csv("./data/df_test.csv") df_train = pd.read_csv("./data/df_train.csv")
 # Let's take the suit and the rank (value) of each card col_names = ["S1", "R1", "S2", "R2", "S3", "R3", "S4", "R4", "S5", "R5", "y"] df_train.columns = col_names df_test.columns = col_names
 # Define our hand combinations target_labels = [    "0 - High card",    "1 - One pair",    "2 - Two pairs",    "3 - Three of a kind",    "4 - Straight",    "5 - Flush",    "6 - Full house",    "7 - Four of a kind",    "8 - Straight flush",    "9 - Royal flush", ]
 # get the training and validation sets y = df_train["y"] X = df_train.drop(columns="y") X_train, X_val, y_train, y_val = train_test_split(    X, y, test_size=0.3, random_state=1 )
 # find best parameters best = find_best_parameters(X_train=X_train, X_val=X_val, y_train=y_train, y_val=y_val)
 # Get test data y_test = df_test["y"] X_test = df_test.drop(columns="y")
 # Get train data y_train = df_train["y"] X_train = df_train.drop(columns="y")
 # Fit with a black-box model on full train dataset model = RandomForestClassifier(random_state=42, **best) model.fit(X_train, y_train)
 # get the F1-score of the model on the test set y_pred = model.predict(X_test) f1score = f1_score(y_test, y_pred, average='weighted')
 # define instances to explain (any instance from train / test can be taken here) instance_1 = pd.Series({'S1': 2, 'R1': 2,                        'S2': 4, 'R2': 3,                        'S3': 4, 'R3': 7,                        'S4': 4, 'R4': 1,                        'S5': 2, 'R5': 1})
 instance_2 = pd.Series({'S1': 4, 'R1': 2,                        'S2': 4, 'R2': 3,                        'S3': 4, 'R3': 4,                        'S4': 4, 'R4': 5,                        'S5': 4, 'R5': 10})
 # initialise LIME explainer = lime_tabular.LimeTabularExplainer(    training_data=np.array(X_train),    feature_names=X_train.columns,    class_names=target_labels,    mode="classification",    categorical_features= [i for i in range(10)] )
 for instance_to_explain, label in zip([instance_1, instance_2], [1, 5]):
    # create explanation    exp = explainer.explain_instance(        data_row=instance_to_explain, predict_fn=model.predict_proba, num_features=10, labels=[label]    )
    # visualize: using lime show_in_noteboook()    exp.show_in_notebook(show_table=True)
    # visualize using the custom visualization    as_pyplot_figure(exp=exp, classif="classification", classes_names=target_labels, instance_to_explain=instance_to_explain, label=label);