Python训练打卡Day16

知识点：

1. numpy数组的创建：简单创建、随机创建、遍历、运算
2. numpy数组的索引：一维、二维、三维
3. SHAP值的深入理解

#NumPy数组

1.数组的维度

NumPy数组的维度或称为轴(Axis)的概念：维度：可以想象成数组的嵌套层数，一维数组只有长度，例如[1,2,3].二维数组有行和列，三维数组像一摞扑克牌，每张牌都是一个二维表格。三个维度可以理解为层→行→列。轴是对维度的编号，从0开始。轴0是方向，轴1是列方向。可以通过打印输出时中括号[]的嵌套层数来初步确定。

2.NumPy数组与深度学习张量的关系

PyTorch 或 TensorFlow 中的 Tensor张量本质上可以 视为支持GPU加速和自动微分的NumPy数组。因为Tensor可以用显卡（GPU）来算数，并且可以记住每个计算步骤，自动计算出每个数字的"影响力"（导数）。

# NumPy（普通模式）
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b  # 在 CPU 上计算

# PyTorch（超能模式）
import torch
a = torch.tensor([1, 2, 3], device='cuda')  # 用 GPU 计算
b = torch.tensor([4, 5, 6], device='cuda')
c = a + b  # GPU 瞬间完成

# 自动微分示例：计算导数
x = torch.tensor(2.0, requires_grad=True)
y = x**2 + 3*x  # 计算 y = x² + 3x
y.backward()     # 系统自动算出 dy/dx = 2 * 2 + 3 = 7（x=2时的导数）
print(x.grad)    # 输出 7.0

3.一维数组（1D Array）

一维数组在结构上与Python中的列表（List）非常相似。他们的主要区别在于打印的输出格式：当使用print()函数输出时，NumPy一维数组的元素之间默认使用空格 分隔；Python列表的元素之间使用逗号分隔。

4.二维数组（2D Array）

行数：表示整个二维数组中包含多少个一维数组

列数：表示每个以为数组（也就是每一行）中包含多少各元素

二维数组可以是任意的n*m形状

5.数组的创建

NumPy 的 `array()` 函数非常灵活，可以接受各种"序列型"对象[列表 (List)、元组 (Tuple)]作为输入参数来创建数组。可直接传递给np.array()来创建新的NumPy数组。

import numpy as np
a = np.array([1,2,3,4,5,6])
b = np.array([1,2,3],[4,5,6])
print(a)
print(b)

#输出：
[ 2  4  6  8 10 12]
[[ 2  4  6]
 [ 8 10 12]]


# 分清楚列表和数组的区别
print([7, 5, 3, 9])  # 输出: [7, 5, 3, 9]（逗号分隔）
print(np.array([7, 5, 3, 9]))  # 输出: [7 5 3 9]（空格分隔）

a.shape # numpy中可以用shape来查看数组的形状
#(6,)表示为一维数组

其他的数组创建函数：np.zeros(),np.ones(),np.arange()

zeros = np.zeros((2, 3)) # 创建一个2行3列的全零矩阵
zeros

ones = np.ones((3,))  # 创建一个形状为(3,)的全1数组
ones

# 顺序数组的创建
arange = np.arange(1, 10) # 创建一个从1到10的数组
arange

#数组的随机化创建

在深度学习中，经常需要对数据进行随机化处理，确保模型的泛化能力。

|-----------------------|------------|---------------|------------------------------------------------------|
| 方法 | 作用范围 | 典型应用场景 | 示例 |
| np.random.randit(a,b) | [a,b]整数 | 生成随机索引/标签 | np.random.randit(1,10) →7 |
| random.random() | [0,1)浮点数 | 简单概率模拟 | mp.random.random() |
| np.random.rand() | [0,1)均匀分布 | 蒙特卡洛模拟 | np.random.rand(3) → [0.2,0.5,0.8] |
| np.random.randn() | 标准正态分布 | 数据标准化/深度学习初始化 | np.random.randn(2,2) → [[-0.1,1.2],[0.5,-0.3]] |

