← 全部课程
COMP5541

Machine Learning and Data Analytics

期末 70%(闭卷)· Quiz 9% · Assignment 10% · Group Project 11%。3 小时闭卷,选择题 + 数学计算题。

连载中,随课程进度更新,目前到第 11 周 L09d(11-12),后面的讲次上完课再补。

复习资料与自测

非官方复习材料。自测保留英文题干,答案与解析逐题折叠;练习分值和用时不代表正式考试安排。

逐讲

L01a第 1 周 · 9-03

L01a 机器学习的地图:学习、推断、参数与非参数

从零讲清机器学习的两个阶段、三层坐标,以及参数模型和非参数模型的分界。

L01b第 1 周 · 9-03

L01b KNN 分类:量距离,问最近的几个邻居

从零讲清两点之间的距离怎么算、KNN 分类的四步怎么走、K 取多少会改变答案。

L01c第 1 周 · 9-03

L01c KNN 回归与局限:取平均、统一尺度、四问

从零讲清类别标签和连续标签的区别、KNN 回归怎么算、为什么要先归一化,以及 KNN 的假设、优点和局限。

P01a习题课第 1 周 · 9-03

P01a Practical 1(上):线性代数与微积分,期末的数学计算题从这里出

Practical 1 的前两节:矩阵形状检查、闭区间最值、梯度与 Hessian、拉格朗日乘子,附答案文档没覆盖的那题完整解。

P01b习题课第 1 周 · 9-03

P01b Practical 1(下):概率、统计与 iris 上的 KNN

Practical 1 的后三节:六个分布的公式、贝叶斯两问、方差的有偏与标准化,外加一道 KNN 编程题的实测结论。

T01习题课第 2 周 · 9-10

T01 Tutorial 1:从 Python 语法到一行算完所有距离

一份 notebook 的四个练习、三条 NumPy 规则,和 KNN 类里一处不报错的排序 bug。

L02a第 3 周 · 9-17

L02a 线性回归:定一条直线,用最小二乘一次算出系数

从「回归」这个词讲起:先把模型写成 y = wᵀx + b,再用均方误差给直线打分,最后用求导把误差最小的 w、b 一次算出来。

L02a-2第 3 周 · 9-17

L02a-2 梯度下降:没有公式时,顺着坡一步步走到谷底

从一维抛物线开始,一步一步跑梯度下降,再推广到 w、b 两个参数同时更新,最后讲学习率太大太小、碗形和多坑损失的区别。

L02b第 3 周 · 9-17

L02b 评估模型与多项式基展开:直线贴不上,就给表格加一列 x²

训练好的直线要拿没见过的数据打分;贴不上弯的数据时加 x²、x³ 这些列,模型仍是线性的;加得越多训练误差越小,测试误差却会反弹。

L02b-2第 3 周 · 9-17

L02b-2 偏差、方差与交叉验证:看两个数诊断模型,用验证集挑次数

偏差是多次训练的预测平均偏离真值多远,方差是这些预测散得多开;看训练误差和测试误差就能分清是哪种毛病,各有各的药;选多项式次数只能靠验证集或 N 折交叉验证。

L03a第 4 周 · 9-24

L03a 逻辑回归:给线性模型套一层 sigmoid

分类的答案从一个数变成一个标签。从零讲 one-hot、sigmoid 和交叉熵:线性那一步原样保留,后面接 sigmoid 压成概率,损失换成交叉熵。

L03a-2第 4 周 · 9-24

L03a-2 交叉熵的梯度:三段相乘,约成「误差 × 输入」

从链式法则讲起,推出 sigmoid 的导数 y(1−y),再把交叉熵对 w 的导数拆成三段相乘,看分母怎么被整个约掉,最后套进梯度下降四步。

L03a-3第 4 周 · 9-24

L03a-3 为什么非得是交叉熵:L2 的梯度在两端归零

把损失换回平方差,同样走三段链式,看 y(1−y) 约不掉以后梯度在错得最离谱的地方归零;再从最大似然出发,把交叉熵重新推一遍。

L03a-4第 4 周 · 9-24

L03a-4 决策边界与 softmax:逻辑回归画的是一条直线

y = 0.5 等价于 w'x + b = 0,逻辑回归在空间里找的是一个线性超平面;二分类推广到多类时 sigmoid 换成 softmax,交叉熵化简成 −ln(正确类的概率),边界仍是直线。

L03b第 4 周 · 9-24

L03b 朴素贝叶斯分类器:先学每一类长什么样,再倒推

分类的另一条路:不学分界线,先数每一类占多少、每一类的特征长什么样,来了新样本用贝叶斯法则倒推它属于哪一类。训练只要数数和求均值方差,测试靠独立性连乘。

L03b-2第 4 周 · 9-24

L03b-2 逻辑回归与朴素贝叶斯:各赢在哪,各通向哪

把两种分类器的假设、关键步骤并排放,逐条看逻辑回归的三条优点和朴素贝叶斯的四条优点,缺特征、加类别时谁更好办,最后看两条路分别通向课程的哪一半。

L04a第 6 周 · 10-08

L04a 隐藏层:一条直线分不开 XOR,就先造新特征

从一个神经元讲起,看线性回归和逻辑回归为什么都学不会 XOR,再一帧一帧看隐藏层怎么先造出 OR、AND 两个新特征,让一条直线重新够用。

L04b第 6 周 · 10-08

L04b 搭网络:加宽加深、选激活函数、配输出层

隐藏层能解决 XOR 之后,网络怎么搭:加宽和加深各是什么、参数怎么一层层数,激活函数为什么必须是弯的,输出层和损失函数怎么按任务配对。

L04c第 6 周 · 10-08

L04c 链式法则:把多层网络的导数拆成一段一段

梯度下降要每个权重的导数,可多层网络是函数套函数。先补上梯度下降四步,再讲链式法则的串联和并联两条规则,最后在示例网络上把前向传播和每一个局部导数都算出来。

L04d第 6 周 · 10-08

L04d 反向传播:把误差从输出一层层送回每个权重

从损失出发往回走,一帧一帧算出示例网络 10 个权重的梯度;再到不全连接的网络里找路径;最后把反向传播放回梯度下降,看一次训练迭代完整长什么样。

L05a第 7 周 · 10-15

L05a Mini-batch 与动量:让梯度下降算得省、走得顺

从梯度下降走一步讲起,看全批梯度为什么太贵、mini-batch 怎么省、动量怎么让步子带上惯性。

L05b第 7 周 · 10-15

L05b 梯度消失与 ReLU:为什么网络深了反而学不动

从链式法则是一串乘法讲起,看 sigmoid 怎么让梯度层层缩小,ReLU 怎么救回来又带出死神经元,Leaky ReLU 再怎么补上。

L05c第 7 周 · 10-15

L05c 正则化:L2、L1、早停和 dropout 怎么防过拟合

从「模型把训练集背下来了」讲起,看 L2 和 L1 怎么在梯度里加一股把权重往 0 拉的力,再看早停、dropout、数据增强从另外三个方向下手。

L05d第 7 周 · 10-15

L05d 通用近似定理:ReLU 网络是一条可以无限折弯的折线

