算法交易执行优化：VWAP、TWAP与降低交易成本的实战技巧

import numpy as np
import pandas as pd
from datetime import datetime

class VWAPExecution:
    def __init__(self, total_shares, time_horizon_minutes=390):  # 390分钟 = 6.5小时交易时间
        self.total_shares = total_shares
        self.time_horizon = time_horizon_minutes
        self.executed_shares = 0
        self.executed_value = 0.0
        
    def load_historical_volume_profile(self, days=20):
        """加载历史成交量分布"""
        # 模拟数据：通常开盘和收盘时段成交量较大
        base_profile = np.array([
            0.008, 0.012, 0.015, 0.018, 0.020,  # 开盘前30分钟
            0.015, 0.014, 0.013, 0.012, 0.011,  # 上午
            0.010, 0.010, 0.011, 0.012, 0.013,  # 午后
            0.015, 0.018, 0.022, 0.025, 0.030   # 收盘前1小时
        ])
        # 归一化
        return base_profile / base_profile.sum()
    
    def calculate_target_shares(self, current_minute, volume_profile):
        """计算当前时刻应完成的累计股数"""
        minutes_per_bucket = self.time_horizon / len(volume_profile)
        current_bucket = int(current_minute / minutes_per_bucket)
        
        if current_bucket >= len(volume_profile):
            return self.total_shares
        
        # 累计目标比例
        target_ratio = volume_profile[:current_bucket+1].sum()
        return self.total_shares * target_ratio
    
    def execute_order(self, current_minute, current_price, volume_profile):
        """执行订单逻辑"""
        target_shares = self.calculate_target_shares(current_minute, volume_profile)
        shares_to_execute = target_shares - self.executed_shares
        
        if shares_to_execute > 0:
            # 实际执行时还需考虑市场冲击和流动性
            self.executed_shares = target_shares
            self.executed_value += shares_to_execute * current_price
            
        return shares_to_execute

# 使用示例
vwap = VWAPExecution(total_shares=100000)
volume_profile = vwap.load_historical_volume_profile()

# 模拟交易
for minute in range(0, 390, 5):  # 每5分钟执行一次
    current_price = 10.0 + np.random.normal(0, 0.01)  # 模拟价格波动
    shares = vwap.execute_order(minute, current_price, volume_profile)
    if shares > 0:
        print(f"Minute {minute}: Execute {shares:.0f} shares at {current_price:.2f}")

class TWAPExecution:
    def __init__(self, total_shares, num_intervals=78):  # 78个5分钟间隔
        self.total_shares = total_shares
        self.num_intervals = num_intervals
        self.shares_per_interval = total_shares / num_intervals
        self.current_interval = 0
        
    def execute_order(self, current_price):
        """每个时间间隔执行固定数量"""
        if self.current_interval >= self.num_intervals:
            return 0
            
        self.current_interval += 1
        return self.shares_per_interval

# 更简单，但可能在不合适的时机交易

def optimal_execution_trajectory(total_shares, time_horizon, risk_aversion, volatility, impact_coefficient):
    """
    计算最优执行轨迹
    基于 Almgren-Chriss 模型
    """
    import math
    
    # 特征时间尺度
    tau = math.sqrt(impact_coefficient / (risk_aversion * volatility**2))
    
    # 最优执行速度（指数衰减）
    def execution_rate(t):
        if tau == float('inf'):
            return total_shares / time_horizon  # TWAP特殊情况
        return (total_shares / tau) * math.exp(-t / tau) / (1 - math.exp(-time_horizon / tau))
    
    # 生成执行计划
    times = np.linspace(0, time_horizon, 100)
    shares_remaining = [total_shares - integrate.quad(execution_rate, 0, t)[0] for t in times]
    
    return times, shares_remaining