10种常用的量化策略

Henry的量化策略小作坊
683 阅读12分钟
  • 以下是使用 Python 实现十种量化交易策略的简要概述，具体实现可能因市场条件和数据质量而有所不同。

海龟交易策略

  • 基于唐奇安通道突破系统，买入价格突破20天高点，卖出突破20天低点，退出条件为10天低点或高点。
  • 示例：使用 yfinance 下载数据，计算20天和10天高低点，模拟交易信号。

均值回归策略

  • 假设价格会回归历史均值，买入低于移动平均线（MA）的价格，卖出高于MA的价格。
  • 示例：使用50天MA和标准差，设置上下带宽，生成买卖信号。

套利策略（配对交易）

  • 利用两个相关资产的价格差异，检查共整合性，交易价差偏离均值时买入低估资产，卖出高估资产。
  • 示例：使用ADF测试检查共整合，计算价差Z分数，设置交易阈值。

趋势跟踪策略

  • 跟随市场趋势，买入短期移动平均线（MA）上穿长期MA，卖出下穿时。
  • 示例：使用50天和200天MA，生成买卖信号，模拟交易回报。

统计套利策略

  • 类似于均值回归和配对交易，基于统计关系识别资产错价。
  • 示例：可参考均值回归和配对交易的实现。

事件驱动策略

  • 关注重大事件（如财报发布），在事件前后交易，基于预期价格变动。
  • 示例：假设有事件日期，提前一天买入，事件后一天卖出，计算回报。

量价分析策略

  • 通过价格和交易量变化预测趋势，买入价格上涨且成交量显著增加时，卖出价格下跌且成交量增加时。
  • 示例：计算每日价格和成交量变化，设置阈值生成信号。

质量轮动策略

  • 根据资产质量（如收益增长）轮换投资，定期选择表现最佳的资产或板块。
  • 示例：按月选择上月回报最高的板块，模拟投资轮换。

风险平价策略

  • 基于资产风险贡献分配资本，确保每个资产的风险贡献相等。
  • 示例：计算协方差矩阵，优化权重使风险贡献均衡。

CTA策略

  • 商品交易顾问策略，通常为趋势跟踪，适用于期货市场。
  • 示例：可参考趋势跟踪策略，调整为期货数据。

这些策略的实现需要进一步优化和风险管理，建议结合实际市场数据进行回测。

详细报告

以下是针对十种量化交易策略的详细实现指南，涵盖每个策略的核心原理、实现步骤和示例代码。这些策略基于历史价格数据和统计分析，适合量化交易初学者深入研究和优化。

1. 海龟交易策略

海龟交易策略是一种趋势跟随策略，基于唐奇安通道突破系统，旨在捕捉趋势性行情。其核心规则包括：

  • 进入规则：当价格突破过去20天最高点时买入；当价格跌破过去20天最低点时卖空。
  • 退出规则：多头头寸在价格跌破过去10天最低点时平仓；空头头寸在价格突破过去10天最高点时平仓。
  • 仓位管理：基于波动率（True Range，TR）计算单位仓位，初始风险为账户的1%，使用20天指数移动平均线（EMA）计算N（平均真实波幅）。

实现步骤：

  1. 下载历史价格数据，包括开盘价、高价、低价、收盘价和成交量。
  2. 计算每日True Range，公式为：TR = max(High - Low, |High - Previous Close|, |Low - Previous Close|)。
  3. 计算N为TR的20天EMA。
  4. 计算20天和10天的滚动高点和低点。
  5. 模拟交易：根据进入和退出规则生成信号，记录每笔交易的回报。

示例代码：

import pandas as pd
import yfinance as yf
import numpy as np

def true_range(df):
    df['tr'] = df.apply(lambda row: max(row['high'] - row['low'], 
                                      abs(row['high'] - df['close'].shift(1)), 
                                      abs(row['low'] - df['close'].shift(1))), axis=1)
    return df['tr']

