导数和微分

flyfish

本文主要论述其中的区别

导数是描述函数变化率的量，它表示函数在某点的瞬时变化速度和切线斜率。
微分是导数的一个线性近似，表示函数在某点处随着自变量变化的增量。
导数和微分在本质上都是研究函数变化的工具，但导数更侧重于变化率，而微分更侧重于线性近似和变化量。
导数和微分是微积分中的两个重要概念，它们虽然紧密相关，但有不同的含义和应用。以下是它们的区别：

导数（Derivative）

1. 定义：

• 导数是描述函数变化率的一个量。具体来说，函数 $f(x)$ 在某点 $x=a$ 处的导数，表示当 $x$ 在 $a$ 附近变化时，函数 $f(x)$ 的变化速度。
• 数学上，导数定义为：
  $f^{\prime }(a)={\lim }_{h\to 0}\frac{f(a+h)-f(a)}{h}$

2. 几何意义：

• 导数在几何上表示曲线 $y=f(x)$ 在点 $(a,f(a))$ 处的切线的斜率。

3. 表示方法：

• 常见的表示法有 $f^{\prime }(x)$、$\frac{df}{dx}$、$Df(x)$ 等。

4. 应用：

• 导数用于研究函数的单调性、极值、凹凸性等性质，广泛应用于物理学、工程学、经济学等领域。

微分（Differential）

1. 定义：

• 微分是导数的一个线性近似。它描述了函数 $f(x)$ 在某点 $x=a$ 处的增量与自变量 $x$ 的增量之间的线性关系。
• 如果 $f$ 在 $a$ 处可导，且导数为 $f^{\prime }(a)$，那么函数在 $a$ 处的微分 $df$ 可以表示为：
  $df=f^{\prime }(a)\cdot dx$
• 其中 $dx$ 是自变量 $x$ 的一个增量。

2. 几何意义：

• 微分表示的是切线的变化量，它是导数的一个线性近似，适用于小范围内的函数变化。

3. 表示方法：

• 微分常表示为 $dy$ 或 $df$，其中 $dy=f^{\prime }(x)\cdot dx$。

导数描述函数变化率

例子：位置函数和速度

假设有一辆车在直线上行驶，其位置 $s$（单位：米）随时间 $t$（单位：秒）的变化用函数 $s(t)=t^2$ 表示。这意味着在时间 $t$ 秒时，车的位置是 $s(t)$ 米。

我们想要了解这辆车在某一时刻的速度。速度就是位置随时间变化的速率，也就是位置函数的导数。

1. 计算导数：

• 首先，计算位置函数 $s(t)$ 的导数 $s^{\prime }(t)$：
  $s^{\prime }(t)=\frac{d}{dt}(t^2)=2t$
• 这个导数 $s^{\prime }(t)$ 就是车在时间 $t$ 秒时的瞬时速度。

2. 解释变化率：

• 导数 $s^{\prime }(t)$ 描述了车的位置 $s(t)$ 随时间 $t$ 变化的速率。例如，在 $t=3$ 秒时，导数 $s^{\prime }(3)=2\times 3=6$ 米/秒。这意味着在第 3 秒时，车的速度是每秒 6 米。
• 更具体地说，导数 $s^{\prime }(t)$ 告诉我们，当时间 $t$ 变化一个非常小的量 $\Delta t$ 时，位置 $s(t)$ 将变化约 $s^{\prime }(t)\cdot \Delta t$。

具体的变化率例子

假设我们想知道在 $t=3$ 秒时，车的位置是如何随时间变化的。我们可以计算导数在这个点的值并解释它的含义。

• 在 $t=3$ 秒时，车的位置是：
  $s(3)=3^2=9\text{ 米}$

• 在 $t=3$ 秒时，车的瞬时速度是：
  $s^{\prime }(3)=2\times 3=6\text{ 米/秒}$
  如果时间从 3 秒增加到 3.1 秒，即 $\Delta t=0.1$ 秒，我们可以使用导数来近似计算这段时间内车位置的变化量：

• 近似变化量 $\Delta s$：
  $\Delta s\approx s^{\prime }(3)\cdot \Delta t=6\text{ 米/秒}\times 0.1\text{ 秒}=0.6\text{ 米}$
  实际位置的变化量：

• 计算实际位置在 3.1 秒时的位置：
  $s(3.1)=(3.1{)}^2=9.61\text{ 米}$

• 实际位置的变化量：
  $\Delta s=s(3.1)-s(3)=9.61-9=0.61\text{ 米}$
  通过这个例子，我们可以看到，导数 $s^{\prime }(t)$ 提供了车在某一时刻的位置变化率，近似地描述了车位置随时间变化的情况。这就是导数描述函数变化率的一个具体实例。

