# Start writing code here...
from numpy import *
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, TimeDistributed, LeakyReLU
from tensorflow import keras
import matplotlib.pyplot as plt
import matplotlib
import os
import pandas as pd
import time
import csv
import requests
from datetime import datetime
ticker = "NVDA"
price = pd.DataFrame()
for i in range(1,2):
for j in range(1,2):
# replace the "demo" apikey below with your own key from https://www.alphavantage.co/support/#api-key
CSV_URL = "https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY_EXTENDED&symbol="+ticker+"&interval=5min&slice=year"+str(i)+"month"+str(j)+"&apikey=XQ8OJYOFJFBN3TA7"
with requests.Session() as s:
download = s.get(CSV_URL)
decoded_content = download.content.decode('utf-8')
cr = csv.reader(decoded_content.splitlines(), delimiter=',')
my_list = list(cr)
temp = pd.DataFrame(my_list)
new_header = temp.iloc[0] #grab the first row for the header
temp = temp[1:] #take the data less the header row
temp.columns = new_header #set the header row as the df header
price = price.append(temp, ignore_index=True)
time.sleep(12) #to satisfy alphavantage data requirements
n_input_data = 1
kept_for_exam = 10000
price = price.iloc[::-1]
price = price.reset_index()
price = price.drop("index", axis=1)
price
def init_network():
global rnn, timesteps, n_input_data
rnn = Sequential()
rnn.add(LSTM(30, batch_input_shape=(None, timesteps, n_input_data), return_sequences=True))
# rnn.add(LSTM(700, return_sequences=True))
rnn.add(LSTM(15, return_sequences=True))
# rnn.add(LSTM(200, return_sequences=True))
rnn.add(LSTM(5, return_sequences=False))
# rnn.add(LSTM(800, return_sequences=True))
# rnn.add(LSTM(800, return_sequences=True))
rnn.add(Dense(1, activation=LeakyReLU(0.3)))
rnn.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
def make_batch(batchsize, timesteps):
"""
Take as argument: batchsize, timesteps.
This function will generate randomly the batches from the available data
"""
global n_input_data, all_y_in, all_y_ans, kept_for_exam, length
#Change the inputs here
all_y_in = array(price["close"])
all_y_in = all_y_in.reshape([shape(all_y_in)[0], 1])
closingprice = array(price["close"])
length = shape(closingprice)[0]
all_y_ans = zeros(length)
all_y_ans[:-1] = closingprice[1:]
length = shape(all_y_ans)[0]
#Generate random samples with timesteps length.
start_time = random.randint(0, length-kept_for_exam-timesteps+1, size =batchsize)
yin = zeros([batchsize, timesteps, n_input_data])
yans = zeros([batchsize, timesteps])
for i in range(batchsize):
yin[i,:,:] = all_y_in[start_time[i]:(start_time[i]+timesteps), :]
yans[i, :] = all_y_ans[start_time[i]:(start_time[i]+timesteps)]
#Normalizing the price and the volume wrt the zeroth price and volume in the time series
for j in range(batchsize):
basis = yin[j,0,0]
maximum = yin[j,:,0].max()
minimum = yin[j,:,0].min()
yin[j, :, 0] = (yin[j, :, 0]-minimum)/(maximum-minimum)
yans[j, :] = (yans[j, :]-minimum)/(maximum-minimum)
# yin[j, :, 1] = yin[j, :, 1]/yin[j,0,1]
#Reshaping yans for categorical cross entropy
yans_new = zeros([batchsize, timesteps, 2])
yans_new[:, :, 0] = (yans[:, :]==0)*1
yans_new[:, :, 1] = (yans[:, :]==1)*1
#New Addition:
y_ans = zeros([batchsize, 2])
y_ans[:,:] = yans_new[:,timesteps-1,:]
#For price prediction
yans_price = zeros([batchsize, 1])
yans_price[:,0] = yans[:,-1]
return [yin, yans_price]
converge =False
while(converge ==False):
batchsize = 30
timesteps = 10
init_network()
accuracy = 0
errors = []
acc = []
array_for_predacc = []
array_for_money = []
k=0
while(accuracy<0.95):
# if(i%10==0):
# print(100*i/epochs)
yin, yout = make_batch(batchsize, timesteps)
temp = rnn.train_on_batch(yin, yout)
errors.append(temp[0])
predicted = rnn.predict(yin)
directional_pred = predicted[:,0]>yin[:, timesteps-1, 0]
directional_answer = yout[:, 0]>yin[:, timesteps-1,0]
accuracy = sum(directional_answer==directional_pred)/batchsize
acc.append(accuracy)
k+=1
####################
#input the testing input
y_input = zeros([kept_for_exam+timesteps-1, n_input_data])
y_input[:,:] = all_y_in[-(kept_for_exam+timesteps-1):, :]
#input the date input
a = pd.DataFrame(price)
datea = a.reset_index()
datea =array(datea)
for i in range(shape(datea)[0]):
datea[i][1] = datetime.strptime(datea[i][1], '%Y-%m-%d %H:%M:%S').date()
datea = datea[:,0]
date_exam = datea[-kept_for_exam:]
#input the testing answer
y_ans = zeros(kept_for_exam)
y_ans[:] = all_y_ans[-kept_for_exam:]
length = shape(y_input)[0] #NOTE THAT THIS IS NOT 500
prediction = []
for i in range(length-timesteps+1):
current_y_input = zeros([1, timesteps, n_input_data])
current_y_input[0,:,:] = y_input[i:i+timesteps, :]
#Normalizing according to the simulation
maximum = current_y_input[0,:,0].max()
minimum = current_y_input[0,:,0].min()
current_y_input[0,:,0] = (current_y_input[0,:,0]-minimum)/(maximum-minimum)
#current_y_input[0,:,1] = current_y_input[0,:,1]/current_y_input[0,0,1]
#current_y_input[0,:,2] = current_y_input[0,:,2]/current_y_input[0,0,2]
if(i<(length-timesteps) and date_exam[i]==date_exam[i+1]): #We must buy at the end of the day
prediction.append(1)
else:
temp = (rnn.predict(current_y_input)[0][0]>current_y_input[0][timesteps-1][0])*1 #IF TRUE IT IS PREDICTING THAT THE PRICE IS GOING UP
prediction.append(temp)
prediction = array(prediction)
#savetxt(exam_folder+"/prediction.txt", prediction)
exam_number = kept_for_exam
y_ans[1:] = y_ans[1:]>y_ans[:-1]
accuracy_of_prediction=zeros(exam_number)
accuracy_of_prediction[:] = (y_ans[:]==prediction[:])*1
pred_acc = sum(accuracy_of_prediction)/exam_number
#Cutting the input to only the last 500 and store into price array
pricenew = zeros(exam_number)
pricenew[:] = y_input[-exam_number:, 0] #Note this is not the actual price, but its ok.and
#output_exam = open("result"+ticker+".txt", "a+")
#output_exam.write("Accuracy ="+ str(pred_acc) + "\n" +"\n")
array_for_predacc.append(pred_acc)
for j in range(1):
have_share = False
money = 10000
shares = 0
i=j
lastbuy=0
Gain = []
Loss = []
while(i < exam_number):
if(prediction[i]==1):
if(have_share==False):
have_share=True
shares += money/pricenew[i]
lastbuy = money
money = 0
if(prediction[i]==0):
if(have_share==True):
have_share = False
money += shares*pricenew[i]
shares = 0
if(money>lastbuy): Gain.append(money-lastbuy)
elif(money<lastbuy): Loss.append(lastbuy-money)
i+=1
# output_exam.write("\n######### Day "+ str(j) + " #########\n")
# output_exam.write("Ending Money: " + str(money+shares*pricenew[kept_for_exam-1]) +"\n")
# output_exam.write("Gain: "+ str(Gain) +"\n")
# output_exam.write("Loss: "+ str(Loss) +"\n")
array_for_money.append(money+shares*pricenew[kept_for_exam-1])
benchmark = (y_input[-1,0]-y_input[timesteps-1,0])/y_input[timesteps-1,0]
# output_exam.write("buy hold=" + str(benchmark))
# output_exam.close()
####################
if(k>100):
converge=True
break
# if(i%10==0):
# im, (ax0, ax1) = plt.subplots(ncols=2)
# ax0.plot(errors)
# ax1.plot(acc)
# plt.show()
# clear_output(wait=True)
if(accuracy>0.95):
converge=True
errors = array(errors)
acc = array(acc)
array_for_money = array(array_for_money)
array_for_predacc = array(array_for_predacc)
im, (ax0, ax1) = plt.subplots(ncols=2)
ax0.plot(errors)
ax1.plot(acc)
plt.savefig("graph"+ticker+".png")
im2, (ax2, ax3) = plt.subplots(nrows=2)
ax2.plot(array_for_predacc)
ax3.plot(array_for_money)
ax3.axhline(y=(benchmark+1)*10000)
plt.savefig("test"+ticker+".png")
Execution error
KeyboardInterrupt:
k
errors = array(errors)
acc = array(acc)
array_for_money = array(array_for_money)
array_for_predacc = array(array_for_predacc)
im, (ax0, ax1) = plt.subplots(ncols=2)
ax0.plot(errors)
ax1.plot(acc)
plt.savefig("graph"+ticker+".png")
im2, (ax2, ax3) = plt.subplots(nrows=2)
ax2.plot(array_for_predacc)
ax3.plot(array_for_money)
ax3.axhline(y=(benchmark+1)*10000)
plt.savefig("test"+ticker+".png")