def turtle_strategy(df):
    # 计算20天高点和低点（进入）
    df['20d_high'] = df['high'].rolling(20).max()
    df['20d_low'] = df['low'].rolling(20).min()
    # 计算10天低点和高点（退出）
    df['10d_low'] = df['low'].rolling(10).min()
    df['10d_high'] = df['high'].rolling(10).max()
    # 初始化仓位和回报
    position = 0
    entry_price = None
    returns = []
    for i in range(len(df)):
        if i < 19:  # 等待足够数据计算20天窗口
            continue
        if position == 0:
            if df['close'].iloc[i] > df['20d_high'].iloc[i]:
                position = 1  # 多头
                entry_price = df['close'].iloc[i]
            elif df['close'].iloc[i] < df['20d_low'].iloc[i]:
                position = -1  # 空头
                entry_price = df['close'].iloc[i]
        elif position == 1:
            if df['close'].iloc[i] < df['10d_low'].iloc[i]:
                position = 0
                exit_price = df['close'].iloc[i]
                returns.append((exit_price - entry_price) / entry_price)
        elif position == -1:
            if df['close'].iloc[i] > df['10d_high'].iloc[i]:
                position = 0
                exit_price = df['close'].iloc[i]
                returns.append((entry_price - exit_price) / entry_price)
    return returns

# 示例使用
df = yf.download('AAPL', start='2010-01-01', end='2020-12-31')
df['tr'] = true_range(df)
df['N'] = df['tr'].ewm(span=20).mean()
returns = turtle_strategy(df)
print(f"Total return: {np.prod(1 + np.array(returns)) - 1:.2%}")

2. 均值回归策略

均值回归策略假设资产价格会回归其历史均值，当价格偏离均值时进行反向操作。

  • 进入规则：当价格低于移动平均线（MA）或下轨带（MA - k*标准差）时买入；当价格高于上轨带时卖空。
  • 退出规则：多头在价格回到MA或上轨时平仓；空头在价格回到MA或下轨时平仓。

实现步骤：

  1. 计算50天简单移动平均线（SMA）和标准差。
  2. 设置上下带宽，例如MA ± 1倍标准差。
  3. 根据价格与带宽的关系生成买卖信号。

示例代码：

def mean_reversion_strategy(df, window=50, k=1):
    df['ma'] = df['close'].rolling(window).mean()
    df['std'] = df['close'].rolling(window).std()
    df['lower_band'] = df['ma'] - k * df['std']
    df['upper_band'] = df['ma'] + k * df['std']
    position = 0
    returns = []
    for i in range(len(df)):
        if i < window - 1:  # 等待足够数据
            continue
        if position == 0:
            if df['close'].iloc[i] < df['lower_band'].iloc[i]:
                position = 1  # 多头
                entry_price = df['close'].iloc[i]
            elif df['close'].iloc[i] > df['upper_band'].iloc[i]:
                position = -1  # 空头
                entry_price = df['close'].iloc[i]
        elif position == 1:
            if df['close'].iloc[i] > df['ma'].iloc[i]:
                position = 0
                exit_price = df['close'].iloc[i]
                returns.append((exit_price - entry_price) / entry_price)
        elif position == -1:
            if df['close'].iloc[i] < df['ma'].iloc[i]:
                position = 0
                exit_price = df['close'].iloc[i]
                returns.append((entry_price - exit_price) / entry_price)
    return returns

returns = mean_reversion_strategy(df)
print(f"Total return: {np.prod(1 + np.array(returns)) - 1:.2%}")

3. 套利策略（配对交易）

配对交易利用两个相关资产的价格差异，通过统计套利获利。

  • 共整合检查：使用ADF测试检查两个资产是否共整合。
  • 价差计算：通过线性回归计算价差，价差为资产1价格 - 回归系数 * 资产2价格。
  • 交易信号：当价差Z分数超过±2时，买入低估资产，卖出高估资产；当Z分数回到0附近时平仓。

实现步骤：

  1. 下载两个资产的历史价格数据。
  2. 使用statsmodels库进行ADF测试，检查共整合性。
  3. 计算价差和Z分数，设置交易阈值。

示例代码：

from statsmodels.tsa.stattools import coint
import numpy as np

def is_cointegrated(series1, series2):
    results = coint(series1, series2)
    return results[1] < 0.05

def get_hedge_ratio(series1, series2):
    results = coint(series1, series2)
    hedge_ratio = results[0]
    return hedge_ratio

def pairs_trading_strategy(df1, df2):
    if is_cointegrated(df1['close'], df2['close']):
        hedge_ratio = get_hedge_ratio(df1['close'], df2['close'])
        spread = df1['close'] - hedge_ratio * df2['close']
        spread_mean = spread.mean()
        spread_std = spread.std()
        z_score = (spread - spread_mean) / spread_std
        entry_threshold = 2
        exit_threshold = 0
        position = 0
        returns = []
        for i in range(len(spread)):
            if z_score.iloc[i] < -entry_threshold and position == 0:
                position = 1  # 多头df1，空头df2
                entry_price = spread.iloc[i]
            elif z_score.iloc[i] > entry_threshold and position == 0:
                position = -1  # 空头df1，多头df2
                entry_price = spread.iloc[i]
            elif (position == 1 and z_score.iloc[i] > exit_threshold) or (position == -1 and z_score.iloc[i] < -exit_threshold):
                position = 0
                exit_price = spread.iloc[i]
                if position == 1:
                    returns.append((exit_price - entry_price) / entry_price)
                else:
                    returns.append((entry_price - exit_price) / entry_price)
        return returns
    else:
        print("Assets are not cointegrated.")
        return []

