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

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

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

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:

 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.

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 !