从一个 ReLU 单元就是一条带折角的线讲起,把课件的四单元网络一项一项拼成折线,再看通用近似定理说「能表示任意函数」到底承诺了什么。

L06a第 8 周 · 10-22

L06a 卷积运算:一个小窗口在图上滑一遍

从全连接网络处理图片的毛病讲起,补上点积,再一帧一帧看小卷积核怎么在图上滑动、算出特征图,以及它为什么能认出一种图案。

L06b第 8 周 · 10-22

L06b 通道、参数量与补边:卷积层怎么一层层叠起来

输入有好几个通道时核该怎么做,一层卷积有多少参数,以及层层堆叠时特征图越缩越小、怎么用补边保住尺寸。

L06c第 8 周 · 10-22

L06c max-pooling 与典型 CNN:把图快速缩小,再把零件装起来

一帧一帧手算 max-pooling,讲清它没有参数、不改通道、梯度怎么回传,再把卷积、ReLU、pooling 组装成一个典型的 CNN。

L06d第 8 周 · 10-22

L06d AlexNet、VGG、ResNet:网络为什么越做越深

从 ImageNet 错误率表出发,依次看 AlexNet、VGG、ResNet 各靠哪一招把网络做深,并逐帧画出感受野怎么随层数变大。

T02习题课第 9 周 · 10-29

T02 Tutorial 2:用 PyTorch 写 MLP 和 CNN 分类手写数字

一份 125 行的 PyTorch 脚本:数据怎么装进 batch,MLP 和 CNN 每一层的形状与参数量,训练循环的四步,以及测试函数里漏掉的 model.eval()。

L07a第 9 周 · 10-29

L07a 序列数据:为什么要换一种网络,以及五种输入输出结构

MLP 和 CNN 要求输入维数固定,一句话、一段语音做不到。先看清这个前提卡在哪,再按「几个输入对几个输出」把序列任务分成五类。

L07b第 9 周 · 10-29

L07b Vanilla RNN:同一组权重,一格一格往下读

从 tanh 讲起,手算一个一维 RNN 读三步,看隐状态怎么把前面的信息带下去;再数参数、看同一个单元的三种接法,最后说清梯度为什么会消失。

L07c第 9 周 · 10-29

L07c LSTM:一条记忆线,加三个门

先补 sigmoid 和逐元素相乘,再拆开 LSTM 单元:cell state 只做乘和加,遗忘门、输入门、输出门各管一件事;最后数一数参数为什么是 RNN 的 4 倍。

L07c-2第 9 周 · 10-29

L07c-2 课堂代码:LSTM 把一张手写数字读成 28 步序列

逐段读 L07 课堂演示代码:一张 28×28 的 MNIST 图怎么变成 28 步序列,nn.LSTM 每一步的张量是什么形状,为什么只取最后一步接全连接层,训练和评估各做了什么,最后按 PyTorch 的写法把 187 万多个参数一项项数出来。

L07d第 9 周 · 10-29

L07d seq2seq 与 attention:翻译时每一步都回头看整句

两个 RNN 首尾相接就能做翻译,但整句要挤进一个固定长度的向量。attention 让解码器每一步都给源句各位置打分、用 softmax 变成权重、加权求和,从全句里取自己要的部分。

L07e第 9 周 · 10-29

L07e Transformer 自注意力:去掉循环,只留 attention

Transformer 把输入变成 Query、Key、Value,用点积打分、除以 √d_k、softmax、再加权求和,所有位置一起算。这一页逐步手算一次,再讲缩放、补齐与 mask、多头注意力。

T03a习题课第 10 周 · 11-05

T03a Tutorial 3 上半:用 PyTorch 从零写注意力和多头注意力

Tutorial 3 前四个填空:Thinking Machines 例子的五步算法,Attention.forward 的四行代码,多头注意力怎么用 reshape 和 permute 把 128 维切成 4 个头再拼回去。

T03b习题课第 10 周 · 11-05

T03b Tutorial 3 下半:把注意力装成 Transformer 层,拼出图像分类器

Tutorial 3 后两个填空和主程序:TransformerEncoderLayer 的残差与 LayerNorm,图片怎么变成 28 个元素的序列,位置编码与 max pooling,174,218 个参数怎么数,以及照注释换成官方层时的 batch_first 陷阱。

L08a第 10 周 · 11-05

L08a 图数据:节点、边、邻接矩阵和三类任务

社交网络、三维网格、分子都是图:节点数不定,每个节点的邻居数不定。这一页讲怎么把一张图写成邻接矩阵、度矩阵和特征矩阵,加自环得到 Ã 和 D̃,再认清图上的三类任务。

L08b第 10 周 · 11-05

L08b 邻居聚合:ÃX 求和、按度平均和对称归一化

GCN 的第一步是让每个节点把自己和邻居的特征收集起来。直接相加会让邻居多的节点数值偏大,所以要按度归一化。这一页用课件的五节点图逐步算 ÃX、D̃⁻¹ÃX,再比较四种归一化写法。

L08c第 10 周 · 11-05

L08c 一层 GCN 逐步手算,再叠成两层做节点分类

一层 GCN 就是 ReLU(ÂXW):先用归一化邻接矩阵 Â 聚合邻居,再乘所有节点共用的权重 W,最后过 ReLU。这一页在一条三节点的链上把每一步的数字算出来,再讲两层 GCN 怎么输出类别、怎么算损失。

L08d第 10 周 · 11-05

L08d 图池化 DiffPool:用分配矩阵把节点合成簇

GCN 层不改节点个数,图分类却要整张图一个答案。DiffPool 用 softmax 给出分配矩阵 S,新特征是 SᵀZ,新邻接矩阵是 SᵀAS,图一层层缩小。这一页在四节点链上手算一遍,再把整讲串成图分类流程。

L09a第 11 周 · 11-12

L09a 无监督学习与自编码器:没有标签时学什么

数据没有标签,模型还能学:聚类、降维、密度估计、自监督学习。这一页先分清有监督和无监督的任务,再看自编码器怎么用编码器压缩、解码器还原、重构误差训练,以及中间的瓶颈为什么必须比输入窄。

L09b第 11 周 · 11-12

L09b 卷积自编码器:转置卷积、尺寸链和潜在表示

把自编码器的全连接层换成卷积:编码器用步长 2 的卷积把 28×28 的手写数字缩到 10 个数,解码器用转置卷积放大回去。这一页手算转置卷积 2×2 → 4×4,推完整条尺寸链,再看这 10 个数能拿来做什么。

L09c第 11 周 · 11-12

L09c 胶囊层:向量进、向量出,变换、加权和与 squash

胶囊把一个神经元的单个数换成一个向量:长度表示某个东西在不在,方向表示它长什么样。这一页按课件的前三步走:用矩阵 W 变换输入向量,按权重 c 加起来,再用 squash 把长度压进 0 和 1 之间,每一步都手算一遍。

L09d第 11 周 · 11-12

L09d 动态路由与胶囊网络:权重 c 怎么一轮轮调出来

