Trading algoritmico con Python - pagina 23

[MetaQuotes]

Normalizzazione e creazione di sequenze Crypto RNN - Deep Learning con Python, TensorFlow e Keras p.9

Normalizzazione e creazione di sequenze Crypto RNN - Deep Learning con Python, TensorFlow e Keras p.9

Salve a tutti e bentornati a un altro episodio della serie di tutorial Deep Learning with Python, TensorFlow e Chaos. In questo video, continueremo a lavorare sul nostro mini-progetto di implementazione di una rete neurale ricorrente (RNN) per prevedere i futuri movimenti di prezzo di una criptovaluta. Useremo le sequenze dei prezzi e dei volumi della valuta, insieme ad altri tre prezzi e volumi di criptovaluta.

Finora abbiamo ottenuto i dati, li abbiamo uniti e creato gli obiettivi. Ora, passiamo ai passaggi successivi. Dobbiamo creare sequenze dai dati ed eseguire attività come il bilanciamento, la normalizzazione e il ridimensionamento. Tuttavia, prima di addentrarsi in questi compiti, è fondamentale affrontare la questione dei test fuori campione.

Quando si ha a che fare con dati temporali e di serie temporali, mescolare e selezionare casualmente una parte come dati fuori campione può portare a un modello distorto. Nel nostro caso, con sequenze di 60 minuti e una finestra di previsione di 3 minuti, la selezione casuale dei dati fuori campione potrebbe comportare la presenza di esempi simili sia nell'insieme in campione che in quello fuori campione. Ciò renderebbe più facile per il modello sovradimensionarsi e funzionare male su dati invisibili.

Per affrontare questo problema, dobbiamo selezionare attentamente i dati fuori campione. Per i dati delle serie temporali, si consiglia di scegliere una porzione di dati dal futuro come set fuori campione. Nel nostro caso, prenderemo l'ultimo 5% dei dati storici come dati fuori campione. Questo approccio simula la creazione del modello il 5% del tempo fa e il test successivo.

Ora, implementiamo questa separazione dei dati fuori campione. Ordineremo i dati in base al timestamp e troveremo la soglia dell'ultimo 5% di volte. Separando i dati in questo modo, ci assicuriamo che il set fuori campione contenga dati dal futuro, prevenendo fughe di dati e test distorti. Una volta separati, avremo i dati di validazione e i dati di addestramento.

Prima di procedere oltre, è importante notare che è necessario preelaborare sia i dati di convalida che quelli di addestramento. Creeremo sequenze, bilanceremo i dati, li normalizzeremo, li ridimensioneremo ed eseguiremo altre attività necessarie. Per semplificare questo processo, creiamo una funzione chiamata preprocess_df che accetta un DataFrame come input ed esegue tutti questi passaggi di pre-elaborazione.

Per prima cosa, importiamo il modulo di preelaborazione dalla libreria sklearn. Se non lo hai installato, puoi farlo eseguendo pip install sklearn. Quindi, definiamo la funzione preprocess_df che accetta un DataFrame come parametro.

All'interno della funzione, iniziamo eliminando la colonna futura non necessaria dal DataFrame. Successivamente, iteriamo sulle colonne del DataFrame e applichiamo la trasformazione della variazione percentuale. Questa fase di normalizzazione aiuta a gestire diverse grandezze di prezzi e volumi tra criptovalute.

Dopo aver normalizzato i dati, eliminiamo tutte le righe che contengono valori NaN, in quanto possono causare problemi durante l'addestramento. Quindi, utilizziamo la funzione preprocessing.scale per ridimensionare i valori tra 0 e 1. In alternativa, puoi implementare la tua logica di ridimensionamento.

Ora che abbiamo preelaborato i dati, passiamo alla gestione dei dati sequenziali. Creiamo una lista vuota chiamata sequential_data e inizializziamo un oggetto deque chiamato prev_days con una lunghezza massima di 60. L'oggetto deque ci consente di aggiungere in modo efficiente nuovi elementi e rimuovere automaticamente quelli vecchi quando raggiunge la lunghezza massima.

Successivamente, iteriamo sui valori di DataFrame, che ora contiene i dati normalizzati e ridimensionati. Per ogni riga, aggiungiamo i valori alla deque prev_days. Una volta che la deque raggiunge una lunghezza di almeno 60, iniziamo a popolare il sequential_data

for i in DF.values:
    # Create a deque object with a maximum length of max_len
    if len(prev_days) < max_len:
        prev_days.append([n for n in i[:-1]])
    else:
        # Append the current values to prev_days
        prev_days.append([n for n in i[:-1]])
        # Add the sequence to the sequential_data list
        sequential_data.append([np.array(prev_days), i[-1]])
        # Remove the oldest sequence from prev_days
        prev_days.popleft()

In questo frammento di codice, iteriamo sui valori del frame di dati DF. Controlliamo se la lunghezza di prev_days (un oggetto deque) è minore di max_len. Se lo è, aggiungiamo i valori correnti (i[:-1]) a prev_days. Altrimenti, aggiungiamo i valori correnti a prev_days, aggiungiamo la sequenza [np.array(prev_days), i[-1]] all'elenco sequential_data e rimuoviamo la sequenza più vecchia da prev_days usando prev_days.popleft().

Ora che abbiamo generato le sequenze, possiamo procedere con il bilanciamento dei dati. Il bilanciamento è importante per evitare qualsiasi pregiudizio nei confronti di una classe specifica nei nostri dati di allenamento. In questo caso, le nostre classi sono i diversi movimenti di prezzo (al rialzo o al ribasso). Per bilanciare i dati, conteremo il numero di occorrenze per ogni classe e limiteremo il numero di sequenze per la classe di maggioranza in modo che corrisponda alla classe di minoranza.

buys = []
sells = []

for seq, target in sequential_data:
    if target == 0:
        sells.append([seq, target])
    elif target == 1:
        buys.append([seq, target])

# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))

# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]

# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells

# Shuffle the balanced_data
random.shuffle(balanced_data)

Nel codice sopra, creiamo due elenchi separati: compra e vende. Iteriamo sull'elenco sequential_data e aggiungiamo le sequenze con il valore target corrispondente al rispettivo elenco. Successivamente, determiniamo il numero minimo di sequenze tra acquisti e vendite. Limitiamo entrambi gli elenchi a questo numero minimo per bilanciare i dati. Quindi, concateniamo acquisti e vendite per creare i dati_equilibrati. Infine, mescoliamo balance_data per garantire la casualità.

Dopo aver bilanciato i dati, possiamo suddividerli in matrici di caratteristiche di input (X) e etichette di destinazione (y).

X = []
y = []

for seq, target in balanced_data:
    X.append(seq)
    y.append(target)

# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)

Ora che abbiamo X come caratteristiche di input e y come etichette di destinazione, possiamo procedere con la suddivisione dei dati in insiemi di addestramento e convalida.

# Split the data into training and validation sets
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)

Nel codice precedente, utilizziamo la funzione train_test_split di scikit-learn per suddividere i dati in set di addestramento e convalida. Assegniamo l'80% dei dati al training set (treno_x e treno_y) e il 20%

# Normalize the data
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))

# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)

Nel codice sopra, usiamo MinMaxScaler da scikit-learn per normalizzare le caratteristiche di input (train_x e val_x). Il metodo fit_transform viene utilizzato sul set di addestramento per adattare lo scaler e normalizzare i dati. Quindi, utilizziamo il metodo di trasformazione sul set di convalida per applicare lo stesso ridimensionamento in base al set di addestramento. I dati vengono rimodellati prima e dopo il ridimensionamento per corrispondere alla forma desiderata.

Con i dati preparati, ora possiamo costruire e addestrare il modello LSTM:

