跳转至




2024

[1103] QuanTide Weekly

本周要闻

  • 英伟达和宣伟公司纳入道指
  • 制造业PMI时隔5个月重返景气区间
  • 三季报收官,8成上市公司实现盈利

下周看点

  • 周二:美国大选投票日(美东时间)
  • 周二:财新发布10月服务业PMI
  • 4日-8日,人常会:增量政策工具或将揭晓
  • 周六:统计局发布10月PPI/CPI

本周精选

  1. 一门三杰!一年翻十倍的男人发明了 UO 指标
  2. 世界就是一个波函数:直流分量差分因子获得15.%年化

  • 道琼斯指数发布公告,将英伟达和全球涂料供应商宣伟公司纳入道琼斯工业平均指数。英伟达将取代英特尔,宣伟将取代陶氏化学。
  • 统计局发布,10月份制造业PMI 50.1%,环比上升0.3。这是制造业PMI连续5个月运行在临界点以下后重新回到景气区间。
  • 统计数据显示,近八成上市公司前三季度实现盈利,近五成实现净利润正增长。消费品行业呈现明显修复态势,高技术制造业经营具有韧性,农林牧渔、非银金融、电子、社会服务等行业净利润增幅居前,同比增速达507%、42%、37%、30%。

  • 人大常会会11月4日至8日在北京举行,前期财政部提及的一次性新增债务额度和“不仅于此”的增量政策工具,或者将在本次会议上揭晓答案。

根据财联社、东方财富、证券时报等资讯汇编


一年十倍男发明了UO

Larry Williams,1987 年世界期货交易大赛冠军

指标 Ultimate Oscillator(终极振荡器)是由 Larry Williams 在 1976 年发表的技术分析因子。

Larry 是个牛人,不打嘴炮的那种。他发明了 William's R(即 WR)和 ultimate ocsillator 这样两个指标。著有《我如何在去年的期货交易中赢得百万美元》一书。他还是 1987 年世界期货交易大赛的冠军。在这场比赛中,他以 11.37 倍回报获得冠军。

更牛的是,在交易上,他们家可谓是一门三杰。


Michelle Williams

这是他女儿,michelle williams。她是知名女演员,出演过《断臂山》等名片,前后拿了 4 个奥斯卡最佳女配提名。更厉害的是,她在 1997 年也获得了世界期货交易大赛的冠军,同样斩获了 10 倍收益。在这个大赛的历史上,有这样收益的,总共只有三人,他们家占了俩。

这件事说明,老 williams 的一些交易技巧,历经 10 年仍然非常有效。

Larry Williams 的儿子是位心理医生,著有《交易中的心理优势》一书。近水楼台先得月,身边有两位世界冠军,确实不愁写作素材。


这是指标的计算公式。

\[ \text{True Low} = \min(\text{Low}, \text{Previous Close}) \\ \text{True High} = \max(\text{High}, \text{Previous Close}) \\ \text{BP} = \text{Close} - \text{True Low} \\ \text{True Range} = \text{True High} - \text{True Low} \\ \text{Average BP}_n = \frac{\sum_{i=1}^{n} BP_i}{\sum_{i=1}^nTR_i} \\ ULTOSC_t=\frac{4Avg_t(7) + 2Avg_t(14) + Avg_t(28)}{4+2+1} \times 100 \]

它旨在通过结合不同时间周期的买入压力来减少虚假信号,从而提供更可靠的超买和超卖信号。Ultimate Oscillator 考虑了三个不同的时间周期,通常为 7 天、14 天和 28 天,以捕捉短期、中期和长期的市场动量。

这个公式计算步骤比较多,主要有 true low, true high 和 true ange, bull power 等概念。

用这个图来解释会更清楚。


所谓的 true range,就是把前收也考虑进行,与当天的最高价、最低价一起,来求一个最大振幅。然后计算从 true low 到现价的一个涨幅,作为看涨力道(Bull Power)。

最后,用看涨力道除以真实波幅,再在一定窗口期内做平均,这样就得到了归一化的看涨力道均值。

最后,它结合长中短三个周期平均,生成最终的指标。

从构造方法来讲,它与 RSI 最重要的区别是,加入了 high 和 low 两个序列的数据。

做过交易的人知道,关键时刻最高价和最低价,都是多空博弈出来的,它是隐含了重要信息的。如果实时盯过盘口的人,可能感受更深。

像最高点,它是主力一口气向上吃掉多少筹码才拿到的这个最高点。上面的筹码吃不掉,最高价就定在这个地方。吃不掉的筹码是更大的资金的成本或者其它什么心理价位,就是未来的压力位

因此,ultimate oscillator 与 RSI 相比,是包含了更多的信息量的。希望这部分解读,能对大家今后探索因子起到一定的启迪作用。

这个图演示了实际中的 uo 指标,看起来是什么样的。从视觉上看起来,它跟 RSI 差不多,都是在一定区间震荡的。


这个因子在回测中的表现如何?在回测中,从 2018 年到 2023 年的 6 年中,它的 alpha 年化达到了 13.7%,表现还是很优秀的。

不过因子收益主要由做空贡献。大家看这张分层收益图,收益主要由第 1 层做空时贡献。在纯多的情况下,alpha 并不高,只有 1.6%,收益主要由 beta 贡献,所以组合收益的波动比较大。


所以,这个指标在期货上会更好使。

在多空组合下,6 年的收益达到了 2.2 倍。

最后我们看一下因子密度分布图。看上去很符合正态分布,尽显对称之美。

从分层均值收益图来看,我们在交易中还可以做一点小小的优化,就是淘汰第8层之上的因子。这样调优之后,在2018年到2022年间,年化Alpha达到了24%,5年累计收益达到了2.75倍。


我们保留了2023年的数据作为带外数据供测试。在这一年的回测中,年化Alpha达到了13%,表明并没有出现过拟合。2023年的累计收益曲线如下:

同期沪指是以下跌为主。8月底开启的上涨,在时间上与DMA策略上涨巧合了。


世界就是一个波函数

从直觉上看,使用波谱分析的方法来构建因子非常自然。因为经济是有周期的,交易更是有周期的。不过在量化交易中运用波谱分析,有它的难度。

以人声的波谱分析来说,它的频率有着固定的范围,能量也有固定的范围,换句话说,它们是平稳序列。但证券价格不是。我们多次讲过这个观点,股票价格是震荡向上的随机序列,只要国家经济还在发展,因此它不是平稳的。

但我们总能找到一种方法来分析问题。

波谱变换

我们先简单地介绍波谱变换。

1
2
3
4
5
6
7
8
fft_result = np.fft.fft(close)
freqs = np.fft.fftfreq(len(close))

# 逆傅里叶变换
filtered = fft_result.copy()
filtered[20:] = 0
inverse_fft = np.fft.ifft(filtered)
inversed = pd.Series(inverse_fft.real, index=close.index)

1
2
3
4
5
# 绘制原始信号和分解后的信号
plt.figure(figsize=(14, 7))
plt.plot(close, label='Original Close')
plt.plot(inversed, label='Reconstructed from Sine Waves')
plt.legend()

第一行代码是将时间序列变换成频谱,也就是所谓的时频变换。变换后的结果是一个复数数组,其中实部是频谱,虚部是频谱的偏移。

该数组是按频率由小大到排列的,也就是数组的开始部分是低频信号,结尾部分是高频信号。元素的取值是该信号的能量。一般我们把高频信号当成时噪声。 在这个数组当中零号元素有特殊的含义,它的频率是零赫兹,也就是它是一种直流分量。

第一行是生成频率的代码。注意它只与时间序列本身的长度有关系。也就是一个序列如果长度为30个时间单位,那么我们认为它的最高频率是30次。至于该频率实际上有没有信号,要看前一个数组对应位置的数值,如果是非零,就认为该频率的波存在。

第6~第8行是对转换后的频率信号进行简单处理。我们将20号以后的数组元素置为零。这样就实现了滤波。

然后我们通过ifft将处理后的信号逆变换回来,再重建时间序列。


