day 16 Numpy数组与Shap值的深入理解-CSDN博客

本文链接：https://blog.csdn.net/weixin_47130140/article/details/147921018

一、NumPy 数组与深度学习 Tensor 的关系

在深度学习中，张量（Tensor）是核心数据结构。与 NumPy 数组类似，张量也有维度概念，并且可以进行各种数学运算。例如，在构建神经网络时，我们会使用张量来表示输入数据、权重矩阵和输出结果。输入数据可能是一个二维张量，其中一行代表一个样本，一列代表一个特征；权重矩阵也是一个二维张量，用于对输入数据进行线性变换。

张量本质上可以视为支持 GPU 加速和自动微分的 NumPy 数组。掌握 NumPy 的基本操作，能极大地降低学习 Tensor 的门槛。

支持 GPU 加速：与 NumPy 数组主要在 CPU 上运行不同，深度学习框架中的张量可以轻松地在 GPU 上运行。GPU（图形处理器）具有强大的并行计算能力，对于大规模的张量运算，如矩阵乘法，GPU 可以显著提高计算速度。

自动微分：自动微分是深度学习框架的重要特性之一。在训练神经网络时，我们需要计算损失函数关于模型参数的梯度，以便使用梯度下降等优化算法来更新参数。NumPy 数组本身不支持自动微分，而深度学习框架中的张量则可以自动计算梯度。

二、什么是梯度？

数学定义：

简单来说：一元函数斜率叫导数，多元函数斜率叫梯度。

利用链式法则求梯度：

几何意义：

想象一座山的表面，高度就是一个关于水平位置（可以用两个坐标 x 和 y 表示）的函数 (h(x, y))。在山的某一点上，梯度向量就指向山坡最陡峭的方向，其大小（向量的长度）表示山坡在这个最陡峭方向上的陡峭程度。也就是说，沿着梯度方向移动，函数值增长得最快；而沿着与梯度相反的方向移动，函数值下降得最快。

在机器学习中的作用：

在机器学习里，特别是在训练模型时，我们通常希望最小化损失函数 $L(\theta )$ ， $\theta$ 是模型的参数。梯度下降算法就是利用梯度的概念来实现的。算法每次迭代时，根据损失函数关于参数的梯度，朝着梯度的反方向更新参数，使得损失函数值逐渐减小，最终找到损失函数的最小值（或局部最小值），此时模型的参数就是最优参数。

梯度下降法调参步骤：

三、Numpy数组

一维数组

在结构上与 Python 中的列表（List）非常相似。它们的主要区别在于：

打印输出格式:

当使用 print() 函数输出时：NumPy 一维数组的元素之间默认使用空格分隔。Python 列表的元素之间使用逗号分隔。

import numpy as np

# 创建一个 NumPy 一维数组
numpy_array = np.array([1, 2, 3, 4])
# 创建一个 Python 列表
python_list = [1, 2, 3, 4]

print(numpy_array)  
# 输出: [1 2 3 4]

print(python_list)  
# 输出: [1, 2, 3, 4]

数据类型：

NumPy 数组要求所有元素具有相同的数据类型，这种一致性也便于进行向量化操作。

Python 列表可以存储不同数据类型的元素，更加灵活。但是这也导致每个元素在内存中需要额外的空间来存储其数据类型信息。

数学运算：

NumPy 数组内置了丰富的数学运算，支持向量化操作。因此可以对整个数组进行数学运算，而无需编写显式的循环。例如，要对数组中的每个元素乘以 2，只需 numpy_array * 2 即可。

Python 列表无向量化数学运算功能。若对列表中的每个元素进行相同数学运算，需要使用循环。例如，要对列表中的每个元素乘以 2，需要new_list = [num * 2 for num in python_list]。

内存管理：

NumPy 数组由于其元素数据类型一致，在内存中是连续存储的（对于一维数组而言），这使得数据的读取和写入速度更快。

Python 列表的由于列表元素的数据类型可以不同，每个元素在内存中的存储地址可能是分散的，这增加了内存访问的开销。

功能用途：

NumPy 数组主要用于数值计算和科学计算领域，在数据分析、机器学习、深度学习等众多领域都有广泛应用。具有高效的计算能力和内存管理方式。

Python 列表应用广泛，存储各种类型的数据对象，以及进行数据的简单组织和处理。