胶囊层的第四步:b 从 0 开始,每轮用 softmax 得到权重 c,算出输出 v,再把每个输入和 v 的内积加回 b。和 v 方向一致的输入越分越多,输出最后落在一团意见一致的输入中间。这一页手算三轮路由,再看几层胶囊怎么叠成胶囊网络。

期末复习怎么用

闭卷考额外考记忆:闭式解、梯度更新式、各类损失函数都要能默写。课件把要求分成 What / Why / How 三层,最易失分的是 Why 那层的辨析题——它横着出(「哪个算法不需要显式训练」),所以复习也得横着来。

  1. 1按讲把页尾「必背」过一遍,公式那几条要真动笔默写,看过不算。
  2. 2每讲的「完整例题」跟着算一遍,然后合上页面做「变式题」,算错就回到那一步重推,别只记结论。
  3. 3把各讲的算法横着填进一张总表,辨析题只在表里才看得出差别;顺手扫「课件里的坑」,标了 [课件有误] 的按更正记。

要能动笔算的题型

这几类没有思考余量,练到不看提示就能做。

KNN 手算
给测试点和训练集,算距离、按 K 投票,说明平票怎么处理
线性回归闭式解
给几个点,算出 w、b 和 MSE
梯度下降一步
给初值和学习率,算一次更新后的参数与损失
贝叶斯法则
写出含全概率分母的完整式子再代数
尺度与标准化
说明不标准化会怎样影响基于距离的算法
偏差与方差
给训练/测试误差的走势,判断欠拟合还是过拟合

复习的产物:自己填的表

填表本身就是复习,抄一份现成的没有用。

  • 算法总表:范式、任务、参数还是非参数、假设、损失函数、优化方式、主要局限
  • 范式对照表:监督信号的形式、典型任务、典型算法
  • 数学公式默写表:闭卷要凭空写出来的那几个式子

累计考点表

各讲页尾「必背」的汇总,随讲次增长。复习时按讲回看,点讲次跳到那一页。

L01a · L01a 机器学习的地图:学习、推断、参数与非参数
  1. Learning 的输入是带标签的训练数据、输出是一个模型,别名 training / fitting;Inferring 的输入是没见过的样本、输出是预测标签,别名 testing / prediction。
  2. ML 的三层坐标是 Paradigm(范式)/ Tasks(任务)/ Algorithms(算法);三个范式是 Supervised、Semi/Unsupervised、Reinforcement。
  3. 划分范式的依据是监督信号的形式,不按算法难度也不按数据量;同一个 DNN 在监督与无监督两栏里都出现。
  4. Parametric 是有限个参数(Linear Regression、PCA、NN),Non-parametric 是参数集合无界(KNN、Gaussian Processes),实质区别是模型复杂度是否随数据量增长。
  5. 参数模型的参数维数预先固定;非参数模型的复杂度可随数据增长,KNN 保留训练数据;KNN 训练开销约等于零,预测时要和全部 N 个训练点各算一次距离(课件给的朴素实现)。
L01b · L01b KNN 分类:量距离,问最近的几个邻居
  1. KNN 是非参数、监督、可做分类也可做回归的方法;核心假设是特征空间中相邻的点性质相似。
  2. KNN 四步:算距离 → 距离升序排序 → 取前 K 个点及其标签 → 汇总;分类取最频繁的标签(投票),回归取 K 个邻居标签的均值或加权均值,只差第 4 步。
  3. 欧氏距离是各维差的平方和再开根号,曼哈顿距离(L1)是各维差的绝对值之和;逐像素 RGB 绝对误差之和就是 L1 距离。
  4. KNN 的关键步骤是距离度量的选择,它由使用者定义(Distance Metric; You define it!),距离决定了谁算邻居。
  5. K 是使用者选定的超参数:K 太小对噪声敏感,K 太大会把远处不相关的点拉进来;二分类取偶数 K 可能平票,所以习惯取奇数。
L01c · L01c KNN 回归与局限:取平均、统一尺度、四问
  1. 类别标签之间没有距离与序,连续标签有,这是分类与回归的本质区别。
  2. 本例类别标签是无序类别,不能直接平均其编号;KNN 回归可取数值均值,分类可投票或汇总类别概率。
  3. KNN 回归前三步和分类相同,第 4 步取 K 个邻居标签的均值或加权均值;加权常用距离的倒数 1/d,越近权重越大。
  4. 某一维取值范围远大于其他维时,距离几乎全由它决定,所以 KNN 之前要先做特征归一化,例如最小-最大归一化 x′ = (x − min) / (max − min)。
  5. KNN 的关键步骤是距离度量的选择,它由使用者定义;四大局限是预测慢、存储大、对特征尺度敏感必须归一化、维度灾难。
P01a · P01a Practical 1(上):线性代数与微积分,期末的数学计算题从这里出
  1. 矩阵乘法不满足交换律,左乘右乘连形状都不同:Xy 是 2×1,zᵀX 是 1×2;写前向传播时靠形状检查判断有没有写反
  2. 行列式非零 ⟺ 可逆 ⟺ 满秩 ⟺ 各列线性无关,四种说法是同一件事,题目会换着问
  3. 连续函数闭区间求最值:列出区间内驻点及不可导点 → 加上两端点 → 比较所有候选函数值;二阶导不能代替全局比较
  4. Hessian 判定表:正定为局部极小、负定为局部极大、不定为鞍点、半定则判据失效要看更高阶
  5. 梯度是列向量、Hessian 是对称矩阵,形状写错本身就是失分点;求偏导时把另一个变量当常数
  6. 拉格朗日乘子把约束优化写成 ∇f = λ∇g 逐分量联立,再代回约束;能几何解释的题用几何验算最快
P01b · P01b Practical 1(下):概率、统计与 iris 上的 KNN
  1. 贝叶斯公式的分母要用全概率公式展开;似然为零的假设后验直接被压成 0,这正是朴素贝叶斯需要平滑的原因
  2. 除以 n 的方差有偏且系统性偏小,E[V] = ((n−1)/n)·σ²;标准化时除以标准差 σ,不是方差
  3. 平方损失来自高斯假设、交叉熵来自伯努利假设、L2 正则来自高斯先验、L1 正则来自拉普拉斯先验
  4. KNN 用距离度量,量纲混杂的数据必须先标准化 yᵢ = (xᵢ − x̄)/σ,否则距离几乎完全由量级大的那一维决定
  5. 打乱数据打乱的是行的顺序,不是每行内部的特征;单次划分的准确率不可信,要多次划分取平均或做交叉验证
  6. K 越大越准是错的:K 过大时投票混进大量其他类别的点,决策边界被抹平成欠拟合
T01 · T01 Tutorial 1:从 Python 语法到一行算完所有距离
  1. NumPy 数组全体元素共用一个 dtype,数字和字符串混放会全部变成字符串
  2. axis 指被消掉的那一维:(4, 3) 对 axis=1 求和得 (4,),对 axis=0 求和得 (3,);keepdims=True 把那一维留成 1
  3. broadcasting 从最右一维往左对比,每维要么相等要么有一边是 1,维数不够在左边补 1
  4. 矩阵乘法 (m×n)(n×p) → (m×p),中间两维必须相等;第 (i, j) 个元素是行与列的点积
  5. 一次算完所有距离:(N, d) − (d,) 广播成 (N, d),再 norm(axis=-1) 得 (N,)
  6. 距离和标签叠进同一个数组后距离变成字符串,argsort 按字典序排,'10.0' 排在 '2.0' 前面
  7. if / elif 链命中第一个为真的分支就结束,最严格的条件放最前面
