cyqnt-trd 0.1.2__py3-none-any.whl → 0.1.7__py3-none-any.whl

cyqnt_trd/trading_signal/example_usage.py

@@ -13,6 +13,7 @@
 
 import sys
 import os
+import numpy as np
 
 # 尝试直接导入（当作为 package 安装时）
 try:
@@ -256,7 +257,7 @@ def example_5_alpha1_factor(data_path):
     
     factor_results = framework.test_factor(
         factor_func=alpha1_wrapper,
-        forward_periods=7,  # 未来7个周期
+        forward_periods=24,  # 未来7个周期
         min_periods=30,  # 至少需要30个周期（5+20+一些缓冲）
         factor_name="Alpha#1因子"
     )
@@ -269,6 +270,121 @@ def example_5_alpha1_factor(data_path):
     )
 
 
+def example_5_normalized_alpha1_factor(data_path):
+    """
+    示例5（归一化版本）: 使用归一化Alpha#1因子进行因子测试
+    """
+    print("\n" + "=" * 60)
+    print("示例5（归一化版本）: 使用归一化Alpha#1因子进行因子测试")
+    print("=" * 60)
+    print("\n因子说明：")
+    print("  - 公式: rank(Ts_ArgMax(SignedPower(((returns<0)?stddev(returns,20):close),2.),5))-0.5)")
+    print("  - 策略逻辑：对过去5天按照收盘价最高或下行波动率最高进行排名")
+    print("  - 下行波动率最高的一天离计算时间越近，越可以投资")
+    print("  - 收盘价最高离计算时间越近，越可以投资")
+    print("  - 标签：mean-reversion+momentum")
+    print("\n归一化说明：")
+    print("  - 计算当前周期和之前30个周期的因子值，进行归一化")
+    print("  - 使用Min-Max归一化将因子值映射到[-1, 1]区间")
+    print("  - 返回归一化后的当前因子值用于测试")
+    print()
+    
+    framework = BacktestFramework(data_path=data_path)
+    
+    # 归一化参数
+    lookback_periods = 30
+    min_required = 30  # alpha1_factor需要的最小周期数（保守估计）
+    
+    # 使用归一化Alpha#1因子进行测试
+    def normalized_alpha1_wrapper(data_slice):
+        """
+        归一化Alpha#1 因子包装函数
+        
+        计算当前周期和之前lookback_periods个周期的因子值，进行归一化后返回当前归一化因子值
+        """
+        # 需要至少min_required+lookback_periods+1行数据
+        # min_required用于计算因子，lookback_periods用于回看，+1用于当前周期
+        available_periods = len(data_slice) - min_required - 1
+        if available_periods < 2:
+            return 0.0  # 至少需要2个周期才能计算归一化
+        
+        # 自适应调整回看周期，但不能小于2
+        actual_lookback = min(lookback_periods, max(2, available_periods))
+        
+        try:
+            # 计算因子值：当前周期和之前actual_lookback个周期
+            factor_values = []
+            for i in range(actual_lookback + 1):
+                end_idx = len(data_slice) - i
+                start_idx = max(0, end_idx - min_required - 1)
+                if end_idx <= start_idx:
+                    factor_values.append(0.0)
+                    continue
+                
+                period_slice = data_slice.iloc[start_idx:end_idx]
+                try:
+                    factor_value = alpha1_factor(
+                        period_slice,
+                        lookback_days=5,
+                        stddev_period=20,
+                        power=2.0
+                    )
+                    if factor_value is not None:
+                        factor_values.append(factor_value)
+                    else:
+                        factor_values.append(0.0)
+                except Exception:
+                    factor_values.append(0.0)
+            
+            # 如果收集到的因子值不足，返回0
+            if len(factor_values) < 2:
+                return 0.0
+            
+            # 将因子值转换为numpy数组进行归一化
+            factor_array = np.array(factor_values)
+            
+            # Min-Max归一化：将值映射到[-1, 1]区间
+            # 如果所有值都相同，则归一化后都为0
+            factor_min = factor_array.min()
+            factor_max = factor_array.max()
+            
+            if factor_max == factor_min:
+                # 所有值相同，归一化后都为0
+                normalized_factors = np.zeros_like(factor_array)
+            else:
+                # Min-Max归一化到[-1, 1]区间
+                normalized_factors = 2 * (factor_array - factor_min) / (factor_max - factor_min) - 1
+            
+            # 返回当前归一化因子值（第一个，即当前周期）
+            return float(normalized_factors[0])
+            
+        except Exception:
+            return 0.0
+    
+    # 测试因子
+    print("开始测试归一化 Alpha#1 因子...")
+    print(f"  回看天数: 5")
+    print(f"  标准差周期: 20")
+    print(f"  幂次: 2.0")
+    print(f"  归一化回看周期数: {lookback_periods}")
+    print(f"  向前看周期: 24")
+    print()
+    
+    factor_results = framework.test_factor(
+        factor_func=normalized_alpha1_wrapper,
+        forward_periods=24,  # 未来24个周期
+        min_periods=65,  # 至少需要65个周期（30+30+5缓冲，确保有足够数据计算因子和归一化）
+        factor_name="归一化Alpha#1因子"
+    )
+    
+    # 打印结果并保存
+    save_dir = '/Users/user/Desktop/repo/cyqnt_trd/result'
+    framework.print_factor_results(
+        factor_results,
+        save_dir=save_dir
+    )
+
+
 def example_6_alpha1_signal(data_path):
     """
     示例6: 使用基于Alpha#1因子的信号策略进行回测
@@ -378,7 +494,7 @@ def example_7_normalized_alpha15_signal(data_path):
     backtest_results = framework.backtest_strategy(
         signal_func=normalized_alpha15_signal_wrapper,
         min_periods=65,  # 至少需要65个周期（30+30+5缓冲，确保有足够数据计算因子和归一化）
-        position_size=0.2,  # 每次使用20%的资金
+        position_size=0.8,  # 每次使用20%的资金
         initial_capital=10000.0,
         commission_rate=0.00001,  # 0.001%手续费
         take_profit=0.5,  # 止盈10%
@@ -411,14 +527,14 @@ def main():
     主函数：运行所有示例
     """
     # 取消注释想要运行的示例
