矩阵、线性映射与线性方程组

水平缩放后剪切图像，与先剪切后缩放可不同。AI 层也如此：特征行表、权重、偏置需特定形状约定。不说明哪个映射先执行、哪个轴是特征，仅写乘号不能定义计算。

本课把矩阵项连接映射、方程与可执行操作，推导复合积、消元保持解集、分类三种系统，区分可逆与数值可靠。最后协调列向量数学与批行存储代码。

回忆检查：点积、线性组合、点与位移、广播。复习模块 09与 NumPy 准备。可选成本比较参考模块 06，不是代数核心先修。矩阵均有限实项，正行列数。

m×n 矩阵 A 是矩形数组 aᵢⱼ，i 行、j 列。作列向量映射时形状依次 m 输出、n 输入，也可存 m 观测 n 特征表。同布局支持两角色，应用要明确；数据表行不自动是某物理变换输出。

x∈Rⁿ 列的 y=Ax∈Rᵐ 定义 $y_i=\sum_{j=1}^n a_{ij}x_j$，每输出是 A 一行与 x 点积。n 输入必须匹配 n 行内项，m 可不同。2×3 把三坐标变二，3×2 反向；同六数字不使它们可互换。

也有列组合 $Ax=\sum_jx_jA_{:j}$。Aeⱼ 恰第 j 列，单位向量选择列。选定各单位坐标像就确定每输入映射，赋列几何意义，不需逐个无限输入列例。

映射 L 线性表示对所有输入与实 α，L(u+v)=L(u)+L(v)、L(αu)=αL(u)。矩阵行有限和分配可证。线性必须零到零，因为 L(0)=L(0)+L(0)。几个样例不证普遍线性，而 Ax 公式有一般坐标证明。

反过来任意 Rⁿ→Rᵐ 线性映射在本坐标有矩阵：x=∑xⱼeⱼ，线性给 L(x)=∑xⱼL(eⱼ)，取单位像为列。坐标选择重要，同一抽象映射可因基不同而有不同数组，模块 11 展开。

仿射映射 x↦Ax+b 添固定输出偏移，保持直线与仿射组合结构，只有 b=0 才线性。如实线 2x+1 不零到零。AI 偏置供偏移，常简称“线性层”，数学区别仍影响加法、原点、固定点证明。

矩阵加法与数乘逐项且需同形状，A+B 表同定义陪域映射之和，αA 表输出缩放。2×3 加 3×2 不按此定义合法，数组广播可另定义数值操作，应区分矩阵代数与库允许的一切数组算术。

B n×p、A m×n，列 x∈Rᵖ 先 B 成 n，后 A 成 m。AB m×p 的 $(AB)_{ik}=\sum_{j=1}^n a_{ij}b_{jk}$。内维 n 数中间坐标，外维 m,p 数结果；列最右先。

推公式：A(Bx) 第 i 项 ∑ⱼaᵢⱼ∑ₖbⱼₖxₖ，有限和重排得 ∑ₖ(∑ⱼaᵢⱼbⱼₖ)xₖ=(AB)x。中间坐标求和说明不同于逐项乘；逐项乘用于其他任务，不实现此复合。

相容矩阵乘结合，(AB)C=A(BC)，两边项展开同有限双和 ∑ⱼ∑ₖaᵢⱼbⱼₖcₖℓ。可以改有序复合分组，不能换顺序。分组仍可改中间数组大小、数值舍入、工作量，尽管实代数结果同。

单位矩阵 Iₙ 对角一其余零，保 n 坐标输入。m×n 的 A 有 IₘA=A、AIₙ=A，两侧不同尺寸。对角矩阵独立缩各坐标，零对角塌方向，负反方向。名称不意味着一般矩阵可逆。

转置 Aᵀ 互换行列，(Aᵀ)ⱼᵢ=aᵢⱼ，形状 n×m。(AB)ᵀ=BᵀAᵀ：左 (k,i) 项 ∑ⱼaᵢⱼbⱼₖ，右 ∑ⱼbⱼₖaᵢⱼ，标量交换给同。反序也保形状，只转不反可能无定义或另映射。

