信噪比(Signal-to-Noise Ratio,SNR)是信号处理与量化交易中的核心概念,表示有用信号与背景噪声的强度比值。在通信工程、音频处理、图像处理、雷达系统和金融量化等多个领域中,SNR 都是衡量系统性能和信息提取能力的根本指标。理解 SNR 的本质及其在不同场景下的表现,对于设计高效的信号处理算法和量化交易策略至关重要。
SNR 的跨学科重要性体现在多个关键领域:
| 领域 | SNR 典型范围 | 核心挑战 | 常用提升手段 |
|---|---|---|---|
| 通信系统 | 0 ~ 30 dB | 信道衰减、干扰 | 编码、调制、均衡 |
| 音频处理 | -10 ~ 60 dB | 环境噪声、混响 | 谱减法、自适应滤波 |
| 图像处理 | 10 ~ 40 dB | 传感器噪声、压缩伪影 | 去噪算法、超分辨率 |
| 雷达系统 | -20 ~ 20 dB | 杂波、干扰 | 脉冲压缩、MTI |
| 金融量化 | -40 ~ -20 dB | 市场噪声、非平稳性 | 特征工程、正则化 |
不同领域对 SNR 的敏感度差异巨大。通信系统在 SNR > 10 dB 时即可实现可靠传输,而金融市场的有效信号往往淹没在比自身强 3-4 个数量级的噪声中,形成了独特的极低 SNR 环境。
其中 为信号功率, 为噪声功率。通常用分贝(dB)表示:
| 形式 | 定义 | 适用场景 |
|---|---|---|
| 功率 SNR | 通用,能量信号 | |
| 幅度 SNR | 时域分析, | |
| 电压 SNR | 电路分析,与幅度 SNR 等价 | |
| 能量 SNR | 有限能量信号,如脉冲 |
对于确定性信号 和噪声 ,功率定义为:
对于离散信号:
对于复数信号 ,功率为:
若 和 是独立同分布的零均值高斯过程,则:
其中 为实部或虚部的方差。
| 线性比值 | dB 值 | 含义 |
|---|---|---|
| 1 | 0 dB | 信号与噪声功率相等 |
| 2 | 3.01 dB | 信号功率翻倍 |
| 10 | 10 dB | 一个数量级 |
| 100 | 20 dB | 两个数量级 |
| 1000 | 30 dB | 三个数量级 |
| 0.1 | -10 dB | 噪声比信号强 10 倍 |
| 0.01 | -20 dB | 噪声比信号强 100 倍 |
| 0.001 | -30 dB | 噪声比信号强 1000 倍 |
在频域分析中,SNR 可以通过功率谱密度(PSD)表示:
其中 和 分别为信号和噪声的功率谱密度。总 SNR 为:
对于带宽为 的信号,若噪声为白噪声(功率谱密度 ):
匹配滤波器是最大化 SNR 的最优线性滤波器。对于已知信号 ,匹配滤波器的冲激响应为:
输出端最大 SNR 为:
其中 为信号能量, 为噪声功率谱密度。
相关检测器通过计算接收信号与已知信号的互相关来检测信号:
输出 SNR 与信号能量和噪声功率的关系:
滤波器是提升 SNR 的基本工具。根据信号和噪声的频谱特性,设计合适的滤波器可以有效分离信号和噪声。
维纳滤波器是最小均方误差(MMSE)意义下的最优线性滤波器。对于平稳随机过程,维纳滤波器的频率响应为:
维纳滤波器的关键特性:
卡尔曼滤波适用于非平稳信号和时变系统,通过状态空间模型递归估计:
其中 为卡尔曼增益,自动权衡预测和观测的可靠性:
为估计误差协方差, 为观测噪声协方差。卡尔曼滤波通过动态调整增益,在信号变化和噪声之间取得最优平衡。
通过分段平均降低方差:
自适应滤波器根据输入信号动态调整系数,适用于非平稳环境:
其中 为步长参数, 为误差信号。步长选择需要权衡收敛速度和稳态误差:
香农定理给出了信道容量的理论上限:
其中 为信道带宽, 为信噪比。关键启示:
| 调制方式 | 每符号比特数 | 所需 (BER=10⁻⁵) | 频谱效率 |
|---|---|---|---|
| BPSK | 1 | 9.6 dB | 1 bps/Hz |
| QPSK | 2 | 9.6 dB | 2 bps/Hz |
| 8-PSK | 3 | 13 dB | 3 bps/Hz |
| 16-QAM | 4 | 17 dB | 4 bps/Hz |
| 64-QAM | 6 | 23 dB | 6 bps/Hz |
| 256-QAM | 8 | 28 dB | 8 bps/Hz |
与 SNR 的关系:
其中 为比特率, 为带宽。
BPSK:
QPSK:
M-QAM:
信道编码可以显著降低达到相同误码率所需的 SNR:
| 编码方案 | 编码增益 (dB) | 复杂度 |
|---|---|---|
| 卷积码 (约束长度 7) | 5-6 | 中 |
| Turbo 码 | 8-10 | 高 |
| LDPC 码 | 10-12 | 中-高 |
| Polar 码 | 10-12 | 中 |
编码增益使得系统在更低 SNR 下可靠工作,是深空通信等功率受限场景的关键技术。
金融市场是典型的极低 SNR环境:
设资产收益率 可以分解为:
其中:
量化策略的 SNR 定义为:
实际中,年化夏普比率的平方与 SNR 成正比:
其中 为观测期数。
| 市场效率层级 | 信息集 | 预期 SNR | 策略类型 |
|---|---|---|---|
| 弱式有效 | 历史价格 | 极低 | 统计套利 |
| 半强式有效 | 公开信息 | 低 | 基本面量化 |
| 强式有效 | 所有信息 | 接近零 | 内幕交易(非法) |
随着市场效率提升,可提取的 SNR 逐渐降低。量化策略的本质是在特定信息集下寻找尚未被完全定价的信号。
| 资产类别 | 典型夏普比率 | 估算 SNR (dB) | 特征 |
|---|---|---|---|
| 股票(长期持有) | 0.3-0.5 | -20 ~ -15 | 高噪声,低信号 |
| 股票(统计套利) | 1.0-2.0 | -10 ~ -5 | 中频信号 |
| 期货(CTA) | 0.5-1.0 | -15 ~ -10 | 趋势信号 |
| 期权(波动率) | 0.3-0.8 | -18 ~ -12 | 复杂非线性 |
| 外汇(高频) | 0.1-0.3 | -25 ~ -20 | 极高噪声 |
| 加密货币 | -0.5-1.5 | -30 ~ -10 | 极端非平稳 |
在高频数据中,市场微观结构噪声成为主导:
其中 为有效价格, 为微观结构噪声。已实现波动率估计:
由于噪声的累积效应,高频采样会导致波动率估计发散。解决方法包括:
在极低 SNR 下,梯度协方差矩阵的主导方向不指向真正的 predictive signal,而是完美指向对噪音最敏感的方向。这导致:
Spectral Bias(谱偏置)是指神经网络倾向于优先学习目标函数的低频分量,而高频分量学习较慢的现象。在频域中,神经网络的训练动态可以描述为:
其中 为频率 处的学习速度,满足:
在极低 SNR 环境下,真正的预测信号往往对应高频分量(快速变化的 alpha),而噪声的低频分量被优先学习,导致模型拟合的是噪声而非信号。
在神经正切核(NTK)框架下,神经网络的训练动态可以近似为核回归:
其中 为 NTK 矩阵。NTK 的特征值分解揭示了学习速度的不均衡:
在极低 SNR 下,梯度协方差矩阵 的特征结构为:
由于噪声能量远大于信号, 的主导特征向量主要由噪声决定,导致优化方向偏离真实信号。
| 优化器 | 问题 | 在极低 SNR 下的表现 |
|---|---|---|
| SGD | 单一学习率 | 快速学习噪声模式 |
| Momentum | 动量累积 | 放大噪声方向的偏差 |
| Adam | 自适应学习率 | 对梯度幅值敏感,噪声主导 |
| RMSprop | 梯度平方平均 | 同样受噪声梯度影响 |
标准优化器的根本问题在于:它们假设梯度方向是信号的无偏估计。在极低 SNR 下,这一假设严重 violated,梯度方向实际上是噪声的有偏估计。
import numpy as np
from scipy import signal
def snr_filter_denoise(x, cutoff=0.1, fs=1.0, order=5):
"""
使用巴特沃斯滤波器去噪并计算 SNR
Parameters:
-----------
x : array_like
输入信号(含噪声)
cutoff : float
截止频率(归一化,0-1)
fs : float
采样频率
order : int
滤波器阶数
Returns:
--------
filtered : ndarray
滤波后信号
snr_before : float
滤波前 SNR (dB)
snr_after : float
滤波后 SNR (dB)
"""
# 设计巴特沃斯低通滤波器
nyquist = fs / 2
normal_cutoff = cutoff / nyquist
b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)
# 应用滤波器
filtered = signal.filtfilt(b, a, x)
# 估计噪声(假设高频为噪声)
noise = x - filtered
# 计算 SNR
signal_power = np.mean(filtered**2)
noise_power = np.mean(noise**2)
snr_before = 10 * np.log10(np.mean(x**2) / noise_power)
snr_after = 10 * np.log10(signal_power / noise_power)
return filtered, snr_before, snr_after
# 示例使用
if __name__ == "__main__":
# 生成测试信号
t = np.linspace(0, 10, 1000)
clean_signal = np.sin(2 * np.pi * 0.5 * t) # 0.5 Hz 正弦
noise = np.random.normal(0, 0.5, len(t))
noisy_signal = clean_signal + noise
filtered, snr_b, snr_a = snr_filter_denoise(noisy_signal, cutoff=0.8)
print(f"滤波前 SNR: {snr_b:.2f} dB")
print(f"滤波后 SNR: {snr_a:.2f} dB")
print(f"SNR 提升: {snr_a - snr_b:.2f} dB")
import pywt
def wavelet_denoise(x, wavelet='db4', level=3, threshold_mode='soft'):
"""
使用小波变换去噪
Parameters:
-----------
x : array_like
输入信号
wavelet : str
小波基函数
level : int
分解层数
threshold_mode : str
阈值模式 ('soft' 或 'hard')
Returns:
--------
denoised : ndarray
去噪后信号
"""
# 小波分解
coeffs = pywt.wavedec(x, wavelet, level=level)
# 计算阈值(Universal Threshold)
sigma = np.median(np.abs(coeffs[-1])) / 0.6745
threshold = sigma * np.sqrt(2 * np.log(len(x)))
# 阈值处理
new_coeffs = [coeffs[0]] # 保留近似系数
for detail in coeffs[1:]:
if threshold_mode == 'soft':
new_coeffs.append(pywt.threshold(detail, threshold, mode='soft'))
else:
new_coeffs.append(pywt.threshold(detail, threshold, mode='hard'))
# 重构信号
denoised = pywt.waverec(new_coeffs, wavelet)
return denoised[:len(x)]
from sklearn.feature_selection import mutual_info_regression
import pandas as pd
def select_high_snr_features(X, y, n_features=10):
"""
基于互信息选择高 SNR 特征
Parameters:
-----------
X : DataFrame
特征矩阵
y : Series
目标变量
n_features : int
选择特征数量
Returns:
--------
selected_features : list
选中的特征名
feature_scores : DataFrame
特征得分
"""
# 计算互信息(信号强度代理)
mi_scores = mutual_info_regression(X, y, random_state=42)
# 计算特征方差(噪声强度代理)
feature_variance = X.var()
# 计算 SNR 近似值
snr_approx = mi_scores / (feature_variance + 1e-10)
# 创建得分表
feature_scores = pd.DataFrame({
'feature': X.columns,
'mutual_info': mi_scores,
'variance': feature_variance,
'snr_approx': snr_approx
}).sort_values('snr_approx', ascending=False)
selected_features = feature_scores.head(n_features)['feature'].tolist()
return selected_features, feature_scores
| 变换方法 | 原理 | 适用场景 |
|---|---|---|
| 对数变换 | 压缩大值,稳定方差 | 收益序列 |
| 差分 | 去除趋势,平稳化 | 价格序列 |
| 标准化 | 零均值单位方差 | 多特征融合 |
| 主成分 | 去相关,集中能量 | 高维特征 |
| 非线性变换 | 揭示隐藏结构 | 特定模式 |
from sklearn.decomposition import PCA
def pca_denoise(X, n_components=None, variance_threshold=0.95):
"""
使用 PCA 降维去噪
Parameters:
-----------
X : array_like
输入数据 (n_samples, n_features)
n_components : int or float
保留成分数或方差比例
variance_threshold : float
保留方差比例(当 n_components 为 None 时)
Returns:
--------
X_denoised : ndarray
去噪后数据
pca : PCA object
PCA 模型
"""
if n_components is None:
n_components = variance_threshold
pca = PCA(n_components=n_components)
X_transformed = pca.fit_transform(X)
X_denoised = pca.inverse_transform(X_transformed)
return X_denoised, pca
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.linear_model import Ridge
import numpy as np
def ensemble_denoise_predict(X_train, y_train, X_test,
base_models=None, meta_model=None):
"""
使用集成学习降低噪声影响
Parameters:
-----------
X_train, y_train : array_like
训练数据
X_test : array_like
测试数据
base_models : list
基学习器列表
meta_model : estimator
元学习器
Returns:
--------
predictions : ndarray
集成预测结果
"""
if base_models is None:
base_models = [
('rf', RandomForestRegressor(n_estimators=100, random_state=42)),
('gb', GradientBoostingRegressor(n_estimators=100, random_state=42)),
('ridge', Ridge(alpha=1.0))
]
if meta_model is None:
meta_model = Ridge(alpha=1.0)
# 训练基学习器
base_predictions = []
for name, model in base_models:
model.fit(X_train, y_train)
pred = model.predict(X_test)
base_predictions.append(pred)
# 简单平均(也可以训练元学习器)
predictions = np.mean(base_predictions, axis=0)
return predictions
| 正则化方法 | 公式 | 作用 | 适用场景 |
|---|---|---|---|
| L1 (Lasso) | 稀疏化,特征选择 | 高维噪声 | |
| L2 (Ridge) | 收缩权重 | 多重共线性 | |
| Elastic Net | 结合 L1/L2 | 一般情况 | |
| Dropout | 随机失活神经元 | 防止共适应 | 深度学习 |
| 早停 | 验证集监控 | 防止过拟合 | 所有迭代算法 |
Preconditioner 是一种通过修改优化问题的几何结构来加速收敛的技术。在极低 SNR 环境下,其核心思想是均衡不同特征方向上的学习速度。
标准梯度下降:
Preconditioned 梯度下降:
其中 为预条件矩阵,通常取 Hessian 矩阵的近似或对角近似。
import numpy as np
def adam_w_preconditioner(grad, m, v, t, beta1=0.9, beta2=0.999,
eps=1e-8, lr=0.001, preconditioner=None):
"""
带预条件器的 Adam 优化器
Parameters:
-----------
grad : ndarray
当前梯度
m, v : ndarray
一阶和二阶矩估计
t : int
时间步
preconditioner : ndarray or None
预条件矩阵(对角)
Returns:
--------
update : ndarray
参数更新量
m, v : ndarray
更新后的矩估计
"""
# 更新矩估计
m = beta1 * m + (1 - beta1) * grad
v = beta2 * v + (1 - beta2) * (grad ** 2)
# 偏差修正
m_hat = m / (1 - beta1 ** t)
v_hat = v / (1 - beta2 ** t)
# 应用预条件器
if preconditioner is not None:
update = lr * preconditioner * m_hat / (np.sqrt(v_hat) + eps)
else:
update = lr * m_hat / (np.sqrt(v_hat) + eps)
return update, m, v
def compute_spectral_preconditioner(grad_history, n_eigen=10):
"""
基于梯度历史计算谱预条件器
Parameters:
-----------
grad_history : list of ndarray
梯度历史
n_eigen : int
保留的主成分数
Returns:
--------
preconditioner : ndarray
对角预条件器
"""
# 构建梯度协方差矩阵
G = np.array(grad_history)
cov = np.cov(G.T)
# 特征值分解
eigenvalues, eigenvectors = np.linalg.eigh(cov)
# 构建预条件器(提升小特征值方向的学习速度)
lambda_max = eigenvalues[-1]
preconditioner = np.ones(len(eigenvalues))
for i, lam in enumerate(eigenvalues):
if lam > 0:
# 逆特征值缩放
preconditioner[i] = np.sqrt(lambda_max / lam)
# 投影回参数空间
P = eigenvectors @ np.diag(preconditioner) @ eigenvectors.T
return np.diag(P)
在核方法中,核矩阵 的谱分析揭示了特征空间中的 SNR 分布:
其中 为特征值, 为特征函数。在核岭回归中,解可以表示为:
正则化参数 的选择直接影响不同频率分量的学习:
Spectrally-Aware 优化的核心目标是使所有特征方向上的有效学习速度相近:
通过调整预条件器或学习率调度,实现:
这使得小特征值方向(通常包含真正的预测信号)也能获得足够的学习速度。
动量策略基于价格趋势的持续性假设:
SNR 分析:
均值回归策略基于价格围绕均衡值波动的假设:
SNR 分析:
统计套利利用多资产价格的协整关系:
其中 为协整向量。SNR 分析:
| 差异来源 | 回测表现 | 实盘表现 | SNR 影响 |
|---|---|---|---|
| 过拟合 | 高估 | 正常 | 回测 SNR 虚高 5-10 dB |
| 市场冲击 | 忽略 | 显著 | 实盘 SNR 降低 3-5 dB |
| 滑点 | 理想 | 实际 | 高频策略降低 5-10 dB |
| 数据窥探 | 累积 | 无 | 回测 SNR 虚高 10+ dB |
| 幸存者偏差 | 存在 | 不存在 | 回测 SNR 虚高 2-3 dB |
| Regime 变化 | 单一 | 多样 | 实盘 SNR 波动大 |
关键教训:回测中的高 SNR 往往是幻觉,需要通过以下方法获得更真实的 SNR 估计:
def realistic_backtest_snr(returns, transaction_cost=0.001,
slippage=0.0005, market_impact=0.001):
"""
计算考虑实际交易成本的 SNR
Parameters:
-----------
returns : array_like
策略原始收益率序列
transaction_cost : float
单边交易成本
slippage : float
滑点成本
market_impact : float
市场冲击成本
Returns:
--------
realistic_snr : float
实际 SNR (dB)
"""
# 估计交易频率(简化)
turnover = np.mean(np.abs(np.diff(returns > 0).astype(int)))
# 总成本
total_cost = 2 * transaction_cost + slippage + market_impact * turnover
# 调整收益
adjusted_returns = returns - total_cost
# 计算实际 SNR
signal_power = np.mean(adjusted_returns) ** 2
noise_power = np.var(adjusted_returns)
realistic_snr = 10 * np.log10(signal_power / noise_power)
return realistic_snr
import numpy as np
from scipy import signal
from scipy.fft import fft, fftfreq
import matplotlib.pyplot as plt
class SNRToolkit:
"""SNR 计算与分析工具箱"""
@staticmethod
def calculate_snr(signal_data, noise_data=None, method='power'):
"""
计算 SNR
Parameters:
-----------
signal_data : array_like
信号数据(若 noise_data 为 None,则尝试分离)
noise_data : array_like, optional
噪声数据
method : str
计算方法 ('power', 'amplitude', 'db')
Returns:
--------
snr : float
信噪比(线性或 dB)
"""
if noise_data is None:
# 尝试用滤波分离信号和噪声
b, a = signal.butter(4, 0.1, 'low')
filtered = signal.filtfilt(b, a, signal_data)
noise_data = signal_data - filtered
signal_data = filtered
if method == 'power':
signal_power = np.mean(signal_data**2)
noise_power = np.mean(noise_data**2)
snr = signal_power / noise_power
elif method == 'amplitude':
signal_amp = np.sqrt(np.mean(signal_data**2))
noise_amp = np.sqrt(np.mean(noise_data**2))
snr = signal_amp / noise_amp
elif method == 'db':
signal_power = np.mean(signal_data**2)
noise_power = np.mean(noise_data**2)
snr = 10 * np.log10(signal_power / noise_power)
return snr
@staticmethod
def snr_spectrum(x, fs=1.0, nperseg=256):
"""
计算频域 SNR 谱
Parameters:
-----------
x : array_like
输入信号
fs : float
采样频率
nperseg : int
每段长度
Returns:
--------
freqs : ndarray
频率轴
snr_spectrum : ndarray
各频率点的 SNR
"""
# 计算功率谱密度
f, psd = signal.welch(x, fs, nperseg=nperseg)
# 估计噪声底(假设最低 10% 为噪声)
noise_floor = np.percentile(psd, 10)
# 计算 SNR 谱
snr_spec = psd / noise_floor
return f, snr_spec
@staticmethod
def plot_snr_analysis(x, fs=1.0, title="SNR Analysis"):
"""
可视化 SNR 分析
Parameters:
-----------
x : array_like
输入信号
fs : float
采样频率
title : str
图表标题
"""
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
# 时域信号
t = np.arange(len(x)) / fs
axes[0, 0].plot(t, x)
axes[0, 0].set_title('Time Domain Signal')
axes[0, 0].set_xlabel('Time (s)')
axes[0, 0].set_ylabel('Amplitude')
# 频域分析
freqs, snr_spec = SNRToolkit.snr_spectrum(x, fs)
axes[0, 1].semilogy(freqs, snr_spec)
axes[0, 1].set_title('SNR Spectrum')
axes[0, 1].set_xlabel('Frequency (Hz)')
axes[0, 1].set_ylabel('SNR (linear)')
axes[0, 1].axhline(y=1, color='r', linestyle='--', label='SNR=1')
axes[0, 1].legend()
# 功率谱密度
f, psd = signal.welch(x, fs)
axes[1, 0].semilogy(f, psd)
axes[1, 0].set_title('Power Spectral Density')
axes[1, 0].set_xlabel('Frequency (Hz)')
axes[1, 0].set_ylabel('PSD')
# SNR 直方图
snr_values = SNRToolkit.snr_spectrum(x, fs)[1]
axes[1, 1].hist(10 * np.log10(snr_values), bins=50, edgecolor='black')
axes[1, 1].set_title('SNR Distribution')
axes[1, 1].set_xlabel('SNR (dB)')
axes[1, 1].set_ylabel('Count')
plt.suptitle(title)
plt.tight_layout()
return fig
@staticmethod
def rolling_snr(x, window=100, step=10):
"""
计算滚动 SNR
Parameters:
-----------
x : array_like
输入信号
window : int
滚动窗口大小
step : int
步长
Returns:
--------
times : ndarray
时间点
snr_values : ndarray
滚动 SNR 值
"""
n = len(x)
times = []
snr_values = []
for i in range(0, n - window, step):
window_data = x[i:i+window]
# 用滤波分离信号和噪声
b, a = signal.butter(2, 0.1, 'low')
filtered = signal.filtfilt(b, a, window_data)
noise = window_data - filtered
signal_power = np.mean(filtered**2)
noise_power = np.mean(noise**2) + 1e-10
snr = 10 * np.log10(signal_power / noise_power)
times.append(i + window // 2)
snr_values.append(snr)
return np.array(times), np.array(snr_values)
# 使用示例
if __name__ == "__main__":
# 生成测试信号
fs = 1000
t = np.arange(0, 10, 1/fs)
# 合成信号:两个正弦 + 噪声
signal = (np.sin(2 * np.pi * 50 * t) +
0.5 * np.sin(2 * np.pi * 120 * t))
noise = 2 * np.random.randn(len(t))
x = signal + noise
# 使用工具箱
toolkit = SNRToolkit()
# 计算整体 SNR
snr_db = toolkit.calculate_snr(x, method='db')
print(f"Overall SNR: {snr_db:.2f} dB")
# 滚动 SNR
times, rolling_snr = toolkit.rolling_snr(x, window=500, step=100)
print(f"Rolling SNR range: {rolling_snr.min():.2f} to {rolling_snr.max():.2f} dB")
# 可视化
fig = toolkit.plot_snr_analysis(x, fs, "Test Signal SNR Analysis")
plt.savefig('/tmp/snr_analysis.png', dpi=150, bbox_inches='tight')
print("SNR analysis plot saved to /tmp/snr_analysis.png")
import pandas as pd
import numpy as np
def evaluate_strategy_snr(returns, benchmark_returns=None,
risk_free_rate=0.02):
"""
评估量化策略的 SNR 指标
Parameters:
-----------
returns : array_like
策略收益率序列(日度)
benchmark_returns : array_like, optional
基准收益率
risk_free_rate : float
年化无风险利率
Returns:
--------
metrics : dict
SNR 相关指标
"""
returns = np.array(returns)
# 年化因子
ann_factor = 252
# 基础统计
mean_return = np.mean(returns)
std_return = np.std(returns)
# 夏普比率(信号强度代理)
excess_return = mean_return - risk_free_rate / ann_factor
sharpe = excess_return / std_return * np.sqrt(ann_factor)
# 信息比率(相对基准)
if benchmark_returns is not None:
active_return = returns - benchmark_returns
tracking_error = np.std(active_return)
information_ratio = np.mean(active_return) / tracking_error * np.sqrt(ann_factor)
else:
information_ratio = None
# Sortino 比率(下行风险调整)
downside_returns = returns[returns < 0]
downside_std = np.std(downside_returns) if len(downside_returns) > 0 else 0
sortino = excess_return / downside_std * np.sqrt(ann_factor) if downside_std > 0 else np.inf
# Calmar 比率
cumulative = np.cumprod(1 + returns) - 1
max_drawdown = np.max(np.maximum.accumulate(cumulative) - cumulative)
calmar = np.mean(returns) * ann_factor / max_drawdown if max_drawdown > 0 else np.inf
# 估计 SNR
signal_power = mean_return ** 2
noise_power = std_return ** 2 - signal_power
snr = 10 * np.log10(signal_power / noise_power) if noise_power > 0 else np.inf
metrics = {
'mean_return_annual': mean_return * ann_factor,
'volatility_annual': std_return * np.sqrt(ann_factor),
'sharpe_ratio': sharpe,
'information_ratio': information_ratio,
'sortino_ratio': sortino,
'calmar_ratio': calmar,
'max_drawdown': max_drawdown,
'estimated_snr_db': snr,
'signal_power': signal_power,
'noise_power': noise_power
}
return metrics
# 示例:比较不同策略的 SNR
def compare_strategies_snr(strategy_returns_dict, benchmark=None):
"""
比较多个策略的 SNR 指标
Parameters:
-----------
strategy_returns_dict : dict
{strategy_name: returns_array}
benchmark : array_like, optional
基准收益率
Returns:
--------
comparison : DataFrame
策略对比表
"""
results = []
for name, returns in strategy_returns_dict.items():
metrics = evaluate_strategy_snr(returns, benchmark)
metrics['strategy'] = name
results.append(metrics)
comparison = pd.DataFrame(results)
comparison = comparison.set_index('strategy')
return comparison
| 方法 | 原理 | 效果 |
|---|---|---|
| 信号预处理 | 滤波去噪 | 提升 SNR 1-2 个数量级 |
| 特征选择 | 筛选高 SNR 特征 | 降低维度,集中信号 |
| 集成学习 | 多模型投票 | 噪声抵消 |
| Spectrally-Aware 优化 | 拉平谱上学习速度 | 让小特征值信号不被忽略 |
创建于:2026-06-11
更新于:2026-06-30
来源:栀染《量化交易的深度学习困境》