-    data_path = "/Users/user/Desktop/repo/data_all/tmp/data/BTCUSDT_current/BTCUSDT_3m_2880_20251215_000000_20251221_000000_20251222_173038.json"
-    # example_1_use_factor()
+    data_path = "/Users/user/Desktop/repo/cyqnt_trd/tmp/data/ETHUSDT_futures/ETHUSDT_30m_1775_20251130_000000_20260105_235959_20260108_230726.json"
+    # example_1_use_factor(data_path)
     # example_2_use_signal(data_path)
-    # example_4_multi_factor()
+    # example_4_multi_factor(data_path)
     # example_3_factor_in_signal(data_path)
-    # example_5_alpha1_factor()  # Alpha#1因子测试
+    example_5_normalized_alpha1_factor(data_path)  # Alpha#1因子测试
     # example_6_alpha1_signal(data_path)  # 基于Alpha#1因子的策略回测
-    example_7_normalized_alpha15_signal(data_path)  # 基于归一化Alpha#15因子的策略回测
+    # example_7_normalized_alpha15_signal(data_path)  # 基于归一化Alpha#15因子的策略回测
     
     
     # print("\n提示：")

cyqnt_trd/trading_signal/factor/__init__.py

@@ -9,10 +9,33 @@
 # 导入所有因子
 from .ma_factor import ma_factor, ma_cross_factor
 from .rsi_factor import rsi_factor
+from .stochastic_factor import stochastic_k_factor
+from .cci_factor import cci_factor
+from .adx_factor import adx_factor
+from .ao_factor import ao_factor
+from .momentum_factor import momentum_factor
+from .macd_factor import macd_level_factor
+from .stochastic_tsi_factor import stochastic_tsi_fast_factor
+from .williams_r_factor import williams_r_factor
+from .bbp_factor import bbp_factor
+from .uo_factor import uo_factor
+from .ema_factor import ema_factor, ema_cross_factor
 
 __all__ = [
     'ma_factor',
     'ma_cross_factor',
     'rsi_factor',
+    'stochastic_k_factor',
+    'cci_factor',
+    'adx_factor',
+    'ao_factor',
+    'momentum_factor',
+    'macd_level_factor',
+    'stochastic_tsi_fast_factor',
+    'williams_r_factor',
+    'bbp_factor',
+    'uo_factor',
+    'ema_factor',
+    'ema_cross_factor',
 ]
 