df1 = yf.download('AAPL', start='2010-01-01', end='2020-12-31')
df2 = yf.download('MSFT', start='2010-01-01', end='2020-12-31')
returns = pairs_trading_strategy(df1, df2)
print(f"Total return: {np.prod(1 + np.array(returns)) - 1:.2%}")

4. 趋势跟踪策略

趋势跟踪策略通过跟随市场趋势获利，常用移动平均线交叉或MACD指标。

  • 移动平均线交叉：当短期MA上穿长期MA时买入，下穿时卖出。
  • 实现：使用50天和200天MA，生成买卖信号。

示例代码：

def trend_following_strategy(df, short_window=50, long_window=200):
    df['ma_short'] = df['close'].rolling(short_window).mean()
    df['ma_long'] = df['close'].rolling(long_window).mean()
    position = 0
    returns = []
    for i in range(len(df)):
        if i < long_window - 1:
            continue
        if df['ma_short'].iloc[i] > df['ma_long'].iloc[i] and position == 0:
            position = 1  # 买入
            entry_price = df['close'].iloc[i]
        elif df['ma_short'].iloc[i] < df['ma_long'].iloc[i] and position == 1:
            position = 0
            exit_price = df['close'].iloc[i]
            returns.append((exit_price - entry_price) / entry_price)
        elif df['ma_short'].iloc[i] < df['ma_long'].iloc[i] and position == 0:
            position = -1  # 卖空
            entry_price = df['close'].iloc[i]
        elif df['ma_short'].iloc[i] > df['ma_long'].iloc[i] and position == -1:
            position = 0
            exit_price = df['close'].iloc[i]
            returns.append((entry_price - exit_price) / entry_price)
    return returns

returns = trend_following_strategy(df)
print(f"Total return: {np.prod(1 + np.array(returns)) - 1:.2%}")

5. 统计套利策略

统计套利策略基于统计模型分析历史数据，寻找资产组合的价差偏离，构建多空头寸。

  • 实现：可参考均值回归和配对交易，基于统计关系生成信号。

6. 事件驱动策略

事件驱动策略关注公司并购、重组等重大事件，分析事件对股价影响制定交易策略。

  • 进入规则：在事件（如财报发布）前买入，事件后卖出。
  • 实现：假设有事件日期，提前一天买入，事件后一天卖出，计算回报。

示例代码：

import pandas as pd

def event_driven_strategy(df, event_dates, days_before=1, days_after=1):
    positions = []
    for date in event_dates:
        buy_date = pd.to_datetime(date) - pd.Timedelta(days=days_before)
        sell_date = pd.to_datetime(date) + pd.Timedelta(days=days_after)
        if buy_date in df.index and sell_date in df.index:
            entry_price = df.loc[buy_date, 'close']
            exit_price = df.loc[sell_date, 'close']
            return_rate = (exit_price - entry_price) / entry_price
            positions.append(return_rate)
    total_return = np.prod(1 + np.array(positions)) - 1
    return total_return

earnings_dates = ['2020-01-28', '2020-04-28', '2020-07-28', '2020-10-27']
total_return = event_driven_strategy(df, earnings_dates)
print(f"Total return: {total_return:.2%}")

7. 量价分析策略

量价分析策略通过研究价格、交易量和持仓量关系预测趋势。

  • 进入规则：价格上涨且成交量显著增加时买入；价格下跌且成交量增加时卖出。
  • 实现：计算每日价格和成交量变化，设置阈值生成信号。

示例代码：

