[PYTHON] [Introduction au système] Retracement de Fibonacci ♬

Cette fois, en tant qu'application des fonctions d'apprentissage et des classes, j'ai créé une classe pour calculer la séquence de Fibonacci et j'ai joué avec. Appliquez également l'application Fx and Stock Price créée dans l'introduction précédente de Pandas. Je mettrai l'application créée en bonus.

Je mets le code ci-dessous

MuAuan/FibonacciRetracement

Tout d'abord, avez-vous vu la séquence de numéros suivante?

Séquence de Fibonacci

F_n

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155　．．．

Cette chaîne numérique a les propriétés suivantes.

Rapport des nombres adjacents

F_n/F_{n+1}

1.00000 1.00000 0.50000 0.66667 0.60000 0.62500 0.61538 0.61905 0.61765 0.61818 0.61798 0.61806 0.61803 0.61804 0.61803 0.61803 ．．．

F_{n+1}/F_n

1.00000 1.00000 2.00000 1.50000 1.66667 1.60000 1.62500 1.61538 1.61905 1.61765 1.61818 1.61798 1.61806 1.61803 1.61804 1.61803 ．．．

nombre d'or

Autrement dit, les valeurs de convergence ci-dessus ont la relation suivante.

\begin{align}
\frac{F_{n+1}}{F_n} &=& 1 + \frac{F_n}{F_{n+1}} \\
(\frac{F_{n+1}}{F_n})^2 &=& \frac{F_{n+1}}{F_n} + 1
\end{align}

Autrement dit, ce rapport est la solution de l'équation quadratique $ x ^ 2-x-1 = 0 $.

x＝\frac{1\pm\sqrt5}{2}

De ces deux solutions, la positive est le rapport ci-dessus, appelé le nombre d'or $ \ phi = \ frac {1 + \ sqrt5} {2} = 1,618 ... $, dans de nombreuses situations dans la nature. Rencontre. De plus, l'inverse est la solution de $ x ^ 2 + x-1 = 0 $, $ x = \ frac {-1 + \ sqrt5} {2} = \ phi -1 $, et $ = \ phi '$ Il s'avère que la relation ci-dessus est satisfaite. Pour référence, il existe des exemples tels que les tournesols.

