机器学习中的微积分

导数告诉你哪边是下坡。神经网络要学习，需要的就只有这个。

类型： Learn 语言： Python 前置要求： 阶段 1，第 01-03 课 预计时间： ~60 分钟

学习目标

计算常见 ML 函数（x^2、sigmoid、交叉熵）的数值导数和解析导数
从零实现梯度下降，在一维和二维下最小化一个损失函数
推导线性回归模型的梯度，并通过手动更新权重来训练它
解释 Hessian 矩阵、泰勒级数近似，以及它们与优化方法的联系

问题背景

你有一个神经网络，里面有上百万个权重。每个权重都是一个旋钮。你要弄清楚每一个旋钮该往哪个方向拧，才能让模型错得稍微少一点。微积分给你的就是这个方向。

没有微积分，训练神经网络就只能靠随机改改、然后祈祷有好结果。有了导数，你就清楚每个权重是怎么影响误差的。每次都能把每个旋钮往对的方向拧。

核心概念

什么是导数？

导数衡量变化率。对于函数 y = f(x)，导数 f'(x) 告诉你：如果你把 x 推动一点点，y 会变多少？

从几何上看，导数是某一点处切线的斜率。

f(x) = x^2：

x	f(x)	f'(x)（斜率）
0	0	0（平的，在最底部）
1	1	2
2	4	4（这一点处切线的斜率）
3	9	6

在 x=2 处，斜率是 4。如果你把 x 往右移动一点点，y 大约会增加这个移动量的 4 倍。在 x=0 处，斜率是 0。你正处在碗底。

正式定义：

f'(x) = lim   f(x + h) - f(x)
        h->0  -----------------
                     h

写代码时，你跳过取极限，直接用一个非常小的 h。这就是数值导数。

偏导数：一次只看一个变量

真实的函数有很多输入。神经网络的损失依赖于成千上万个权重。偏导数把除一个变量外的所有变量都固定住，然后对那一个变量求导。

f(x, y) = x^2 + 3xy + y^2

df/dx = 2x + 3y     (treat y as a constant)
df/dy = 3x + 2y     (treat x as a constant)

每个偏导数回答的是：如果我只推动这一个权重，损失会怎么变？

梯度：所有偏导数组成的向量

梯度把每个偏导数收集进一个向量。对于函数 f(x, y, z)，梯度是：

grad f = [ df/dx, df/dy, df/dz ]

梯度指向最陡上升的方向。要最小化一个函数，就往相反方向走。

f(x,y) = x^2 + y^2 的等高线图：

这个函数形成一个碗状，等高线是一圈圈同心圆。最小值在 (0, 0)。

点	grad f	-grad f（下降方向）
(1, 1)	[2, 2]（指向上坡，远离最小值）	[-2, -2]（指向下坡，朝向最小值）
(0, 0)	[0, 0]（平的，在最小值处）	[0, 0]

这就是一张图里的梯度下降。计算梯度，取反，迈一步。

与优化的联系

训练神经网络就是优化。你有一个损失函数 L(w1, w2, ..., wn)，衡量模型错得多离谱。你想最小化它。

Gradient descent update rule:

  w_new = w_old - learning_rate * dL/dw

For every weight:
  1. Compute the partial derivative of loss with respect to that weight
  2. Subtract a small multiple of it from the weight
  3. Repeat

学习率控制步长。太大就会越过头。太小就只能慢慢爬。

损失曲面（一维切片）：

随着权重 w 变化，损失函数 L(w) 形成一条有峰有谷的曲线。

特征	描述
全局最小值	整条曲线上的最低点——最优解
局部最小值	比邻近点低、但不是全局最低的山谷
斜率	梯度下降从任意起点沿斜率往下走

梯度下降沿斜率往下走。它可能困在局部最小值里，但在高维空间（上百万个权重）里，这在实践中很少成为问题。

数值导数 vs 解析导数

计算导数有两种方式。

解析：手算微积分法则。对于 f(x) = x^2，导数是 f'(x) = 2x。精确。快。

数值：用定义来近似。对一个很小的 h 计算 f(x+h) 和 f(x-h)，然后用差值。

Numerical (central difference):

f'(x) ~= f(x + h) - f(x - h)
          -----------------------
                  2h

h = 0.0001 works well in practice