我们看到图像更平滑了。所以这也是一种均线平滑的方法。好,关于FFT我们就介绍到这里。

直流分量的解释

现在我们思考一个问题,将价格序列进行时频变换后,得到的直流分量,意味着什么?

这里有一个猜想,如果我们把一次振动看成一次交易 -- 买入时导致股价上升,卖出时导致股价下跌回到起点 -- 这就是一种振动,对吧?

那么,高频振动就对应着高频交易,低频振动就对应着低频交易。如果在该窗口期没有做任何交易的资金,它们就是长线资金,是信号中的直流分量。直流分量的能量越大,高频振动的能量越小,股价就越稳定。

现在,我们再进一步思考,如果在t0期直流分量的能量为e0,在t1期的能量变为e1,那么,两者的差值意味着什么?


这就意味着有新的长线资金(超过窗口期)进来了。那么,股价就应该看涨。

直流分量差分因子

这个因子的原理是把股价当成一种波动,对它按30天为滑动窗口,进行波谱分析,提取直流分量(即频率为0的分量)的差分作为因子。

1
2
3
4
5
6
7
def calc_wave_energy(df, win):
    close = df.close / df.close[0]
    dc = close.rolling(win).apply(lambda x: np.fft.fft(x)[0])
    return-1 * dc.diff()

np.random.seed(78)
_ = alphatest(2000, start, end, calc_factor=calc_wave_energy, args=(30,), top=9)

这是年化Alpha,很意外我们就得到了17%的年化:

1D 5D 10D
Ann. alpha 0.170 0.144 0.114
beta 0.022 0.030 0.040
Mean Period Wise Return Top Quantile (bps) 2.742 2.512 2.042
Mean Period Wise Return Bottom Quantile (bps) -9.614 -8.516 -7.270
Mean Period Wise Spread (bps) 12.355 11.178 9.473

我们再来看分层收益均值图。我们从未得到过如此完美的图形。它简直就像是合成出来的。


近20年累计收益17.5倍。

在《因子分析与机器学习》课程中,我们批露了更多高效率因子,并且深入浅出地讲解了因子分析和机器学习构建量化交易策略的原理,快来一起学习吧。

一门三杰 一年翻十倍的男人发明了 UO 指标

Larry Williams,1987 年世界期货交易大赛冠军

指标 Ultimate Oscillator(终极振荡器)是由 Larry Williams 在 1976 年发表的技术分析因子。

Larry 是个牛人,不打嘴炮的那种。他发明了 William's R(即 WR)和 ultimate ocsillator 这样两个指标。著有《我如何在去年的期货交易中赢得百万美元》一书。他还是 1987 年世界期货交易大赛的冠军。在这场比赛中,他以 11.37 倍回报获得冠军。

更牛的是,在交易上,他们家可谓是一门三杰。

这是他女儿,michelle williams。她是知名女演员,出演过《断臂山》等名片,前后拿了 4 个奥斯卡最佳女配提名。更厉害的是,她在 1997 年也获得了世界期货交易大赛的冠军,同样斩获了 10 倍收益。在这个大赛的历史上,有这样收益的,总共只有三人,他们家占了俩。

这件事说明,老 williams 的一些交易技巧,历经 10 年仍然非常有效。

Larry Williams 的儿子是位心理医生,著有《交易中的心理优势》一书。近水楼台先得月,身边有两位世界冠军,确实不愁写作素材。

这是指标的计算公式。

\[ \text{True Low} = \min(\text{Low}, \text{Previous Close}) \\ \text{True High} = \max(\text{High}, \text{Previous Close}) \\ \text{BP} = \text{Close} - \text{True Low} \\ \text{True Range} = \text{True High} - \text{True Low} \\ \text{Average BP}_n = \frac{\sum_{i=1}^{n} BP_i}{\sum_{i=1}^nTR_i} \\ ULTOSC_t=\frac{4Avg_t(7) + 2Avg_t(14) + Avg_t(28)}{4+2+1} \times 100 \]

它旨在通过结合不同时间周期的买入压力来减少虚假信号,从而提供更可靠的超买和超卖信号。Ultimate Oscillator 考虑了三个不同的时间周期,通常为 7 天、14 天和 28 天,以捕捉短期、中期和长期的市场动量。

这个公式计算步骤比较多,主要有 true low, true high 和 true ange, bull power 等概念。

用这个图来解释会更清楚。

所谓的 true range,就是把前收也考虑进行,与当天的最高价、最低价一起,来求一个最大振幅。然后计算从 true low 到现价的一个涨幅,作为看涨力道(Bull Power)。

最后,用看涨力道除以真实波幅,再在一定窗口期内做平均,这样就得到了归一化的看涨力道均值。

最后,它结合长中短三个周期平均,生成最终的指标。

从构造方法来讲,它与 RSI 最重要的区别是,加入了 high 和 low 两个序列的数据。

做过交易的人知道,关键时刻最高价和最低价,都是多空博弈出来的,它是隐含了重要信息的。如果实时盯过盘口的人,可能感受更深。

像最高点,它是主力一口气向上吃掉多少筹码才拿到的这个最高点。上面的筹码吃不掉,最高价就定在这个地方。吃不掉的筹码是更大的资金的成本或者其它什么心理价位,就是未来的压力位

因此,ultimate oscillator 与 RSI 相比,是包含了更多的信息量的。希望这部分解读,能对大家今后探索因子起到一定的启迪作用。

这个图演示了实际中的 uo 指标,看起来是什么样的。从视觉上看起来,它跟 RSI 差不多,都是在一定区间震荡的。

这个因子在回测中的表现如何?在回测中,从 2018 年到 2023 年的 6 年中,它的 alpha 年化达到了 13.7%,表现还是很优秀的。

不过因子收益主要由做空贡献。大家看这张分层收益图,收益主要由第 1 层做空时贡献。在纯多的情况下,alpha 并不高,只有 1.6%,收益主要由 beta 贡献,所以组合收益的波动比较大。

所以,这个指标在期货上会更好使。

在多空组合下,6 年的收益达到了 2.2 倍。

最后我们看一下因子密度分布图。看上去很符合正态分布,尽显对称之美。

从分层均值收益图来看,我们在交易中还可以做一点小小的优化,就是淘汰第8层之上的因子。这样调优之后,在2018年到2022年间,年化Alpha达到了24%,5年累计收益达到了2.75倍。

我们保留了2023年的数据作为带外数据供测试。在这一年的回测中,年化Alpha达到了13%,表明并没有出现过拟合。2023年的累计收益曲线如下:

同期沪指是以下跌为主。8月底开启的上涨,在时间上与DMA策略上涨巧合了。

完整测试代码加入星球后即可获取。

[1027] QuanTide Weekly

本周要闻

  • 财政部:中国还将加大财政政策逆周期调节力度
  • 统计局:1-9月全国规上工业利润下降3.5%
  • 纽交所计划延长美股交易时间。

下周看点

  • 周一:医保目录现场谈判开始
  • 周四:统计局发布10月PMI
  • 美股Q3财报季下周将迎来最繁忙的一周

本周精选

  • 连载!量化人必会的 Numpy 编程(8) - 暴力美学,无洗盘,不拉升。洗盘模式如何检测?(应用案例5)

  • 10月25日,世行举行发展委员会第110次会议。财政部副部长廖岷表示,中国还将加大财政政策逆周期调节力度,在化解地方政府债务、稳定房地产市场、提高重点群体收入、保障民生、推动设备更新和消费品以旧换新等方面实施一系列强有力措施。中国有信心实现5%增长目录(财政部网站)
  • 1—9月份,全国规模以上工业企业实现利润总额52281.6亿元 同比下降3.5%。
  • 今日2024年医保目录现场谈判/竞价正式拉开帷幕,医保局工作人员现场点名华润医药、百特药业、康缘药业、康哲药业、宜昌人福、正大天晴等在内十余家多家企业先后进场,节奏明显快于去年。
  • 北交所分别举办券商、上市公司两场专项座谈会,会议提出,北交所将推动提高企业运用并购重组工具的能力,促进提高北交所上市公司质量和投资价值
  • 三季度中央汇金大举增持多只宽基ETF 仅4只沪深300ETF和华夏上证50ETF就耗资3000亿元
  • 纽交所计划延长美股交易时间至每个工作日22小时。