对称方阵 A=Aᵀ 只描述项对称，不自动正性、可逆或数据解释。单位对称可逆，全零方阵对称奇异。后面用于内积、谱、协方差，这里仅一个有自己定义范围的性质。

分块矩阵把行列分组，积仍相容块积和，需中间分区对齐。如横 [A B] 乘竖 [u;v] 为 Au+Bv，u,v 匹配各列组。块仍矩形映射有维度，把块当标量会隐藏非法乘。记法组织大系统，不改项公式。

线性系统 Ax=b 为 m 方程 n 未知，第 i 行 ∑ⱼaᵢⱼxⱼ=bᵢ，b 每方程一常数。增广矩阵 [A|b] 同存系数与常数，分隔区别未知系数与固定目标。只改 A 不改 b 可改变解，即使系数变换熟悉。

三初等行操作：交换方程，方程乘非零标量，一方程加另一方程倍。操作整增广行含 RHS。各有同类逆，故双向保解；乘零不允许，可能擦约束且不可逆。

证明行相加：旧解满足原两行，故满足线性组合新行；反向用未改源行，从新目标减同倍可恢复旧目标。这反向给解集相等，只有“旧解仍解”不能排新增解。

主元为选定消元非零系数。候选对角零而下行同列非零可交换；剩同列全零则跳列继续，不能除零。主元列识别约束坐标，跳列可在确认相容后对应自由变量。

精确算术任意适当非零主元合法，浮点选本列剩余最大绝对项是部分选主元，避免不必要小分母。实用规则不让全部系统条件好，也不证明所有误差小。实验用精确 Fraction 跟踪，分开代数等价与浮舍入。

行操作改方程、不改未知坐标身份。交换行重约束顺序，交换列则重变量，需对应改 x 解释。求解器可有意列排列，但必须记录。混淆行列交换会把看似合理数赋错特征。

消元不变式是当前增广与原系统解集完全相同。每合法操作保持，零模式使求解容易。终止由主元行或列在有限界内推进。不变式本身不保证进展，有限候选位置遍历另给终止。

行阶梯形非零系数行在零系数行前，后主元严格右移，主元下零。矛盾行可系数全零、RHS 非零，应明确识别而非当普通未知主元，区分系数主元与增广常数。

高斯消元选主元、可归一主行、消下面、继续余行列。归一非阶梯必需，实验为回代方便归一。上面也消可得简化行阶梯，是额外转换，唯一三角系统求解不必如此。

回代从末主元行起，自由值选定后，每主元式从已知后变量解自身，若未归一再除非零主元。结构保证所需后来值已知，向上继续；无此结构自上而下可能用尚未知值。

精确实解集三类：有 0=c,c≠0 则不相容无解；无矛盾且每未知列有主元则唯一；无矛盾且至少一自由未知则欠定无限实解，每实自由值可回代扩展。

[1,1|3],[2,2|7] 消得矛盾常数一，无解；改第二常数六则冗余、x+y=3，解 (3−t,t)，t 实。系数相同，奇异为矩阵性质，相容还依 b，仅报“奇异”不分类解集。

只数方程不够。方形相关约束可无解或无限，瘦高可每未知主元且额外式相容而唯一，宽不可能约全部未知却也可不相容。看变换方程与常数，不按形状完整分类。

参数族完整：每阶梯解有某自由值，向上主元强迫报告的其他坐标；反向任意自由值回代满足全部主元，且无矛盾零行。行等价双向转回原系统，族既不漏不添。

精确零与近零不同，Fraction 可判精确零，浮点需容差与尺度解释。小残差或小计算行列式本身不是精确符号分类。模块 11 数值秩、28 浮点可靠，先由小精确例建立代数类。