L02a · L02a 线性回归:定一条直线,用最小二乘一次算出系数
  1. 本讲单输出线性回归是参数模型、输出一个标量;参数个数 = 特征维度 D + 1,由模型形态定,与训练样本数无关。
  2. 模型写成 y = wᵀx + b;在特征前补一列常数 1 可以把偏置 b 吸进 w,之后公式里只剩 w。
  3. 损失用均方误差 MSE:L(w,b) = (1/N) Σ (ȳⁿ − (wxⁿ + b))²;最小化平方和与最小化 MSE 解相同,换成 MAE 解一般不同。
  4. 一维闭式解 w = Σ(xⁿ−x̄)(ȳⁿ−ȳ) / Σ(xⁿ−x̄)²,b = ȳ − w·x̄,要能手算。
  5. 四个阶段里只有 Stage 2「确定参数 W 的数值」叫训练;Stage 1 定模型形状是人定的,Stage 3 是评估打分。
L02a-2 · L02a-2 梯度下降:没有公式时,顺着坡一步步走到谷底
  1. 梯度下降四步:随机初始化 → 算损失判停 → 求梯度 → w ← w − η·∂L/∂w;更新方向永远与梯度相反,每步实际位移 η·|梯度| 随梯度变小,η 本身不变,必须设最大迭代次数。
  2. 更新项 −η·dL/dw 不恒为负:谷底右侧导数为正、w 减小,左侧导数为负、w 增大,不变的只有「方向与导数相反」。
  3. 两个参数时各求偏导、用同一轮的旧值同时更新:∂L/∂w = −(2/N)Σxⁿ(ȳⁿ−wxⁿ−b),∂L/∂b = −(2/N)Σ(ȳⁿ−wxⁿ−b)。
  4. 学习率太大会跨过谷底甚至发散,太小收敛很慢;非凸损失有多个局部极小,梯度下降只保证停在某一个局部极小。
  5. 线性回归 + MSE 的损失是凸的碗,学习率合适、迭代够多时梯度下降收敛到闭式解。
L02b · L02b 评估模型与多项式基展开:直线贴不上,就给表格加一列 x²
  1. 评估只看模型没见过的数据:训练误差小不等于模型好,测试误差才反映模型在新数据上的表现。
  2. 加 x²、x³ 等高次项后仍是线性模型,因为对参数 w 线性;多项式基展开用来抓非线性关系,嵌套模型充分优化时,次数增加使训练误差不增。
  3. 改进模型的三条路各管一件事:调 ε、η 重新训练只影响能不能找到最优 (w, b),加数据对减小方差有用,改模型(加特征)才能解决直线拟合不了曲线。
  4. 误差—复杂度曲线:训练误差随复杂度一路下降,测试误差常示意为先降后升的 U 形但不保证;左端欠拟合,右端过拟合。
  5. 输入不止一维时可以用 x₃ = k(x₁, x₂) 这类函数从原始特征造新特征,思路和加 x² 一样:造特征让线性模型表达非线性。
L02b-2 · L02b-2 偏差、方差与交叉验证:看两个数诊断模型,用验证集挑次数
  1. 偏差 = 多次训练所得预测的平均偏离真值多远,方差 = 这些预测彼此散得多开;简单模型方差小,复杂模型方差大。
  2. 训练集都拟合不了是大偏差(欠拟合),训练好测试差是大方差(过拟合);诊断只看训练误差和测试误差两个数。
  3. 大偏差靠加特征或换更复杂的模型,仅加数据通常不能解决模型表达力不足;大方差靠正则化、更多数据或简化模型。
  4. 选模型只能用验证集或 N 折交叉验证,测试集不参与任何选择,只在最后报一次分。
  5. N 折交叉验证:训练集切 N 份,轮流拿 1 份验证、其余 N−1 份训练,N 个验证误差取平均,比的是平均值。
  6. 线性模型四问:假设标签是特征的线性函数加噪声;关键步骤是最小化 MSE;优点是简单、可解释、有闭式解;局限是只能表达对参数线性的关系、对离群点敏感。
L03a · L03a 逻辑回归:给线性模型套一层 sigmoid
  1. 分类的标准答案是 one-hot 向量、模型输出是一组概率,两边都是向量;类别总数和类别到 one-hot 的对应关系都预先定好。
  2. 逻辑回归 = 线性回归的第一步 t = w'x + b 加 sigmoid 再加交叉熵;t 叫 logit 或 pre-activation。
  3. sigmoid:y = σ(t) = 1 / (1 + exp(−t)),把任意实数压进 (0, 1);t = 0 时 y = 0.5,单调递增,不改变谁大谁小。
  4. 二分类交叉熵 L = −ȳ ln y − (1 − ȳ) ln(1 − y):ȳ = 1 时只剩 −ln y,ȳ = 0 时只剩 −ln(1 − y),给正确答案的概率越低罚得越重。
  5. 交叉熵里 log 取底 e 或 2 只差一个常数因子,不影响梯度方向和最优解位置。
L03a-2 · L03a-2 交叉熵的梯度:三段相乘,约成「误差 × 输入」
  1. 交叉熵梯度三步链式:dL/dy = (y − ȳ)/[y(1−y)],dy/dt = y(1−y),dt/dw = x,化简得 dL/dw = (y − ȳ)x、dL/db = y − ȳ。
  2. sigmoid 的导数 σ' = σ(1 − σ),即 dy/dt = y(1 − y):t = 0 时最大为 0.25,往两端的饱和区趋于 0。
  3. 交叉熵的分母 y(1 − y) 正好和 sigmoid 的导数约掉,这是选交叉熵的根本原因;梯度是「预测误差 × 输入」,和线性回归同形。
  4. 梯度下降四步和线性回归一字不差:随机取初值、算 L 判停、算导数、按 w¹ = w⁰ − η·dL/dw 更新后回到第二步;唯一变的是 L 换成了交叉熵。
  5. 三段链式要能逐段默写,计算题考过程,只记 (y − ȳ)x 不够。
L03a-3 · L03a-3 为什么非得是交叉熵:L2 的梯度在两端归零
  1. L2 loss 用在逻辑回归上,梯度 2(y − ȳ)·y(1 − y)·x 里的 y(1 − y) 约不掉:ȳ = 1 时为 −2y(y − 1)²,ȳ = 0 时为 −2y²(y − 1)(x 取 1),两条在 y = 0 和 y = 1 两端都归零。
  2. L2 失效的要害:ȳ = 1 而 y ≈ 0 时错得最离谱,梯度却接近 0,参数几乎不动;交叉熵在同一位置梯度是 y − ȳ ≈ −1。
  3. 交叉熵的损失曲面起伏明显,L2 的曲面几乎是平板,梯度下降无处可下,所以逻辑回归用交叉熵、不用 L2。
  4. 最大似然:p(y = 1) = σ(t),似然写成 Πⁿ σ(tⁿ)^{ȳⁿ}·[1 − σ(tⁿ)]^{1 − ȳⁿ},指数 ȳⁿ 当开关,一个式子同时表达两种标签。
  5. 取对数变连加、加负号变最小化,负对数似然把 σ(t) 换回 y 就逐字等于交叉熵:最大似然 ≡ 最小化交叉熵;MLE 只推出目标函数,求解仍用梯度下降。
