Algorithmic Stock Trading Strategy Using Python

stock_trading_strategy

In [1]:

# Algorithmic Stock Trading Strategy Using Python
# compare the simple moving average wi th a 30/100 day to determine the buy/sell price
import math
import pandas_datareader as web
import numpy as np
import pandas as pd
from datetime import datetime
import matplotlib.pyplot as plt
plt.style.use('fivethirtyeight')

In [22]:

AAPL = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2021-04-25')
AAPL

Out[22]:

	High	Low	Open	Close	Volume	Adj Close
Date
2012-01-03	14.732143	14.607143	14.621429	14.686786	302220800.0	12.650659
2012-01-04	14.810000	14.617143	14.642857	14.765714	260022000.0	12.718646
2012-01-05	14.948214	14.738214	14.819643	14.929643	271269600.0	12.859850
2012-01-06	15.098214	14.972143	14.991786	15.085714	318292800.0	12.994284
2012-01-09	15.276786	15.048214	15.196429	15.061786	394024400.0	12.973674
…	…	…	…	…	…	…
2021-04-19	135.470001	133.339996	133.509995	134.839996	94264200.0	134.839996
2021-04-20	135.529999	131.809998	135.020004	133.110001	94812300.0	133.110001
2021-04-21	133.750000	131.300003	132.360001	133.500000	68847100.0	133.500000
2021-04-22	134.149994	131.410004	133.039993	131.940002	84566500.0	131.940002
2021-04-23	135.119995	132.160004	132.160004	134.320007	78657500.0	134.320007

2342 rows × 6 columns

In [23]:

plt.figure(figsize=(16,8))
plt.title('Close Price History')
plt.plot(AAPL['Adj Close'])
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD$', fontsize=18)
plt.show()

In [24]:

# create the simple moving average with a 30 day window
SMA30 = pd.DataFrame()
SMA30['Adj Close'] = AAPL['Adj Close'].rolling(window=30).mean()
SMA30

Out[24]:

	Adj Close
Date
2012-01-03	NaN
2012-01-04	NaN
2012-01-05	NaN
2012-01-06	NaN
2012-01-09	NaN
…	…
2021-04-19	125.136333
2021-04-20	125.694666
2021-04-21	126.108333
2021-04-22	126.507000
2021-04-23	126.919000

2342 rows × 1 columns

In [25]:

# create the simple moving average with a 100 day window
SMA100 = pd.DataFrame()
SMA100['Adj Close'] = AAPL['Adj Close'].rolling(window=100).mean()
SMA100

Out[25]:

	Adj Close
Date
2012-01-03	NaN
2012-01-04	NaN
2012-01-05	NaN
2012-01-06	NaN
2012-01-09	NaN
…	…
2021-04-19	127.688672
2021-04-20	127.882971
2021-04-21	128.067989
2021-04-22	128.228820
2021-04-23	128.407860

2342 rows × 1 columns

In [26]:

plt.figure(figsize=(16,8))
plt.title('Close Price History')
plt.plot(AAPL['Adj Close'], label = 'AAPL')
plt.plot(SMA30['Adj Close'], label = 'SMA30')
plt.plot(SMA100['Adj Close'], label = 'SMA100')
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD$', fontsize=18)
plt.legend(loc='upper left')
plt.show()

In [27]:

# create a new data frame to store all the data
data = pd.DataFrame()
data['AAPL'] = AAPL['Adj Close']
data['SMA30'] = SMA30['Adj Close']
data['SMA100'] = SMA100['Adj Close']
data

Out[27]:

	AAPL	SMA30	SMA100
Date
2012-01-03	12.650659	NaN	NaN
2012-01-04	12.718646	NaN	NaN
2012-01-05	12.859850	NaN	NaN
2012-01-06	12.994284	NaN	NaN
2012-01-09	12.973674	NaN	NaN
…	…	…	…
2021-04-19	134.839996	125.136333	127.688672
2021-04-20	133.110001	125.694666	127.882971
2021-04-21	133.500000	126.108333	128.067989
2021-04-22	131.940002	126.507000	128.228820
2021-04-23	134.320007	126.919000	128.407860

2342 rows × 3 columns

In [41]:

#create a function to signal when to buy and sell 
def buy_sell(data):
  sigPriceBuy = []
  sigPriceSell = []
  flag = -1
  
  for i in range(len(data)):
    if data['SMA30'][i] > data['SMA100'][i]:
      if flag != 1:
        sigPriceBuy.append(data['AAPL'][i])
        sigPriceSell.append(np.nan)
        flag = 1
      else:
        sigPriceBuy.append(np.nan)
        sigPriceSell.append(np.nan)
    elif data['SMA30'][i] < data['SMA100'][i]:
      if flag != 0:
        sigPriceBuy.append(np.nan)
        sigPriceSell.append(data['AAPL'][i])
        flag = 0
      else:
        sigPriceBuy.append(np.nan)
        sigPriceSell.append(np.nan)
    else:
        sigPriceBuy.append(np.nan)
        sigPriceSell.append(np.nan)
  return(sigPriceBuy, sigPriceSell)

In [42]:

#store the buy and sell data into a variable
buy_sell = buy_sell(data)
data['Buy_Signal_Price'] = buy_sell[0]
data['Sell_Signal_Price'] = buy_sell[1]

In [43]:

data

Out[43]:

	AAPL	SMA30	SMA100	Buy_Signal_Price	Sell_Signal_Price
Date
2012-01-03	12.650659	NaN	NaN	NaN	NaN
2012-01-04	12.718646	NaN	NaN	NaN	NaN
2012-01-05	12.859850	NaN	NaN	NaN	NaN
2012-01-06	12.994284	NaN	NaN	NaN	NaN
2012-01-09	12.973674	NaN	NaN	NaN	NaN
…	…	…	…	…	…
2021-04-19	134.839996	125.136333	127.688672	NaN	NaN
2021-04-20	133.110001	125.694666	127.882971	NaN	NaN
2021-04-21	133.500000	126.108333	128.067989	NaN	NaN
2021-04-22	131.940002	126.507000	128.228820	NaN	NaN
2021-04-23	134.320007	126.919000	128.407860	NaN	NaN

2342 rows × 5 columns

In [47]:

#visualize the data and the strategy to buy and sell
plt.figure(figsize=(16,8))
plt.title('Close Price History')
plt.plot(data['AAPL'], label = 'AAPL', alpha = 0.35)
plt.plot(data['SMA30'], label = 'SMA30', alpha = 0.35)
plt.plot(data['SMA100'], label = 'SMA100', alpha = 0.35)
plt.scatter(data.index, data['Buy_Signal_Price'], label = 'Buy', marker = '^', color = 'green')
plt.scatter(data.index, data['Sell_Signal_Price'], label = 'Sell', marker = 'v', color = 'red')
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD$', fontsize=18)
plt.legend(loc='upper left')
plt.show()

In [ ]:

April 29, 2021April 29, 2021

Stock Price Prediction Using Python & Machine Learning

stock_prediction

In [2]:

# Description: this program uses an artificial recurrent neural network called Long Short Term Memory (LSTM) 
# to predict the closing stock price of a corporation (IBM)
# pip install pandas_datareader
# pip install tensorflow
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')

In [11]:

# get stock data from yahoo
df = web.DataReader('IBM', data_source='yahoo', start='2012-01-01', end='2021-04-25')
df

Out[11]:

	High	Low	Open	Close	Volume	Adj Close
Date
2012-01-03	188.710007	186.000000	186.729996	186.300003	5646000.0	134.881241
2012-01-04	186.330002	184.940002	185.570007	185.539993	4346700.0	134.330948
2012-01-05	185.029999	183.100006	184.809998	184.660004	4463100.0	133.693863
2012-01-06	184.479996	182.309998	184.389999	182.539993	4897100.0	132.158981
2012-01-09	182.270004	180.270004	182.199997	181.589996	5201200.0	131.471176
…	…	…	…	…	…	…
2021-04-19	133.820007	132.580002	133.600006	133.119995	8198600.0	133.119995
2021-04-20	139.770004	136.699997	137.070007	138.160004	15480600.0	138.160004
2021-04-21	143.729996	137.710007	138.059998	143.550003	11909000.0	143.550003
2021-04-22	144.740005	141.000000	143.699997	141.279999	7101400.0	141.279999
2021-04-23	143.610001	140.949997	141.309998	142.429993	4556000.0	142.429993

2342 rows × 6 columns

In [12]:

df.shape

Out[12]:

(2342, 6)

In [13]:

# Visualize the closing price history
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()

In [15]:

# create a new dataframe with only the Close colunm
data = df.filter(['Close'])
dataset = data.values
training_data_len = math.ceil(len(dataset) * 0.8)
training_data_len

Out[15]:

In [16]:

# Scale the data
scaler = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler.fit_transform(dataset)
scaled_data

Out[16]:

array([[0.75625879],
       [0.74997928],
       [0.74270844],
       ...,
       [0.4030406 ],
       [0.38428489],
       [0.39378661]])

In [19]:

# create the training data set
# create the scaled training data set
train_data = scaled_data[0:training_data_len, :]
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])
  if i<=60:
    print(x_train)
    print(y_train)
    print

[array([0.75625879, 0.74997928, 0.74270844, 0.72519203, 0.71734277,
       0.7150293 , 0.72337442, 0.70874991, 0.69726516, 0.70420556,
       0.7130464 , 0.70850205, 0.77460136, 0.78666441, 0.8027761 ,
       0.80112364, 0.79492683, 0.79063046, 0.80748573, 0.80831202,
       0.80847718, 0.79947118, 0.81690488, 0.81012977, 0.81450883,
       0.81120379, 0.81269109, 0.80682472, 0.80847718, 0.80517227,
       0.80542013, 0.81178222, 0.81508714, 0.81483928, 0.8188052 ,
       0.84970667, 0.85094598, 0.84904566, 0.85276372, 0.84243571,
       0.84904566, 0.85962154, 0.87490706, 0.84681478, 0.85102869,
       0.86788396, 0.87457649, 0.87771625, 0.90068575, 0.90845244,
       0.91902832, 0.9191109 , 0.91671485, 0.90456909, 0.90820458,
       0.91481453, 0.91473183, 0.93365283, 0.92877791, 0.92968678])]
[0.9377840338711563]

In [20]:

# convert the x_train and y_train to numpy arrays
x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
x_train.shape

Out[20]:

(1814, 60, 1)

In [21]:

# build the LSTM model
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(x_train.shape[1], 1)))
model.add(LSTM(50, return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))

In [23]:

# compile the model
model.compile(optimizer='adam', loss='mean_squared_error')

In [24]:

# train the model
model.fit(x_train, y_train, batch_size=1, epochs=1)

1814/1814 [==============================] - 72s 38ms/step - loss: 0.0057

Out[24]:

<tensorflow.python.keras.callbacks.History at 0x7f0eb01d3ad0>

In [25]:

# create the testing data set
# create a new array containing scaled values from index 1814 to 2342
test_data = scaled_data[training_data_len - 60: , :]
x_test = []
y_test = dataset[training_data_len: , :]
for i in range(60, len(test_data)):
  x_test.append(test_data[i-60:i, 0])

In [26]:

x_test = np.array(x_test)

In [27]:

x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))

In [28]:

#get teh models predicted price values
predictions = model.predict(x_test)
predictions = scaler.inverse_transform(predictions)

In [29]:

# get the root mean squared error (RMSE)
rmse = np.sqrt(np.mean(predictions - y_test)**2)
rmse

Out[29]:

1.0317235441289396

In [30]:

# plot the data
train = data[:training_data_len]
valid = data[training_data_len:]
valid['Predictions'] = predictions
plt.figure(figsize=(16,8))
plt.title('Model')
plt.xlabel('Date')
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()

/home/ubuntu/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  after removing the cwd from sys.path.

In [31]:

valid

Out[31]:

	Close	Predictions
Date
2019-06-17	134.949997	133.716370
2019-06-18	136.380005	133.921265
2019-06-19	137.080002	134.221985
2019-06-20	138.850006	134.618698
2019-06-21	139.199997	135.268433
…	…	…
2021-04-19	133.119995	132.004868
2021-04-20	138.160004	131.903015
2021-04-21	143.550003	132.635849
2021-04-22	141.279999	134.464783
2021-04-23	142.429993	136.136017

468 rows × 2 columns

In [35]:

# get the quote
apple_quote = web.DataReader('IBM', data_source='yahoo', start='2012-01-01', end='2021-04-25')
new_df = apple_quote.filter(['Close'])
last_60_days = new_df[-60:].values
#scale the data to be values between 0 and 1
last_60_days_scaled = scaler.transform(last_60_days)
X_test = []
X_test.append(last_60_days_scaled)
X_test = np.array(X_test)
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
pred_price = model.predict(X_test)
pred_price = scaler.inverse_transform(pred_price)
print(pred_price)