【référence】 [Nombre de Fibonacci](https://ja.wikipedia.org/wiki/%E3%83%95%E3%82%A3%E3%83%9C%E3%83%8A%E3%83%83%E3% 83% 81% E6% 95% B0)

Retracement de Fibonacci

Dans le monde du cistre, comme commentaire de référence, le «retracement Fibonatch» est utilisé comme un indice pour juger de l'objectif de cours d'un resserrement du marché haussier et d'un retour temporaire du marché baissier. » D'après la référence (2), "le retracement est ce que l'on appelle" push twill "et" twill return ". En d'autres termes, il s'agit d'un prix rétrograde temporaire dans la tendance formée. " 【référence】 ① Retracement Fibonacci ② Connaissance du presseur de retracement quatre points @ Cette fois, je voudrais vérifier en faisant attention à "3/4, 2/3, 1/2, 1/3, 1/4" de la référence ②.

Vérification

L'objectif était ZARJPY = X en Afrique du Sud, qui serait généralement difficile en FX. ① Tout d'abord, dans la séquence de nombres de Fibonacci, regardez le retracement entre le haut et le bas comme d'habitude pendant une période appropriée. En conséquence, il semble que le retour après 2020.5 après avoir atteint le prix inférieur soit correctement sur la ligne de prédiction. Il convient de noter ici que même si nous sommes partis d'un endroit négligé, nous avons presque reproduit le retour, et il semble que de nombreux pics sur le côté gauche du prix inférieur reviennent également près de la ligne tracée.

• C'est une grande question de savoir ce que dit le fait que ces rendements soient adaptés à l'utilisation du prix inférieur, qui est la valeur future.

Le retracement entre les prix supérieur et inférieur est calculé par la fonction suivante. Dans l'étiquette m618d, d signifie n = 2, t signifie 3 ... De plus, m50 est la ligne à 50%.

def M618_(x, n):
    #Trouvez le retracement entre les limites inférieure et supérieure
    f = 1
    for i in range(0,n,1):
        f *= f_ratio
    m618 = pd.Series(x).min() + f*(pd.Series(x).max()-pd.Series(x).min())
    return m618

(2) Définissez la période sur 2020.1.1-2020.8.14 et dessinez un prix supérieur et inférieur clair afin qu'il soit entré dans la moitié de la période. De plus, j'ajouterai un retracement de Fibonacci proche du prix supérieur. Les résultats montrent qu'il évolue sur la ligne de prévision depuis la mi-2020. De plus, il semble que le retracement de la période à gauche du prix inférieur soit également reproduit ici.

Ici, en plus de ce qui précède, une ligne près du prix supérieur est ajoutée par la fonction suivante. L'étiquette m618_3 signifie n = 3.

def M618_1(x, n):
    #Trouvez le retracement près de la limite supérieure
    f = 1
    for i in range(0,n,1):
        f *= f_ratio
    m618 = pd.Series(x).max() - f*(pd.Series(x).max()-pd.Series(x).min())
    return m618

③ Maintenant, dessinons la période 2019.4.1-2020.8.14. Dans cette figure, le prix supérieur de 2019.4 et le prix inférieur de 2019.9 sont utilisés pour prédire la transition ultérieure. Dans ce cas également, le comportement de cette fourchette de prix dans la période suivante peut être prédit. En outre, bien qu'il soit passé en dessous du prix inférieur en 2020.3, la transition ultérieure a pu reproduire un retour et un rebond importants. En particulier, il est bon de pouvoir prédire m618_20 (prochain prix bas), et si le prix le plus bas change, si la prochaine prédiction est faite à nouveau, la transition suivante peut être prédite plus précisément comme le montre le graphique ci-dessus. Cependant, les retours ultérieurs tels que m618_23 peuvent être presque prédits, et ce n'est pas nécessaire. La prédiction en dessous du prix le plus bas est effectuée par la fonction suivante. Le libellé est m618_23, où 23 signifie n = 3.

def M618_2(x, n):
    #Trouver le retracement en dessous de la limite inférieure
    f = 1
    for i in range(0,n,1):
        f *= f_ratio
    m618 = pd.Series(x).min() - f*(pd.Series(x).max()-pd.Series(x).min())
    return m618

Prix de l'action

Comme indiqué ci-dessous, les cours des actions et les retracements sont en bon accord.

Essayez les nombres rationnels

En comparant la séquence de nombres de Fibonacci et la séquence de nombres rationnels (rapport de fraction), nous pouvons les trouver presque aux positions correspondantes, comme indiqué ci-dessous. Donc, puisqu'il y a aussi l'histoire de référence (2), je vais essayer de calculer et comparer le retracement de la même manière avec le rapport de fraction.

Le nombre rationnel est un nombre intuitif (sur le graphique), bien qu'il existe d'autres nombres rationnels.

Le résultat est le suivant (1) Période et conditions correspondant à (1) de vérification Le résultat montre que les lignes de retracement sont à nouveau bien alignées. ③ Période et conditions correspondant à ③ de vérification Comme illustré ci-dessous, la position du retour est reproduite considérablement. Il semble qu'il n'y ait presque aucune supériorité ou infériorité. La raison pour laquelle -50% et -100% lorsque le prix s'écarte du prix inférieur peut être qu'ils sont dans la même position en premier lieu, mais comme mentionné ci-dessus, la cause initiale est qu'il existe des valeurs numériques dans des positions similaires. je pense que La comparaison numérique des positions en dessous du prix inférieur est la suivante. Certaines lignes ne correspondent pas à des nombres rationnels, mais comme on le voit dans ①, si vous essayez de le faire, vous pouvez le faire.

Discussion

La partie intéressante de cette histoire est que ces hauts et ces bas existent même s'ils se développent ou se contractent, et il semble y avoir un indice représenté par le nombre d'or dans les prix supérieurs et inférieurs infinis. C'est à la place. Autrement dit, il existe une possibilité d'un des soi-disant phénomènes fractaux. Cette histoire ne consiste pas à prédire si elle augmentera, qu'il s'agisse de devises ou de cours boursiers. Cependant, si le retracement (retour) se produit dans la tendance, cela signifie qu'il retourne ou se repousse autour de la valeur calculée par ce coefficient. Dans le passé, des gens qui pensaient qu'ils auraient introduit cette séquence de Fibonacci parce qu'ils auraient investi dans les yeux et par calcul, donc ils l'auraient fait avec une façon de penser rationnelle, mais maintenant ils le font avec Systre. Peut être jugé bon. Je pense qu'incorporer ce type de connaissances et faire ne serait-ce qu'un petit investissement scientifique est un raccourci vers le succès.

Résumé

・ Création d'une classe pour calculer la séquence de nombres de Fibonacci à grande vitesse ・ En tant qu'application, nous avons vérifié le retracement de Fibonacci. ・ Le retracement de Fibonacci est établi pour les prix fx et boursiers. ・ Suite à la vérification d'un retracement similaire avec des nombres rationnels, il a été constaté que presque la même ligne de prédiction peut être calculée.

・ Afin de l'introduire dans Systre, il est nécessaire de calculer un retracement de Fibonacci approprié à partir des numéros de séries chronologiques en constante évolution.

prime

fibonacci

class_fibonacci.py

import numpy as np

class MyFibonacciClass:
    f_const = 0.6180339887498949 #514229/832040 #0.6180
    def __init__(self,x=1,y=0,n=10):
        self.x = x
        self.y = y
        self.n = n
                
    def calc_1(self,n):
        const = 1
        for i in range(1,n):
            const *= MyFibonacciClass.f_const
        return const, self.y + const*(self.x - self.y), self.x - const*(self.x - self.y)
    def calc_1_(self,n):
        const = 1
        for i in range(1,n):
            const *= MyFibonacciClass.f_const
        return self.y + (1-const)*(self.x - self.y)
    
    def calc_fib(self,m, sb1,sb2):
            if m ==1 or m== 2:
                return 1
            else:
                return sb1 + sb2
    def calc_fib2(self,m):
            if m ==1 or m== 2:
                return 1
            else:
                return MyFibonacciClass.calc_fib2(self,m-1) + MyFibonacciClass.calc_fib2(self,m-2)
            
    def calc_fib3(self, m): 
        # fastest m=100000;108 ms ± 4.01 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
        a, b = 1, 1
        for _ in range(m-2):
            a, b = b, a + b
        return b
    
    def calc_fib4(self,m): # m =< 70
        return round((((1 + 5 ** 0.5) / 2) ** m - ((1 - 5 ** 0.5) / 2) ** m) / 5 ** 0.5)
  
    def calc_print(self):
        sb1 = 1
        sb2 = 1
        for n0 in range(1,self.n+1):
            s = MyFibonacciClass.calc_fib(self,n0, sb1, sb2)
            print(n0, s,end=' ')
            #print(s,end=' ')
            rs = np.float64(sb1/s)
            rs1 = np.float64(s/sb1)
            print(rs, rs1)
            #print('{0:5,.5f}'.format(rs1), end=' ')
            sb2 = sb1
            sb1 = s
            
if __name__ == '__main__':
    fibonacci1 = MyFibonacciClass(1604.5,834.6,10)
    for i in range(1,11,1):
        c,a,b = fibonacci1.calc_1(i)
        print('{0:5,.3f}_{1:5,.3f}_{2:5,.3f}'.format(c,a,b))

    fibonacci2 = MyFibonacciClass(1604.5,834.6,10000)
    fibonacci2.calc_print()
    print(fibonacci2.calc_fib3(1000000))

fx_plot.py

fx_plot.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

import datetime as dt
import statsmodels.api as sm
from statsmodels.tsa.seasonal import STL
import pandas_datareader.data as DataReader

stock0='ZARJPY=X'  #'USDJPY=X' #'EURJPY=X' #AUDJPY=X JPYAUD=X ZARJPY=X GBPJPY=X JPYUSD=X
bunseki = "trend"
start = dt.date(2018,1,1)
end = dt.date(2020,8,14)

df=DataReader.get_data_yahoo("{}".format(stock0),start,end) 
print(df)

series=df['Close']
cycle, trend = sm.tsa.filters.hpfilter(series, 144)
df['trend']=  trend
f_ratio = 0.6180339887498949

def MAX_(x):
    return pd.Series(x).max()
def MIN_(x):
    return pd.Series(x).min()
def M618_(x, n):
    #Trouvez le retracement entre les limites inférieure et supérieure
    f = 1
    for i in range(0,n,1):
        f *= f_ratio
    m618 = pd.Series(x).min() + f*(pd.Series(x).max()-pd.Series(x).min())
    return m618
def M618_2(x, n):
    #Trouver le retracement en dessous de la limite inférieure
    f = 1
    for i in range(0,n,1):
        f *= f_ratio
    m618 = pd.Series(x).min() - f*(pd.Series(x).max()-pd.Series(x).min())
    return m618
def M618_1(x, n):
    #Trouvez le retracement près de la limite supérieure
    f = 1
    for i in range(0,n,1):
        f *= f_ratio
    m618 = pd.Series(x).max() - f*(pd.Series(x).max()-pd.Series(x).min())
    return m618
def M50_(x, n):
    #Rechercher un retracement à 50%
    f = 1
    for i in range(0,n,1):
        f *= 0.5
    m618 = pd.Series(x).max() - f*(pd.Series(x).max()-pd.Series(x).min())
    return m618
def M50_1(x, n):
    #Trouvez un retracement supplémentaire de 50% en dessous de la limite inférieure
    f = 1
    for i in range(0,n,1):
        f *= 0.5
    m618 = pd.Series(x).min() - f*(pd.Series(x).max()-pd.Series(x).min())
    return m618


series2 = df['trend'].values.tolist()
print(series2[len(series2)-10:len(series2)])
m = 1/5 #Plage de données pour trouver les limites supérieures et inférieures; rapport autour de toutes les données
df['Close']=series  #series" #cycle" #trend
df['Close2']=series2
df['max'] = MAX_(df['Close'][:int(len(series)*m)])
df['min'] = MIN_(df['Close'][:int(len(series)*m)])
df['m50'] = M50_(df['Close'][:int(len(series)*m)],1)
df['m50_1'] = M50_1(df['Close'][:int(len(series)*m)],1)
#Trouvez le retracement près de la limite supérieure
df['m618_3'] = M618_1(df['Close'][:int(len(series)*m)],3)
df['m618_4'] = M618_1(df['Close'][:int(len(series)*m)],4)
df['m618_5'] = M618_1(df['Close'][:int(len(series)*m)],5)
#Trouver le retracement en dessous de la limite inférieure
df['m618_20'] = M618_2(df['Close'][:int(len(series)*m)],0)
df['m618_21'] = M618_2(df['Close'][:int(len(series)*m)],1)
df['m618_22'] = M618_2(df['Close'][:int(len(series)*m)],2)
df['m618_23'] = M618_2(df['Close'][:int(len(series)*m)],3)
df['m618_24'] = M618_2(df['Close'][:int(len(series)*m)],4)
#Trouvez le retracement entre les limites inférieure et supérieure
df['m618'] = M618_(df['Close'][:int(len(series)*m)],1)
df['m618d'] = M618_(df['Close'][:int(len(series)*m)],2)
df['m618t'] = M618_(df['Close'][:int(len(series)*m)],3)
df['m618q'] = M618_(df['Close'][:int(len(series)*m)],4)
df['m618q5'] = M618_(df['Close'][:int(len(series)*m)],5)
df['m618q6'] = M618_(df['Close'][:int(len(series)*m)],6)

date_df=df['Close'].index.tolist()
print(df[len(series)-10:len(series)])

fig, ax1 = plt.subplots(1,1,figsize=(1.6180 * 8, 8*1),dpi=200)
ax1.plot(df['Close'],label="series")
ax1.plot(df['Close2'],label="series2")
ax1.plot(df['max'],label="max")
ax1.plot(df['min'],'black',label="min")
ax1.plot(df['m50'],'blue',label="m50")
ax1.plot(df['m50_1'],'blue',label="m50_1")
ax1.plot(df['m618_3'],label="m618_3")
ax1.plot(df['m618_4'],label="m618_4")
ax1.plot(df['m618_5'],label="m618_5")
ax1.plot(df['m618_20'],label="m618_20")
ax1.plot(df['m618_21'],label="m618_21")
ax1.plot(df['m618_22'],label="m618_22")
ax1.plot(df['m618_23'],label="m618_23")
ax1.plot(df['m618_24'],label="m618_24")
ax1.plot(df['m618'],label="m618")
ax1.plot(df['m618d'],label="m618d")
ax1.plot(df['m618t'],label="m618t")
ax1.plot(df['m618q'],label="m618q")
ax1.plot(df['m618q5'],label="m618q5")
ax1.plot(df['m618q6'],label="m618q6")

ax1.set_title("{}".format(stock0))
ax1.legend()
#ax1.grid()
plt.savefig("./fx/fx_{}_ema_df_decompose_{}_{}ex{}.png ".format(stock0,start,end,m))
plt.pause(1)
plt.close()