二维数组

可被看作是“数组的数组”或者矩阵，它可以是任意的 n * m 形状。其结构由两个主要维度决定：

行数n: 代表整个二维数组中包含多少个一维数组。
列数m: 代表每个一维数组（也就是每一行）中包含多少个元素。

数组的创建

np.array()：

Numpy 的array()函数类似于类型转换函数，可以把列表、元组等序列型对象转换为 NumPy 数组类型。并且能处理嵌套的序列型对象，创建多维数组，比类型转换函数处理的数据结构更为复杂。

import numpy as np
a = np.array([2,4,6,8,10,12]) # 创建一个一维数组
b = np.array([[2,4,6],[8,10,12]]) # 创建一个二维数组
print(a)
print(b)
# 输出：
[ 2  4  6  8 10 12]
[[ 2  4  6]
 [ 8 10 12]]

np.zeros():

功能：创建一个指定形状和数据类型（默认为 float64），且所有元素都为零的 NumPy 数组。

语法：np.zeros(shape, dtype = None, order = 'C')，其中 shape 是一个整数或整数元组，用于指定数组的形状；dtype 可选，用于指定数组的数据类型；order 可选，有 'C'（按行优先）和 'F'（按列优先）两种。

import numpy as np
zeros = np.zeros((2, 3))
print(zeros)
# 输出:
array([[0., 0., 0.],
       [0., 0., 0.]])

np.ones():

功能：创建一个指定形状和数据类型（默认为 float64），且所有元素都为 1 的 NumPy 数组。

语法：np.ones(shape, dtype = None, order = 'C')，参数含义与 np.zeros() 相同。

zerosones = np.ones((3,))
print(zerosones)
# 输出: array([1., 1., 1.])

注意：虽然在打印输出时，一维数组看起来和 Python 列表类似，但它是 NumPy 数组，具有 NumPy 数组的特性，如支持向量化运算。

np.arange():

功能：创建一个按顺序排列的数组。类似于 Python 的内置函数 range()，但返回 NumPy 数组。

语法：np.arange(start,stop,step,dtype = None)也遵循取左不取右，其中stop是必选参数

arange = np.arange(1, 10)
print(arange)
# 输出: 
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

数组的随机化创建

方法	作用范围/分布	记忆口诀	典型应用场景	示例
`np.random.randint(a,b)`	[a,b]整数	"int"结尾表示整数	生成随机索引/标签	`np.random.randint(1,10)` → 7非负
`random.random()`	[0,1)浮点数	纯"random"最基础	简单概率模拟	`random.random()` → 0.548非负
`np.random.rand()`	[0,1)均匀分布	“rand”=random+uniform	蒙特卡洛模拟	`np.random.rand(3)` → [0.2,0.5,0.8]非负
`np.random.randn()`	标准正态分布(μ=0,σ=1)	多一个"n"=normal	数据标准化/深度学习初始化	`np.random.randn(2,2)` → [[-0.1,1.2],[0.5,-0.3]]有正有负

代码实例

import numpy as np
np.random.seed(42)  # 设置随机种子以确保结果可重复

# 生成10个语文成绩（正态分布，均值75，标准差10），保留一位小数
chinese_scores = np.random.normal(75, 10, 10).round(1)

# 找出最高分和最低分及其索引
max_score = np.max(chinese_scores)
max_index = np.argmax(chinese_scores)
min_score = np.min(chinese_scores)
min_index = np.argmin(chinese_scores)

print(f"所有成绩: {chinese_scores}")
print(f"最高分: {max_score} (第{max_index}个学生)")
print(f"最低分: {min_score} (第{min_index}个学生)")

# 输出：
所有成绩: [80.  73.6 81.5 90.2 72.7 72.7 90.8 82.7 70.3 80.4]
最高分: 90.8 (第6个学生)
最低分: 70.3 (第8个学生)

数组的遍历

# 对数组中的每个元素加 1，然后通过循环累加这些成绩
import numpy as np
scores = np.array([5, 9, 9, 11, 11, 13, 15, 19])
scores += 1 
sum = 0
for i in scores: 
    sum += i   
print(sum)

数组的运算