！正确使用random模块

如果使用MumPy的随机函数，需要通过调用numpy实现：（一般都为这种）

import numpy as np
a = np.random.random()  # 正确写法：通过 np. 调用

import numpy as np
a = np.random.random()  # √ 生成一个随机数（比如0.123）
b = np.random.random((2,3))  # √ 生成一个2行3列的随机数组

如果使用Python自带的random模块：

import random  # 需先导入模块
a = random.random()  # Python 原生生成随机数的方法

补充：如果我需要控制随机生成的浮点数小数位数，应该如何实现？

import random
import numpy as np

# 方法1：生成时控制（整数缩放）
decimal_places = 2
value_int = random.randint(0, 100)  # 0~100 的整数
value_float = value_int / 100
print("生成时控制:", value_float)  # 如 0.75

# 方法2：四舍五入
raw_value = random.random()
rounded_value = round(raw_value, 3)
print("四舍五入后:", rounded_value)  # 如 0.123

# 方法3：NumPy 生成后处理
np_value = np.random.random()
np_rounded = np.round(np_value, 2)
print("NumPy 四舍五入:", np_rounded)  # 如 0.56


# 方法4：字符串格式化
formatted = "{:.4f}".format(np_value)
print("格式化显示:", formatted)  # 如 0.1235


#精度问题​：浮点数计算可能存在二进制舍入误差（如 0.1 + 0.2 ≠ 0.3），对精度要求极高时建议使用 decimal 模块。
#​性能​：如果处理大规模数据，优先用 NumPy 的向量化操作（如 np.round(array, 2)），避免循环。

随机种子

随机种子是「随机数的起点密码」​ ，设定相同的种子，就能让计算机生成相同顺序的"随机数"​，保证结果可重复。可通俗的理解为：想象你在玩一款游戏，地图是随机生成的：

• 不设种子：每次打开游戏都是新地图（不同结果）。
• 设定种子 ：输入一个固定数字（如 123），每次打开都会生成相同的地图（结果可重复）。

import numpy as np

# 设定种子为 42
np.random.seed(42)
print(np.random.rand(3))  # 输出：[0.3745, 0.9507, 0.7320]（固定）

# 重置种子后结果一致
np.random.seed(42)
print(np.random.rand(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}个学生)")

np.random.normal(a,b,c): 生成符合正态分布的随机数。

第一个参数 a ：表示正态分布的均值（mean）

第二个参数 b ：表示正态分布的标准差（standard deviation），它衡量了数据的离散程度

第三个参数 c ：表示要生成的随机数的数量

#数组的遍历

import numpy as np
scores = np.array([1,2,3,4,5,56,6])
scores += 1
sum = 0
for i in scores:
    sum += i
print(sum)

#数组的运算

1. 矩阵乘法：需要满足第一个矩阵的列数等于第二个矩阵的行数，和线代的矩阵乘法算法相同。

2. 矩阵点乘：需要满足两个矩阵的行数和列数相同，然后两个矩阵对应位置的元素相乘。

3. 矩阵转置：将矩阵的行和列互换。

4. 矩阵求逆：需要满足矩阵是方阵且行列式不为0，然后使用伴随矩阵除以行列式得到逆矩阵。

5. 矩阵求行列式：需要满足矩阵是方阵，然后使用代数余子式展开计算行列式。

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)


print(a + b) # 计算两个数组的和

print(a - b) # 计算两个数组的差

print(a / b) # 计算两个数组的除法

a * b # 矩阵点乘，ipynb文件中不使用print()函数会自动输出结果，这是ipynb文件的特性

a @ b.T # 矩阵乘法,3*2的矩阵和2*3的矩阵相乘，得到3*3的矩阵

#数组的索引

1.一维数组的索引

arr1d = np.arange(10)
arr1d

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

