devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[可解释机器学习]Task07：LIME、shap代码实战_shap的pytorch

作者：weixin_40725706 | 2024-02-16 23:01:24

赞

踩

shap的pytorch

GPU平台：Kaggle

一、shap工具包

第一部分：基于shapley值的机器学习可解释分析

第二部分：代码实战-UCl心脏病二分类随机森林可解释性分析

第三部分：使用SHAP工具包对pytorch的图像分类模型进行可解释分析

第一部分：基于shapley值的机器学习可解释分析

  • 什么是Shapley值？博弈论中的Shapley值 

 

 在机器学习中，Shapley值反映了特定样本的特征重要度

相关论文如下：

  •  介绍一下shap工具包

 

 第二部分：代码实战-UCl心脏病二分类随机森林可解释性分析

这里是做简略描述，具体还得看具体讲解 

模型在测试集上表现不错

 但在实际上模型到底有没有学到关键特征呢，是不是符合人类常识？需要可解释分析

可以选本身可解释性就很好的模型

如：决策树

 随机森林的特征重要性

 置换特征重要性

 PDP图与ICE图

 

 

 

 

 

 第三部分：使用SHAP工具包对pytorch的图像分类模型进行可解释分析

A-安装配置环境

  1. ##下载shap工具包
  2. !pip install numpy pandas matplotlib requests tqdm opencv-python pillow shap tensorflow keras -i https://pypi.tuna.tsinghua.edu.cn/simple
  3.  
  4. ##验证shap工具包安装成功
  5. import shap
  6.  
  7. ##下载安装Pytorch
  8. !pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113
  9.  
  10. ##创建目录
  11. import os
  12.  
  13. #存放测试图片
  14. os.mkdir('test_img')
  15.  
  16. #存放结果文件
  17. os.mkdir('output')
  18.  
  19. #存放标注文件
  20. os.mkdir('data')
  21.  
  22. ##下载中文字体文件
  23. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/SimHei.ttf -P data
  24.  
  25. ##下载ImageNet1000类别信息
  26. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/meta_data/imagenet_class_index.csv -P data
  27.  
  28. ##下载训练好的水果图像分类模型，及类别名称信息
  29. # 下载样例模型文件
  30. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/checkpoints/fruit30_pytorch_20220814.pth -P checkpoint
  31.  
  32. # 下载 类别名称 和 ID索引号 的映射字典
  33. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/fruit30/labels_to_idx.npy -P data
  34. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/fruit30/idx_to_labels.npy -P data
  35.  
  36. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220919-explain/imagenet_class_index.json -P data
  37.  
  38. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/fruit30/idx_to_labels_en.npy -P data
  39.  
  40. ##下载测试图像文件至test_img文件夹
  41. # 边牧犬，来源：https://www.woopets.fr/assets/races/000/066/big-portrait/border-collie.jpg
  42. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/border-collie.jpg -P test_img
  43.  
  44. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/cat_dog.jpg -P test_img
  45.  
  46. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/0818/room_video.mp4 -P test_img
  47.  
  48. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/swan-3299528_1280.jpg -P test_img
  49.  
  50. # 草莓图像，来源：https://www.pexels.com/zh-cn/photo/4828489/
  51. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/0818/test_草莓.jpg -P test_img
  52.  
  53. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_fruits.jpg -P test_img
  54.  
  55. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_orange_2.jpg -P test_img 
  56.  
  57. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/banana-kiwi.png -P test_img
  58.  
  59. ##设置matplotlib中文字体
  60. import matplotlib.pyplot as plt
  61. %matplotlib inline
  62.  
  63. # # windows操作系统
  64. # plt.rcParams['font.sans-serif']=['SimHei']  # 用来正常显示中文标签 
  65. # plt.rcParams['axes.unicode_minus']=False  # 用来正常显示负号
  66.  
  67. # Mac操作系统，参考 https://www.ngui.cc/51cto/show-727683.html
  68. # 下载 simhei.ttf 字体文件
  69. # !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/SimHei.ttf
  70.  
  71. # Linux操作系统，例如 云GPU平台：https://featurize.cn/?s=d7ce99f842414bfcaea5662a97581bd1
  72. # 如果报错 Unable to establish SSL connection.，重新运行本代码块即可
  73. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/SimHei.ttf -O /environment/miniconda3/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/ttf/SimHei.ttf --no-check-certificate
  74. !rm -rf /home/featurize/.cache/matplotlib
  75.  
  76. import matplotlib
  77. import matplotlib.pyplot as plt
  78. %matplotlib inline
  79. matplotlib.rc("font",family='SimHei') # 中文字体
  80. plt.rcParams['axes.unicode_minus']=False  # 用来正常显示负号
  81.  
  82. plt.plot([1,2,3], [100,500,300])
  83. plt.title('matplotlib中文字体测试', fontsize=25)
  84. plt.xlabel('X轴', fontsize=15)
  85. plt.ylabel('Y轴', fontsize=15)
  86. plt.show()

 B-Pytorch-MNIST分类可解释性分析