矩阵乘法：需要满足第一个矩阵的列数等于第二个矩阵的行数，和线代的矩阵乘法算法相同。
矩阵点乘：需要满足两个矩阵的行数和列数相同，然后两个矩阵对应位置的元素相乘。
矩阵转置：将矩阵的行和列互换。
矩阵求逆：需要满足矩阵是方阵且行列式不为0，然后使用伴随矩阵除以行列式得到逆矩阵。
矩阵求行列式：需要满足矩阵是方阵，然后使用代数余子式展开计算行列式。

import numpy as np
a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([[7, 8], [9, 10], [11, 12]])
print(a)
print(b)
# 输出：
[[1 2]
 [3 4]
 [5 6]]
[[ 7  8]
 [ 9 10]
 [11 12]]
# 计算两个数组的和
print(a + b) 
# 输出：
[[ 8 10]
 [12 14]
 [16 18]]
# 计算两个数组的除法
print(a / b) 
# 输出：
[[0.14285714 0.25      ]
 [0.33333333 0.4       ]
 [0.45454545 0.5       ]]
# 矩阵点乘
a * b 
# 输出：
array([[ 7, 16],
       [27, 40],
       [55, 72]])
# 对矩阵 a 和转置后的矩阵 b.T 进行矩阵乘法，得到3×3的结果矩阵。
a @ b.T
# 输出：
array([[ 23,  29,  35],
       [ 53,  67,  81],
       [ 83, 105, 127]])

数组的索引

一维数组索引

arr1d = np.arange(10)  # 数组: [0 1 2 3 4 5 6 7 8 9]
arr1d
# 输出：array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 取出数组的第一个元素。
arr1d[0]
# 输出：0

# 取出数组的最后一个元素。
arr1d[-1]
# 输出：9

# 取出数组中索引为 3, 5, 8 的元素。使用整数数组进行索引，可一次性取出多个元素。
# 语法是 arr1d[[index1, index2, ...]]。
arr1d[[3, 5, 8]]
# 输出：array([3, 5, 8])

# 切片取出索引，取左不取右
arr1d[2:6] 
# 输出：array([2, 3, 4, 5])

# 取出数组中从头到索引 5 (不包含 5) 的元素。
arr1d[:5]
# 输出：array([0, 1, 2, 3, 4])

# 取出数组中从索引 4 到结尾的元素。
arr1d[4:]
# 输出：array([4, 5, 6, 7, 8, 9])

# 取出全部元素
arr1d[:]
# 输出：array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 取出数组中所有偶数索引对应的元素
arr1d[::2]
# 输出：array([0, 2, 4, 6, 8])

二维数组索引

arr2d = np.array([[1, 2, 3, 4],
                  [5, 6, 7, 8],
                  [9, 10, 11, 12],
                  [13, 14, 15, 16]])
arr2d
# 输出：
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

# 使用索引 arr[row_index, :] 取第 2 行 (索引为 1) 的所有元素。
arr2d[1, :]或者arr2d[1]
# 输出：array([5, 6, 7, 8])

# 取出第 3 列 (索引为 2) 的所有元素。
arr2d[:, 2]
# 输出：array([ 3,  7, 11, 15])

# 取出位于第 3 行 (索引 2)、第 4 列 (索引 3) 的元素。
arr2d[2, 3]
# 输出：12

# 取出由第 1 行（索引0）和第 3 行（索引2）组成的新数组。
arr2d[[0, 2], :]
# 输出：array([[ 1,  2,  3,  4],
       [ 9, 10, 11, 12]])

# 取出由第 2 列和第 4 列组成的新数组。
arr2d[:, [1, 3]]
# 输出：array([[ 2,  4],
       [ 6,  8],
       [10, 12],
       [14, 16]])

# 取出一个 2x2 的子矩阵，包含元素 6, 7, 10, 11。
arr2d[1:3, 1:3]
# 输出：array([[ 6,  7],
       [10, 11]])

三维数组索引

# 创建一个包含 0 到 59 共 60 个元素的一维数组，然后将其重新排列成一个三维数组 arr3d，其形状为 (3, 4, 5)，总元素个数仍然是 3×4×5 = 60 个。
arr3d = np.arange(3 * 4 * 5).reshape((3, 4, 5))
arr3d 
# 输出：
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19]],

       [[20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34],
        [35, 36, 37, 38, 39]],

       [[40, 41, 42, 43, 44],
        [45, 46, 47, 48, 49],
        [50, 51, 52, 53, 54],
        [55, 56, 57, 58, 59]]])

