ALPHA_101因子（01_25）

最新推荐文章于 2025-04-23 16:14:44 发布

ml......

最新推荐文章于 2025-04-23 16:14:44 发布

阅读量1k

点赞数

分类专栏：多因子

本文链接：https://blog.csdn.net/M977986310/article/details/125753106

版权

量化交易 Alpha因子金融数据统计逻辑交易策略

关键词由CSDN通过智能技术生成

多因子专栏收录该内容

3 篇文章

订阅专栏

本文介绍了25种不同的Alpha因子计算逻辑，这些逻辑涉及股票市场的价格、交易量、收益率等指标，用于构建量化交易策略。每个因子通过不同的数学运算和统计方法，如标准差、相关性、协方差等，捕捉股票价格变动的潜在信息。这些因子可用于预测股票表现，为投资决策提供依据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Alpha#1

计算逻辑：(rank(Ts_ArgMax(SignedPower(((returns < 0) ? stddev(returns, 20) : close), 2.), 5)) -0.5)

def alpha001(self):
    inner = copy.deepcopy(self.close)
    inner[self.returns < 0] = stddev(self.returns, 20)
    return rank(ts_argmax(inner ** 2, 5))

Alpha#2

计算逻辑：(-1 * correlation(rank(delta(log(volume), 2)), rank(((close - open) / open)), 6))

def alpha002(self):
    df = -1 * correlation(rank(delta(log(self.volume), 2)), rank((self.close - self.open) / self.open), 6)
    return df.replace([-np.inf, np.inf], 0).fillna(value=0)

Alpha#3

计算逻辑：(-1 * correlation(rank(open), rank(volume), 10))

def alpha003(self):
    df = -1 * correlation(rank(self.open), rank(self.volume), 10)
    return df.replace([-np.inf, np.inf], 0).fillna(value=0)

Alpha#4

计算逻辑：(-1 * Ts_Rank(rank(low), 9))

def alpha004(self):
      return -1 * ts_rank(rank(self.low), 9)

Alpha#5

计算逻辑：(rank((open - (sum(vwap, 10) / 10))) * (-1 * abs(rank((close - vwap)))))

def alpha005(self):
        return  (rank((self.open - (sum(self.vwap, 10) / 10))) * (-1 * abs(rank((self.close - self.vwap)))))

Alpha#6

计算逻辑：(-1 * correlation(open, volume, 10))

def alpha006(self):
        df = -1 * correlation(self.open, self.volume, 10)
        return df.replace([-np.inf, np.inf], 0).fillna(value=0)

Alpha#7

计算逻辑：((adv20 < volume) ? ((-1 * ts_rank(abs(delta(close, 7)), 60)) * sign(delta(close, 7))) : (-1 1))*

def alpha007(self):
        adv20 = sma(self.volume, 20)
        alpha = -1 * ts_rank(abs(delta(self.close, 7)), 60) * sign(delta(self.close, 7))
        alpha[adv20 >= self.volume] = -1
        return alpha

Alpha#8

计算逻辑：(-1 * rank(((sum(open, 5) * sum(returns, 5)) - delay((sum(open, 5) * sum(returns, 5)),10))))

def alpha008(self):
        return -1 * (rank(((ts_sum(self.open, 5) * ts_sum(self.returns, 5)) -
                           delay((ts_sum(self.open, 5) * ts_sum(self.returns, 5)), 10))))

Alpha#9

计算逻辑：((0 < ts_min(delta(close, 1), 5)) ? delta(close, 1) : ((ts_max(delta(close, 1), 5) < 0) ?delta(close, 1) : (-1 * delta(close, 1))))

def alpha009(self):
        delta_close = delta(self.close, 1)
        cond_1 = ts_min(delta_close, 5) > 0
        cond_2 = ts_max(delta_close, 5) < 0
        alpha = -1 * delta_close
        alpha[cond_1 | cond_2] = delta_close
        return alpha

Alpha#10

计算逻辑：rank(((0 < ts_min(delta(close, 1), 4)) ? delta(close, 1) : ((ts_max(delta(close, 1), 4) < 0)? delta(close, 1) : (-1 * delta(close, 1)))))

def alpha010(self):
        delta_close = delta(self.close, 1)
        cond_1 = ts_min(delta_close, 4) > 0
        cond_2 = ts_max(delta_close, 4) < 0
        alpha = -1 * delta_close
        alpha[cond_1 | cond_2] = delta_close
        return alpha

Alpha#11

*计算逻辑：((rank(ts_max((vwap - close), 3)) + rank(ts_min((vwap - close), 3))) rank(delta(volume, 3)))

def alpha011(self):
        return ((rank(ts_max((self.vwap - self.close), 3)) + rank(ts_min((self.vwap - self.close), 3))) *rank(delta(self.volume, 3)))

Alpha#12

计算逻辑：(sign(delta(volume, 1)) * (-1 * delta(close, 1)))

def alpha012(self):
        return sign(delta(self.volume, 1)) * (-1 * delta(self.close, 1))