用Pythorch构建简单的 卷积神经网络，在MNIST手写数字数据集上，使用shap的Deep Explainer进行可解释性分析。

可视化每一张图像的每一个像素，对模型预测为每一个类别的影响。

  1. ##导入工具包
  2. import torch, torchvision
  3. from torchvision import datasets, transforms
  4. from torch import nn, optim
  5. from torch.nn import functional as F
  6.  
  7. import numpy as np
  8. import shap
  9.  
  10. ##用Pytorch构建卷积神经网络
  11. class Net(nn.Module):
  12.     def __init__(self):
  13.         super(Net, self).__init__()
  14.  
  15.         self.conv_layers = nn.Sequential(
  16.             nn.Conv2d(1, 10, kernel_size=5),
  17.             nn.MaxPool2d(2),
  18.             nn.ReLU(),
  19.             nn.Conv2d(10, 20, kernel_size=5),
  20.             nn.Dropout(),
  21.             nn.MaxPool2d(2),
  22.             nn.ReLU(),
  23.         )
  24.         self.fc_layers = nn.Sequential(
  25.             nn.Liner(320, 50),
  26.             nn.ReLU(),
  27.             nn.Dropout(),
  28.             nn.Linear(50, 10),
  29.             nn.Softmax(dim=1)
  30.         )
  31.     def forward(self, x):
  32.         x = self.conv_layers(x)
  33.         x = x.view(-1, 320)
  34.         x = self.fc_layers(x)
  35.         return x
  36.  
  37. ##初始化模型
  38. model = Net()
  39. optimizer = optim.SGD(model.parameters(), 1r=0.01, momentum=0.5)
  40.  
  41. ##载入MNIST数据集
  42. train_dataset = dataset.MNIST('mnist_data',
  43.                                train=True,
  44.                                download=True,
  45.                                transform=transforms.Compose([transforms.ToTensor()]))
  46.  
  47. test_dataset = dataset.MNIST('mnist_data',
  48.                                train=False,
  49.                                download=True,
  50.                                transform=transforms.Compose([transforms.ToTensor()]))
  51.  
  52. bantch_size = 256
  53. train_loader = torch.utils.data.DataLoader(
  54.     train_dataset,
  55.     batch_size=ban_size,
  56.     shuffle=True)
  57.  
  58. test_loader = torch.utils.data.DataLoader(
  59.     test_dataset,
  60.     batch_size=ban_size,
  61.     shuffle=True)
  62.  
  63. ##训练模型
  64. num_epochs = 5
  65. device = torch.device('cpu')
  66.  
  67. def train(model, device, train_loader, optimizer, epoch):
  68.     #训练一个epoch
  69.     model.train()
  70.     for batch_idx, (data, target) in enumerate(train_loader):
  71.         data, target = data.to(device), target.to(device)
  72.         optimizer.zero_grad()
  73.         output = model(data)
  74.         loss = F.null_loss(output.log(), target)
  75.         loss.backward()
  76.         optimizer.step()
  77.         if batch_idx % 100 == 0:
  78.             print('Train Epoch: {} [{} / {} ({:.0f}%)]\tLoss: {:.6f}'.format(
  79.                 epoch, batch_idx * len(data), len(train_loader.dataset),
  80.                 100. *batch_idx / len(train_loader), loss.item()))
  81.  
  82. def test(model, device, test_loader):
  83.     # 测试一个 epoch
  84.     model.eval()
  85.     test_loss = 0
  86.     correct = 0
  87.     with torch.no_grad():
  88.         for data, target in test_loader:
  89.             data, target = data.to(device), target.to(device)
  90.             output = model(data)
  91.             test_loss += F.nll_loss(output.log(), target).item() # sum up batch loss
  92.             pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability
  93.             correct += pred.eq(target.view_as(pred)).sum().item()
  94.  
  95.     test_loss /= len(test_loader.dataset)
  96.     print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
  97.         test_loss, correct, len(test_loader.dataset),
  98.     100. * correct / len(test_loader.dataset)))
  99.  
  100. for epoch in range(1, num_epochs + 1):
  101.     train(model, device, train_loader, optimizer, epoch)
  102.     test(model, device, test_loader)

 

  1. ##获取背景样本和测试样本
  2. images, labels = next(iter(test_loader))
  3.  
  4. images.shape
  5.  
  6. #B背景图像样本
  7. background = images[:250]
  8.  
  9. #测试图像样本
  10. test_images = images[250:254]
  11.  
  12. ##初始化Deep Explainer
  13. e = shap.DeepExplainer(model, background)
  14.  
  15. ##计算每个类别、每张测试图像、每个像素，对应的shap值
  16. shap_values = e.shap_values(test_images)
  17.  
  18. #类别1，所有测试图像，每个像素的shap值
  19. print(shap_values[1].shape)

 输出结果为(4, 1, 28, 28)

  1. ##整理张量结构
  2. #shap值
  3. shap_numpy = [np.swapaxes(np.swapaxes(s, 1, -1), 1, 2) for s in shap_values]
  4.  
  5. #测试图像
  6. test_numpy = np.swapaxes(np.swapaxes(test_images.numpy(), 1, -1), 1, 2)
  7.  
  8. ##可视化
  9. print(shap.image_plot(shap_numpy, -test_numpy))

 展示了每个测试图像样本的每个像素，对10个类别的shap值。

