Neural Network Finding Peaks and Troughs

# -*- coding: utf-8 -*-
"""
Created on Sat Jan 20 12:55:43 2018
@author: Rudy Xu
"""
import json
import numpy as np
import matplotlib.pyplot as plt
def sigma(x,deriv=False):
if deriv==True:
return x*(1-x)
return 1/(1+np.exp(-x))
def TrainNN2(X,Y,Matrixdimension = 3,iterations=6000):

#inut dataset
X = X
#print(len(X[0]))
#output dataset
Y = np.array([Y]).T
#print(Y)
#Seed random numbers to make calculation

#deterministic (just good practice)
np.random.seed(1)
#Dimension of Weights matrix
#randomly initialise our weights with mean 0
syn0 = 2*np.random.random((len(X[0]),Matrixdimension))-1
syn1 = 2*np.random.random((Matrixdimension,1))-1
for j in range(iterations):
#Feed forward through layers 0,1,2
l0 = X
l1 = sigma(np.dot(X,syn0))
l2 = sigma(np.dot(l1,syn1))
#how much did we miss the target value?

l2_error = Y - l2
if (j% message_interval) == 0:
#print("Error:" + str(np.mean(np.abs(l2_error))))
print("TrainingResult sum:" + str(sum(l2)))
#in what direction is the target value?

#were we really sure? if so, don't change too much.
l2_delta = l2_error*sigma(l2,deriv=True)
#How much did each l1 value contribute to the l2 error

#according to the weights?
l1_error = l2_delta.dot(syn1.T)
#In what direction is the target l1?

#Were we really sure? if so, don't change much
l1_delta = l1_error*sigma(l1,deriv=True)
syn1 += l1.T.dot(l2_delta)
syn0 += l0.T.dot(l1_delta)
return(l2,syn0,syn1)
def TrainNN1(X,Y,iterations=6000):
x = X
y = np.array([Y]).T
np.random.seed(1)
syn0 = 2*np.random.random((len(x[0]),1))-1
for i in range(iterations):
l0 = x
l1 = sigma(np.dot(x,syn0))
l1_err=y-l1
if (i% 1000) == 0:
print("Error:" + str(np.mean(np.abs(l1_err))))
print("TrainingResult sum:" + str(sum(l1)))
l1_delta=l1_err*sigma(l1,True)
syn0+=np.dot(l0.T,l1_delta)
return(l1,syn0)
def ReadFile(coin = "ETH"):

with open(coin + '.json', 'r') as inputfile:
json_data = json.load(inputfile)
return(json_data)
def GetData(json_data,datarange):
pricedata = []
for i in datarange:
pricedata.append(json_data[i][1])
return(pricedata)
def ConvertPercentageChange(pricedata):
#Units are actually in decimal, not percentage
PercentageChangeData = [0]
for i in range(len(pricedata)-1):
PercentageChangei = (pricedata[i+1]-
pricedata[i])/pricedata[i]*PercentageChangeDataModifier
PercentageChangeData.append(PercentageChangei+PercentageNormaliser*PercentageChange
DataModifier) #PercentageCHangeDataDivide
return(PercentageChangeData)
def BuySellHold(pricedata, brokerage_percent=0.1):
#Units should be in decimal, not percent
ResultList = []
BiggestIncreaseFound = 0
BiggestDecreaseFound = 0
InitialValue = 0
PercentageChangeFromInitial = 0 #This is a decimal, not percentage
for i in range(len(pricedata)):
j=i
InitialValue = pricedata[j]
while j<len(pricedata):
PercentageChangeFromInitial = (pricedata[j]-InitialValue)/InitialValue
if BiggestIncreaseFound < PercentageChangeFromInitial:
BiggestIncreaseFound = PercentageChangeFromInitial
if BiggestDecreaseFound > PercentageChangeFromInitial:

BiggestDecreaseFound = PercentageChangeFromInitial
if BiggestIncreaseFound > brokerage_percent and BiggestDecreaseFound ==

