[PYTHON] [Einführung in Systre] Fibonacci Retracement ♬

Dieses Mal habe ich als Anwendung von Lernfunktionen und Klassen eine Klasse zur Berechnung der Fibonacci-Sequenz erstellt und damit gespielt. Wenden Sie auch die in der vorherigen Einführung zu Pandas erstellte Fx- und Aktienkurs-App an. Ich werde die erstellte Anwendung als Bonus setzen.

Ich habe den folgenden Code eingegeben

MuAuan/FibonacciRetracement

Haben Sie zuerst die folgende Zahlenfolge gesehen?

Fibonacci-Folge

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　．．．

Diese Zahlenfolge hat die folgenden Eigenschaften.

Verhältnis benachbarter Zahlen

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 ．．．

Goldener Schnitt

Das heißt, die obigen Konvergenzwerte haben die folgende Beziehung.

\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}

Das heißt, dieses Verhältnis ist die Lösung der quadratischen Gleichung $ x ^ 2-x-1 = 0 $.

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

Von diesen beiden Lösungen ist die positive das obige Verhältnis, das in vielen Situationen in der Natur als goldener Schnitt $ \ phi = \ frac {1 + \ sqrt5} {2} = 1,618 ... $ bezeichnet wird. Begegnung. Die Umkehrung ist auch die Lösung von $ x ^ 2 + x-1 = 0 $, $ x = \ frac {-1 + \ sqrt5} {2} = \ phi -1 $ und $ = \ phi '$ Es stellt sich heraus, dass die obige Beziehung erfüllt ist. Als Referenz gibt es Beispiele wie Sonnenblumen.

【Referenz】 [Anzahl der 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)

Fibonacci-Retracement

In der Welt der Cistre wird "Fibonatch Retracement" als Referenzkommentar als Index verwendet, um das Kursziel eines Squeeze auf dem Aufwärtsmarkt und einer vorübergehenden Rendite auf dem Abwärtsmarkt zu beurteilen. " Aus Lit. (2) geht hervor, dass "Retracement" sogenannter "Twill Push" und "Twill Return" ist. Mit anderen Worten, es handelt sich um einen vorübergehenden rückläufigen Preis im gebildeten Trend. "" 【Referenz】 ① Fibonacci Retracement ② Retracement Presser Wissen vier Punkte @ Dieses Mal möchte ich dies überprüfen, indem ich auf "3/4, 2/3, 1/2, 1/3, 1/4" der Referenz ② achte.

Überprüfung

Das Ziel war ZARJPY = X in Südafrika, was in FX angeblich allgemein schwierig ist. ① Betrachten Sie zunächst in der Fibonacci-Zahlenfolge das Retracement zwischen Auf- und Abwärtsbewegung wie gewohnt für einen angemessenen Zeitraum. Infolgedessen scheint die Rendite nach 2020,5 nach Erreichen des niedrigeren Preises ordnungsgemäß auf der Prognoselinie zu liegen. Es sollte hier angemerkt werden, dass wir, obwohl wir von einem schlampigen Ort aus gestartet sind, die Rendite fast reproduziert haben, und es scheint, dass viele der Spitzen auf der linken Seite des niedrigeren Preises auch in der Nähe der gezeichneten Linie zurückkehren.

• Es ist eine große Frage, was die Tatsache, dass diese Renditen für die Verwendung des niedrigeren Preises geeignet sind, der der zukünftige Wert ist, aussagt.

Das Retracement zwischen dem oberen und dem unteren Preis wird durch die folgende Funktion berechnet. In der Bezeichnung m618d bedeutet d n = 2, t bedeutet 3 ... Außerdem ist m50 die 50% -Linie.

def M618_(x, n):
    #Finden Sie das Retracement zwischen der unteren und oberen Grenze
    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) Stellen Sie den Zeitraum auf 2020.1.1-2020.8.14 ein und ziehen Sie einen klaren oberen und unteren Preis, damit er in der Hälfte des Zeitraums eingegeben wird. Zusätzlich werde ich ein Fibonacci-Retracement in der Nähe des oberen Preises hinzufügen. Die Ergebnisse zeigen, dass es sich seit Mitte 2020 auf der Prognoselinie bewegt.4. Darüber hinaus scheint auch hier die Rückverfolgung des Zeitraums links vom niedrigeren Preis wiedergegeben zu sein.

Hier wird zusätzlich zu dem oben Gesagten eine Zeile in der Nähe des oberen Preises durch die folgende Funktion hinzugefügt. Das Label m618_3 bedeutet n = 3.

def M618_1(x, n):
    #Finden Sie das Retracement in der Nähe der Obergrenze
    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