n×n 方阵 A 可逆若 n×n A⁻¹ 满足 A⁻¹A=Iₙ 且 AA⁻¹=Iₙ，撤销映射，给每 b 的 x=A⁻¹b。若 B,C 均逆，B=B(AC)=(BA)C=C，唯一。矩形可有条件下单侧逆，但非本双侧方阵定义。

方阵每列主元当且仅当可逆。全主元使任意目标相容唯一，解 Aeⱼ 构建逆列。反向可逆不可能非零 z 满足 Az=0，施逆强迫 z=0；漏主元可选自由值给非零齐次解，矛盾。连接映射、方程、主元。

构造 B 的列式给 AB=I。BAx 与 x 都解 Ay=Ax，该目标唯一使 BAx=x 全 x，因此 BA=I。这样查双侧，不把单侧默当全部定义。

2×2 行 (a,b),(c,d) 的行列式 ad−bc。两列为单位方形映像平行四边形边，表达式为有符号面积；绝对值为面积倍率，负指方向反转，零塌为线或点。不是单输出长或存储项数。

一般 2×2 直接乘核 $(ad-bc)^{-1}\begin{bmatrix}d&-b\\-c&a\end{bmatrix}$，当 det非零。零时列相关，非零方向塌掉，无双侧逆。这小证明支撑面积与逆条件，不靠库成功调用。

高维行列式推广有符号体积，实方阵可逆当且仅当 det非零。本课声明使用一般定理，交替多线性体积完整构造为后续内容。消元换行改符号、非零缩行乘尺度、行相加保，三角 det 是对角积，连接主元。

代数 x=A⁻¹b 正确，数值求一个 RHS 用直接求解器，无需先构全部逆项。分解回代可复用多目标。实验良好例两法一致，不证明逆代码总失败或每直接求解都不敏感。

克拉默法则把每未知写替换一个系数列为 b 的行列式比，非奇异方阵精确公式。分别多算行列式重复工作，比值不消敏感。可作小符号推导，本课数值流程用直接分解求解。代数合法式未必优选过程。

残差 r=A x̂−b。精确零说明解存储方程，数值小残差度量近满足，不证明原数据准确或推断值接近微扰数据解，尺度与敏感重要。

A=diag(1,10⁻¹²)，b=(1,10⁻¹²) 得 (1,1)。第二目标加 10⁻⁹ 得 (1,1001)。仍可逆且新目标残差零，却解大变，是方程内在敏感，不自动求解器 bug。谱与条件数后量化，此例已反驳可逆或残差保证可靠系数。

输入列 x 有 d 坐标，输出列 y 有 o，y=Mx+b，M o×d、b o×1，每行一个输出特征加权和。B 输入存行 X B×d，用 W=Mᵀ d×o，Y=XW+bᵀ B×o，各行同仿射。

转置关系协调约定，不使乘交换。XW 与 Mx 同系数、不同明确方向。库权布局可选任一，应读定义标轴再用公式。B,d,o 分别观测、特征、输出，不是可互换尺寸。

NumPy X @ W 矩阵积，X * W 逐项或广播。形状恰同，错操作也可跑而数似合理。平坦偏置 (o,) 供每行，列 (o,1) 可失败或 B=o 时供不同批行偏移。轴長偶合可掩语义错，形状相容不够。

例子前两行错偏置列会第一行两输出都加 0.5、第二都减 0.5，得 (1.5,2.5),(−1.5,2.5)，不同目标。两者形状都是 (2,2)，标输出/批轴，除形状还查刻意不均匀小例值。

朴素 m×n 乘 n×p 用 mnp 标乘，每输出 n 项若首积初始化，需 n−1 加，共 mp(n−1)；从零开始实现可计 n 加。先声明收费操作，有限索引直接给数，可选渐近参考模块 06。

偏置再每输出一加。长积改分组可改中间维与工作，结合保精确映射。库利用结构硬件，标量计数是教育模型，不直接预测机器秒数，分代数、计数、时间。