# 选择第2层
arr3d[1, :, :]
# 输出：array([[20, 21, 22, 23, 24],
       [25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34],
       [35, 36, 37, 38, 39]])

# 选择第一层的前两行
arr3d[1, 0:2, :]
# 输出：array([[20, 21, 22, 23, 24],
       [25, 26, 27, 28, 29]])

# 选择第一层的前两行的3、4列
arr3d[1, 0:2, 2:4]
# 输出：array([[22, 23],
       [27, 28]])

四、Shap值的理解

导入机器学习库→筛选离散特征→字符串变量映射→无序变量独热编码（记得类型转换）→筛选连续特征→连续特征缺失值补全→导入机器学习模型和方法→划分数据编辑→基准模型训练

# 先运行之前预处理好的代码
import pandas as pd
import pandas as pd    #用于数据处理和分析，可处理表格数据。
import numpy as np     #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt    #用于绘制各种类型的图表
import seaborn as sns   #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
import warnings
warnings.filterwarnings("ignore")
 
 # 设置中文字体（解决中文显示问题）
plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统常用黑体字体
plt.rcParams['axes.unicode_minus'] = False    # 正常显示负号
data = pd.read_csv('data.csv')    #读取数据

# 先筛选字符串变量 
discrete_features = data.select_dtypes(include=['object']).columns.tolist()

# Home Ownership 标签编码
home_ownership_mapping = {
    'Own Home': 1,
    'Rent': 2,
    'Have Mortgage': 3,
    'Home Mortgage': 4
}
data['Home Ownership'] = data['Home Ownership'].map(home_ownership_mapping)

# Years in current job 标签编码
years_in_job_mapping = {
    '< 1 year': 1,
    '1 year': 2,
    '2 years': 3,
    '3 years': 4,
    '4 years': 5,
    '5 years': 6,
    '6 years': 7,
    '7 years': 8,
    '8 years': 9,
    '9 years': 10,
    '10+ years': 11
}
data['Years in current job'] = data['Years in current job'].map(years_in_job_mapping)

# Purpose 独热编码，记得需要将bool类型转换为数值
data = pd.get_dummies(data, columns=['Purpose'])

data2 = pd.read_csv("data.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
for i in data.columns:
    if i not in data2.columns:
       list_final.append(i) # 这里打印出来的就是独热编码后的特征名
for i in list_final:
    data[i] = data[i].astype(int) # 这里的i就是独热编码后的特征名

# Term 0 - 1 映射
term_mapping = {
    'Short Term': 0,
    'Long Term': 1
}
data['Term'] = data['Term'].map(term_mapping)
data.rename(columns={'Term': 'Long Term'}, inplace=True) # 重命名列

continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist()  #把筛选出来的列名转换成列表
 
# 连续特征用众数补全
for feature in continuous_features:     
    mode_value = data[feature].mode()[0]           
    data[feature].fillna(mode_value, inplace=True)   # inplace=True表示直接在原数据上修改。

# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多
# 所以这里我们还是只划分一次数据集
from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1)  # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签
# 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80%训练集，20%测试集

from sklearn.ensemble import RandomForestClassifier #随机森林分类器
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # 用于评估分类器性能的指标
from sklearn.metrics import classification_report, confusion_matrix #用于生成分类报告和混淆矩阵
import warnings #用于忽略警告信息
warnings.filterwarnings("ignore") # 忽略所有警告信息

# --- 1. 默认参数的随机森林 ---
# 评估基准模型，这里确实不需要验证集
print("--- 1. 默认参数随机森林 (训练集 -> 测试集) ---")
import time 
start_time = time.time() # 记录开始时间
rf_model = RandomForestClassifier(random_state=42)
rf_model.fit(X_train, y_train) # 在训练集上训练
rf_pred = rf_model.predict(X_test) # 在测试集上预测
end_time = time.time() # 记录结束时间

