Esempio pratico di Deep Learning con Python : Previsione del prezzo delle azioni

Prerequisiti :

• Se non sai perchè utilizzeremo python, clicca qui

• Se non hai ancora installato Python, clicca qui

• Se non sai come scaricare e gestire le librerie, clicca qui

• Se non sai cosa sia un Dataset, clicca qui

In questo articolo ti mostrerò come scrivere un programma python che prevede il prezzo delle azioni utilizzando una tecnica di apprendimento automatico chiamata Long Short-Term Memory (LSTM) . Questo programma è davvero semplice e dubito che da questo programma ne riusciare a trarre un profitto importante, ma è leggermente meglio che indovinare! Ricorda che il prezzo delle azioni può essere influenzato da molti parametri diversi.

Lunga memoria a breve termine (LSTM) è una rete neurale artificiale ricorrente (RNN) utilizzato nel campo dell'apprendimento profonda. A differenza delle reti neurali feed forward standard, LSTM ha connessioni di feedback. Non solo può elaborare singoli punti dati (come le immagini), ma anche intere sequenze di dati .

- Wikipedia

Gli LSTM sono ampiamente utilizzati per i problemi di predizione di sequenza e si sono dimostrati estremamente efficaci. Il motivo per cui funzionano così bene è perché LSTM è in grado di memorizzare le informazioni passate che sono importanti e dimenticare le informazioni che non lo sono.

-Stackabuse.com

Iniziamo a programmare il nostro modello:

Inizierò affermando cosa voglio che faccia questo programma.

Voglio che questo programma preveda i prezzi delle azioni Apple Inc. 60 giorni nel futuro in base al prezzo di chiusura corrente.

Per prima cosa scriverò una descrizione del programma.

# Descrizione: questo programma utilizza una rete neurale artificiale ricorrente chiamata Long Short Term Memory (LSTM) per prevedere il prezzo di chiusura delle azioni di una società (Apple Inc.) utilizzando il prezzo delle azioni degli ultimi 60 giorni.

Successivamente caricherò / importerò le librerie che verranno utilizzate in questo programma.

import math
import pandas_datareader as web
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense, LSTM
import matplotlib.pyplot as plt
plt.style.use('fivethirtyeight')

Riceverò la quotazione delle azioni della società "Apple Inc." utilizzando il ticker di borsa delle società (AAPL) dal 1 gennaio 2012 al 17 dicembre 2019.

#Ricevi la quotazione di borsa 
df = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2019-12-17') 
#stampa le quotazioni
df

Output:
High Low Open CloseVolumeAdj CloseDate 2012-01-0314.73214214.60714214.62142814.686786302220800.012.5666762012-01-0414.81000014.61714314.64285814.765715260022000.012.6342132012-01-0514.94821514.73821414.81964314.929643271269600.012.7744812012-01-0615.09821414.97214314.99178615.085714318292800.012.9080232012-01-0915.27678615.04821415.19642815.061786394024400.012.887549.....................2019-12-1167.77500267.12500067.20249967.69249778756800.066.5678862019-12-1268.13999966.83000266.94500067.864998137310400.066.7375182019-12-1368.82499767.73249867.86499868.787498133587600.067.6447072019-12-1670.19750269.24500369.25000069.964996128186000.068.8026352019-12-1770.44249769.69999769.89250270.102501114158400.068.937851

2003 rows × 6 columns

Queste sono le quotazione di azioni Apple. Successivamente, mostrerò il numero di righe e colonne nel set di dati. Il risultato mostra che abbiamo 2003 righe o giorni in cui è stato registrato il prezzo delle azioni e 6 colonne.

df.shape

Output:
(2003, 6)

Crea un grafico per visualizzare i dati.

#Visualizza la cronologia del prezzo di chiusura
plt.figure(figsize=(16,8))
plt.title('Close Price History')
plt.plot(df['Close'])
plt.xlabel('Date',fontsize=18)
plt.ylabel('Close Price USD ($)',fontsize=18)
plt.show()

Output:

grafico quotazioni Apple

Grafico che mostra la cronologia dei prezzi delle azioni di chiusura di Apple Inc.

Crea un nuovo data frame con solo il prezzo di chiusura e convertilo in un array. Quindi creare una variabile per memorizzare la lunghezza del set di dati di addestramento. Desidero che il set di dati di addestramento contenga circa l'80% dei dati.

#nuova dataframe solo con le chiusure
data = df.filter(['Close'])
#Convertiamolo in un numpy array
dataset = data.values
training_data_len = math.ceil( len(dataset) *.8) 