model = Sequential()
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))

model.add(Dense(units=2, activation='softmax'))

# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])

# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)

# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])

Nel codice sopra, definiamo un modello sequenziale usando Sequential(). Aggiungiamo tre strati LSTM con 128 unità ciascuno, seguiti da strati di abbandono con un tasso di 0,2 per evitare l'overfitting. La normalizzazione batch viene applicata dopo ogni strato LSTM. Aggiungiamo quindi uno strato denso con 32 unità e una funzione di attivazione ReLU, seguito da un altro strato di abbandono. Infine, aggiungiamo uno strato denso con 2 unità (che rappresentano le due classi: compra e vendi) e una funzione di attivazione softmax.

Definiamo l'ottimizzatore come Adam con un tasso di apprendimento di 0,001 e compiliamo il modello utilizzando l'entropia incrociata categoriale sparsa come funzione di perdita e l'accuratezza come metrica.

L'arresto anticipato viene definito utilizzando il callback EarlyStopping per monitorare la perdita di convalida e interrompere l'addestramento se non migliora dopo 3 epoche.

Il modello viene addestrato utilizzando la funzione fit, passando i dati di addestramento (train_x e train_y), i dati di convalida (val_x e val_y) e i callback definiti. L'allenamento viene eseguito per 20 epoche.

È possibile regolare l'architettura del modello, gli iperparametri e la configurazione di addestramento in base ai propri requisiti specifici.

# Evaluate the model
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)

loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')

Nel codice sopra, valutiamo il modello addestrato utilizzando i dati di test. Innanzitutto, normalizziamo i dati di input del test utilizzando il metodo di trasformazione dello scaler e li rimodelliamo in modo che corrispondano alla forma desiderata.

Quindi, utilizziamo il metodo di valutazione del modello per calcolare la perdita e l'accuratezza sui dati del test. Il metodo di valutazione accetta i dati di input del test (test_x) e le corrispondenti etichette di verità di base (test_y). La perdita calcolata e la precisione vengono stampate sulla console.

Ricorda di importare i moduli necessari all'inizio del tuo script:

import numpy as np
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense

Inoltre, assicurati di disporre dei set di dati necessari (train_x, train_y, val_x, val_y, test_x, test_y) preparati prima di eseguire il codice.

Questo codice ti consentirà di addestrare un modello LSTM per l'attività di classificazione di acquisto/vendita, normalizzare i dati e valutare le prestazioni del modello sul set di test. Sentiti libero di apportare modifiche o modifiche secondo le tue esigenze specifiche.

[MetaQuotes]

Bilanciamento dei dati della sequenza RNN - Deep Learning con Python, TensorFlow e Keras p.10

Bilanciamento dei dati della sequenza RNN - Deep Learning con Python, TensorFlow e Keras p.10

Salve a tutti e benvenuti a un altro video tutorial di deep learning con Python, TensorFlow e Keras. In questo video, continueremo a sviluppare il nostro futuro predittore del movimento dei prezzi delle criptovalute utilizzando una rete neurale ricorrente (RNN)."

Il video tutorial è incentrato sulla creazione di un predittore del movimento dei prezzi delle criptovalute utilizzando tecniche di deep learning.

Il relatore afferma di aver già eseguito le fasi di pre-elaborazione, inclusa la creazione di dati sequenziali e la separazione dei dati di convalida. Hanno anche normalizzato i dati.

Il passo successivo nel processo è bilanciare i dati. È importante avere un numero uguale di istanze di acquisto e vendita nel set di dati. Se c'è uno squilibrio, può influire sulle prestazioni del modello. Il presentatore suggerisce che anche se c'è un leggero squilibrio, è meglio bilanciare i dati per evitare che il modello favorisca una classe rispetto all'altra.

Per bilanciare i dati, il presentatore crea due liste: compra e vende. Eseguono iterazioni sui dati sequenziali e controllano se l'obiettivo è 0 (vendita) o 1 (acquisto). Se si tratta di una vendita, aggiungono la sequenza all'elenco delle vendite. Se si tratta di un acquisto, lo aggiungono all'elenco degli acquisti. Successivamente, mescolano entrambe le liste.

Successivamente, trovano la lunghezza minima tra le due liste (compra e vende). Aggiornano gli elenchi di acquisti e vendite per contenere solo gli elementi fino alla lunghezza dell'elenco più breve. Ciò garantisce che entrambi gli elenchi abbiano lo stesso numero di istanze.

Quindi, il relatore combina gli elenchi di acquisti e vendite nell'elenco di dati_sequenziali. Mescolano nuovamente l'elenco sequential_data per randomizzare ulteriormente l'ordine dei dati.

Il passaggio successivo consiste nel suddividere sequential_data in feature (X) ed etichette (Y). Creano elenchi vuoti x e y per memorizzare rispettivamente le caratteristiche e le etichette. Eseguono iterazioni su sequential_data e aggiungono la sequenza all'elenco x e l'obiettivo all'elenco y.

Infine, restituiscono gli array di x e y come dati pre-elaborati.

Il relatore procede quindi alla stampa di alcune statistiche sui dati, come le dimensioni dei set di dati di addestramento e convalida e l'equilibrio tra le istanze di acquisto e vendita.

Nel prossimo video, pianificano di costruire e addestrare il modello utilizzando i dati pre-elaborati.

[MetaQuotes]

Modello RNN per la previsione delle criptovalute - Deep Learning con Python, TensorFlow e Keras p.11

Modello RNN per la previsione delle criptovalute - Deep Learning con Python, TensorFlow e Keras p.11

Salve a tutti e benvenuti all'ennesimo tutorial di deep learning con Python, TensorFlow e Keras. In questo tutorial, continueremo da dove eravamo rimasti nel tutorial precedente. Il nostro obiettivo è prevedere i futuri movimenti di prezzo di una specifica criptovaluta in base ai suoi prezzi storici, volume e altre principali criptovalute. Raggiungeremo questo obiettivo utilizzando una rete neurale ricorrente (RNN).

Per iniziare, dobbiamo importare le librerie necessarie. Importeremo la libreria del tempo per un uso successivo. Successivamente, definiamo alcune costanti. La prima costante è il numero di epoche per le quali vogliamo addestrare il modello. Inizialmente impostiamo la dimensione del batch su 64, ma possiamo regolarla in seguito se necessario. Infine, definiamo un nome per il modello utilizzando una stringa F. È importante avere un nome univoco per il modello e i registri di TensorBoard per facilitare il confronto e l'identificazione.

Ora importiamo i moduli TensorFlow richiesti. Importiamo TensorFlow come tf e i sottomoduli richiesti: tf.keras.models, tf.keras.layers, tf.keras.optimizers, tf.keras.callbacks e tf.keras.backend. Importiamo anche numpy e matplotlib per l'elaborazione e la visualizzazione dei dati.

Successivamente, iniziamo a costruire il nostro modello. Creiamo un modello sequenziale usando model = tf.keras.models.Sequential(). All'interno del modello, aggiungiamo livelli usando la funzione model.add(). Il nostro primo livello è un livello LSTM con 128 nodi. Impostiamo return_sequences=True poiché vogliamo passare l'output al livello successivo. Specifichiamo la forma di input come train_X.shape[1:], dove train_X sono i dati di input. Aggiungiamo anche un livello di abbandono con un tasso di 0,2 e un livello di normalizzazione batch.

Ripetiamo questo processo altre due volte, aggiungendo altri due livelli LSTM con 128 nodi ciascuno. Rimuoviamo return_sequences=True per l'ultimo livello LSTM poiché sarà seguito da un livello denso. Aggiungiamo anche livelli di normalizzazione di dropout e batch a ciascun livello LSTM.