[[137.67413]]

In [37]:

# get the quote
apple_quote2 = web.DataReader('IBM', data_source='yahoo', start='2021-04-27', end='2021-04-27')
print(apple_quote2['Close'])

Date
2021-04-27    142.009995
Name: Close, dtype: float64

In [ ]:

April 22, 2021April 23, 2021

create Solr server with ansible roles from Galaxy

Apache Solr is a fast and scalable search server optimized for full-text search, word highlighting, faceted search, fast indexing, and more. It’s a very popular search server, and it’s pretty easy to install and configure using Ansible.

Step 1. Getting roles from Galaxy
https://galaxy.ansible.com/

ansible-galaxy install geerlingguy.java geerlingguy.solr

Step 2. create solr.yml

---
- hosts: all
  become: yes
  
  roles:
    - geerlingguy.java
    - geerlingguy.solr

Step 3. run it with ansible-playbook solr.yml, then you can open http://ubuntu2004:8983/solr

if you didn’t install roles, the playbook.yml could be:

---
- hosts: all
  become: true

  vars_files:
    - vars.yml

  pre_tasks:
    - name: Update apt cache if needed.
      apt: update_cache=true cache_valid_time=3600

  tasks:
    - name: Install Java.
      apt: name=openjdk-11-jdk state=present

    - name: Download Solr.
      get_url:
        url: "https://archive.apache.org/dist/lucene/solr/{{ solr_version }}/solr-{{ solr_version }}.tgz"
        dest: "{{ download_dir }}/solr-{{ solr_version }}.tgz"
        checksum: "{{ solr_checksum }}"

    - name: Expand Solr.
      unarchive:
        src: "{{ download_dir }}/solr-{{ solr_version }}.tgz"
        dest: "{{ download_dir }}"
        remote_src: true
        creates: "{{ download_dir }}/solr-{{ solr_version }}/README.txt"

    - name: Run Solr installation script.
      command: >
        {{ download_dir }}/solr-{{ solr_version }}/bin/install_solr_service.sh
        {{ download_dir }}/solr-{{ solr_version }}.tgz
        -i /opt
        -d /var/solr
        -u solr
        -s solr
        -p 8983
        creates={{ solr_dir }}/bin/solr

    - name: Ensure solr is started and enabled on boot.
      service: name=solr state=started enabled=yes

Helpful Galaxy commands:
ansible-galaxy list displays a list of installed roles, with version numbers
ansible-galaxy remove [role] removes an installed role

April 21, 2021December 21, 2021

Using ansible-vault to store ssh and sudo password

edit /etc/ansible/ansible.cfg
host_key_checking = False
edit /etc/ansible/hosts
[all:vars]
ansible_connection=ssh
ansible_ssh_user=your_sshid
ansible_ssh_pass=your_sshpassword
ansible_sudo_pass=your_sudopassword
[appservers]
192.168.0.[1-3]
edit playbook.yml

---
-hosts: all
 vars_files:
 - vars.yml
 tasks:
  -name: download file from link
   get_url:
    url:http://github.com/test.txt
    dest: /tmp/test.txt
    mode: 0755
  -name: ensure directory exists
   file:
     path: "{{ jboss_conf_location }}"
     state: directory
     owner: jboss
     group: jboss
  -name: copy file
   command: >
     cp /tmp/test.txt {{ jboss_conf_location }}
   become: yes
   become_user: jboss
  -name: remove file
   file:
     path: "{{ jboss_conf_location }}/test.txt"
     state: absent
   become: yes
   become_user: jboss

then you can run it with ansible-playbook playbook.yml

there is another way to store password, ansible-vault create passwd.yml

ansible_ssh_user: your_sshid
ansible_ssh_pass: your_sshpassword
ansible_sudo_pass: your_sudopassword

then you can run it with command:

ansible-playbook --ask-vault-pass --extra-vars '@passwd.yml' playbook.yml

you can run Shell command with sudo password input:

ansible appservers -m shell -a "source /home/pm2/.bashrc && pm2 status" -b --become-user=pm2 -K

scp files:

- name: Copy configuration files.
  copy:
    src: "{{ item.src }}"
    dest: "{{ item.dest }}"
    owner: root
    group: root
    mode: 0644
  with_items:
    - src: httpd.conf
      dest: /etc/httpd/conf/httpd.conf
    - src: httpd-vhosts.conf
      dest: /etc/httpd/conf/httpd-vhosts.conf