Ora ridimensiona il set di dati in modo che sia valori compresi tra 0 e 1 incluso, lo faccio perché è generalmente buona pratica ridimensionare i dati prima di darli alla rete neurale.

#Scala tutti i dati in modo che siano valori compresi tra 0 e 1 
scaler = MinMaxScaler(feature_range=(0, 1)) 
scaled_data = scaler.fit_transform(dataset)
​

Creare un set di dati di addestramento che contenga i valori del prezzo di chiusura degli ultimi 60 giorni che si desidera utilizzare per prevedere il valore del prezzo di chiusura 61 °. Quindi la prima colonna nel set di dati ' x_train ' conterrà i valori dal set di dati dall'indice 0 all'indice 59 (60 valori in totale) e la seconda colonna conterrà i valori dal set di dati dall'indice 1 all'indice 60 (60 valori) E così via e così via. Il set di dati " y_train " conterrà il 61 ° valore situato all'indice 60 per la sua prima colonna e il 62 ° valore situato all'indice 61 del set di dati per il suo secondo valore e così via e così via.

#Crea il set di dati per l'addestramento in scala
train_data = scaled_data[0:training_data_len  , : ]
#Dividi i dati nel x_train e  y_train
x_train=[]
y_train = []
for i in range(60,len(train_data)):
 x_train.append(train_data[i-60:i,0])
 y_train.append(train_data[i,0])

Ora converti il ​​set di dati indipendente " x_train " e il set di dati dipendente " y_train " in array numpy in modo che possano essere utilizzati per l'addestramento del modello LSTM.

# Converti x_train e y_train in array
x_train, y_train = np.array(x_train), np.array(y_train)

Rimodellare i dati in modo tridimensionale nella forma

• numero di campioni

• numero di fasi temporali

• numero di caratteristiche

Il modello LSTM si aspetta un set di dati tridimensionale.

#Reshape i dati nella forma accettata da LSTM
x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))

Costruisci il modello LSTM per avere due strati LSTM con 50 neuroni e due strati densi, uno con 25 neuroni e l'altro con 1 neurone di output.

#Costruiamo il LSTM network model
model = Sequential()
model.add(LSTM(units=50, return_sequences=True,input_shape=(x_train.shape[1],1)))
model.add(LSTM(units=50, return_sequences=False))
model.add(Dense(units=25))
model.add(Dense(units=1))

Compilare il modello utilizzando la funzione di perdita dell'errore quadratico medio (MSE) e l'ottimizzatore adam.

#Compila il modello model.compile
model.compile(optimizer='adam', loss='mean_squared_error')

Addestra il modello utilizzando i set di dati di addestramento. La dimensione del batch è il numero totale di esempi di addestramento presenti in un singolo batch ed epoch è il numero di iterazioni in cui un intero set di dati viene passato avanti e indietro attraverso la rete neurale.

#Allena il modello
model.fit(x_train, y_train, batch_size=1, epochs=10)

Output:
Epoch 1/10 1543/1543 [==============================] - 21s 14ms/step - loss: 6.0664e-04 
Epoch 2/10 1543/1543 [==============================] - 21s 13ms/step - loss: 2.9017e-04 
Epoch 3/10 1543/1543 [==============================] - 21s 13ms/step - loss: 2.4941e-04 
Epoch 4/10 1543/1543 [==============================] - 20s 13ms/step - loss: 1.5669e-04 
Epoch 5/10 1543/1543 [==============================] - 21s 13ms/step - loss: 1.6930e-04 
Epoch 6/10 1543/1543 [==============================] - 21s 13ms/step - loss: 1.5684e-04 
Epoch 7/10 1543/1543 [==============================] - 21s 14ms/step - loss: 1.6119e-04
Epoch 8/10 1543/1543 [==============================] - 22s 14ms/step - loss: 1.4235e-04 
Epoch 9/10 1543/1543 [==============================] - 24s 15ms/step - loss: 1.4032e-04 
Epoch 10/10 1543/1543 [==============================] - 23s 15ms/step - loss: 1.4214e-04

Crea un set di dati di test.

#Dati di test
test_data = scaled_data[training_data_len - 60: , : ]
#Crea i set di dati x_test e y_test
x_test = []
y_test = dataset[training_data_len : , : ] 
#Recupera tutte le righe dall'indice 1603 al resto e tutte le colonne (in questo caso è solo la colonna "Chiudi"), così 2003 - 1603 = 400 righe di dati 
for i in range(60,len(test_data)):
 x_test.append(test_data[i-60:i,0])

