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

cyqnt_trd/trading_signal/factor/macd_factor.py

@@ -0,0 +1,97 @@
+"""
+MACD（移动平均收敛散度）因子
+
+基于MACD指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def _ema(data: np.ndarray, period: int) -> float:
+    """计算指数移动平均"""
+    if len(data) < period:
+        return np.mean(data)
+    
+    # 使用最后period个值计算EMA
+    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 macd_level_factor(
+    data_slice: 'pd.DataFrame', 
+    fast_period: int = 12, 
+    slow_period: int = 26
+) -> float:
+    """
+    MACD Level因子
+    
+    当MACD线在信号线上方时看多，在下方时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 slow_period+9 行数据
+                   最后一行是当前数据点，前面 slow_period+8 行是历史数据
+        fast_period: 快速EMA周期（默认12）
+        slow_period: 慢速EMA周期（默认26）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    # 需要足够的数据来计算MACD和信号线（信号线通常是9期EMA）
+    signal_period = 9
+    min_period = max(slow_period, fast_period) + signal_period
+    
+    if len(data_slice) < min_period + 1:
+        return 0.0
+    
+    # 获取收盘价
+    close_prices = data_slice['close_price'].values
+    
+    # 计算快速和慢速EMA
+    fast_ema = _ema(close_prices, fast_period)
+    slow_ema = _ema(close_prices, slow_period)
+    
+    # MACD线 = 快速EMA - 慢速EMA
+    macd_line = fast_ema - slow_ema
+    
+    # 计算MACD历史值以计算信号线
+    # 需要计算过去signal_period个时间点的MACD值
+    macd_values = []
+    for i in range(signal_period):
+        # 计算第i个历史时间点的MACD值
+        # 需要从当前时间点往前推i+1个周期
+        lookback = i + 1
+        if len(data_slice) < slow_period + lookback:
+            return 0.0
+        
+        # 获取到第i个历史时间点的数据（不包括当前时间点）
+        # 例如：i=0时，取data_slice[:-1]（不包括最后一行）
+        #      i=1时，取data_slice[:-2]（不包括最后两行）
+        close_subset = data_slice.iloc[:-(lookback)]['close_price'].values
+        if len(close_subset) < slow_period:
+            return 0.0
+        
+        fast_ema_val = _ema(close_subset, fast_period)
+        slow_ema_val = _ema(close_subset, slow_period)
+        macd_val = fast_ema_val - slow_ema_val
+        macd_values.append(macd_val)
+    
+    # 计算信号线（MACD的EMA）
+    if len(macd_values) < signal_period:
+        return 0.0
+    
+    signal_line = _ema(np.array(macd_values), signal_period)
+    
+    # 根据MACD和信号线的关系返回因子
+    if macd_line > signal_line:
+        return 1.0  # MACD在信号线上方，看多
+    elif macd_line < signal_line:
+        return -1.0  # MACD在信号线下方，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/momentum_factor.py