Dopo gli strati LSTM, aggiungiamo uno strato denso con 32 nodi e una funzione di attivazione lineare rettificata. Aggiungiamo un livello di abbandono con un tasso di 0,2 e, infine, il livello di output con due nodi e una funzione di attivazione softmax.

Ora specifichiamo l'ottimizzatore per il nostro modello. Utilizziamo l'ottimizzatore Adam con un tasso di apprendimento di 0,001 e un tasso di decadimento di 1e-6. Compiliamo il modello usando model.compile() e specifichiamo la funzione di perdita come entropia incrociata categoriale sparsa e le metriche come accuratezza.

Successivamente, definiamo i callback per il nostro modello. Creiamo un callback TensorBoard con la directory dei log impostata su 'logs'. Creiamo anche un callback ModelCheckpoint per salvare il modello migliore durante l'addestramento. Specifichiamo il percorso del file per il salvataggio dei punti di controllo utilizzando la formattazione della stringa.

Infine, addestriamo il modello usando model.fit(). Passiamo i dati di addestramento (train_X e train_Y), la dimensione del batch, il numero di epoche e i dati di convalida (validation_X e validation_Y). Passiamo anche i callback che abbiamo definito in precedenza.

Dopo l'addestramento, possiamo salvare il modello usando model.save() per un uso futuro.

Questo è tutto! Abbiamo costruito e addestrato con successo un modello di rete neurale ricorrente per prevedere i futuri movimenti di prezzo di una criptovaluta. Abbiamo anche visualizzato i progressi della formazione utilizzando TensorBoard.

[MetaQuotes]

Strategia di trading algoritmico in Python

Strategia di trading algoritmico in Python

Nel tutorial di oggi, implementeremo una strategia di trading azionario algoritmico utilizzando Python. Immergiamoci dentro.

Prima di iniziare, voglio sottolineare che questo video non è inteso come un investimento o un consiglio finanziario. Non sono un professionista di borsa, un esperto di investimenti o un professionista finanziario. Lo scopo di questo video è dimostrare come implementare una strategia di trading algoritmico utilizzando Python. Se scegli di usarlo per i tuoi investimenti è interamente una tua decisione e responsabilità. Mi concentrerò solo sull'aspetto della programmazione.

Per iniziare, dobbiamo installare due librerie: "pandas-datareader" per recuperare i dati di borsa e "matplotlib" per la visualizzazione dei dati. Apri il prompt dei comandi (CMD) e installa queste librerie. Una volta installato, possiamo procedere con la codifica.

Innanzitutto, importiamo i moduli necessari: "datetime" per la gestione di data e ora, "matplotlib.pyplot" per tracciare grafici e "pandas_datareader" come "web" per recuperare i dati di borsa.

Successivamente, definiamo le medie mobili (MA) che utilizzeremo. Le medie mobili rappresentano il prezzo medio delle azioni in un periodo di tempo specificato, ad esempio 30 giorni o 100 giorni. Creiamo due variabili, "ma1" e "ma2", che saranno impostate rispettivamente a 30 e 100. Questi valori determinano la lunghezza delle medie mobili che analizzeremo.

Ora, fissiamo il lasso di tempo per la nostra analisi. Definiamo le date di inizio e di fine utilizzando la data corrente e un delta temporale di 3 anni. Questo intervallo di tempo verrà utilizzato per recuperare i dati di borsa.

Utilizzando la libreria "datareader", recuperiamo i dati azionari per una società specifica (in questo caso, Facebook) dall'API di Yahoo Finance. Passiamo le date di inizio e di fine per recuperare i dati rilevanti.

Per calcolare le medie mobili, aggiungiamo due nuove colonne ai dati DataFrame. Utilizziamo la funzione "rolling" per calcolare la media mobile per entrambi i periodi "ma1" e "ma2". La colonna "adjusted close" rappresenta il prezzo di chiusura aggiustato per i frazionamenti azionari. Memorizziamo le medie mobili nelle rispettive colonne.

Prima di procedere oltre, visualizziamo i dati e le medie mobili. Tracciamo i valori di chiusura rettificati come prezzo delle azioni e le medie mobili vengono tracciate sullo stesso grafico. Impostiamo lo stile del grafico in modo che utilizzi uno sfondo scuro e diamo etichette e colori appropriati per differenziare le linee. Infine, aggiungiamo una legenda per identificare le linee tracciate e visualizzare il grafico.

Passiamo ora all'implementazione della strategia di trading algoritmico. Creiamo due elenchi vuoti, "buy_signals" e "sell_signals", che memorizzeranno rispettivamente i segnali di acquisto e di vendita. Inoltre, introduciamo una variabile "trigger" che ci aiuterà a tenere traccia dei cambiamenti nella strategia.

Usando un ciclo for, iteriamo sui dati DataFrame. All'interno del ciclo, controlliamo due condizioni: se la prima media mobile ("ma1") è maggiore della seconda media mobile ("ma2"), e se il trigger non è uguale a 1. Se entrambe le condizioni sono soddisfatte, aggiungiamo un segnale di acquisto all'elenco "buy_signals" e aggiungi "NaN" (non un numero) all'elenco "sell_signals". Aggiorniamo anche il trigger a 1.

Nel caso opposto, dove "ma1" è minore di "ma2" e il trigger non è uguale a -1, aggiungiamo un segnale di vendita all'elenco "sell_signals" e aggiungiamo il prezzo effettivo dell'azione all'elenco "buy_signals". Aggiorniamo il trigger a -1.

Se nessuna delle condizioni è soddisfatta, aggiungiamo valori "NaN" a entrambi gli elenchi per mantenere lunghezze coerenti.

Infine, aggiungiamo altre due colonne al DataFrame di dati per memorizzare i segnali di acquisto e vendita.

Disperderemo anche i segnali di vendita, quindi aggiungeremo un altro grafico a dispersione utilizzando plt.scatter. Questa volta, spargeremo i segnali di vendita su data.index come valori x e i corrispondenti prezzi dei segnali di vendita come valori y. Etichetteremo questo grafico a dispersione come "segnale di vendita" per differenziarlo dai segnali di acquisto.

Infine, aggiungeremo una legenda al grafico utilizzando plt.legend per visualizzare le etichette per i diversi elementi. Quindi, chiameremo plt.show() per visualizzare il grafico.

Il codice:

plt.plot(data.index, data[ 'Adj Close' ], label= 'Share Price' , color= 'lightgray' )
plt.plot(data.index, data[ 'sma_{}' .format(ma1)], label= 'SMA {}' .format(ma1), linestyle= '--' )
plt.plot(data.index, data[ 'sma_{}' .format(ma2)], label= 'SMA {}' .format(ma2), linestyle= '--' )
plt.scatter(data.index, data[ 'Buy Signal' ], label= 'Buy Signal' )
plt.scatter(data.index, data[ 'Sell Signal' ], label= 'Sell Signal' )
plt.legend(loc= 'upper left' )
plt.show()

Ora, quando esegui il codice, dovresti vedere un grafico che mostra il prezzo delle azioni, le medie mobili e i segnali di acquisto e vendita.

Ricorda, questa è solo una semplice strategia di trading algoritmico implementata in Python e non è pensata per essere considerata un consiglio finanziario o di investimento. È importante fare ricerche approfondite e consultare professionisti prima di prendere qualsiasi decisione di investimento.

[MetaQuotes]

Introduzione al trading algoritmico utilizzando Python - Come creare e testare l'algoritmo di trading

Introduzione al trading algoritmico utilizzando Python - Come creare e testare l'algoritmo di trading