实现约定记输入输出、轴义、数值表示、例外。测试环境 np.linalg.solve(A,b) 要方形非奇异系数作唯一系统求解，不返回欠定族、不分类矛盾奇异。最小二乘与最小范数需另定义，模块 12。

核验分层：乘前维度、小手算例、适当残差或逆恒等式。已知解可揭转置、偏置位置，容差按数据，不使有限检查变普遍证明。行操作与复合证明解释一般公式。

用 NumPy 准备 固定环境。消元另标准库 Fraction 精确。下载源产生捕获输出，含实际残差。

实验 A 矩阵积与批仿射

预测：SH,HS 及 (1,1) 像，标 X,W,偏置形状。运行：循环与 NumPy 比。解释：最右列映射先，偏置按输出。修改：矩形权并改偏置、输出约定。程序拒锯齿与不合内维。

下载 lab1_products.py

"""Shape-checked matrix multiplication and an explicitly batched affine map."""
import numpy as np

def shape(matrix):
    if not matrix or not matrix[0] or any(len(row) != len(matrix[0]) for row in matrix):
        raise ValueError("Require a nonempty rectangular matrix")
    return len(matrix), len(matrix[0])

def multiply(a, b):
    rows, inner = shape(a)
    other_inner, cols = shape(b)
    if inner != other_inner:
        raise ValueError("Inner dimensions must agree")
    return [[sum(a[i][k] * b[k][j] for k in range(inner)) for j in range(cols)] for i in range(rows)]

scale, shear = [[2, 0], [0, 1]], [[1, 1], [0, 1]]
for name, a, b in [("S H (shear first)", scale, shear), ("H S (scale first)", shear, scale)]:
    product = multiply(a, b)
    assert np.array_equal(np.array(product), np.array(a) @ np.array(b))
    print(name + ":", product, "; image of (1,1):", multiply(product, [[1], [1]]))
x, weights, bias = [[1, 0], [0, 1], [2, -1]], [[1, 2], [-1, 3]], [0.5, -0.5]
linear = multiply(x, weights)
affine = [[value + bias[j] for j, value in enumerate(row)] for row in linear]
reference = np.array(x) @ np.array(weights) + np.array(bias)
assert reference.shape == (3, 2) and np.array_equal(reference, np.array(affine))
print("Shapes X / W / bias / output:", shape(x), shape(weights), (len(bias),), shape(affine))
print("XW:", linear)
print("XW + bias:", affine)
for a, b in [([[1, 2]], [[1, 2]]), ([[1, 2], [3]], [[1], [2]])]:
    try:
        multiply(a, b)
    except ValueError as error:
        print("Rejected:", error)

S H (shear first): [[2, 2], [0, 1]] ; image of (1,1): [[4], [1]]
H S (scale first): [[2, 1], [0, 1]] ; image of (1,1): [[3], [1]]
Shapes X / W / bias / output: (3, 2) (2, 2) (2,) (3, 2)
XW: [[1, 2], [-1, 3], [3, 1]]
XW + bias: [[1.5, 1.5], [-0.5, 2.5], [3.5, 0.5]]
Rejected: Inner dimensions must agree
Rejected: Require a nonempty rectangular matrix

实验 B 精确带主元消元

预测：首主元行、三系统类别。运行：读精确增广、主元、自由列。解释：零常数与矛盾，原式验唯一解。修改：改重复行 RHS 先预测。打印索引零基，x,y,z 原顺序不改。

下载 lab2_elimination.py

"""Exact rational elimination with pivot selection and all three system classes."""
from fractions import Fraction