@@ -0,0 +1,44 @@
+"""
+Momentum（动量指标）因子
+
+基于动量指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def momentum_factor(data_slice: 'pd.DataFrame', period: int = 10) -> float:
+    """
+    动量指标因子
+    
+    当动量为正时看多，为负时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period+1 行数据
+                   最后一行是当前数据点，前面 period 行是历史数据
+        period: 动量计算周期（默认10）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足）
+    """
+    if len(data_slice) < period + 1:
+        return 0.0
+    
+    # 当前收盘价
+    current_close = data_slice.iloc[-1]['close_price']
+    
+    # period期前的收盘价
+    past_close = data_slice.iloc[-period-1]['close_price']
+    
+    # 计算动量
+    momentum = current_close - past_close
+    
+    # 根据动量值返回因子
+    if momentum > 0:
+        return 1.0  # 正动量，看多
+    elif momentum < 0:
+        return -1.0  # 负动量，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/stochastic_factor.py

@@ -0,0 +1,76 @@
+"""
+Stochastic（随机指标）因子
+
+基于Stochastic %K指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def stochastic_k_factor(
+    data_slice: 'pd.DataFrame', 
+    period: int = 14, 
+    k_smooth: int = 3, 
+    d_smooth: int = 3,
+    oversold: float = 20.0, 
+    overbought: float = 80.0
+) -> float:
+    """
+    Stochastic %K因子
+    
+    当Stochastic %K低于oversold时看多，高于overbought时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period+1 行数据
+                   最后一行是当前数据点，前面 period 行是历史数据
+        period: Stochastic计算周期（默认14）
+        k_smooth: %K平滑周期（默认3）
+        d_smooth: %D平滑周期（默认3，未使用但保留参数）
+        oversold: 超卖阈值（默认20）
+        overbought: 超买阈值（默认80）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    if len(data_slice) < period + k_smooth:
+        return 0.0
+    
+    # 计算Stochastic %K
+    # 需要period+k_smooth行数据来计算平滑后的%K
+    k_values = []
+    for i in range(k_smooth):
+        if len(data_slice) < period + i + 1:
+            return 0.0
+        
+        # 获取最近period+1行数据（包括当前点）
+        high_prices = data_slice.iloc[-period-i-1:]['high_price'].values
+        low_prices = data_slice.iloc[-period-i-1:]['low_price'].values
+        close_prices = data_slice.iloc[-period-i-1:]['close_price'].values
+        
+        # 计算最高价和最低价
+        highest_high = np.max(high_prices)
+        lowest_low = np.min(low_prices)
+        
+        # 当前收盘价
+        current_close = close_prices[-1]
+        
+        # 计算%K
+        if highest_high == lowest_low:
+            k = 50.0  # 中性值
+        else:
+            k = 100.0 * (current_close - lowest_low) / (highest_high - lowest_low)
+        
+        k_values.append(k)
+    
+    # 平滑%K（简单移动平均）
+    k_smoothed = np.mean(k_values)
+    
+    # 根据Stochastic %K值返回因子
+    if k_smoothed < oversold:
+        return 1.0  # 超卖，看多
+    elif k_smoothed > overbought:
+        return -1.0  # 超买，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/stochastic_tsi_factor.py

@@ -0,0 +1,129 @@
+"""
+Stochastic TSI（随机TSI）因子
+
+基于Stochastic TSI指标的交易因子
+"""
+
+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 stochastic_tsi_fast_factor(
+    data_slice: 'pd.DataFrame',
+    r_period: int = 3,
+    s_period: int = 3,
+    tsi_period1: int = 14,
+    tsi_period2: int = 14,
+    oversold: float = 20.0,
+    overbought: float = 80.0
+) -> float:
+    """
+    Stochastic TSI Fast因子
+    
+    当Stochastic TSI低于oversold时看多，高于overbought时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含足够的历史数据
+                   最后一行是当前数据点
+        r_period: %K平滑周期（默认3）
+        s_period: %D平滑周期（默认3）
+        tsi_period1: TSI第一个周期（默认14）
+        tsi_period2: TSI第二个周期（默认14）
+        oversold: 超卖阈值（默认20）
+        overbought: 超买阈值（默认80）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    # 需要足够的数据来计算TSI和Stochastic
+    min_period = tsi_period1 + tsi_period2 + max(r_period, s_period) + 10
+    
+    if len(data_slice) < min_period + 1:
+        return 0.0
+    
+    # 计算价格变化
+    close_prices = data_slice['close_price'].values
+    price_changes = np.diff(close_prices)
+    
+    # 计算TSI
+    # TSI = 100 * (EMA(EMA(price_change, period1), period2) / EMA(EMA(abs(price_change), period1), period2))
+    
+    # 计算第一个EMA
+    ema1_values = []
+    ema1_abs_values = []
+    
+    for i in range(len(price_changes) - tsi_period1 + 1):
+        subset = price_changes[i:i+tsi_period1]
+        ema1 = _ema(subset, tsi_period1)
+        ema1_values.append(ema1)
+        
+        abs_subset = np.abs(subset)
+        ema1_abs = _ema(abs_subset, tsi_period1)
+        ema1_abs_values.append(ema1_abs)
+    
+    if len(ema1_values) < tsi_period2:
+        return 0.0
+    
+    # 计算第二个EMA
+    ema2 = _ema(np.array(ema1_values[-tsi_period2:]), tsi_period2)
+    ema2_abs = _ema(np.array(ema1_abs_values[-tsi_period2:]), tsi_period2)
+    
+    # 计算TSI
+    if ema2_abs == 0:
+        tsi = 0.0
+    else:
+        tsi = 100.0 * ema2 / ema2_abs
+    
+    # 计算Stochastic TSI
+    # 需要r_period个TSI值来计算%K
+    tsi_history = []
+    for i in range(r_period):
+        if len(ema1_values) < tsi_period2 + i:
+            return 0.0
+        
+        ema2_val = _ema(np.array(ema1_values[-(tsi_period2 + i):-i if i > 0 else None]), tsi_period2)
+        ema2_abs_val = _ema(np.array(ema1_abs_values[-(tsi_period2 + i):-i if i > 0 else None]), tsi_period2)
+        
+        if ema2_abs_val == 0:
+            tsi_val = 0.0
+        else:
+            tsi_val = 100.0 * ema2_val / ema2_abs_val
+        
+        tsi_history.append(tsi_val)
+    
+    if len(tsi_history) < r_period:
+        return 0.0
+    
+    # 计算%K（Stochastic of TSI）
+    tsi_array = np.array(tsi_history)
+    highest_tsi = np.max(tsi_array)
+    lowest_tsi = np.min(tsi_array)
+    current_tsi = tsi_history[-1]
+    
+    if highest_tsi == lowest_tsi:
+        stoch_tsi = 50.0
+    else:
+        stoch_tsi = 100.0 * (current_tsi - lowest_tsi) / (highest_tsi - lowest_tsi)
+    
+    # 根据Stochastic TSI值返回因子
+    if stoch_tsi < oversold:
+        return 1.0  # 超卖，看多
+    elif stoch_tsi > overbought:
+        return -1.0  # 超买，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/uo_factor.py