来源:财联社网站


暴力美学!无洗盘,不拉升。洗盘模式如何检测?

无洗盘,不拉升。 筹码收集阶段,股价呈现出上涨形态,也吸引到许多不坚定的跟风盘,它们将成为主升过程中的不利因素。

因此,在拉升之前,主力会采用洗盘的方式,将这些不坚定的低价筹码洗下车。这个过程中往往暴涨暴跌,犹如一匹烈马,要摆脱它身上的骑手一样。

暴力洗盘,某种程度上就成为了行情快速上涨之前的信号之一。

这篇文章,我们量化实现的技术问题:如何快速检测出洗盘模式?

L50

暴力洗盘是在证券市场上观察到的一种经验模式,因此没有严格的定义。一般把两阳夹一阴、且涨跌幅都巨大的情况认为是暴力洗盘。

在本文中我们把两阳夹两阴、且涨跌幅都较大的情况定义为暴力洗盘。


但我们介绍的方法,也完全适用于其它模式,只需要微调参数即可。

如左图所示,标的在1号位置之前,经过一段时间的吸筹,由于期间股价上涨,已经吸引了一些跟风盘。主力在1号位置拉出20cm,在这一过程中,较多跟风筹码被锁定在涨停位置。

第2天起主力开始洗盘,连续两天,分别下跌14.4%和18.9%。此时在1号位置买入的筹码因为忍受不住巨大的跌幅,忍痛交出筹码。主力筹码增加,成本降低,为后面的拉升留出了空间。

第4天主力将个股拉涨9.4%,表明洗盘结束。

随后几天的整理,主要是留出时间,让下一波的跟风盘有时间发现这支标的,并且有信心跟随买入。紧接着使用一系列小阳线做出上升趋势,最终再拉出一个20cm,从第4天起,短期涨幅高达87%。

我们为什么要使用两阳夹两阴的4天模式来定义洗盘?

因为经过两天的洗盘,从时间和空间上看,洗盘效果会更好(考虑到交易者心理因素,一些人第一天亏损后,往往还不会绝望,第二天继续下跌,更容易崩溃卖出)。另外,从一些技术指标上来看,经过连续两天大幅下跌,技术指标修复比较到位,也更能为后面的拉升腾出上涨空间。


我们为涨跌幅设置一个阈值,如果期间的每个bar的涨跌幅超过这个阈值,我们就认为发生了洗盘。在我们的示例中,使用的阈值是0.05,即涨跌5%。

下面我们来看代码实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 示例1
def feature_washout(bars, threshold=0.05):
    """返回在bars中最后一次洗盘结束的位置,-1表示最后一个bar,
        0表示不存在洗盘模式
    """
    close = bars["close"]
    opn = bars["open"]
    truerange = np.maximum(np.abs(close[1:] - close[:-1]), 
                           np.abs(opn-close)[1:]) 
    # 百分比化
    tr = truerange / close[:-1]
    sign = (opn < close)[1:] * 2 - 1
    signed_tr = tr * sign

这里我们使用了truerange这个变量名,是因为这段代码脱胎于技术指标TR

这段代码解决如何将涨跌幅转换为由1,-1和0表示的模式,以便我们后面进行模式检索。

如果当天涨跌超过5%,或者实体的振幅超过5%,我们就将其标记为1或者-1,否则标记为0。标记的符号由它的形态是阴线还是阳线决定。阴线为-1,阳线为1.

我们通过这样一段简单的代码就实现了求阴阳线的功能:

1
(opn < close) * 2 -1

其结果将生成由1和-1组成的数组。无论是涨还是跌,我们总是认为,阴线是洗盘。所以,高开大阴线,即使收盘是上涨的,我们也当成洗盘来处理。

下图就是高开大阴线洗盘一例:

75%

在判断每个bar的涨跌幅、或者实体的振幅是否超过阈值时,我们使用了一个简单的技巧,即通过np.maximimum来从多个数组中,以 element-wise 的形式选取最大值。即,如果有数组\(A\)\(B\),那么\(np.maximum(A, B)\)将返回一个数组,其元素为\(A\)\(B\)对应位置的元素中的较大值。

也就是,如果结果是\(C\),那么\(C_0\)将是\(A_0\)\(B_0\)中的较大值,\(C_1\)将是\(A_1\)\(B_1\)中的较大值,以此类推。

除了使用\(np.maximimum\)这种 ufunc 之外,实际上\(np.max\)也可以用来完成这项任务,只是我们需要先将数组\(A\)\(B\)堆叠成一个矩阵:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
# 示例2
A = np.arange(4)
B = np.arange(3, 7)
C = np.arange(8, 4, -1)

Z = np.vstack((A,B,C))

# 通过np.max求每列最大值
r1 = np.max(Z, axis=0)

# 通过np.maximum求最大值
r2 = np.maximum.reduce([A, B, C])

# 比较两种方法的结果是否相同
np.array_equal(r1, r2)

为了提供更多信息,示例中我们演示了三个数组按元素求最大值的情况。答案是要使用reduce方法。如果只在两个数组间进行比较,则可以只使用np.maximum

经过示例1处理后,我们可能得到如下所示的数组:

[ ... 0.04 -0.02 -0.06 0.04 -0.04 -0. 0.2 -0.14 -0.19 0.09 -0.03 ...]

显然,我们还应该把它二值化,转换成为[大阳,大阴,大阴,大阳](即[1, -1, -1, 1])这样的模式:

1
2
3
4
5
6
7
8
9
# 示例3
encoded = np.select([signed_tr > threshold, 
                    signed_tr < -threshold], 
                    [1, -1], 0)

for i in range(len(encoded) - 3, 0, -1):
    if np.array_equal([-1, -1, 1], encoded[i:i+3]):
        return i - len(encoded) + 2
return 0

我们通过select方法完成了二值化转换。接下来我们通过一个逆序的循环,通过array_equal完成了模式匹配。

在回测中,我们可能需要一次性地提取出很长一段行情中所有的洗盘模式,并对其效果进行检验。上面的代码还可以通过numpy.lib.stride_tricks.sliding_window_view进行优化:

1
2
3
4
5
6
7
8
def feature_washout(bars):
    ...
    washouts = []
    for i, patten in enumerate(sliding_window_view(encoded, window_shape = 4)):
        if np.array_equal(patten, [1, -1, -1, 1]):
            washouts.append(i)

    return washouts

通过将涨跌幅二值化,我们就可以在随后方便地通过array_equal来匹配模式。我们这样做,是因为在这里定性分析基本就够了,只要涨跌幅超过5%,那么无论是跌了5.1%还是7.2%,我们都认为是洗盘。

但是,如果你觉得定量分析仍然有意义,也可以通过求皮尔逊相关系数的方法来进行模式匹配。

拯救CCI!因子纯化后,证实CCI确实是超有效的技术指标!

CCI(商品通道指数) 由 Donald Lambert 研发,首次发表于 1980 年的《商品期货》杂志,一直以来很受交易大量推崇。但是,简单地将这个指标作为因子进行因子检验,差点使明珠蒙尘。最后,因子密度分布图揭示了真相,通过因子纯化,最终检验结果给出了与传统经验一致的结论!

CCI的计算公式是:

\[ CCI=\frac{Typical Price - MA}{.015 * Mean Deviation} \]

其中,

\[ \text{Typical Price}_t=(H_t+L_t+C_t)\div 3 \\ MA = Moving Average \\ Moving Average = (\sum_{i=1}^PTypical Price)\div P \\ Mean Deviation = (\sum_{i=1}^P|Typical Price - MA|)\div P \]

简单来说,CCI 表示了价格对移动平均线的徧离程度。

Tip