In questo video, approfondiremo lo sviluppo di una strategia di trading algoritmico. È fondamentale notare che questo video è destinato esclusivamente a scopi didattici e non deve essere considerato un consiglio di investimento. La strategia che esploreremo è comunemente nota come strategia momentum, sebbene il termine stesso possa essere ambiguo e aperto a interpretazioni.

Essenzialmente, una strategia momentum comporta l'identificazione di titoli che mostrano un chiaro movimento direzionale. Nel nostro caso, inizieremo conducendo un processo di screening per identificare i titoli che vengono scambiati al di sopra della loro media mobile a 50 giorni o qualsiasi altra metrica predeterminata che abbiamo ricercato.

Questa strategia viene spesso definita strategia che segue la tendenza, in quanto mira a capitalizzare titoli che si muovono in una direzione specifica, al rialzo o al ribasso. È importante notare che questo approccio richiede una ricerca approfondita per identificare potenziali segnali di trading redditizi che possono essere applicati a vari titoli.

Ai fini di questo video, ci concentreremo sull'analisi di un singolo titolo per determinarne il potenziale. Per iniziare, importeremo le librerie necessarie e configureremo il nostro ambiente. Il notebook contenente il codice sarà reso disponibile su un link GitHub, che si trova nella descrizione del video.

Successivamente, scaricheremo i dati richiesti per l'analisi. In questo caso, utilizzeremo l'API di Yahoo Finance per recuperare i dati per il Gold ETF (Exchange Traded Fund) con il simbolo "GLD". Utilizzeremo il lettore di dati Pandas per recuperare i dati, specificando il simbolo e lasciando le date di inizio e di fine come predefinite, che dovrebbero fornirci circa cinque anni di dati. Una volta scaricato, esamineremo le prime righe dei dati per assicurarne l'accuratezza.

Per facilitare la nostra analisi, aggiungeremo ulteriori colonne al data frame. Innanzitutto, includeremo una colonna contagiorni per tenere traccia del giorno nella serie temporale. Ciò sarà realizzato utilizzando la libreria NumPy per creare un array di intervalli che corrisponda al numero di osservazioni nel data frame dorato. La colonna del contatore del giorno verrà quindi aggiunta al frame di dati e regoleremo l'ordine della colonna per garantire che il giorno segua la colonna della data.

Inoltre, elimineremo le colonne non necessarie come la chiusura e il volume rettificati per la nostra analisi specifica. Vale la pena ricordare che per alcuni titoli, la chiusura rettificata può essere utile, soprattutto nei casi in cui si sono verificati frazionamenti azionari. Tuttavia, per i nostri scopi, escluderemo queste colonne.

Completati i passi preliminari, possiamo esaminare la struttura dei dati eseguendo il comando info sul data frame. Ciò fornirà informazioni sul numero di osservazioni e tipi di dati presenti nel data frame, confermando che tutte le colonne sono numeriche.

Successivamente, introdurremo la strategia momentum aggiungendo colonne di media mobile al frame di dati. Utilizzeremo due medie mobili, una veloce (9 giorni) e una lenta (21 giorni), per attivare le negoziazioni. Nello specifico, entreremo in un'operazione quando la media mobile veloce supera la media mobile lenta e usciremo o andremo short quando la media mobile veloce incrocia al di sotto della media mobile lenta. È essenziale notare che questa strategia presuppone che siamo sempre in uno scambio, lungo o corto.

Per calcolare le medie mobili basate sul prezzo di chiusura, utilizzeremo il metodo di rotazione fornito da Pandas. Questo metodo ci consente di specificare il numero di giorni per la media mobile. Inoltre, se lo desideri, possiamo applicare diversi aggregatori, come la deviazione standard o la mediana. In questo caso, ci concentreremo esclusivamente sulla media mobile. Duplicheremo questo processo per entrambe le medie mobili veloci e lente, ottenendo due colonne aggiuntive nel frame di dati.

Poiché le medie mobili sono ritardate rispettivamente di 9 e 21 giorni, dobbiamo aggiustarle spostando i dati in avanti di un giorno utilizzando il metodo shift in Pandas.

Dopo aver calcolato le medie mobili, le regoleremo spostando i dati in avanti di un giorno utilizzando il metodo shift in Pandas. Ciò garantisce che le medie mobili del giorno corrente siano allineate con l'azione dei prezzi del giorno successivo.

Ora che abbiamo regolato le colonne della media mobile, possiamo generare segnali di trading basati sull'incrocio delle medie mobili veloci e lente. Per fare ciò, creeremo una nuova colonna chiamata "Segnale" e le assegneremo un valore di 1 quando la media mobile veloce è al di sopra della media mobile lenta, indicando un segnale rialzista, e -1 quando la media mobile veloce è al di sotto della media mobile lenta. media mobile, che indica un segnale ribassista.

Per determinare i punti di ingresso e di uscita per le nostre negoziazioni, aggiungeremo un'altra colonna chiamata "Posizione". Inizialmente, gli assegneremo un valore pari a 0, a indicare che non siamo in uno scambio. Quando si verifica un segnale rialzista (la media mobile veloce incrocia sopra la media mobile lenta) e non siamo attualmente in uno scambio (Posizione = 0), assegneremo un valore di 1 alla colonna Posizione, indicando una posizione lunga. Al contrario, quando si verifica un segnale ribassista (la media mobile veloce incrocia sotto la media mobile lenta) e non siamo attualmente in uno scambio, assegneremo un valore di -1 alla colonna Posizione, indicando una posizione corta. Ciò garantisce che entriamo in un'operazione solo quando c'è un nuovo segnale e non siamo già in un'operazione.

Per tenere traccia dei rendimenti giornalieri della nostra strategia di trading, creeremo un'altra colonna chiamata "Rendimenti della strategia". Calcoleremo i rendimenti giornalieri moltiplicando la colonna Posizione per la variazione percentuale giornaliera del prezzo di chiusura. Questo ci darà il rendimento che avremmo ottenuto se avessimo seguito i segnali di trading.

Infine, calcoleremo i rendimenti cumulativi della nostra strategia applicando il metodo cumprod alla colonna Rendimenti della strategia. Questo ci fornirà la performance complessiva della nostra strategia nel periodo di tempo specificato.

A questo punto, possiamo visualizzare la performance della nostra strategia tracciando i rendimenti cumulativi. Useremo la libreria matplotlib per creare un grafico a linee che mostri la crescita dei rendimenti della nostra strategia nel tempo.

Nel grafico possiamo osservare la curva dei rendimenti cumulativi, che dovrebbe darci un'idea dell'efficacia della nostra strategia momentum. I rendimenti cumulativi positivi indicano la redditività, mentre i rendimenti cumulativi negativi indicano le perdite.

Tieni presente che questo è un esempio semplificato di una strategia di momentum trading e ci sono molti fattori da considerare quando si sviluppa una strategia di trading nel mondo reale, come i costi di transazione, lo slippage e la gestione del rischio. È importante eseguire un backtest approfondito e convalidare qualsiasi strategia di trading prima di applicarla al trading nel mondo reale.

<

[MetaQuotes]

Come utilizzare Alpha Vantage Free Real Time Stock API e Python per estrarre il tempo dei massimi e dei minimi giornalieri

Come utilizzare Alpha Vantage Free Real Time Stock API e Python per estrarre il tempo dei massimi e dei minimi giornalieri

In questo video, utilizzeremo un Jupyter Notebook per esplorare l'API Alpha Vantage ed estrarre i prezzi di trading alti e bassi per un titolo utilizzando i dati di trading di un minuto. Alpha Vantage è una delle numerose API disponibili per ottenere dati di trading in tempo reale e opera su un modello freemium. Per iniziare, dovremo registrarci per un account gratuito e ottenere una chiave API dal sito Web di Alpha Vantage.

