Pull stock prices from online API and perform predictions using Recurrent Neural Network & Long Short Term Memory (LSTM) with TensorFlow.js framework Machine learning is becoming increasingly popular these days and a growing number of the world’s population see it is as a magic crystal ball: predicting when and what will happen in the future. This experiment uses artificial neural networks to reveal stock market trends and demonstrates the ability of time series forecasting to predict future stock prices based on past historical data. Disclaimer: As stock markets fluctuation are dynamic and unpredictable owing to multiple factors, this experiment is 100% educational and by no means a trading prediction tool. . Explore the demo Project Walkthrough There are 4 parts to this project walkthrough: 1. Get stocks data from online API 2. Compute simple moving average for a given time window 3. Train LSTM neural network 4. Predict and compare predicted values to the actual values Get Stocks Data Before we can train the neural network and make any predictions, we will first require data. The type of data we are looking for is time series: a sequence of numbers in chronological order. A good place to fetch these data are from . This API allows us to retrieve chronological data on specific company stocks prices from the last 20 years. alphavantage.co The API yields the following fields: - open price -the highest price of that day - the lowest price of that day - closing price (this is used in this project) - volume To prepare training dataset for our neural network, we will be using closing stocks price. This also means that we will be aiming to predict the future closing price. This graph shows 20 years of Microsoft Corporation weekly closing prices. Simple Moving Average For this experiment, we are using , which means feeding data to the neural network and it learns by mapping input data to the output label. One way to prepare the training dataset is to extract the moving average from that time-series data. supervised learning is a method to identify trends direction for a certain period of time, by looking at the average of all the values within that time window. The number of prices in a time window is selected experimentally. Simple Moving Average (SMA) For example, let’s assume the closing prices for the past 5 days were 13, 15, 14, 16, 17, the SMA would be (13+15+14+16+17)/5 = 15. So the input for our training dataset is the set of prices within a single time window, and its label is the computed moving average of those prices. Let’s compute the SMA of Microsoft Corporation weekly closing prices data, with a window size of 50. { r_avgs = [], avg_prev = ; ( i = ; i <= data.length - window_size; i++){ curr_avg = , t = i + window_size; ( k = i; k < t && k <= data.length; k++){
      curr_avg += data[k][ ] / window_size;
    }
    r_avgs.push({ : data.slice(i, i + window_size), : curr_avg });
    avg_prev = curr_avg;
  } r_avgs;
} ( ) function ComputeSMA data, window_size let 0 for let 0 let 0.00 for let 'price' set avg return And this is what we get, weekly stock closing price in blue, and SMA in orange. Because SMA is the moving average of 50 weeks, it is smoother than the weekly price, which can fluctuate. This graph is a simple Moving Average of Microsoft Corporation closing prices data to actual closing prices. Training Data We can prepare the training data with weekly stock prices and the computed SMA. Given the window size is 50, this means that we will use the closing price of every 50 consecutive weeks as our training features (X), and the SMA of those 50 weeks as our training label (Y). Next, we split our data into 2 sets, training and validation set. If 70% of the data is used for training, then 30% for validation. The API returns us approximate 1000 weeks of data, so 700 for training, and 300 for validation. Train Neural Network Now that the training data is ready, it is time to create a model for time series prediction, to achieve this we will use framework. TensorFlow.js is a library for developing and training machine learning models in JavaScript, and we can deploy these machine learning capabilities in a web browser. TensorFlow.js is selected which simply connects each layer and pass the data from input to the output during the training process. In order for the model to learn time series data which are sequential, (RNN) layer is created and a number of are added to the RNN. Sequential model recurrent neural network LSTM cells The model will be trained using ( ), a popular optimisation algorithm for machine learning. which will determine the difference between predicted values and the actual values, so the model is able to learn by minimising the error during the training process. Adam research paper Root mean square error Here is a code snippet of the model described above, full code on Github. { input_layer_shape  = window_size; input_layer_neurons = ; rnn_input_layer_features = ; rnn_input_layer_timesteps = input_layer_neurons / rnn_input_layer_features; rnn_input_shape  = [rnn_input_layer_features, rnn_input_layer_timesteps]; rnn_output_neurons = ; rnn_batch_size = window_size; output_layer_shape = rnn_output_neurons; output_layer_neurons = ; model = tf.sequential(); X = inputs.slice( , .floor(trainingsize / * inputs.length)); Y = outputs.slice( , .floor(trainingsize / * outputs.length)); xs = tf.tensor2d(X, [X.length, X[ ].length]).div(tf.scalar( )); ys = tf.tensor2d(Y, [Y.length, ]).reshape([Y.length, ]).div(tf.scalar( ));

  model.add(tf.layers.dense({ : input_layer_neurons, : [input_layer_shape]}));
  model.add(tf.layers.reshape({ : rnn_input_shape})); lstm_cells = []; ( index = ; index < n_layers; index++) {
       lstm_cells.push(tf.layers.lstmCell({ : rnn_output_neurons}));
  }

  model.add(tf.layers.rnn({ : lstm_cells, : rnn_input_shape, : }));

  model.add(tf.layers.dense({ : output_layer_neurons, : [output_layer_shape]}));

  model.compile({ : tf.train.adam(learning_rate), : }); hist = model.fit(xs, ys,
    { : rnn_batch_size, : n_epochs, : { : (epoch, log) => {
        callback(epoch, log);
      }
    }
  }); { : model, : hist };
} async ( ) function trainModel inputs, outputs, trainingsize, window_size, n_epochs, learning_rate, n_layers, callback const const 100 const 10 const const const 20 const const const 1 const let 0 Math 100 let 0 Math 100 const 0 10 const 1 1 10 units inputShape targetShape let for let 0 units cell inputShape returnSequences false units inputShape optimizer loss 'meanSquaredError' const await batchSize epochs callbacks onEpochEnd async return model stats These are the (parameters used in the training process) available for tweaking in the : hyper-parameters frontend - Training Dataset Size (%): the amount of data used for training, and remaining data will be used for validation - Epochs: number of times the dataset is used to train the model ( ) learn more - Learning Rate: the amount of change in the weights during training in each step ( ) learn more - Hidden LSTM Layers: to increase the model complexity to learn in higher dimensional space ( ) learn more Click the Begin Training Model button… The model seems to converge at around 15 epoch. Validation Now that the model is trained, it is time to use it for predicting future values, for our case, it is the moving average. We will use the function from TFJS. model.predict The data has been split into 2 sets, training and validation set. The training set has been used for training the model, thus will be using the validation set to validate the model. Since the model has not seen the validation dataset, it will be good if the model is able to predict values that are close to the true values. So let us use the remaining data for prediction which allow us to see how closely our predicted values are compared to the actual values. This graph shows the green line which is the prediction of the validation data. Looks like the model predicted (green line) does a good job plotting closely to the actual price (blue line). This means that the model is able to predict the last 30% of the data which was unseen by the model. Other algorithms can be applied and uses the to compare 2 or more models performance. Root Mean Square Error Prediction Finally, the model has been validated and the predicted values map closely to its true values, we shall use it to predict the future. We will apply the same function and use the last 50 data points as the input, because our window size is 50. Since our training data is increment daily, we will use the past 50 days as input, to predict the 51st day. model.predict This graph shows the latest 50 days, which is the test data (blue line), and the predicted value (orange). Conclusion There are many ways to do time series prediction other than using a simple moving average. Possible future work is to implement this with more data from various sources. With TensorFlow.js, machine learning on a web browser is possible, and it is actually pretty cool. , this experiment is 100% educational and by no means a trading prediction tool. Explore the demo on Github View source code on Github Hi! I’m , currently a data scientist at Alibaba Group, a PhD student at Nanyang Technological University, and a passionate writer on and . Connect with me on . Hong Jing (Jingles) Towards Data Science Hackernoon LinkedIn This article was originally published on Towards Data Science

Ball

Fetch

Microsoft

ORANGE

Scalar

Linear Regression vs. Logistic Regression for Classification Tasks

work work

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Time Series Forecasting with TensorFlow.js

Time Series Forecasting with TensorFlow.js

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Reinforcement Learning - The Value Function

The Noonification: Use This 7-Step McKinsey Framework to Solve Any Problem (1/10/2023)

The Noonification: A Taxonomy of Inclusiveness (1/11/2024)

The Noonification: What is the InfiniteNature-Zero AI Model? (11/19/2022)

10 Ways AI Has Changed Our Lives

Reinforcement Learning - The Value Function

The Noonification: Use This 7-Step McKinsey Framework to Solve Any Problem (1/10/2023)

The Noonification: A Taxonomy of Inclusiveness (1/11/2024)

The Noonification: What is the InfiniteNature-Zero AI Model? (11/19/2022)

10 Ways AI Has Changed Our Lives

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps