### 背景





小波变换是一种在信号处理中广泛应用的数学工具。与傅里叶变换不同，小波变换可以提供同时在时间和频率上的局部化信息。它通过缩放和平移基本小波函数来分析信号，适用于处理非平稳信号，如音频、图像和生物医学信号等。

### 公式

小波变换的基本公式如下：

1. **连续小波变换（CWT）**:

$$

W_\psi (a, b) = \frac{1}{\sqrt{|a|}} \int_{-\infty}^{\infty} x(t) \psi^*\left(\frac{t - b}{a}\right) dt

$$

2. **离散小波变换（DWT）**:

离散小波变换通过一系列滤波器实现，通常包括低通滤波器 $ h(n) $ 和高通滤波器 $ g(n) $。

### 示例题目

假设我们有一个简单的一维信号 $ x(t) = [1, 2, 3, 4, 5, 6, 7, 8] $，使用离散小波变换进行分析。

### 详细讲解

1. **选择小波函数**:

   常见的小波函数有Haar小波、Daubechies小波等。在这里，我们选择Haar小波作为例子。

2. **分解步骤**:

   - **第一级分解**: 

     使用低通滤波器和高通滤波器分别对信号进行滤波，并下采样，得到逼近系数和细节系数。

     - 逼近系数 (Approximation Coefficients): $ A_1 = [2.5, 6.5] $

     - 细节系数 (Detail Coefficients): $ D_1 = [-0.5, -0.5, -0.5, -0.5] $

   - **第二级分解**: 

     对第一级的逼近系数再进行一次低通和高通滤波并下采样。

     - 逼近系数 (Approximation Coefficients): $ A_2 = [4.5] $

     - 细节系数 (Detail Coefficients): $ D_2 = [-2] $

### Python代码求解
```python
import pywt
import numpy as np
# 原始信号
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
# 使用Haar小波进行离散小波变换
coeffs = pywt.wavedec(x, 'haar', level=2)
# 分解系数
A2, D2, D1 = coeffs
print("逼近系数 A2:", A2)
print("细节系数 D2:", D2)
print("细节系数 D1:", D1)
```

### 实际生活中的例子

在医学影像处理中，小波变换可以用于图像去噪和特征提取。例如，在处理脑电图（EEG）信号时，小波变换可以帮助提取特定频率成分，以检测异常活动如癫痫发作。与传统的傅里叶变换相比，小波变换能够在时频平面上提供更好的局部化信息，使得信号处理更为精细和准确。

【数学】什么是小波变换？

# 什么是傅里叶变换？什么是离散傅里叶变换？什么是拉普拉斯变换？





### 背景

傅里叶变换、离散傅里叶变换和拉普拉斯变换都是在信号处理和系统分析中非常重要的工具。

- **傅里叶变换（Fourier Transform）** 用于将时间或空间上的信号转换到频率域。通过傅里叶变换，我们可以分析信号的频率成分。

- **离散傅里叶变换（Discrete Fourier Transform, DFT）** 是傅里叶变换在离散信号上的实现。它用于将有限长的序列转换到频率域。

- **拉普拉斯变换（Laplace Transform）** 用于分析线性时不变系统。它将一个时间域的函数转换为复频域的函数，可以解决微分方程和控制系统问题。



### 公式

1. **傅里叶变换**

   连续函数 $f(t)$ 的傅里叶变换 $F(\omega)$ 定义为：

   $$

   F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-i \omega t} \, dt

   $$

   反傅里叶变换为：

   $$

   f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega) e^{i \omega t} \, d\omega

   $$

2. **离散傅里叶变换（DFT）**

   序列 $x[n]$ 的离散傅里叶变换 $X[k]$ 定义为：

   $$

   X[k] = \sum_{n=0}^{N-1} x[n] e^{-i \frac{2\pi}{N} kn}

   $$

   反离散傅里叶变换为：

   $$

   x[n] = \frac{1}{N} \sum_{k=0}^{N-1} X[k] e^{i \frac{2\pi}{N} kn}

   $$

3. **拉普拉斯变换**

   函数 $f(t)$ 的拉普拉斯变换 $F(s)$ 定义为：

   $$

   F(s) = \int_{0}^{\infty} f(t) e^{-st} \, dt

   $$

   其中，$s$ 是复数，可以表示为 $s = \sigma + i\omega$。

### 示例题目

1. **傅里叶变换示例**

   求 $f(t) = e^{-t} u(t)$ 的傅里叶变换，其中 $u(t)$ 是单位阶跃函数。

2. **离散傅里叶变换示例**

   对序列 $x = [1, 2, 3, 4]$ 计算其离散傅里叶变换。

3. **拉普拉斯变换示例**

   求 $f(t) = e^{3t}$ 的拉普拉斯变换。

### 详细讲解

1. **傅里叶变换示例讲解**

   对于 $f(t) = e^{-t} u(t)$，傅里叶变换为：

   $$

   F(\omega) = \int_{0}^{\infty} e^{-t} e^{-i \omega t} \, dt = \int_{0}^{\infty} e^{-(1 + i \omega)t} \, dt

   $$

   这个积分是一个简单的指数积分，可以求得：

   $$

   F(\omega) = \frac{1}{1 + i \omega}

   $$

2. **离散傅里叶变换示例讲解**

   对于序列 $x = [1, 2, 3, 4]$，计算其离散傅里叶变换：

   $$

   X[k] = \sum_{n=0}^{3} x[n] e^{-i \frac{2\pi}{4} kn}

   $$

   具体计算为：

   $$

   X[0] = 1 + 2 + 3 + 4 = 10

   $$

   $$

   X[1] = 1 + 2e^{-i \frac{\pi}{2}} + 3e^{-i \pi} + 4e^{-i \frac{3\pi}{2}} = 1 - 2i - 3 + 4i = -2 + 2i

   $$

   $$

   X[2] = 1 + 2e^{-i \pi} + 3e^{-i 2\pi} + 4e^{-i 3\pi} = 1 - 2 + 3 - 4 = -2

   $$

   $$

   X[3] = 1 + 2e^{-i \frac{3\pi}{2}} + 3e^{-i 3\pi} + 4e^{-i \frac{9\pi}{2}} = 1 + 2i - 3 - 4i = -2 - 2i

   $$

3. **拉普拉斯变换示例讲解**

   对于 $f(t) = e^{3t}$，拉普拉斯变换为：

   $$

   F(s) = \int_{0}^{\infty} e^{3t} e^{-st} \, dt = \int_{0}^{\infty} e^{(3-s)t} \, dt

   $$

   这个积分是一个简单的指数积分，可以求得：

   $$

   F(s) = \frac{1}{s - 3} \quad \text{对于 } \text{Re}(s) > 3

   $$

### Python代码求解

```python
import numpy as np
# 离散傅里叶变换示例代码
x = np.array([1, 2, 3, 4])
X = np.fft.fft(x)
print("DFT of x:", X)
```

### 实际生活中的例子

1. **傅里叶变换**：在音频信号处理中，用于将声音分解成不同的频率分量。比如，用傅里叶变换来分析音乐中的不同音调和音符。

2. **离散傅里叶变换**：在图像处理中，用于图像的压缩和去噪。例如，JPEG图像压缩算法中使用了离散余弦变换（DCT），其原理类似于DFT。

3. **拉普拉斯变换**：在控制系统中，用于分析系统的稳定性和瞬态响应。例如，电路分析中的传递函数和机械系统的振动分析都使用拉普拉斯变换。

这些变换在工程和科学中的广泛应用，使得它们成为信号处理和系统分析中的基础工具。



# 什么是线性时不变系统


线性时不变系统（Linear Time-Invariant System，LTI系统）是控制理论和信号处理中的一个重要概念。它具有两个主要特性：线性性（Linearity）和时不变性（Time-Invariance）。理解这些特性有助于分析和设计许多实际系统。以下是对这两个特性的详细解释：

### 线性性（Linearity）

线性性包括两个方面：

1. **齐次性（Homogeneity）或比例性（Scaling）：**

   对于任意输入信号 $ x(t) $ 和常数 $ a $，系统的响应满足：

   $$

   x(t) \rightarrow y(t) \implies a \cdot x(t) \rightarrow a \cdot y(t)

   $$

2. **可加性（Additivity）或叠加性（Superposition）：**

   对于任意两个输入信号 $ x_1(t) $ 和 $ x_2(t) $，系统的响应满足：

   $$

   x_1(t) \rightarrow y_1(t) \quad \text{和} \quad x_2(t) \rightarrow y_2(t) \implies x_1(t) + x_2(t) \rightarrow y_1(t) + y_2(t)

   $$

如果一个系统同时满足齐次性和可加性，那么它就是线性的。

### 时不变性（Time-Invariance）

时不变性意味着系统的特性不会随时间变化。也就是说，如果一个系统在时刻 $ t $ 的输入 $ x(t) $ 产生输出 $ y(t) $，那么对输入信号的任意时间平移 $ x(t - \tau) $ 产生的输出应为相同时间平移的输出信号 $ y(t - \tau) $：

$$

x(t) \rightarrow y(t) \implies x(t - \tau) \rightarrow y(t - \tau)

$$

### LTI系统的分析方法

LTI系统的两个重要性质使得其分析和处理变得相对简单。以下是一些常用的方法：

1. **脉冲响应（Impulse Response）：**

   LTI系统可以通过其对单位脉冲信号 $ \delta(t) $ 的响应来完全描述。单位脉冲响应 $ h(t) $ 和任意输入 $ x(t) $ 的关系可以通过卷积积分表示：

   $$

   y(t) = (x * h)(t) = \int_{-\infty}^{\infty} x(\tau) h(t - \tau) d\tau

   $$

2. **频率响应（Frequency Response）：**

   LTI系统的频率响应可以通过其脉冲响应的傅里叶变换得到：

   $$

   H(\omega) = \mathcal{F}\{h(t)\}

   $$

   系统的输出信号的频谱是输入信号频谱和系统频率响应的乘积：

   $$

   Y(\omega) = X(\omega) \cdot H(\omega)

   $$

3. **拉普拉斯变换（Laplace Transform）：**

   对于连续时间系统，拉普拉斯变换可以用于求解系统的微分方程。系统的传递函数 $ H(s) $ 是脉冲响应的拉普拉斯变换：

   $$

   H(s) = \mathcal{L}\{h(t)\}

   $$

   输入输出关系可以表示为：

   $$

   Y(s) = H(s) \cdot X(s)

   $$

4. **Z变换（Z-Transform）：**

   对于离散时间系统，Z变换是类似的工具。系统的传递函数 $ H(z) $ 是脉冲响应的Z变换：

   $$

   H(z) = \mathcal{Z}\{h[n]\}

   $$

   输入输出关系可以表示为：

   $$

   Y(z) = H(z) \cdot X(z)

   $$

### 结论

线性时不变系统（LTI系统）通过其线性性和时不变性特性，使得分析和设计变得较为简单。利用脉冲响应、频率响应、拉普拉斯变换和Z变换等工具，可以有效地处理和理解这些系统。

【数学】什么是傅里叶变换？什么是离散傅里叶变换？什么是拉普拉斯变换？

## 傅里叶级数与傅里叶变换





### 背景

傅里叶级数和傅里叶变换是数学和工程领域中的重要工具，特别是在信号处理、图像处理和物理学中。傅里叶级数用于将周期函数表示为正弦和余弦函数的和，而傅里叶变换用于将任意函数表示为频率的函数。

### 公式

- **傅里叶级数**：给定周期函数 $f(t)$，其傅里叶级数表示为：

  $$

  f(t) = a_0 + \sum_{n=1}^{\infty} \left( a_n \cos \left( \frac{2\pi n t}{T} \right) + b_n \sin \left( \frac{2\pi n t}{T} \right) \right)

  $$

  其中：

  $$

  a_0 = \frac{1}{T} \int_{0}^{T} f(t) \, dt

  $$

  $$

  a_n = \frac{2}{T} \int_{0}^{T} f(t) \cos \left( \frac{2\pi n t}{T} \right) \, dt

  $$

  $$

  b_n = \frac{2}{T} \int_{0}^{T} f(t) \sin \left( \frac{2\pi n t}{T} \right) \, dt

  $$

- **傅里叶变换**：给定函数 $f(t)$，其傅里叶变换表示为：

  $$

  \mathcal{F}(f)(\omega) = F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-i\omega t} \, dt

  $$

  其逆变换为：

  $$

  f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega) e^{i\omega t} \, d\omega

  $$

### 示例题目

**题目**：求周期函数 $f(t) = t$ 在区间 $[-\pi, \pi]$ 上的傅里叶级数表示。

### 详细讲解

1. **计算 $a_0$**：

   $$

   a_0 = \frac{1}{2\pi} \int_{-\pi}^{\pi} t \, dt = 0

   $$

2. **计算 $a_n$**：

   $$

   a_n = \frac{1}{\pi} \int_{-{\pi}}^{\pi} t \cos(nt) \, dt = 0

   $$

3. **计算 $b_n$**：

   $$

   b_n = \frac{1}{\pi} \int_{-\pi}^{\pi} t \sin(nt) \, dt = \frac{2(-1)^{n+1}}{n}

   $$

因此，傅里叶级数为：

$$

f(t) = \sum_{n=1}^{\infty} \frac{2(-1)^{n+1}}{n} \sin(nt)

$$

### Python代码求解
```python
import numpy as np
import matplotlib.pyplot as plt
# 定义周期函数
def f(t):
    return t
# 定义傅里叶级数展开的项数
N = 10
# 定义傅里叶级数
def fourier_series(t, N):
    result = np.zeros_like(t)
    for n in range(1, N + 1):
        result += (2 * (-1)**(n + 1) / n) * np.sin(n * t)
    return result
# 生成时间点
t = np.linspace(-np.pi, np.pi, 1000)
# 计算傅里叶级数近似
f_approx = fourier_series(t, N)
# 绘图
plt.plot(t, f(t), label='Original function')
plt.plot(t, f_approx, label='Fourier series approximation')
plt.legend()
plt.xlabel('t')
plt.ylabel('f(t)')
plt.title('Fourier Series Approximation')
plt.grid(True)
plt.show()
```

### 实际生活中的例子

在实际生活中，傅里叶变换用于信号处理，例如将音频信号转换为频谱，以分析不同频率的声音成分。傅里叶级数则在分析周期信号（如振动和电波）时非常有用。通过将复杂的周期信号分解为简单的正弦和余弦分量，可以更容易地理解和处理这些信号。


### 一个python例子

```dart
import numpy as np
import matplotlib.pyplot as plt
# 定义周期函数的频率和系数
T = 2 * np.pi  # 周期
N = 5  # 傅里叶级数的项数
# 定义时间范围
t = np.linspace(-np.pi, np.pi, 1000)
# 定义傅里叶级数的各项
def fourier_series_terms(t, N):
    terms = []
    for n in range(1, N + 1):
        term = (2 * (-1)**(n + 1) / n) * np.sin(n * t)
        terms.append(term)
    return terms
# 计算傅里叶级数的各项
terms = fourier_series_terms(t, N)
# 绘图
plt.figure(figsize=(12, 8))
# 原始函数
plt.subplot(2, 1, 1)
plt.plot(t, t, label='Original function')
plt.title('Original Function')
plt.xlabel('t')
plt.ylabel('f(t)')
plt.legend()
plt.grid(True)
# 各项的和
plt.subplot(2, 1, 2)
sum_terms = np.zeros_like(t)
for i, term in enumerate(terms):
    sum_terms += term
    plt.plot(t, sum_terms, label=f'Term {i+1}')
plt.title('Sum of Fourier Series Terms')
plt.xlabel('t')
plt.ylabel('Sum of terms')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
```

![在这里插入图片描述](/static/img/images/02951.png)

【数学】什么是傅里叶级数与傅里叶变换？

## 隐马尔可夫模型 (HMM)





### 背景

隐马尔可夫模型（Hidden Markov Model, HMM）是一种统计模型，用于描述含有隐含变量的时间序列数据。它在自然语言处理、语音识别、生物信息学等领域有广泛应用。HMM假设系统是一个马尔可夫过程，即未来的状态只依赖于当前状态，而与过去状态无关。此外，HMM有两个层次：观测层次和隐藏层次，观测层次是可以看到的数据，隐藏层次是我们无法直接观察到的状态。

### 公式

HMM主要包括以下几个公式和参数：

1. 初始状态分布：$\pi = \{\pi_i\}$，表示系统初始时刻各状态的概率分布。

2. 状态转移矩阵：$A = \{a_{ij}\}$，表示从状态$i$转移到状态$j$的概率。

3. 观测概率矩阵：$B = \{b_j(k)\}$，表示在状态$j$下观测到符号$k$的概率。

上述参数的定义为：

- $\pi_i = P(Q_1 = S_i)$

- $a_{ij} = P(Q_{t+1} = S_j | Q_t = S_i)$

- $b_j(k) = P(O_t = v_k | Q_t = S_j)$

### 示例题目

假设一个简单的天气模型，有两个隐藏状态（晴天和雨天）和两个观测值（散步和打伞）。我们知道初始状态分布、状态转移矩阵和观测概率矩阵如下：

- 初始状态分布：$\pi = [0.6, 0.4]$

- 状态转移矩阵：

$$

A = \begin{bmatrix}

0.7 & 0.3 \\

0.4 & 0.6

\end{bmatrix}

$$

- 观测概率矩阵：

$$

B = \begin{bmatrix}

0.5 & 0.5 \\

0.1 & 0.9

\end{bmatrix}

$$

观测序列为：散步，打伞，散步，问隐状态序列的概率分布。

### 详细讲解

我们需要使用前向算法计算观测序列的概率。前向算法通过动态规划的方法逐步计算出每个时刻的前向概率。

1. 初始化：

$$

\alpha_1(i) = \pi_i b_i(O_1)

$$

对于本题：

$$

\alpha_1(1) = 0.6 \cdot 0.5 = 0.3

$$

$$

\alpha_1(2) = 0.4 \cdot 0.1 = 0.04

$$

2. 递推：

$$

\alpha_{t+1}(j) = \left[ \sum_{i=1}^{N} \alpha_t(i) a_{ij} \right] b_j(O_{t+1})

$$

对于第二个观测值：

$$

\alpha_2(1) = \left[ \alpha_1(1) \cdot a_{11} + \alpha_1(2) \cdot a_{21} \right] b_1(O_2)

$$

$$

= \left[ 0.3 \cdot 0.7 + 0.04 \cdot 0.4 \right] \cdot 0.5

$$

$$

= 0.107

$$

$$

\alpha_2(2) = \left[ \alpha_1(1) \cdot a_{12} + \alpha_1(2) \cdot a_{22} \right] b_2(O_2)

$$

$$

= \left[ 0.3 \cdot 0.3 + 0.04 \cdot 0.6 \right] \cdot 0.9

$$

$$

= 0.081

$$

3. 终止：

$$

P(O | \lambda) = \sum_{i=1}^{N} \alpha_T(i)

$$

对于第三个观测值：

$$

\alpha_3(1) = \left[ \alpha_2(1) \cdot a_{11} + \alpha_2(2) \cdot a_{21} \right] b_1(O_3)

$$

$$

= \left[ 0.107 \cdot 0.7 + 0.081 \cdot 0.4 \right] \cdot 0.5

$$

$$

= 0.04255

$$

$$

\alpha_3(2) = \left[ \alpha_2(1) \cdot a_{12} + \alpha_2(2) \cdot a_{22} \right] b_2(O_3)

$$

$$

= \left[ 0.107 \cdot 0.3 + 0.081 \cdot 0.6 \right] \cdot 0.1

$$

$$

= 0.00837

$$

最终，观测序列的概率为：

$$

P(O | \lambda) = \alpha_3(1) + \alpha_3(2) = 0.04255 + 0.00837 = 0.05092

$$

### Python代码求解
```python
import numpy as np
# 初始参数
pi = np.array([0.6, 0.4])
A = np.array([[0.7, 0.3],
              [0.4, 0.6]])
B = np.array([[0.5, 0.5],
              [0.1, 0.9]])
O = [0, 1, 0]  # 0表示散步，1表示打伞
# 前向算法
def forward(pi, A, B, O):
    N = len(pi)
    T = len(O)
    alpha = np.zeros((T, N))
    # 初始化
    alpha[0, :] = pi * B[:, O[0]]
    # 递推
    for t in range(1, T):
        for j in range(N):
            alpha[t, j] = np.sum(alpha[t-1, :] * A[:, j]) * B[j, O[t]]
    # 终止
    return np.sum(alpha[-1, :])
# 计算观测序列的概率
prob = forward(pi, A, B, O)
print(f"观测序列的概率为: {prob}")
```

### 实际生活中的例子

隐马尔可夫模型在语音识别中有重要应用。例如，在电话客服系统中，HMM可以用来处理用户的语音输入，识别用户的意图，进而提供相应的服务。假设用户输入了一段语音，系统通过HMM模型对语音进行分析，判断每一段语音对应的文字，再根据文字内容判断用户的需求，例如查询余额、转账等。


## 什么是隐变量

隐含变量（Hidden Variables）在隐马尔可夫模型（HMM）中指的是那些不能直接观察到但对系统行为产生影响的状态。它们是隐藏在观测数据背后的真实状态。

### 背景

在很多实际问题中，我们只能观察到某些现象或数据（观测变量），但这些数据是由一些我们看不到的状态（隐含变量）所决定的。例如，在语音识别中，观测变量是音频信号，而隐含变量是对应的文字或语音的语义。在天气预测中，观测变量是我们每天看到的天气情况（晴天、雨天），而隐含变量可能是更深层的气候模式或气压系统。

### 隐含变量的意义

隐含变量的存在使得问题更加复杂，因为我们需要通过观测数据去推断这些看不见的状态。HMM提供了一种系统化的方法来处理这种问题。通过定义初始状态分布、状态转移矩阵和观测概率矩阵，我们可以描述系统在时间序列上的演变。

### 举例说明

以天气预测为例：

- **隐含变量**：天气状态（晴天、雨天）

- **观测变量**：活动（散步、打伞）

我们无法直接知道今天是晴天还是雨天（隐含变量），但是我们可以看到今天有人散步或者打伞（观测变量）。通过一段时间的观测活动数据，我们可以推断出天气的变化模式（隐含变量的变化）。

### HMM的三个基本问题

1. **评估问题**：给定模型参数和观测序列，计算观测序列的概率。

2. **解码问题**：给定观测序列和模型参数，找到最有可能的隐含状态序列。

3. **学习问题**：给定观测序列，估计模型参数（初始状态分布、状态转移矩阵、观测概率矩阵）。

### 示例

假设我们有以下模型参数：

- 隐含状态：晴天（$S_1$）、雨天（$S_2$）

- 观测状态：散步（$O_1$）、打伞（$O_2$）

- 初始状态分布：$\pi = [0.6, 0.4]$

- 状态转移矩阵：

$$

A = \begin{bmatrix}

0.7 & 0.3 \\

0.4 & 0.6

\end{bmatrix}

$$

- 观测概率矩阵：

$$

B = \begin{bmatrix}

0.5 & 0.5 \\

0.1 & 0.9

\end{bmatrix}

$$

观测序列为：散步，打伞，散步。我们通过前向算法计算该观测序列的概率。

```python
import numpy as np
# 初始参数
pi = np.array([0.6, 0.4])
A = np.array([[0.7, 0.3],
              [0.4, 0.6]])
B = np.array([[0.5, 0.5],
              [0.1, 0.9]])
O = [0, 1, 0]  # 0表示散步，1表示打伞
# 前向算法
def forward(pi, A, B, O):
    N = len(pi)
    T = len(O)
    alpha = np.zeros((T, N))
    # 初始化
    alpha[0, :] = pi * B[:, O[0]]
    # 递推
    for t in range(1, T):
        for j in range(N):
            alpha[t, j] = np.sum(alpha[t-1, :] * A[:, j]) * B[j, O[t]]
    # 终止
    return np.sum(alpha[-1, :])
# 计算观测序列的概率
prob = forward(pi, A, B, O)
print(f"观测序列的概率为: {prob}")
```

实际生活中的例子如语音识别系统和天气预测系统都是通过观察外部现象（观测变量）来推断内部状态（隐含变量），从而进行决策和预测。

【数学】【机器学习】什么是隐马尔可夫模型 (HMM)？

## 马尔可夫链





### 背景

马尔可夫链是描述一个系统在不同状态之间转移的数学模型。它的特点是“无记忆性”，即下一状态只依赖于当前状态，而与之前的状态无关。马尔可夫链在许多领域有广泛应用，如经济学、统计学、计算机科学（尤其是人工智能和机器学习）等。

### 公式

马尔可夫链的主要公式包括状态转移矩阵和初始状态向量：

1. **状态转移矩阵**：$P = [p_{ij}]$，其中 $p_{ij}$ 表示从状态 $i$ 转移到状态 $j$ 的概率。

2. **初始状态向量**：

$$

\pi^{(0)} = [\pi_1^{(0)}, \pi_2^{(0)}, \ldots, \pi_n^{(0)}]，其中 \pi_i^{(0)}

$$

表示系统初始处于状态 $i$ 的概率。

状态转移的公式：

$$

\pi^{(n)} = \pi^{(0)} P^n

$$

### 示例题目

假设有一个简单的天气模型，它只有三种状态：晴天、阴天和雨天。它的状态转移矩阵 $P$ 为：

$$

P = \begin{bmatrix}

0.6 & 0.3 & 0.1 \\

0.2 & 0.7 & 0.1 \\

0.4 & 0.2 & 0.4

\end{bmatrix}

$$

初始状态向量 $ \pi^{(0)} $ 为：

$$

\pi^{(0)} = [0.5, 0.3, 0.2]

$$

请问三天后的状态概率分布是多少？

### 详细讲解

1. 首先，计算第一天的状态概率分布：

$$

\pi^{(1)} = \pi^{(0)} P

$$

$$

= [0.5, 0.3, 0.2] \begin{bmatrix}

0.6 & 0.3 & 0.1 \\

0.2 & 0.7 & 0.1 \\

0.4 & 0.2 & 0.4

\end{bmatrix}

$$

$$

= [0.5 \times 0.6 + 0.3 \times 0.2 + 0.2 \times 0.4, 0.5 \times 0.3 + 0.3 \times 0.7 + 0.2 \times 0.2, 0.5 \times 0.1 + 0.3 \times 0.1 + 0.2 \times 0.4]

$$

$$

= [0.42, 0.36, 0.22]

$$

2. 然后，计算第二天的状态概率分布：

$$

\pi^{(2)} = \pi^{(1)} P

$$

$$

= [0.42, 0.36, 0.22] \begin{bmatrix}

0.6 & 0.3 & 0.1 \\

0.2 & 0.7 & 0.1 \\

0.4 & 0.2 & 0.4

\end{bmatrix}

$$

$$

= [0.42 \times 0.6 + 0.36 \times 0.2 + 0.22 \times 0.4, 0.42 \times 0.3 + 0.36 \times 0.7 + 0.22 \times 0.2, 0.42 \times 0.1 + 0.36 \times 0.1 + 0.22 \times 0.4]

$$

$$

= [0.424, 0.362, 0.214]

$$

3. 最后，计算第三天的状态概率分布：

$$

\pi^{(3)} = \pi^{(2)} P

$$

$$

= [0.424, 0.362, 0.214] \begin{bmatrix}

0.6 & 0.3 & 0.1 \\

0.2 & 0.7 & 0.1 \\

0.4 & 0.2 & 0.4

\end{bmatrix}

$$

$$

= [0.424 \times 0.6 + 0.362 \times 0.2 + 0.214 \times 0.4, 0.424 \times 0.3 + 0.362 \times 0.7 + 0.214 \times 0.2, 0.424 \times 0.1 + 0.362 \times 0.1 + 0.214 \times 0.4]

$$

$$

= [0.4196, 0.3696, 0.2108]

$$

### Python代码求解

```python
import numpy as np
# 状态转移矩阵
P = np.array([
    [0.6, 0.3, 0.1],
    [0.2, 0.7, 0.1],
    [0.4, 0.2, 0.4]
])
# 初始状态向量
pi_0 = np.array([0.5, 0.3, 0.2])
# 计算三天后的状态概率分布
pi_3 = pi_0 @ np.linalg.matrix_power(P, 3)
print(pi_3)
```

### 实际生活中的例子

马尔可夫链在金融市场中有广泛应用。例如，股票价格可以被看作是一个马尔可夫过程，股票的未来价格仅依赖于当前价格，而不依赖于过去的价格变化。通过构建马尔可夫链模型，投资者可以预测股票价格的变化趋势，制定相应的投资策略。此外，在自然语言处理领域，马尔可夫链被用于语言建模和文本生成，例如用于预测一个单词序列中的下一个单词。



## RNN 与马尔可夫链的联系

递归神经网络（RNN）是一种深度学习模型，用于处理序列数据。与马尔可夫链不同，RNN 具有记忆能力，可以通过隐状态（hidden state）存储之前时刻的信息。这使得 RNN 能够捕捉序列中的长期依赖关系。

具体来说，在 RNN 中，每个时间步 $ t $ 的隐状态 $ h_t $ 是由当前输入 $ x_t $ 和前一时间步的隐状态 $ h_{t-1} $ 决定的：

$$

h_t = f(h_{t-1}, x_t)

$$

其中 $ f $ 是一个非线性激活函数（如 tanh 或 ReLU）。

从这个公式可以看出，RNN 的状态不仅依赖于当前输入，还依赖于之前所有时间步的隐状态。因此，RNN 能够捕捉序列中的长期依赖关系，而不仅仅是当前状态的信息。

### 对比总结

- **马尔可夫链**：下一状态仅依赖于当前状态，与之前的状态无关。适合建模具有无记忆性的随机过程。

- **RNN**：下一状态依赖于当前输入和之前所有时间步的隐状态。适合建模具有长期依赖关系的序列数据。

### 图示解释

1. **马尔可夫链**：

```
s0 → s1 → s2 → ... → st
```

每个状态只依赖于前一个状态。

2. **RNN**：

```
x0 → x1 → x2 → ... → xt
  ↓   ↓   ↓        ↓
h0 → h1 → h2 → ... → ht
```

每个隐状态 $ h_t $ 依赖于前一个隐状态 $ h_{t-1} $ 和当前输入 $ x_t $。

这说明 RNN 可以记住更长的历史信息，适用于需要考虑上下文的任务，比如自然语言处理、时间序列预测等。

## 马尔可夫链与条件随机场的比较

### 条件随机场 (Conditional Random Field, CRF)

条件随机场是一种用于标注和分割序列数据的概率图模型。它通过定义在观测数据条件下的一组随机变量之间的条件概率分布来进行建模。CRF 在自然语言处理（NLP）和计算机视觉等领域中被广泛应用，尤其适用于序列标注任务。

### 马尔可夫链与 CRF 的联系

马尔可夫链是描述状态序列中的转移概率的模型，而 CRF 则是在给定观测序列条件下建模状态序列的概率分布。两者的联系在于它们都基于图模型，并且可以用于序列数据的建模。然而，它们在建模方式和应用场景上有所不同。

#### 马尔可夫链

马尔可夫链假设当前状态只依赖于前一个状态，即马尔可夫性质。通常使用转移概率矩阵来描述状态转移。

#### 隐马尔可夫模型 (HMM)

隐马尔可夫模型（Hidden Markov Model, HMM）是在马尔可夫链基础上扩展的模型，用于处理观测数据和隐藏状态之间的关系。HMM 假设观测序列是由隐藏状态序列生成的，每个隐藏状态生成一个观测数据。

#### 条件随机场 (CRF)

CRF 是一种判别式模型，它直接建模观测序列条件下的状态序列的概率分布，而不需要显式建模观测数据的生成过程。CRF 通过定义全局特征函数来捕捉观测数据和状态序列之间的依赖关系。

### 举例说明

假设我们有一个命名实体识别（NER）任务，需要从文本序列中识别出实体（如人名、地名等）。

#### 使用 HMM 的方法

1. **状态**：每个单词的标签，如 B-PER（人名的开始）、I-PER（人名的内部）、O（非实体）。

2. **观测**：文本中的单词。

3. **模型**：通过观察单词的特征（如单词本身、词性等）来预测隐藏状态（标签）。

HMM 模型会基于观测数据生成隐藏状态序列，假设观测数据是由隐藏状态生成的。

#### 使用 CRF 的方法

1. **状态**：每个单词的标签。

2. **观测**：文本中的单词及其特征（如词性、词形、上下文等）。

3. **模型**：直接建模在给定观测序列条件下的状态序列的概率分布。

CRF 通过定义特征函数来捕捉观测数据和标签之间的依赖关系，以及标签之间的相互依赖关系。例如，CRF 可以定义特征函数来表示“如果一个单词以大写字母开头并且出现在句子开头，那么它很可能是一个人名的开始”。

### 图示解释

1. **隐马尔可夫模型 (HMM)**：
```
观测序列:  o1  o2  o3  o4
             ↓   ↓   ↓   ↓
隐藏状态:  s1 → s2 → s3 → s4
```

2. **条件随机场 (CRF)**：
```
观测序列:  o1  o2  o3  o4
              ↓   ↓   ↓   ↓
标签序列:  y1 → y2 → y3 → y4
```

CRF 的特征函数可以捕捉：

- 观测数据 $ o $ 和标签 $ y $ 之间的依赖关系。

- 标签 $ y $ 之间的相互依赖关系。

### 总结

- **马尔可夫链**：用于建模状态序列的转移概率。

- **隐马尔可夫模型 (HMM)**：在马尔可夫链基础上增加了观测数据和隐藏状态之间的关系。

- **条件随机场 (CRF)**：直接建模观测数据条件下的状态序列概率分布，适合序列标注任务。

CRF 比 HMM 更加灵活，因为它不需要假设观测数据是由隐藏状态生成的，并且可以使用丰富的特征来捕捉数据和标签之间的复杂关系。

【数学】什么是马尔可夫链？RNN 与马尔可夫链的联系，马尔可夫链与条件随机场的比较

### 背景





方法矩估计（Method of Moments Estimation）和最大似然估计（Maximum Likelihood Estimation, MLE）是两种常用的参数估计方法。方法矩估计基于样本矩与总体矩的关系，通过样本数据计算样本矩来估计总体参数。最大似然估计基于最大化样本数据的联合概率密度函数，通过寻找参数值使得样本数据出现的概率最大来估计参数。

### 公式

#### 方法矩估计

方法矩估计基于以下公式：

- 样本矩：$M_k = \frac{1}{n} \sum_{i=1}^{n} X_i^k$

- 总体矩：$E(X^k) = \mu_k$

通过设定样本矩等于总体矩，可以解出参数估计值。

#### 最大似然估计

最大似然估计基于以下公式：

- 似然函数：$L(\theta) = \prod_{i=1}^{n} f(X_i; \theta)$

- 对数似然函数：$\ln L(\theta) = \sum_{i=1}^{n} \ln f(X_i; \theta)$

通过最大化对数似然函数来求解参数估计值。

### 示例题目

#### 示例 1：正态分布参数估计

假设样本数据来自一个均值为$\mu$，方差为$\sigma^2$的正态分布$N(\mu, \sigma^2)$，我们要估计$\mu$和$\sigma^2$。

### 详细讲解

#### 方法矩估计

1. 样本矩计算：

   - 一阶样本矩：$M_1 = \frac{1}{n} \sum_{i=1}^{n} X_i$

   - 二阶样本矩：$M_2 = \frac{1}{n} \sum_{i=1}^{n} X_i^2$

   

2. 总体矩关系：

   - 一阶总体矩：$E(X) = \mu$

   - 二阶总体矩：$E(X^2) = \mu^2 + \sigma^2$

   

3. 通过样本矩等于总体矩，得到：

   $$

   \hat{\mu} = M_1 = \frac{1}{n} \sum_{i=1}^{n} X_i

   $$

   $$

   \hat{\sigma}^2 = M_2 - \hat{\mu}^2

   $$

#### 最大似然估计

1. 似然函数：

   $$

   L(\mu, \sigma^2) = \prod_{i=1}^{n} \frac{1}{\sqrt{2\pi\sigma^2}} \exp\left( -\frac{(X_i - \mu)^2}{2\sigma^2} \right)

   $$

   

2. 对数似然函数：

   $$

   \ln L(\mu, \sigma^2) = -\frac{n}{2} \ln(2\pi\sigma^2) - \frac{1}{2\sigma^2} \sum_{i=1}^{n} (X_i - \mu)^2

   $$

3. 对$\mu$和$\sigma^2$求导并设为0，解得：

   $$

   \hat{\mu} = \frac{1}{n} \sum_{i=1}^{n} X_i

   $$

   $$

   \hat{\sigma}^2 = \frac{1}{n} \sum_{i=1}^{n} (X_i - \hat{\mu})^2

   $$

### Python代码求解
```python
import numpy as np
# 生成样本数据
np.random.seed(0)
data = np.random.normal(loc=5, scale=2, size=100)
# 方法矩估计
mu_mom = np.mean(data)
sigma2_mom = np.mean(data**2) - mu_mom**2
# 最大似然估计
mu_mle = np.mean(data)
sigma2_mle = np.var(data, ddof=0)
print("方法矩估计：")
print(f"mu = {mu_mom}, sigma^2 = {sigma2_mom}")
print("最大似然估计：")
print(f"mu = {mu_mle}, sigma^2 = {sigma2_mle}")
```

### 实际生活中的例子

在金融领域中，投资组合的收益通常被假设为正态分布。为了估计未来收益的均值和波动率，金融分析师可以使用历史收益数据来进行参数估计。通过方法矩估计或最大似然估计，可以得出投资组合的均值收益和方差，从而指导投资决策。

### 方法矩估计与最大似然估计的关系与优缺点

两种方法各有优缺点：

- **方法矩估计**通常计算简单，易于理解，但在有限样本量下估计量的效率较低。

- **最大似然估计**在大样本量下具有一致性和渐近正态性，估计量更有效，但计算复杂，尤其是对于复杂模型。

选择哪种方法更好取决于具体问题和数据特点。一般情况下，最大似然估计更受欢迎，因为它在大样本下具有良好的统计性质。

【数学】什么是方法矩估计？和最大似然估计是什么关系？

### 背景





最小二乘法（Least Squares Method）是一种用于找到数据点最佳拟合曲线的数学优化技术。它通过最小化数据点和拟合曲线之间的误差平方和来实现。广泛应用于统计学、数据分析和机器学习中。

### 公式

最小二乘法的基本公式如下：

1. 线性回归模型：

   $$

   \hat{y} = \beta_0 + \beta_1 x

   $$

2. 误差平方和（SSE）：

   $$

   SSE = \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 = \sum_{i=1}^{n} (y_i - (\beta_0 + \beta_1 x_i))^2

   $$

3. 通过求解最小化误差平方和，得出最佳拟合参数：

   $$

   \beta_1 = \frac{n \sum (x_i y_i) - \sum x_i \sum y_i}{n \sum x_i^2 - (\sum x_i)^2}

   $$

   $$

   \beta_0 = \frac{\sum y_i - \beta_1 \sum x_i}{n}

   $$

### 示例题目

假设我们有以下数据点：$(1, 2)$、$(2, 3)$、$(3, 5)$、$(4, 4)$、$(5, 6)$。求最佳拟合直线。

### 详细讲解

1. 计算必要的求和：

   $$

   \sum x_i = 1 + 2 + 3 + 4 + 5 = 15

   $$

   $$

   \sum y_i = 2 + 3 + 5 + 4 + 6 = 20

   $$

   $$

   \sum x_i^2 = 1^2 + 2^2 + 3^2 + 4^2 + 5^2 = 55

   $$

   $$

   \sum x_i y_i = 1 \cdot 2 + 2 \cdot 3 + 3 \cdot 5 + 4 \cdot 4 + 5 \cdot 6 = 70

   $$

2. 计算斜率 $\beta_1$：

   $$

   \beta_1 = \frac{5 \cdot 70 - 15 \cdot 20}{5 \cdot 55 - 15^2} = \frac{350 - 300}{275 - 225} = \frac{50}{50} = 1

   $$

3. 计算截距 $\beta_0$：

   $$

   \beta_0 = \frac{20 - 1 \cdot 15}{5} = \frac{5}{5} = 1

   $$

4. 最佳拟合直线方程为：

   $$

   \hat{y} = 1 + 1x = x + 1

   $$

### Python代码求解

```python
import numpy as np
import matplotlib.pyplot as plt
# 数据点
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 3, 5, 4, 6])
# 最小二乘法计算
A = np.vstack([x, np.ones(len(x))]).T
beta, beta_0 = np.linalg.lstsq(A, y, rcond=None)[0]
# 绘图
plt.plot(x, y, 'o', label='原始数据', markersize=10)
plt.plot(x, beta * x + beta_0, 'r', label='拟合直线')
plt.legend()
plt.show()
```

### 实际生活中的例子

在经济学中，最小二乘法可以用来预测消费支出与收入之间的关系。例如，根据历史数据，使用最小二乘法可以拟合出消费支出与收入的关系直线，从而预测未来的消费行为。

【数学】什么是最小二乘法？如何求解最小二乘法？

### 背景





最大似然估计（Maximum Likelihood Estimation, MLE）是一种估计统计模型参数的方法。它在众多统计学领域中被广泛使用，比如回归分析、时间序列分析、机器学习和经济学。其核心思想是：给定一个观测数据集，找到一组参数，使得在这些参数下观测到当前数据的可能性（似然）最大。

### 公式

假设我们有一个参数为 $\theta$ 的概率分布，观测数据为 $X = (x_1, x_2, \ldots, x_n)$，则似然函数（Likelihood Function）可以表示为：

$$

L(\theta; X) = P(X|\theta) = \prod_{i=1}^n P(x_i|\theta)

$$

为了简化计算，我们通常使用对数似然函数（Log-Likelihood Function）：

$$

\ell(\theta; X) = \log L(\theta; X) = \sum_{i=1}^n \log P(x_i|\theta)

$$

最大似然估计的目标是找到参数 $\theta$，使得对数似然函数 $\ell(\theta; X)$ 达到最大值。即：

$$

\hat{\theta} = \arg \max_\theta \ell(\theta; X)

$$

### 示例题目

正态分布的概率密度函数（PDF）可以表示为：

$$

f(x|\mu, \sigma^2) = \frac{1}{\sqrt{2\pi\sigma^2}} \exp\left(-\frac{(x - \mu)^2}{2\sigma^2}\right)

$$

假设我们有一组观测数据 $X = (x_1, x_2, \ldots, x_n)$，这些数据都来自于一个正态分布 $N(\mu, \sigma^2)$。我们希望估计正态分布的参数 $\mu$ 和 $\sigma^2$。

观测数据为 $X = (x_1, x_2, \ldots, x_n)$。

### 详细讲解

1. **写出似然函数**：根据正态分布的概率密度函数，似然函数可以写为：

似然函数 $L(\mu, \sigma^2; X)$ 是在给定参数 $\mu$ 和 $\sigma^2$ 下，观测数据 $X$ 出现的概率。对于独立同分布的数据，这个概率是每个数据点概率密度的乘积，即：

$$

L(\mu, \sigma^2; X) = \prod_{i=1}^n f(x_i|\mu, \sigma^2)

$$

 将正态分布的概率密度函数代入似然函数中，得到：

 $$

 L(\mu, \sigma^2; X) = \prod_{i=1}^n \frac{1}{\sqrt{2\pi\sigma^2}} \exp\left(-\frac{(x_i - \mu)^2}{2\sigma^2}\right)

 $$

### 对数似然函数

3. **取对数**：为了简化计算，取对数得到对数似然函数：

   $$

   \ell(\mu, \sigma^2; X) = \sum_{i=1}^n \log \left( \frac{1}{\sqrt{2\pi\sigma^2}} \exp\left(-\frac{(x_i - \mu)^2}{2\sigma^2}\right) \right)

   $$

   进一步简化：

   $$

   \ell(\mu, \sigma^2; X) = -\frac{n}{2} \log(2\pi\sigma^2) - \frac{1}{2\sigma^2} \sum_{i=1}^n (x_i - \mu)^2

   $$

4. **求导并解方程**：对 $\mu$ 和 $\sigma^2$ 分别求导并令其等于零，可以得到参数的估计值。

   对 $\mu$ 求导：

   $$

   \frac{\partial \ell}{\partial \mu} = \frac{1}{\sigma^2} \sum_{i=1}^n (x_i - \mu) = 0

   $$

   解得：

   $$

   \hat{\mu} = \frac{1}{n} \sum_{i=1}^n x_i

   $$

   对 $\sigma^2$ 求导：

   $$ 

   \frac{\partial \ell}{\partial \sigma^2} = -\frac{n}{2\sigma^2} + \frac{1}{2\sigma^4} \sum_{i=1}^n (x_i - \mu)^2 = 0

   $$

   解得：

   $$

   \hat{\sigma}^2 = \frac{1}{n} \sum_{i=1}^n (x_i - \mu)^2

   $$

### Python代码求解

```python
import numpy as np
# 观测数据
X = np.array([2.3, 1.9, 3.1, 2.8, 2.4])
# 估计参数
mu_hat = np.mean(X)
sigma_squared_hat = np.var(X, ddof=0)
print("估计的均值 μ:", mu_hat)
print("估计的方差 σ^2:", sigma_squared_hat)
```

### 实际生活中的例子

最大似然估计在实际生活中的应用广泛。例如，在医学研究中，科学家常常需要估计某种疾病的发病率。假设有一个新的传染病，研究人员需要估计其传播率（即，传染给某人的概率）。他们收集了若干病例数据，通过最大似然估计，可以得到传播率的最优估计，从而帮助制定防控策略。

最大似然估计同样可以应用于金融领域，比如估计股票的收益率和风险；在机器学习中，用于训练模型的参数，如线性回归中的回归系数等。

【数学】什么是最大似然估计？如何求解最大似然估计

## 如何求解矩阵的特征向量





### 背景

特征向量和特征值是线性代数中的重要概念，广泛应用于物理学、计算机科学（如机器学习、图像处理）和统计学等领域。特征向量描述了线性变换中不改变方向的向量，而特征值描述了这些向量被拉伸或压缩的程度。

### 公式

求解矩阵的特征向量需要用到特征值方程：

$$

A \mathbf{v} = \lambda \mathbf{v}

$$

其中，$A$ 是矩阵，$\mathbf{v}$ 是特征向量，$\lambda$ 是特征值。

特征值可以通过解以下特征多项式来找到：

$$

\det(A - \lambda I) = 0

$$

其中，$\det$ 表示行列式，$I$ 是单位矩阵。

### 示例题目

求解矩阵

$$

A = \begin{pmatrix}

4 & 1 \\

2 & 3

\end{pmatrix}

$$

的特征向量和特征值。

### 详细讲解

1. **计算特征多项式**：

   计算 $\det(A - \lambda I)$：

   $$

   A - \lambda I = \begin{pmatrix}

   4 & 1 \\

   2 & 3

   \end{pmatrix} - \lambda \begin{pmatrix}

   1 & 0 \\

   0 & 1

   \end{pmatrix} = \begin{pmatrix}

   4 - \lambda & 1 \\

   2 & 3 - \lambda

   \end{pmatrix}

   $$

   计算行列式：

   $$

   \det(A - \lambda I) = (4 - \lambda)(3 - \lambda) - 2 \cdot 1 = \lambda^2 - 7\lambda + 10

   $$

   解特征方程：

   $$

   \lambda^2 - 7\lambda + 10 = 0

   $$

   解得：

   $$

   \lambda_1 = 2, \quad \lambda_2 = 5

   $$

2. **求特征向量**：

   对 $\lambda_1 = 2$，解 $A\mathbf{v} = 2\mathbf{v}$：

   $$

   \begin{pmatrix}

   4 & 1 \\

   2 & 3

   \end{pmatrix} \begin{pmatrix}

   x \\

   y

   \end{pmatrix} = 2 \begin{pmatrix}

   x \\

   y

   \end{pmatrix}

   $$

   得：

   $$

   \begin{cases}

   4x + y = 2x \\

   2x + 3y = 2y

   \end{cases}

   $$

   化简得：

   $$

   \begin{cases}

   2x + y = 0 \\

   2x + y = 0

   \end{cases}

   $$

   取 $x = 1$，则 $y = -2$，即特征向量为 $\mathbf{v_1} = \begin{pmatrix}

   1 \\

   -2

   \end{pmatrix}$。

   对 $\lambda_2 = 5$，解 $A\mathbf{v} = 5\mathbf{v}$：

   $$

   \begin{pmatrix}

   4 & 1 \\

   2 & 3

   \end{pmatrix} \begin{pmatrix}

   x \\

   y

   \end{pmatrix} = 5 \begin{pmatrix}

   x \\

   y

   \end{pmatrix}

   $$

   得：

   $$

   \begin{cases}

   4x + y = 5x \\

   2x + 3y = 5y

   \end{cases}

   $$

   化简得：

   $$

   \begin{cases}

   -x + y = 0 \\

   2x - 2y = 0

   \end{cases}

   $$

   取 $x = 1$，则 $y = 1$，即特征向量为 $\mathbf{v_2} = \begin{pmatrix}

   1 \\

   1

   \end{pmatrix}$。

### Python代码求解
```python
import numpy as np
# 定义矩阵
A = np.array([[4, 1], [2, 3]])
# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
print("特征值:", eigenvalues)
print("特征向量:")
print(eigenvectors)
```

### 实际生活中的例子

在图像处理领域，特征向量用于主成分分析（PCA），可以帮助降维和提取重要特征。例如，在面部识别系统中，PCA可以用于从高维的图像数据中提取主要特征向量，这些特征向量代表了图像的主要变化方向，从而减少计算复杂度并提高识别效率。




### 本质解释

特征值和特征向量的本质可以通过以下几个方面来理解：

1. **线性变换的固有方向：**

   特征向量表示矩阵 $A$ 作用下保持方向不变的向量，即 $A$ 对特征向量 $\mathbf{v}$ 的作用只是将其拉伸或缩短，缩放的倍数即为特征值 $\lambda$。因此，特征向量可以看作是矩阵 $A$ 作用下的“固有方向”。

2. **矩阵的几何解释：**

   在二维或三维空间中，特征向量指向的是矩阵变换的主要方向，而特征值则描述了矩阵在这些方向上拉伸或缩短的程度。例如，一个二维矩阵 $A$ 可能会将一个特征向量方向上的所有点拉伸（特征值大于1）或缩短（特征值小于1）。

3. **系统的稳定性：**

   在动力系统中，特征值可以用来判断系统的稳定性。如果特征值的绝对值都小于1，那么系统是稳定的；如果特征值的绝对值大于1，那么系统是不稳定的。


1. **求特征值和特征向量：**

   （见上一个示例题目的详细讲解部分）

2. **解释特征值和特征向量的意义：**

   对于矩阵 $A$，特征值 $\lambda_1 = 5$ 和 $\lambda_2 = 2$ 分别表示在特征向量 $\mathbf{v}_1 = \begin{bmatrix} 1 \\ 1 \end{bmatrix}$ 和 $\mathbf{v}_2 = \begin{bmatrix} 1 \\ -1 \end{bmatrix}$ 方向上，矩阵 $A$ 作用下的缩放倍数。换句话说，沿着方向 $\mathbf{v}_1$，矩阵 $A$ 将向量拉伸了5倍；而沿着方向 $\mathbf{v}_2$，矩阵 $A$ 将向量拉伸了2倍。

1. **图像压缩：**

   在图像处理技术中，特征值分解用于压缩图像。通过主成分分析（PCA），我们可以将图像数据投影到少数几个主要方向上，这些方向对应于最大的特征值，从而实现降维和压缩。

2. **振动分析：**

   在机械工程中，特征值和特征向量用于分析结构的振动模式。特征值表示系统的固有频率，而特征向量表示对应频率下的振动模式。通过分析这些特征，我们可以设计出更加稳定和安全的机械结构。

3. **金融风险分析：**

   在金融领域，特征值用于分析资产的风险。通过对资产协方差矩阵进行特征值分解，投资者可以识别出市场中的主要风险因素，并据此进行投资组合的优化。

【数学】如何求解矩阵的特征值和特征向量

# 协方差





协方差（Covariance）是统计学中用来衡量两个随机变量之间关系的一种度量。它反映了这两个变量的变化趋势是否一致，即当一个变量偏离其均值时，另一个变量是否也倾向于偏离其均值。协方差可以帮助我们了解变量之间的线性关系以及它们的相互变化情况。

具体而言，对于两个随机变量 X 和 Y，它们的协方差记作 Cov(X, Y)，计算公式如下：

Cov(X, Y) = Σ [(Xᵢ - μₓ) * (Yᵢ - μᵧ)] / (n - 1)

其中：

- Xᵢ 和 Yᵢ 分别表示两个变量在第 i 个观测点的取值。

- μₓ 和 μᵧ 分别表示 X 和 Y 的均值。

- n 表示观测点的数量。

协方差的值有以下几种情况：

- 若协方差为正值，说明两个变量倾向于一起增加或减少，表现出正相关关系。

- 若协方差为负值，说明一个变量增加时另一个变量倾向于减少，表现出负相关关系。

- 若协方差接近于零，说明两个变量之间关系较弱，可能不存在明显的线性关系。

然而，协方差的数值大小受到变量单位的影响，不易直接比较不同数据集之间的关系。因此，人们通常使用标准化后的协方差，即相关系数（Correlation Coefficient），来更好地度量变量之间的关联程度。相关系数范围在 -1 到 1 之间，能够消除单位的影响，更直观地反映变量之间的线性关系程度。

# 相关系数

相关系数（Correlation Coefficient）是用来衡量两个随机变量之间线性关系强度的统计指标。它反映了两个变量的变化趋势是否在某种程度上是一致的，即当一个变量发生变化时，另一个变量是否倾向于以一定的方式随之变化。相关系数的取值范围在 -1 到 1 之间，不受变量单位的影响，能够更清晰地描述变量之间的关系。

常见的相关系数有皮尔逊相关系数（Pearson Correlation Coefficient）和斯皮尔曼等级相关系数（Spearman Rank Correlation Coefficient）等。

1. 皮尔逊相关系数：

皮尔逊相关系数衡量的是两个变量之间的线性关系程度。它的计算公式如下：

ρ(X, Y) = Cov(X, Y) / (σₓ * σᵧ)

其中：

- Cov(X, Y) 是变量 X 和 Y 的协方差。

- σₓ 和 σᵧ 分别是变量 X 和 Y 的标准差。

皮尔逊相关系数的取值范围在 -1 到 1 之间：

- 当相关系数接近 1 时，表明两个变量呈现强正相关关系，即一个变量增加时另一个变量也倾向于增加。

- 当相关系数接近 -1 时，表明两个变量呈现强负相关关系，即一个变量增加时另一个变量倾向于减少。

- 当相关系数接近 0 时，表明两个变量之间关系较弱，可能没有线性关系。

2. 斯皮尔曼等级相关系数：

斯皮尔曼等级相关系数适用于在数据集中存在非线性关系或异常值时。它首先将变量的观测值转化为等级，然后计算等级之间的皮尔逊相关系数。这种方法对于不满足正态分布假设的数据集更具鲁棒性。

总之，相关系数可以帮助我们判断两个变量之间的关系强度和方向，从而更好地理解数据的特性和变化趋势。

# Python

下面是Python代码：

```python
import numpy as np
import matplotlib.pyplot as plt
# 示例数据：学习时间（小时）和考试成绩
study_time = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
exam_scores = np.array([60, 65, 70, 75, 80, 85, 88, 92, 95, 98])
# 计算皮尔逊相关系数
correlation_coefficient = np.corrcoef(study_time, exam_scores)[0, 1]
# 计算斯皮尔曼等级相关系数
spearman_corr = np.corrcoef(study_time, exam_scores)[0, 1]
# 计算协方差
covariance = np.cov(study_time, exam_scores)[0, 1]
print(f"Covariance between X and Y: {covariance:.2f}")
# 绘制散点图
plt.scatter(study_time, exam_scores, color='blue', label='Data Points')
plt.title(
    f"Pearson Correlation Coefficient: {correlation_coefficient:.2f}\n"
    f"Spearman Rank Correlation Coefficient: {spearman_corr:.2f}\n"
    f"Covariance: {covariance:.2f}")
plt.xlabel('Study Time (hours)')
plt.ylabel('Exam Scores')
plt.legend()
plt.grid(True)
plt.show()
```

可见：

![在这里插入图片描述](/static/img/images/04063.png)

【数学】协方差介绍、相关系数介绍，Python代码

# 纯python





![在这里插入图片描述](/static/img/images/04097.png)


以下是一个简单的Python示例，演示了如何使用NumPy库实现一个一维卡尔曼滤波器。

```python
import numpy as np
import matplotlib.pyplot as plt
def kalman_filter(initial_state, initial_estimate_error, process_variance, measurement_variance, measurements):
    num_measurements = len(measurements)
    state_estimate = initial_state
    estimate_error = initial_estimate_error
    filtered_state_estimates = []
    for i in range(num_measurements):
        # Prediction step
        predicted_state = state_estimate
        predicted_estimate_error = estimate_error + process_variance
        # Update step
        kalman_gain = predicted_estimate_error / (predicted_estimate_error + measurement_variance)
        state_estimate = predicted_state + kalman_gain * (measurements[i] - predicted_state)
        estimate_error = (1 - kalman_gain) * predicted_estimate_error
        filtered_state_estimates.append(state_estimate)
    return filtered_state_estimates
# Generate some noisy measurements
np.random.seed(0)
true_values = np.linspace(0, 10, num=50)
measurements = true_values + np.random.normal(0, 0.5, size=len(true_values))
# Kalman filter parameters
initial_state = measurements[0]
initial_estimate_error = 1
process_variance = 0.1
measurement_variance = 0.5
# Apply Kalman filter
filtered_estimates = kalman_filter(initial_state, initial_estimate_error, process_variance, measurement_variance, measurements)
# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(true_values, label='True Values', linestyle='dashed')
plt.plot(measurements, label='Noisy Measurements', marker='o', markersize=5)
plt.plot(filtered_estimates, label='Filtered Estimates', linestyle='dotted')
plt.legend()
plt.xlabel('Time Step')
plt.ylabel('Value')
plt.title('Kalman Filter Example')
plt.show()
```

卡尔曼滤波参数的含义如下：

1. `initial_state`: 初始状态估计值，通常设置为第一个测量值。在卡尔曼滤波开始时，您的系统的初始状态估计值。

2. `initial_estimate_error`: 初始状态估计误差，表示初始状态估计值的不确定性。通常设置为一个较大的值，以表示初始状态的不确定性。

3. `process_variance`: 过程方差，表示系统模型中状态转移的噪声或不确定性。较大的值表示系统模型中的不确定性较大。

4. `measurement_variance`: 测量方差，表示传感器测量的噪声或不确定性。较大的值表示测量值的不确定性较大。

在卡尔曼滤波中，这些参数的调整会影响滤波器的性能。例如，如果您预计系统模型比传感器测量更可靠，则可以适当减小`measurement_variance`。如果初始状态估计值的不确定性较大，您可以增加`initial_estimate_error`。调整这些参数可能需要一些试验和经验。

![在这里插入图片描述](/static/img/images/04098.png)

![在这里插入图片描述](/static/img/images/04099.png)





# 基于pykalman 库
```go
import numpy as np
import matplotlib.pyplot as plt
from pykalman import KalmanFilter
# Generate some noisy measurements
np.random.seed(0)
true_values = np.linspace(0, 10, num=50)
measurements = true_values + np.random.normal(0, 0.5, size=len(true_values))
# Create a Kalman Filter object
kf = KalmanFilter(initial_state_mean=measurements[0], n_dim_obs=1)
# Apply Kalman filter
filtered_state_means, _ = kf.filter(measurements)
# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(true_values, label='True Values', linestyle='dashed')
plt.plot(measurements, label='Noisy Measurements', marker='o', markersize=5)
plt.plot(filtered_state_means, label='Filtered Estimates', linestyle='dotted')
plt.legend()
plt.xlabel('Time Step')
plt.ylabel('Value')
plt.title('Kalman Filter Example using pykalman')
plt.show()
```

【卡尔曼滤波】用Python实现卡尔曼滤波效果，Python

# 小波变换





小波变换（Wavelet Transform）是一种数学信号处理技术，用于将信号或图像分解为不同频率的小波成分，从而可以在不同时间尺度上分析信号的特征。小波变换具有许多重要的特性，使其在许多领域中有广泛的应用。

小波变换的意义包括以下几个方面：

1. 多尺度分析：小波变换可以在不同的时间尺度上分析信号，这意味着它可以同时提供关于信号的短时和长时特征信息。这使得小波变换在时频域分析中具有优势，特别是对于非平稳信号的处理。

2. 局部特征提取：小波变换是一种局部分析方法，它可以有效地捕获信号的局部特征，如突变、边缘等。相比之下，傅里叶变换是一种全局分析方法，往往无法提供局部特征信息。

3. 压缩和去噪：小波变换可以将信号分解为多个小波系数，其中包含不同频率的信息。通过适当选择小波系数，可以实现信号的压缩和去噪，去除噪声和冗余信息，从而提高信号处理的效果。

4. 图像处理：小波变换在图像处理中也有重要的应用。它可以用于图像压缩、边缘检测、纹理分析等任务，同时保持图像的局部特征和结构信息。

5. 特征提取：小波变换可以用于特征提取，从信号或图像中提取有用的特征信息，用于分类、识别和模式匹配等任务。

6. 数据分析：小波变换在数据分析中有广泛的应用，包括金融市场分析、生物医学信号处理、地震信号处理等领域。

小波变换是一种强大的数学工具，可以用于多尺度分析、特征提取、信号压缩和去噪等多个领域。它的应用涵盖了信号处理、图像处理、数据分析和模式识别等广泛领域，为我们理解信号的时频特性、提取重要特征和优化数据处理提供了重要手段。


小波变换（Wavelet Transform）可以用数学公式表示为以下形式：

给定一个连续函数或离散信号 $f(t)$，小波变换是通过将原始信号与一组小波基函数进行内积运算得到的。这些小波基函数是原始信号在不同频率和时间尺度上的缩放和平移版本。

连续小波变换（Continuous Wavelet Transform，CWT）的数学公式为：

$$

CWT(a, b) = \int_{-\infty}^{\infty} f(t) \psi^* \left( \frac{t-b}{a} \right) dt

$$

其中，$CWT(a, b)$ 是连续小波变换的结果，$a$ 和 $b$ 是小波基函数的缩放因子和平移因子，$\psi^*(t)$ 是复共轭小波基函数。

复共轭小波基函数是小波变换中的一个重要概念。在小波变换中，我们通常使用两类小波基函数：一个是正向小波基函数（Mother Wavelet），另一个是复共轭小波基函数（Complex Conjugate Wavelet）。

设正向小波基函数为 $\psi(t)$，复共轭小波基函数为 $\psi^*(t)$。复共轭小波基函数是与正向小波基函数相对应的共轭复数函数。

数学上，复共轭小波基函数可以表示为：

$$

\psi^*(t) = \psi^*(-t)

$$

其中，$\psi^*(-t)$ 表示对 $\psi(t)$ 中的每个点取共轭复数。换句话说，复共轭小波基函数是通过将正向小波基函数 $\psi(t)$ 中的每个点取共轭而得到的。这意味着复共轭小波基函数在时间域上是对称的，其实部和虚部都是奇函数。

在小波变换的计算过程中，复共轭小波基函数与信号进行内积运算，用于计算小波变换的实部和虚部部分，从而获得更完整的频率信息。

复共轭小波基函数在小波变换的正交性和完备性等性质中起到重要作用，确保小波变换的精确性和有效性。同时，复共轭小波基函数也在许多小波变换的应用中发挥着重要的作用，如信号压缩、图像处理和特征提取等领域。

离散小波变换（Discrete Wavelet Transform，DWT）则是通过对信号进行多级的低通滤波和高通滤波得到的。对于长度为 $N$ 的离散信号 $x[n]$，DWT 的数学公式为：

$$

\begin{align*}

cA_{j}[k] &= \sum_{n=0}^{N-1} x[n] \cdot \frac{1}{\sqrt{2}} \cdot \psi \left( \frac{n-2k}{2^{j}} \right) \\

cD_{j}[k] &= \sum_{n=0}^{N-1} x[n] \cdot \frac{1}{\sqrt{2}} \cdot \phi \left( \frac{n-2k}{2^{j}} \right)

\end{align*}

$$

其中，$cA_{j}[k]$ 和 $cD_{j}[k]$ 分别是第 $j$ 级近似子带（Approximation Coefficients）和细节子带（Detail Coefficients），$k$ 表示子带的索引，$j$ 表示变换的级数。$\psi$ 和 $\phi$ 是小波基函数和尺度函数，$\cdot$ 表示卷积运算。

通过多级的低通和高通滤波，DWT 可以将信号分解为不同频率的子带，从而实现多尺度分析。同时，通过对子带系数进行阈值处理和逆变换，可以实现信号的压缩和去噪等应用。

综上所述，小波变换是一种灵活且强大的信号处理技术，可以用于时频分析、信号压缩、去噪和特征提取等多个领域。它的数学公式描述了小波基函数与信号之间的变换关系，通过这种变换可以获得信号的不同频率和时间尺度上的特征信息。

# 程序实现

实现二维离散小波变换（2D-DWT），我们可以使用Python的pywt库，它提供了对小波变换的支持。首先，确保已经安装了pywt库，可以使用以下命令安装：

```c
pip install PyWavelets
```


接下来，我们将给出一个示例代码，用于对一个二维图像进行小波变换。

```c
import pywt
import numpy as np
import matplotlib.pyplot as plt
# blur.png
image = cv2.imread('blur.png', 0)
# 进行二维离散小波变换（2D-DWT）
coeffs = pywt.dwt2(image, 'haar')
# 从结果中获取近似子带和细节子带
cA, (cH, cV, cD) = coeffs
# 打印结果
print("近似子带：")
print(cA)
print("\n水平细节子带：")
print(cH)
print("\n垂直细节子带：")
print(cV)
print("\n对角细节子带：")
print(cD)
# 可视化结果
plt.figure(figsize=(8, 8))
plt.subplot(2, 2, 1)
plt.imshow(cA, cmap='gray')
plt.title('Approximation')
plt.subplot(2, 2, 2)
plt.imshow(cH, cmap='gray')
plt.title('Horizontal Detail')
plt.subplot(2, 2, 3)
plt.imshow(cV, cmap='gray')
plt.title('Vertical Detail')
plt.subplot(2, 2, 4)
plt.imshow(cD, cmap='gray')
plt.title('Diagonal Detail')
plt.show()
```

![在这里插入图片描述](/static/img/images/04260.png)

# 子带


`pywt.dwt2`是`pywt`库中实现的二维离散小波变换（2D-DWT）函数。让我们通过数学公式来解释这个函数的作用：

给定一个2D数组`data`，我们可以将其表示为一个二维网格，其中每个元素表示一个像素的灰度值。2D-DWT的目标是将这个二维数组分解为多个子带，每个子带代表原始图像的不同部分或特征。具体地说，2D-DWT将输入的二维数组`data`分解为以下四个子带：

1. 近似子带（Approximation，记为`cA`）：表示原始图像的低频部分，包含图像中的整体结构和大致形状信息。

2. 水平细节子带（Horizontal Detail，记为`cH`）：表示图像中水平方向的高频信息，包括边缘和细节的水平变化。

3. 垂直细节子带（Vertical Detail，记为`cV`）：表示图像中垂直方向的高频信息，包括边缘和细节的垂直变化。

4. 对角细节子带（Diagonal Detail，记为`cD`）：表示图像中对角方向的高频信息，包括边缘和细节的对角变化。

这些子带可以用数学公式表示为：


```
cA：近似子带
cH：水平细节子带
cV：垂直细节子带
cD：对角细节子带
```


`pywt.dwt2`函数使用指定的小波（`wavelet`）对输入的图像`data`进行2D离散小波变换。其中，`mode`参数表示信号扩展模式，可以选择不同的模式进行计算。`axes`参数用于指定要进行变换的轴（即图像的维度）。函数返回近似子带`cA`和包含水平、垂直和对角细节子带的元组`cH, cV, cD`。

在示例中，我们使用Haar小波对其进行2D-DWT变换。

请注意，实际应用中，我们通常使用真实的图像数据，并根据不同的任务选择适合的小波函数。

# 数学公式





2D离散小波变换（2D-DWT）的数学公式可以用以下方式表示：

给定一个二维离散信号（图像） $f(x, y)$，其中 $(x, y)$ 表示图像的坐标，2D-DWT 将其分解为近似子带（Approximation, $cA$）和三个细节子带（Details）：水平细节子带（Horizontal Detail, $cH$）、垂直细节子带（Vertical Detail, $cV$）和对角细节子带（Diagonal Detail, $cD$）。

数学公式表示为：

$$

\begin{align*}

cA &= (cA_{LL}, cA_{LH}, cA_{HL}, cA_{HH}) \\

cH &= (cH_{LL}, cH_{LH}, cH_{HL}, cH_{HH}) \\

cV &= (cV_{LL}, cV_{LH}, cV_{HL}, cV_{HH}) \\

cD &= (cD_{LL}, cD_{LH}, cD_{HL}, cD_{HH})

\end{align*}

$$

其中，$cA_{LL}, cH_{LL}, cV_{LL}, cD_{LL}$ 是具有更低空间分辨率的近似子带和细节子带，分别代表水平、垂直和对角方向的低频信息。而 $cA_{LH}, cH_{LH}, cV_{LH}, cD_{LH}$ 分别代表水平、垂直和对角方向的高频信息。

在实际应用中，通常会对近似子带进行进一步的分解，即多级小波变换，以获得更多层次的细节信息。2D-DWT 是图像处理和压缩中常用的技术，它允许我们在不同频率和空间尺度上分析图像内容，并用于多种图像处理任务。

【Python】二维离散小波变换（2D-DWT）实现

p1点和p2点是一条线段的两端，沿着p1指向p2的方向，将线段长度延伸长度x，求延伸后的点ep。如下图：





![在这里插入图片描述](/static/img/images/04438.png)

Python代码：