# 取出数组的最后一个元素。-1表示倒数第一个元素。
arr1d[-1]

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

# 切片取出索引
arr1d[2:6] # 取出索引为2到5的元素（不包括索引6的元素，取左不取右）

# 取出数组中从头到索引 5 (不包含 5) 的元素。
# 使用切片 slice [:stop]
arr1d[:5]

# 取出数组中从索引 4 到结尾的元素。
# 使用切片 slice [start:]
arr1d[4:]

# 取出全部元素
arr1d[:]

# 取出数组中所有偶数索引对应的元素 (即索引 0, 2, 4, 6, 8)
# 使用带步长的切片 slice [start:stop:step]
arr1d[::2]

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

2.二维数组

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

# 取出第 1 行 (索引为 1) 的所有元素。
#
# 使用索引 arr[row_index, :] 或 arr[row_index]
arr2d[1, :]

# 也可以省略后面的 :
arr2d[1]

# 取出第 2 列 (索引为 2) 的所有元素。
# 使用索引 arr[:, column_index]
arr2d[:, 2]

# 取出位于第 2 行 (索引 2)、第 3 列 (索引 3) 的元素。
# 使用 arr[row_index, column_index]
arr2d[2, 3]

# 取出由第 0 行和第 2 行组成的新数组。
# 使用整数数组作为行索引 arr[[row1, row2, ...], :]
arr2d[[0, 2], :]


# 取出由第 1 列和第 3 列组成的新数组。
# 使用整数数组作为列索引 arr[:, [col1, col2, ...]]
arr2d[:, [1, 3]]

# 取出一个 2x2 的子矩阵，包含元素 6, 7, 10, 11。
# 使用切片 slice arr[row_start:row_stop, col_start:col_stop]
arr2d[1:3, 1:3]

3.三维数组

arr3d = np.arange(3 * 4 * 5).reshape((3, 4, 5))
arr3d 

# 选择特定的层
# 使用整数数组 [0, 2] 作为第一个维度 (层) 的索引
arr3d[1, :, :]

arr3d[1, 0:2, :]

arr3d[1, 0:2, 2:4]

np.arange() 是 NumPy 库中的一个函数，用于创建一个等差数组。它会生成一个从 0 开始，步长为 1 的整数序列。

reshape() 是 NumPy 数组的一个方法，用于改变数组的形状。reshape() 是 NumPy 数组的一个方法，用于改变数组的形状。（元组是「固定的小仓库」​ ​：可以存放多个数据，但一旦创建，里面的内容不能修改。）

#SHAP值的深入理解

重新使用之前的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 # 这里介绍一个新的库，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))

import shap
import matplotlib.pyplot as plt

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

# 计算 SHAP 值（基于测试集），这个shap_values是一个numpy数组，表示每个特征对每个样本的贡献值
# 这里大家先知道这是个numpy数组即可，我们后面学习完numpy在来回头解读这个值
shap_values = explainer.shap_values(X_test) # 这个计算耗时

shap_values 

shap_values[0,:,:]

shap_values[0,:,:].shape #(31, 2) ：这个对应的是（特征数，类别数目）----每个特征对2个目标类别的shap值贡献


# 三个维度
# 第一个维度是样本数
# 第二个维度是特征数
# 第三个维度是类别数
shap_values.shape #(1500, 31, 2)

# 比如我想取出所有样本对第一个类别的贡献值
shap_values[:,:,0]

传入的 SHAP 值 (shap_values[:, :, 0]) 和特征数据 (X_test) 在维度上需要高度一致和对应。

• shap_values[:, :, 0] 的每一行代表的是 一个特定样本每个特征对于预测类别的贡献值（SHAP 值）。缺乏特征本身的值
• X_test 的每一行代表的也是同一个特定样本的特征值。

这二者组合后，就可以组合（特征数，特征值，shap值）构成shap图的基本元素

@浙大疏锦行