def echelon(coefficients, rhs):
    rows, cols = len(coefficients), len(coefficients[0])
    if len(rhs) != rows or any(len(row) != cols for row in coefficients):
        raise ValueError("Require rectangular coefficients and one RHS per row")
    augmented = [[Fraction(x) for x in row] + [Fraction(b)] for row, b in zip(coefficients, rhs)]
    pivot_row, pivots, events = 0, [], []
    for column in range(cols):
        if pivot_row == rows:
            break
        chosen = max(range(pivot_row, rows), key=lambda i: abs(augmented[i][column]))
        if augmented[chosen][column] == 0:
            continue  # No pivot in this column; it can be free.
        if chosen != pivot_row:
            augmented[chosen], augmented[pivot_row] = augmented[pivot_row], augmented[chosen]
            events.append(f"swap rows {pivot_row} and {chosen}")
        pivot = augmented[pivot_row][column]
        augmented[pivot_row] = [value / pivot for value in augmented[pivot_row]]
        for i in range(pivot_row + 1, rows):
            factor = augmented[i][column]
            augmented[i] = [a - factor * b for a, b in zip(augmented[i], augmented[pivot_row])]
        pivots.append(column)
        events.append(f"pivot row {pivot_row}, column {column}")
        pivot_row += 1
    inconsistent = any(all(value == 0 for value in row[:cols]) and row[cols] != 0 for row in augmented)
    status = "inconsistent" if inconsistent else "unique" if len(pivots) == cols else "underdetermined"
    return augmented, pivots, events, status

def solve_unique(rows, pivots):
    cols = len(rows[0]) - 1
    answer = [Fraction(0)] * cols
    for row_index in range(len(pivots) - 1, -1, -1):
        column = pivots[row_index]
        row = rows[row_index]
        answer[column] = row[-1] - sum(row[j] * answer[j] for j in range(column + 1, cols))
    return answer

cases = [
    ("pivoted unique", [[0, 2, 1], [1, -2, -3], [2, 3, 1]], [3, 0, 7]),
    ("inconsistent", [[1, 1], [2, 2]], [3, 7]),
    ("underdetermined", [[1, 1], [2, 2]], [3, 6]),
]
for name, coefficients, rhs in cases:
    rows, pivots, events, status = echelon(coefficients, rhs)
    print(name + ":", status)
    print("Events:", events)
    print("Echelon augmented rows:", [[str(value) for value in row] for row in rows])
    print("Pivot / free columns (zero based):", pivots, [j for j in range(len(coefficients[0])) if j not in pivots])
    if status == "unique":
        answer = solve_unique(rows, pivots)
        assert all(sum(Fraction(a) * x for a, x in zip(row, answer)) == b for row, b in zip(coefficients, rhs))
        assert answer == [1, 2, -1]
        print("Solution:", [str(x) for x in answer])
    assert status == ("unique" if name == "pivoted unique" else name)
print("All row operations used exact Fractions; a zero RHS row differs from a contradiction row.")

pivoted unique: unique
Events: ['swap rows 0 and 2', 'pivot row 0, column 0', 'pivot row 1, column 1', 'pivot row 2, column 2']
Echelon augmented rows: [['1', '3/2', '1/2', '7/2'], ['0', '1', '1', '1'], ['0', '0', '1', '-1']]
Pivot / free columns (zero based): [0, 1, 2] []
Solution: ['1', '2', '-1']
inconsistent: inconsistent
Events: ['swap rows 0 and 1', 'pivot row 0, column 0']
Echelon augmented rows: [['1', '1', '7/2'], ['0', '0', '-1/2']]
Pivot / free columns (zero based): [0] [1]
underdetermined: underdetermined
Events: ['swap rows 0 and 1', 'pivot row 0, column 0']
Echelon augmented rows: [['1', '1', '3'], ['0', '0', '0']]
Pivot / free columns (zero based): [0] [1]
All row operations used exact Fractions; a zero RHS row differs from a contradiction row.

实验 C 求解器、奇异与敏感

预测：[[3,1],[1,2]] 目标 [9,8] 解、两奇异目标。运行：直接与逆在此均可。解释：异常不区分无解无限，微扰对角系统仍零残差。修改：增小对角项，同扰动比较。它展示数据敏感，不声称某库法永远较精确。