cyqnt_trd/trading_signal/factor/adx_factor.py

@@ -0,0 +1,116 @@
+"""
+ADX（平均趋向指数）因子
+
+基于ADX指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def adx_factor(
+    data_slice: 'pd.DataFrame', 
+    period: int = 14,
+    adx_threshold: float = 25.0
+) -> float:
+    """
+    ADX因子
+    
+    当ADX高于阈值且+DI > -DI时看多，当ADX高于阈值且+DI < -DI时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period*2+1 行数据
+                   最后一行是当前数据点，前面 period*2 行是历史数据
+        period: ADX计算周期（默认14）
+        adx_threshold: ADX阈值，低于此值表示趋势较弱（默认25）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    if len(data_slice) < period * 2 + 1:
+        return 0.0
+    
+    # 计算True Range (TR)
+    tr_list = []
+    di_plus_list = []
+    di_minus_list = []
+    
+    # 需要period+1行数据来计算DI
+    for i in range(period):
+        if len(data_slice) < period + 1 + i:
+            return 0.0
+        
+        idx = -(period + 1 + i)
+        if idx == -1:
+            current_high = data_slice.iloc[-1]['high_price']
+            current_low = data_slice.iloc[-1]['low_price']
+            prev_close = data_slice.iloc[-2]['close_price']
+        else:
+            current_high = data_slice.iloc[idx]['high_price']
+            current_low = data_slice.iloc[idx]['low_price']
+            prev_close = data_slice.iloc[idx-1]['close_price']
+        
+        # True Range
+        tr1 = current_high - current_low
+        tr2 = abs(current_high - prev_close)
+        tr3 = abs(current_low - prev_close)
+        tr = max(tr1, tr2, tr3)
+        tr_list.append(tr)
+        
+        # Directional Movement
+        if idx == -1:
+            prev_high = data_slice.iloc[-2]['high_price']
+            prev_low = data_slice.iloc[-2]['low_price']
+        else:
+            prev_high = data_slice.iloc[idx-1]['high_price']
+            prev_low = data_slice.iloc[idx-1]['low_price']
+        
+        plus_dm = current_high - prev_high if current_high > prev_high else 0.0
+        minus_dm = prev_low - current_low if prev_low > current_low else 0.0
+        
+        # 如果plus_dm和minus_dm都大于0，取较大者，另一个设为0
+        if plus_dm > minus_dm:
+            minus_dm = 0.0
+        elif minus_dm > plus_dm:
+            plus_dm = 0.0
+        else:
+            plus_dm = 0.0
+            minus_dm = 0.0
+        
+        # 计算DI
+        if tr == 0:
+            di_plus = 0.0
+            di_minus = 0.0
+        else:
+            di_plus = 100.0 * plus_dm / tr
+            di_minus = 100.0 * minus_dm / tr
+        
+        di_plus_list.append(di_plus)
+        di_minus_list.append(di_minus)
+    
+    # 计算平滑后的TR、+DI和-DI（使用Wilder平滑）
+    atr = np.mean(tr_list)  # 简化：使用简单平均，实际应该用Wilder平滑
+    di_plus_smooth = np.mean(di_plus_list)
+    di_minus_smooth = np.mean(di_minus_list)
+    
+    # 计算DX
+    di_sum = di_plus_smooth + di_minus_smooth
+    if di_sum == 0:
+        dx = 0.0
+    else:
+        dx = 100.0 * abs(di_plus_smooth - di_minus_smooth) / di_sum
+    
+    # ADX是DX的移动平均（这里简化处理，实际应该用平滑的DX）
+    adx = dx
+    
+    # 根据ADX和DI关系返回因子
+    if adx < adx_threshold:
+        return 0.0  # 趋势不明显，中性
+    
+    if di_plus_smooth > di_minus_smooth:
+        return 1.0  # 上升趋势，看多
+    elif di_minus_smooth > di_plus_smooth:
+        return -1.0  # 下降趋势，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/ao_factor.py