```python
import math
def extend_line_segment(p1, p2, extension_length):
    """
    延伸线段长度并返回延伸后的点坐标
    参数:
    p1: list，起始点的坐标 [x1, y1]
    p2: list，结束点的坐标 [x2, y2]
    extension_length: float，延伸长度
    返回值:
    list，延伸后的点的坐标 [x, y]
    """
    # 计算p1指向p2的向量
    vector = [p2[0] - p1[0], p2[1] - p1[1]]
    # 计算向量的模
    magnitude = math.sqrt(vector[0] ** 2 + vector[1] ** 2)
    # 单位化向量
    unit_vector = [vector[0] / magnitude, vector[1] / magnitude]
    # 判断线段是否水平或垂直
    if p1[0] == p2[0]:  # 垂直线段
        extended_point = [p2[0], p2[1] + extension_length]
    elif p1[1] == p2[1]:  # 水平线段
        extended_point = [p2[0] + extension_length, p2[1]]
    else:  # 其他情况
        # 计算延伸后的点
        extended_point = [p2[0] + unit_vector[0] * extension_length, p2[1] + unit_vector[1] * extension_length]
    return extended_point
if __name__ == '__main__':
    p1 = [10, 200]
    p2 = [110, 100]
    extend_p = extend_line_segment(p1, p2, 300)
    print("延伸后的点坐标: ", extend_p)
    # 绘制图
    import matplotlib.pyplot as plt
    plt.plot([p1[0], p2[0]], [p1[1], p2[1]], 'r-')
    plt.plot([p2[0], extend_p[0]], [p2[1], extend_p[1]], 'b-')
    # 加注释
    plt.annotate('p1', xy=(p1[0], p1[1]), xytext=(p1[0], p1[1]))
    plt.annotate('p2', xy=(p2[0], p2[1]), xytext=(p2[0], p2[1]))
    plt.annotate('ep', xy=(extend_p[0], extend_p[1]), xytext=(extend_p[0] + 5, extend_p[1] + 5))
    # 等距
    plt.axis('equal')
    plt.show()
```

C++：

```cpp
cv::Point2f extend_line_segment(const cv::Point2f& p1, const cv::Point2f& p2, double extension_length) {
    // 计算p1指向p2的向量
    cv::Point2f vector = {p2.x - p1.x, p2.y - p1.y};
    // 计算向量的模
    double magnitude = sqrt(vector.x * vector.x + vector.y * vector.y);
    // 单位化向量
    cv::Point2f unit_vector = {static_cast<float>(vector.x / magnitude), static_cast<float>(vector.y / magnitude)};
    // 判断线段是否水平或垂直
    if (p1.x == p2.x) {  // 垂直线段
        cv::Point2f extended_point = {p2.x, static_cast<float>(p2.y + extension_length)};
        return extended_point;
    } else if (p1.y == p2.y) {  // 水平线段
        cv::Point2f extended_point = {static_cast<float>(p2.x + extension_length), p2.y};
        return extended_point;
    } else {  // 其他情况
        // 计算延伸后的点
        cv::Point2f extended_point = {static_cast<float>(p2.x + unit_vector.x * extension_length), static_cast<float>(p2.y + unit_vector.y * extension_length)};
        return extended_point;
    }
}
```

【几何数学】【Python】【C++】将线段沿着线段方向延长一定长度，求新的点

判断线段是否相交的办法（使用了向量叉积的方法）：





```c
首先，通过给定的线段端点坐标p1、p2、p3和p4构建了四个向量v1、v2、v3和v4：
v1表示从p1指向p2的向量，其分量为[p2[0] - p1[0], p2[1] - p1[1]]。
v2表示从p3指向p4的向量，其分量为[p4[0] - p3[0], p4[1] - p3[1]]。
v3表示从p1指向p3的向量，其分量为[p3[0] - p1[0], p3[1] - p1[1]]。
v4表示从p1指向p4的向量，其分量为[p4[0] - p1[0], p4[1] - p1[1]]。
接下来，计算了两个叉积cross1和cross2：
cross1表示v1和v3的叉积，计算公式为v1[0] * v3[1] - v1[1] * v3[0]。
cross2表示v1和v4的叉积，计算公式为v1[0] * v4[1] - v1[1] * v4[0]。
最后，根据两个叉积的乘积进行判断：
如果cross1和cross2的乘积小于等于0，意味着v1和v3位于不同的半平面或者其中一个线段的某个端点在另一个线段上，这时可以判断两条线段相交。
如果cross1和cross2的乘积大于0，意味着v1和v3位于同一侧或者两个线段没有交点，这时可以判断两条线段不相交。
根据以上逻辑，如果条件满足，则返回True表示线段相交，否则返回False表示线段不相交。
```


Python代码实现：

```python
class point():  # 定义类
    def __init__(self, x, y):
        self.x = x
        self.y = y
def cross(p1, p2, p3):  # 跨立实验
    x1 = p2.x - p1.x
    y1 = p2.y - p1.y
    x2 = p3.x - p1.x
    y2 = p3.y - p1.y
    return x1 * y2 - x2 * y1
def has_intersect(p1, p2, p3, p4):  # 判断两线段是否相交
    # 快速排斥，以l1、l2为对角线的矩形必相交，否则两线段不相交
    if (max(p1.x, p2.x) >= min(p3.x, p4.x)  # 矩形1最右端大于矩形2最左端
            and max(p3.x, p4.x) >= min(p1.x, p2.x)  # 矩形2最右端大于矩形最左端
            and max(p1.y, p2.y) >= min(p3.y, p4.y)  # 矩形1最高端大于矩形最低端
            and max(p3.y, p4.y) >= min(p1.y, p2.y)):  # 矩形2最高端大于矩形最低端
        # 若通过快速排斥则进行跨立实验
        if (cross(p1, p2, p3) * cross(p1, p2, p4) <= 0
                and cross(p3, p4, p1) * cross(p3, p4, p2) <= 0):
            D = True
        else:
            D = False
    else:
        D = False
    return D
def are_lines_intersect(p1, p2, p3, p4):
    p1 = point(p1[0], p1[1])
    p2 = point(p2[0], p2[1])
    p3 = point(p3[0], p3[1])
    p4 = point(p4[0], p4[1])
    if has_intersect(p1, p2, p3, p4):
        return True
    else:
        return False
def compute_intersection(p1, p2, p3, p4):
    if p1[0] == p2[0]:  # p1p2为垂直线
        x = p1[0]
        slope2 = (p4[1] - p3[1]) / (p4[0] - p3[0])
        intercept2 = p3[1] - slope2 * p3[0]
        y = slope2 * x + intercept2
    elif p3[0] == p4[0]:  # p3p4为垂直线
        x = p3[0]
        slope1 = (p2[1] - p1[1]) / (p2[0] - p1[0])
        intercept1 = p1[1] - slope1 * p1[0]
        y = slope1 * x + intercept1
    else:
        slope1 = (p2[1] - p1[1]) / (p2[0] - p1[0])
        slope2 = (p4[1] - p3[1]) / (p4[0] - p3[0])
        intercept1 = p1[1] - slope1 * p1[0]
        intercept2 = p3[1] - slope2 * p3[0]
        if slope1 == slope2:
            # 斜率相等的时候，如果线段重合，交点是无数个，这里返回断点表达此意
            if p1[0] <= p3[0] <= p2[0]:
                return p3
            if p1[0] <= p4[0] <= p2[0]:
                return p4
        else:
            x = (intercept2 - intercept1) / (slope1 - slope2)
            y = slope1 * x + intercept1
    return [x, y]
if __name__ == '__main__':
    p1 = [0, 5]
    p2 = [10, 5]
    p3 = [0, 10]
    p4 = [10, 10]
    # p1 p2 是一条线段
    # p3 p4 是另一条线段
    # 判断是否相交，相交且求交点
    if are_lines_intersect(p1, p2, p3, p4):
        print(compute_intersection(p1, p2, p3, p4))
        x, y = compute_intersection(p1, p2, p3, p4)
    else:
        print("No intersection")
    # 画图
    import matplotlib.pyplot as plt
    # 样式是波浪线
    plt.plot([p1[0], p2[0]], [p1[1], p2[1]], color='r')
    # 样式是点线
    plt.plot([p3[0], p4[0]], [p3[1], p4[1]], color='b', linewidth=4, linestyle=':')
    # 加注释
    plt.annotate('p1', xy=(p1[0], p1[1]), xytext=(p1[0] + 10, p1[1] + 10))
    plt.annotate('p2', xy=(p2[0], p2[1]), xytext=(p2[0] + 10, p2[1] + 10))
    plt.annotate('p3', xy=(p3[0], p3[1]), xytext=(p3[0] + 10, p3[1] + 10))
    plt.annotate('p4', xy=(p4[0], p4[1]), xytext=(p4[0] + 10, p4[1] + 10))
    try:
        # 绘制交点
        plt.scatter(x, y, color='g', marker='o')
        # 给交点加注释
        plt.annotate('intersection', xy=(x, y), xytext=(x, y),
                     arrowprops=dict(facecolor='g', shrink=0.05))
    except:
        pass
    # 坐标轴等距
    plt.axis('equal')
    plt.show()
```

绘制的图：

![在这里插入图片描述](/static/img/images/04451.png)

![在这里插入图片描述](/static/img/images/04452.png)

不相交：

![在这里插入图片描述](/static/img/images/04453.png)


# C++ 借助opencv的数据结构

```cpp
float cross(const cv::Point2f& p1, const cv::Point2f& p2, const cv::Point2f& p3) {
    float x1 = p2.x - p1.x;
    float y1 = p2.y - p1.y;
    float x2 = p3.x - p1.x;
    float y2 = p3.y - p1.y;
    return x1 * y2 - x2 * y1;
}
bool has_intersect(const cv::Point2f& p1, const cv::Point2f& p2, const cv::Point2f& p3, const cv::Point2f& p4) {
    // 快速排斥，以l1、l2为对角线的矩形必相交，否则两线段不相交
    if (std::max(p1.x, p2.x) >= std::min(p3.x, p4.x)  // 矩形1最右端大于矩形2最左端
        && std::max(p3.x, p4.x) >= std::min(p1.x, p2.x)  // 矩形2最右端大于矩形最左端
        && std::max(p1.y, p2.y) >= std::min(p3.y, p4.y)  // 矩形1最高端大于矩形最低端
        && std::max(p3.y, p4.y) >= std::min(p1.y, p2.y)) {  // 矩形2最高端大于矩形最低端
        // 若通过快速排斥则进行跨立实验
        if (cross(p1, p2, p3) * cross(p1, p2, p4) <= 0
            && cross(p3, p4, p1) * cross(p3, p4, p2) <= 0) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
        return false;
    }
}
bool has_intersect(const std::vector<cv::Point2f>& seg1, const std::vector<cv::Point2f>& seg2) {
    return has_intersect(seg1[0], seg1[1], seg2[0], seg2[1]);
}
// compute_intersection: 计算两条线段的交点
// 原理：计算两条线段的斜率和截距，然后解方程
cv::Point2f compute_intersection(cv::Point2f p1, cv::Point2f p2, cv::Point2f p3, cv::Point2f p4) {
    cv::Point2f intersection;
    if (p1.x == p2.x) {
        intersection.x = p1.x;
        float slope2 = (p4.y - p3.y) / (p4.x - p3.x);
        float intercept2 = p3.y - slope2 * p3.x;
        intersection.y = slope2 * intersection.x + intercept2;
    } else if (p3.x == p4.x) {
        intersection.x = p3.x;
        float slope1 = (p2.y - p1.y) / (p2.x - p1.x);
        float intercept1 = p1.y - slope1 * p1.x;
        intersection.y = slope1 * intersection.x + intercept1;
    } else {
        float slope1 = (p2.y - p1.y) / (p2.x - p1.x);
        float slope2 = (p4.y - p3.y) / (p4.x - p3.x);
        float intercept1 = p1.y - slope1 * p1.x;
        float intercept2 = p3.y - slope2 * p3.x;
        if (slope1 == slope2) {
            // if p1[0] <= p3[0] <= p2[0]:
            if (p1.x <= p3.x && p3.x <= p2.x) {
                return p3;
            } else if (p1.x <= p4.x && p4.x <= p2.x) {
                return p4;
            } else {
                return {-1, -1};
            }
        }
    }
    return intersection;
}
```

【几何数学】【Python】【C++】判断两条线段是否相交，若相交则求出交点坐标

一个高中数学题目，已经点P1和点P2构成直线，经过P3点做已知直线的垂线，求垂线与已知直线的交点坐标。





![在这里插入图片描述](/static/img/images/04471.png)


```python
p1 = [100, 15]
p2 = [16, 85]
p3 = [-50, 100]
if p2[0] - p1[0] == 0:
    # p1 p2 构成垂线，那么垂直线就是一条水平线
    x = p1[0]
    y = p3[1]
elif p2[1] - p1[1] == 0:
    # p1 p2 构成水平线，那么垂直线就是一条垂直线
    x = p3[0]
    y = p1[1]
else:
    slope = (p2[1] - p1[1]) / (p2[0] - p1[0])
    perpendicularSlope = -1 / slope
    intercept = p3[1] - perpendicularSlope * p3[0]
    x = (p3[1] - p1[1] + slope * p1[0] - perpendicularSlope * p3[0]) / (slope - perpendicularSlope)
    y = slope * (x - p1[0]) + p1[1]
# 绘制两条直线和交点
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
plt.plot([p1[0], p2[0]], [p1[1], p2[1]], color='b')
plt.plot([p3[0], x], [p3[1], y], color='r')
plt.scatter([x], [y], color='r')
# 给P1,P2,P3点加注释
plt.annotate('P1', xy=(p1[0], p1[1]), xytext=(p1[0] + 0.5, p1[1] + 0.5))
plt.annotate('P2', xy=(p2[0], p2[1]), xytext=(p2[0] + 0.5, p2[1] + 0.5))
plt.annotate('P3', xy=(p3[0], p3[1]), xytext=(p3[0] + 0.5, p3[1] + 0.5))
# 给交点加注释
plt.annotate('JD', xy=(x, y), xytext=(x + 0.5, y + 0.5))
# 让坐标轴比例一样
plt.axis('equal')
plt.show()
```

【Python】经过一个点P3的一条直线垂直于已知直线，求交点坐标

# 贝叶斯概率





通过条件概率以及贝叶斯公式，可以在已知某些条件的情况下，计算出某一事件发生的概率。下面我会详细解释条件概率和贝叶斯概率，并结合公式和例子进行说明。

### **条件概率**

条件概率是指在事件B发生的条件下，事件A发生的概率，记作$P(A|B)$。公式如下：

$$

P(A|B) = \frac{P(A \cap B)}{P(B)}

$$

其中，$P(A \cap B)$是事件A和事件B同时发生的概率。

**例子：**

我们有以下数据：

| 性别 | 职业  |

| ---- | ----- |

| 男   | 教师  |

| 男   | 学生  |

| 男   | 教师  |

| 女   | 学生  |

| 女   | 教师  |

| 女   | 教师  |

| 女   | 教师  |

| 女   | 教师  |

| 女   | 教师  |

| 女   | 教师  |

男性有3名，其中教师2名。我们要计算在性别是男(B)的条件下，职业是教师(A)的概率：

$$

