线性代数核心

子空间与基的概念

向量空间的子集如果也构成一个向量空间，则称为子空间。线性无关向量组中的向量数量等于空间维数时，该向量组构成该空间的一组基。

import numpy as np

def is_linearly_independent(vectors):
    """检查向量组是否线性无关"""
    matrix = np.vstack(vectors)
    # 计算矩阵的秩
    rank = np.linalg.matrix_rank(matrix)
    # 如果秩等于向量数量，则线性无关
    return rank == len(vectors)

# 示例向量组
vectors = [
    np.array([1, 0, 0]),
    np.array([0, 1, 0]),
    np.array([0, 0, 1])
]

print(f"向量组是否线性无关: {is_linearly_independent(vectors)}")
# 输出: 向量组是否线性无关: True

Python中使用NumPy实现矩阵操作

import numpy as np

# 创建两个矩阵
A = np.array([[3, 1], [1, 2]])
B = np.array([[2, 1], [1, 3]])

# 矩阵乘法
C = np.dot(A, B)
print("矩阵乘法结果:\n", C)

# 计算矩阵的行列式
det_A = np.linalg.det(A)
print(f"行列式值: {det_A}")

# 计算矩阵的逆
if det_A != 0:
    A_inv = np.linalg.inv(A)
    print("矩阵的逆:\n", A_inv)
    
    # 验证逆矩阵性质
    identity = np.dot(A, A_inv)
    print("A·A^-1:\n", np.round(identity, decimals=10))  # 四舍五入处理浮点误差
else:
    print("矩阵不可逆")

特征值分解的Python实现

import numpy as np
import matplotlib.pyplot as plt

# 创建一个对称矩阵
A = np.array([[4, 2], [2, 3]])

# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)

print("特征值:", eigenvalues)
print("特征向量:\n", eigenvectors)

# 验证分解结果
P = eigenvectors
D = np.diag(eigenvalues)
P_inv = np.linalg.inv(P)

# 重建原矩阵
A_reconstructed = np.dot(np.dot(P, D), P_inv)
print("重建的矩阵:\n", np.round(A_reconstructed, decimals=10))

# 验证特征向量与特征值的关系
for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    Av = np.dot(A, v)
    lambda_v = eigenvalues[i] * v
    print(f"验证特征向量 {i+1}:")
    print(f"A·v = {Av}")
    print(f"λ·v = {lambda_v}")
    print(f"误差: {np.linalg.norm(Av - lambda_v)}\n")

Python实现注意力机制

import numpy as np

def scaled_dot_product_attention(Q, K, V):
    """
    计算缩放点积注意力
    
    参数:
        Q: 查询矩阵，形状 (seq_len, d_k)
        K: 键矩阵，形状 (seq_len, d_k)
        V: 值矩阵，形状 (seq_len, d_v)
        
    返回:
        注意力加权后的值，形状 (seq_len, d_v)
    """
    # 计算注意力分数
    d_k = K.shape[1]
    scores = np.dot(Q, K.T) / np.sqrt(d_k)
    
    # 应用softmax获取注意力权重
    attention_weights = softmax(scores)
    
    # 加权求和
    output = np.dot(attention_weights, V)
    
    return output, attention_weights

def softmax(x):
    """Compute softmax values for each sets of scores in 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 = 3
d_k = 2
d_v = 2

Q = np.array([[1, 0], [0, 1], [1, 1]])  # (3, 2)
K = np.array([[1, 0], [0, 1], [1, 1]])  # (3, 2)
V = np.array([[0.5, 0.8], [0.2, 0.3], [0.9, 0.1]])  # (3, 2)

output, attention_weights = scaled_dot_product_attention(Q, K, V)

print("注意力权重:\n", attention_weights)
print("\n注意力输出:\n", output)

Python实现图像变换

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon

def transform_point(point, matrix):
    """应用变换矩阵到点"""
    # 将2D点转换为齐次坐标
    homogeneous_point = np.array([point[0], point[1], 1])
    # 应用变换
    transformed = np.dot(matrix, homogeneous_point)
    # 转回2D坐标
    return transformed[:2]

def transform_polygon(vertices, matrix):
    """应用变换矩阵到多边形的所有顶点"""
    return np.array([transform_point(v, matrix) for v in vertices])

# 创建一个简单的正方形
square = np.array([[0, 0], [1, 0], [1, 1], [0, 1]])

# 定义不同的变换矩阵
# 旋转45度
theta = np.radians(45)
rotation_matrix = np.array([
    [np.cos(theta), -np.sin(theta), 0],
    [np.sin(theta), np.cos(theta), 0],
    [0, 0, 1]
])

# 缩放: x方向2倍，y方向0.5倍
scaling_matrix = np.array([
    [2, 0, 0],
    [0, 0.5, 0],
    [0, 0, 1]
])

# 平移: x方向1单位，y方向2单位
translation_matrix = np.array([
    [1, 0, 1],
    [0, 1, 2],
    [0, 0, 1]
])

# 切变: x方向切变因子0.5
shear_matrix = np.array([
    [1, 0.5, 0],
    [0, 1, 0],
    [0, 0, 1]
])

# 应用变换
rotated_square = transform_polygon(square, rotation_matrix)
scaled_square = transform_polygon(square, scaling_matrix)
translated_square = transform_polygon(square, translation_matrix)
sheared_square = transform_polygon(square, shear_matrix)

# 绘图
plt.figure(figsize=(12, 10))

plt.subplot(221)
plt.gca().add_patch(Polygon(square, fill=False, edgecolor='blue', label='原始'))
plt.gca().add_patch(Polygon(rotated_square, fill=False, edgecolor='red', label='旋转45°'))
plt.title('旋转变换')
plt.axis('equal')
plt.grid(True)
plt.legend()

plt.subplot(222)
plt.gca().add_patch(Polygon(square, fill=False, edgecolor='blue', label='原始'))
plt.gca().add_patch(Polygon(scaled_square, fill=False, edgecolor='green', label='缩放'))
plt.title('缩放变换 (x: 2倍, y: 0.5倍)')
plt.axis('equal')
plt.grid(True)
plt.legend()

plt.subplot(223)
plt.gca().add_patch(Polygon(square, fill=False, edgecolor='blue', label='原始'))
plt.gca().add_patch(Polygon(translated_square, fill=False, edgecolor='purple', label='平移'))
plt.title('平移变换 (x: +1, y: +2)')
plt.axis('equal')
plt.grid(True)
plt.legend()

plt.subplot(224)
plt.gca().add_patch(Polygon(square, fill=False, edgecolor='blue', label='原始'))
plt.gca().add_patch(Polygon(sheared_square, fill=False, edgecolor='orange', label='切变'))
plt.title('切变变换 (x方向切变因子: 0.5)')
plt.axis('equal')
plt.grid(True)
plt.legend()

plt.tight_layout()
plt.show()