0:
ResultList.append(1)
break
elif BiggestIncreaseFound > brokerage_percent and
BiggestDecreaseFound != 0:
ResultList.append(0.5)
break
elif BiggestDecreaseFound < -brokerage_percent and BiggestIncreaseFound
== 0:
break
!= 0:
break
elif j == len(pricedata)-1:
break
j=j+1
return(ResultList)
def BuySellHold2(pricedata,brokerage_percent=0.1):
#Tries to only output buy or sell, and less holds
ResultList = []
InitialValue = 0
j=i

if BiggestIncreaseFound > brokerage_percent:

break
elif BiggestDecreaseFound < -brokerage_percent:
break
break
j=j+1
return(ResultList)
def BuyOnly(pricedata, brokerage_percent=0.1):

ResultList = []
InitialValue = 0
LastPeakTrough = 0
j=i


0 and LastPeakTrough == 0:
LastPeakTrough = 1
break
break
== 0:
LastPeakTrough = 0
break
!= 0:
break
break
j=j+1
return(ResultList)
def SellOnly(pricedata, brokerage_percent=0.1):

ResultList = []
InitialValue = 0
LastPeakTrough = 0
j=i


0:
LastPeakTrough = 0
break
break
== 0 and LastPeakTrough == 0:
LastPeakTrough = 1
break
!= 0:
break
break
j=j+1
return(ResultList)
def Buy1StepProfit(pricedata, brokerage_percent=0.1):

ResultList = []
for i in range(len(pricedata)-1):
if pricedata[i]<pricedata[i+1]:
else:
return(ResultList)
def Savedata(data,filename):
dataArray = np.array(data)
np.savetxt(filename,dataArray)
def Loaddata(filename, datatype=float):

data = np.loadtxt(filename,dtype=datatype)
return(data)
def GenerateDataset(data,answerkey,setsize, start_position=0):

i=start_position
dataset = np.array([np.append(data[i:i+setsize], answerkey[i+setsize-1])])
i=i+1
while i+setsize <len(data):
dataset =
np.append(dataset,np.array([np.append(data[i:i+setsize],answerkey[i+setsize-
1])]),axis=0)
i=i+1
return(dataset)
def CreateRandomPriceData(length,average=1,std=0.05):
#randomData = np.random.random(length)
randomData = np.random.normal(average,std,length)
return(randomData)
'''
for i in range(1,100,5):
PercentageChangeDataModifier = i
for i range()
'''
PercentageChangeDataModifier = 2000
TrainingRange = range(-2501,-1)
TestingRange1 = range(-5000,-2502)
SetSize = 150
Brokerage_Percent = 0.03
BuyThreshhold = 0.45
SellThreshhold = 0.45
Matrixdimension = 14
NN2_iter = 6000
message_interval = 1000
PercentageNormaliser = 0.0
json_data = ReadFile('POWR2')
#pricedata = Loaddata('testingbasic.txt')
#pricedata = CreateRandomPriceData(100,1,0.02)
#pricedata = data
pricedata = GetData(json_data,TrainingRange)
#TrainingRange
PercentageChangeData = ConvertPercentageChange(pricedata)
answerkey = BuyOnly(pricedata,Brokerage_Percent)
#anskwerkey generator function, Brokerage_percentage
answerkeyS = SellOnly(pricedata,Brokerage_Percent)
#dataset = GenerateDataset(pricedata,answerkey,SetSize)
dataset = GenerateDataset(PercentageChangeData,answerkey, SetSize)
#Setsize
datasetS = GenerateDataset(PercentageChangeData,answerkeyS, SetSize)
(TrainingResults, Weights0, Weights1) = TrainNN2(dataset[:,0:-1],dataset[:,-

1],Matrixdimension,NN2_iter)
(TrainingResultsS, Weights0S, Weights1S) = TrainNN2(datasetS[:,0:-1],datasetS[:,-
1],Matrixdimension,NN2_iter)
#(TrainingResults, Weights0) = TrainNN1(dataset[:,0:-1],dataset[:,-1])
def TestWeightsNN2(pricedata, setsize):