红色代表shap正值：对模型预测为该类别有正向作用

蓝色代表shap正值：对模型预测为该类别有正向作用

AI告诉我们，它认为7和9的区别，2和3的区别等等

#无论像素值高低，都可能对某个类别产生较大影响

 钱和你对我都不重要,没有你，对我很重要。
                                                                                                               —电影"让子弹飞"台词

 扩展阅读：

[子豪兄]玩转MNIST数据集

这部分放在另一个文里

https://github.com/slundberg/shap/tree/master/notebooks/image_examples/image_classification

C1-Pytorch-预训练ImageNet图像分类可解释分析

对Pytorch模型中的ImageNet预训练图像分类模型进行可解释性分析，可视化指定预测类别的shap值热力图

  1. ##导入工具包
  2. import json
  3. import numpy as np
  4. from PIL import Image
  5. import torch
  6. import torch.nn as nn
  7. import torchvision
  8. from torchvision import transforms
  9. import shap
  10.  
  11. # 有 GPU 就用 GPU，没有就用 CPU
  12. device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
  13. print('device', device)
  14.  
  15. ##载入ImageNet预训练图像分类模型
  16. model = torchvision.models.mobilenet_v2(pretrained=True, progress=False).eval().to(device)
  17.  
  18. ##载入ImageNet1000类别标注名称
  19. with open('data/imagenet_class_index.json') as file:
  20.     class_names = [v[1] for v in json.load(file).values()]
  21.  
  22. ##载入一张测试图像，整理维度
  23. img_path = 'test_img/cat_dog.jpg'
  24.  
  25. img_pil = Image.open(img_path)
  26. X = torch.Tensor(np.array(img_pil)).unsqueeze(0)
  27.  
  28. ##预处理
  29. mean = [0.485, 0.456, 0.406]
  30. std = [0.229, 0.224, 0.225]
  31.  
  32. def nhwc_to_nchw(x: torch.Tensor) -> torch.Tensor:
  33.     if x.dim() == 4:
  34.         x = x if x.shape[1] == 3 else x.permute(0, 3, 1, 2)
  35.     elif x.dim() == 3:
  36.         x = x if x.shape[0] == 3 else x.permute(2, 0, 1)
  37.     return x
  38.  
  39. def nchw_to_nhwc(x: torch.Tensor) -> torch.Tensor:
  40.     if x.dim() == 4:
  41.         x = x if x.shape[3] == 3 else x.permute(0, 2, 3, 1)
  42.     elif x.dim() == 3:
  43.         x = x if x.shape[2] == 3 else x.permute(1, 2, 0)
  44.     return x 
  45.         
  46.  
  47. transform= [
  48.     transforms.Lambda(nhwc_to_nchw),
  49.     transforms.Resize(224),
  50.     transforms.Lambda(lambda x: x*(1/255)),
  51.     transforms.Normalize(mean=mean, std=std),
  52.     transforms.Lambda(nchw_to_nhwc),
  53. ]
  54.  
  55. inv_transform= [
  56.     transforms.Lambda(nhwc_to_nchw),
  57.     transforms.Normalize(
  58.         mean = (-1 * np.array(mean) / np.array(std)).tolist(),
  59.         std = (1 / np.array(std)).tolist()
  60.     ),
  61.     transforms.Lambda(nchw_to_nhwc),
  62. ]
  63.  
  64. transform = torchvision.transforms.Compose(transform)
  65. inv_transform = torchvision.transforms.Compose(inv_transform)
  66.  
  67. ##构建模型预测函数
  68. def predict(img: np.ndarray) -> torch.Tensor:
  69.     img = nhwc_to_nchw(torch.Tensor(img)).to(device)
  70.     output = model(img)
  71.     return output
  72.  
  73. def predict(img):
  74.     img = nhwc_to_nchw(torch.Tensor(img)).to(device)
  75.     output = model(img)
  76.     return output
  77.  
  78. Xtr = transform(X)
  79. out = predict(Xtr[0:1])
  80.  
  81. classes = torch.argmax(out, axis=1).detach().cpu().numpy()
  82. print(f'Classes: {classes}: {np.array(class_names)[classes]}')
  83.