下载 lab3_solvers_and_faults.py

"""Direct solves, singular RHS distinctions, and sensitivity despite a nonzero determinant."""
import numpy as np

a = np.array([[3.0, 1.0], [1.0, 2.0]])
b = np.array([9.0, 8.0])
direct = np.linalg.solve(a, b)
via_inverse = np.linalg.inv(a) @ b
assert direct.shape == (2,) and via_inverse.shape == (2,)
assert np.allclose(direct, [2, 3], rtol=1e-12, atol=1e-12)
assert np.allclose(via_inverse, direct, rtol=1e-12, atol=1e-12)
print("Direct solve:", direct.round(6).tolist())
print("Inverse times RHS:", via_inverse.round(6).tolist())
print("Residual norms:", float(np.linalg.norm(a @ direct - b)), float(np.linalg.norm(a @ via_inverse - b)))
print("Both agree here; forming an inverse is unnecessary for solving one RHS.")

singular = np.array([[1.0, 2.0], [2.0, 4.0]])
for rhs in [np.array([3.0, 6.0]), np.array([3.0, 7.0])]:
    try:
        np.linalg.solve(singular, rhs)
    except np.linalg.LinAlgError:
        kind = "infinitely many: x+2y=3" if rhs[1] == 2 * rhs[0] else "inconsistent: second RHS is not twice first"
        print("Singular solve rejected:", rhs.tolist(), ";", kind)

sensitive = np.diag([1.0, 1e-12])
baseline_rhs = np.array([1.0, 1e-12])
changed_rhs = np.array([1.0, 1e-12 + 1e-9])
baseline, changed = np.linalg.solve(sensitive, baseline_rhs), np.linalg.solve(sensitive, changed_rhs)
assert np.allclose(baseline, [1, 1], rtol=1e-12, atol=1e-12)
assert np.allclose(changed, [1, 1001], rtol=1e-12, atol=1e-12)
print("Nonzero determinant:", float(np.linalg.det(sensitive)))
print("Baseline / perturbed solution:", baseline.round(6).tolist(), changed.round(6).tolist())
print("Small RHS change:", float(np.linalg.norm(changed_rhs - baseline_rhs)))
print("Changed-system residual:", float(np.linalg.norm(sensitive @ changed - changed_rhs)))
print("Invertibility and small residual do not guarantee insensitivity of the solution.")

Direct solve: [2.0, 3.0]
Inverse times RHS: [2.0, 3.0]
Residual norms: 0.0 0.0
Both agree here; forming an inverse is unnecessary for solving one RHS.
Singular solve rejected: [3.0, 6.0] ; infinitely many: x+2y=3
Singular solve rejected: [3.0, 7.0] ; inconsistent: second RHS is not twice first
Nonzero determinant: 1.000000000000001e-12
Baseline / perturbed solution: [1.0, 1.0] [1.0, 1001.0]
Small RHS change: 1e-09
Changed-system residual: 0.0
Invertibility and small residual do not guarantee insensitivity of the solution.

1–12 必做，13–14 扩展。小系统用精确算术，给解集不只状态。

1–9 自动，10 书面自评。

读作者 Mathematics for Machine Learning 伴随站 的系统、积、行列式选段，查 NumPy solve 约定及逆接口。一手阅读补本原创例与论证。

库的“精确系统求解”指解 Ax=b 而非最小二乘目标，浮点实现仍数值，不保证符号精确或不敏感。

不看笔记解释列像、推积项、证行加等价。各解一系统类，分声明 det 与残差，再标批仿射。

结业任务：A=[[1,2],[0,1]],b=(5,2)，回代 y=2,x=1，det一，逆 [[1,−2],[0,1]] 恢复输入。b 存 (2,) 或 (2,1) 不改同一数学目标，也不会仅因形状变成两独立目标批。

前进标准：可解释方程、完整分类解、保映射与存储约定。下一课空间、基、秩、零方向、参数可辨识，见课程总览。