added stock prediction tutorial

Author: x4nth055

README.md

@@ -39,6 +39,7 @@ This is a repository of all the tutorials of [The Python Code](https://www.thepy
     - [Building a Speech Emotion Recognizer using Scikit-learn](https://www.thepythoncode.com/article/building-a-speech-emotion-recognizer-using-sklearn). ([code](machine-learning/speech-emotion-recognition))
     - [How to Convert Speech to Text in Python](https://www.thepythoncode.com/article/using-speech-recognition-to-convert-speech-to-text-python). ([code](machine-learning/speech-recognition))
     - [Top 8 Python Libraries For Data Scientists and Machine Learning Engineers](https://www.thepythoncode.com/article/top-python-libraries-for-data-scientists).
+    - [How to Predict Stock Prices in Python using TensorFlow 2 and Keras](https://www.thepythoncode.com/article/stock-price-prediction-in-python-using-tensorflow-2-and-keras). ([code](machine-learning/stock-prediction))
 
 
 - ### [General Python Topics](https://www.thepythoncode.com/topic/general-python-topics)

machine-learning/stock-prediction/README.md

@@ -0,0 +1,6 @@
+# [How to Predict Stock Prices in Python using TensorFlow 2 and Keras](https://www.thepythoncode.com/article/stock-price-prediction-in-python-using-tensorflow-2-and-keras)
+
+To run this:
+- `pip3 install -r requirements.txt`
+- Please read the tutorial before using this, edit `parameters.py` for your needs and run `train.py`. This will start training using the parameters you specified, you can use `tensorboard` on `logs` folder to visualize your training process.
+- Once you trained your model, use `test.py` to evaluate and test your model.

machine-learning/stock-prediction/data/AAPL_2020-01-08.csv

@@ -0,0 +1,40 @@
+import os
+import time
+from tensorflow.keras.layers import LSTM
+
+
+# Window size or the sequence length
+N_STEPS = 100
+# Lookup step, 1 is the next day
+LOOKUP_STEP = 90
+
+# test ratio size, 0.2 is 20%
+TEST_SIZE = 0.2
+# features to use
+FEATURE_COLUMNS = ["adjclose", "volume", "open", "high", "low"]
+# date now
+date_now = time.strftime("%Y-%m-%d")
+
+### model parameters
+
+N_LAYERS = 3
+# LSTM cell
+CELL = LSTM
+# 256 LSTM neurons
+UNITS = 256
+# 40% dropout
+DROPOUT = 0.4
+
+### training parameters
+
+# mean squared error loss
+LOSS = "mse"
+OPTIMIZER = "rmsprop"
+BATCH_SIZE = 64
+EPOCHS = 300
+
+# Apple stock market
+ticker = "AAPL"
+ticker_data_filename = os.path.join("data", f"{ticker}_{date_now}.csv")
+# model name to save
+model_name = f"{date_now}_{ticker}-{LOSS}-{CELL.__name__}-seq-{N_STEPS}-step-{LOOKUP_STEP}-layers-{N_LAYERS}-units-{UNITS}"

machine-learning/stock-prediction/data/TSLA_2020-01-08.csv

@@ -0,0 +1,6 @@
+sklearn
+tensorflow
+matplotlib
+numpy
+pandas
+yahoo_fin

machine-learning/stock-prediction/logs/2020-01-08_AAPL-mse-LSTM-seq-50-step-1-layers-3-units-256/train/events.out.tfevents.1578493736.DESKTOP-JCAH48A.15628.1854.v2

@@ -0,0 +1,122 @@
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
+from sklearn import preprocessing
+from sklearn.model_selection import train_test_split
+from yahoo_fin import stock_info as si
+from collections import deque
+
+import numpy as np
+import pandas as pd
+import random
+
+
+def load_data(ticker, n_steps=50, scale=True, shuffle=True, lookup_step=1, 
+                test_size=0.2, feature_columns=['adjclose', 'volume', 'open', 'high', 'low']):
+    """
+    Loads data from Yahoo Finance source, as well as scaling, shuffling, normalizing and splitting.
+    Params:
+        ticker (str/pd.DataFrame): the ticker you want to load, examples include AAPL, TESL, etc.
+        n_steps (int): the historical sequence length (i.e window size) used to predict, default is 50
+        scale (bool): whether to scale prices from 0 to 1, default is True
+        shuffle (bool): whether to shuffle the data, default is True
+        lookup_step (int): the future lookup step to predict, default is 1 (e.g next day)
+        test_size (float): ratio for test data, default is 0.2 (20% testing data)
+        feature_columns (list): the list of features to use to feed into the model, default is everything grabbed from yahoo_fin
+    """
+    # see if ticker is already a loaded stock from yahoo finance
+    if isinstance(ticker, str):
+        # load it from yahoo_fin library
+        df = si.get_data(ticker)
+    elif isinstance(ticker, pd.DataFrame):
+        # already loaded, use it directly
+        df = ticker
+    else:
+        raise TypeError("ticker can be either a str or a `pd.DataFrame` instances")
+
+    # this will contain all the elements we want to return from this function
+    result = {}
+    # we will also return the original dataframe itself
+    result['df'] = df.copy()
+
+    # make sure that the passed feature_columns exist in the dataframe
+    for col in feature_columns:
+        assert col in df.columns
+
+    if scale:
+        column_scaler = {}
+        # scale the data (prices) from 0 to 1
+        for column in feature_columns:
+            scaler = preprocessing.MinMaxScaler()
+            df[column] = scaler.fit_transform(np.expand_dims(df[column].values, axis=1))
+            column_scaler[column] = scaler
+
+        # add the MinMaxScaler instances to the result returned
+        result["column_scaler"] = column_scaler
+
+    # add the target column (label) by shifting by `lookup_step`
+    df['future'] = df['adjclose'].shift(-lookup_step)
+
+    # last `lookup_step` columns contains NaN in future column
+    # get them before droping NaNs
+    last_sequence = np.array(df[feature_columns].tail(lookup_step))
+    
+    # drop NaNs
+    df.dropna(inplace=True)
+
+    sequence_data = []
+    sequences = deque(maxlen=n_steps)
+
+    for entry, target in zip(df[feature_columns].values, df['future'].values):
+        sequences.append(entry)
+        if len(sequences) == n_steps:
+            sequence_data.append([np.array(sequences), target])
+
+    # get the last sequence by appending the last `n_step` sequence with `lookup_step` sequence
+    # for instance, if n_steps=50 and lookup_step=10, last_sequence should be of 59 (that is 50+10-1) length
+    # this last_sequence will be used to predict in future dates that are not available in the dataset
+    last_sequence = list(sequences) + list(last_sequence)
+    # shift the last sequence by -1
+    last_sequence = np.array(pd.DataFrame(last_sequence).shift(-1).dropna())
+    # add to result
+    result['last_sequence'] = last_sequence
+    
+    # construct the X's and y's
+    X, y = [], []
+    for seq, target in sequence_data:
+        X.append(seq)
+        y.append(target)
+
+    # convert to numpy arrays
+    X = np.array(X)
+    y = np.array(y)
+
+    # reshape X to fit the neural network
+    X = X.reshape((X.shape[0], X.shape[2], X.shape[1]))
+    
+    # split the dataset
+    result["X_train"], result["X_test"], result["y_train"], result["y_test"] = train_test_split(X, y, 
+                                                                                test_size=test_size, shuffle=shuffle)
+    # return the result
+    return result
+
+
+def create_model(input_length, units=256, cell=LSTM, n_layers=2, dropout=0.3,
+                loss="mean_absolute_error", optimizer="rmsprop"):
+    model = Sequential()
+    for i in range(n_layers):
+        if i == 0:
+            # first layer
+            model.add(cell(units, return_sequences=True, input_shape=(None, input_length)))
+        elif i == n_layers - 1:
+            # last layer
+            model.add(cell(units, return_sequences=False))
+        else:
+            # hidden layers
+            model.add(cell(units, return_sequences=True))
+        # add dropout after each layer
+        model.add(Dropout(dropout))
+    
+    model.add(Dense(1, activation="linear"))
+    model.compile(loss=loss, metrics=["mean_absolute_error"], optimizer=optimizer)
+
+    return model

machine-learning/stock-prediction/logs/2020-01-08_AAPL-mse-LSTM-seq-50-step-1-layers-3-units-256/train/events.out.tfevents.1578493742.DESKTOP-JCAH48A.profile-empty

@@ -0,0 +1,67 @@
+from stock_prediction import create_model, load_data, np
+from parameters import *
+import matplotlib.pyplot as plt
+from sklearn.metrics import accuracy_score
+
+def plot_graph(model, data):
+    y_test = data["y_test"]
+    X_test = data["X_test"]
+    y_pred = model.predict(X_test)
+    y_test = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(np.expand_dims(y_test, axis=0)))
+    y_pred = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(y_pred))
+    plt.plot(y_test[-200:], c='b')
+    plt.plot(y_pred[-200:], c='r')
+    plt.xlabel("Days")
+    plt.ylabel("Price")
+    plt.legend(["Actual Price", "Predicted Price"])
+    plt.show()
+
+
+def get_accuracy(model, data):
+    y_test = data["y_test"]
+    X_test = data["X_test"]
+    y_pred = model.predict(X_test)
+    y_test = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(np.expand_dims(y_test, axis=0)))
+    y_pred = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(y_pred))
+    y_pred = list(map(lambda current, future: int(float(future) > float(current)), y_test[:-LOOKUP_STEP], y_pred[LOOKUP_STEP:]))
+    y_test = list(map(lambda current, future: int(float(future) > float(current)), y_test[:-LOOKUP_STEP], y_test[LOOKUP_STEP:]))
+    return accuracy_score(y_test, y_pred)
+
+
+def predict(model, data, classification=False):
+    # retrieve the last sequence from data
+    last_sequence = data["last_sequence"][:N_STEPS]
+    # retrieve the column scalers
+    column_scaler = data["column_scaler"]
+    # reshape the last sequence
+    last_sequence = last_sequence.reshape((last_sequence.shape[1], last_sequence.shape[0]))
+    # expand dimension
+    last_sequence = np.expand_dims(last_sequence, axis=0)
+    # get the prediction (scaled from 0 to 1)
+    prediction = model.predict(last_sequence)
+    # get the price (by inverting the scaling)
+    predicted_price = column_scaler["adjclose"].inverse_transform(prediction)[0][0]
+    return predicted_price
+
+
+# load the data
+data = load_data(ticker, N_STEPS, lookup_step=LOOKUP_STEP, test_size=TEST_SIZE,
+                feature_columns=FEATURE_COLUMNS, shuffle=False)
+
+# construct the model
+model = create_model(N_STEPS, loss=LOSS, units=UNITS, cell=CELL, n_layers=N_LAYERS,
+                    dropout=DROPOUT, optimizer=OPTIMIZER)
+
+model_path = os.path.join("results", model_name) + ".h5"
+model.load_weights(model_path)
+
+# evaluate the model
+mse, mae = model.evaluate(data["X_test"], data["y_test"])
+# calculate the mean absolute error (inverse scaling)
+mean_absolute_error = data["column_scaler"]["adjclose"].inverse_transform(mae.reshape(1, -1))[0][0]
+print("Mean Absolute Error:", mean_absolute_error)
+# predict the future price
+future_price = predict(model, data)
+print(f"Future price after {LOOKUP_STEP} days is {future_price:.2f}$")
+print("Accuracy Score:", get_accuracy(model, data))
+plot_graph(model, data)

machine-learning/stock-prediction/logs/2020-01-08_AAPL-mse-LSTM-seq-50-step-1-layers-3-units-256/train/plugins/profile/2020-01-08_15-29-02/local.trace

@@ -0,0 +1,45 @@
+from stock_prediction import create_model, load_data
+from tensorflow.keras.layers import LSTM
+from tensorflow.keras.callbacks import ModelCheckpoint, TensorBoard
+import os
+import pandas as pd
+from parameters import *
+
+
+# create these folders if they does not exist
+if not os.path.isdir("results"):
+    os.mkdir("results")
+
+if not os.path.isdir("logs"):
+    os.mkdir("logs")
+
+if not os.path.isdir("data"):
+    os.mkdir("data")
+
+# load the CSV file from disk (dataset) if it already exists (without downloading)
+if os.path.isfile(ticker_data_filename):
+    ticker = pd.read_csv(ticker_data_filename)
+
+# load the data
+data = load_data(ticker, N_STEPS, lookup_step=LOOKUP_STEP, test_size=TEST_SIZE, feature_columns=FEATURE_COLUMNS)
+
+if not os.path.isfile(ticker_data_filename):
+    # save the CSV file (dataset)
+    data["df"].to_csv(ticker_data_filename)
+
+# construct the model
+model = create_model(N_STEPS, loss=LOSS, units=UNITS, cell=CELL, n_layers=N_LAYERS,
+                    dropout=DROPOUT, optimizer=OPTIMIZER)
+
+# some tensorflow callbacks
+checkpointer = ModelCheckpoint(os.path.join("results", model_name), save_weights_only=True, save_best_only=True, verbose=1)
+tensorboard = TensorBoard(log_dir=os.path.join("logs", model_name))
+
+history = model.fit(data["X_train"], data["y_train"],
+                    batch_size=BATCH_SIZE,
+                    epochs=EPOCHS,
+                    validation_data=(data["X_test"], data["y_test"]),
+                    callbacks=[checkpointer, tensorboard],
+                    verbose=1)
+
+model.save(os.path.join("results", model_name) + ".h5")