import numpy as np
import matplotlib.pyplot as plt

# 定义函数和导数
def f(x):
    return x**2

def f_prime(x):
    return 2*x

# 定义点和增量
a = 2
h = 0.5

# 计算切线的点
x_tangent = np.linspace(a - 1, a + 1, 100)
y_tangent = f(a) + f_prime(a) * (x_tangent - a)

# 绘图
x = np.linspace(a - 2, a + 2, 400)
y = f(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, label='Function $f(x) = x^2$')
plt.scatter([a, a + h], [f(a), f(a + h)], color='red')
plt.plot(x_tangent, y_tangent, '--', label='Tangent line at $x = 2$', color='orange')

# 标注
plt.text(a, f(a), 'A (2, 4)', fontsize=12, verticalalignment='bottom')
plt.text(a + h, f(a + h), f'B ({a+h}, {f(a + h):.2f})', fontsize=12, verticalalignment='bottom')

plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Visualization of Derivative Definition')
plt.legend()
plt.grid(True)
plt.show()

微分作为导数的线性近似

例子：函数 $f(x)=x^2$

假设我们有一个函数 $f(x)=x^2$，我们想要研究这个函数在某个点 $x=2$ 处的导数和微分。

1. 计算导数：

• 首先，计算 $f(x)$ 的导数 $f^{\prime }(x)$：
  $f^{\prime }(x)=\frac{d}{dx}(x^2)=2x$
• 在 $x=2$ 处的导数 $f^{\prime }(2)$ 为：
  $f^{\prime }(2)=2\times 2=4$

2. 微分的线性近似：

• 在 $x=2$ 处，函数 $f(x)$ 的微分 $df$ 表示为：
  $df=f^{\prime }(2)\cdot dx=4\cdot dx$
• 这里，$dx$ 是自变量 $x$ 的一个小增量。

3. 具体例子：估算函数值的变化：

• 现在假设 $x$ 从 2 增加到 2.1，即 $dx=0.1$。
• 通过微分来近似计算 $f(x)$ 的变化量 $df$：
  $df=4\cdot 0.1=0.4$
• 这意味着，当 $x$ 从 2 增加到 2.1 时，函数值 $f(x)$ 的变化量大约为 0.4。
• 现在我们来计算精确的变化量，即 $f(2.1)-f(2)$：
  $f(2.1)=(2.1{)}^2=4.41$
  $f(2)=2^2=4$
  $f(2.1)-f(2)=4.41-4=0.41$
• 由此可见，通过微分得到的近似值 $0.4$ 与精确变化量 $0.41$ 非常接近。

在这个例子中，导数 $f^{\prime }(2)=4$ 表示函数 $f(x)=x^2$ 在 $x=2$ 处的瞬时变化率。而微分 $df=4\cdot dx$ 提供了一个线性近似，用于估算当 $x$ 发生小变化时，函数值 $f(x)$ 的变化量。

这种线性近似在 $dx$ 很小时非常有效，可以用于快速估算和简化计算。

PyTorch 中的求导（autograd）功能

基本用法

1. 计算标量函数的导数

假设我们有一个标量函数 $f(x)=x^2$，我们希望计算它的导数。

import torch

# 创建一个张量并启用梯度计算
x = torch.tensor(2.0, requires_grad=True)

# 定义函数
y = x**2

# 计算导数
y.backward()

# 打印导数
print(x.grad)  # 输出: tensor(4.0)

在这个例子中：

• 我们创建了一个标量张量 x 并启用了梯度计算（requires_grad=True）。
• 定义了一个函数 $y=x^2$。
• 使用 y.backward() 计算导数，这会计算 $\frac{dy}{dx}$ 并将结果存储在 x.grad 中。

2. 计算向量函数的导数

对于向量函数，我们可以计算每个分量对输入的梯度。

import torch

# 创建一个张量并启用梯度计算
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 定义函数
y = x**2

# 计算导数，y 是一个向量，因此需要提供梯度的初始值
y.backward(torch.tensor([1.0, 1.0, 1.0]))

# 打印导数
print(x.grad)  # 输出: tensor([2.0, 4.0, 6.0])

在这个例子中：

• y 是一个向量函数 $y=[x_1^2,x_2^2,x_3^2]$。
• y.backward() 需要一个与 y 形状相同的张量作为参数，表示每个分量的梯度初始值。
• 结果是 x.grad，它包含了每个分量的导数。