python - 从 pandas DataFrame 计算 RSI 指标？

转载作者：太空狗更新时间：2023-10-30 01:17:52

我的问题

我在 Github 上尝试了很多库，但它们都没有为 TradingView 生成匹配结果，所以我遵循了这个 link 上的公式计算 RSI 指标。我用 Excel 计算并用 TradingView 整理结果。我知道它绝对正确但是，我没有找到用Pandas计算它的方法。

公式

              100
RSI = 100 - --------
             1 + RS

RS = Average Gain / Average Loss

The very first calculations for average gain and average loss are simple
14-period averages:

First Average Gain = Sum of Gains over the past 14 periods / 14.
First Average Loss = Sum of Losses over the past 14 periods / 14

The second, and subsequent, calculations are based on the prior averages
and the current gain loss:

Average Gain = [(previous Average Gain) x 13 + current Gain] / 14.
Average Loss = [(previous Average Loss) x 13 + current Loss] / 14.

预期结果

     close   change     gain     loss     avg_gian    avg_loss        rs  \
0    4724.89      NaN      NaN      NaN          NaN         NaN       NaN   
1    4378.51  -346.38     0.00   346.38          NaN         NaN       NaN   
2    6463.00  2084.49  2084.49     0.00          NaN         NaN       NaN   
3    9838.96  3375.96  3375.96     0.00          NaN         NaN       NaN   
4   13716.36  3877.40  3877.40     0.00          NaN         NaN       NaN   
5   10285.10 -3431.26     0.00  3431.26          NaN         NaN       NaN   
6   10326.76    41.66    41.66     0.00          NaN         NaN       NaN   
7    6923.91 -3402.85     0.00  3402.85          NaN         NaN       NaN   
8    9246.01  2322.10  2322.10     0.00          NaN         NaN       NaN   
9    7485.01 -1761.00     0.00  1761.00          NaN         NaN       NaN   
10   6390.07 -1094.94     0.00  1094.94          NaN         NaN       NaN   
11   7730.93  1340.86  1340.86     0.00          NaN         NaN       NaN   
12   7011.21  -719.72     0.00   719.72          NaN         NaN       NaN   
13   6626.57  -384.64     0.00   384.64          NaN         NaN       NaN   
14   6371.93  -254.64     0.00   254.64   931.605000  813.959286  1.144535   
15   4041.32 -2330.61     0.00  2330.61   865.061786  922.291480  0.937948   
16   3702.90  -338.42     0.00   338.42   803.271658  880.586374  0.912201   
17   3434.10  -268.80     0.00   268.80   745.895111  836.887347  0.891273   
18   3813.69   379.59   379.59     0.00   719.730460  777.109680  0.926163   
19   4103.95   290.26   290.26     0.00   689.053999  721.601845  0.954895   
20   5320.81  1216.86  1216.86     0.00   726.754428  670.058856  1.084613   
21   8555.00  3234.19  3234.19     0.00   905.856968  622.197509  1.455899   
22  10854.10  2299.10  2299.10     0.00  1005.374328  577.754830  1.740140   

       rsi_14  
0         NaN  
1         NaN  
2         NaN  
3         NaN  
4         NaN  
5         NaN  
6         NaN  
7         NaN  
8         NaN  
9         NaN  
10        NaN  
11        NaN  
12        NaN  
13        NaN  
14  53.369848  
15  48.399038  
16  47.704239  
17  47.125561  
18  48.083322  
19  48.846358  
20  52.029461  
21  59.281719  
22  63.505515

我的代码

导入

import pandas as pd
import numpy as np

加载数据

df = pd.read_csv("rsi_14_test_data.csv")
close = df['close']
print(close)

0      4724.89
1      4378.51
2      6463.00
3      9838.96
4     13716.36
5     10285.10
6     10326.76
7      6923.91
8      9246.01
9      7485.01
10     6390.07
11     7730.93
12     7011.21
13     6626.57
14     6371.93
15     4041.32
16     3702.90
17     3434.10
18     3813.69
19     4103.95
20     5320.81
21     8555.00
22    10854.10
Name: close, dtype: float64

改变

计算每一行的变化

change = close.diff(1)
print(change)

0         NaN
1     -346.38
2     2084.49
3     3375.96
4     3877.40
5    -3431.26
6       41.66
7    -3402.85
8     2322.10
9    -1761.00
10   -1094.94
11    1340.86
12    -719.72
13    -384.64
14    -254.64
15   -2330.61
16    -338.42
17    -268.80
18     379.59
19     290.26
20    1216.86
21    3234.19
22    2299.10
Name: close, dtype: float64

得与失

从变化中得到得失

is_gain, is_loss = change > 0, change < 0
gain, loss = change, -change
gain[is_loss] = 0
loss[is_gain] = 0