L03a-4 · L03a-4 决策边界与 softmax:逻辑回归画的是一条直线
  1. 逻辑回归本质上是找一个线性超平面把训练点分开:w'x + b = 0 是决策边界,大于 0 和小于 0 的点分在两侧。
  2. y = 0.5 ⇔ σ(t) = 0.5 ⇔ t = 0 ⇔ w'x + b = 0,三种说法是同一件事,所以分类阈值默认取 0.5。
  3. 决策边界只能是线性的,异或(XOR)这类线性不可分的数据单层逻辑回归做不了,这是下一讲引入多层神经网络的直接动机。
  4. 多分类模型 y = softmax(W'x + b),p(y = c) = exp(w_c'x + b_c) / Σ_{c'} exp(w_{c'}'x + b_{c'}):分子 exp 保证为正,分母求和保证加起来等于 1;sigmoid 是 softmax 在 C = 2 时的特例。
  5. 多分类交叉熵 −Σᵢ ȳᵢ ln(yᵢ),ȳ 是 one-hot,只有正确类别那一项非零,退化为 −ln(y_正确类)。
  6. softmax 分类器的决策边界依然是线性的:三分类时平面被若干条直线切成三块,三条直线交于一点。
L03b · L03b 朴素贝叶斯分类器:先学每一类长什么样,再倒推
  1. 判别式建 P(y|x) 只估一套参数、测试时直接算;生成式建 P(y) 与 P(x|y) 要估两套、测试时用贝叶斯法则倒推。
  2. NBC 训练学两件事:先验 p(y = cᵢ) = count(cᵢ)/N;条件分布按特征类型分流,实值特征假设类内高斯(这是额外假设),类别型特征用类内计数比例。
  3. NBC 测试用独立性假设把 p(x|y) 拆成各维连乘,后验正比于先验乘连乘;只比大小时归一化可省,要报告概率值时不能省。
  4. 贝叶斯法则 p(y|x) = p(y)·p(x|y) / p(x):分母 p(x) 对所有类别相同,只比大小时可以不算。
  5. NBC 有两个假设:特征类内条件独立(朴素的含义),以及实值特征类内服从高斯,判断题常把两者揉成一条。
  6. 判别式成员:Logistic Regression、Support Vector Machine、Conditional Random Fields;生成式成员:Naïve Bayes Classifier、Markov Random Fields、Hidden Markov Models。
L03b-2 · L03b-2 逻辑回归与朴素贝叶斯:各赢在哪,各通向哪
  1. LR 的假设是决策边界线性,关键步骤是用梯度下降最小化交叉熵;NBC 的假设是特征类内条件独立加实值特征类内高斯,关键步骤是数数与求均值方差。
  2. LR 优点:准确率更高、可做特征预处理、概率校准好;NBC 优点:不需优化、能处理缺失特征、可按类别单独拟合、可用于无标签数据。
  3. NBC 因连乘小概率导致输出走极端,排序可信、数值不可信。
  4. 特征预处理(如多项式基展开)能绕开「决策边界只能是线性」的限制:在展开后的特征空间里是线性的,映射回原空间就是曲面。
  5. 缺失特征时 NBC 把连乘里那一项跳过即可,LR 的 w'x 少一维就算不下去;新增类别时 NBC 只拟合新类,LR 要整体重训。
  6. 逻辑回归就是单个神经元,堆起来通向深度学习(L04–L08);NBC 学数据分布,通向表示学习(L09–L11)。
L04a · L04a 隐藏层:一条直线分不开 XOR,就先造新特征
  1. 单个神经元 = 先加权求和、再过激活函数;去掉激活就是线性回归,激活用 sigmoid 就是逻辑回归。
  2. XOR 线性不可分:线性回归最好只能全输出 0.5,逻辑回归卡在 ln 2 ≈ 0.693。
  3. 逻辑回归的判定边界仍是一条直线,sigmoid 只把分数压进 (0,1),改变不了边界的形状。
  4. 隐藏层必须有非线性激活,否则多层叠起来仍是线性模型。
  5. 课件第一组分类参数里 h₁ 相当于 OR、h₂ 相当于 AND,输出「OR 而且不是 AND」就是 XOR。
  6. 同一个网络结构可以有多组好解,损失的谷底不止一个。
L04b · L04b 搭网络:加宽加深、选激活函数、配输出层
  1. 全连接层参数个数 =(上一层宽度 + 1)× 本层宽度,不计偏置时去掉 +1。
  2. 加宽是同一层并排放更多神经元,加深是往上叠更多层;层数叫深度,每层神经元数叫宽度。
  3. 三种常用激活:sigmoid 值域 (0,1),ReLU 把负数截成 0,tanh 值域 (−1,1)。
  4. 隐藏层必须带非线性激活,输出层可以不带(课件原文 may not)。
  5. 输出层配对:回归配线性或 ReLU 加 MSE/MAE,二分类配 sigmoid 加 CE,多分类配 softmax 加 CE。
  6. softmax 把 K 个得分变成 K 个加起来为 1 的正数,再和 one-hot 标签一起算交叉熵。
L04c · L04c 链式法则:把多层网络的导数拆成一段一段
  1. 梯度下降四步:随机初值、算损失、求每个参数的导数、沿负梯度更新;多层网络难在第 3 步。
  2. 链式法则:一条路径上局部导数相乘,多条路径相加。
  3. 加权和对权重的导数是它所乘的输入,对上一层输出的导数是对应的权重。
  4. sigmoid 导数 σ(s)(1−σ(s)),只用前向已算好的 σ(s),最大 0.25(s = 0 时)。
  5. 前向传播先算出并存下每个 s、h、y 和 ℓ,反向时直接拿来用。
  6. s 是激活之前的加权和,h 是激活之后的值,两者别混。
L04d · L04d 反向传播:把误差从输出一层层送回每个权重
  1. 任一权重的梯度 = 下游累积误差 × 上游激活。
  2. 累积误差往回传一层:乘连线上的权重,再乘该节点的 σ′;一个节点连向几个下游,就把几条路加起来。
  3. 越靠前的权重求导链越长、路径越多,但前半段的累积误差可以复用。
  4. 非全连接网络只沿真实存在的连线找路径;碰不到某个输出,对那个输出的梯度就是 0。
  5. BP 负责计算梯度,参数更新由梯度下降完成。
  6. 一次训练迭代:前向算出并存下所有值,反向算累积误差和梯度,再更新全部权重。