输出为： classes:[232]:[ 'Border_collie']

  1. ##设置shap可解释性分析算法
  2. #构造输入图像
  3. input_img = Xtr[0].unsqueeze(0)
  4.  
  5. batch_size = 50
  6. n_evals = 5000 #迭代次数越大，显著性分析粒度越细，计算消耗时间越长
  7.  
  8. #定义mask，遮盖输入图像上的局部区域
  9. masker_blur = shap.maskers.Image("blur(64, 64)", Xtr[0].shape)
  10.  
  11. #创建可解释分析算法
  12. explainer = shap.Explainer(predict, masker_blur, output_names=class_names)
  13.  
  14. ##指定单个预测类别
  15. # 281：虎斑猫 tabby
  16. shap_values = explainer(input_img, max_evals=n_evals, batch_size=batch_size, outputs=[281])
  17.  
  18. # 整理张量维度
  19. shap_values.data = inv_transform(shap_values.data).cpu().numpy()[0] # 原图
  20. shap_values.values = [val for val in np.moveaxis(shap_values.values[0],-1, 0)] # shap值热力图
  21.  
  22.  
  23. # 可视化
  24. shap.image_plot(shap_values=shap_values.values,
  25.                 pixel_values=shap_values.data,
  26.                 labels=shap_values.output_names)

  

  1. ##指定多个预测类别
  2. # 232 边牧犬 border collie
  3. # 281：虎斑猫 tabby
  4. # 852 网球 tennis ball
  5. # 288 豹子 leopard
  6. shap_values = explainer(input_img, max_evals=n_evals, batch_size=batch_size, outputs=[232, 281, 852, 288])
  7.  
  8. # 整理张量维度
  9. shap_values.data = inv_transform(shap_values.data).cpu().numpy()[0] # 原图
  10. shap_values.values = [val for val in np.moveaxis(shap_values.values[0],-1, 0)] # shap值热力图
  11.  
  12. # shap值热力图：每个像素，对于每个类别的shap值
  13. shap_values.shape
  14.  
  15. # 可视化
  16. shap.image_plot(shap_values=shap_values.values,
  17.                 pixel_values=shap_values.data,
  18.                 labels=shap_values.output_names)

  1. ##前k个预测类别
  2. topk = 5
  3. shap_values = explainer(input_img, max_evals=n_evals, batch_size=batch_size, outputs=shap.Explanation.argsort.flip[:topk])
  4.  
  5. # shap值热力图：每个像素，对于每个类别的shap值
  6. shap_values.shape
  7.  
  8. # 整理张量维度
  9. shap_values.data = inv_transform(shap_values.data).cpu().numpy()[0] # 原图
  10. shap_values.values = [val for val in np.moveaxis(shap_values.values[0],-1, 0)] # 各个类别的shap值热力图
  11.  
  12. # 各个类别的shap值热力图
  13. len(shap_values.values)
  14.  
  15. # 第一个类别，shap值热力图
  16. shap_values.values[0].shape
  17.  
  18. # 可视化
  19. shap.image_plot(shap_values=shap_values.values,
  20.                 pixel_values=shap_values.data,
  21.                 labels=shap_values.output_names
  22.                 )