answerkey = BuyOnly(pricedata,Brokerage_Percent)
#anskwerkey generator function
dataset = GenerateDataset(PercentageChangeData,answerkey, setsize)
l1 = sigma(np.dot(dataset[:,0:-1],Weights0))
l2 = sigma(np.dot(l1,Weights1))
return(l2,answerkey,PercentageChangeData,dataset,l1)
def TestWeightsNN2S(pricedata, setsize):

answerkey = SellOnly(pricedata,Brokerage_Percent)
#anskwerkey generator function
l1 = sigma(np.dot(dataset[:,0:-1],Weights0S))
l2 = sigma(np.dot(l1,Weights1S))
return(l2,answerkey,PercentageChangeData,dataset,l1)
'''
def TestWeightsNN1(pricedata,setsize):
answerkey = Buy1StepProfit(pricedata,Brokerage_Percent)
#anskwerkey generator function, Brokerage_Percentage
l1 = sigma(np.dot(dataset[:,0:-1],Weights0))
return(l1,answerkey,PercentageChangeData,dataset)
'''
def CheckEffectiveness(TrainingResults,PercentageChangeData,threshhold =
BuyThreshhold):
dollars = 1
IncCount = 0
DecCount = 0
sizeDifference = len(PercentageChangeData)-len(TrainingResults)
for i in range(len(TrainingResults)):
if TrainingResults[i]>threshhold:
dollars =
dollars*(1+PercentageChangeData[i+sizeDifference]/PercentageChangeDataModifier)
#PercentageChangeDataDivide
if PercentageChangeData[i+sizeDifference]>0:
IncCount+=1
elif PercentageChangeData[i+sizeDifference]<0:
DecCount+=1
#print(i+sizeDifference,dollars)
print("Increase Count: " + str(IncCount))
print("Decrease Count: " + str(DecCount))
try:
print("Inc/Dec ratio: " + str(IncCount/DecCount))
except ZeroDivisionError:
print("You can't divide by zero, you're silly.")
return(dollars)
def
CheckEffectivenessBuySell(TrainingResults,TrainingResultsS,PercentageChangeData,thr
eshhold = BuyThreshhold,threshholdS = SellThreshhold):
dollars = 1
Buy1Sell0 = 0
sizeDifference = len(PercentageChangeData)-len(TrainingResults)
HitCount = 0
MissCount = 0
for i in range(len(TrainingResults)):
if TrainingResults[i]>threshhold and TrainingResultsS[i]<threshholdS:
Buy1Sell0 = 1
if
PercentageChangeData[i+sizeDifference]>PercentageNormaliser*PercentageChangeDataMod
ifier:
HitCount+=1
elif
PercentageChangeData[i+sizeDifference]<PercentageNormaliser*PercentageChangeDataMod
ifier:
MissCount+=1
elif TrainingResultsS[i]>threshholdS and TrainingResults[i]<threshhold:
Buy1Sell0 = 0
if
ifier:
HitCount+=1
elif
ifier:
MissCount+=1
else:
Buy1Sell0 = Buy1Sell0
if Buy1Sell0 == 1:
dollars =
dollars*(1+PercentageChangeData[i+sizeDifference]/PercentageChangeDataModifier-
PercentageNormaliser) #PercentageChangeDataDivide
elif Buy1Sell0 == 0:
dollars = dollars
print("Hit Count: " + str(HitCount))
print("Miss Count: " + str(MissCount))
try:
print("Hit/Miss ratio: " + str(HitCount/MissCount))
except ZeroDivisionError:
print("You can't divide by zero, you're silly.")
return(dollars)
def IncDecCounter(PercentageChangeData):
IncreasesTrue =
np.array(PercentageChangeData)>PercentageNormaliser*PercentageChangeDataModifier
DecreasesTrue =
np.array(PercentageChangeData)<PercentageNormaliser*PercentageChangeDataModifier
IncreasesCount = sum(IncreasesTrue.astype(int))
DecreasesCount = sum(DecreasesTrue.astype(int))
print("Number of increases: " + str(IncreasesCount))