L05a · L05a Mini-batch 与动量:让梯度下降算得省、走得顺
  1. 深度网络三类问题:优化低效用 mini-batch 和动量,梯度消失用 ReLU/Leaky ReLU,过拟合用正则化。
  2. 全批梯度是所有样本梯度的平均,每步都算全体太费计算和内存,所以改用 mini-batch。
  3. mini-batch 梯度是全批梯度的有噪声估计;小 batch 有正则化效果但运行慢。
  4. 大 batch 梯度更准但不是最优;GPU 适合 2 的幂次 batch,batch 太小 GPU 吃不满。
  5. 动量更新:v ← αv − εg,θ ← θ + v;α = 0 时退化为普通梯度下降。
  6. 动量的惯性帮助越过局部极小,也会冲过最低点(过冲)。
L05b · L05b 梯度消失与 ReLU:为什么网络深了反而学不动
  1. sigmoid 导数最大 0.25,层层相乘导致梯度消失;ReLU 导数 {0, 1},Leaky ReLU 导数 {a, 1}。
  2. 欠拟合的三个原因:层太少、神经元太少、激活函数不好;第三个就是梯度消失。
  3. 只看 sigmoid 导数因子,隔 n 层梯度上限是 0.25ⁿ,层数一多前面层学不动。
  4. ReLU 导数为 1 时梯度原样传回,缓解梯度消失;代价是 s < 0 时出现死神经元。
  5. Leaky ReLU 负区斜率为 a(课件 a = 0.02),死掉的单元仍有小梯度、能慢慢恢复。
  6. 换激活函数只改 dℓ/dw 里的激活导数因子,展开式结构不变。
L05c · L05c 正则化:L2、L1、早停和 dropout 怎么防过拟合
  1. L2 梯度加 2αw,按比例压小权重;L1 梯度加 α·sign(w),拉力恒定,倾向稀疏。
  2. L2 更新式 w ← (1 − 2ηα)·w − η·dℓ/dw,每步先乘一个略小于 1 的系数,所以也叫 weight decay。
  3. L2 求导出来是 2α 不是 α;正则项只在每个权重的梯度上加一项,原来 BP 算的 dℓ/dw 不用重算。
  4. early stopping 停在验证误差最低点;data augmentation 和 dropout 也是正则化。
  5. 三种手段各管一个方向:data augmentation 管数据,early stopping 管训练过程,dropout 管网络结构。
  6. dropout 训练时按概率 p 随机关掉单元,保留的输出除以 (1 − p);测试时用完整网络。
L05d · L05d 通用近似定理:ReLU 网络是一条可以无限折弯的折线
  1. ReLU 网络是分段线性函数,每个 ReLU 单元贡献一个拐点。
  2. 单元 ReLU(wx + b) 的拐点在 x = −b/w;每过一个拐点,斜率加上那个单元的输出权重。
  3. 课件网络 f(x) = ReLU(x) − 2ReLU(x−2) + 2ReLU(x−4) − 2ReLU(x−6) 四段化简为 x、4 − x、x − 4、8 − x,x 为负时 f = 0。
  4. DNN 是分段线性函数:每一段内是线性的,整体是非线性的。
  5. 单隐藏层理论上能表示任意函数,但可能大到不可行,也可能学不出、泛化差。
  6. 定理的严格说法是在有界闭区域上以任意精度逼近连续函数,课件简写成 any function。
L06a · L06a 卷积运算:一个小窗口在图上滑一遍
  1. FC 处理图像的三个问题:参数多、容易过拟合、拉平后丢掉空间关系。
  2. 一个全连接神经元 = 一个和整张图一样大的核,只做一次点积。
  3. 卷积:小核按 stride 在图上滑动做点积,得到一张特征图;无 padding 时输出边长 = (N − k)/s + 1。
  4. 卷积层两个特点:局部连接(每个神经元只连一个 patch)和权重共享(同一个核扫全图)。
  5. 点积 x·w = ||x||·||w||·cosθ;一个核学一种图案,点积越大,这块 patch 越像这个核。
L06b · L06b 通道、参数量与补边:卷积层怎么一层层叠起来
  1. 核深度必须等于输入通道数;有几个核就有几个输出通道。
  2. 卷积层参数量 = k×k×C_in×C_out(偏置另加 C_out),和输入长宽无关。
  3. 求输出尺寸要知道三样:输入尺寸、核尺寸、stride;输出通道数 = 核的个数。
  4. 不补边时每过一层(stride 1)边长少 k − 1;层数一多图越缩越小。
  5. stride 1 时每边补 (k − 1)/2 可以保持尺寸;padding 可以补 0 或复制边界。
L06c · L06c max-pooling 与典型 CNN:把图快速缩小,再把零件装起来
  1. max-pooling 按窗口取最大值:降采样、保留最大响应、对窗口内排列不变;没有参数,通道数不变。
  2. 2×2、stride 2 的 max-pooling 让长宽各减半:128×128×32 → 64×64×32。
  3. max-pooling 反向传播只把梯度传给窗口里的最大值位置,其余位置梯度为 0。
  4. 典型 CNN:CONV-RELU-CONV-RELU-POOL 重复几次,最后接全连接层输出类别。
  5. ReLU 和 max-pooling 交换顺序结果相同(ReLU 单调不减),先 pool 计算更少。
L06d · L06d AlexNet、VGG、ResNet:网络为什么越做越深
  1. ImageNet top-5 错误率:AlexNet 16.4%(8 层)→ VGG 7.3%(19 层)→ ResNet 3.6%(152 层),人类基准 5.1%。
  2. AlexNet:用 ReLU 替代 Sigmoid、8 层(5 个卷积 + 3 个全连接)、各层核大小不同。
  3. VGG 统一用 3×3 小核:两层 3×3 = 5×5 感受野(18 vs 25 个权重),三层 = 7×7(27 vs 49)。
  4. 感受野:原始输入图像中影响某个神经元激活值的区域;深层神经元的感受野比核本身大。
  5. ResNet 的 skip connection:输出 = F(x) + x,梯度能沿捷径传回前层,可训练 152 层甚至 1000 层。
  6. 越深的层倾向于学到语义越强的特征:边缘 → 纹理 → 部件 → 物体。
T02 · T02 Tutorial 2:用 PyTorch 写 MLP 和 CNN 分类手写数字
  1. 训练循环每一步四件事:前向算输出、算 loss、zero_grad 后 backward 求梯度、optimizer.step() 更新参数
  2. 模型最后一层不加 softmax,输出 logits 直接交给 CrossEntropyLoss,它内部等于 LogSoftmax + NLLLoss
  3. MLP 先把 (B, 1, 28, 28) 拉平成 (B, 784);CNN 保留二维,直到全连接层前才拉平成 (B, 1568)
  4. 卷积输出边长 = (输入 + 2·padding − kernel) / stride + 1;5×5 核、padding 2、stride 1 时尺寸不变
  5. MaxPool2d(2, 2) 让高和宽各减半,通道数不变:28 → 14 → 7
  6. 参数量:MLP 397,510,CNN 29,034;Linear(a, b) 有 a·b + b 个,Conv2d 有 输入通道·输出通道·k² + 输出通道 个
  7. 含 BatchNorm 或 Dropout 的模型,测试前要 model.eval();torch.no_grad() 只关梯度,不切模式