D1-Pytorch-预训练VGG中间层可解释性分析

使用shap库的GradientExplainer，对预训练VGG16模型的中间层输出，计算shap值

这个结果的运行时间格外长

  1. ##导入工具包
  2. import torch, torchvision
  3. from torch import nn
  4. from torchvision import transforms, models, datasets
  5. import shap
  6. import json
  7. import numpy as np
  8.  
  9. ##载入模型
  10. model = models.vgg16(pretrained=True).eval()
  11.  
  12. ##载入数据集，预处理
  13. mean = [0.485, 0.456, 0.406]
  14. std = [0.229, 0.224, 0.225]
  15.  
  16. def normalize(image):
  17.     if image.max() > 1:
  18.         image /= 255
  19.     image = (image - mean) / std
  20.     # in addition, roll the axis so that they suit pytorch
  21.     return torch.tensor(image.swapaxes(-1, 1).swapaxes(2, 3)).float()
  22.  
  23. ##指定测试图像
  24. X, y = shap.datasets.imagenet50()
  25.  
  26. X /= 255
  27.  
  28. to_explain = X[[39, 41]]
  29.  
  30. ##载入类别和索引号
  31. url = "https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json"
  32. fname = shap.datasets.cache(url)
  33. with open(fname) as f:
  34.     class_names = json.load(f)
  35.  
  36. ##计算模型中间层，在输入图像上的shap值
  37. # 指定中间层
  38. layer_index = 7 
  39.  
  40. # 迭代次数，200次大约需计算 5 分钟
  41. samples = 200
  42.  
  43. ##预测类别名称
  44. index_names = np.vectorize(lambda x: class_names[str(x)][1])(indexes)
  45. print(index_names)

 

  1. ##可视化
  2. shap_values = [np.swapaxes(np.swapaxes(s, 2, 3), 1, -1) for s in shap_values]
  3.  
  4. shap.image_plot(shap_values, to_explain, index_names)

 

 在图像上引入局部平滑