数值导数更慢，但对任何函数都管用。解析导数快，但需要你自己推出公式。神经网络框架用的是第三种办法：自动微分，它机械地算出精确导数。这个你会在阶段 3 看到。

手算简单函数的导数

这些是你在 ML 里会一遍遍见到的导数。

Function        Derivative       Used in
--------        ----------       -------
f(x) = x^2     f'(x) = 2x      Loss functions (MSE)
f(x) = wx + b  f'(w) = x        Linear layer (gradient w.r.t. weight)
                f'(b) = 1        Linear layer (gradient w.r.t. bias)
                f'(x) = w        Linear layer (gradient w.r.t. input)
f(x) = e^x     f'(x) = e^x     Softmax, attention
f(x) = ln(x)   f'(x) = 1/x     Cross-entropy loss
f(x) = 1/(1+e^-x)  f'(x) = f(x)(1-f(x))   Sigmoid activation

对于 f(x) = x^2：

f(x) = x^2    f'(x) = 2x

  x    f(x)   f'(x)   meaning
  -2    4      -4      slope tilts left (decreasing)
  -1    1      -2      slope tilts left (decreasing)
   0    0       0      flat (minimum!)
   1    1       2      slope tilts right (increasing)
   2    4       4      slope tilts right (increasing)

对于 f(w) = wx + b，取 x=3、b=1：

f(w) = 3w + 1    f'(w) = 3

The derivative with respect to w is just x.
If x is big, a small change in w causes a big change in output.

链式法则

当函数被复合在一起时，链式法则告诉你怎么求导。

If y = f(g(x)), then dy/dx = f'(g(x)) * g'(x)

Example: y = (3x + 1)^2
  outer: f(u) = u^2       f'(u) = 2u
  inner: g(x) = 3x + 1    g'(x) = 3
  dy/dx = 2(3x + 1) * 3 = 6(3x + 1)

神经网络是一连串函数：输入 -> 线性 -> 激活 -> 线性 -> 激活 -> 损失。反向传播就是从输出到输入反复套用链式法则。整个算法就是这么回事。

Hessian 矩阵

梯度告诉你斜率。Hessian 告诉你曲率。

Hessian 是二阶偏导数构成的矩阵。对于函数 f(x1, x2, ..., xn)，Hessian 的第 (i, j) 项是：

H[i][j] = d^2f / (dx_i * dx_j)

对于双变量函数 f(x, y)：

H = | d^2f/dx^2    d^2f/dxdy |
    | d^2f/dydx    d^2f/dy^2 |

在临界点（梯度 = 0 处）Hessian 告诉你什么：

Hessian 性质	含义	对应曲面
正定（所有特征值 > 0）	局部最小值	朝上的碗
负定（所有特征值 < 0）	局部最大值	朝下的碗
不定（特征值正负混合）	鞍点	马鞍形

例子： f(x, y) = x^2 - y^2（一个鞍函数）

df/dx = 2x       df/dy = -2y
d^2f/dx^2 = 2    d^2f/dy^2 = -2    d^2f/dxdy = 0

H = | 2   0 |
    | 0  -2 |

Eigenvalues: 2 and -2 (one positive, one negative)
--> Saddle point at (0, 0)

和 f(x, y) = x^2 + y^2（一个碗）对比：

H = | 2  0 |
    | 0  2 |

Eigenvalues: 2 and 2 (both positive)
--> Local minimum at (0, 0)

Hessian 在 ML 里为什么重要：

牛顿法用 Hessian 来迈出比梯度下降更好的优化步子。它不只是顺着斜率走，而是把曲率也考虑进来：

Newton's update:    w_new = w_old - H^(-1) * gradient
Gradient descent:   w_new = w_old - lr * gradient

牛顿法收敛更快，因为 Hessian 对梯度做了"重新缩放"——陡的方向走小步，平的方向走大步。

代价在这：对于有 N 个参数的神经网络，Hessian 是 N x N 的。一个百万参数的模型就需要一个有一万亿个元素的矩阵。这就是我们用近似方法的原因。

