def shap_values(model, x_train, x_text, features, initialization_examples): """ Provides feature importances to explain the model. Parameters: x_train: input dataset to train the model x_test: test dataset model: trained model features: list of feature names. Optional, used if doing classification classes: list of output class labels or names. Optional, used if doing classification Returns: explainer (object): provides the feature importances that determines the prediction of the model global_explanation (object): provides the global feature importances that determines the prediction of the model local_explanation (object): provides the global feature importances that determines the prediction of the model """ explainer = TabularExplainer(model, x_train, features=features) # you can use the training data or the test data here global_explanation = explainer.explain_global(x_test) # explain the selected data point in the test set local_explanation = explainer.explain_local(x_test) return explainer, global_explanation, local_explanation
def main(): # Add arguments to script parser = argparse.ArgumentParser() parser.add_argument('--C', type=float, default=1.0, help="Inverse of regularization strength. Smaller values cause stronger regularization") parser.add_argument('--max_iter', type=int, default=100, help="Maximum number of iterations to converge") args = parser.parse_args() run.log("Regularization Strength:", np.float(args.C)) run.log("Max iterations:", np.int(args.max_iter)) model = LogisticRegression(C=args.C, max_iter=args.max_iter).fit(x_train, y_train) accuracy = model.score(x_test, y_test) run.log("Accuracy", np.float(accuracy)) os.makedirs('outputs', exist_ok=True) # files saved in the "outputs" folder are automatically uploaded into run history joblib.dump(model, 'outputs/modelht.pkl') #model_name model_file_name = 'modelht.pkl' # register the model run.upload_file('original_model.pkl', os.path.join('./outputs/', model_file_name)) original_model = run.register_model(model_name='model_explain',model_path='original_model.pkl') # Explain predictions on your local machine tabular_explainer = TabularExplainer(model, x_train, features=feature_names) global_explanation = tabular_explainer.explain_global(x_test) # The explanation can then be downloaded on any compute comment = 'Global explanation on regression model trained on bank marketing campaing dataset' client.upload_model_explanation(global_explanation, comment=comment, model_id=original_model.id)
def interpret_model(model, x_train, x_test, feature_names=None, classes=None): #Using SHAP TabularExplainer explainer = TabularExplainer(model, x_train, features=feature_names, classes=classes) #Generate global explanations global_explanation = explainer.explain_global(x_test) #Return Generated Explanation dashboard return ExplanationDashboard(global_explanation, model, datasetX=x_test)
def test_serialize_kernel(self): test_logger.info("Running test_serialize_kernel to validate inner explainer and wrapped model serialization") x_train, _, y_train, _, feature_names, target_names = create_scikit_cancer_data() model = create_sklearn_svm_classifier(x_train, y_train) explainer = TabularExplainer(model, x_train, features=feature_names, classes=target_names) # Validate wrapped model and inner explainer can be serialized model_name = 'wrapped_model.joblib' explainer_name = 'inner_explainer.joblib' with open(explainer_name, 'wb') as stream: dump(explainer.explainer.explainer, stream) with open(model_name, 'wb') as stream: dump(explainer.model, stream) assert path.exists(model_name) assert path.exists(explainer_name)
def Global_Model_Explanation(model, x_train, x_test, feature_names=None, classes=None, explantion_data=None): #Using SHAP TabularExplainer explainer = TabularExplainer(model, x_train, features=feature_names, classes=classes) #Generate global explanations if explantion_data == 'Training': global_explanation = explainer.explain_global(x_train) else: global_explanation = explainer.explain_global(x_test) ##print the global importance rank data print('global importance rank: {}'.format( global_explanation.get_feature_importance_dict())) #Return Generated Explanation dashboard return global_explanation
def interpret_global(model, train, test, features=None, classes=None, local=False, task=None): # explain predictions on your local machine # "features" and "classes" fields are optional explainer = TabularExplainer(model, train, features=features, classes=classes, model_task=task) # explain overall model predictions (global explanation) global_explanation = explainer.explain_global(test) # uploading global model explanation data for storage or visualization in webUX # the explanation can then be downloaded on any compute # multiple explanations can be uploaded return global_explanation
def train_interpret(self, X, model="tabular"): """ Train a interpret model Parameters ---------- self : object Wrapper X : pd.DataFrame Data that were used in the train for interpret model : string, optional Model to use for the interpret [tabular,mimic_LGBME, mimic_Linear,mimic_SGDE,mimic_Dec_Tree] Returns ------- None """ mimic_models = { "mimic_LGBME": LGBMExplainableModel, "mimic_Linear": LinearExplainableModel, "mimic_SGDE": SGDExplainableModel, "mimic_Dec_Tree": DecisionTreeExplainableModel, } if model == "tabular": explainer = TabularExplainer(self.artifacts["model"], X, features=self.artifacts["columns"]) else: explainer = MimicExplainer( self.artifacts["model"], X, mimic_models[model], augment_data=True, max_num_of_augmentations=10, features=self.artifacts["columns"], ) self.artifacts["explainer"] = explainer
def train_model(df, target): # Creating dummy columns for each categorical feature categorical = [] for col, value in df.iteritems(): if value.dtype == 'object': categorical.append(col) # Store the numerical columns in a list numerical numerical = df.columns.difference(categorical) numeric_transformations = [ ([f], Pipeline(steps=[('imputer', SimpleImputer( strategy='median')), ('scaler', StandardScaler())])) for f in numerical ] categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical] transformations = numeric_transformations + categorical_transformations # Append classifier to preprocessing pipeline clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations) ), ('classifier', LogisticRegression(solver='lbfgs'))]) # Split data into train and test x_train, x_test, y_train, y_test = train_test_split(df, target, test_size=0.35, random_state=0, stratify=target) clf.fit(x_train, y_train) y_pred = clf.predict(x_test) print(classification_report(y_test, y_pred)) accu = accuracy_score(y_test, y_pred) model_file_name = 'classifier.pkl' # save model in the outputs folder so it automatically get uploaded with open(model_file_name, 'wb') as file: joblib.dump(value=clf, filename=os.path.join('./outputs/', model_file_name)) run = Run.get_context() run.log("accuracy", accu) # we upload the model into the experiment artifact store, but do not register it as a model until unit tests are sucessfully passed in next ML step run.upload_file(model_file_name, os.path.join('./outputs/', model_file_name)) #Interpret steps client = ExplanationClient.from_run(run) # Using SHAP TabularExplainer explainer = TabularExplainer(clf.steps[-1][1], initialization_examples=x_train, features=df.columns, classes=["Not leaving", "leaving"], transformations=transformations) # explain overall model predictions (global explanation) global_explanation = explainer.explain_global(x_test) # Sorted SHAP values print('ranked global importance values: {}'.format( global_explanation.get_ranked_global_values())) # Corresponding feature names print('ranked global importance names: {}'.format( global_explanation.get_ranked_global_names())) # Feature ranks (based on original order of features) print('global importance rank: {}'.format( global_explanation.global_importance_rank)) # uploading global model explanation data for storage or visualization in webUX # the explanation can then be downloaded on any compute # multiple explanations can be uploaded client.upload_model_explanation(global_explanation, comment='global explanation: all features')
def model_train(df): run = Run.get_context() df.drop("Sno", axis=1, inplace=True) y_raw = df['Risk'] X_raw = df.drop('Risk', axis=1) categorical_features = X_raw.select_dtypes(include=['object']).columns numeric_features = X_raw.select_dtypes(include=['int64', 'float']).columns categorical_transformer = Pipeline( steps=[('imputer', SimpleImputer(strategy='constant', fill_value="missing")), ('onehotencoder', OneHotEncoder(categories='auto', sparse=False))]) numeric_transformer = Pipeline(steps=[('scaler', StandardScaler())]) feature_engineering_pipeline = ColumnTransformer(transformers=[ ('numeric', numeric_transformer, numeric_features), ('categorical', categorical_transformer, categorical_features) ], remainder="drop") # Encode Labels le = LabelEncoder() encoded_y = le.fit_transform(y_raw) # Train test split X_train, X_test, y_train, y_test = train_test_split(X_raw, encoded_y, test_size=0.20, stratify=encoded_y, random_state=42) # Create sklearn pipeline lr_clf = Pipeline( steps=[('preprocessor', feature_engineering_pipeline ), ('classifier', LogisticRegression(solver="lbfgs"))]) # Train the model lr_clf.fit(X_train, y_train) # Capture metrics train_acc = lr_clf.score(X_train, y_train) test_acc = lr_clf.score(X_test, y_test) print("Training accuracy: %.3f" % train_acc) print("Testing accuracy: %.3f" % test_acc) # Log to Azure ML run.log('Train accuracy', train_acc) run.log('Test accuracy', test_acc) # Explain model explainer = TabularExplainer(lr_clf.steps[-1][1], initialization_examples=X_train, features=X_raw.columns, classes=["Good", "Bad"], transformations=feature_engineering_pipeline) # explain overall model predictions (global explanation) global_explanation = explainer.explain_global(X_test) # Sorted SHAP values print('ranked global importance values: {}'.format( global_explanation.get_ranked_global_values())) # Corresponding feature names print('ranked global importance names: {}'.format( global_explanation.get_ranked_global_names())) # Feature ranks (based on original order of features) print('global importance rank: {}'.format( global_explanation.global_importance_rank)) client = ExplanationClient.from_run(run) client.upload_model_explanation(global_explanation, comment='Global Explanation: All Features') return lr_clf
model_file_name = 'ridge_{0:.2f}.pkl'.format(alpha) # save model in the outputs folder so it automatically get uploaded with open(model_file_name, 'wb') as file: joblib.dump(value=reg, filename=os.path.join(OUTPUT_DIR, model_file_name)) # register the model run.upload_file('original_model.pkl', os.path.join('./outputs/', model_file_name)) original_model = run.register_model( model_name='model_explain_model_on_amlcomp', model_path='original_model.pkl') # Explain predictions on your local machine tabular_explainer = TabularExplainer(model, X_train, features=boston_data.feature_names) # Explain overall model predictions (global explanation) # Passing in test dataset for evaluation examples - note it must be a representative sample of the original data # x_train can be passed as well, but with more examples explanations it will # take longer although they may be more accurate global_explanation = tabular_explainer.explain_global(X_test) # Uploading model explanation data for storage or visualization in webUX # The explanation can then be downloaded on any compute comment = 'Global explanation on regression model trained on boston dataset' client.upload_model_explanation(global_explanation, comment=comment, model_id=original_model.id)
def main(): print("Running train_aml.py") parser = argparse.ArgumentParser("train") parser.add_argument( "--model_name", type=str, help="Name of the Model", default="diabetes_model.pkl", ) parser.add_argument("--step_output", type=str, help=("output for passing data to next step")) parser.add_argument("--dataset_version", type=str, help=("dataset version")) parser.add_argument("--data_file_path", type=str, help=("data file path, if specified,\ a new version of the dataset will be registered")) parser.add_argument( "--caller_run_id", type=str, help=("caller run id, for example ADF pipeline run id")) parser.add_argument("--dataset_name", type=str, help=("Dataset name. Dataset must be passed by name\ to always get the desired dataset version\ rather than the one used while the pipeline creation")) args = parser.parse_args() print("Argument [model_name]: %s" % args.model_name) print("Argument [step_output]: %s" % args.step_output) print("Argument [dataset_version]: %s" % args.dataset_version) print("Argument [data_file_path]: %s" % args.data_file_path) print("Argument [caller_run_id]: %s" % args.caller_run_id) print("Argument [dataset_name]: %s" % args.dataset_name) model_name = args.model_name step_output_path = args.step_output dataset_version = args.dataset_version data_file_path = args.data_file_path dataset_name = args.dataset_name run = Run.get_context() print("Getting training parameters") # Load the training parameters from the parameters file with open("parameters.json") as f: pars = json.load(f) try: train_args = pars["training"] except KeyError: print("Could not load training values from file") train_args = {} # Log the training parameters print(f"Parameters: {train_args}") for (k, v) in train_args.items(): run.log(k, v) run.parent.log(k, v) # Get the dataset if (dataset_name): if (data_file_path == 'none'): dataset = Dataset.get_by_name(run.experiment.workspace, dataset_name, dataset_version) # NOQA: E402, E501 else: dataset = register_dataset(run.experiment.workspace, dataset_name, os.environ.get("DATASTORE_NAME"), data_file_path) else: e = ("No dataset provided") print(e) raise Exception(e) # Link dataset to the step run so it is trackable in the UI run.input_datasets['training_data'] = dataset run.parent.tag("dataset_id", value=dataset.id) # Split the data into test/train df0 = dataset.to_pandas_dataframe() df = prepare_data(df0) data = split_data(df) # Train the model model = train_model(data, train_args) explainer = TabularExplainer(model, data["train"]["X"], features=df0.drop(['car name', 'mpg'], axis=1).columns) global_explanation = explainer.explain_global(data["test"]["X"]) client = ExplanationClient.from_run(run) client.upload_model_explanation(global_explanation, comment='MPG Predication Explanation') # Evaluate and log the metrics returned from the train function metrics = get_model_metrics(model, data) for (k, v) in metrics.items(): run.log(k, v) run.parent.log(k, v) # Pass model file to next step os.makedirs(step_output_path, exist_ok=True) model_output_path = os.path.join(step_output_path, model_name) joblib.dump(value=model, filename=model_output_path) # Also upload model file to run outputs for history os.makedirs('outputs', exist_ok=True) output_path = os.path.join('outputs', model_name) joblib.dump(value=model, filename=output_path) run.tag("run_type", value="train") print(f"tags now present for run: {run.tags}") run.complete()
# preds = reg.predict(X_test) run.log('C', C) run.log('gamma', gamma) model_file_name = 'svc.pkl' # save model in the outputs folder so it automatically get uploaded with open(model_file_name, 'wb') as file: joblib.dump(value=reg, filename=os.path.join(OUTPUT_DIR, model_file_name)) # register the model run.upload_file('original_model.pkl', os.path.join('./outputs/', model_file_name)) original_model = run.register_model(model_name='model_explain_model_on_amlcomp', model_path='original_model.pkl') # Explain predictions on your local machine tabular_explainer = TabularExplainer(model, X_train.to_pandas(), features=X_train.columns, use_gpu=True) # Explain overall model predictions (global explanation) # Passing in test dataset for evaluation examples - note it must be a representative sample of the original data # x_train can be passed as well, but with more examples explanations it will # take longer although they may be more accurate global_explanation = tabular_explainer.explain_global(X_test.to_pandas()[:50]) # Uploading model explanation data for storage or visualization in webUX # The explanation can then be downloaded on any compute comment = 'Global explanation on regression model trained on boston dataset' client.upload_model_explanation(global_explanation, comment=comment, model_id=original_model.id)
# MimicExplainer from interpret.ext.blackbox import MimicExplainer from interpret.ext.glassbox import DecisionTreeExplainableModel mim_explainer = MimicExplainer(model=loan_model, initialization_examples=X_test, explainable_model = DecisionTreeExplainableModel, features=['loan_amount','income','age','marital_status'], classes=['reject', 'approve']) # TabularExplainer from interpret.ext.blackbox import TabularExplainer tab_explainer = TabularExplainer(model=loan_model, initialization_examples=X_test, features=['loan_amount','income','age','marital_status'], classes=['reject', 'approve']) # PFIExplainer from interpret.ext.blackbox import PFIExplainer pfi_explainer = PFIExplainer(model = loan_model, features=['loan_amount','income','age','marital_status'], classes=['reject', 'approve']) # MimicExplainer global_mim_explanation = mim_explainer.explain_global(X_train) global_mim_feature_importance = global_mim_explanation.get_feature_importance_dict()
# save model for use outside the script model_file_name = 'original_model.pkl' with open(model_file_name, 'wb') as file: joblib.dump(value=clf, filename=os.path.join(OUTPUT_DIR, model_file_name)) # register the model with the model management service for later use run.upload_file('original_model.pkl', os.path.join(OUTPUT_DIR, model_file_name)) original_model = run.register_model(model_name='amlcompute_deploy_model', model_path='original_model.pkl') # - # create an explainer to validate or debug the model tabular_explainer = TabularExplainer(model, initialization_examples=x_train, features=attritionXData.columns, classes=["Staying", "Leaving"], transformations=transformations) # explain overall model predictions (global explanation) # passing in test dataset for evaluation examples - note it must be a representative sample of the original data # more data (e.g. x_train) will likely lead to higher accuracy, but at a time cost global_explanation = tabular_explainer.explain_global(x_test) # uploading model explanation data for storage or visualization comment = 'Global explanation on classification model trained on IBM employee attrition dataset' client.upload_model_explanation(global_explanation, comment=comment, model_id=original_model.id) # also create a lightweight explainer for scoring time
print("Running train.py") # Randomly pic alpha alphas = np.arange(0.0, 0.5, 0.01) alpha = alphas[np.random.choice(alphas.shape[0], 1, replace=False)][0] print(alpha) run.log("alpha", alpha) reg = Ridge(alpha=alpha) reg.fit(data["train"]["X"], data["train"]["y"]) preds = reg.predict(data["test"]["X"]) run.log("mse", mean_squared_error(preds, data["test"]["y"])) # create an explainer to validate or debug the model tabular_explainer = TabularExplainer(reg, initialization_examples=X_train, features=columns) # explain overall model predictions (global explanation) # passing in test dataset for evaluation examples global_explanation = tabular_explainer.explain_global(X_test) # uploading model explanation data for storage or visualization comment = 'Global explanation on of Diabetes Regression' client.upload_model_explanation(global_explanation, comment=comment) with open(model_name, "wb") as file: joblib.dump(value=reg, filename=model_name) # upload the model file explicitly into artifacts run.upload_file(name="./outputs/" + model_name, path_or_stream=model_name)
from interpret.ext.blackbox import TabularExplainer iris = load_iris() X = iris['data'] y = iris['target'] classes = iris['target_names'] feature_names = iris['feature_names'] x_train, x_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=0) clf = svm.SVC(gamma=0.001, C=100., probability=True) model = clf.fit(x_train, y_train) explainer = TabularExplainer(model, x_train, features=feature_names, classes=classes) global_explanation = explainer.explain_global(x_test) instance_num = 0 local_explanation = explainer.explain_local(x_test[instance_num, :]) prediction_value = clf.predict(x_test)[instance_num] sorted_local_importance_values = local_explanation.get_ranked_local_values()[ prediction_value] sorted_local_importance_names = local_explanation.get_ranked_local_names()[ prediction_value]
Y_predict = rfc.predict(X_test) # Evaluate the RFC model from sklearn.metrics import confusion_matrix cm = confusion_matrix(Y_test, Y_predict) score = rfc.score(X_test, Y_test) #explainability from interpret.ext.blackbox import TabularExplainer classes = ['Not Greater than 50k', "Greater than 50k"] features = list(X.columns) tab_explainer = TabularExplainer(trained_model, X_train, features=features, classes=classes) #global global_explaination = tab_explainer.explain_global(X_train) global_fi = global_explaination.get_feature_importance_dict() #local X_explain = X_test[:5] local_explaination = tab_explainer.explain_local(X_explain) local_f = local_explaination.get_ranked_local_names() local_importance = local_explaination.get_ranked_local_values()
# Train a decision tree model print('Training a decision tree model') model = DecisionTreeClassifier().fit(X_train, y_train) # calculate accuracy y_hat = model.predict(X_test) acc = np.average(y_hat == y_test) run.log('Accuracy', np.float(acc)) # calculate AUC y_scores = model.predict_proba(X_test) auc = roc_auc_score(y_test, y_scores[:, 1]) run.log('AUC', np.float(auc)) os.makedirs('outputs', exist_ok=True) # note file saved in the outputs folder is automatically uploaded into experiment record joblib.dump(value=model, filename='outputs/diabetes.pkl') # Get explanation explainer = TabularExplainer(model, X_train, features=features, classes=labels) explanation = explainer.explain_global(X_test) # Get an Explanation Client and upload the explanation explain_client = ExplanationClient.from_run(run) explain_client.upload_model_explanation(explanation, comment='Tabular Explanation') # Complete the run run.complete()
model = clf.steps[-1][1] # save model for use outside the script model_file_name = 'log_reg.pkl' joblib.dump(value=clf, filename=os.path.join(OUTPUT_DIR, model_file_name)) # register the model with the model management service for later use run.upload_file('model.pkl', os.path.join(OUTPUT_DIR, model_file_name)) original_model = run.register_model(model_name='creditmodel_explainer_remote', model_path='model.pkl') print('create explainer') # create an explainer to validate or debug the model tabular_explainer = TabularExplainer(model, x_train, features=creditXData.columns, classes=[0, 1], transformations=transformations) # explain overall model predictions (global explanation) # passing in test dataset for evaluation examples - note it must be a representative sample of the original data # more data (e.g. x_train) will likely lead to higher accuracy, but at a time cost global_explanation = tabular_explainer.explain_global(x_test) print('upload explanation') # uploading model explanation data for storage or visualization comment = 'Global explanation on classification model trained on German credit dataset' client.upload_model_explanation(global_explanation, comment=comment) if not is_remote_run: run.complete()
# 2. Mimic Explainer from interpret.ext.blackbox import MimicExplainer # You can use one of the following four interpretable models as a global surrogate to the black box model from interpret.ext.glassbox import LGBMExplainableModel from interpret.ext.glassbox import LinearExplainableModel from interpret.ext.glassbox import SGDExplainableModel from interpret.ext.glassbox import DecisionTreeExplainableModel # OR # 3. PFI Explainer from interpret.ext.blackbox import PFIExplainer # In[9]: explainer = TabularExplainer(m, X_train, features=featu_na, classes=classes) # In[13]: X_tests = joblib.load("X_tests") # In[15]: X_test = joblib.load("X_test") # In[16]: X_t, X_tests, y_train, y_tests = train_test_split(X_test, y_test, test_size=0.02, random_state=56)
from sklearn.model_selection import train_test_split from interpret.ext.blackbox import TabularExplainer breast_cancer_data = load_breast_cancer() classes = breast_cancer_data.target_names.tolist() x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data, breast_cancer_data.target, test_size=0.2, random_state=42) clf = RandomForestClassifier() model = clf.fit(x_train, y_train) # "features" and "classes" fields are optional explainer = TabularExplainer(model, x_train, features=breast_cancer_data.feature_names, classes=classes) # you can use the training data or the test data here global_explanation = explainer.explain_global(x_train) # sorted feature importance values and feature names sorted_global_importance_values = global_explanation.get_ranked_global_values() sorted_global_importance_names = global_explanation.get_ranked_global_names() print( f'Type: {type(sorted_global_importance_values)}, Value: {sorted_global_importance_values}' ) print( f'Type: {type(sorted_global_importance_names)}, Value: {sorted_global_importance_names}' ) print(
run.log("Test R2 Score", test_r2) run.log("RMSE", rmse) print("Saving the model to outputs ...") model_file_name = 'gbr_tickfund.pkl' joblib.dump(value=gbr, filename='outputs/model.pkl') with open(model_file_name, 'wb') as file: joblib.dump(value=gbr, filename=os.path.join(OUTPUT_DIR, model_file_name)) # register the model run.upload_file('dev_model.pkl', os.path.join('./outputs/', model_file_name)) original_model = run.register_model(model_name='gbr_model_train_msft', model_path='dev_model.pkl') # Explain predictions on your local machine tabular_explainer = TabularExplainer(gbr, train_features, features=df.columns) # Explain overall model predictions (global explanation) # Passing in test dataset for evaluation examples - note it must be a representative sample of the original data # x_train can be passed as well, but with more examples explanations it will # take longer although they may be more accurate global_explanation = tabular_explainer.explain_global(test_features) # Uploading model explanation data for storage or visualization in webUX # The explanation can then be downloaded on any compute comment = 'Global explanation on regression model trained on ticker fund dataset' client.upload_model_explanation(global_explanation, comment=comment, model_id=original_model.id)
print(cm) # Save the model as .pkl file and # save model file to the outputs/ folder - this will auto upload the model to the run in AzureML model_file_name = 'log_reg.pkl' #TODO: Write out the real model file :) from interpret.ext.blackbox import TabularExplainer from azureml.interpret import ExplanationClient # create an explanation client to store the explanation (contrib API) client = ExplanationClient.from_run(run) print('create explainer') # create an explainer to validate or debug the model tabular_explainer = TabularExplainer(clf.steps[-1][1], initialization_examples=x_train, features=attritionXData.columns, classes=["Not leaving", "leaving"], transformations=transformations) # explain overall model predictions (global explanation) # passing in test dataset for evaluation examples - note it must be a representative sample of the original data # more data (e.g. x_train) will likely lead to higher accuracy, but at a time cost global_explanation = tabular_explainer.explain_global(x_test) print('upload explanation') # uploading model explanation data for storage or visualization comment = 'Global explanation on classification model trained on IBM employee attrition dataset' client.upload_model_explanation(global_explanation, comment=comment) # save model in the outputs folder so it automatically get uploaded with open(model_file_name, 'wb') as file: