NumPy 基础使用方法（基础+矩阵运算+Attention）

文章目录

• [NumPy 基础使用方法（基础+矩阵运算+Attention）](#NumPy 基础使用方法（基础+矩阵运算+Attention）)
• • 一、基础巩固
  • • [1. 数组创建（ndarray）](#1. 数组创建（ndarray）)
    • [2. 数组核心属性](#2. 数组核心属性)
  • 二、**矩阵运算（重中之重）*
  • • [1. 关键区分：逐元素乘 vs 数学矩阵乘法](#1. 关键区分：逐元素乘 vs 数学矩阵乘法)
    • [2. **矩阵乘法（NumPy核心）*](#2. **矩阵乘法（NumPy核心）*)
    • [3. 线性代数常用函数](#3. 线性代数常用函数)
  • 三、Attention必备函数
  • • [1. Softmax 归一化（注意力权重核心）](#1. Softmax 归一化（注意力权重核心）)
    • [2. **维度扩展/求和（指定轴）*](#2. **维度扩展/求和（指定轴）*)
  • [四、纯NumPy实现 **Self-Attention（自注意力）**](#四、纯NumPy实现 Self-Attention（自注意力）)
  • • 自注意力公式（Transformer原版）
    • 完整代码实现
  • 五、实战示例（从基础到深度学习）
  • • [示例1：基础数组 + 逐元素运算](#示例1：基础数组 + 逐元素运算)
    • 示例2：矩阵乘法实战（线性代数核心）
    • 示例3：完整版Self-Attention（可直接运行）
  • 六、完整总结

---

前言：用python必不可少的就是numpy，那么这篇主要讲解numpy的基本常见操作，示例部分使用numpy实现了经典的attention。

NumPy 基础使用方法（基础+矩阵运算+Attention）

# 全局导入（行业标准）
import numpy as np

一、基础巩固

1. 数组创建（ndarray）

# 1. 常规创建
arr = np.array([1,2,3])                # 一维
arr2d = np.array([[1,2],[3,4]])        # 二维（矩阵）

# 2. 特殊数组
zeros = np.zeros((2,3))    # 全0矩阵
ones = np.ones((3,2))      # 全1矩阵
eye = np.eye(3)           # 3阶单位矩阵
arange = np.arange(0,10,2)# 等差序列
rand = np.random.randn(2,3) # 标准正态分布随机数

2. 数组核心属性

arr = np.array([[1,2,3],[4,5,6]])
print(arr.shape)   # 形状 (行数, 列数) → (2,3)
print(arr.ndim)    # 维度 → 2
print(arr.size)    # 总元素数 →6
print(arr.T)       # 矩阵转置（核心！）

---

二、*矩阵运算（重中之重）

1. 关键区分：逐元素乘 vs 数学矩阵乘法

符号	名称	规则	代码
*	哈达玛积	对应元素相乘，形状必须完全相同	a * b
@/np.matmul/np.dot	标准矩阵乘法	数学矩阵乘，前列=后行	a @ b

2. *矩阵乘法（NumPy核心）

# 定义两个矩阵（满足：A的列数 = B的行数）
A = np.array([[1,2], 
              [3,4]])  # 2x2
B = np.array([[5,6], 
              [7,8]])  # 2x2

# 三种写法（效果完全一致，推荐 @ 最简洁）
mat_mul1 = A @ B          # 最优写法
mat_mul2 = np.matmul(A,B) # 标准函数
mat_mul3 = np.dot(A,B)    # 二维矩阵等价于matmul

print("标准矩阵乘法结果：\n", mat_mul1)
# 输出：
# [[19 22]
#  [43 50]]

# 向量点积（一维矩阵乘法）
x = np.array([1,2,3])
y = np.array([4,5,6])
print("向量点积：", np.dot(x,y)) # 32

3. 线性代数常用函数

# 矩阵求逆（方阵）
A_inv = np.linalg.inv(A)
# 矩阵行列式
det = np.linalg.det(A)
# 矩阵范数
norm = np.linalg.norm(A)

---

三、Attention必备函数

Self-Attention 是Transformer的核心，纯NumPy即可实现，先掌握必备函数：

1. Softmax 归一化（注意力权重核心）

def softmax(x):
    """Softmax函数：将数值转为0-1之间的概率分布"""
    exp_x = np.exp(x - np.max(x))  # 防溢出
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# 测试
x = np.array([[1,2,3],[4,5,6]])
print("Softmax结果：\n", softmax(x))

2. *维度扩展/求和（指定轴）

arr = np.random.randn(2,3)
sum_col = np.sum(arr, axis=0)  # 按列求和
sum_row = np.sum(arr, axis=1)  # 按行求和

---

四、纯NumPy实现 Self-Attention（自注意力）

自注意力公式（Transformer原版）

Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q,K,V) = \text{softmax}\left( \frac{QK^T}{\sqrt{d_k}} \right) V Attention(Q,K,V)=softmax(dk QKT)V

• Q Q Q：查询矩阵 (Query)
• K K K：键矩阵 (Key)
• V V V：值矩阵 (Value)
• d k d_k dk： K K K的维度（缩放因子，防止梯度消失）

完整代码实现

# ====================== 1. 初始化参数 ======================
batch_size = 1   # 批次大小
seq_len = 3      # 序列长度（3个词）
d_k = d_v = 2    # Q/K/V的维度

# 随机生成 Q, K, V 矩阵
Q = np.random.randn(batch_size, seq_len, d_k)
K = np.random.randn(batch_size, seq_len, d_k)
V = np.random.randn(batch_size, seq_len, d_v)

# ====================== 2. 自注意力计算 ======================
# 步骤1：计算 Q × K转置 → 注意力分数
attn_score = Q @ K.transpose(0, 2, 1)  # 高维矩阵转置

# 步骤2：缩放（除以根号dk）
scaled_attn = attn_score / np.sqrt(d_k)

# 步骤3：Softmax归一化 → 注意力权重
attn_weights = softmax(scaled_attn)

# 步骤4：权重 × V → 最终输出
output = attn_weights @ V

# ====================== 打印结果 ======================
print("Q矩阵:\n", Q)
print("注意力权重:\n", attn_weights)  # 每个词对其他词的关注度
print("Attention输出:\n", output)

---

五、实战示例（从基础到深度学习）

示例1：基础数组 + 逐元素运算

import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
print("逐元素相加：", a + b)
print("逐元素相乘：", a * b)
print("向量点积：", a @ b)

示例2：矩阵乘法实战（线性代数核心）

import numpy as np
# 2x3 矩阵 × 3x2 矩阵 → 2x2 矩阵
A = np.array([[1,2,3],[4,5,6]])
B = np.array([[1,2],[3,4],[5,6]])
res = A @ B
print("矩阵乘法结果：\n", res)

示例3：完整版Self-Attention（可直接运行）

import numpy as np

def softmax(x):
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# 超参数
seq_len = 4
d_k = 8

# 生成QKV
Q = np.random.randn(1, seq_len, d_k)
K = np.random.randn(1, seq_len, d_k)
V = np.random.randn(1, seq_len, d_k)

# 注意力计算
attn = softmax(Q @ K.transpose(0,2,1) / np.sqrt(d_k)) @ V
print("Attention最终输出形状：", attn.shape) # (1,4,8)
print("Attention输出：\n", attn)

---

六、完整总结

1. 基础 ：NumPy核心是ndarray，创建用np.array/zeros/randn；
2. 核心运算 ：
   • * = 逐元素乘
   • @/np.matmul = 标准矩阵乘法（线性代数/深度学习必备）；
3. Attention ：
   • 公式：softmax(QKᵀ/√dk)V
   • 纯NumPy可完整实现，是Transformer的基础；
4. 必备函数 ：转置.T、softmax、指定轴求和sum(axis=)。