Useremo la libreria helper Alpha Vantage chiamata "alpha_vantage", che semplifica il processo di effettuare chiamate API. Se non hai la libreria installata, puoi farlo eseguendo il comando "pip install alpha_vantage" nella riga di comando.

Per iniziare, impostiamo il nostro ambiente importando le necessarie librerie di terze parti. Fatto ciò, memorizziamo la nostra chiave API in una variabile. Se preferisci mantenere privata la tua chiave API, puoi memorizzarla in un file di testo separato e leggerla nel tuo notebook. Successivamente, creiamo un oggetto serie temporale specificando la chiave API e il formato di output desiderato. In questo caso, scegliamo di utilizzare la libreria Pandas in quanto fornisce un modo più semplice per lavorare con i dati di output, che per impostazione predefinita sono in formato JSON.

Per recuperare i dati di trading, effettuiamo una chiamata all'API Alpha Vantage utilizzando la funzione "get_intraday". Questa funzione ci consente di specificare il simbolo del titolo e l'intervallo desiderato, ad esempio un minuto, cinque minuti o un'ora. Possiamo anche impostare la dimensione dell'output, che determina la quantità di dati storici che vogliamo recuperare. Per questo video, l'abbiamo impostato su "completo", che ci fornisce circa dieci giorni di dati.

Una volta recuperati i dati, possiamo esaminare i metadati ad essi associati accedendo all'attributo "meta". Il meta oggetto fornisce informazioni sui dati scaricati, come l'intervallo, la data dei dati e le colonne che contiene. Possiamo quindi ispezionare i dati stessi chiamando il metodo "info", che visualizza i nomi delle colonne e l'indice data-ora.

Per ottenere una rappresentazione visiva dei dati, possiamo tracciare una delle colonne, come i prezzi di chiusura. Tuttavia, i nomi delle colonne restituiti da Alpha Vantage potrebbero non essere convenienti con cui lavorare, quindi possiamo rinominarli con nomi più significativi.

Successivamente, estraiamo i dati corrispondenti alle normali ore di negoziazione, escluse le negoziazioni fuori orario, che possono introdurre distorsioni. Creiamo una nuova variabile chiamata "mercato" applicando un filtro basato sul tempo ai dati. Pandas fornisce una comoda funzione, "between_time", che ci consente di specificare l'ora di inizio e di fine del mercato.

A questo punto siamo pronti per estrarre le date e gli orari dei massimi e dei minimi. Lo facciamo in due modi. Innanzitutto, raggruppiamo i dati per data di negoziazione e utilizziamo il metodo "ag" per calcolare rispettivamente i valori minimo e massimo per le colonne bassa e alta. Questo approccio ci fornisce i valori minimi e massimi effettivi per ogni giorno di negoziazione.

In secondo luogo, adottiamo un approccio diverso e ci concentriamo sul minuto in cui si sono verificati il minimo e il massimo. Utilizziamo la funzione "loc" per individuare le righe specifiche in cui si verificano i minimi e i massimi all'interno di ogni giorno di negoziazione. Quindi, estraiamo l'indice (data e ora) rispettivamente per i valori minimo e massimo. Questo ci permette di identificare il minuto esatto in cui sono stati raggiunti i prezzi minimo e massimo.

Esaminando i risultati, possiamo osservare modelli interessanti, come la tempistica dei minimi e dei massimi durante i giorni di negoziazione.

Questo video fornisce una panoramica di base sull'utilizzo dell'API Alpha Vantage per recuperare i dati di trading minuto per minuto ed estrarre i massimi e i minimi per l'analisi. Serve come punto di partenza per esplorare e utilizzare l'API Alpha Vantage nei propri progetti.

In conclusione, questo tutorial video mostra come utilizzare l'API Alpha Vantage e la libreria helper Alpha Vantage in un notebook Jupyter per estrarre i prezzi di negoziazione alti e bassi per un titolo utilizzando i dati di negoziazione di un minuto. Seguendo i passaggi descritti nel video, puoi recuperare i dati di trading in tempo reale, analizzarli utilizzando i panda e ottenere informazioni dettagliate sui tempi dei massimi e dei minimi in un determinato giorno di negoziazione.

È importante notare che l'API Alpha Vantage offre varie funzionalità e opzioni di dati oltre a quanto descritto in questo video. Puoi esplorare diversi intervalli, ad esempio dati di cinque minuti o di un'ora, nonché diversi tipi di dati, inclusi dati giornalieri o storici. L'API fornisce anche funzionalità aggiuntive, come indicatori tecnici e dati fondamentali.

Per migliorare ulteriormente la tua analisi, puoi incorporare ulteriori tecniche di manipolazione e visualizzazione dei dati. Ad esempio, puoi calcolare metriche aggiuntive basate sui prezzi alti e bassi estratti, eseguire analisi statistiche o creare visualizzazioni interattive per presentare i dati in modo più intuitivo.

Ricordati di fare riferimento alla documentazione di Alpha Vantage per informazioni dettagliate su chiamate API, parametri e opzioni disponibili. Inoltre, assicurati di rispettare i termini e le condizioni dell'API Alpha Vantage, incluse eventuali limitazioni o restrizioni di utilizzo associate al tuo account gratuito.

Sfruttando l'API Alpha Vantage e combinandola con le funzionalità di Jupyter Notebook e della libreria panda, puoi sbloccare una vasta gamma di dati di trading ed esplorare varie strategie e approfondimenti per supportare le tue decisioni di investimento e analisi quantitative.

[MetaQuotes]

Introduzione ai grafici a dispersione con matplotlib Python per Data Science

Introduzione ai grafici a dispersione con matplotlib Python per Data Science

Questo è il secondo video della mia serie introduttiva a Matplotlib. In questo video, ci concentreremo sui grafici a dispersione. I grafici a dispersione sono un aiuto visivo che ci aiuta a determinare la forza e la natura di una relazione tra due variabili. Tratteremo le basi della creazione di grafici a dispersione, inclusa l'impostazione di temi, l'aggiunta di una mappa dei colori, la creazione di un grafico a bolle e l'aggiunta di dimensionalità.

Per iniziare, impostiamo il nostro ambiente importando le librerie necessarie. Importeremo NumPy, Matplotlib e il lettore di dati Pandas. Il lettore di dati Pandas ci consentirà di scaricare dati reali con cui lavorare. In questo caso, scaricheremo tre o quattro mesi di dati per Google, Amazon e l'ETF sull'oro.

Una volta che abbiamo i dati, possiamo dare un'occhiata alle prime righe per familiarizzare con il set di dati. Possiamo vedere che i dati iniziano il 1° agosto e includono i prezzi di chiusura.

Ora, creiamo un grafico a dispersione di base utilizzando il metodo a dispersione di Matplotlib. Possiamo scegliere due colonne dal set di dati e tracciarle. Tuttavia, questo grafico a dispersione di base non fornisce molte informazioni sulla relazione tra le variabili.

Per indagare ulteriormente, possiamo calcolare il tasso di rendimento istantaneo per ciascun titolo. Questo ci darà una migliore comprensione di come le variazioni di prezzo si relazionano tra loro. Rimuoviamo il prezzo assoluto e lo riduciamo a una variazione percentuale. Guardando le prime osservazioni, possiamo vedere che tutti i titoli sono scesi, con Amazon e Google che hanno registrato un calo di oltre l'1%, mentre l'oro è rimasto relativamente invariato.

Successivamente, rimuoviamo la prima osservazione, che non è un numero, e tracciamo un grafico a dispersione per vedere se il cambiamento in Google è rilevante per il cambiamento in Amazon. Questo grafico a dispersione racconta una storia diversa da quella precedente. Possiamo osservare una tendenza generale che quando Google sale, così fa Amazon, indicando una forte relazione positiva tra le due variabili.