Alpha#13

计算逻辑：(-1 * rank(covariance(rank(close), rank(volume), 5)))

def alpha013(self):
        return -1 * rank(covariance(rank(self.close), rank(self.volume), 5))

Alpha#14

计算逻辑：((-1 * rank(delta(returns, 3))) * correlation(open, volume, 10))

def alpha014(self):
        df = correlation(self.open, self.volume, 10)
        df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
        return -1 * rank(delta(self.returns, 3)) * df

Alpha#15

计算逻辑：(-1 * sum(rank(correlation(rank(high), rank(volume), 3)), 3))

def alpha015(self):
        df = correlation(rank(self.high), rank(self.volume), 3)
        df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
        return -1 * ts_sum(rank(df), 3)

Alpha#16

计算逻辑：(-1 * rank(covariance(rank(high), rank(volume), 5)))

def alpha016(self):
        return -1 * rank(covariance(rank(self.high), rank(self.volume), 5))

Alpha#17

*计算逻辑：(((-1 * rank(ts_rank(close, 10))) * rank(delta(delta(close, 1), 1))) rank(ts_rank((volume / adv20), 5)))

def alpha017(self):
        adv20 = sma(self.volume, 20)
        return -1 * (rank(ts_rank(self.close, 10)) *
                     rank(delta(delta(self.close, 1), 1)) *
                     rank(ts_rank((self.volume / adv20), 5)))

Alpha#18

计算逻辑：(-1 * rank(((stddev(abs((close - open)), 5) + (close - open)) + correlation(close, open,10))))

def alpha018(self):
        df = correlation(self.close, self.open, 10)
        df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
        return -1 * (rank((stddev(abs((self.close - self.open)), 5) + (self.close - self.open)) +
                          df))

Alpha#19

计算逻辑：((-1 * sign(((close - delay(close, 7)) + delta(close, 7)))) * (1 + rank((1 + sum(returns,250)))))

def alpha019(self):
        return ((-1 * sign((self.close - delay(self.close, 7)) + delta(self.close, 7))) *
                (1 + rank(1 + ts_sum(self.returns, 250))))

Alpha#20

计算逻辑：(((-1 * rank((open - delay(high, 1)))) * rank((open - delay(close, 1)))) * rank((open -delay(low, 1))))

def alpha020(self):
        return -1 * (rank(self.open - delay(self.high, 1)) *
                     rank(self.open - delay(self.close, 1)) *
                     rank(self.open - delay(self.low, 1)))

Alpha#21

计算逻辑：((((sum(close, 8) / 8) + stddev(close, 8)) < (sum(close, 2) / 2)) ? (-1 * 1) : (((sum(close,2) / 2) < ((sum(close, 8) / 8) - stddev(close, 8))) ? 1 : (((1 < (volume / adv20)) || ((volume /adv20) == 1)) ? 1 : (-1 * 1))))

def alpha021(self):
        cond_1 = sma(self.close, 8) + stddev(self.close, 8) < sma(self.close, 2)
        cond_2 = sma(self.volume, 20) / self.volume < 1
        alpha = pd.DataFrame(np.ones_like(self.close), index=self.close.index
                             )
        #        alpha = pd.DataFrame(np.ones_like(self.close), index=self.close.index,
        #                             columns=self.close.columns)
        alpha[cond_1 | cond_2] = -1
        return alpha

Alpha#22

计算逻辑：(-1 * (delta(correlation(high, volume, 5), 5) * rank(stddev(close, 20))))

def alpha022(self):
        df = correlation(self.high, self.volume, 5)
        df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
        return -1 * delta(df, 5) * rank(stddev(self.close, 20))

Alpha#23

计算逻辑：(((sum(high, 20) / 20) < high) ? (-1 * delta(high, 2)) : 0)

def alpha023(self):
        cond = sma(self.high, 20) < self.high
        alpha = pd.DataFrame(np.zeros_like(self.close),index=self.close.index,columns=['close'])
        alpha.at[cond,'close'] = -1 * delta(self.high[cond], 2).fillna(value=0)
        return alpha

Alpha#24

计算逻辑：((((delta((sum(close, 100) / 100), 100) / delay(close, 100)) < 0.05) ||((delta((sum(close, 100) / 100), 100) / delay(close, 100)) == 0.05)) ? (-1 * (close - ts_min(close,100))) : (-1 * delta(close, 3)))

def alpha024(self):
        cond = delta(sma(self.close, 100), 100) / delay(self.close, 100) <= 0.05
        alpha = -1 * delta(self.close, 3)
        alpha[cond] = -1 * (self.close - ts_min(self.close, 100))
        return alpha

Alpha#25

计算逻辑：rank(((((-1 * returns) * adv20) * vwap) * (high - close)))

def alpha025(self):
        adv20 = sma(self.volume, 20)
        return rank(((((-1 * self.returns) * adv20) * self.vwap) * (self.high - self.close)))