@@ -0,0 +1,92 @@
+"""
+UO（终极震荡指标，Ultimate Oscillator）因子
+
+基于UO指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def uo_factor(
+    data_slice: 'pd.DataFrame',
+    period1: int = 7,
+    period2: int = 14,
+    period3: int = 28,
+    oversold: float = 30.0,
+    overbought: float = 70.0
+) -> float:
+    """
+    终极震荡指标（UO）因子
+    
+    当UO低于oversold时看多，高于overbought时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period3+1 行数据
+                   最后一行是当前数据点，前面 period3 行是历史数据
+        period1: 第一个周期（默认7）
+        period2: 第二个周期（默认14）
+        period3: 第三个周期（默认28）
+        oversold: 超卖阈值（默认30）
+        overbought: 超买阈值（默认70）
+    
+    Returns:
+        因子值：1.0（看多）、-1.0（看空）或 0（数据不足或中性）
+    """
+    if len(data_slice) < period3 + 1:
+        return 0.0
+    
+    # 计算Buying Pressure (BP) 和 True Range (TR)
+    bp_list = []
+    tr_list = []
+    
+    for i in range(period3):
+        if len(data_slice) < period3 - i + 1:
+            return 0.0
+        
+        idx = -(period3 - i + 1)
+        current_close = data_slice.iloc[idx]['close_price']
+        current_low = data_slice.iloc[idx]['low_price']
+        
+        if idx == -1:
+            prev_close = data_slice.iloc[-2]['close_price']
+            current_high = data_slice.iloc[-1]['high_price']
+        else:
+            prev_close = data_slice.iloc[idx-1]['close_price']
+            current_high = data_slice.iloc[idx]['high_price']
+        
+        # Buying Pressure = Close - min(Low, Previous Close)
+        bp = current_close - min(current_low, prev_close)
+        bp_list.append(bp)
+        
+        # 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)
+    
+    # 计算三个周期的平均值
+    bp1 = np.sum(bp_list[-period1:])
+    tr1 = np.sum(tr_list[-period1:])
+    avg1 = bp1 / tr1 if tr1 != 0 else 0.0
+    
+    bp2 = np.sum(bp_list[-period2:])
+    tr2 = np.sum(tr_list[-period2:])
+    avg2 = bp2 / tr2 if tr2 != 0 else 0.0
+    
+    bp3 = np.sum(bp_list[-period3:])
+    tr3 = np.sum(tr_list[-period3:])
+    avg3 = bp3 / tr3 if tr3 != 0 else 0.0
+    
+    # 计算UO（加权平均）
+    uo = 100.0 * (4.0 * avg1 + 2.0 * avg2 + avg3) / 7.0
+    
+    # 根据UO值返回因子
+    if uo < oversold:
+        return 1.0  # 超卖，看多
+    elif uo > overbought:
+        return -1.0  # 超买，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor/williams_r_factor.py

@@ -0,0 +1,60 @@
+"""
+Williams %R（威廉百分比变动）因子
+
+基于Williams %R指标的交易因子
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def williams_r_factor(
+    data_slice: 'pd.DataFrame', 
+    period: int = 14,
+    oversold: float = -80.0, 
+    overbought: float = -20.0
+) -> float:
+    """
+    Williams %R因子
+    
+    当Williams %R低于oversold时看多，高于overbought时看空
+    
+    Args:
+        data_slice: 数据切片，必须包含至少 period+1 行数据
+                   最后一行是当前数据点，前面 period 行是历史数据
+        period: Williams %R计算周期（默认14）
+        oversold: 超卖阈值（默认-80）
+        overbought: 超买阈值（默认-20）
+    
+    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
+    
+    # 计算最高价和最低价（不包括当前行）
+    highest_high = np.max(high_prices[:-1])
+    lowest_low = np.min(low_prices[:-1])
+    
+    # 当前收盘价
+    current_close = close_prices[-1]
+    
+    # 计算Williams %R
+    if highest_high == lowest_low:
+        williams_r = -50.0  # 中性值
+    else:
+        williams_r = -100.0 * (highest_high - current_close) / (highest_high - lowest_low)
+    
+    # 根据Williams %R值返回因子
+    if williams_r < oversold:
+        return 1.0  # 超卖，看多
+    elif williams_r > overbought:
+        return -1.0  # 超买，看空
+    else:
+        return 0.0  # 中性
+

cyqnt_trd/trading_signal/factor_details.json

@@ -0,0 +1,107 @@
+{
+  "ma_factor_5": "5期移动平均因子：当前价格高于过去5期平均价格时看多(1.0)，否则看空(-1.0)",
+  "ma_factor_10": "10期移动平均因子：当前价格高于过去10期平均价格时看多(1.0)，否则看空(-1.0)",
+  "rsi_factor_14": "14期RSI相对强弱指标因子：RSI低于30时看多(1.0)，高于70时看空(-1.0)，否则中性(0.0)",
+  "ma_cross_factor_5_20": "5日与20日移动平均交叉因子：短期均线上穿长期均线时看多(1.0)，下穿时看空(-1.0)，否则中性(0.0)",
+  "alpha1_factor": "Alpha#1因子：基于收益率与波动率的时序排名因子。当收益率为负时使用20期收益率标准差，否则使用收盘价，计算平方后的5期时序最大值位置排名",
+  "alpha2_factor": "Alpha#2因子：负相关因子，计算成交量对数2期差值的排名与收盘价相对开盘价变化排名的6期相关性，捕捉价量背离信号",
+  "alpha3_factor": "Alpha#3因子：负相关因子，计算开盘价排名与成交量排名的10期相关性，识别开盘价与成交量的反向关系",
+  "alpha4_factor": "Alpha#4因子：基于最低价的时序排名因子，计算最低价排名的9期时序排名，负值表示低价的相对位置",
+  "alpha5_factor": "Alpha#5因子：结合开盘价与VWAP关系的因子，计算开盘价相对10期VWAP均值的排名，乘以收盘价相对VWAP偏离度的排名",
+  "alpha6_factor": "Alpha#6因子：负相关因子，计算开盘价与成交量的10期相关性，捕捉开盘价与成交量的反向关系",
+  "alpha7_factor": "Alpha#7因子：条件因子，当20期平均成交量小于当前成交量时，计算收盘价7期差值的60期时序排名与价格变化方向的乘积，否则返回-1",
+  "alpha8_factor": "Alpha#8因子：基于开盘价与收益率乘积的因子，计算5期开盘价总和与5期收益率总和的乘积，减去10期延迟后的差值排名",
+  "alpha9_factor": "Alpha#9因子：价格变化方向因子，当5期内最小价格变化大于0或最大价格变化小于0时，返回价格变化值，否则返回负的价格变化值",
+  "alpha10_factor": "Alpha#10因子：价格变化方向的排名因子，当4期内最小价格变化大于0或最大价格变化小于0时，返回价格变化值，否则返回负的价格变化值，然后进行排名",
+  "alpha11_factor": "Alpha#11因子：VWAP与收盘价关系的因子，计算VWAP与收盘价差值的3期最大值和最小值的排名之和，乘以成交量3期差值的排名",
+  "alpha12_factor": "Alpha#12因子：价量关系因子，计算成交量1期差值的符号与收盘价1期差值的负值乘积，捕捉价量背离",
+  "alpha13_factor": "Alpha#13因子：负协方差排名因子，计算收盘价排名与成交量排名的5期协方差的排名，识别价量关系的反向变化",
+  "alpha14_factor": "Alpha#14因子：收益率变化与价量相关性因子，计算收益率3期差值的排名，乘以开盘价与成交量的10期相关性",
+  "alpha15_factor": "Alpha#15因子：负时序排名因子，计算最高价排名与成交量排名的3期相关性，然后对相关性进行排名，再计算3期时序排名总和",
+  "alpha16_factor": "Alpha#16因子：负协方差排名因子，计算最高价排名与成交量排名的5期协方差的排名，识别高价与成交量的反向关系",
+  "alpha17_factor": "Alpha#17因子：复合排名因子，计算收盘价10期时序排名的排名、收盘价二阶差值的排名、以及成交量相对20期平均成交量比值的5期时序排名的乘积",
+  "alpha18_factor": "Alpha#18因子：负排名因子，计算收盘价与开盘价差值的5期标准差加上价差，再加上收盘价与开盘价的10期相关性，然后进行排名",
+  "alpha19_factor": "Alpha#19因子：长期收益率因子，计算收盘价相对7期前价格变化与7期差值的符号，乘以1加上250期收益率总和的排名",
+  "alpha20_factor": "Alpha#20因子：开盘价相对位置因子，计算开盘价相对前一期最高价、收盘价、最低价差值的三个排名乘积",
+  "alpha21_factor": "Alpha#21因子：条件因子，当8期均价加标准差小于2期均价，或成交量相对20期平均成交量小于1时返回-1，否则返回1",
+  "alpha22_factor": "Alpha#22因子：负时序变化因子，计算最高价与成交量5期相关性的5期差值，乘以收盘价20期标准差的排名",
+  "alpha23_factor": "Alpha#23因子：条件因子，当20期最高价均值小于当前最高价时，返回最高价2期差值的负值，否则返回0",
+  "alpha24_factor": "Alpha#24因子：条件因子，当100期均价变化率小于等于5%时，返回收盘价与100期最低价差值的负值，否则返回收盘价3期差值的负值",
+  "alpha25_factor": "Alpha#25因子：复合排名因子，计算负收益率、20期平均成交量、VWAP、以及最高价与收盘价差值的乘积排名",
+  "alpha26_factor": "Alpha#26因子：基于价格与成交量关系的时序因子，捕捉价格变化与成交量变化的时序相关性",
+  "alpha27_factor": "Alpha#27因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha28_factor": "Alpha#28因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha29_factor": "Alpha#29因子：复合时序排名因子，计算收盘价5期差值的多重排名与对数缩放的时序最小值，加上负收益率6期延迟的5期时序排名",
+  "alpha30_factor": "Alpha#30因子：基于价格变化方向的排名因子，分析价格变化趋势的一致性",
+  "alpha31_factor": "Alpha#31因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha32_factor": "Alpha#32因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha33_factor": "Alpha#33因子：开盘价相对收盘价排名因子，计算开盘价与收盘价比值的排名，反映开盘相对收盘的位置",
+  "alpha34_factor": "Alpha#34因子：波动率与价格变化排名因子，计算收益率2期与5期标准差比值的排名，加上收盘价1期差值的排名，然后进行排名",
+  "alpha35_factor": "Alpha#35因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha36_factor": "Alpha#36因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha37_factor": "Alpha#37因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha38_factor": "Alpha#38因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha39_factor": "Alpha#39因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha40_factor": "Alpha#40因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha41_factor": "Alpha#41因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha42_factor": "Alpha#42因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha43_factor": "Alpha#43因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha44_factor": "Alpha#44因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha45_factor": "Alpha#45因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha46_factor": "Alpha#46因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha47_factor": "Alpha#47因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha48_factor": "Alpha#48因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha49_factor": "Alpha#49因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha50_factor": "Alpha#50因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha51_factor": "Alpha#51因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha52_factor": "Alpha#52因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha53_factor": "Alpha#53因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha54_factor": "Alpha#54因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha55_factor": "Alpha#55因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha56_factor": "Alpha#56因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha57_factor": "Alpha#57因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha58_factor": "Alpha#58因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha59_factor": "Alpha#59因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha60_factor": "Alpha#60因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha61_factor": "Alpha#61因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha62_factor": "Alpha#62因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha63_factor": "Alpha#63因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha64_factor": "Alpha#64因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha65_factor": "Alpha#65因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha66_factor": "Alpha#66因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha67_factor": "Alpha#67因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha68_factor": "Alpha#68因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha69_factor": "Alpha#69因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha70_factor": "Alpha#70因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha71_factor": "Alpha#71因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha72_factor": "Alpha#72因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha73_factor": "Alpha#73因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha74_factor": "Alpha#74因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha75_factor": "Alpha#75因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha76_factor": "Alpha#76因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha77_factor": "Alpha#77因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha78_factor": "Alpha#78因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha79_factor": "Alpha#79因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha80_factor": "Alpha#80因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha81_factor": "Alpha#81因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha82_factor": "Alpha#82因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha83_factor": "Alpha#83因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha84_factor": "Alpha#84因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha85_factor": "Alpha#85因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha86_factor": "Alpha#86因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha87_factor": "Alpha#87因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha88_factor": "Alpha#88因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha89_factor": "Alpha#89因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha90_factor": "Alpha#90因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha91_factor": "Alpha#91因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha92_factor": "Alpha#92因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha93_factor": "Alpha#93因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha94_factor": "Alpha#94因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha95_factor": "Alpha#95因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha96_factor": "Alpha#96因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha97_factor": "Alpha#97因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式",
+  "alpha98_factor": "Alpha#98因子：基于价格变化与成交量时序关系的因子，分析价格变化与成交量的时序动态",
+  "alpha99_factor": "Alpha#99因子：基于价格与成交量相关性的因子，识别价格与成交量的相关性模式",
+  "alpha100_factor": "Alpha#100因子：基于价格变化与成交量关系的因子，分析价格变化与成交量的动态关系",
+  "alpha101_factor": "Alpha#101因子：基于价格波动与成交量相关性的因子，识别价格波动与成交量的关系模式"
+}

cyqnt_trd/trading_signal/selected_alpha/alpha1.py

@@ -54,11 +54,13 @@ def alpha1_factor(
         quote_volume = data_slice.get('quote_volume', volume * close_price)  # 如果没有quote_volume，使用volume*close_price估算
         
         # 计算收益率
-        returns = close_price.pct_change().fillna(0)
+        returns = close_price.pct_change()
+        returns = returns.fillna(0).infer_objects(copy=False)
         
         # 计算VWAP (Volume Weighted Average Price)
         # vwap = quote_volume / volume，如果volume为0则使用close_price
-        vwap = (quote_volume / (volume + 1e-10)).fillna(close_price)
+        vwap = (quote_volume / (volume + 1e-10))
+        vwap = vwap.fillna(close_price).infer_objects(copy=False)
         
         # 计算adv20 (20日平均成交量)
         adv20 = sma(volume, 20)

cyqnt_trd/trading_signal/selected_alpha/alpha15.py

@@ -54,11 +54,13 @@ def alpha15_factor(
         quote_volume = data_slice.get('quote_volume', volume * close_price)  # 如果没有quote_volume，使用volume*close_price估算
         
         # 计算收益率
-        returns = close_price.pct_change().fillna(0)
+        returns = close_price.pct_change()
+        returns = returns.fillna(0).infer_objects(copy=False)
         
         # 计算VWAP (Volume Weighted Average Price)
         # vwap = quote_volume / volume，如果volume为0则使用close_price
-        vwap = (quote_volume / (volume + 1e-10)).fillna(close_price)
+        vwap = (quote_volume / (volume + 1e-10))
+        vwap = vwap.fillna(close_price).infer_objects(copy=False)
         
         # 计算adv20 (20日平均成交量)
         adv20 = sma(volume, 20)

cyqnt_trd/trading_signal/selected_alpha/generate_alphas.py

@@ -131,3 +131,4 @@ if __name__ == "__main__":
         print(f"Generated alpha{alpha_num}.py")
 
 
+