Gradient explainer的期望梯度，融合了integrated gradients, SHAP, SmoothGrad的思想，只需将local_smoothing参数设置为非0即可。在计算期望时，在输入图像加入正态分布噪声，绘制出更平滑的显著性分析图。

  1. # 计算模型中间层，在输入图像上的shap值
  2. explainer = shap.GradientExplainer((model, model.features[layer_index]), normalize(X), local_smoothing=0.5)
  3. shap_values, indexes = explainer.shap_values(normalize(to_explain), ranked_outputs=2, nsamples=samples)
  4.  
  5. # 预测类别名称
  6. index_names = np.vectorize(lambda x: class_names[str(x)][1])(indexes)
  7.  
  8. # 可视化
  9. shap_values = [np.swapaxes(np.swapaxes(s, 2, 3), 1, -1) for s in shap_values]
  10.  
  11. shap.image_plot(shap_values, to_explain, index_names)

  

 可以看出，模型浅层输出的显著性分析图，虽然具有细粒度、高分辨率，但不具有类别判别性（class discriminative）

模型深层输出的显著性分析图，虽然分辨率较低，但具有类别判别性。

 D2-Tensorflow-预训练ResNet50可解释性分析

将输入图像局部遮挡，对ResNet50图像分类模型的预测结果进行可解释性分析

  1. ##导入工具包
  2. import json
  3. import numpy as np
  4. import tensorflow as tf
  5. from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input
  6. import shap
  7.  
  8. ##导入预训练模型
  9. model = ResNet50(weights='imagenet')
  10.  
  11. ##导入数据集
  12. X, y = shap.datasets.imagenet50()
  13.  
  14. ##构建模型预测函数
  15. def f(x):
  16.     tmp =
  17.  x.copy()
  18.     preprocess_input(tmp)
  19.     return model(tmp)
  20.  
  21. ##构建局部遮挡函数
  22. masker = shap.maskers.Image("inpaint_telea", X[0].shape)
  23.  
  24. ##输出类别名称
  25. url = "https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json"
  26. with open(shap.datasets.cache(url)) as file:
  27.     class_names = [v[1] for v in json.load(file).values()]
  28.  
  29. ##创建Explainer
  30. explainer = shap.Explainer(f, masker, output_names=class_names)
  31.  
  32. ##计算shap值
  33. shap_values = explainer(X[1:3], max_evals=100, batch_size=50, outputs=shap.Explanation.argsort.flip[:4]) 
  34.  
  35. ##可视化
  36. shap.image_plot(shap_values)

 

 原图可视化如果有误，不用担心，不影响后面几个图的shap可视化效果

  1. ##更加细粒度的shap计算和可视化
  2. masker_blur = shap.maskers.Image("blur(128,128)", X[0].shape)
  3.  
  4. explainer_blur = shap.Explainer(f, masker_blur, output_names=class_names)
  5.  
  6. shap_values_fine = explainer_blur(X[1:3], max_evals=5000, batch_size=50, outputs=shap.Explanation.argsort.flip[:4]) 
  7.  
  8. shap.image_plot(shap_values_fine)

Z-扩展阅读

预备知识：

图像分类全流程：构建数据集、训练模型、预测新图、测试集评估、可解释分析、终端部署

视频教程：构建自己的图像分类数据集【两天搞定AI毕设】_哔哩哔哩_bilibili

代码教程：https://github.com/TommyZihao/Train_Custom_Dataset

 UCl心脏病二分类+可解释性分析：【子豪兄Kaggle】玩转UCI心脏病二分类数据集_哔哩哔哩_bilibili

 shap工具包相关

 shap工具包：GitHub - slundberg/shap: A game theoretic approach to explain the output of any machine learning model.

  shap工具包论文：https://proceedings.neurips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf

DataWhale公众号推送【6个机器学习可解释性框架!】：6个机器学习可解释性框架！