@@ -0,0 +1,66 @@
+"""
+AO（动量震荡指标，Awesome Oscillator）因子
+
+基于AO指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def ao_factor(data_slice: 'pd.DataFrame') -> float:
+    """
+    AO（动量震荡指标）因子
+    
+    当AO为正值且上升时看多，为负值且下降时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 35 行数据（5+34）
+                   最后一行是当前数据点，前面 34 行是历史数据
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    # AO使用5期和34期的简单移动平均
+    short_period = 5
+    long_period = 34
+    
+    if len(data_slice) < long_period + 1:
+        return 0.0
+    
+    # 计算中位数价格 (Median Price = (High + Low) / 2)
+    median_prices = (data_slice['high_price'] + data_slice['low_price']) / 2.0
+    
+    # 计算短期和长期移动平均（不包括最后一行）
+    short_ma = median_prices.iloc[-short_period-1:-1].mean()
+    long_ma = median_prices.iloc[-long_period-1:-1].mean()
+    
+    # 当前AO值
+    ao_current = short_ma - long_ma
+    
+    # 计算上一期的AO值（需要更多历史数据）
+    if len(data_slice) < long_period + 2:
+        # 如果数据不足，只根据当前AO值判断
+        if ao_current > 0:
+            return 1.0
+        elif ao_current < 0:
+            return -1.0
+        else:
+            return 0.0
+    
+    short_ma_prev = median_prices.iloc[-short_period-2:-2].mean()
+    long_ma_prev = median_prices.iloc[-long_period-2:-2].mean()
+    ao_prev = short_ma_prev - long_ma_prev
+    
+    # 判断趋势
+    if ao_current > 0 and ao_current > ao_prev:
+        return 1.0  # 正值且上升，看多
+    elif ao_current < 0 and ao_current < ao_prev:
+        return -1.0  # 负值且下降，看空
+    elif ao_current > 0:
+        return 0.5  # 正值但未上升，轻微看多
+    elif ao_current < 0:
+        return -0.5  # 负值但未下降，轻微看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/bbp_factor.py