Quindi converti il ​​set di dati di test indipendente ' x_test ' in un array numpy in modo che possa essere utilizzato per testare il modello LSTM.

# Converti x_test in un array numpy 
x_test = np.array(x_test)

Rimodellare i dati in modo tridimensionale nella forma [numero di campioni , numero di fasi temporali e numero di caratteristiche ]. Questo deve essere fatto, perché il modello LSTM si aspetta un set di dati tridimensionale.

#Reshape i dati nella forma accettata da LSTM
x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1))

Ora ottieni i valori previsti dal modello utilizzando i dati del test.

#Otteniamo le predizioni del modello
predictions = model.predict(x_test) 
predictions = scaler.inverse_transform(predictions)

Ottieni l'errore quadratico medio (RMSE), che è una buona misura dell'accuratezza del modello. Un valore pari a 0 indica che i valori previsti dai modelli corrispondono perfettamente ai valori effettivi del set di dati del test. Più basso è il valore, migliori saranno le prestazioni del modello. Ma di solito è meglio usare anche altre metriche per avere davvero un'idea di come si è comportato bene il modello.

# Calcola / Ottieni il valore di RMSE
rmse=np.sqrt(np.mean(((predictions- y_test)**2)))
rmse

Output:
1.020505485309228

Tracciamo e visualizziamo i dati.

# Traccia / Crea i dati per il
train = data[:training_data_len]
valid = data[training_data_len:]
valid['Predictions'] = predictions
#Visualize the data
plt.figure(figsize=(16,8))
plt.title('Model')
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.plot(train['Close'])
plt.plot(valid[['Close', 'Predictions']])
plt.legend(['Train', 'Val', 'Predictions'], loc='lower right')
plt.show()

Output:

Visualizzazione valori predetti

Il grafico che mostra i prezzi di formazione (allenamento), effettivi (validi) e previsti (previsioni).Mostra i prezzi validi e previsti.

valid

Output:
Close Predictions Date 
2018-05-1746.74750146.8632932018-05-1846.57749946.3976942018-05-2146.90750146.3534812018-05-2246.79000146.7314762018-05-2347.09000046.534359.........2019-12-1167.69249766.0610052019-12-1267.86499866.4198382019-12-1368.78749866.5070722019-12-1669.96499667.5563352019-12-1770.10250168.624374
400 rows × 2 columns

I valori del prezzo effettivo (chiusura) e previsto (previsioni).Voglio testare ancora il modello e ottenere il valore del prezzo di chiusura previsto di Apple Inc. per il 18 dicembre 2019 (18/12/2019). Convertirò i dati in un array che contiene solo il prezzo di chiusura. Quindi otterrò il prezzo di chiusura degli ultimi 60 giorni e ridimensionerò i dati in modo che siano valori compresi tra 0 e 1 inclusi. Dopodiché creerò un elenco vuoto e vi aggiungerò il prezzo degli ultimi 60 giorni, quindi lo convertirò in un array numpy e lo rimodellerò in modo da poter inserire i dati nel modello. Ultimo ma non meno importante, inserirò i dati nel modello e otterrò il prezzo previsto.

# Ottieni la citazione
apple_quote = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2019-12-17')
#Crea un nuovo dataframe
new_df = apple_quote.filter(['Close'])
# Ottieni il prezzo di chiusura degli ultimi 60 giorni 
last_60_days = new_df[-60:].values
#Scala i dati in modo che siano valori compresi tra 0 e 1
last_60_days_scaled = scaler.transform(last_60_days)
#Crea un elenco vuoto
X_test = []
#Appendi agli ultimi 60 giorni
X_test.append(last_60_days_scaled)
# Converti il ​​set di dati X_test in un array
X_test = np.array(X_test)
#ridimensioni i dati 
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
# Ottieni il prezzo scalato previsto
pred_price = model.predict(X_test)

pred_price = scaler.inverse_transform (pred_price)
print (pred_price)


Output:
[[68.51323]] 

Ora vediamo qual era il prezzo effettivo per quel giorno.

apple_quote2 = web.DataReader('AAPL', data_source='yahoo', start='2019-12-18', end='2019-12-18')
print(apple_quote2['Close'])

Output:
Date 2019-12-18    69.934998 
Name: Close, dtype: float64

Proprio come volevamo "quasi" una predizione Perfetta.

Scarica Gratuitamente tutto il Progetto

Per scaricare gratuitamente devi prima registrati/accede al portale.

Scorri in fondo alla pagina per registrati o accedere

Condividi e commenta l'articolo se ti è stato utile , Grazie !