MACD, PPO, CCI 和 BIAS 是一组非常相似的指标,它们的区别主要在于选择的价格序列不同,是否进行了归一化。在本章我们不会介绍 BIAS 指标,这里就顺带提一下。它的公式是:

\[ \text{Bias} = \frac{\text{当前价格} - \text{N 日移动平均线}}{\text{N 日移动平均线}} \times 100 \]

这个对比给我们提示了创新因子的一个思路。

CCI 使用最高价、最低价和收盘价的平均值作为价格序列的想法,在很多地方都很常见。本质上,它是对 vwap 的一种近似。因此,在有 vwap 数据可用的前提下,直接使用 vwap 数据有可能更好,后者的博弈含义更明确。

CCI 公式当中有一个魔术数字:0.15. 它的作用是为了使 CCI 的值标准化到一个合理的范围,并且能在-100和100边界处有信号意义。起初,公式的设计者 lambert 认为,当 CCI 在[-100,100]区间内时,意味着价格在随机波动,是不值得交易的。而只有当 CCI 绝对值超过了 100 时,才认为有趋势出现,即当 CCI 上穿 100 时买入,下穿-100 时卖出。

我们先用一个简单的双轴图观察一下这个指标。

1
2
3
4
5
6
7
8
9
df = PAYH.copy()
df['cci'] = ta.CCI(df.high, df.low, df.close, 14)

axes = df[['close', 'cci']].plot(figsize=(14, 7), 
                            subplots=True, 
                            title=['PAYH', 'cci'])
axes[1].set_xlabel('')
sns.despine()
plt.tight_layout()

这是输出结果:

输出结果中,我在两处CCI穿越 \(\pm 100\) 的位置上标注了交易信号,以说明CCI的信号作用。这只是单个资产、某小段时间上的观察结果,说明不了问题。

现在我们运行因子检验来测试一下:

1
2
3
4
5
_ = alphatest(2000, start, end, 
              calc_factor = lambda x: ta.CCI(x.high, 
                                             x.low, 
                                             x.close, 
                                             14))

看起来因子测试的结果不是很好。

但是,只要对 CCI 的原理略加分析,我们就很容易明白,它不适合直接当成因子来使用。因为CCI的交易信号是,当CCI穿越\(\pm 100\) 时,就发出交易信号。它是一种事件信号,并不是我们通常意义上的因子。

下面,我们从因子分布的角度来讲一下为什么。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
cci = barss.groupby(level="asset")
            .apply(lambda x: ta.CCI(x.high, 
                                    x.low, 
                                    x.close, 
                                    timeperiod=14
                                    )
                )

with sns.axes_style('white'):
    sns.distplot(cci)
    sns.despine()

从密度分布图来看,因子分布出现了双峰。

我们在课程中讲过,如果因子的分布出现双峰,这个因子往往包含了多种因素,它是不纯粹的。现在,我们面临的正是这种情况。在这种情况下,进行因子分析,我们需要先对因子进行“纯化”。

1
2
3
4
5
6
7
8
cci = barss.groupby(level="asset")
            .apply(lambda x: ta.CCI(x.high, 
                                    x.low, 
                                    x.close, 
                                    timeperiod=14))
with sns.axes_style('white'):
    sns.distplot(cci[cci> 0])
    sns.despine()

输出结果如下:

现在,我们看到的 cci 的分布就是单峰的了。然后我们对它进行因子检验,看看结果如何:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def calc_cci(df, n):
    cci = ta.CCI(df.high, df.low, df.close, n)
    cci[cci < 0] = np.nan
    return cci * -1

alphatest(2000, 
         start, 
         end, 
         calc_factor= calc_cci, args=(14,), 
         max_loss=0.55, long_short=False)

注意,这段代码的第三行,我们对返回前的CCI 进行了修正,使其负值部分被置为nan,从而它们将会在因子检验中被抛弃掉。这是之前讲Alphalens框架时讲过的内容。

也正是因为丢弃了一半的因子,所以,在调用Alphalens时,我们需要将max_loss参数设置为大于0.5(具体看maxlosserror报告)。

基于纯化后的因子,回报是惊人的。它没有我们之前调谐过的RSI那么强,但是,我们是在纯多条件下得到的结果,因此它格外吸引人。

年化Alpha图

Alpha 达到了年化 19%。而且这个因子呈现比较好的正向单调性,见分层收益图:

因子分层收益均值图

不过,它在纯多的情况下,累计收益表现不是很稳定。这一点也从前面的年化收益图中的beta值可以看出来,受市场波动影响比较大。

累积收益图

但是我们不一定非要纯多,本来CCI就是期货指标。我们来看看多空组合的情况:

多空组合时的Alpha

不仅Alpha收益很强,而且beta被对冲到几乎没有!在beta为零的情况下,累积收益就应该是平稳向上、且波动很小,我们来看看是否是这样:

多空组合时的累积收益

这也许是 CCI 如此受人推崇的原因之一。

不过,这里的因子检验并不等同于实盘,因为操作手法不一样。在因子检验中,我们是按因子值进行的加权多空操作,在实盘中,会固定按CCI是否穿越\(\pm 100\)来确实是否开仓。在因子检验中,我们的开仓条件会更宽松一些,有一些自适应的味道。

本文附有代码和数据,可复现。加入星球后,即可获取基于Jupyter Notebook的研究环境,直接运行代码。

在该环境中,除本文代码外,之前付费文章的代码也都在。并且,今后的文章只要声明附有代码和数据,可复现的,都能在此环境中找到。

10 月 24 日,庆祝码农节!Python 刚刚发布了 3.13 版本

今天(10 月 24 日)是码农节。这一天也是裘伯君、Chris Lattner, Robert Khan 等人的生日。Lattner 是 LLVM 开源编译器的创始人、Swift 和 Mojo 语言的主要设计者。Khan 是互联网奠基人之一,他与温顿。瑟夫共同发明了 TCP/IP 协议。

不过,最令程序员兴奋的是,Python 3.13 正式版本发布了!

这个版本的重点是,引入了一个新的交互式解释器,并且对自由线程模型(PEP 703)和即时编译器(PEP 744)提供了实验性支持。这是 Python 程序员多少年以来,翘首以盼的性能改进!

REPL

新的交互式解释器这一功能可能会引起误解。它实际上指的是一个新的交互式 shell,而不是语言解释器本身。这个新的 shell 来自于 PyPy 项目。这个解释器支持彩色输出、多行编辑、历史回顾和多行粘贴模式。

Lattner 和 Mojo 语言。Mojo 号称比 Python 快 6.8 万倍

Python 的交互式 shell 一直是它的特色和优势,想了解一个函数的功能和用法,直接在终端中输入 ipython 之后,就可以立即尝试这个函数。我是常常拿 ipython 当计算器使用,特别方便。

JIT

从 3.11 起,Python 开始引进 JIT 的一些特性。在 Python 3.11 版本中,当解释器检测到某些操作涉及的类型总是相同的时候,这些操作就会被“专门化”,替换成特别的字节码,这使得代码中这部分区域的运行速度提升 10%到 25%。到了 3.13 版本,它已经能在运行时生成实际的机器代码,而不仅仅是专门的字节码。现在,提速还不是很明显,但为未来的优化铺平了道路。

不过,目前 JIT 还被认为是实验性的,默认情况下未启用。CPython 团队还在观察它对整个社区的影响,一旦成熟,就会成为默认选项。

Free Threaded CPython

Robert Kahn,互联网之父

之前大家讨论很久的无 GIL 版本,现在官方名称确定为 Free Threaded CPython。在这个版本下,CPython 允许线程完全并行运行。这将立刻数倍提升 Python 的性能。不过,目前该功能也是实验性的。

要启用这两个实验性的功能,你需要自己从源代码编译 CPython。同样地,这已经让人看到了曙光。而且,这个等待时间并不会太长,这些功能已经在 Meta 内部广泛使用了。

其它性能优化