Ora che abbiamo il grafico a dispersione di base, possiamo aggiungere alcune funzionalità per migliorarlo. Innanzitutto, cambiamo le dimensioni della trama per renderla più visibile. Possiamo farlo importando il modulo dei parametri da Matplotlib.

Possiamo anche aggiungere un tocco visivo al grafico a dispersione aggiungendo linee guida per mostrare il movimento dei punti in direzioni diverse. Tracciando linee attraverso lo zero sugli assi X e Y, possiamo identificare rapidamente quando i punti si muovono insieme, si allontanano o in direzioni opposte.

Per migliorare la visibilità delle linee guida, possiamo impostare il loro colore su una sfumatura di grigio utilizzando la notazione RGB. Inoltre, possiamo impostare lo stile della linea su tratteggiato per un diverso effetto visivo.

Per migliorare ulteriormente il grafico a dispersione, possiamo aggiungere uno schema di colori. Anche se non abbiamo una terza variabile da rappresentare, possiamo comunque aggiungere una mappa dei colori al grafico a dispersione. Modifichiamo il codice del grafico a dispersione per includere il colore dei resi per Amazon e scegliamo la mappa dei colori spettrale. Questa mappa dei colori assegna colori diversi ai punti in base ai valori dei rendimenti, con il rosso che rappresenta i valori più negativi e il viola che rappresenta i valori più positivi.

Tuttavia, alcuni punti nella gamma media potrebbero essere difficili da vedere a causa del gradiente di colore. Per risolvere questo problema, possiamo cambiare il colore del bordo dei punti in nero, rendendoli più distinti.

Per fornire ulteriori informazioni sulle gradazioni di colore, possiamo aggiungere una barra dei colori. La barra dei colori traccia una legenda che indica la mappatura dei colori in base ai rendimenti.

Inoltre, possiamo migliorare l'aspetto generale della trama applicando un tema. Possiamo usare Seaborn come tema, che è un involucro attorno a Matplotlib che fornisce uno stile visivamente accattivante. Questo tema cambia lo sfondo e aggiunge linee della griglia senza sminuire i dati tracciati.

Infine, possiamo regolare i limiti della trama per centrare le linee guida.

Infine, possiamo regolare i limiti del grafico per centrare le linee guida e rendere visivamente più bilanciato il grafico a dispersione. Possiamo impostare i limiti dell'asse x e dell'asse y sui valori minimo e massimo dei rendimenti per garantire che le linee guida si intersechino al centro del grafico. Questa regolazione ci aiuta a visualizzare in modo più efficace il movimento dei punti in relazione alle linee guida.

Ora che abbiamo apportato questi miglioramenti, il nostro grafico a dispersione è più informativo e visivamente accattivante. Possiamo vedere chiaramente la relazione tra i resi di Google e Amazon, nonché la distribuzione dei resi in base alla mappa dei colori. Le linee guida forniscono un riferimento visivo per interpretare il movimento dei punti in diverse direzioni.

Oltre ai grafici a dispersione di base, possiamo anche creare un grafico a bolle utilizzando Matplotlib. Un grafico a bolle aggiunge una terza dimensione al grafico variando la dimensione degli indicatori in base a una terza variabile. Nel nostro caso, possiamo utilizzare il volume di ciascun titolo come terza variabile.

Per creare un grafico a bolle, modifichiamo il codice del grafico a dispersione specificando il parametro size e passando il volume di ciascun titolo come dimensione del marker. Questo crea cerchi con dimensioni proporzionali al volume di ciascun titolo, permettendoci di visualizzare la relazione tra rendimenti, volume e movimento dei punti.

Aggiungendo questa terza dimensione al grafico a dispersione, otteniamo una comprensione più profonda della relazione tra le variabili. Possiamo vedere che i cerchi più grandi rappresentano volumi di trading più elevati e il movimento dei punti può essere correlato sia ai rendimenti che al volume.

In conclusione, i grafici a dispersione e i grafici a bolle sono potenti strumenti di visualizzazione che ci aiutano a comprendere la relazione tra le variabili. Possiamo usarli per analizzare e interpretare i dati, identificare modelli e tendenze e prendere decisioni informate. Con Matplotlib, possiamo creare grafici a dispersione personalizzati e visivamente accattivanti e migliorarli con varie funzionalità, come mappe dei colori, linee guida e temi.

[MetaQuotes]

Introduzione al trading algoritmico con Python: creare un algoritmo di trading con ripristino della media

Introduzione al trading algoritmico con Python: creare un algoritmo di trading con ripristino della media

In questo video, esploreremo un algoritmo di trading con ripristino della media solo a scopo didattico. È importante notare che questo video non fornisce consigli di investimento. L'algoritmo verrà implementato utilizzando un notebook Jupyter e nella descrizione del video verrà fornito un collegamento per scaricare il notebook. Questo video funge da accompagnamento alla strategia di momentum trading discussa in precedenza e verrà fornito anche un collegamento a quel video.

La strategia di trading mean-reverting presuppone che un titolo tornerà indietro verso un valore medio ogni volta che si discosta troppo da esso. Esistono diversi modi per affrontare questa strategia, ad esempio utilizzando la regressione lineare o una media mobile. La determinazione di "troppo lontano" e la misurazione utilizzata possono variare. Alcune persone usano un valore assoluto in dollari, mentre in questo video useremo i percentili. Inoltre, verrà utilizzata una media mobile per determinare il valore medio.

Per iniziare, importiamo le librerie necessarie, inclusi Pandas per la manipolazione dei dati, Pandas DataReader per scaricare dati in tempo reale (possono essere utilizzati anche altri servizi), NumPy per le operazioni numeriche, Matplotlib per la rappresentazione grafica e Seaborn per lo styling dei grafici. Le librerie richieste vengono importate eseguendo la rispettiva cella di codice.

Successivamente, otteniamo i dati per l'analisi. Mentre un buon algoritmo di trading dovrebbe essere generalizzabile a più titoli, questo video si concentra su un singolo titolo: l'ETF sull'oro. Il Pandas DataReader viene utilizzato per scaricare circa cinque anni di dati per l'ETF sull'oro. Poiché interessa solo il prezzo di chiusura, limitiamo il download a quella colonna. Una volta ottenuti i dati, esaminiamo le prime righe per assicurarne il corretto recupero.

Dopo aver ottenuto i dati, aggiungiamo alcune colonne al data frame. La prima colonna aggiunta è per la media mobile. Impostiamo una variabile per definire il periodo della media mobile, che può essere facilmente manipolato. Il tasso di rendimento istantaneo dalla chiusura del giorno precedente viene calcolato e memorizzato in una nuova colonna. Un'altra colonna, denominata "media mobile", viene creata per tenere traccia del valore medio in base al prezzo di chiusura utilizzando una media di 21 giorni (o un mese di negoziazione). Inoltre, viene aggiunta una colonna "rapporto", che rappresenta la divisione del prezzo di chiusura per la media mobile. Questa colonna aiuta a determinare quando il prezzo è troppo lontano dalla media.

Le statistiche descrittive vengono calcolate per la colonna "rapporto" per ottenere informazioni sulla distribuzione dei dati. Come previsto, i prezzi rimangono generalmente vicini al valore medio. Il 25° e il 75° percentile definiscono i limiti inferiore e superiore dei dati, mentre i valori minimo e massimo indicano deviazioni estreme dalla media. Ulteriori punti di prezzo vengono selezionati per l'analisi, come il 5°, 10°, 90° e 95° percentile, per determinare deviazioni significative dalla media. La funzione percentile numpy viene utilizzata per calcolare i rispettivi valori in base alla colonna "gold ratio". Prima di eseguire il calcolo, i valori mancanti vengono eliminati.