方法	它用什么	代价	收敛性
梯度下降	只用一阶导数	每步 O(N)	慢（线性）
牛顿法	完整 Hessian	每步 O(N^3)	快（二次）
L-BFGS	从梯度历史近似 Hessian	每步 O(N)	中等（超线性）
Adam	逐参数自适应学习率（对角 Hessian 近似）	每步 O(N)	中等
自然梯度	Fisher 信息矩阵（统计意义的 Hessian）	每步 O(N^2)	快

实践中，Adam 是深度学习的默认优化器。它通过追踪每个参数梯度的滑动均值和方差，廉价地近似二阶信息。

泰勒级数近似

任何光滑函数都能在局部用一个多项式来近似：

f(x + h) = f(x) + f'(x)*h + (1/2)*f''(x)*h^2 + (1/6)*f'''(x)*h^3 + ...

你包含的项越多，近似越好——但仅限于点 x 附近。

泰勒级数对 ML 为什么重要：

一阶泰勒 = 梯度下降。 当你用 f(x + h) ~ f(x) + f'(x)*h 时，你做的是线性近似。梯度下降最小化这个线性模型，从而选出 h = -lr * f'(x)。
二阶泰勒 = 牛顿法。 用 f(x + h) ~ f(x) + f'(x)*h + (1/2)*f''(x)*h^2，你得到一个二次模型。最小化它给出 h = -f'(x)/f''(x)——牛顿步。
损失函数设计。 MSE 和交叉熵是光滑的，这意味着它们的泰勒展开性质良好。这不是巧合。光滑的损失让优化变得可预测。

Approximation order    What it captures    Optimization method
-------------------    -----------------   -------------------
0th order (constant)   Just the value      Random search
1st order (linear)     Slope               Gradient descent
2nd order (quadratic)  Curvature           Newton's method
Higher orders          Finer structure     Rarely used in ML

关键洞见：所有基于梯度的优化，本质上都是在局部近似损失函数，然后迈向那个近似的最小值。

ML 中的积分

导数告诉你变化率。积分计算累积——曲线下方的面积。

在 ML 里，你很少手算积分，但这个概念无处不在：

概率。 对于一个密度为 p(x) 的连续随机变量：

P(a < X < b) = integral from a to b of p(x) dx

概率密度曲线在 a 和 b 之间的面积，就是落在那个区间里的概率。

期望值。 按概率加权的平均结果：

E[f(X)] = integral of f(x) * p(x) dx

在数据分布上的期望损失就是一个积分。训练最小化的是它的经验近似。

KL 散度。 衡量两个分布有多不同：

KL(p || q) = integral of p(x) * log(p(x) / q(x)) dx

用于 VAE、知识蒸馏和贝叶斯推断。

归一化常数。 在贝叶斯推断里：

p(w | data) = p(data | w) * p(w) / integral of p(data | w) * p(w) dw

分母是对所有可能参数值的积分。它常常不可解，所以我们用 MCMC、变分推断这类近似方法。

积分概念	它在 ML 里出现在哪
曲线下面积	由密度函数得到的概率
期望值	损失函数、风险最小化
KL 散度	VAE、策略优化、蒸馏
归一化	贝叶斯后验、softmax 分母
边际似然	模型比较、证据下界（ELBO）

计算图中的多变量链式法则

链式法则不只适用于排成一条线的标量函数。在神经网络里，变量会分叉再汇合。下面是导数如何在一次简单前向传播中流动：

mermaid

graph LR
    x["x (input)"] -->|"*w"| z1["z1 = w*x"]
    z1 -->|"+b"| z2["z2 = w*x + b"]
    z2 -->|"sigmoid"| a["a = sigmoid(z2)"]
    a -->|"loss fn"| L["L = -(y*log(a) + (1-y)*log(1-a))"]

反向传播从右往左计算梯度：

mermaid

graph RL
    dL["dL/dL = 1"] -->|"dL/da"| da["dL/da = -y/a + (1-y)/(1-a)"]
    da -->|"da/dz2 = a(1-a)"| dz2["dL/dz2 = dL/da * a(1-a)"]
    dz2 -->|"dz2/dw = x"| dw["dL/dw = dL/dz2 * x"]
    dz2 -->|"dz2/db = 1"| db["dL/db = dL/dz2 * 1"]

每条箭头乘上局部导数。任何参数的梯度，是从损失到该参数这条路径上所有局部导数的乘积。当路径分叉再汇合时，你把各路贡献加起来（多变量链式法则）。