这一版在 Windows 上,将提供精度为 1 微秒的计时器,而不再是过去精度只有 15.6 毫秒的时钟。这一变化将使得 Python 在 Windows 上将能执行一些实时任务。

之前 typing 库的部分模块会导致导入时间过长,现在,这个时间已减少了大约 1/3。当然,我们平常可能感受不出来,但如果你的程序会启动子进程来执行一些简短的计算密集型任务的话,这个区别就比较大了。

说到子进程,subprocess 现在会更多地使用 posix_spawn 函数创建子进程,这将带来一些性能上的提升。

弃用版本管理

在 Python 中,弃用版本管理一直是通过第三方库来实现的。现在,这一特性终于被内置了:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from warnings import deprecated
from typing import overload

@deprecated("Use B instead")
class A:
    pass

@deprecated("Use g instead")
def f():
    pass

@overload
@deprecated("int support is deprecated")
def g(x: int) -> int: ...
@overload
def g(x: str) -> int: ...

不过,第三方库 deprecation 似乎仍然在功能上更胜一筹。这是 deprecation 的用法:

1
2
3
4
5
from deprecation import deprecated

@deprecated("2.0.0", details="use function `bar` instead")
def foo(*args):
    pass

你就是列文。虎克!

这是网上的一个梗,说的是有些人看图特别仔细,拿着显微镜找 bug。列文。虎克就是发明显微镜的人。10月24日也是他的生日。

列文。虎克裁缝学徒出身,没受过正规教育。后来成为一名布匹商,为了检验布匹的质量,他购买了放大镜来观察布匹的纤维,也由此开启了他的大国工匠之路(17 世纪的荷兰的确是大国。世界上的第一个证券交易所 -- 资本主义的标志,就诞生在 17 世纪的荷兰)。

列文。虎克没有受过正规训练,凭着兴趣和热爱,发明了显微镜,为人类打开了从未见过的世界。他的成就最终被英国皇家学会接受,在 1680 年当选为皇家学会成员。终其一生,他为这个世界留下的,除了他自己的名字,还有 cell 这个词。

“我总是尽力做到最好,即使是最小的事物也值得认真对待”。正是凭着这种信仰,他才得以见微知著,于一粒沙中发现宇宙。

Pandas连续涨停统计

题图: 哈佛大学

常常需要快速统计出一段时间内,最强的股和最弱的股,以便研究该区间内,强势股和弱势股有什么特点。

如果使用循环,这就跟掰着手指头数数没啥区别,各位藤校生一定是不屑的。所以,我们来看看如何简洁优雅地实现这一功能,同时可以在同事面前zhuangbility.


这里我们以2023年的数据为例,要求统计出连续涨停在n天以上的个股,并且给出涨停时间。同样的方案也可以找出当年最终的股,以及它们的时间。

你可以对着屏幕把代码copy下来,自己找来数据验证。不过要是赶时间的话,建议加入我的部落:

加入部落者,即可获得Quantide研究环境账号,直接运行和下载本教程。

我们先加载数据:


1
2
3
4
5
6
np.random.seed(78)
start = datetime.date(2023,1,1)
end = datetime.date(2023, 12, 31)

barss = load_bars(start, end, -1)
barss.tail()

load_bars函数在我们的研究环境下可用。这将得到以下格式的数据:

date asset open high low close volume amount price
2023-12-25 **** 30.85 31.20 30.06 30.08 3591121.00 109649397.62 30.14
2023-12-26 **** 30.14 30.25 26.00 27.85 9042296.00 251945474.00 27.90
2023-12-27 **** 27.90 28.89 27.18 28.89 5488847.00 155156381.16 28.58
2023-12-28 **** 28.58 29.85 28.44 29.20 5027247.00 147201133.00 29.25
2023-12-29 **** 29.25 30.14 29.25 29.66 3923048.00 116933800.77 NaN

我们只取价格数据,然后展开成宽表,以求出每天的涨跌符:

1
2
3
pd.options.display.max_columns = 6
returns = barss.close.unstack("asset").pct_change()
returns.tail()

现在我们将得到这样的结果:

date **** **** **** ... **** **** ****
2023-12-25 -0.00 -0.01 -0.02 ... -0.01 -0.03 -0.03
2023-12-26 -0.01 -0.01 -0.02 ... 0.00 -0.02 -0.07
2023-12-27 0.00 0.00 0.02 ... -0.01 0.00 0.04
2023-12-28 0.04 0.03 0.01 ... 0.03 0.02 0.01
2023-12-29 -0.01 -0.01 0.02 ... 0.00 -0.00 0.02

5 rows × 5085 columns

接下来,我们要判断哪一天为涨停。因为我们的目标并不是执行量化交易,只是为了研究,所以,这里可以容忍一定的误差。我们用以下方式决定是否涨停(排除北交所、ST):

1
2
3
criteria = ((returns > 0.095) & (returns < 0.105)) | 
            ((returns > 0.19)& (returns < 0.21))
zt = returns[criteria].notna().astype(int)

这里的语法要点是,如何使用多个条件的组合,以及如何将nan的值转换为0,而其它值转换为1。


这里会出现nan,是因为我们处理的是宽表。在宽表中,有一些列在某个点上(行)不满足条件,而在该点上,其它列满足条件,导致该行必须被保留;不满足条件的列,在该行的值就是nan。然后我们用notna将nan转换为False,其它值转换为True,最后通过astype转换为整数0和1,1代表该天有涨停。

接下来,我们就要对每一个资产,统计它的连续涨停天数。我们用以下函数来处理:

1
2
3
4
5
6
7
8
def process_column(series):
    g = (series.diff() != 0).cumsum()

    g_cumsum = series.groupby(g).cumsum()

    result = series.copy()
    result[g_cumsum > 1] = g_cumsum[g_cumsum > 1]
    return result

这个函数的巧妙之处是,它先计算每一行与前一行的差值,并进行累加。如果有这样一个序列: 0 0 1 1 1 0 0,那么diff的结果就是nan, 0, 1, 0, 0, -1, 0。这里不为0的地方,就表明序列的连续状态发生了变化:要么出现连续涨停,要么连续涨停中止。

然后它通过cumsum累计差分序列。这样就与原序列形成如下的对应关系:

原序列 diff diff!=0 cumsum
0 nan true 1
0 0 false 1
1 1 true 2
1 0 false 2
1 0 false 2
0 -1 true 3
0 0 false 3

如果把这里的cumsum看成组号,那么就可以通过groupby分组,然后计算每组中非0的个数,就得到组内连续涨停次数。这就是第4行的工作。

Marvelous!


最后,我们来应用这个函数:

1
2
df_processed = zt.apply(process_column, axis=0)
df_processed.stack().nlargest(5)

我们得到以下结果(部分):

date asset 连续涨停
2023-10-25 **.XSHG 14
2023-10-24 **.XSHG 13
2023-03-21 **.XSHE 12
2023-10-23 **.XSHG 12
2023-03-20 **.XSHE 11

我们拿其中一个验证一下:

1
2
3
4
5
6
7
code = "******.XSHG"

bars = barss.xs(code, level="asset")
bars["frame"] = bars.index

plot_candlestick(bars.to_records(index=False), 
                ma_groups=[5,10,20,60])

我们来看下k线图:

最后,我们把函数封装一下:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def find_buy_limit(closes, low = 0.095, high = 0.105,n=50):
    def process_column(series):
        group = (series.diff() != 0).cumsum()

        group_cumsum = series.groupby(group).cumsum()

        result = series.copy()
        result[group_cumsum > 1] = group_cumsum[group_cumsum > 1]
        return result

    returns = closes.unstack("asset").pct_change()
    criteria = (returns > low) & (returns < high)

    zt = returns[criteria].notna().astype(int)
    df_processed = zt.apply(process_column, axis=0)
    return df_processed.stack().nlargest(n)

find_buy_limit(barss.close)

最后,这一届的奥斯卡颁给...的主力(算了,哪怕是历史数据,也不要透露了)。

当你不知道该往哪里踢时,就往球门里踢!现在,对着你去年错过的连接14个涨停,来找找规律吧!