Per visualizzare il movimento della colonna del rapporto attorno alla media, viene generato un grafico. I valori irrilevanti vengono eliminati e la colonna del rapporto viene tracciata con una legenda. Le linee orizzontali vengono aggiunte per rappresentare le interruzioni di prezzo nei percentili selezionati (5°, 50° e 95°). Questa rappresentazione visiva aiuta a osservare il movimento ciclico della colonna del rapporto attorno alla media, indicando una tendenza a correggere le deviazioni.

Successivamente, vengono definite soglie specifiche per determinare quando andare short o long. La posizione corta è definita come il 95° percentile, mentre la posizione lunga è definita come il 5° percentile. Una nuova colonna viene aggiunta al frame di dati, indicando se la posizione è lunga o corta. La funzione "dove" di Numpy viene utilizzata per assegnare valori in base alla colonna del rapporto aureo. Viene assegnato un valore pari a -1 quando il rapporto è inferiore alla soglia short, indicando una posizione corta, e viene assegnato un valore pari a 1 quando il rapporto è maggiore della soglia long, indicando una posizione lunga. Infine, viene generato un grafico per visualizzare le posizioni. Il grafico mostra la colonna del rapporto ed evidenzia le posizioni lunghe e corte con colori diversi.

Dopo aver individuato le posizioni, il passo successivo è calcolare i rendimenti giornalieri. Questo viene fatto moltiplicando la colonna della posizione per la colonna del tasso di rendimento giornaliero, che fornisce il rendimento per ogni giorno in base alla posizione detenuta. Una nuova colonna denominata "strategia" viene aggiunta al data frame per memorizzare i rendimenti giornalieri.

Per valutare la performance della strategia, vengono calcolati i rendimenti cumulativi. I rendimenti cumulativi si ottengono prendendo il prodotto cumulativo dei rendimenti della strategia, aggiungendo 1 al risultato e moltiplicando per 100 per la rappresentazione percentuale. Viene generato un grafico per visualizzare i rendimenti cumulativi nel tempo.

Successivamente, vengono calcolate ulteriori metriche di rendimento per valutare le prestazioni della strategia. Vengono calcolati il rendimento totale, il rendimento giornaliero medio, la deviazione standard dei rendimenti giornalieri, l'indice di Sharpe e il drawdown massimo. Queste metriche forniscono informazioni sulla redditività, sul rischio e sul rendimento aggiustato per il rischio della strategia. I valori sono stampati per una facile consultazione.

Infine, viene generato un grafico per confrontare i rendimenti cumulativi della strategia di ritorno alla media con la strategia buy-and-hold. La strategia buy-and-hold presuppone di detenere l'asset per l'intero periodo senza alcuna decisione di trading. Questo grafico consente un confronto visivo delle due strategie.

In sintesi, questo video mostra l'implementazione di una strategia di trading che ripristina la media utilizzando Python e Jupyter Notebook. Copre il recupero dei dati, il calcolo delle medie mobili, la determinazione delle soglie, la visualizzazione delle posizioni, il calcolo dei rendimenti giornalieri, la valutazione delle metriche di performance e il confronto con una strategia buy-and-hold. Il Jupyter Notebook di accompagnamento fornisce una guida dettagliata per ricreare la strategia ed esplorare ulteriormente la sua implementazione. Ricorda che questo video è solo a scopo didattico e non fornisce consigli di investimento.

[MetaQuotes]

Python Panda || Medie mobili e statistiche Rolling Window per i prezzi delle azioni

Python Panda || Medie mobili e statistiche Rolling Window per i prezzi delle azioni

In questo video tutorial, dimostrerò come utilizzare il metodo di rotazione dei panda, che automatizza i calcoli per le medie mobili e le deviazioni standard di rotazione. Il metodo di rotazione è un potente strumento per eseguire aggregazioni di finestre di rotazione e può essere facilmente implementato utilizzando la versione 0.21 di Pandas. Fornirò un collegamento al notebook Jupyter utilizzato in questo tutorial come riferimento.

Per iniziare, dobbiamo impostare l'ambiente. Importiamo la libreria numpy poiché i panda si basano su di essa. Sebbene non utilizzeremo direttamente numpy in modo estensivo, è necessario che i panda funzionino correttamente. Inoltre, importiamo il lettore di dati panda per il recupero dei dati e matplotlib per scopi di tracciamento. Utilizzando la funzione magica, ci assicuriamo che i grafici vengano visualizzati all'interno del Jupyter Notebook.

Successivamente, acquisiamo i dati per l'analisi. Scaricherò i dati per l'ETF sull'oro (Exchange-Traded Fund) da Yahoo Finance. Per specificare il periodo di tempo desiderato, ho fissato la data di inizio al giorno delle elezioni presidenziali, circa un anno fa. Per confermare che i dati sono stati recuperati correttamente, visualizzo le prime righe del set di dati. Poiché siamo principalmente interessati ai prezzi di chiusura di questa dimostrazione, rimuovo le altre colonne. Inoltre, poiché il frame di dati che viene scaricato è una serie di serie e manca di determinate proprietà di cui ho bisogno, lo lancio come frame di dati.

Ora siamo pronti per dimostrare il metodo di rotolamento. Aggiungerò una nuova colonna al data frame chiamata "MA9" per rappresentare la media mobile a nove giorni. Utilizzando il metodo di rotazione, calcolo la media per il numero specificato di periodi o righe. Ripeto questo processo per una finestra più lunga di 21 giorni. Queste due nuove colonne rappresentano le medie mobili che abbiamo calcolato. Per visualizzare i dati, traccio i prezzi di chiusura, la media mobile a nove giorni e la media mobile a 21 giorni.

A volte è utile ritardare le medie mobili. Aggiungendo il parametro "center=True" quando si utilizza il metodo rolling, possiamo spostare la linea della media mobile indietro di dieci giorni per la finestra di 21 giorni. Questo crea una linea ritardata che si allinea con i dati corrispondenti. Possiamo osservare questo spostamento nel grafico tracciato.

Dovrei notare che quando si calcolano le medie mobili, l'osservazione corrente è inclusa nella media. Se desideri utilizzarlo come strumento di previsione tradizionale, potresti voler spostare in avanti la media mobile. Utilizzando il metodo shift e specificando un numero intero positivo, possiamo spostare in avanti la media mobile del numero desiderato di periodi. Ciò garantisce che l'osservazione corrente non sia inclusa nella media.

Inoltre, il metodo rolling offre altri parametri, come la possibilità di impostare qualsiasi valore di ritardo o persino spostare la media mobile al primo giorno utilizzando un numero intero negativo.

Inoltre, dimostro come calcolare la volatilità storica, spesso utilizzata nel prezzo delle opzioni. Per fare ciò, dobbiamo aggiungere un'altra colonna al frame di dati. Usando numpy, calcolo i rendimenti logaritmici dividendo i prezzi di chiusura per la chiusura del giorno precedente. Tracciando questi rendimenti viene visualizzato un grafico rumoroso centrato attorno allo zero.

Per ottenere la volatilità storica, utilizziamo una deviazione standard mobile con una finestra di 21 giorni, poiché in genere ci sono 21 giorni di negoziazione in un mese. Questo calcolo include la ventunesima osservazione, quindi per riflettere accuratamente la volatilità, spostiamo il risultato in avanti di un giorno. Ciò evita di implicare che abbiamo una conoscenza futura. Tracciare la volatilità fornisce una rappresentazione più chiara dei dati e rivela periodi di alta e bassa volatilità dei prezzi dell'oro.