gain.name = 'gain'
loss.name = 'loss'
print(loss)

0         NaN
1      346.38
2        0.00
3        0.00
4        0.00
5     3431.26
6        0.00
7     3402.85
8        0.00
9     1761.00
10    1094.94
11       0.00
12     719.72
13     384.64
14     254.64
15    2330.61
16     338.42
17     268.80
18       0.00
19       0.00
20       0.00
21       0.00
22       0.00
Name: loss, dtype: float64

计算拳头平均 yield 和损失

前 n 行的平均值

n = 14
avg_gain = change * np.nan
avg_loss = change * np.nan

avg_gain[n] = gain[:n+1].mean()
avg_loss[n] = loss[:n+1].mean()

avg_gain.name = 'avg_gain'
avg_loss.name = 'avg_loss'

avg_df = pd.concat([gain, loss, avg_gain, avg_loss], axis=1)
print(avg_df)

       gain     loss  avg_gain    avg_loss
0       NaN      NaN       NaN         NaN
1      0.00   346.38       NaN         NaN
2   2084.49     0.00       NaN         NaN
3   3375.96     0.00       NaN         NaN
4   3877.40     0.00       NaN         NaN
5      0.00  3431.26       NaN         NaN
6     41.66     0.00       NaN         NaN
7      0.00  3402.85       NaN         NaN
8   2322.10     0.00       NaN         NaN
9      0.00  1761.00       NaN         NaN
10     0.00  1094.94       NaN         NaN
11  1340.86     0.00       NaN         NaN
12     0.00   719.72       NaN         NaN
13     0.00   384.64       NaN         NaN
14     0.00   254.64   931.605  813.959286
15     0.00  2330.61       NaN         NaN
16     0.00   338.42       NaN         NaN
17     0.00   268.80       NaN         NaN
18   379.59     0.00       NaN         NaN
19   290.26     0.00       NaN         NaN
20  1216.86     0.00       NaN         NaN
21  3234.19     0.00       NaN         NaN
22  2299.10     0.00       NaN         NaN

平均 yield 和平均损失的第一次计算还可以，但我不知道如何为第二次和后续应用 pandas.core.window.Rolling.apply，因为它们在很多行和不同的列中。它可能是这样的:

avg_gain[n] = (avg_gain[n-1]*13 + gain[n]) / 14

我的愿望-我的问题

计算和使用技术指标的最佳方式？
在“Pandas Style”中完成上述代码。
与 Pandas 相比，传统的循环编码方式是否会降低性能？

最佳答案

平均 yield 和损失是通过递归公式计算的，不能用 numpy 向量化。但是，我们可以尝试找到一个分析(即非递归)解决方案来计算各个元素。然后可以使用 numpy 实现这样的解决方案。

将平均增益表示为 y，将当前增益表示为 x，我们得到 y[i] = a*y[i-1] + b *x[i]，其中 a = 13/14 和 b = 1/14 对于 n = 14。展开递归导致: (对不起，图片不好，打字太麻烦了)

这可以使用 cumsum(rma = 运行移动平均线)在 numpy 中有效计算:

import pandas as pd
import numpy as np

df = pd.DataFrame({'close':[4724.89, 4378.51,6463.00,9838.96,13716.36,10285.10,
                          10326.76,6923.91,9246.01,7485.01,6390.07,7730.93,
                          7011.21,6626.57,6371.93,4041.32,3702.90,3434.10,
                          3813.69,4103.95,5320.81,8555.00,10854.10]})
n = 14


def rma(x, n, y0):
    a = (n-1) / n
    ak = a**np.arange(len(x)-1, -1, -1)
    return np.r_[np.full(n, np.nan), y0, np.cumsum(ak * x) / ak / n + y0 * a**np.arange(1, len(x)+1)]

df['change'] = df['close'].diff()
df['gain'] = df.change.mask(df.change < 0, 0.0)
df['loss'] = -df.change.mask(df.change > 0, -0.0)
df['avg_gain'] = rma(df.gain[n+1:].to_numpy(), n, np.nansum(df.gain.to_numpy()[:n+1])/n)
df['avg_loss'] = rma(df.loss[n+1:].to_numpy(), n, np.nansum(df.loss.to_numpy()[:n+1])/n)
df['rs'] = df.avg_gain / df.avg_loss
df['rsi_14'] = 100 - (100 / (1 + df.rs))

df.round(2) 的输出:

         close   change     gain     loss  avg_gain  avg_loss    rs    rsi  rsi_14