量化实盘接口

Easytrader

Easytrader是一个通过模拟键鼠事件,操作券商客户端来实现交易功能的交易代理。这种方式中,easytrader提供了buy, sell等交易API,策略调用这些API,easytrader把它转化成对券商交易客户端的鼠标点击事件,最终完成交易。 特点是接入不需要申请,支持的券商较多(除华泰、海通、国金外,其它的可以通过同花顺来接入)。但由于是模拟键鼠事件来操作GUI,所以存在稳定性较差、响应速度慢的问题。 如果一定要通过它来进行实盘,需要找一台性能较好的独立的物理机,只安装券商的交易客户端和Easytrader, Easytrader以服务器模式运行,再在策略端,使用easytrader的remote client连接过去,平时不操作这台物理机,以名对easytrader的操作造成干扰。 此外,还应该关闭该机器上的自动更新等功能。

恒生电子Ptrade

Ptrade是恒生电子开发的量化平台。官方有一个视频教程,免费注册后可收看。在我的《大富翁量化编程实战》课程中也有介绍。 它的运行方式是券商托管式。券商采购Ptrade软件,进行一些定制化后,提供给自己的客户使用。 用户使用Ptrade策略编辑器生成自己的策略,回测通过后,上传到券商机房运行。这种接入方式中,券商提供python版本的sdk,通过sdk中的交易API来进行下单。 托管模式下,一般不能访问互联网、无法更新Python及依赖库的版本,不能自行安装软件。量化策略与交易API、数据获取API等紧密耦合,如果后期想更换券商,成本较高。因为不能自行安装软件和库,因此难以利用较新的第三方算法。如果使用了机器学习、强化学习等人工智能算法,这些库不一定在券商提供的环境下有,即使有的话,版本很可能跟我们常用的不一致,并且可能没有GPU可用。 优点是行情速度更快,省去了机房维护工作。 Ptrade软件网上无法下载,需要找券商工作人员开户后获取,并且一般要满足30万资金门槛才能开通实盘。目前可以向国金、国盛、国元、安信、东莞等券商申请开通Ptrade。如果有调佣(可以做到万一免五)和资金门槛要求(可以做到最低两万)的,也可以找我。

QMT

讯投QMT由北京睿智融科开发。与Ptrade一样,它也是由券商采购定制后,提供给自己的客户使用的。不一样的是,它是本地运行模式,策略安全性更好一点。 QMT提供了两种交易接入方式,一种是文件扫单模式,一种是API式。后者需要在QMT平台里编写策略并运行,对Python版本和可运行库有一定限制(但可以通过白名单增加新的第三方库)。 文件扫单模式则没有上述限制。 QMT软件网上无法下载,需要找券商工作人员开户后获取,目前可以向国金、国盛、国元、安信、东莞等券商申请开通。如果有调佣(可以做到万一免五)和资金门槛要求(可以做到最低两万)的,也可以找我。

东财EMC

东方财富EMC,开户门槛为100万资金。需要加入它的官方量化技术支持群申请开通。它提供API交易和本地文件扫单两种方式。 本地文件扫单方式响应速度在10ms以内。与量化程序没有耦合,因此量化程序可以运行在任何一台机器上,可以使用任意的Python版本和第三方库。 但是用户需要自己将交易指令(比如buy, sell等)转换成为文件单格式,并且EMC对委托的结果也是以csv方式返回,也需要用户自己解析。 gmadaptor提供了这种封装。不仅如此,它还将自己封装成一个服务器,因此量化策略可以运行在不同的机器和操作系统上(EMC只能运行在Windows上)。

其它接入方式

其它还有华泰MATIC,需要找华泰证券开通,这个资金门槛比较高,需要1000万,我可以帮忙申请到500万门槛的。 一创聚宽也提供了量化交易接入,采用的是托管模式。

参考资源

如果有需要学习Easytrader, Ptrade, QMT和东财EMC的,我这里有相关的学习资料,可以留言获取。

[1020] QuanTide Weekly

本周要闻

  • 幻方量化宣布降低对冲全系产品投资仓位至0
  • 9月CPI、PPI及前三季度GDP数据出炉
  • 潘功胜发声,宏观经济政策应更加重视消费

下周看点

  • 周一:最新LPR报价
  • 周二:华为原生鸿蒙之夜新品发布会
  • 周五:多家银行存量房贷利率调整
  • 周日:全球低空经济论坛年会

本周精选

  • 连载!量化人必会的 Numpy 编程(7)

  • 宁波幻方量化公告,将逐步把对冲全系产品投资仓位降低至0,同时自10月28日起免除对冲系列产品后期的管理费。作出改变的原因是,市场环境变化,对冲系列产品难以同时取得收益和缩小风险敞口,潜在收益风险比明显下降,未来收益将明显低于投资人预期。建议投资者适时调整投资组合,市场低位较适合配置指数增强产品,在风险能力匹配前提下,对冲产品可转至多头。(财联社)
  • 10月13日,国家统计局数据显示,9月份全国居民消费价格(CPI)环比持平,同比上涨0.4%,涨幅回落;工业生产者出厂价格(PPI)环比降幅收窄,同比降幅扩大。CPI、PPI同比表现均弱于市场预期。(证券时报网)
  • 10月18日,统计局公布2024年9月经济数据,9月社零当月同比3.2%,固定资产投资累计同比3.4%,工增当月同比5.4%,三季度GDP同比4.6%。前三季度GDP累计同比4.8%。(财联社)
  • 在10月18日的2024金融街论坛上,央行行长潘功胜重磅发声。谈及实现经济的动态平衡,需要把握好几个重点时,他提到宏观经济政策的作用方向应从过去的更多偏向投资,转向消费与投资并重,并更加重视消费。(财联社)

Numpy量化应用案例[4]

突破旗形整理

最近和一位做量化的私募大佬聊了一下行情,他给我发了这张图片。

75%

这个底部点位,他又一次精准命中了(3143那个点,不是3066。周五上证实际下探到3152点)。不过,我更好奇的是他的研究方法,也就图的下半部分。知道大致的底之后,再结合缺口、前低等一些信息,确实有可能比较精准地预测底部点位。


我当时就回了一句,最近忙着上课,等有时间了,把这个三角形检测写出来。

这个检测并不难,写一个教学示例,一个小时的时间足够了。

在分享我的算法之前,先推荐一个外网的方案。同样是教学代码,显然不如我随手写的优雅,先小小自得一下。不过,这样的好处就是,他的代码可能更容易读懂。

所谓旗形整理(或者说三角形检测),就是下面这张图:

在这张图,每次上涨的局部高点连接起来,构成压力线;而下跌的局部低点连起来,构成支撑线。

如果我们再在开始的位置画一条竖线,就构成了一个小旗帜,这就是旗形的来由。


旗形整理的特别之处是,整理何时结束似乎是可以预测的,因为这两条线之间的交易空间会越来越窄。

当它小于一个ATR时,就是整理必须结束,即将选择方向的时候。

下图显示了随时间推移,震荡幅度越来越小的情况。

75%

最终,股价会选择方向。一旦选择方向,就往往会有一波较大的行情(或者下跌):

75%


所以,能够自动化检测旗形整理,有以下作用:

  1. 如果当前处理在旗形整理中,可以设定合理的波段期望。
  2. 检测临近整理结束,可以减仓等待方向。
  3. 一旦方向确定,立即加仓。

现在,我们就来看如何实现。首先,我们有这样一个标的:

75%

这是已经上涨后的。我们再来看它上涨前的:

75%


肉眼来看,一个旗形整理似有若无。