P(A|B) = \frac{\text{性别是男且职业是教师的数量}}{\text{性别是男的总数量}} = \frac{2}{3}

$$

同样的，我们可以计算在职业是教师(A)的条件下，性别是男(B)的概率：

职业是教师的共有8名，其中男性2名。

$$

P(B|A) = \frac{\text{职业是教师且性别是男的数量}}{\text{职业是教师的总数量}} = \frac{2}{8} = \frac{1}{4}

$$

### **联合概率**

联合概率$P(A, B)$表示事件A和事件B同时发生的概率。在上述例子中，即既是男，而且还是教师的比例：

$$

P(A, B) = \frac{2}{10}

$$

同时，我们可以用条件概率和边际概率来表示联合概率：

$$

P(A, B) = P(A \mid B) \cdot P(B) = \frac{2}{3} \cdot \frac{3}{10} = \frac{2}{10}

$$

$$

P(A, B) = P(B \mid A) \cdot P(A) = \frac{1}{4} \cdot \frac{8}{10} = \frac{2}{10}

$$

### **贝叶斯概率**

贝叶斯概率是基于贝叶斯公式，用来计算在已知条件下，某一事件发生的概率。贝叶斯公式如下：

$$

P(A|B) = \frac{P(A) \cdot P(B|A)}{P(B)}

$$

我们用前面的数据来验证一下：

$$

P(A|B) = \frac{P(A) \cdot P(B|A)}{P(B)} = \frac{\frac{8}{10} \cdot \frac{2}{8}}{\frac{3}{10}} = \frac{\frac{16}{80}}{\frac{3}{10}} = \frac{2}{3}

$$

这与我们通过直接计算得出的结果是一致的。

### **代码示例**

接下来我们用Python代码来验证这些计算：

```python
# 定义数据
total_population = 10
male_population = 3
teacher_population = 8
male_teacher_population = 2
# 计算条件概率
P_A_given_B = male_teacher_population / male_population
P_B_given_A = male_teacher_population / teacher_population
# 计算联合概率
P_A_and_B = male_teacher_population / total_population
# 计算贝叶斯概率
P_A = teacher_population / total_population
P_B = male_population / total_population
P_A_given_B_bayes = (P_A * P_B_given_A) / P_B
# 输出结果
print(f"P(A|B) = {P_A_given_B:.2f}")
print(f"P(B|A) = {P_B_given_A:.2f}")
print(f"P(A and B) = {P_A_and_B:.2f}")
print(f"P(A|B) using Bayes' theorem = {P_A_given_B_bayes:.2f}")
```

### **Key Concept**

贝叶斯概率是基于贝叶斯公式，用来计算在已知条件下某一事件发生的概率。

### **Key Concept Explanation**

贝叶斯公式是一个非常重要的工具，可以帮助我们在已知某些条件的情况下，重新评估事件的概率。它基于条件概率的概念，通过已知的概率关系，计算未知条件下的概率。在实际应用中，贝叶斯公式被广泛用于统计推断、机器学习、数据分析等领域。

# 实际应用示例

条件概率在日常生活中有许多实际应用，以下是几个常见的例子：

### **医疗诊断**

在医疗诊断中，医生常常需要判断在已经出现某些症状（条件B）的情况下，某种疾病（事件A）发生的概率。例如，假设我们有以下数据：

- 某疾病的总发病率：$P(D) = 0.01$

- 出现某种症状的总概率：$P(S) = 0.1$

- 在患有这种疾病的情况下出现症状的概率：$P(S|D) = 0.8$

我们需要计算在出现这种症状的情况下，患有这种疾病的概率，即$P(D|S)$。根据贝叶斯公式：

$$

P(D|S) = \frac{P(D) \cdot P(S|D)}{P(S)} = \frac{0.01 \cdot 0.8}{0.1} = 0.08

$$

### **天气预报**

在天气预报中，我们可能会遇到这样的情况：已知某天早上有云（条件B），那么下雨（事件A）的概率是多少。假设我们有以下数据：

- 某天有云的概率：$P(C) = 0.3$

- 某天会下雨的概率：$P(R) = 0.2$

- 在有云的情况下会下雨的概率：$P(R|C) = 0.6$

我们可以计算在有云的情况下下雨的概率：

$$

P(R|C) = \frac{P(R \cap C)}{P(C)} = \frac{P(R) \cdot P(C|R)}{P(C)}

$$

由于$P(R \cap C) = P(R) \cdot P(C|R)$，我们可以得到：

$$

P(R|C) = \frac{0.2 \cdot 0.6}{0.3} = 0.4

$$

### **信用评分**

在金融领域，银行会根据客户的某些行为（如按时还款，借贷记录等）来评估他们的信用风险。假设我们有以下数据：

- 某客户违约的概率：$P(D) = 0.05$

- 某客户有不良信用记录的概率：$P(B) = 0.1$

- 在有不良信用记录的情况下客户违约的概率：$P(D|B) = 0.4$

我们可以计算在客户有不良信用记录的情况下违约的概率：

$$

P(D|B) = \frac{P(D \cap B)}{P(B)} = \frac{P(D) \cdot P(B|D)}{P(B)} = \frac{0.05 \cdot 0.4}{0.1} = 0.2

$$

### **代码示例**

我们可以用Python代码来实现这些计算：

```python
# 医疗诊断
P_D = 0.01
P_S = 0.1
P_S_given_D = 0.8
P_D_given_S = (P_D * P_S_given_D) / P_S
print(f"医疗诊断: P(D|S) = {P_D_given_S:.2f}")
# 天气预报
P_R = 0.2
P_C = 0.3
P_C_given_R = 0.6
P_R_given_C = (P_R * P_C_given_R) / P_C
print(f"天气预报: P(R|C) = {P_R_given_C:.2f}")
# 信用评分
P_D = 0.05
P_B = 0.1
P_B_given_D = 0.4
P_D_given_B = (P_D * P_B_given_D) / P_B
print(f"信用评分: P(D|B) = {P_D_given_B:.2f}")
```

【数学】【概率论】如何理解贝叶斯概率

# 1 概率密度函数





![](/static/img/images/00975.png)

# 2 八个分布

![在这里插入图片描述](/static/img/images/00976.png)

![在这里插入图片描述](/static/img/images/00977.png)

![在这里插入图片描述](/static/img/images/00978.png)

![在这里插入图片描述](/static/img/images/00979.png)

# 3 期望

![在这里插入图片描述](/static/img/images/00980.png)

# 4 方差

![在这里插入图片描述](/static/img/images/00981.png)

# 5 有了大数定律后才有后面的

# 6 样本和统计量

![在这里插入图片描述](/static/img/images/00982.png)

![在这里插入图片描述](/static/img/images/00983.png)

![在这里插入图片描述](/static/img/images/00984.png)


# 6 点估计 利用期望求解估计量  例题

不论总体服从什么分布，样本均值是总体均值的无偏估计量。

总体 X ——某全体研究对象的某一指标。

样本——只研究“简单随机样本”：Xi 独立同分布于 X。

![在这里插入图片描述](/static/img/images/00985.png)

![在这里插入图片描述](/static/img/images/00986.png)

举例：

![在这里插入图片描述](/static/img/images/00987.png)

![在这里插入图片描述](/static/img/images/00988.png)


# 7 最大似然估计  利用似然函数求解估计量

![在这里插入图片描述](/static/img/images/00989.png)

![在这里插入图片描述](/static/img/images/00990.png)


![在这里插入图片描述](/static/img/images/00991.png)

# 8 估计量的评价标准  方差的除数为啥是n-1

![在这里插入图片描述](/static/img/images/00992.png)

![在这里插入图片描述](/static/img/images/00993.png)

![在这里插入图片描述](/static/img/images/00994.png)

![在这里插入图片描述](/static/img/images/00995.png)


# 9 置信区间

![在这里插入图片描述](/static/img/images/00996.png)

![在这里插入图片描述](/static/img/images/00997.png)

[复习]概率论的一些知识

# 1 香农墒  量化信息  信息量大小