L07a · L07a 序列数据:为什么要换一种网络,以及五种输入输出结构
  1. MLP 和 CNN 要求每个输入的维数固定;只要输入或输出有一边是序列,就需要处理序列的模型。
  2. 五种结构:One to One(DNN、CNN)、One to Many(看图说话)、Many to One(情感分类)、Many to Many 同步(视频描述)、Many to Many 先读后写(机器翻译)。
  3. 两种 Many to Many 的区别:同步的每读一格就出一格,输入输出等长;先读后写的读完整串才开始输出,长度可以不同。
  4. 判结构先问输入是不是一串,再问输出是不是一串,两边都是一串时再问是不是每读一格就出一格。
  5. 全连接层的权重矩阵是「输出维数 × 输入维数」,输入维数一变,矩阵就对不上,这是 MLP 处理不了变长输入的原因。
L07b · L07b Vanilla RNN:同一组权重,一格一格往下读
  1. vanilla RNN:h_t = tanh(W_hh h_{t−1} + W_hx x_t),y_t = W_yh h_t。
  2. 三个权重矩阵 W_hh、W_hx、W_yh 在所有时间步共用,参数量和序列长度无关。
  3. 隐状态记住、累积每个时间步的信息;某一步输入为 0,输出也不一定为 0。
  4. 参数量:W_hh 是隐×隐,W_hx 是隐×输入,W_yh 是输出×隐;输入 3、隐状态 4、输出 2 时共 36 个(不计偏置)。
  5. 同一个单元的接法:Many-to-One 只取最后一步的输出,One-to-Many 只在第一步给输入,Many-to-Many 每步都取输出。
  6. RNN/LSTM 的优点:处理长度可变的序列、学序列内部的依赖;缺点:梯度爆炸和消失、训练推理慢、难捕捉很长的依赖。
L07c · L07c LSTM:一条记忆线,加三个门
  1. LSTM:c_t = f_t × c_{t−1} + i_t × g_t,h_t = o_t × tanh(c_t);× 是逐元素相乘。
  2. 遗忘门 f 决定旧记忆留多少,输入门 i 决定新内容写多少,输出门 o 决定拿出多少作为隐状态。
  3. 三个门用 sigmoid,取值 0 到 1,表示放行多少;候选内容 g 用 tanh,取值 −1 到 1,是要写入的内容。
  4. 四个门控量都由 x_t 和 h_{t−1} 算出,各有一对权重矩阵。
  5. cell state 是长期记忆,主要靠加法更新;hidden state 是每一步对外的输出。
  6. LSTM 核心参数是同维数 vanilla RNN 的 4 倍:输入 3、隐状态 4 时 112 对 28(不计偏置)。
L07c-2 · L07c-2 课堂代码:LSTM 把一张手写数字读成 28 步序列
  1. MNIST 一张图 28×28,按行切成 28 步、每步 28 个像素:sequence_length = 28,input_size = 28,是 many-to-one。
  2. batch_first=True 时 LSTM 的输入是 (batch, seq, feature) = (64, 28, 28),输出 out 是 (64, 28, 256)。
  3. h0、c0 的形状是 (num_layers, batch, hidden) = (4, 64, 256),batch_first 不管隐状态。
  4. out[:, -1, :] 取最后一步的 256 维,再接 Linear(256, 10) 得到 10 个类别分数;scores.max(1) 取分数最大的类别。
  5. PyTorch 的 LSTM 每层有两组偏置:一层参数 = 4×hidden×(该层输入 + hidden) + 8×hidden。
  6. 本代码共 1874442 个参数:LSTM 四层 1871872,fc 2570。
  7. count > 100 时 continue 只跳过计算:只训练前 100 个 batch(6400 张),938 个 batch 仍全部取一遍。
L07d · L07d seq2seq 与 attention:翻译时每一步都回头看整句
  1. seq2seq = Many to One + One to Many:编码器把整句压成 Encoder Vector,解码器展开成另一句。
  2. seq2seq 的瓶颈:整句信息要挤进一个固定长度的 Encoder Vector,句子越长越难装下。
  3. Attention + RNN:e_ij = a(s_{i−1}, h_j),α_ij = softmax 后的权重,c_i = Σ α_ij h_j(context vector)。
  4. vanilla attention 的工作方式:对所有时间步的特征做加权求和。
  5. softmax 把一组分数变成非负、加起来等于 1 的权重,分数越高权重越大。
  6. RNN 加 attention 仍要顺序处理,编码器一格等一格、解码器一个词一个词地出,很耗时。
L07e · L07e Transformer 自注意力:去掉循环,只留 attention
  1. Attention(Q, K, V) = softmax(Q Kᵀ / √d_k) V;d_k 是 key 向量的维数。
  2. Q、K、V 都来自同一段输入(自注意力),分数直接用点积算,所有位置可以同时算。
  3. 除以 √d_k:d_k 越大点积越大,softmax 会变得很尖锐、梯度很小;缩放把分数拉回温和范围。
  4. 变长输入用 0 补齐(padding),补齐位置在计算损失时 mask 掉。
  5. Multi-Head Attention:Q、K、V 各过 Linear,h 个头并行做 scaled dot-product attention,Concat 后再过 Linear。
  6. Transformer 出自 Vaswani 等 2017 年的「Attention is all you need」。
T03a · T03a Tutorial 3 上半:用 PyTorch 从零写注意力和多头注意力
  1. 注意力四步:q 和每个 k 点积打分、除以 √d_k、沿最后一维 softmax、用权重对 v 加权求和
  2. Thinking Machines 例子:分数 112、96,除以 8 得 14、12,softmax 得 0.88、0.12
  3. torch.bmm(Q, K.permute(0, 2, 1)) 得到 (batch, seq, seq) 的分数表,每行是一个元素对全部元素的打分
  4. 除以 √d_k 防止点积过大让 softmax 一边倒、梯度变小;d_k 取 q 的最后一维
  5. 多头切分:(B, S, E) → reshape (B, S, h, E/h) → permute(0, 2, 1, 3) → reshape (B·h, S, E/h)
  6. 本例 B = 256、S = 28、E = 128、h = 4:切头后 (1024, 28, 32),分数表 (1024, 28, 28)
  7. 代码用一个 Linear(128, 128) 再切 4 段,等价于每个头各有一个 128 → 32 的小矩阵;课件图里 Concat 后的输出 Linear 代码没写
T03b · T03b Tutorial 3 下半:把注意力装成 Transformer 层,拼出图像分类器
  1. Encoder 层两个子层:x = LN(attn(x) + x),out = LN(ff(x) + x);进出形状都是 (B, S, E),所以可以叠任意多层
  2. 图片变序列:(B, 1, 28, 28) reshape 成 (B, 28, 28),每一行像素是一个元素,共 28 个元素、每个 28 维
  3. 分类器四步:fc1 升到 128 维并加位置编码 → 叠 Transformer 层 → 沿序列维 max 合成 (B, 128) → fc2 输出 (B, 10)
  4. 位置编码 nn.Embedding(28, 128) 是可学习的,形状 (28, 128) 靠广播加到每张图上;没有它注意力分不出元素的先后
  5. 参数量 174,218:fc1 3,712,每层 encoder 82,816(MHA 49,536 + LN 256 + FFN 33,024),pos 3,584,fc2 1,290
  6. 官方 nn.TransformerEncoderLayer 默认 batch_first=False,吃 (S, B, E);直接喂 (B, S, E) 不报错但注意力做在 batch 维上
  7. batch 256 时训练集每轮 235 步、最后一批 96 张;测试集 40 批、最后一批 16 张