In un video futuro, tratterò ulteriori tecniche di analisi dei prezzi utilizzando i panda. Spero che questo tutorial abbia fornito un'utile introduzione all'utilizzo del metodo rolling nei panda per le medie mobili e le deviazioni standard rolling.

[MetaQuotes]

Analisi quantitativa del prezzo delle azioni con Python, panda, NumPy matplotlib e SciPy

Analisi quantitativa del prezzo delle azioni con Python, panda, NumPy matplotlib e SciPy

In questo video, il relatore introduce metodi analitici quantitativi per analizzare le variazioni dei prezzi delle azioni. L'obiettivo principale è determinare se la variazione del prezzo delle azioni segue una distribuzione normale, identificare eventuali distorsioni direzionali nella variazione giornaliera e valutare se il movimento del prezzo può essere descritto come una passeggiata casuale. L'oratore menziona l'utilizzo di un notebook Jupyter e fornisce un collegamento per il download del notebook.

Il relatore inizia configurando l'ambiente e importando librerie di analisi dei dati come NumPy, Pandas e Matplotlib. Citano anche l'utilizzo della libreria Pandas Data Reader per scaricare dati in tempo reale dall'API di Yahoo. L'oratore quindi recupera i dati delle azioni per Amazon, specificando le date di inizio e di fine, che per impostazione predefinita sono gli ultimi cinque anni di dati sui prezzi.

Dopo aver ottenuto i dati, il relatore esamina le prime righe per verificare le informazioni disponibili. Sottolineano le colonne che rappresentano i prezzi massimi, minimi, aperti, chiusi, di volume e di chiusura rettificati. Poiché sono principalmente interessati al prezzo di chiusura, discutono l'opzione di utilizzare la colonna "chiusura" o "chiusura corretta", quest'ultima utile per le azioni che hanno subito frazionamenti. In questo caso, poiché l'ultima scissione di Amazon risale al 1999, la scelta tra le due colonne non ha molta importanza.

Successivamente, l'oratore estrae la colonna del prezzo di chiusura in una variabile separata e calcola il tasso di rendimento istantaneo utilizzando il logaritmo della differenza tra prezzi di chiusura consecutivi. Visualizzano i valori risultanti, notando che la prima riga contiene un valore NaN (non un numero) perché il rendimento non può essere calcolato per il primo giorno.

L'oratore visualizza quindi la variazione giornaliera dei prezzi tracciando i dati come un grafico a linee utilizzando Matplotlib. Osservano che la variazione dei prezzi fluttua considerevolmente e si concentra intorno allo zero, con grandi eventi occasionali che si verificano in modo imprevedibile durante il periodo di cinque anni. Per analizzare un periodo di tempo specifico, tracciano i dati dell'ultimo anno, che mostrano una minore densità ma mantengono lo stesso modello generale.

Le statistiche descrittive per il movimento dei prezzi si ottengono utilizzando la funzione "descrivi" di Pandas. Il relatore accenna alla possibilità di ottenere le statistiche individualmente o utilizzando altri strumenti ma ritiene che il metodo Pandas sia sufficiente per i loro scopi. Introducono anche la libreria SciPy e dimostrano un altro modo per calcolare le statistiche descrittive utilizzando la funzione "descrivi" dalle statistiche SciPy. Dicono che alcuni valori appaiono come "NaN" a causa della gestione di valori mancanti in NumPy e SciPy.

Per rendere i numeri più interpretabili, l'oratore moltiplica i valori per 100 per convertirli in percentuali. Questa modifica migliora la leggibilità dell'output senza alterare i dati.

Proseguendo, il relatore confronta la distribuzione della variazione giornaliera del prezzo con un campione tratto da una distribuzione normale. Tracciano un istogramma dei dati sui resi di Amazon e osservano che mostra un'attività significativa attorno al centro, con i rendimenti che si estendono a sinistra ea destra, indicando code più grosse rispetto a una distribuzione normale. Quindi generano un campione della stessa dimensione da una distribuzione normale utilizzando il modulo delle statistiche SciPy e lo tracciano come istogramma accanto ai dati di ritorno di Amazon. Il campione di distribuzione normale appare squatter e distribuito in modo più uniforme rispetto ai dati di Amazon.

Successivamente, l'oratore esegue un test statistico, in particolare un test di curtosi, sia sulla variabile normale che sui rendimenti di Amazon. Il test della curtosi esamina se la distribuzione può essere considerata normale, con l'ipotesi nulla che presuppone una distribuzione normale. Si ottengono la statistica del test e il valore p, con il relatore che spiega l'interpretazione dei risultati. Per la variabile normale, la statistica del test è leggermente negativa, indicando nessuna forte evidenza contro l'ipotesi nulla. Al contrario, per i rendimenti di Amazon, la statistica del test è molto più ampia, suggerendo un rifiuto dell'ipotesi nulla e concludendo che la variazione di prezzo di Amazon non può essere descritta come normalmente distribuita.

Per visualizzare ulteriormente la differenza, l'altoparlante modifica l'istogramma visualizzando le proporzioni anziché le frequenze e quanto bene si adatta alla distribuzione. Per fare ciò, apporterò un paio di modifiche all'istogramma iniziale. Invece di visualizzare le frequenze, visualizzerò le proporzioni. In questo modo, posso sovrapporre una curva normale teorica sull'istogramma e vedere come si adatta.

Andiamo avanti e tracciamo l'istogramma con la curva normale. Userò il modulo norm di scipy.stats per generare la curva normale, quindi la traccerò sullo stesso grafico dell'istogramma.

import matplotlib.pyplot as plt

# Plot histogram
plt.hist(amazon_return, bins= 50 , density=True, alpha= 0.5 , label= 'Amazon Returns' )

# Generate normal curve
x = np.linspace(amazon_return.min(), amazon_return.max(), 100 )
normal_curve = norm.pdf(x, mu, sigma)

# Plot normal curve
plt.plot(x, normal_curve, 'r-' , label= 'Normal Distribution' )

# Add labels and legend
plt.xlabel( 'Daily Price Change' )
plt.ylabel( 'Proportion' )
plt.title( 'Histogram of Amazon Returns with Normal Distribution' )
plt.legend()

# Show the plot
plt.show()

Ora diamo un'occhiata alla trama. Abbiamo l'istogramma dei rendimenti di Amazon e la sovrapposizione della curva di distribuzione normale teorica. Questo confronto visivo ci consente di valutare in che misura le variazioni di prezzo giornaliere si allineano con una distribuzione normale.

Osservando la trama, possiamo vedere che l'istogramma dei rendimenti di Amazon devia in modo significativo dalla forma di una distribuzione normale. La distribuzione ha code più grosse, indicando una maggiore presenza di movimenti di prezzo estremi rispetto a quanto ci aspetteremmo da una distribuzione normale. Ciò è in linea con la nostra precedente analisi della curtosi, che indicava un eccesso di curtosi nei dati sui resi di Amazon.

In conclusione, sulla base dei metodi analitici quantitativi che abbiamo impiegato, possiamo determinare che la variazione del prezzo delle azioni di Amazon non può essere descritta come un fenomeno normalmente distribuito. I dati presentano caratteristiche come l'asimmetria e l'eccesso di curtosi, che indicano deviazioni da una distribuzione normale. Le variazioni di prezzo giornaliere sono più raggruppate intorno allo zero, con il frequente verificarsi di movimenti più ampi e imprevedibili. Queste informazioni sono preziose per comprendere la natura del comportamento del prezzo delle azioni di Amazon e possono essere utili nello sviluppo di strategie di investimento o approcci di gestione del rischio.