可解释的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);