@@ -0,0 +1,68 @@
+"""
+BBP（牛熊力量，Bull Bear Power）因子
+
+基于BBP指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def _ema(data: np.ndarray, period: int) -> float:
+    """计算指数移动平均"""
+    if len(data) < period:
+        return np.mean(data)
+    
+    alpha = 2.0 / (period + 1.0)
+    ema = data[-period]
+    
+    for i in range(-period + 1, 0):
+        ema = alpha * data[i] + (1 - alpha) * ema
+    
+    return ema
+
+
+def bbp_factor(data_slice: 'pd.DataFrame', period: int = 13) -> float:
+    """
+    牛熊力量（BBP）因子
+    
+    当BBP为正值时看多，为负值时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period+1 行数据
+                   最后一行是当前数据点，前面 period 行是历史数据
+        period: EMA计算周期（默认13）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足）
+    """
+    if len(data_slice) < period + 1:
+        return 0.0
+    
+    # 获取收盘价
+    close_prices = data_slice['close_price'].values
+    
+    # 计算EMA
+    ema_value = _ema(close_prices, period)
+    
+    # 当前最高价和最低价
+    current_high = data_slice.iloc[-1]['high_price']
+    current_low = data_slice.iloc[-1]['low_price']
+    
+    # 计算牛熊力量
+    # Bull Power = High - EMA
+    # Bear Power = Low - EMA
+    bull_power = current_high - ema_value
+    bear_power = current_low - ema_value
+    
+    # BBP = Bull Power + Bear Power
+    bbp = bull_power + bear_power
+    
+    # 根据BBP值返回因子
+    if bbp > 0:
+        return 1.0  # 正值，看多
+    elif bbp < 0:
+        return -1.0  # 负值，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/cci_factor.py

@@ -0,0 +1,65 @@
+"""
+CCI（商品通道指数）因子
+
+基于CCI指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def cci_factor(
+    data_slice: 'pd.DataFrame', 
+    period: int = 20,
+    oversold: float = -100.0, 
+    overbought: float = 100.0
+) -> float:
+    """
+    CCI因子
+    
+    当CCI低于oversold时看多，高于overbought时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period+1 行数据
+                   最后一行是当前数据点，前面 period 行是历史数据
+        period: CCI计算周期（默认20）
+        oversold: 超卖阈值（默认-100）
+        overbought: 超买阈值（默认100）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    if len(data_slice) < period + 1:
+        return 0.0
+    
+    # 获取最近period+1行数据
+    high_prices = data_slice.iloc[-period-1:]['high_price'].values
+    low_prices = data_slice.iloc[-period-1:]['low_price'].values
+    close_prices = data_slice.iloc[-period-1:]['close_price'].values
+    
+    # 计算典型价格 (TP = (High + Low + Close) / 3)
+    tp = (high_prices + low_prices + close_prices) / 3.0
+    
+    # 当前典型价格
+    current_tp = tp[-1]
+    
+    # 计算过去period期的典型价格移动平均
+    sma_tp = np.mean(tp[:-1])
+    
+    # 计算平均偏差
+    mean_deviation = np.mean(np.abs(tp[:-1] - sma_tp))
+    
+    # 计算CCI
+    if mean_deviation == 0:
+        cci = 0.0  # 中性值
+    else:
+        cci = (current_tp - sma_tp) / (0.015 * mean_deviation)
+    
+    # 根据CCI值返回因子
+    if cci < oversold:
+        return 1.0  # 超卖，看多
+    elif cci > overbought:
+        return -1.0  # 超买，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/ema_factor.py

@@ -0,0 +1,102 @@
+"""
+EMA（指数移动平均线）因子
+
+基于EMA指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def _ema(data: np.ndarray, period: int) -> float:
+    """计算指数移动平均"""
+    if len(data) < period:
+        return np.mean(data)
+    
+    alpha = 2.0 / (period + 1.0)
+    ema = data[-period]
+    
+    for i in range(-period + 1, 0):
+        ema = alpha * data[i] + (1 - alpha) * ema
+    
+    return ema
+
+
+def ema_factor(data_slice: 'pd.DataFrame', period: int = 10) -> float:
+    """
+    EMA因子
+    
+    如果当前价格高于EMA，返回1（看多）
+    否则返回-1（看空）
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period+1 行数据
+                   最后一行是当前数据点，前面 period 行是历史数据
+        period: EMA周期（默认10，可选10/20/30/50/100/200）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足）
+    """
+    if len(data_slice) < period + 1:
+        return 0.0
+    
+    # 获取收盘价
+    close_prices = data_slice['close_price'].values
+    
+    # 计算EMA（不包括最后一行）
+    ema = _ema(close_prices[:-1], period)
+    
+    # 当前价格
+    current_price = data_slice.iloc[-1]['close_price']
+    
+    if current_price > ema:
+        return 1.0  # 看多
+    else:
+        return -1.0  # 看空
+
+
+def ema_cross_factor(
+    data_slice: 'pd.DataFrame', 
+    short_period: int = 10, 
+    long_period: int = 20
+) -> float:
+    """
+    EMA交叉因子
+    
+    当短期EMA上穿长期EMA时看多，下穿时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 long_period+2 行数据
+                   最后一行是当前数据点，前面 long_period+1 行是历史数据
+        short_period: 短期EMA周期（默认10）
+        long_period: 长期EMA周期（默认20）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足）
+    """
+    if len(data_slice) < long_period + 2:
+        return 0.0
+    
+    # 获取收盘价
+    close_prices = data_slice['close_price'].values
+    
+    # 计算当前周期的EMA（不包括最后一行）
+    short_ema_current = _ema(close_prices[:-1], short_period)
+    long_ema_current = _ema(close_prices[:-1], long_period)
+    
+    # 计算上一周期的EMA（不包括最后两行）
+    if len(data_slice) < long_period + 3:
+        return 0.0
+    
+    short_ema_prev = _ema(close_prices[:-2], short_period)
+    long_ema_prev = _ema(close_prices[:-2], long_period)
+    
+    # 上穿：之前短期EMA在长期EMA下方，现在在上方
+    if short_ema_prev <= long_ema_prev and short_ema_current > long_ema_current:
+        return 1.0  # 看多
+    # 下穿：之前短期EMA在长期EMA上方，现在在下方
+    elif short_ema_prev >= long_ema_prev and short_ema_current < long_ema_current:
+        return -1.0  # 看空
+    else:
+        return 0.0  # 中性
+