def volume_price_strategy(df, price_threshold=0.01, volume_threshold=0.5):
    df['price_change'] = df['close'].pct_change()
    df['volume_change'] = df['volume'].pct_change()
    buy_signal = (df['price_change'] > price_threshold) & (df['volume_change'] > volume_threshold)
    sell_signal = (df['price_change'] < -price_threshold) & (df['volume_change'] > volume_threshold)
    position = 0
    returns = []
    for i in range(1, len(df)):
        if buy_signal.iloc[i] and position == 0:
            position = 1  # 买入
            entry_price = df['close'].iloc[i]
        elif sell_signal.iloc[i] and position == 1:
            position = 0
            exit_price = df['close'].iloc[i]
            returns.append((exit_price - entry_price) / entry_price)
        elif sell_signal.iloc[i] and position == 0:
            position = -1  # 卖空
            entry_price = df['close'].iloc[i]
        elif buy_signal.iloc[i] and position == -1:
            position = 0
            exit_price = df['close'].iloc[i]
            returns.append((entry_price - exit_price) / entry_price)
    return returns

returns = volume_price_strategy(df)
print(f"Total return: {np.prod(1 + np.array(returns)) - 1:.2%}")

8. 质量轮动策略

质量轮动策略根据资产质量评估，发现并投资被低估的高质量资产。

  • 进入规则：按月选择上月回报最高的板块或资产，轮换投资。
  • 实现：计算各板块月度回报，选择表现最佳的板块。

示例代码：

def quality_rotation_strategy(data, sectors):
    monthly_returns = {}
    for sector in sectors:
        monthly_returns[sector] = data[sector].resample('M').last().pct_change()
    positions = []
    current_month = None
    for month in monthly_returns[sectors[0]].index:
        if current_month is None:
            current_month = month
            continue
        prev_month = current_month
        current_month = month
        best_sector = max(sectors, key=lambda x: monthly_returns[x].loc[prev_month])
        positions.append(best_sector)
    return positions

sectors = ['XLK', 'XLY', 'XLP', 'XLE', 'XLF', 'XLI', 'XLB', 'XLV', 'XLU']
data = {sector: yf.download(sector, start='2010-01-01', end='2020-12-31')['close'] for sector in sectors}
positions = quality_rotation_strategy(data, sectors)
print("Selected positions:", positions)

9. 风险平价策略

风险平价策略通过平衡投资组合中各资产类别的风险贡献度，优化风险分布。

  • 进入规则：计算资产协方差矩阵，优化权重使每个资产的风险贡献相等。
  • 实现：使用scipy.optimize求解权重，满足风险贡献均衡。

示例代码：

import numpy as np
from scipy.optimize import fsolve

def risk_contributions(weights, cov):
    portfolio_vol = np.sqrt(weights @ cov @ weights.T)
    risk_contribution = (weights * np.sqrt(cov.diagonal())) / portfolio_vol
    return risk_contribution

def equal_risk_contribution(weights):
    rc = risk_contributions(weights, cov_matrix)
    return rc[0] - rc[1]

cov_matrix = np.array([[0.04, 0.02], [0.02, 0.09]])
weights_guess = np.array([0.5, 0.5])
weights = fsolve(equal_risk_contribution, weights_guess)
print("Risk parity weights:", weights)

10. CTA策略

CTA策略主要应用于期货和期权市场，通过追踪市场趋势制定决策。

  • 实现：类似于趋势跟踪策略，可使用移动平均线交叉或MACD指标，调整为期货数据。

示例代码：参考趋势跟踪策略部分，替换为期货数据。

总结

以上策略的实现基于Python和常用金融库（如yfinance、pandas、statsmodels），每个策略都有其适用场景和复杂性。建议结合实际市场数据进行回测，优化参数并加入风险管理措施以适应真实交易环境。

策略名称核心原理主要指标/方法示例数据源
龟交易策略趋势跟随，突破系统20天高低点，10天退出，N波动率yfinance (股票)
均值回归策略价格回归均值，买卖偏离带宽移动平均线，标准差带宽yfinance (股票)
套利策略（配对交易）利用资产价差，统计套利ADF测试，共整合，Z分数yfinance (两资产)
趋势跟踪策略跟随趋势，MA交叉50/200天MA交叉yfinance (股票)
统计套利策略基于统计关系，识别错价均值回归，配对交易yfinance (多资产)
事件驱动策略事件前后交易，基于预期价格变动事件日期，价格变动yfinance + 事件数据
量价分析策略价格和成交量关系预测趋势价格变化，成交量变化，阈值yfinance (股票)
质量轮动策略按质量轮换投资，基于表现或基本面月度回报，板块选择yfinance (板块指数)
风险平价策略风险贡献均衡，优化组合协方差矩阵，优化权重yfinance (多资产)
CTA策略趋势跟随，期货市场MA交叉，MACD，调整为期货yfinance (期货数据)
avatar
文章
阅读
粉丝