# 线性代数与机器学习工程应用教程 --- ## 目录 1. [基础篇：线性代数核心概念](#一基础篇线性代数核心概念) 2. [应用篇：机器学习中的线性代数](#二应用篇机器学习中的线性代数) 3. [工程篇：NumPy实现与优化](#三工程篇numpy实现与优化) 4. [实战案例](#四实战案例) --- ## 一、基础篇：线性代数核心概念 ### 1.1 向量 (Vector) #### 定义 向量是既有大小又有方向的量，可以表示为有序的数字数组。 ``` v = [v₁, v₂, v₃, ..., vₙ]ᵀ ``` #### 基本运算 **向量加法** ``` u + v = [u₁+v₁, u₂+v₂, ..., uₙ+vₙ]ᵀ ``` **数乘** ``` αv = [αv₁, αv₂, ..., αvₙ]ᵀ ``` **点积（内积）** ``` u · v = u₁v₁ + u₂v₂ + ... + uₙvₙ = Σ(uᵢvᵢ) ``` **几何意义**：点积 = |u||v|cos(θ)，表示两个向量的相似程度 **叉积（外积）**（仅3维） ``` u × v = [u₂v₃-u₃v₂, u₃v₁-u₁v₃, u₁v₂-u₂v₁]ᵀ ``` #### 范数（长度） **L2范数（欧几里得范数）** ``` ||v||₂ = √(v₁² + v₂² + ... + vₙ²) ``` **L1范数（曼哈顿范数）** ``` ||v||₁ = |v₁| + |v₂| + ... + |vₙ| ``` **L∞范数（最大范数）** ``` ||v||∞ = max(|v₁|, |v₂|, ..., |vₙ|) ``` --- ### 1.2 矩阵 (Matrix) #### 定义 矩阵是由 m×n 个数排列成的矩形阵列。 ``` A = [a₁₁ a₁₂ ... a₁ₙ] [a₂₁ a₂₂ ... a₂ₙ] [... ... ... ... ] [aₘ₁ aₘ₂ ... aₘₙ] ``` #### 基本运算 **矩阵加法** ``` C = A + B，其中 cᵢ = aᵢ + bᵢ ``` **数乘** ``` C = αA，其中 cᵢ = α·aᵢ ``` **矩阵乘法** ``` C = AB，其中 cᵢ = Σ(aᵢₖ·bₖⱼ) for k=1 to n ``` **重要性质**： - 不满足交换律：AB ≠ BA - 满足结合律：(AB)C = A(BC) - 满足分配律：A(B+C) = AB + AC **转置** ``` (Aᵀ)ᵢ = Aᵢ ``` 性质：(AB)ᵀ = BᵀAᵀ --- ### 1.3 特殊矩阵 **单位矩阵 I** ``` I = [1 0 ... 0] [0 1 ... 0] [... ... ... ] [0 0 ... 1] ``` 性质：AI = IA = A **对角矩阵** ``` D = diag(d₁, d₂, ..., dₙ) ``` **对称矩阵** ``` A = Aᵀ ``` **正交矩阵** ``` QᵀQ = QQᵀ = I ``` 性质：Q⁻¹ = Qᵀ，保持向量长度不变 --- ### 1.4 矩阵的逆 #### 定义 对于方阵A，如果存在B使得 AB = BA = I，则B称为A的逆矩阵，记为A⁻¹。 #### 求逆方法 **2×2矩阵** ``` A = [a b] A⁻¹ = 1/(ad-bc) [ d -b] [c d] [-c a] ``` **高斯消元法**（通用方法） **伪逆（Moore-Penrose逆）** 对于非方阵或奇异矩阵，使用伪逆 A⁺。 --- ### 1.5 行列式 (Determinant) #### 定义 行列式是一个将方阵映射到标量的函数。 **2×2矩阵** ``` |a b| = ad - bc |c d| ``` **3×3矩阵** ``` |a b c| |d e f| = a(ei-fh) - b(di-fg) + c(dh-eg) |g h i| ``` #### 几何意义 - |det(A)| 表示矩阵A对空间的体积缩放比例 - det(A) = 0 表示矩阵是奇异的（不可逆） --- ### 1.6 特征值与特征向量 #### 定义 对于方阵A，如果存在非零向量v和标量λ使得： ``` Av = λv ``` 则λ称为特征值，v称为对应的特征向量。 #### 求解方法 ``` Av = λv Av - λv = 0 (A - λI)v = 0 ``` 有非零解的条件：det(A - λI) = 0（特征方程） #### 性质 - 特征值的和 = 矩阵的迹（对角线元素之和） - 特征值的积 = 行列式 - 对称矩阵的特征值都是实数，特征向量正交 --- ### 1.7 矩阵分解 #### LU分解 ``` A = LU ``` 其中L是下三角矩阵，U是上三角矩阵。 应用：解线性方程组 Ax = b #### QR分解 ``` A = QR ``` 其中Q是正交矩阵，R是上三角矩阵。 应用：最小二乘法、特征值计算 #### 特征分解 ``` A = PDP⁻¹ ``` 其中P是特征向量组成的矩阵，D是对角矩阵（特征值）。 应用：矩阵幂运算、微分方程求解 #### 奇异值分解 (SVD) ``` A = UΣVᵀ ``` 其中U和V是正交矩阵，Σ是对角矩阵（奇异值）。 **重要性质**： - 任何矩阵都可以进行SVD - 奇异值σ₁ ≥ σ₂ ≥ ... ≥ σᵣ ≥ 0 - 奇异值的平方 = AᵀA的特征值 --- ## 二、应用篇：机器学习中的线性代数 ### 2.1 数据表示 #### 特征矩阵 ``` X = [x₁₁ x₁₂ ... x₁d] ← 样本1 [x₂₁ x₂₂ ... x₂d] ← 样本2 [... ... ... ... ] [xₙ₁ xₙ₂ ... xₙd] ← 样本n ↑ ↑ ↑ 特征1 特征2 特征d ``` n个样本，每个样本d个特征 #### 标签向量 ``` y = [y₁, y₂, ..., yₙ]ᵀ ``` --- ### 2.2 线性回归 #### 模型 ``` y = Xw + b ``` 其中w是权重向量，b是偏置。 #### 最小二乘法求解 目标：最小化 ||Xw - y||² 解析解： ``` w = (XᵀX)⁻¹Xᵀy ``` **问题**：XᵀX可能不可逆（特征数大于样本数，或多重共线性） **解决方案**： - 正则化：w = (XᵀX + λI)⁻¹Xᵀy - 使用伪逆：w = X⁺y --- ### 2.3 主成分分析 (PCA) #### 目标 将高维数据投影到低维空间，保留最大方差。 #### 步骤 **1. 数据中心化** ``` X̃ = X - μ，其中μ是均值向量 ``` **2. 计算协方差矩阵** ``` C = (1/n) X̃ᵀX̃ ``` **3. 特征分解** ``` C = VΛVᵀ ``` **4. 选择前k个特征向量** ``` Vₖ = [v₁, v₂, ..., vₖ]（对应最大k个特征值） ``` **5. 投影** ``` Z = X̃Vₖ ``` #### 与SVD的关系 对X̃进行SVD：X̃ = UΣVᵀ V的列就是主成分方向，Σ²/(n-1)就是特征值。 --- ### 2.4 降维与特征提取 #### t-SNE 使用概率分布保持局部结构，涉及大量矩阵运算。 #### 线性判别分析 (LDA) 最大化类间距离，最小化类内距离。 ``` J(w) = (wᵀS_Bw) / (wᵀS_Ww) ``` 其中S_B是类间散度矩阵，S_W是类内散度矩阵。 --- ### 2.5 神经网络中的线性代数 #### 前向传播 ``` zˡ = Wˡaˡ⁻¹ + bˡ aˡ = σ(zˡ) ``` #### 反向传播 ``` δˡ = (Wˡ⁺¹)ᵀδˡ⁺¹ ⊙ σ'(zˡ) ``` #### 批量处理 ``` Z = XW + b ``` X是m×n的批量数据，W是n×k的权重矩阵。 --- ### 2.6 卷积神经网络 #### 卷积操作 使用卷积核（滤波器）在输入上滑动，本质是一种特殊的矩阵乘法。 #### im2col 将卷积转换为矩阵乘法，利用BLAS加速。 --- ### 2.7 注意力机制 #### Self-Attention ``` Attention(Q, K, V) = softmax(QKᵀ/√dₖ)V ``` Q、K、V都是矩阵，整个计算涉及多次矩阵乘法。 --- ### 2.8 推荐系统 #### 矩阵分解 ``` R ≈ PQᵀ ``` 其中R是用户-物品评分矩阵，P是用户特征矩阵，Q是物品特征矩阵。 #### 协同过滤 基于用户相似度或物品相似度，使用余弦相似度等度量。 --- ## 三、工程篇：NumPy实现与优化 ### 3.1 NumPy基础 #### 数组创建 ```python import numpy as np # 从列表创建 a = np.array([1, 2, 3]) # 创建特殊数组 zeros = np.zeros((3, 4)) ones = np.ones((3, 4)) eye = np.eye(3) # 单位矩阵 arange = np.arange(0, 10, 2) # [0, 2, 4, 6, 8] linspace = np.linspace(0, 1, 5) # [0, 0.25, 0.5, 0.75, 1] # 随机数组 rand = np.random.rand(3, 4) # 均匀分布 randn = np.random.randn(3, 4) # 标准正态分布 ``` #### 数组属性 ```python a.shape # 形状 a.ndim # 维度 a.size # 元素总数 a.dtype # 数据类型 ``` --- ### 3.2 矩阵运算 #### 基本运算 ```python # 逐元素运算 a + b a - b a * b # 逐元素乘法 a / b # 矩阵乘法 np.dot(a, b) a @ b # Python 3.5+ np.matmul(a, b) # 转置 a.T np.transpose(a) # 逆矩阵 np.linalg.inv(a) # 行列式 np.linalg.det(a) # 特征值和特征向量 eigenvalues, eigenvectors = np.linalg.eig(a) # SVD U, S, Vt = np.linalg.svd(a, full_matrices=False) ``` --- ### 3.3 广播机制 NumPy的广播允许不同形状的数组进行运算。 ```python # 标量广播 a = np.array([1, 2, 3]) a + 1 # [2, 3, 4] # 向量广播 a = np.array([[1, 2, 3], [4, 5, 6]]) # shape: (2, 3) b = np.array([10, 20, 30]) # shape: (3,) a + b # [[11, 22, 33], [14, 25, 36]] ``` --- ### 3.4 性能优化 #### 向量化 避免Python循环，使用NumPy的向量化操作。 ```python # 慢 result = [] for i in range(n): result.append(a[i] + b[i]) # 快 result = a + b ``` #### 内存布局 ```python # C-order（行优先）vs F-order（列优先） a = np.array([[1, 2], [3, 4]], order='C') b = np.array([[1, 2], [3, 4]], order='F') # 按行遍历用C-order，按列遍历用F-order ``` #### 使用einsum ```python # 矩阵乘法 np.einsum('ij,jk->ik', A, B) # 批量矩阵乘法 np.einsum('bij,bjk->bik', A, B) # 迹 np.einsum('ii->', A) ``` #### 使用Numba加速 ```python from numba import jit @jit(nopython=True) def fast_function(x): return x ** 2 ``` --- ### 3.5 稀疏矩阵 对于稀疏数据，使用scipy.sparse节省内存。 ```python from scipy import sparse # 创建稀疏矩阵 A = sparse.csr_matrix((data, (row_ind, col_ind)), shape=(1000, 1000)) # 稀疏矩阵乘法 B = A @ A.T # 转回稠密矩阵（小心内存！） A_dense = A.toarray() ``` --- ### 1.8 机器人技术中的变换矩阵 #### 齐次坐标与4×4变换矩阵 在机器人学中，为了统一表示**旋转、平移、缩放**等变换，引入**齐次坐标**和**4×4变换矩阵**。 **为什么用4×4矩阵？** - 3×3矩阵只能表示旋转和缩放，无法表示平移 - 4×4齐次变换矩阵可以统一表示：旋转 + 平移 + 缩放 **齐次坐标：** ``` 3D点 P = (x, y, z) → 齐次坐标 P_h = (x, y, z, 1) 3D向量 v = (x, y, z) → 齐次坐标 v_h = (x, y, z, 0) ``` **4×4变换矩阵结构：** ``` T = [ R t ] ← 旋转矩阵 R (3×3) + 平移向量 t (3×1) [ 0 1 ] ← 透视变换 (机器人中通常为0) + 齐次坐标 ``` #### 旋转矩阵 **绕X轴旋转θ角：** ``` R_x(θ) = [1 0 0 0] [0 cosθ -sinθ 0] [0 sinθ cosθ 0] [0 0 0 1] ``` **绕Y轴旋转θ角：** ``` R_y(θ) = [ cosθ 0 sinθ 0] [ 0 1 0 0] [-sinθ 0 cosθ 0] [ 0 0 0 1] ``` **绕Z轴旋转θ角：** ``` R_z(θ) = [cosθ -sinθ 0 0] [sinθ cosθ 0 0] [ 0 0 1 0] [ 0 0 0 1] ``` #### 平移矩阵 ``` T(t_x, t_y, t_z) = [1 0 0 t_x] [0 1 0 t_y] [0 0 1 t_z] [0 0 0 1] ``` #### 缩放矩阵 ``` S(s_x, s_y, s_z) = [s_x 0 0 0] [ 0 s_y 0 0] [ 0 0 s_z 0] [ 0 0 0 1] ``` #### 复合变换 变换可以**级联**（右乘）： ``` P' = T · R · S · P ``` **注意：变换顺序很重要！** 先执行的变换在右边。 **示例：先旋转后平移** ``` P' = T(t) · R(θ) · P ``` #### 机器人运动学应用 **正向运动学：** 已知关节角度，求末端执行器位姿 ``` T_end = T_1(θ_1) · T_2(θ_2) · ... · T_n(θ_n) ``` **Denavit-Hartenberg (D-H) 参数法：** 每个关节用一个4×4齐次变换矩阵表示，包含： - **θ**：关节角（旋转） - **d**：连杆偏移（平移） - **a**：连杆长度（平移） - **α**：连杆扭角（旋转） ``` T_i = Rot_z(θ_i) · Trans_z(d_i) · Trans_x(a_i) · Rot_x(α_i) ``` **D-H 变换矩阵的完整形式：** ``` ┌ ┐ │ cos(θᵢ) -sin(θᵢ)·cos(αᵢ) sin(θᵢ)·sin(αᵢ) aᵢ·cos(θᵢ) │ Tᵢ = │ sin(θᵢ) cos(θᵢ)·cos(αᵢ) -cos(θᵢ)·sin(αᵢ) aᵢ·sin(θᵢ) │ │ 0 sin(αᵢ) cos(αᵢ) dᵢ │ │ 0 0 0 1 │ └ ┘ ``` **Python 实现示例：** ```python import numpy as np def dh_transform(theta, d, a, alpha): """ 根据D-H参数计算齐次变换矩阵 参数: theta: 关节角 (rad) d: 连杆偏移 a: 连杆长度 alpha: 连杆扭角 (rad) 返回: 4×4 齐次变换矩阵 """ ct, st = np.cos(theta), np.sin(theta) ca, sa = np.cos(alpha), np.sin(alpha) T = np.array([ [ct, -st*ca, st*sa, a*ct], [st, ct*ca, -ct*sa, a*st], [0, sa, ca, d], [0, 0, 0, 1] ]) return T def forward_kinematics(dh_params, joint_angles): """ 计算机械臂正向运动学 参数: dh_params: 列表，每个元素是字典 {'d': ..., 'a': ..., 'alpha': ...} joint_angles: 关节角度列表 [θ₁, θ₂, ..., θₙ] 返回: T_end: 末端执行器的4×4齐次变换矩阵 """ T = np.eye(4) # 初始化为单位矩阵 for i, (params, theta) in enumerate(zip(dh_params, joint_angles)): T_i = dh_transform( theta, params['d'], params['a'], params['alpha'] ) T = T @ T_i # 矩阵乘法（级联变换） return T # 示例：2自由度平面机械臂 dh_params = [ {'d': 0, 'a': 1.0, 'alpha': 0}, # 关节1 {'d': 0, 'a': 0.8, 'alpha': 0} # 关节2 ] joint_angles = [np.pi/4, np.pi/6] # 45°, 30° T_end = forward_kinematics(dh_params, joint_angles) print("末端执行器位姿:") print(f"位置: [{T_end[0,3]:.3f}, {T_end[1,3]:.3f}, {T_end[2,3]:.3f}]") print(f"旋转矩阵:\n{T_end[:3,:3]}") ``` **逆运动学简介：** 逆运动学是正向运动学的逆问题：已知末端执行器位姿，求关节角度。 ``` 给定: T_end 求解: [θ₁, θ₂, ..., θₙ] ``` 常用解法： - **解析法（封闭解）**：适用于特定结构的机械臂（如6轴工业机器人） - **数值法**：雅可比迭代法、牛顿-拉夫森法等 ```python def inverse_kinematics_jacobian(T_target, dh_params, initial_guess, max_iter=100, tol=1e-6): """ 使用雅可比迭代法求解逆运动学 参数: T_target: 目标位姿 (4×4矩阵) dh_params: D-H参数 initial_guess: 初始关节角度猜测 max_iter: 最大迭代次数 tol: 收敛容差 返回: joint_angles: 求解的关节角度 """ q = np.array(initial_guess) for _ in range(max_iter): # 计算当前位姿 T_current = forward_kinematics(dh_params, q) # 计算位姿误差 pos_error = T_target[:3, 3] - T_current[:3, 3] # 计算雅可比矩阵 J = compute_jacobian(dh_params, q) # 使用伪逆求解关节速度 J_pinv = np.linalg.pinv(J) delta_q = J_pinv @ np.concatenate([pos_error, [0, 0, 0]]) # 更新关节角度 q = q + delta_q[:len(q)] * 0.1 # 使用步长控制 # 检查收敛 if np.linalg.norm(pos_error) < tol: break return q ``` --- ### 1.9 雅可比矩阵（Jacobian） #### 定义与物理意义 雅可比矩阵（Jacobian Matrix）是机器人学中最重要的数学工具之一，它建立了**关节空间**与**操作空间**（笛卡尔空间）之间的微分映射关系。 **核心思想**：描述关节的微小变化如何引起末端执行器位姿的变化。 对于n自由度机械臂，设： - **q** = [q₁, q₂, ..., qₙ]ᵀ：关节变量（旋转关节为角度，移动关节为位移） - **x** = [x, y, z, α, β, γ]ᵀ：末端执行器位姿（位置和姿态） 则位姿与关节变量的关系为： ``` x = f(q) ``` 雅可比矩阵定义为 **f** 对 **q** 的偏导数： ``` J(q) = ∂f/∂q = [∂x/∂q₁ ∂x/∂q₂ ... ∂x/∂qₙ] [∂y/∂q₁ ∂y/∂q₂ ... ∂y/∂qₙ] [∂z/∂q₁ ∂z/∂q₂ ... ∂z/∂qₙ] [ ... ... ... ...] [∂γ/∂q₁ ∂γ/∂q₂ ... ∂γ/∂qₙ] ``` #### 速度映射关系 雅可比矩阵的核心作用是建立**速度映射**： ``` ẋ = J(q) · q̇ ``` 其中： - **ẋ** = [v_x, v_y, v_z, ω_x, ω_y, ω_z]ᵀ：末端执行器速度（6×1） - [v_x, v_y, v_z]：线速度（m/s） - [ω_x, ω_y, ω_z]：角速度（rad/s） - **q̇** = [q̇₁, q̇₂, ..., q̇ₙ]ᵀ：关节速度（n×1） - **J(q)**：6×n 雅可比矩阵 **直观理解**：J 的每一列表示"当第i个关节以单位速度运动时，末端执行器产生的速度"。 #### 雅可比矩阵结构 ``` 关节1 关节2 ... 关节n ┌─────────────────────────────────┐ v_x │ ∂x/∂q₁ ∂x/∂q₂ ... ∂x/∂qₙ │ v_y │ ∂y/∂q₁ ∂y/∂q₂ ... ∂y/∂qₙ │ ← 线速度部分 J_v (3×n) v_z │ ∂z/∂q₁ ∂z/∂q₂ ... ∂z/∂qₙ │ ├─────────────────────────────────┤ ω_x │ ... ... ... ... │ ω_y │ ... ... ... ... │ ← 角速度部分 J_ω (3×n) ω_z │ ... ... ... ... │ └─────────────────────────────────┘ ``` #### 几何法求雅可比（矢量法） 对于**旋转关节**（Revolute Joint）： 当第i个关节以角速度 q̇ᵢ 旋转时： **1. 产生的角速度** ``` ω_i = z_i · q̇ᵢ ``` 其中 **z_i** 是关节i的旋转轴方向向量（在世界坐标系中）。 **2. 产生的线速度** ``` v_i = ω_i × (p_end - p_i) = q̇ᵢ · z_i × (p_end - p_i) ``` 其中： - **p_i**：关节i的位置 - **p_end**：末端执行器位置 - **×** 表示向量叉积 **3. 雅可比矩阵的第i列** ``` ┌ ┐ Jᵢ =│ z_i × (p_end - p_i) │ ← 线速度分量 (3×1) │ z_i │ ← 角速度分量 (3×1) └ ┘ ``` 对于**移动关节**（Prismatic Joint）： **1. 产生的线速度** ``` v_i = z_i · q̇ᵢ ``` **2. 产生的角速度** ``` ω_i = 0 ``` （移动关节不产生旋转） **3. 雅可比矩阵的第i列** ``` ┌ ┐ Jᵢ =│ z_i │ ← 线速度分量 │ 0 │ ← 角速度分量 └ ┘ ``` #### 数学推导：从正向运动学求雅可比 **步骤1：建立正向运动学** 末端执行器位置 **p** 是关节变量 **q** 的函数： ``` p(q) = [x(q), y(q), z(q)]ᵀ ``` **步骤2：求偏导数** 雅可比的线速度部分： ``` J_v = [∂p/∂q₁, ∂p/∂q₂, ..., ∂p/∂qₙ] ``` 对于旋转关节i： ``` ∂p/∂qᵢ = z_i × (p - p_i) ``` **推导过程**： - 旋转关节i以角速度 q̇ᵢ 旋转 - 根据刚体运动学，点p的速度为：v = ω × r - 其中 ω = z_i · q̇ᵢ，r = p - p_i - 因此：∂p/∂qᵢ = z_i × (p - p_i) #### 2D平面机械臂示例 **示例：2自由度平面机械臂** ``` 关节1 (θ₁) ──连杆1── 关节2 (θ₂) ──连杆2── 末端 ``` **正向运动学**： ``` x = l₁·cos(θ₁) + l₂·cos(θ₁+θ₂) y = l₁·sin(θ₁) + l₂·sin(θ₁+θ₂) ``` **求雅可比矩阵**： ``` J = [ ∂x/∂θ₁ ∂x/∂θ₂ ] [ ∂y/∂θ₁ ∂y/∂θ₂ ] ``` 计算偏导数： ``` ∂x/∂θ₁ = -l₁·sin(θ₁) - l₂·sin(θ₁+θ₂) ∂x/∂θ₂ = -l₂·sin(θ₁+θ₂) ∂y/∂θ₁ = l₁·cos(θ₁) + l₂·cos(θ₁+θ₂) ∂y/∂θ₂ = l₂·cos(θ₁+θ₂) ``` **几何解释**： - 第1列：关节1单独转动时，末端的速度方向 - 第2列：关节2单独转动时，末端的速度方向 #### 3D空间机械臂（6自由度） 对于6自由度机械臂，完整的雅可比是 6×6 矩阵： ``` J = [ J_v ] = [ z₁×(p₆-p₁) z₂×(p₆-p₂) ... z₆×(p₆-p₆) ] [ J_ω ] [ z₁ z₂ ... z₆ ] ``` 其中： - **p_i**：第i个关节的位置 - **p_6**：末端执行器位置 - **z_i**：第i个关节的旋转轴方向 #### 雅可比矩阵的关键性质 **1. 与位形相关** - J 是关节角度 q 的函数 - 不同位形下，相同的关节速度产生不同的末端速度 **2. 维度** - 对于6自由度机械臂：J 是 6×6 方阵 - 对于n自由度机械臂（n≠6）：J 是 6×n 矩阵 **3. 秩与奇异点** - rank(J) < min(6, n) 时，机械臂处于**奇异位形** - 在奇异点，某些方向的末端运动无法实现 #### 定义（原内容保留） 雅可比矩阵描述了**关节空间速度**与**笛卡尔空间速度**之间的映射关系。 对于n自由度机械臂： ``` v = J(q) · q̇ ``` 其中： - v = [v_x, v_y, v_z, ω_x, ω_y, ω_z]ᵀ：末端执行器线速度和角速度（6×1） - q̇ = [q̇₁, q̇₂, ..., q̇ₙ]ᵀ：关节速度（n×1） - J(q)：6×n 雅可比矩阵 #### 雅可比矩阵结构（原内容保留） ``` J = [ J_v ] ← 线速度部分 (3×n) [ J_ω ] ← 角速度部分 (3×n) ``` **线速度雅可比：** ``` J_v = [∂x/∂q₁ ∂x/∂q₂ ... ∂x/∂qₙ] [∂y/∂q₁ ∂y/∂q₂ ... ∂y/∂qₙ] [∂z/∂q₁ ∂z/∂q₂ ... ∂z/∂qₙ] ``` **角速度雅可比：** ``` J_ω = [z₁ z₂ ... zₙ] ``` 其中 z_i 是第i个关节轴在世界坐标系中的方向向量。 #### 几何法求雅可比（原内容保留） 对于旋转关节i： ``` J_v_i = z_i × (p_end - p_i) ← 线速度分量 J_ω_i = z_i ← 角速度分量 ``` 其中： - z_i：关节i的旋转轴方向向量 - p_i：关节i的位置 - p_end：末端执行器位置 ```python # 已知关节速度，求末端速度 v_end = J @ q_dot ``` **2. 逆运动学（数值解法）** ```python # 已知末端速度，求关节速度（伪逆） q_dot = np.linalg.pinv(J) @ v_end ``` **3. 奇异点检测** ``` det(J·Jᵀ) = 0 → 机械臂处于奇异位形 ``` **4. 力传递** ``` τ = Jᵀ · F ``` 其中 τ 是关节力矩，F 是末端外力。 #### NumPy实现示例 ```python import numpy as np def compute_jacobian(robot_config, joint_angles): """ 计算6自由度机械臂的雅可比矩阵 Args: robot_config: 机器人D-H参数 joint_angles: 关节角度 [θ₁, θ₂, ..., θ₆] Returns: J: 6×6 雅可比矩阵 """ n = len(joint_angles) J = np.zeros((6, n)) # 计算各关节位置和方向 T = np.eye(4) positions = [] axes = [] for i in range(n): # 计算当前关节的变换矩阵 T_i = dh_transform(robot_config[i], joint_angles[i]) T = T @ T_i # 提取位置和旋转轴 positions.append(T[:3, 3]) axes.append(T[:3, 2]) # Z轴方向 end_pos = positions[-1] # 构建雅可比 for i in range(n): # 线速度分量 J[:3, i] = np.cross(axes[i], end_pos - positions[i]) # 角速度分量 J[3:, i] = axes[i] return J def dh_transform(dh_params, theta): """根据D-H参数计算变换矩阵""" d, a, alpha = dh_params['d'], dh_params['a'], dh_params['alpha'] ct, st = np.cos(theta), np.sin(theta) ca, sa = np.cos(alpha), np.sin(alpha) T = np.array([ [ct, -st*ca, st*sa, a*ct], [st, ct*ca, -ct*sa, a*st], [0, sa, ca, d], [0, 0, 0, 1] ]) return T # 使用示例 joint_velocities = np.array([0.1, 0.2, 0.1, 0.0, 0.0, 0.0]) # rad/s J = compute_jacobian(robot_config, current_angles) end_effector_velocity = J @ joint_velocities ``` --- ## 四、实战案例 ### 案例1：使用PCA进行图像压缩 ```python import numpy as np from sklearn.decomposition import PCA import matplotlib.pyplot as plt # 加载图像（灰度） image = plt.imread('image.jpg') # 对每个颜色通道进行PCA compressed = np.zeros_like(image) n_components = 50 # 保留50个主成分 for i in range(3): # RGB三个通道 pca = PCA(n_components=n_components) transformed = pca.fit_transform(image[:, :, i]) compressed[:, :, i] = pca.inverse_transform(transformed) # 计算压缩比 original_size = image.shape[0] * image.shape[1] * 3 compressed_size = n_components * (image.shape[0] + image.shape[1]) * 3 print(f"压缩比: {original_size / compressed_size:.2f}x") ``` --- ### 案例2：使用SVD进行推荐系统 ```python import numpy as np class SVDRecommender: def __init__(self, n_factors=50): self.n_factors = n_factors def fit(self, R): """ R: 用户-物品评分矩阵 (n_users, n_items) """ # 填充缺失值（均值填充） self.mean = np.nanmean(R) R_filled = np.where(np.isnan(R), self.mean, R) # SVD分解 U, S, Vt = np.linalg.svd(R_filled, full_matrices=False) # 保留前n_factors个奇异值 k = self.n_factors self.U = U[:, :k] self.S = np.diag(S[:k]) self.Vt = Vt[:k, :] def predict(self, user_id, item_id): """预测用户对物品的评分""" pred = self.U[user_id] @ self.S @ self.Vt[:, item_id] return pred + self.mean def recommend(self, user_id, n_recommendations=10): """为用户推荐n个物品""" scores = self.U[user_id] @ self.S @ self.Vt