反向传播就这么点事：在计算图里从输出到输入，系统性地套用链式法则。

Jacobian 矩阵

当一个函数把向量映射到向量时（就像神经网络的一层），它的导数是一个矩阵。Jacobian 包含每个输出对每个输入的所有偏导数。

对于 f: R^n -> R^m，Jacobian J 是一个 m x n 矩阵：

	x1	x2	...	xn
f1	df1/dx1	df1/dx2	...	df1/dxn
f2	df2/dx1	df2/dx2	...	df2/dxn
...	...	...	...	...
fm	dfm/dx1	dfm/dx2	...	dfm/dxn

你不会为神经网络手算 Jacobian。PyTorch 替你搞定。但知道它的存在能帮你理解反向传播里的形状：如果一层把 R^n 映射到 R^m，它的 Jacobian 就是 m x n。梯度通过这个矩阵的转置往回流。

这对神经网络为什么重要

神经网络里的每个权重都会拿到一个梯度。梯度告诉你怎么调整那个权重才能减小损失。

mermaid

graph LR
    subgraph Forward["前向传播"]
        I["输入"] --> W1["W1"] --> R["relu"] --> W2["W2"] --> S["softmax"] --> L["损失"]
    end

mermaid

graph RL
    subgraph Backward["反向传播"]
        dL["dL/dloss"] --> dW2["dL/dW2"] --> d2["..."] --> dW1["dL/dW1"]
    end

每次权重更新：

W1 = W1 - lr * dL/dW1
W2 = W2 - lr * dL/dW2

前向传播算出预测和损失。反向传播算出损失对每个权重的梯度。然后每个权重往下坡迈一小步。重复几百万步。这就是深度学习。

figure

derivative-tangent

动手构建

第 1 步：从零写数值导数

python

def numerical_derivative(f, x, h=1e-7):
    return (f(x + h) - f(x - h)) / (2 * h)

def f(x):
    return x ** 2

for x in [-2, -1, 0, 1, 2]:
    numerical = numerical_derivative(f, x)
    analytical = 2 * x
    print(f"x={x:2d}  f'(x) numerical={numerical:.6f}  analytical={analytical:.1f}")

数值导数和解析导数能对上好几位小数。

第 2 步：偏导数和梯度

python

def numerical_gradient(f, point, h=1e-7):
    gradient = []
    for i in range(len(point)):
        point_plus = list(point)
        point_minus = list(point)
        point_plus[i] += h
        point_minus[i] -= h
        partial = (f(point_plus) - f(point_minus)) / (2 * h)
        gradient.append(partial)
    return gradient

def f_multi(point):
    x, y = point
    return x**2 + 3*x*y + y**2

grad = numerical_gradient(f_multi, [1.0, 2.0])
print(f"Numerical gradient at (1,2): {[f'{g:.4f}' for g in grad]}")
print(f"Analytical gradient at (1,2): [2*1+3*2, 3*1+2*2] = [{2*1+3*2}, {3*1+2*2}]")

第 3 步：用梯度下降找 f(x) = x^2 的最小值

python

x = 5.0
lr = 0.1
for step in range(20):
    grad = 2 * x
    x = x - lr * grad
    print(f"step {step:2d}  x={x:8.4f}  f(x)={x**2:10.6f}")

从 x=5 出发，每一步都更靠近 x=0（最小值）。

第 4 步：在二维函数上做梯度下降

python

def f_2d(point):
    x, y = point
    return x**2 + y**2

point = [4.0, 3.0]
lr = 0.1
for step in range(30):
    grad = numerical_gradient(f_2d, point)
    point = [p - lr * g for p, g in zip(point, grad)]
    loss = f_2d(point)
    if step % 5 == 0 or step == 29:
        print(f"step {step:2d}  point=({point[0]:7.4f}, {point[1]:7.4f})  f={loss:.6f}")

第 5 步：比较数值导数和解析导数

python

import math

test_functions = [
    ("x^2",      lambda x: x**2,          lambda x: 2*x),
    ("x^3",      lambda x: x**3,          lambda x: 3*x**2),
    ("sin(x)",   lambda x: math.sin(x),   lambda x: math.cos(x)),
    ("e^x",      lambda x: math.exp(x),   lambda x: math.exp(x)),
    ("1/x",      lambda x: 1/x,           lambda x: -1/x**2),
]