print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred))
print("默认随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred))

# 计算shap值
import shap
import matplotlib.pyplot as plt

# 初始化 SHAP 解释器
explainer = shap.TreeExplainer(rf_model)

# 计算 SHAP 值（基于测试集），这个shap_values是一个numpy数组，表示每个特征对每个样本的贡献值
shap_values = explainer.shap_values(X_test) # 这个计算耗时

type(shap_values)
# 输出：list

shap_values
# 输出：

shap_values值返回类型及维度情况

要看好输出的shap值的类型以及维度信息，不然绘制shap图可能因为维度对应不一致出现报错。

shap_values 的返回类型既可能是列表，也可能是 numpy 数组，list类型是不能查看形状的。

当 shap_values 返回列表类型时，形状是 [类别数，(样本数，特征数)]。每个列表元素是对应类别预测的 SHAP 值数组，数组形状为 (样本数，特征数)。

当 shap_values 返回 numpy 数组时，形状是 (样本数，特征数，类别数)。使得每个样本针对每个类别都有一组与特征相关的 SHAP 值。

绘制shap图所需参数

此处以shap.summary_plot()函数举例：

# 语法
shap.summary_plot(shap_values, features=None, feature_names=None,
                  plot_type='dot', class_names=None,
                  show=True, max_display=20,
                  color_bar=True, plot_size=None,
                  clustering=False, clustering_cutoff=1,
                  hist=True, sort=True, axis=None,
                  title="Summary of SHAP values",
                  cmap='viridis', color=None)

# 实例
shap.summary_plot(shap_values_aligned[:, :, 1], X_test, plot_type="bar",show=False)

shap_values：必需参数，代表计算得到的 SHAP 值。它可以是一个 numpy 数组，也可能是一个列表（取决于模型类型，如多分类模型中可能返回列表）。

features：可选参数，通常为输入数据矩阵，用于将 SHAP 值与实际特征值关联起来。通过它可以观察不同特征值范围与 SHAP 值的关系。比如在使用训练好的模型对测试集 X_test 计算 SHAP 值后，这里可以传入 X_test。

plot_type：可选参数，指定绘图类型，有 'dot'（点图，默认）和 'bar'（条形图）两种选项。点图展示特征值与 SHAP 值的关系，条形图按特征平均 SHAP 值绝对值排序展示。

show：可选参数，布尔值，决定是否立即显示图形。True 为显示（默认），False 则不显示，方便后续对图形进行自定义操作。

max_display：可选参数，整数类型，指定在图中显示的最大特征数量。默认值为 20。

color：可选参数，用于指定图的颜色。可以是单个颜色字符串，也可以是与特征数量相同长度的颜色列表。如color ='red' 或 color = ['red', 'blue', 'green'] （假设只有 3 个特征）

如何解决维度不一致的报错？

如果shap_values返回的是列表类型，这里提供两种方法：

1、将列表转换为数组类型，打印其和X_test的形状查看维度情况，通过矩阵转置进行维度交换，使shap值和测试集的维度一致。

shap_values 
shap_values=np.array(shap_values)
print(type(shap_values))
print(shap_values.shape)
shap_values_aligned=shap_values.transpose(1,2,0)
print(shap_values_aligned.shape)
# 输出：
<class 'numpy.ndarray'>
(2, 1500, 31)
(1500, 31, 2)

print("shap_values shape:", shap_values.shape)
print("shap_values[1] shape:", shap_values[1].shape)
print("shap_values_aligned[:, :, 1] shape:", shap_values_aligned[:, :, 1].shape)
print("X_test shape:", X_test.shape)
# 输出：
shap_values shape: (2, 1500, 31)
shap_values[1] shape: (1500, 31)
shap_values_aligned[:, :, 1] shape: (1500, 31)
X_test shape: (1500, 31)

print("--- 1. SHAP 特征重要性条形图 ---")
shap.summary_plot(shap_values_aligned[:, :, 1], X_test, plot_type="bar",show=False) 
plt.title("SHAP Feature Importance (Bar Plot)")
plt.show()

2、如果直接对该列表类型进行切片，后面按照原来的维度顺序采取和X_test维度一致的索引方式，也会发生报错。如下。这意味着在以不当的方式索引一个本质为列表嵌套结构的数据。

可以先转化为数组形式，通过打印形状获得维度信息然后用对应的索引方式使维度一致。

shap_values 
shap_values=np.array(shap_values)
print(shap_values.shape)
print(shap_values[0,:,:].shape)
print(X_test.shape)
# 输出：
(2, 1500, 31)
(1500, 31)
(1500, 31)
# 此时这个索引方式和测试集维度一致可以将该索引作为参数传入shap图函数

@浙大疏锦行