[https://baike.baidu.com/item/%E9%A6%99%E5%86%9C%E7%86%B5/1649961?fr=aladdin](https://baike.baidu.com/item/%E9%A6%99%E5%86%9C%E7%86%B5/1649961?fr=aladdin)

1948 年，香农提出了“信息熵”(shāng) 的概念，解决了对**信息的量化度量问题**。

实质就是：信息不确定性的多少。

对于任意一个随机变量 X，它的熵定义如下：

![在这里插入图片描述](/static/img/images/01003.png)

变量的不确定性越大，熵也就越大，把它搞清楚所需要的信息量也就越大。


# 2 交叉熵

[https://www.cnblogs.com/wangguchangqing/p/12068084.html](https://www.cnblogs.com/wangguchangqing/p/12068084.html)

非常好的解释：[https://www.zhihu.com/question/65288314/answer/244557337](https://www.zhihu.com/question/65288314/answer/244557337)

KL散度（度量2个概率分布之间的距离差异）公式：

![在这里插入图片描述](/static/img/images/01004.png)

交叉熵公式：

![在这里插入图片描述](/static/img/images/01005.png)

交叉熵=KL散度-熵

KL散度是非负的。

最小化KL散度 等价于 最小化交叉熵。

# 3 交叉熵损失函数

[https://zhuanlan.zhihu.com/p/35709485](https://zhuanlan.zhihu.com/p/35709485)

[https://zhuanlan.zhihu.com/p/35707643](https://zhuanlan.zhihu.com/p/35707643)

为什么它会在分类问题中这么有效呢？

主要原因是逻辑回归配合MSE损失函数时，采用梯度下降法进行学习时，会出现模型一开始训练时，**学习速率非常慢**的情况。

使用MSE的一个缺点就是其偏导值在输出概率值接近0或者接近1的时候非常小，这可能会造成模型刚开始训练时，偏导值几乎消失。

![在这里插入图片描述](/static/img/images/01006.png)

Cross Entropy Error Function（交叉熵损失函数）该函数是凸函数，求导时能够得到全局最优值。

![在这里插入图片描述](/static/img/images/01007.png)

![在这里插入图片描述](/static/img/images/01008.png)

![在这里插入图片描述](/static/img/images/01009.png)

香农墒 交叉熵

作者：Ghost





链接：[https://www.zhihu.com/question/51448623/answer/275721105](https://www.zhihu.com/question/51448623/answer/275721105)

来源：知乎

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

<font face="微软雅黑" size = 5 color = red > **贝叶斯统计学派和频率派统计是不一样的。贝叶斯统计学派是含有先验知识的。** 

![在这里插入图片描述](/static/img/images/01010.png)

![在这里插入图片描述](/static/img/images/01011.png)

概率论 贝叶斯公式

代码：[https://github.com/simon20010923/DDAMFN/tree/main](https://github.com/simon20010923/DDAMFN/tree/main)





此算法是当前的第一名：[https://paperswithcode.com/paper/a-dual-direction-attention-mixed-feature](https://paperswithcode.com/paper/a-dual-direction-attention-mixed-feature)




# 介绍

面部表情在人类交流中起着重要作用，是理解情绪和态度的关键信号。因此，计算机需要获得辨识和解释面部表情的能力。[1–3]已经清楚地阐明了视觉感知、环境映射算法与基于生物识别认证计算机视觉的面部表情识别（FER）之间的关系，因此使用深度学习方法解决FER问题是有意义的。FER网络的主流架构通常由主干和头部组成。然而，最近的方法主要集中在头部或颈部区域，并仅使用VGG [4]或ResNet [5]作为其主干。值得注意的是，这些主干最初是为更大的数据集而设计的，可能会从图像中提取冗余信息，在相对较小的数据集中导致过度拟合。本文提出了一种创新的主干网络，称为混合特征网络（MFN）。MFN建立在MobileFaceNets [6]的基础上，这是一个专门为面部验证任务量身定制的轻量级网络。通过引入混合深度卷积核 [7]来增强MFN，这些卷积核利用了不同尺寸卷积核的优势。此外，坐标注意 [8]被引入到MFN架构中，以促进对长距离依赖的捕捉。因此，提取了用于FER的有意义的特征。

此外，FER面临着两个重要挑战：类间差异小和类内差异大。要解决这些挑战，建立各种面部区域之间的连接，如嘴巴、眼睛、鼻子等，至关重要。在这方面，注意机制提供了潜在的解决方案。具体来说，提出了双向注意（DDA）头，该头应用于所提出的方法，旨在根据提取的特征信息构建注意图。根据以前的工作 [8]，设计了从垂直和水平方向生成注意图的注意头。随后，将从双向注意网络（DDAN）获得的注意图与输入特征图相乘，得到一个新的特征图。该特征图经过线性全局深度卷积（GDConv）层 [6]，然后进行重塑操作。采用全连接层生成最终结果。通过集成所提出的DDA头和后续处理步骤，可以增强模型的能力。

最后，本文将MFN和DDAN集成在一起，提出了一种名为双向注意混合特征网络（DDAMFN）的新模型。

为了直观地展示DDAMFN的有效性，进行了涉及ResNet_50、MFN和DDAMFN模型的比较分析。所有模型都在AffectNet-7数据集上进行了训练，并在相同的测试数据上进行了测试。Grad-CAM [9]被应用于捕获各自主干架构提取的特征的见解。该技术通过基于梯度的定位，促进了通过热图突出显示图像中的重要区域进行预测。该分析的结果在图1中呈现。对结果的综合评估展示了模型之间注意焦点的明显模式。很明显，MFN关注的区域比ResNet_50更特定。对于DDAMFN，DDAN允许MFN定位更合适的区域。

图1。七张图像的热图：中性（第1行），快乐（第2行），悲伤（第3行），惊讶（第4行），恐惧（第5行），厌恶（第6行）和愤怒（第7行）。列1：原始图像。列2：ResNet_50。列3：MFN。列4：DDAMFN（MFN + DDAN）。很明显，MFN关注的区域比ResNet_50更特定。DDAN允许MFN定位更合适的区域。

此外，当在各种基准数据集上进行了大量实验时，DDAMFN模型表现出了显着的性能，将其确立为FER领域的当前最先进网络。我们研究的贡献可以总结如下：

（1）为了增强FER的提取特征的质量，本研究提出了一种名为MFN的新型主干网络。MFN利用不同内核尺寸的利用，从而有助于获得强大的特征。此外，在MFN架构中包含坐标注意层，可以捕捉长距离依赖性，进一步增强了其在FER任务中的有效性。

（2）为了有效检测不同面部表情之间的细微变化，引入了DDAN。通过从两个不同方向生成关注，DDAN旨在全面捕捉相关的面部区域，并提高FER的区分能力。

（3）应用了一种新颖的注意力损失机制，以确保DDAN的注意头聚焦在不同区域，从而显著提高了模型的整体性能和区分能力。

（4）对著名的FER数据集进行了广泛的评估，包括A

ffectNet、RAF-DB和FERPlus，以评估DDAMFN的性能。实验结果表明，其在AffectNet-7上的准确率为67.03％，在AffectNet-8上为64.25％，在RAF-DB上为91.35％，在FERPlus上为90.74％。这些出色的结果突显了DDAMFN在FER领域的有效性和优越性。

# 网络结构

DDAMFN的架构概述如图2所示，包括两个主要组件：MFN和DDAN。首先，面部图像被输入到MFN中，产生基本的特征图作为输出。随后，通过DDAN在垂直和水平方向生成注意力图。最终，注意力图被重塑为特定维度，并通过全连接层预测图像的表情类别。

DDAMFN框架有效地结合了MFN的特征提取能力和DDAN的注意机制的判别力。通过整合这些组件，DDAMFN可以在FER任务中实现改善的性能。

![在这里插入图片描述](/static/img/images/00042.png)

MFN结构：

![在这里插入图片描述](/static/img/images/00043.png)

# 损失

如图2所示，从DDAN获得的大小为7×7×512的特征图经过线性GDConv层和线性层处理。然后，将转换后的特征图重新形状为一个512维的向量。通过全连接层获得类别置信度。在损失函数方面，训练过程中采用标准的交叉熵损失。该损失函数有效地衡量了预测类别概率与真实标签之间的差异，有助于优化模型的参数。整体损失函数可以表示为：

L = L_cls + λ_a * L_att，(3)

其中，L_cls代表标准交叉熵损失，L_att是注意力损失。λ_a是一个超参数，默认值为0.1。


# 指标比较 

![在这里插入图片描述](/static/img/images/00044.png)

# 处理数据

在DDAMFN中，只有前8个类别是重要的。我将后面三个类别都归位负样本类别。

![在这里插入图片描述](/static/img/images/00045.png)

![在这里插入图片描述](/static/img/images/00046.png)

使用此代码处理数据，将原始数据集进行转换：

```python
import os
import shutil
import pandas as pd
from tqdm import tqdm
root = r"/ssd/xd/src_data/Manually_Annotated_Images/"
# training.csv
training_csv = r"/ssd/xd/src_data/training.csv"
# validation.csv
validation_csv = r"/ssd/xd/src_data/validation.csv"
dst_train = r"/ssd/xd/src_data/new_datasets_ImageFolder/train"
os.makedirs(dst_train, exist_ok=True)
dst_val = r"/ssd/xd/src_data/new_datasets_ImageFolder/val"
os.makedirs(dst_val, exist_ok=True)
# subDirectory_filePath列是图片的路径，expression列是标签
# 用标签创建子文件夹，然后对应图片移动到对应文件夹
df_train = pd.read_csv(training_csv)
df_train = df_train[["subDirectory_filePath", "expression"]]
for i in tqdm(range(len(df_train))):
    img_path = os.path.join(root, df_train.iloc[i, 0])
    label = df_train.iloc[i, 1]
    dst = os.path.join(dst_train, str(label))
    os.makedirs(dst, exist_ok=True)
    if os.path.exists(img_path):
        shutil.copy(img_path, dst)
df_val = pd.read_csv(validation_csv)
df_val = df_val[["subDirectory_filePath", "expression"]]
for i in tqdm(range(len(df_val))):
    img_path = os.path.join(root, df_val.iloc[i, 0])
    label = df_val.iloc[i, 1]
    dst = os.path.join(dst_val, str(label))
    os.makedirs(dst, exist_ok=True)
    if os.path.exists(img_path):
        shutil.copy(img_path, dst)
# 0到7的类别标签保留，其余的都转为一个标签8
dst_train_8 = r"/ssd/xd/src_data/new_datasets_ImageFolder/train/8"
dst_train_9 = r"/ssd/xd/src_data/new_datasets_ImageFolder/train/9"
dst_train_10 = r"/ssd/xd/src_data/new_datasets_ImageFolder/train/10"
# 将9和10类别的图片移动到8类别文件夹，然后删除9和10文件夹
files_9 = os.listdir(dst_train_9)
files_10 = os.listdir(dst_train_10)
for file in files_9:
    shutil.move(os.path.join(dst_train_9, file), os.path.join(dst_train_8, file))
for file in files_10:
    shutil.move(os.path.join(dst_train_10, file), os.path.join(dst_train_8, file))
shutil.rmtree(dst_train_9)
shutil.rmtree(dst_train_10)
dst_val_8 = r"/ssd/xd/src_data/new_datasets_ImageFolder/val/8"
dst_val_9 = r"/ssd/xd/src_data/new_datasets_ImageFolder/val/9"
dst_val_10 = r"/ssd/xd/src_data/new_datasets_ImageFolder/val/10"
# 将9和10类别的图片移动到8类别文件夹，然后删除9和10文件夹
files_9 = os.listdir(dst_val_9)
files_10 = os.listdir(dst_val_10)
for file in files_9:
    shutil.move(os.path.join(dst_val_9, file), os.path.join(dst_val_8, file))
for file in files_10:
    shutil.move(os.path.join(dst_val_10, file), os.path.join(dst_val_8, file))
shutil.rmtree(dst_val_9)
shutil.rmtree(dst_val_10)
```


得到：

![在这里插入图片描述](/static/img/images/00047.png)

文件夹 0 中的文件数量为: 74874

文件夹 1 中的文件数量为: 134415

文件夹 2 中的文件数量为: 25459

文件夹 3 中的文件数量为: 14090

文件夹 4 中的文件数量为: 6378

文件夹 5 中的文件数量为: 3803

文件夹 6 中的文件数量为: 24882

文件夹 7 中的文件数量为: 3750

文件夹 8 中的文件数量为: 127148

文件夹 0 中的文件数量为: 500

文件夹 1 中的文件数量为: 500

文件夹 2 中的文件数量为: 500

文件夹 3 中的文件数量为: 500

文件夹 4 中的文件数量为: 500

文件夹 5 中的文件数量为: 500

文件夹 6 中的文件数量为: 500

文件夹 7 中的文件数量为: 500

文件夹 8 中的文件数量为: 1500


# 下载代码训练

https://github.com/simon20010923/DDAMFN/tree/main

![在这里插入图片描述](/static/img/images/00048.png)

# 效果

垂直领域模型比通用分类模型强多了，这3轮直接干到道心破碎：

(py310_torch)   Tue Mar 19 #   15:54:01 #   /ssd/src_data/eff_train/DDAMFN-main # python affectnet_train.py

Whole train set size: 414798

Validation set size: 5500

[Epoch 1] Training accuracy: 0.4141. Loss: 3.846. LR 0.000100

[Epoch 1] Validation accuracy:0.4827. Loss:7.671

best_acc:0.4827

Model saved.

[Epoch 2] Training accuracy: 0.5221. Loss: 2.075. LR 0.000060

[Epoch 2] Validation accuracy:0.5035. Loss:5.648

best_acc:0.5035

Model saved.

[Epoch 3] Training accuracy: 0.5471. Loss: 1.810. LR 0.000036

[Epoch 3] Validation accuracy:0.5105. Loss:4.621

best_acc:0.5105

Model saved.

[Epoch 4] Training accuracy: 0.5606. Loss: 1.685. LR 0.000022

[Epoch 4] Validation accuracy:0.5198. Loss:3.784

best_acc:0.5198

Model saved.

[Epoch 5] Training accuracy: 0.5674. Loss: 1.618. LR 0.000013

[Epoch 5] Validation accuracy:0.5220. Loss:3.048

best_acc:0.522

Model saved.

 12%|██████████████▌                        


最后结果：

[Epoch 38] Training accuracy: 0.5799. Loss: 1.502. LR 0.000000

[Epoch 38] Validation accuracy:0.5225. Loss:2.505

best_acc:0.5245

Model saved.

[Epoch 39] Training accuracy: 0.5784. Loss: 1.505. LR 0.000000

[Epoch 39] Validation accuracy:0.5235. Loss:2.513

best_acc:0.5245

Model saved.

[Epoch 40] Training accuracy: 0.5799. Loss: 1.504. LR 0.000000

[Epoch 40] Validation accuracy:0.5215. Loss:2.496

best_acc:0.5245

Model saved.



# 试试8个类别的训练

8个类别表情少了一些数据干扰，结果好多了：

![在这里插入图片描述](/static/img/images/00049.png)

训练结果：

![在这里插入图片描述](/static/img/images/00050.png)


Model saved.

[Epoch 33] Training accuracy: 0.5960. Loss: 1.590. LR 0.000000

[Epoch 33] Validation accuracy:0.6235. Loss:2.621

best_acc:0.6265

Model saved.

[Epoch 34] Training accuracy: 0.5939. Loss: 1.596. LR 0.000000

[Epoch 34] Validation accuracy:0.6258. Loss:2.589

best_acc:0.6265

Model saved.

[Epoch 35] Training accuracy: 0.5967. Loss: 1.593. LR 0.000000

[Epoch 35] Validation accuracy:0.6263. Loss:2.558

best_acc:0.6265

Model saved.

[Epoch 36] Training accuracy: 0.5963. Loss: 1.593. LR 0.000000

[Epoch 36] Validation accuracy:0.6263. Loss:2.578

best_acc:0.6265

Model saved.

[Epoch 37] Training accuracy: 0.5951. Loss: 1.593. LR 0.000000

[Epoch 37] Validation accuracy:0.6252. Loss:2.576

best_acc:0.6265

Model saved.

[Epoch 38] Training accuracy: 0.5960. Loss: 1.591. LR 0.000000

[Epoch 38] Validation accuracy:0.6272. Loss:2.607

best_acc:0.6272

Model saved.

[Epoch 39] Training accuracy: 0.5957. Loss: 1.592. LR 0.000000

[Epoch 39] Validation accuracy:0.6255. Loss:2.612

best_acc:0.6272

Model saved.

[Epoch 40] Training accuracy: 0.5969. Loss: 1.592. LR 0.000000

[Epoch 40] Validation accuracy:0.6235. Loss:2.588

best_acc:0.6272

Model saved.

100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [3:58:59<00:00, 358.48s/it]


# 8类验证精度

![在这里插入图片描述](/static/img/images/00051.png)

# 8类训练损失变化

![在这里插入图片描述](/static/img/images/00052.png)


# 8类混淆矩阵

混淆矩阵很容易看出，本身是某个类别的数据，被误判为哪个类别去了，可以看出某两个类别容易混淆。

![在这里插入图片描述](/static/img/images/00053.png)

# 推理测试

推理这张图：

![在这里插入图片描述](/static/img/images/00054.png)

a100显卡CUDA推理：

用时0.029578685760498047秒

Class Neutral: 0.0000

Class Happy: 0.0001

Class Sad: 0.0000

Class Surprise: 0.0008

Class Fear: 0.0125

Class Disgust: 0.0001

Class Angry: 0.9865

Class Contempt: 0.0000

# 转onnx模型

![在这里插入图片描述](/static/img/images/00055.png)

```cpp
    # Define input example
    dummy_input = torch.randn(1, 3, 112, 112, device=device)
    # Perform inference to capture dynamic computation graph
    with torch.no_grad():
        output, _, _ = model(dummy_input)
    # Export the model to ONNX
    torch.onnx.export(model, dummy_input, args.output_path, verbose=True,opset_version=10)
    print(f"ONNX model exported to {args.output_path}")
```

# onnx推理

```cpp
def inference(args):
    # Load ONNX model
    ort_session = onnxruntime.InferenceSession(args.onnx_model_path)
    time1 = time.time()
    # Preprocess input image
    image_transform = transforms.Compose([
        transforms.Resize((112, 112)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                             std=[0.229, 0.224, 0.225])
    ])
    image = Image.open(args.image_path).convert('RGB')
    image_tensor = image_transform(image).unsqueeze(0).numpy()
    # Perform inference
    ort_inputs = {ort_session.get_inputs()[0].name: image_tensor}
    ort_outs = ort_session.run(None, ort_inputs)
    logits = np.squeeze(ort_outs[0])
    # Apply softmax
    probabilities = np.exp(logits) / np.sum(np.exp(logits), axis=0)
    time2 = time.time()
    print(f"Inference time: {time2 - time1} seconds")
    return probabilities
```

Inference time: 0.08892297744750977 seconds

Class Neutral: 0.0000

Class Happy: 0.0001

Class Sad: 0.0000

Class Surprise: 0.0008

Class Fear: 0.0125

Class Disgust: 0.0001

Class Angry: 0.9865

Class Contempt: 0.0000


# 结合一些别的项目

本文的分类器只是针对方形图像进行分类的，所以一些日常图片要进行人脸检测，可以参看项目：

[https://github.com/derronqi/yolov8-face](https://github.com/derronqi/yolov8-face)

[https://github.com/hpc203/yolov8-face-landmarks-opencv-dnn/tree/main](https://github.com/hpc203/yolov8-face-landmarks-opencv-dnn/tree/main)

## 跑完后的一些图鉴

![请添加图片描述](/static/img/images/00056.jpeg)

![请添加图片描述](/static/img/images/00057.png)

![请添加图片描述](/static/img/images/00058.png)


![请添加图片描述](/static/img/images/00059.png)

![请添加图片描述](/static/img/images/00060.png)

![请添加图片描述](/static/img/images/00061.png)

![请添加图片描述](/static/img/images/00062.png)

![请添加图片描述](/static/img/images/00063.png)



# 做个gradio的web app

用gradio做了个页面，可以上传图片后，对图片进行人脸检测，然后进行人脸推理，效果如下：

![在这里插入图片描述](/static/img/images/00064.png)






# 代码、训练、权重、帮助

如果想获取帮助：

```bash
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

背景

什么是傅里叶变换？什么是离散傅里叶变换？什么是拉普拉斯变换？

傅里叶级数与傅里叶变换

隐马尔可夫模型 (HMM)

马尔可夫链

背景

背景

背景

如何求解矩阵的特征向量

协方差

纯python

小波变换

贝叶斯概率

1 概率密度函数

1 香农墒 量化信息 信息量大小

1 香农墒量化信息信息量大小