print("Number of Decreases: "+ str(DecreasesCount))
print("Market Inc/Dec ratio: " + str(IncreasesCount/DecreasesCount))
pricedataT1 = GetData(json_data,TestingRange1)
#TestingRange
(TrT1,AkT1,PcdT1,DsT1,L1T1) = TestWeightsNN2(pricedataT1,SetSize)
#Setsize
(TrT1S,AkT1S,PcdT1S,DsT1S,L1T1S) = TestWeightsNN2S(pricedataT1,SetSize)
#Setsize
#(Tr2,Ak2,Pcd2,Ds2) = TestWeightsNN1(pricedata2,SetSize)
#Setsize
print("\nTraining Set: ")

IncDecCounter(PercentageChangeData)
DollarsTrained =
CheckEffectivenessBuySell(TrainingResults,TrainingResultsS,PercentageChangeData,Buy
Threshhold,SellThreshhold)
print("NN performance: "+ str(DollarsTrained))
#print(np.power(np.mean(PercentageChangeData)/PercentageChangeDataModifier+1,len(Pe
rcentageChangeData)))
print("Avg. Market performance: "+
str(np.mean(pricedata)/np.mean(pricedata[0:SetSize])))
print("\nTest Set 1: ")

IncDecCounter(PcdT1)
DollarsT1 =
CheckEffectivenessBuySell(TrT1,TrT1S,PcdT1,BuyThreshhold,SellThreshhold)
print("NN performance: "+ str(DollarsT1))
#print(np.power(np.mean(PcdT1)/PercentageChangeDataModifier+1,len(PcdT1)))
str(np.mean(pricedataT1)/np.mean(pricedataT1[0:SetSize])))
'''
DollarsPerfect = CheckEffectiveness(DsT1[:,-1],PcdT1)
print(DollarsPerfect)
'''
#TestingRange
#Setsize
#Setsize
#Setsize
DollarsT2 =
#TestingRange
#Setsize
#Setsize
#Setsize
DollarsT3 =
json_data = ReadFile('POWR2')
#TestingRange
#Setsize
#Setsize
#Setsize
DollarsT4 =
'''
pp=0
ppp=0
while ppp < 3:
pp = ppp
while pp <10:
if pp > 5:
break
pp=pp+1
print(pp)
ppp=ppp+1
'''

Neural Network Finding Peaks and Troughs

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Neural Network Finding Peaks and Troughs

Hochgeladen von

Copyright:

Verfügbare Formate

# -*- coding: utf-8 -*-

def TrainNN2(X,Y,Matrixdimension = 3,iterations=6000):

#Seed random numbers to make calculation

#how much did we miss the target value?

#in what direction is the target value?

#How much did each l1 value contribute to the l2 error

#In what direction is the target l1?

def ReadFile(coin = "ETH"):

if BiggestDecreaseFound > PercentageChangeFromInitial:

if BiggestIncreaseFound > brokerage_percent and BiggestDecreaseFound ==

if BiggestDecreaseFound > PercentageChangeFromInitial:

if BiggestIncreaseFound > brokerage_percent:

def BuyOnly(pricedata, brokerage_percent=0.1):

if BiggestDecreaseFound > PercentageChangeFromInitial:

if BiggestIncreaseFound > brokerage_percent and BiggestDecreaseFound ==

def SellOnly(pricedata, brokerage_percent=0.1):

if BiggestDecreaseFound > PercentageChangeFromInitial:

if BiggestIncreaseFound > brokerage_percent and BiggestDecreaseFound ==

def Buy1StepProfit(pricedata, brokerage_percent=0.1):

def Loaddata(filename, datatype=float):

def GenerateDataset(data,answerkey,setsize, start_position=0):

(TrainingResults, Weights0, Weights1) = TrainNN2(dataset[:,0:-1],dataset[:,-

def TestWeightsNN2(pricedata, setsize):

def TestWeightsNN2S(pricedata, setsize):

print("Number of increases: " + str(IncreasesCount))

print("\nTraining Set: ")

print("\nTest Set 1: ")

Das könnte Ihnen auch gefallen

# -- coding: utf-8 --