0      4724.89      NaN      NaN      NaN       NaN       NaN   NaN    NaN     NaN
1      4378.51  -346.38     0.00   346.38       NaN       NaN   NaN    NaN     NaN
2      6463.00  2084.49  2084.49     0.00       NaN       NaN   NaN    NaN     NaN
3      9838.96  3375.96  3375.96     0.00       NaN       NaN   NaN    NaN     NaN
4     13716.36  3877.40  3877.40     0.00       NaN       NaN   NaN    NaN     NaN
5     10285.10 -3431.26     0.00  3431.26       NaN       NaN   NaN    NaN     NaN
6     10326.76    41.66    41.66     0.00       NaN       NaN   NaN    NaN     NaN
7      6923.91 -3402.85     0.00  3402.85       NaN       NaN   NaN    NaN     NaN
8      9246.01  2322.10  2322.10     0.00       NaN       NaN   NaN    NaN     NaN
9      7485.01 -1761.00     0.00  1761.00       NaN       NaN   NaN    NaN     NaN
10     6390.07 -1094.94     0.00  1094.94       NaN       NaN   NaN    NaN     NaN
11     7730.93  1340.86  1340.86     0.00       NaN       NaN   NaN    NaN     NaN
12     7011.21  -719.72     0.00   719.72       NaN       NaN   NaN    NaN     NaN
13     6626.57  -384.64     0.00   384.64       NaN       NaN   NaN    NaN     NaN
14     6371.93  -254.64     0.00   254.64    931.61    813.96  1.14  53.37   53.37
15     4041.32 -2330.61     0.00  2330.61    865.06    922.29  0.94  48.40   48.40
16     3702.90  -338.42     0.00   338.42    803.27    880.59  0.91  47.70   47.70
17     3434.10  -268.80     0.00   268.80    745.90    836.89  0.89  47.13   47.13
18     3813.69   379.59   379.59     0.00    719.73    777.11  0.93  48.08   48.08
19     4103.95   290.26   290.26     0.00    689.05    721.60  0.95  48.85   48.85
20     5320.81  1216.86  1216.86     0.00    726.75    670.06  1.08  52.03   52.03
21     8555.00  3234.19  3234.19     0.00    905.86    622.20  1.46  59.28   59.28
22    10854.10  2299.10  2299.10     0.00   1005.37    577.75  1.74  63.51   63.51

关于你关于性能的最后一个问题:python/pandas 中的显式循环很糟糕，尽可能避免它们。如果不行，试试cython or numba .

为了说明这一点，我将我的 numpy 解决方案与 dimitris_ps 的 loop solution 做了一个小的比较。 :

import pandas as pd
import numpy as np
import timeit

mult = 1        # length of dataframe = 23 * mult
number = 1000   # number of loop for timeit

df0 = pd.DataFrame({'close':[4724.89, 4378.51,6463.00,9838.96,13716.36,10285.10,
                          10326.76,6923.91,9246.01,7485.01,6390.07,7730.93,
                          7011.21,6626.57,6371.93,4041.32,3702.90,3434.10,
                          3813.69,4103.95,5320.81,8555.00,10854.10] * mult })
n = 14

def rsi_np():
    # my numpy solution from above
    return df
    
def rsi_loop():
    # loop solution https://stackoverflow.com/a/57008625/3944322
    # without the wrong alternative calculation of df['avg_gain'][14]
    return df

df = df0.copy()
time_np = timeit.timeit('rsi_np()', globals=globals(), number = number) / 1000 * number

df = df0.copy()
time_loop = timeit.timeit('rsi_loop()', globals=globals(), number = number) / 1000 * number

print(f'rows\tnp\tloop\n{len(df0)}\t{time_np:.1f}\t{time_loop:.1f}')

assert np.allclose(rsi_np(), rsi_loop(), equal_nan=True)

结果(毫秒/循环):

rows    np    loop
23      4.9   9.2
230     5.0   112.3
2300    5.5   1122.7

因此，即使对于 8 行(第 15...22 行)，循环解决方案的时间也是 numpy 解决方案的两倍。 Numpy 的扩展性很好，而循环解决方案不适用于大型数据集。

关于python - 从 pandas DataFrame 计算 RSI 指标？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/57006437/

文章推荐： python - Keras:模型和图层有什么区别？

文章推荐： python - 在数据框中的列表中查找元素

文章推荐： c# - 闪屏上的淡入淡出效果

文章推荐： c# - 如何计算嵌套类别中项目的总数(自引用类别表)