L08a · L08a 图数据:节点、边、邻接矩阵和三类任务
  1. 图是不规则数据:每张图的节点数不同,每个节点的边数不同,节点和边带的特征也不同。
  2. 固定大小的网格数据用 CNN / Dense 层,长度可变的序列用 RNN / Attention,图要用 GNN。
  3. 邻接矩阵 A:节点 i 和 j 之间有边记 1,没有记 0;无向图的 A 左右对称,对角线为 0。
  4. 度矩阵 D 是对角矩阵,对角线上是每个节点的边数,也就是 A 每行之和。
  5. Ã = A + I(给每个节点加自环),D̃ = D + I;特征矩阵 X 每行是一个节点的特征。
  6. 图上的三类任务:节点分类、图分类、连边预测(Link/Edge Prediction)。
L08b · L08b 邻居聚合:ÃX 求和、按度平均和对称归一化
  1. ÃX 的第 i 行 = 节点 i 自己和所有邻居的特征之和(消息传递)。
  2. 直接求和的问题:度大的节点加的项多,数值偏大,需要归一化。
  3. D̃⁻¹ÃX 按行平均:每行除以该节点的 d̃,D̃⁻¹Ã 每行之和为 1,但矩阵不对称。
  4. D̃⁻¹ÃD̃⁻¹X 左右各除一次度,对称,课件称为 averaged twice。
  5. D̃^-1/2 Ã D̃^-1/2 X 是 modified average,第 i 行第 j 列的权重是 1/√(d̃_i d̃_j)。
  6. Â := D̃^-1/2 Ã D̃^-1/2,是 GCN 层实际使用的归一化邻接矩阵。
L08c · L08c 一层 GCN 逐步手算,再叠成两层做节点分类
  1. 一层 GCN:H = ReLU(ÂXW), := D̃^-1/2 à D̃^-1/2。
  2. Â 的第 i 行第 j 列 = Ã[i][j] / √(d̃_i d̃_j),只由图的结构决定。
  3. W 是 shared dense layer:所有节点共用同一组参数,W 的列数决定新特征的长度。
  4. GCN 层只改每个节点的特征,不改节点个数。
  5. 两层 GCN:y = sigmoid(Â ReLU(ÂXW⁰) W¹)。
  6. 训练时在每个有标签的节点上算交叉熵损失,再加起来。
L08d · L08d 图池化 DiffPool:用分配矩阵把节点合成簇
  1. GCN 层不缩小图(The graph size is not reduced),图分类需要池化把节点合并。
  2. DiffPool 的嵌入矩阵 Z = GNN₁(A, X),形状 N×F',F' 是自己定的新特征长度。
  3. 分配矩阵 S = softmax(GNN₂(A, X)),形状 N×K,softmax 在 K 个新簇上做,每行加起来是 1。
  4. 新特征 X' = SᵀZ,形状 K×F'。
  5. 新邻接矩阵 A' = SᵀAS,形状 (K×N)(N×N)(N×K) = K×K。
  6. 图分类:GNN 和 DiffPool 交替堆叠,图越缩越小,最后接分类器。
L09a · L09a 无监督学习与自编码器:没有标签时学什么
  1. 有监督学习的数据带标签,任务是分类和回归;无监督学习的数据没有标签。
  2. 无监督学习的四类任务:聚类(K-means)、降维(PCA、Autoencoder)、密度估计(生成模型)、自监督学习。
  3. 自编码器三条公式:编码 h = e(x),解码 x' = d(h),损失 ℓ = ||x' − x||。
  4. 自编码器训练不用标签,输入自己就是要还原的目标;h 叫潜在表示(latent representation)。
  5. undercomplete 自编码器的瓶颈层比输入窄,逼网络学出输入最重要特征的压缩表示。
  6. 自编码器可以用全连接层、卷积层搭,解码器放大尺寸时用转置卷积层。
L09b · L09b 卷积自编码器:转置卷积、尺寸链和潜在表示
  1. 转置卷积(反卷积)把小特征图放大:课件例子 2 x 2 → 4 x 4,用在解码器里做上采样。
  2. 转置卷积的输出边长:(H_in − 1)·s − 2p + k;普通卷积的输出边长:⌊(H_in + 2p − k)/s⌋ + 1。
  3. 课件卷积自编码器:28x28x1 → 14x14x32 → 7x7x64 → 3x3x128 → Flatten 1152 → h(10)。
  4. 解码器倒着走:10 → FC 1152 → Reshape 3x3x128 → DeConv3 → 7x7x64 → DeConv2 → 14x14x32 → DeConv1 → 28x28x1。
  5. 编码器是 Downsample(卷积 stride 2),解码器是 Upsample(转置卷积 stride 2)。
  6. 潜在表示 h 是输入的短编码,同类样本的编码挨在一起;应用:降维、图像压缩、聚类、推荐系统、特征提取。
L09c · L09c 胶囊层:向量进、向量出,变换、加权和与 squash
  1. 神经元:标量进、标量出,y = f(Σ w_i x_i);胶囊:向量进、向量出(Vector In – Vector Out)。
  2. 胶囊输出向量的长度表示它代表的实体出现的概率,方向表示实体的参数(p.26 Q3 选 D)。
  3. Step 1:用可学的矩阵变换输入向量,û_i = W_i u_i;变换后的 û 维数相同。
  4. Step 2:加权和 s_j = Σ c_ij û_i;权重 c_ij 由 Step 4 动态路由给出。
  5. Step 3:squash,v_j = ||s_j||² / (1 + ||s_j||²) · s_j / ||s_j||,方向不变,长度压到 0 和 1 之间。
  6. 胶囊网络想解决 CNN 难以表示部件和整体相对关系的问题(p.26 Q4 选 D)。
L09d · L09d 动态路由与胶囊网络:权重 c 怎么一轮轮调出来
  1. Step 4 动态路由:b 初始化为 0;每轮 c = softmax(b),算 s_j、v_j,再 b_ij ← b_ij + û_i · v_j;跑 K 轮后返回 v_j。
  2. 完整胶囊层:û_i = W_i u_i → s_j = Σ c_ij û_i → v_j = squash(s_j),c_ij 由动态路由求。
  3. 内积 û_i · v_j 大表示输入和输出方向一致(agreement),下一轮这个输入的权重 c 变大。
  4. 动态路由学到的:输出向量会「聚类」输入向量,k > 1 时 v 落在一团方向一致的 û 中间。
  5. 胶囊网络用 routing-by-agreement 代替 max-pooling 在层间传信息(p.25 Q2 选 D)。
  6. 课件的胶囊网络:卷积块 → 多层胶囊(层间动态路由)→ 全连接解码器重构输入,用重构误差训练。