二、LIME工具包

 A-安装配置环境

  1. ##安装工具包
  2. !pip install lime scikit-learn numpy pandas matplotlib pillow
  3.  
  4. ##创建目录
  5. import os
  6.  
  7. # 存放测试图片
  8. os.mkdir('test_img')
  9.  
  10. # 存放模型权重文件
  11. os.mkdir('checkpoint')
  12.  
  13. ##自己训练得到的30类水果图像分类模型
  14. # 下载样例模型文件
  15. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/checkpoints/fruit30_pytorch_20220814.pth -P checkpoint
  16.  
  17. # 下载 类别名称 和 ID索引号 的映射字典
  18. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/fruit30/labels_to_idx.npy
  19. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/dataset/fruit30/idx_to_labels.npy
  20.  
  21. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/cat_dog.jpg -P test_img
  22.  
  23. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_fruits.jpg -P test_img
  24.  
  25. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_orange_2.jpg -P test_img 
  26.  
  27. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_bananan.jpg -P test_img
  28.  
  29. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_kiwi.jpg -P test_img
  30.  
  31. # 草莓图像，来源：https://www.pexels.com/zh-cn/photo/4828489/
  32. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/0818/test_草莓.jpg -P test_img
  33.  
  34. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_石榴.jpg -P test_img
  35.  
  36. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_orange.jpg -P test_img
  37.  
  38. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_lemon.jpg -P test_img
  39.  
  40. !wget https://zihao-openmmlab.obs.myhuaweicloud.com/20220716-mmclassification/test/0818/test_火龙果.jpg -P test_img
  41.  
  42. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/watermelon1.jpg -P test_img
  43.  
  44. !wget https://zihao-openmmlab.obs.cn-east-3.myhuaweicloud.com/20220716-mmclassification/test/banana1.jpg -P test_img
  45.  
  46. import lime
  47. import sklearn

 B-葡萄酒二分类-lime可解释分析

在葡萄酒质量二分类数据集上训练随机森林分类模型，对测试集样本预测结果，基于LIME进行可解释分析。

定量评估出某个样本、某个特征，对模型预测为某个类别的贡献影响。

  1. ##导入工具包
  2. import numpy as np
  3. import pandas as pd
  4.  
  5. import lime
  6. from lime import lime_tabular
  7.  
  8. ##载入数据集
  9. df = pd.read_csv('wine.csv')
  10.  
  11. ##划分训练集和测试集
  12. from sklearn.model_selection import train_test_split
  13.  
  14. X = df.drop('quality', axis=1)
  15. y = df['quality']
  16.  
  17. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

 

  1. ##训练模型
  2. from sklearn.ensemble import RandomForestClassifier
  3. model = RandomForestClassidier(random_state=42)
  4. model.fit(X_train, y_train)

 

  1. ##评估模型
  2. score = model.score(X_test, y_test)
  3. print(score)

 

  1. ##初始化LIME可解释性分析算法
  2. explainer = lime_tabular.LimeTabularExplainer(
  3.     training_data=np.array(X_train), # 训练集特征，必须是 numpy 的 Array
  4.     feature_names=X_train.columns, # 特征列名
  5.     class_names=['bad', 'good'], # 预测类别名称
  6.     mode='classification' # 分类模式
  7. )
  8.  
  9. ##从测试集中选取一个样本，输入训练好的模型中预测，查看预测结果
  10. # idx = 1
  11.  
  12. idx = 3
  13.  
  14. data_test = np.array(X_test.iloc[idx]).reshape(1, -1)
  15. prediction = model.predict(data_test)[0]
  16. y_true = np.array(y_test)[idx]
  17. print('测试集中的 {} 号样本, 模型预测为 {}, 真实类别为 {}'.format(idx, prediction, y_true))

 

  1. ##可解释分析
  2. exp = explainer.explain_instance(
  3.     data_row=X_test.iloc[idx], 
  4.     predict_fn=model.predict_proba
  5. )
  6.  
  7. exp.show_in_notebook(show_table=True)

C1-LIME可解释性分析-ImageNet图像分类

对Pytorch的ImageNet预训练图像分类模型，运行LIME可解释性分析