我们的算法分这样几步:

  1. 找到每阶段的峰和谷的坐标
  2. 通过这些坐标及它们的收盘价,进行趋势线拟合
  3. 通过np.poly1d生成趋势线
  4. 将趋势线和k线图画在一张图上
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
def find_peak_pivots(df, win):
    local_high = (df.close.rolling(win)
                    .apply(lambda x: x.argmax()== win-1))
    local_high[:win] = 0

    # find_runs函数是量化24课内容
    v,s,l = find_runs(local_high)

    peaks = []
    i = 0
    while i < len(v):
        if l[i] >= win // 2:
            if s[i] > 0:
                peaks.append(s[i] - 1)
        for j in range(i+1, len(v)):
            if l[j] >= win // 2:
                peaks.append(s[j] - 1)
                i = j
        if j == len(v)-1:
            break

    return peaks

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def find_valley_pivots(df, win):
    local_min = (df.close.rolling(win)
                .apply(lambda x: x.argmin()== win-1))
    local_min[:win] = 0

    v,s,l = find_runs(local_min)

    valleys = []
    i = 0
    while i < len(v):
        if l[i] >= win // 2:
            if s[i] > 0:
                valleys.append(s[i] - 1)
        for j in range(i+1, len(v)):
            if l[j] >= win // 2:
                valleys.append(s[j] - 1)
                i = j
        if j == len(v)-1:
            break

    return valleys

def trendline(df):
    peaks = find_peak_pivots(df, 20)
    valleys = find_valley_pivots(df, 20)

    y = df.close[peaks].values
    p = np.polyfit(x=peaks, y = y, deg=1)
    upper_trendline = np.poly1d(p)(np.arange(0, len(df)))

    y = df.close[valleys].values
    v = np.polyfit(x=valleys, y = y, deg=1)
    lower_trendline = np.poly1d(v)(np.arange(0, len(df)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    candle = go.Candlestick(x=df.index,
                    open=df['open'],
                    high=df['high'],
                    low=df['low'],
                    close=df['close'],
                    line=dict({"width": 1}),
                    name="K 线",
                    increasing = {
                        "fillcolor":"rgba(255,255,255,0.9)",
                        "line": dict({"color": RED})
                    },
                    decreasing = {
                        "fillcolor": GREEN, 
                        "line": dict(color =  GREEN)
                    })
    upper_trace = go.Scatter(x=df.index, 
                             y=upper_trendline, 
                             mode='lines', 
                             name='压力线')

    lower_trace = go.Scatter(x=df.index, 
                             y=lower_trendline, 
                             mode='lines', 
                             name='支撑线')

    fig = go.Figure(data=[candle,lower_trace, upper_trace])

    fig.show()

最后,我们对该标的在上涨之前的形态进行检测,得到以下结果:


这个结果说明,旗形整理结束时,方向选择受大盘影响,仍有一定不确定性,但没有跌破前低,这是此后能凝聚共识、返身上涨的关键。

我们再来看一个最近一个月翻了7倍的标的:

这是未上涨前的形态:

这是检测出来的旗形整理:


完美捕捉!

当然,这里只是示例代码,在实际运用中,由于我们使用了小样本线性回归,回归结果具有不稳定性,要作为生产代码,还需要辅以其它方法让其预测更稳定。无论如何,我们已经迈出了关键一步。

代码(可运行的ipynb文件)放在知识星球里。正在建设,所以目前是最低价格。

如果有一些代码和术语看不明白(比如为何以ATR来决定整理结束),这些都是我们量化24课的内容,欢迎报名!


好课开讲!


目标清晰 获得感强


为什么选择QuanTide的课程?

第42个因子:年化17.6%,15年累计10倍

题图:第比利斯自由大学,Kahushadze在此任教

《101个公式化因子》是Zura Kahushadze于2015年发表的paper。在这篇paper中,他拿出了在worldquant广泛使用的因子中,便于公式化的因子(约80个),加上其它自创因子,共101个,集结发表在预印论文网站arXiv上。

这一paper甫一发表,便引起业界关注。现在,Alpha101因子已成为国内机构广泛使用的付费因子。但是,Alpha101因子中的公式比较晦涩难懂,使用了自定义的算子、大量魔术数字和数不清的括号嵌套,让无数人不得不从入门到放弃。


然而,如果你因此放弃Alpha101,不能不说是巨大的损失。比如,我们近期对第42个因子进行了回测,发现它在A股有相当好的表现。

Info

回测使用2008年到2022年的数据,随机抽取2000支个股参与回测。考虑到2018年A股才1800支个股左右,这一回测在2018年前几乎是全覆盖。具有很强的代表性。

回测结果表明,这一因子的年代收益达到16.1%, 累计收益达到7倍(15年)。


不过,驾驭Alpha101并不容易。不得不说,它的公式有点晦涩难懂,比如第29号因子,它的公式如下:

1
2
(min(product(rank(rank(scale(log(sum(ts_min(rank(rank((-1 * rank(delta((close - 1),
5))))), 2), 1))))), 1), 5) + ts_rank(delay((-1 * returns), 6), 5))

这只是Alpha101中中等阅读难度的因子。如果我们把它展开,相当于:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(
    min(
        product(
            rank(
                rank(
                    scale(
                        log(
                            sum(
                                ts_min(
                                    rank(rank((-1 * rank(delta((close - 1), 5))))), 2
                                ),
                                1,
                            )
                        )
                    )
                )
            ),
            1,
        ),
        5,
    )
    + ts_rank(delay((-1 * returns), 6), 5)
)

不仅是了解其含义非常困难,就是实现它也不是件容易的事。而且,Alpha101中还存在大量待优化的部分,以及少部分错误(对于一篇免费、公开的文章,仍然是相当宝贵的资源)。比如,对于42号因子,它仍然有改进空间。这是我们改进后的因子表现(同等条件下,源码仅对学员开放):

我们看到,年化alpha有了1.5%的上涨。而下面这张分层收益图,懂行的人一看就知道,简直是完美。西蒙斯所谓追随美的指引,应该就是指的这种图了。


累积收益图也很完美。A股2008年触顶6124之后,持续下跌数年,但这期间此因子的收益仍然保持上涨。

不过,Alpha101确实很难懂。比如公式001看起来并不复杂:

1
2
3
(rank(Ts_ArgMax(SignedPower((
    (returns < 0) ? stddev(returns, 20) : close), 2.)
    , 5)) -0.5)

但它却做了许多无用操作。它实际上是对现价对近期高点的距离排序,你看明白了吗?所以,这个因子到底有没有效呢?在什么情况下,它会出现出人意料的表现呢?

还有,像这样的因子,从公式到代码,再到结合数据进行因子检验,又该如何操作呢?如果你感兴趣,快来加入我们一起学习吧!

地量见地价?我拿一年的上证数据算了算

多伦多大学校园。2024诺贝尔物理学奖获得者,Geoffrey Hinton在此任教。

股谚云,天量见天价、地量见地价。今天我们就来验证一下。

要把股谚量化,首先要解这道难题:数组中第i个元素是多少周期以来的最小值(最大值)?


比如,有数组如下: 1, 2, 2, 1, 3, 0。那么,第1个元素1,是1周期以来的最小值,第2个元素2,是到目前为止的最大值,所以,也是1周期以来的最小值;但第4个元素1则是从第2个元素以来的最小值,所以它是3周期以来的最小值。

依次计算下去,我们得到这样一个序列: 1, 1, 2, 1, 4, 6。其中的每一项,都是原数组中,对应项到目前为止的最小值。

这个算法有什么用处呢?它可以用在下面的计算当中。

比如,有股谚云,天量见天价,地量见地价。

当行情处在高位,成交量创出一段时间以来的天量之后,后续成交量将难以为继,容易引起下跌;当行情处在低位,成交量创出一段时间以来的地量之后,表明市场人气极度低迷,此时价格容易被操纵,从而引来投机盘。在计算地量时,我们就要知道,当前的成交量是多少期以来的最小值。

比如,如果大盘当前的成交量成为了120天以来的最低量,这时候很可能就会引起大家的关注了。要验证出现地量之后,后面是否真的有行情,就需要进行因子分析或者回测验证。现在的问题是,怎么计算呢?

无脑的双重循环

我们以上面的数组为例,最简单的算法是使用循环:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def min_range_loop(s):
    minranges = [1]
    for i in range(1, len(s)):
        for j in range(i-1, -1, -1):
            if s[j] < s[i]:
                minranges.append(i - j)
                break
        else:
            minranges.append(i+1)
    return minranges

s = [1,2,2,1,3,0]

min_range_loop(s)

输出为:1, 1, 2, 1, 4, 5

这个算法实现用了双重循环,应该比较耗时。我们生成10000个元素的数组跑一下,发现调用一次需要用时9.5ms。

它山之石,myTT的实现

在myTT中有一个类似的函数实现:

1
2
3
4
5
def LOWRANGE(S):                       
    # LOWRANGE(LOW)表示当前最低价是近多少周期内最低价的最小值 by jqz1226
    rt = np.zeros(len(S))
    for i in range(1,len(S)):  rt[i] = np.argmin(np.flipud(S[:i]>S[i]))
    return rt.astype('int')

它应该也是实现元素i是多少周期之前的最小值,只不过从注释上看,该函数多在计算最低价时使用。但实际上序列s是什么没有关系。

这个函数用了一个循环,还使用了flipuid函数,比较有技巧。这个函数的用法演示如下:

1
2
s = [1, 2, 2, 3, 2, 0]
np.all(np.flipud(s) == s[::-1])

也就是它的作用实际上就是翻转数组。

不过,LOWRANGE函数似乎没有实现它声明的功能,不知道是不是对它的功能理解上有错误。当我们用同一个数组进行测试时,得到的结果与双循环的并不一致。

1
2
s = np.array([1, 2, 2, 3, 2, 0])
LOWRANGE(s)

得到的结果是:

1
array([0, 0, 0, 0, 1, 0])

除此之外,如果同样拿10000个元素的数组进行性能测试,LOWRANGE执行时间要60ms,居然跑输给Python双循环。测试环境使用的Python是3.11版本,不得不说Python3.11的优化非常明显。

如果我们要完全消除循环,应该怎么做呢?

烧脑的向量化

如果我们能把数组[1, 2, 2, 3, 2, 0]展开为:

\(\displaystyle \left[\begin{matrix}1.0 & \text{NaN} & \text{NaN} & \text{NaN} & \text{NaN} & \text{NaN}\\1.0 & 2.0 & \text{NaN} & \text{NaN} & \text{NaN} & \text{NaN}\\1.0 & 2.0 & 2.0 & \text{NaN} & \text{NaN} & \text{NaN}\\1.0 & 2.0 & 2.0 & 3.0 & \text{NaN} & \text{NaN}\\1.0 & 2.0 & 2.0 & 3.0 & 2.0 & \text{NaN}\\1.0 & 2.0 & 2.0 & 3.0 & 2.0 & 0.0\end{matrix}\right]\)

然后实现一个函数,接收该矩阵输入,并能独立计算出每一行最后一列是多少个周期以来的最小值,这个问题就得到了求解。

要实现这个功能,我们可以通过numpy的masked array和triu矩阵来实现。


1
2
3
4
n = len(s)
mask = np.triu(np.ones((n, n), dtype=bool), k=1)
masked = np.ma.array(m, mask=mask)
masked

triu中的k参数决定了生成的三角矩阵中主对角线的位置。k=0,对角线取在主对角线上;k<0,对角线取在主对角线之个k个单位;k>0,对角线取在主对角线之上k个单位。

我们将得到以下输出:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
masked_array(
  data=[[1.0, --, --, --, --, --],
        [1.0, 2.0, --, --, --, --],
        [1.0, 2.0, 2.0, --, --, --],
        [1.0, 2.0, 2.0, 3.0, --, --],
        [1.0, 2.0, 2.0, 3.0, 2.0, --],
        [1.0, 2.0, 2.0, 3.0, 2.0, 0.0]],
  mask=[[False,  True,  True,  True,  True,  True],
        [False, False,  True,  True,  True,  True],
        [False, False, False,  True,  True,  True],
        [False, False, False, False,  True,  True],
        [False, False, False, False, False,  True],
        [False, False, False, False, False, False]],
  fill_value=1e+20)

mask flag为True的部分将不会参与运算。如果我们把masked转给sympy,就可以验证这一点:


1
2
3
4
5
6
from sympy import Matrix

n = len(s)
mask = np.triu(np.ones((n, n), dtype=bool), k=1)
masked = np.ma.array(m, mask=mask)
Matrix(masked)

我们得到了与期望中一样的展开矩阵。

\(\displaystyle \left[\begin{matrix}1.0 & \text{NaN} & \text{NaN} & \text{NaN} & \text{NaN} & \text{NaN}\\1.0 & 2.0 & \text{NaN} & \text{NaN} & \text{NaN} & \text{NaN}\\1.0 & 2.0 & 2.0 & \text{NaN} & \text{NaN} & \text{NaN}\\1.0 & 2.0 & 2.0 & 3.0 & \text{NaN} & \text{NaN}\\1.0 & 2.0 & 2.0 & 3.0 & 2.0 & \text{NaN}\\1.0 & 2.0 & 2.0 & 3.0 & 2.0 & 0.0\end{matrix}\right]\)

现在,我们要求解的问题变成,每一行最后一个数是多少周期的最小值。我们进行一个变换:

1
2
3
4
s = np.array([1, 2, 2, 3, 2, 0])
diff = s[-1] - s
rng = np.arange(len(diff))
rng - np.argmax(np.ma.where(diff > 0, rng, -1))

我们用最后一个元素减去数组,然后再比较元素是否大于零,如果大于零,我们就将值设置为索引(rng),否则设置为-1,然后再通过argmax找到最后一个非零值。这样输出元素的最后一个值,就是最小周期数。在此例中是5。

如果s = np.array([1, 2, 2, 3, 2]),那么计算出来的最后一个值是4。 如果s = np.array([1, 2, 2, 3]),这样计算出来的最后一个值是1。 依次类推。这刚好就是在masked array中,按axis = 1计算的结果。

下面是完整的代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def min_range(s):
    """计算序列s中,元素i是此前多少个周期以来的最小值"""
    n = len(s)

    diff = s[:,None] - s
    mask = np.triu(np.ones((n, n), dtype=bool), k=1)
    masked = np.ma.array(diff, mask=mask)

    rng = np.arange(n)
    ret = rng - np.argmax(np.ma.where(masked > 0, rng, -1), axis=1)
    ret[0] = 1
    if filled[1] <= filled[0]:
        ret[1] = 2
    return ret

我们来验证一下结果:

1
2
s = np.array([1, 2, 2, 3, 2, 0])
min_range(s)

输出结果是1, 1, 2, 1, 4, 6

在最后一个数字上,与loop略有差异。不过,如果是用来寻找地量条件,这个数值一般要比较大才生效,所以,有一点误差可以接受。

消除了两个循环,性能应该有很大的提升吧?

遗憾的是,在同样的测试条件下,这个函数需要822ms,比双循环慢了100倍。花了这么多功夫,还引入了一点小误差,许诺的性能提升不仅没有实现,反而更糟糕了。真是意外啊。

地量见地价?

最后,我们以上证为例,看看这个算法的实际作用。

1
2
3
4
5
6
7
8
import akshare as ak
df = ak.stock_zh_index_daily(symbol="sh000001")

df_one_year = df.tail(250)
df_one_year["minrange"] = min_range_loop(df_one_year["volume"].to_numpy())

ax = df_one_year.plot(x='date', y='close', label='close', color='blue', secondary_y=False)
df_one_year.plot(x='date', y='minrange', label='Min Range', color='red', secondary_y=True, ax=ax)

这里我们使用了akshare数据源,所以,所有人都可以复现。

我们得到的输出如下:

这个图显示了惊人的结果。几乎在每一次地量(大于50天)出现之后,都能立刻迎来一个小的反弹。但大级别的反弹,还需要在地量之后,随着资金不断进场,成交量放大才能出现。

比如,在8月底,上证出现了一年以来的最低地量,随后立即迎来一个小反弹。在反弹失败之后,其它指标也逐渐见底回升,最终迎来了9月底的十年不遇的暴涨行情。