③ Zeichnen wir nun den Zeitraum als 2019.4.1-2020.8.14. In dieser Abbildung werden der obere Preis von 2019,4 und der untere Preis von 2019,9 verwendet, um den nachfolgenden Übergang vorherzusagen. Auch in diesem Fall kann das Verhalten dieser Preisspanne in der nächsten Periode vorhergesagt werden. Darüber hinaus konnte der nachfolgende Übergang, obwohl er im Jahr 2020 unter dem niedrigeren Preis lag.3, eine hohe Rendite und Erholung erzielen. Insbesondere ist es gut, in der Lage zu sein, m618_20 (nächster unterster Preis) vorherzusagen, und wenn sich der niedrigere Preis ändert, wenn die nächste Vorhersage erneut gemacht wird, kann der nachfolgende Übergang genauer vorhergesagt werden, wie in der obigen Grafik gezeigt. Nachfolgende Rückgaben wie m618_23 können jedoch fast vorhergesagt werden und sind nicht erforderlich. Die Vorhersage unter dem niedrigeren Preis wird durch die folgende Funktion durchgeführt. Die Bezeichnung lautet m618_23, wobei 23 n = 3 bedeutet.

def M618_2(x, n):
    #Finden Sie das Retracement unterhalb der Untergrenze
    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

Standard Preis

Wie unten gezeigt, stimmen die Aktienkurse und Retracements gut überein.

Versuchen Sie rationale Zahlen

Wenn wir die Fibonacci-Zahlenfolge und die Folge der rationalen Zahl (Bruchverhältnis) vergleichen, können wir sie an fast den entsprechenden Positionen finden, wie unten gezeigt. Da es also auch die Referenzgeschichte (2) gibt, werde ich versuchen, das Retracement auf die gleiche Weise mit dem Bruchverhältnis zu berechnen und zu vergleichen.

Die rationale Zahl ist eine intuitive Zahl (in der Tabelle), obwohl es andere rationale Zahlen gibt.

Das Ergebnis ist wie folgt (1) Zeitraum und Bedingungen gemäß (1) der Überprüfung Das Ergebnis zeigt, dass die Retracement-Linien wieder gut ausgerichtet sind. ③ Zeitraum und Bedingungen, die ③ der Überprüfung entsprechen Wie unten gezeigt, wird die Position der Rückgabe erheblich reproduziert. Es scheint, dass es fast keine Überlegenheit oder Unterlegenheit gibt. Der Grund, warum -50% und -100%, wenn der Preis aus dem niedrigeren Preis ausbricht, kann sein, dass sie sich an erster Stelle an derselben Position befinden, aber wie oben erwähnt, ist die ursprüngliche Ursache, dass es numerische Werte in ähnlichen Positionen gibt. ich denke, dass Der numerische Vergleich der Positionen unter dem niedrigeren Preis ist wie folgt. Einige Zeilen entsprechen nicht rationalen Zahlen, aber wie in ① zu sehen, können Sie es machen, wenn Sie versuchen, es zu machen.

Diskussion

Der interessante Teil dieser Geschichte ist, dass dieses Auf und Ab auch dann existiert, wenn es expandiert oder schrumpft, und es scheint einen Index zu geben, der durch den goldenen Schnitt in den unendlichen oberen und unteren Preisen dargestellt wird. Es ist im Ort. Das heißt, es besteht die Möglichkeit eines der sogenannten fraktalen Phänomene. In dieser Geschichte geht es nicht darum, vorherzusagen, ob es steigen wird, ob es sich um Devisen oder Aktienkurse handelt. Wenn jedoch im Trend ein Retracement (Return) auftritt, bedeutet dies, dass der durch diesen Koeffizienten berechnete Wert zurückgegeben oder abgestoßen wird. In der Vergangenheit dachten Leute, sie hätten diese Fibonacci-Sequenz eingeführt, weil sie in die Augen und durch Kalkül investiert hätten, also hätten sie es mit einer rationalen Denkweise getan, aber jetzt tun sie es mit Systre. Kann als gut beurteilt werden. Ich denke, dass es eine Abkürzung zum Erfolg ist, diese Art von Wissen einzubeziehen und auch nur ein wenig wissenschaftliche Investition zu tätigen.

Zusammenfassung

・ Erstellt eine Klasse zur Berechnung der Fibonacci-Zahlenfolge mit hoher Geschwindigkeit ・ Als Anwendung haben wir das Fibonacci-Retracement überprüft. ・ Das Fibonacci-Retracement wird sowohl für Devisen- als auch für Aktienkurse festgelegt. ・ Als Ergebnis der Überprüfung eines ähnlichen Retracement mit rationalen Zahlen wurde festgestellt, dass fast dieselbe Vorhersagelinie berechnet werden kann.

・ Um es in Systre einzuführen, muss aus den sich ständig ändernden Zeitreihenzahlen ein geeignetes Fibonacci-Retracement berechnet werden.

Bonus

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):
    #Finden Sie das Retracement zwischen der unteren und oberen Grenze
    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):
    #Finden Sie das Retracement unterhalb der Untergrenze
    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):
    #Finden Sie das Retracement in der Nähe der Obergrenze
    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):
    #Ich suche 50% Retracement
    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):
    #Finden Sie ein zusätzliches 50% Retracement unterhalb der Untergrenze
    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 #Datenbereich zum Finden von Ober- und Untergrenzen, Verhältnis um alle Daten
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)
#Finden Sie das Retracement in der Nähe der Obergrenze
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)
#Finden Sie das Retracement unterhalb der Untergrenze
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)
#Finden Sie das Retracement zwischen der unteren und oberen Grenze
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()