可视化某个输入图像，某个图块区域，对模型预测为某个类别的贡献影响

  1. ##导入工具包
  2. import matplotlib.pyplot as plt
  3. from PIL import Image
  4. import torch.nn as nn
  5. import numpy as np
  6. import os, json
  7.  
  8. import torch
  9. from torchvision import models, transforms
  10. from torch.autograd import Variable
  11. import torch.nn.functional as F
  12.  
  13. # 有 GPU 就用 GPU，没有就用 CPU
  14. device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
  15. print('device', device)
  16.  
  17. ##载入测试图片
  18. img_path = 'test_img/cat_dog.jpg'
  19.  
  20. img_pil = Image.open(img_path)
  21.  
  22. print(img_pil)

  1. ##载入模型
  2. model = models.inception_v3(pretrained=True).eval().to(device)
  3.  
  4. ##载入ImageNet-1000类别
  5. idx2label, cls2label, cls2idx = [], {}, {}
  6. with open(os.path.abspath('imagenet_class_index.json'), 'r') as read_file:
  7.     class_idx = json.load(read_file)
  8.     idx2label = [class_idx[str(k)][1] for k in range(len(class_idx))]
  9.     cls2label = {class_idx[str(k)][0]: class_idx[str(k)][1] for k in range(len(class_idx))}
  10.     cls2idx = {class_idx[str(k)][0]: k for k in range(len(class_idx))}
  11.  
  12. ##预处理
  13. trans_norm = transforms.Normalize(mean=[0.485, 0.456, 0.406],
  14.                                   std=[0.229, 0.224, 0.225])
  15.  
  16. trans_A = transforms.Compose([
  17.     transforms.Resize((256, 256)),
  18.     transforms.CenterCrop(224),
  19.     transforms.ToTensor(),
  20.     trans_norm
  21.     ])
  22.  
  23. trans_B = transforms.Compose([
  24.         transforms.ToTensor(),
  25.         trans_norm
  26.     ])
  27.  
  28. trans_C = transforms.Compose([
  29.     transforms.Resize((256, 256)),
  30.     transforms.CenterCrop(224)
  31. ])
  32.  
  33. ##图像分类预测
  34. input_tensor = trans_A(img_pil).unsqueeze(0).to(device)
  35. pred_logits = model(input_tensor)
  36. pred_softmax = F.softmax(pred_logits, dim=1)
  37. top_n = pred_softmax.topk(5)
  38. print(top_n)

  1. ##定义分类预测函数
  2. def batch_predict(images):
  3.     batch = torch.stack(tuple(trans_B(i) for i in images), dim=0)
  4.     batch = batch.to(device)
  5.     
  6.     logits = model(batch)
  7.     probs = F.softmax(logits, dim=1)
  8.     return probs.detach().cpu().numpy()
  9.  
  10. test_pred = batch_predict([trans_C(img_pil)])
  11. test_pred.squeeze().argmax()

输出为231

  1. ##LIME可解释性分析
  2. from lime import lime_image
  3.  
  4. explainer = lime_image.LimeImageExplainer()
  5. explanation = explainer.explain_instance(np.array(trans_C(img_pil)), 
  6.                                          batch_predict, # 分类预测函数
  7.                                          top_labels=5, 
  8.                                          hide_color=0, 
  9.                                          num_samples=8000) # LIME生成的邻域图像个数
  10.  
  11. ##可视化
  12. from skimage.segmentation import mark_boundaries
  13.  
  14. temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=20, hide_rest=False)
  15. img_boundry = mark_boundaries(temp/255.0, mask)
  16. plt.imshow(img_boundry)
  17. plt.show()

  1. ##修改可视化参数
  2. temp, mask = explanation.get_image_and_mask(281, positive_only=False, num_features=20, hide_rest=False)
  3. img_boundry = mark_boundaries(temp/255.0, mask)
  4. plt.imshow(img_boundry)
  5. plt.show()

Z-博客链接 

lime工具包： GitHub - marcotcr/lime: Lime: Explaining the predictions of any machine learning classifier

总结：

本文主要演示了对shap、LIME两个工具包的使用

shap是一种解释任何机器学习模型输出的博弈论方法，它利用博弈论中的经典Shapley值及其相关扩展将最优信贷分配与局部解释联系起来。

LIME帮助解释学习模型正在学习什么以及为什么他们以某种方式预测。目前支持对表格的数据，文本分类器和图像分类器的解释。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/blog/article/detail/97546
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号