x = 2.0
print(f"{'Function':<12} {'Numerical':>12} {'Analytical':>12} {'Error':>12}")
print("-" * 50)
for name, f, df in test_functions:
    num = numerical_derivative(f, x)
    ana = df(x)
    err = abs(num - ana)
    print(f"{name:<12} {num:12.6f} {ana:12.6f} {err:12.2e}")

第 6 步：数值计算 Hessian

python

def hessian_2d(f, x, y, h=1e-5):
    fxx = (f(x + h, y) - 2 * f(x, y) + f(x - h, y)) / (h ** 2)
    fyy = (f(x, y + h) - 2 * f(x, y) + f(x, y - h)) / (h ** 2)
    fxy = (f(x + h, y + h) - f(x + h, y - h) - f(x - h, y + h) + f(x - h, y - h)) / (4 * h ** 2)
    return [[fxx, fxy], [fxy, fyy]]

def saddle(x, y):
    return x ** 2 - y ** 2

def bowl(x, y):
    return x ** 2 + y ** 2

H_saddle = hessian_2d(saddle, 0.0, 0.0)
H_bowl = hessian_2d(bowl, 0.0, 0.0)
print(f"Saddle Hessian: {H_saddle}")  # [[2, 0], [0, -2]] -- mixed signs
print(f"Bowl Hessian:   {H_bowl}")    # [[2, 0], [0, 2]]  -- both positive

鞍函数的 Hessian 特征值是 2 和 -2（符号混合，确认是鞍点）。碗的特征值是 2 和 2（都为正，确认是最小值）。

第 7 步：泰勒近似实战

python

import math

def taylor_approx(f, f_prime, f_double_prime, x0, h, order=2):
    result = f(x0)
    if order >= 1:
        result += f_prime(x0) * h
    if order >= 2:
        result += 0.5 * f_double_prime(x0) * h ** 2
    return result

x0 = 0.0
for h in [0.1, 0.5, 1.0, 2.0]:
    true_val = math.sin(h)
    t1 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=1)
    t2 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=2)
    print(f"h={h:.1f}  sin(h)={true_val:.4f}  order1={t1:.4f}  order2={t2:.4f}")

在 x0=0 附近，sin(x) ~ x（一阶泰勒）。这个近似对小 h 极好，但对大 h 就崩了。这就是为什么梯度下降在学习率小的时候效果最好——每一步都假设线性近似是准的。

第 8 步：这对神经网络为什么重要

python

import random

random.seed(42)

w = random.gauss(0, 1)
b = random.gauss(0, 1)
lr = 0.01

xs = [1.0, 2.0, 3.0, 4.0, 5.0]
ys = [3.0, 5.0, 7.0, 9.0, 11.0]

for epoch in range(200):
    total_loss = 0
    dw = 0
    db = 0
    for x, y in zip(xs, ys):
        pred = w * x + b
        error = pred - y
        total_loss += error ** 2
        dw += 2 * error * x
        db += 2 * error
    dw /= len(xs)
    db /= len(xs)
    total_loss /= len(xs)
    w -= lr * dw
    b -= lr * db
    if epoch % 40 == 0 or epoch == 199:
        print(f"epoch {epoch:3d}  w={w:.4f}  b={b:.4f}  loss={total_loss:.6f}")

print(f"\nLearned: y = {w:.2f}x + {b:.2f}")
print(f"Actual:  y = 2x + 1")

每一个基于梯度的训练循环都遵循这个套路：预测、算损失、算梯度、更新权重。

实际使用

用 NumPy，同样的操作更快也更简洁：

python

import numpy as np

x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([3, 5, 7, 9, 11], dtype=float)

w, b = np.random.randn(), np.random.randn()
lr = 0.01

for epoch in range(200):
    pred = w * x + b
    error = pred - y
    loss = np.mean(error ** 2)
    dw = np.mean(2 * error * x)
    db = np.mean(2 * error)
    w -= lr * dw
    b -= lr * db

print(f"Learned: y = {w:.2f}x + {b:.2f}")

你刚从零搭起了梯度下降。PyTorch 把梯度计算自动化了，但更新循环和这一模一样。

练习