Make sure Apache or other service is started now and at boot:

- name: Make sure Apache is started now and at boot
  service: name=httpd state=started enabled=yes

yum install apache or other packages:

- name: Install Apache.
  yum:
    name:
      - httpd
      - httpd-devel
    state: present

lineinfile edit:

- name: Adjust OpCache memory setting.
  lineinfile:
    dest: "/etc/php/7.1/apache2/conf.d/10-opcache.ini"
    regexp: "^opcache.memory_consumption"
    line: "opcache.memory_consumption = 96"
    state: present
  notify: restart apache

git clone:

- name: Check out drush 8.x branch.
  git:
    repo: https://github.com/drush-ops/drush.git
    version: 8.x
    dest: /opt/drush

run command in one line:

- name: Install Drush dependencies with Composer.
  command: >
    /usr/local/bin/composer install
    chdir=/opt/drush
    creates=/opt/drush/vendor/autoload.php

create file link:

- name: Create drush bin symlink.
  file:
    src: /opt/drush/drush
    dest: /usr/local/bin/drush
    state: link

list files in directory:

    - shell: 'ls -ltr /opt/jboss/log/'
      register: ps

    - debug: var=ps.stdout_lines

April 14, 2021April 14, 2021

How to Install Anaconda and Jupyter on Ubuntu 20.04

STEP1. Commands:
sudo apt install libgl1-mesa-glx libegl1-mesa libxrandr2 libxrandr2 libxss1 libxcursor1 libxcomposite1 libasound2 libxi6 libxtst6
wget -P /tmp https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh
bash /tmp/Anaconda3-2020.02-Linux-x86_64.sh
source ~/.bashrc
conda update –all

STEP2. anaconda-navigator to open the Navigator GUI in terminal:

STEP3. install jupyter notebook extension and start it

pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable –user
conda install -c conda-forge jupyter_contrib_nbextensions
jupyter notebook –ip 0.0.0.0
then you can open http://192.168.226.128:8888/tree#notebooks

You can enable Table of Content to add TOC for your notebook!

April 9, 2021April 9, 2021

Query google geocoding API with python

Create your application’s API key:

Go to the Google API Console https://console.cloud.google.com/apis/dashboard
From the projects list, select a project or create a new one.
If the APIs & services page isn’t already open, open the left side menu and select APIs & services.
On the left, choose Credentials.
Click Create credentials and then select API key.

Enable Geocoding API:

Log in to the Google API Manager Console here: https://console.developers.google.com/apis/library
Click the Library link in the left sidebar
Select the project you created when you created your API Key for WP Google Maps (See the top arrow in the screenshot below)
Click the link to the Google Maps Geocoding API
Click Enable on the Google Maps Geocoding API window.

Verify your KEY in browser https://maps.googleapis.com/maps/api/geocode/json?address=1600+Amphitheatre+Parkway,+Mountain+View,+CA&key=your-key

Create geocode.py

import json
import time
import urllib.error
import urllib.request
import urllib.parse

api_file = 'your-key'
base_url = "https://maps.googleapis.com/maps/api/geocode/json"

def geoapi(address):
    params = urllib.parse.urlencode({"address": address, "key": api_file})
    url = f"{base_url}?{params}"
    response = urllib.request.urlopen(url)
    result = json.load(response)
    return result

if __name__ == "__main__":
    goecode = geoapi('3600 Steeles Ave E, Markham, ON')
    print(goecode)

run it with python geocode.py

April 6, 2021April 6, 2021

Get started with machine learning in Databricks

create Azure Databricks and launch workspace

2. import jupyter notebook into workspace

import Notebooks URL: https://docs.microsoft.com/en-us/azure/databricks/_static/notebooks/getting-started/get-started-sklearn-7.3.html

3. create cluster
we can select Databricks Runtime Version: 8.1 ML (includes Apache Spark 3.1.1, Scala 2.12)
Worker Type: Standard_D12_v2

4. Attach the cluster to notebook and click “Run All”

April 6, 2021April 6, 2021

Work on Azure Machine Learning workspace with python3

Create a machine learning workspace and open Azure Machine Learning Studio

Create a Compute instance in Azure Machine Learning Studio
Open instance Terminal to clone git repository
git clone https://github.com/MicrosoftLearning/mslearn-dp100.git

Open instance Jupyter to run python code