c# - RSI vs Wilder 的 RSI 计算问题
我无法获得平滑的 RSI。下图来自 freestockcharts.com。计算使用此代码。 public static double CalculateRsi(IEnumerable closePr
vim - 如何重新映射键盘键以避免 VIM 中的 RSI
我希望这不会被视为纯粹为了这样做而试图引发对话。我经常使用 vim(每天 5-10 小时)，我注意到我的左手腕首先开始疼痛。标准键盘布局(见下图)几乎肯定会给你带来关节炎。目前，我已经重新映射 C
javascript - 我可以为 highcharts RSI 指标添加自定义数据吗？
我正在寻找何时能够为 RSI 指标添加自己的数据。在图片 RSI 指标上，我可以使用接下来的代码行添加: id: 'AAPL', type: 'rsi', params: { period: 1
vim - 重新映射 Vim 键以避免左手出现 RSI
我的左手腕总是受到 RSI 的困扰(参见 here )，我认为这是因为按下 ctrl 和 shift 键时发生的扭转 Action 。因此，我继续购买了Advantage Kinesis keyboa
emacs - 在没有 RSI 的情况下输入 latex
按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the
linux - movq (%rsi), %rcx 谁能告诉我这是什么意思？
这是 ../sysdeps/x86_64/memcpy.S 中的一行，在这行之后我遇到了 VM 崩溃，所以我需要知道发生了什么。基本上我知道它类似于将 rsi 复制到 rcx。但这是否意味着 rsi
python - 从 Pandas 数据帧计算 RSI
这个问题在这里已经有了答案: Relative Strength Index in python pandas (11 个答案) 关闭 2 年前。我有一个来自外汇市场的值(value) df，我正
python - 如何在 Python 中实现 RSI Divergence
我想知道是否有任何涵盖 RSI-Divergence 的 Python 库(快速和慢速之间的差异 RSI )或有关如何在 Python 中实现其算法的任何指导。已提问:Programmaticall
javascript - 基于 Kraken OHLC 计算 RSI
我想准确反射(reflect) cryptowatch.de 上的 RSI 值(在我的例子中是 LTC-EUR)，我使用了网站 stockcharts.com ，解释了如何计算 RSI，用 Javas
pine-script - 如何从 TradingView Pine 脚本中的不同图表获取每小时 RSI？
我正在以 1 分钟的分辨率编写硬币 A 的策略。现在我需要获得硬币 B 的每小时 RSI。我试过: btcusdtHour = security("BITTREX:BTCUSDT", "60", c
c# - 将 RSI 从 pinescript 转换为 C#？
来自 Trading View ，我们看到 rsi 可以用 pinescript 写成如下: pine_rsi(x, y) => u = max(x - x[1], 0) // upward
assembly - Intel 64、rsi 和 rdi 寄存器
在 Intel x86 64 位架构中，有 rax...rdx 寄存器，它们只是 A...D 通用寄存器。但也有称为rsi和rdi的寄存器，它们分别是“源索引”和“目标索引”寄存器。为什么这些寄存器
c# - 使用某种编程语言 (JS/C#..) 计算 RSI(相对强弱指数)
我正在计算 RSI (相对强度指数)。我有这样的数据 **Date|Close|Change|Gain|Loss** 计算公式为 RSI = 100 - 100/(1+RS) where RS = A
python - 从 pandas DataFrame 计算 RSI 指标？
我的问题我在 Github 上尝试了很多库，但它们都没有为 TradingView 生成匹配结果，所以我遵循了这个 link 上的公式计算 RSI 指标。我用 Excel 计算并用 TradingV
pine-script - 如何在 pinescript 中为 TradingView 开发多个时间框架 RSI
我正在尝试在交易 View 上使用 pine-script 开发一个多时间框架 RSI，但我似乎在长期图表 View 中遇到了短期 RSI 的问题。例如，以下代码将显示 5 分钟 RSI。如果我将图
python - pine 脚本如何使用 2 系列而不是 1 和一个周期来计算 RSI？
我有一个 pine 脚本，我正在尝试将其转换为 python。但是，pine 脚本允许 RSI 有 2 个系列作为输入，而不是传统的系列和周期。我的问题是这是如何实现的，我在他们的文档中尝试了实现
sql - 基于郁金香指标的 C 语言函数，使用 postgresql 计算 RSI
是否可以在数据库中实现RSI功能？ https://github.com/TulipCharts/tulipindicators我在 postgresql 表中有市场数据，我想根据这些数据计算 RSI
c - 指令 mov %edi 和 mov %rsi 有什么作用？
我编写了一个基本的 C 程序，它定义了一个整型变量 x，将其设置为零并返回该变量的值: #include int main(int argc, char **argv) { int x;
Connors RSI Calculation Python Not Calculating Correctly(Connors RSI计算Python计算不正确)
我正在试着用熊猫和NumPy来计算蟒蛇中的Connors RSI。我想用ConnorsRSI的默认值(3，2,100)来计算它。。Connors RSI的公式为：[RSI(Close，3)+RSI(S
.NET:无法从 TA-Lib 获得正确的 RSI 和 MACD 值
我正在尝试使用 TA-Lib 进行技术分析。我下载了 .NET 的 TA-Lib-Core Nuget 包。不幸的是，我找不到任何 API 文档，所以一些方法参数有点神秘。我下载了 2016 年 4

太空狗

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城