实现 numerical_second_derivative(f, x)，调用两次 numerical_derivative。验证 x^3 在 x=2 处的二阶导数是 12。
用梯度下降找 f(x, y) = (x - 3)^2 + (y + 1)^2 的最小值。从 (0, 0) 出发。答案应该收敛到 (3, -1)。
给梯度下降循环加上动量：维护一个速度向量，累积过去的梯度。在 f(x) = x^4 - 3x^2 上比较有动量和无动量时的收敛速度。

关键术语

术语	人们常说	它实际指什么
导数	"斜率"	函数在某一点的变化率。告诉你输入每变化一个单位、输出变化多少。
偏导数	"对一个变量求导"	在固定其他所有变量的情况下对某一个变量求导。
梯度	"最陡上升方向"	所有偏导数组成的向量。指向让函数增长最快的方向。
梯度下降	"往下坡走"	从参数中减去梯度（乘以学习率）以减小损失。神经网络训练的核心。
学习率	"步长"	控制每次梯度下降步子多大的标量。太大：发散。太小：收敛慢。
链式法则	"把导数乘起来"	复合函数的求导规则：df/dx = df/dg * dg/dx。反向传播的数学基础。
Jacobian	"导数矩阵"	当函数把向量映射到向量时，Jacobian 是输出对输入的所有偏导数组成的矩阵。
数值导数	"有限差分"	通过在两个邻近点求值、计算它们之间斜率来近似导数。
反向传播	"反向模式自动微分"	用链式法则从输出到输入逐层计算梯度。神经网络学习的方式。
Hessian	"二阶导数矩阵"	所有二阶偏导数组成的矩阵。描述函数的曲率。临界点处 Hessian 正定意味着局部最小值。
泰勒级数	"多项式近似"	用函数的各阶导数在某点附近近似它：f(x+h) ~ f(x) + f'(x)h + (1/2)f''(x)h^2 + ...。理解梯度下降和牛顿法为何有效的基础。
积分	"曲线下面积"	一个量在某区间上的累积。在 ML 里，积分定义了概率、期望值和 KL 散度。

Claude 认证课程

lessons

00-certification-strategy

01-claude-product-and-model-landscape

02-model-selection-and-token-economics

03-prompting-and-task-decomposition

04-context-knowledge-memory-and-caching

05-output-evaluation-and-validation

06-governance-safety-and-responsible-use

07-workflow-design-and-human-handoffs

08-messages-api-and-application-lifecycle

09-structured-output-and-defensive-parsing

10-tool-use-and-agentic-loops

11-mcp-server-design-and-integration

12-claude-agent-sdk-and-hooks

13-application-security-and-secrets

14-evals-testing-debugging-and-observability

15-claude-code-for-development-teams

16-multi-agent-orchestration-and-delegation

17-agent-sdk-sessions-subagents-and-context

18-tool-contracts-errors-and-progressive-discovery

19-claude-code-memory-rules-skills-and-ci

20-reliable-extraction-batch-and-reviewers

21-long-context-reliability-provenance-and-escalation

22-business-discovery-requirements-and-slas

23-end-to-end-architecture-and-value-tradeoffs

24-rag-retrieval-and-data-pipelines

25-integration-protocols-identity-and-least-privilege

26-production-observability-latency-and-cost

27-enterprise-governance-compliance-and-hitl

28-stakeholder-communication-adrs-and-lifecycle

29-associate-workflow-capstone

30-developer-application-capstone

31-architect-foundations-scenario-capstone

32-architect-professional-system-capstone

references

research

阶段 0：环境与工具

01-dev-environment

outputs

04-apis-and-keys

outputs

05-jupyter-notebooks

outputs

09-data-management

outputs

12-debugging-and-profiling

outputs

阶段 1：数学基础

01-linear-algebra-intuition

outputs

02-vectors-matrices-operations

outputs

03-matrix-transformations

outputs

04-calculus-for-ml

outputs

05-chain-rule-and-autodiff

outputs

06-probability-and-distributions

outputs

07-bayes-theorem

outputs

08-optimization

outputs

09-information-theory

outputs

10-dimensionality-reduction

outputs

11-singular-value-decomposition

outputs

12-tensor-operations

outputs

13-numerical-stability

outputs

14-norms-and-distances

outputs

15-statistics-for-ml

outputs

16-sampling-methods