def __init__(self, numInput=6, numHidden=[5,6], numOutput=1, numHiddenLayers=1):
"""initialise some variables and arrays"""
self.numberHiddenLayers=numHiddenLayers
self.numInput=numInput
self.numHidden=numHidden
self.numOutput=numOutput
self.allInputs=[]
#input to hidden layer arrays and weights and biases
self.inputs=[None]*numInput
self.ihWeights=[[0 for x in xrange(numInput)] for x in xrange(numHidden[0])]
self.cummulativeDeltaihWeights=[[0 for x in xrange(numInput)] for x in xrange(numHidden[0])]
self.ihSums=[None]*numHidden[0]
self.ihBiases=[None]*numHidden[0]
self.cummulativeDeltaihBiases=[0.0]*numHidden[0]
self.ihOutputs=[None]*numHidden[0]
#hidden layer to hidden layer
self.hiddenInputs=[None]*(numHidden[0]+1)
self.hhWeights=[[0 for x in xrange(numHidden[0]+1)] for x in xrange(numHidden[1])]
self.cummulativeDeltahhWeights=[[0 for x in xrange(numHidden[0]+1)] for x in xrange(numHidden[1])]
self.hhSums=[None]*numHidden[1]
self.hhBiases=[None]*numHidden[1]
self.cummulativeDeltahhBiases=[0.0]*numHidden[1]
self.hhOutputs=[None]*numHidden[1]
#hidden layer to output layer
self.hoWeights=[[0 for x in xrange(numHidden[1])] for x in xrange(numOutput)]
self.cummulativeDeltahoWeights=[[0 for x in xrange(numHidden[1])] for x in xrange(numOutput)]
self.hoSums=[None]*numOutput
self.hoBiases=[None]*numOutput
self.cummulativeDeltahoBiases=[0.0]*numOutput
self.outputs=[None]*numOutput
#back propogation
self.oGrads=[None]*numOutput
self.hoGrads=[None]*numHidden[1]
self.hiGrads=[None]*numHidden[0]
self.ihPrevWeightsDelta=[[0 for x in xrange(numInput)] for x in xrange(numHidden[0])]
self.ihPrevBiasesDelta=[0.0]*numHidden[0]
self.hhPrevWeightsDelta=[[0 for x in xrange(numHidden[0]+1)] for x in xrange(numHidden[1])]
self.hhPrevBiasesDelta=[0.0]*numHidden[1]
self.hoPrevWeightsDelta=[[0 for x in xrange(numHidden[1])] for x in xrange(numOutput)]
self.hoPrevBiasesDelta=[0.0]*numOutput
self.NeuralNetworkStuffInst=NeuralNetworkStuff()
class NeuralNetwork:
def __init__(self, numInput=6, numHidden=[5,6], numOutput=1, numHiddenLayers=1):
"""initialise some variables and arrays"""
self.numberHiddenLayers=numHiddenLayers
self.numInput=numInput
self.numHidden=numHidden
self.numOutput=numOutput
self.allInputs=[]
#input to hidden layer arrays and weights and biases
self.inputs=[None]*numInput
self.ihWeights=[[0 for x in xrange(numInput)] for x in xrange(numHidden[0])]
self.cummulativeDeltaihWeights=[[0 for x in xrange(numInput)] for x in xrange(numHidden[0])]
self.ihSums=[None]*numHidden[0]
self.ihBiases=[None]*numHidden[0]
self.cummulativeDeltaihBiases=[0.0]*numHidden[0]
self.ihOutputs=[None]*numHidden[0]
#hidden layer to hidden layer
self.hiddenInputs=[None]*(numHidden[0]+1)
self.hhWeights=[[0 for x in xrange(numHidden[0]+1)] for x in xrange(numHidden[1])]
self.cummulativeDeltahhWeights=[[0 for x in xrange(numHidden[0]+1)] for x in xrange(numHidden[1])]
self.hhSums=[None]*numHidden[1]
self.hhBiases=[None]*numHidden[1]
self.cummulativeDeltahhBiases=[0.0]*numHidden[1]
self.hhOutputs=[None]*numHidden[1]
#hidden layer to output layer
self.hoWeights=[[0 for x in xrange(numHidden[1])] for x in xrange(numOutput)]
self.cummulativeDeltahoWeights=[[0 for x in xrange(numHidden[1])] for x in xrange(numOutput)]
self.hoSums=[None]*numOutput
self.hoBiases=[None]*numOutput
self.cummulativeDeltahoBiases=[0.0]*numOutput
self.outputs=[None]*numOutput
#back propogation
self.oGrads=[None]*numOutput
self.hoGrads=[None]*numHidden[1]
self.hiGrads=[None]*numHidden[0]
self.ihPrevWeightsDelta=[[0 for x in xrange(numInput)] for x in xrange(numHidden[0])]
self.ihPrevBiasesDelta=[0.0]*numHidden[0]
self.hhPrevWeightsDelta=[[0 for x in xrange(numHidden[0]+1)] for x in xrange(numHidden[1])]
self.hhPrevBiasesDelta=[0.0]*numHidden[1]
self.hoPrevWeightsDelta=[[0 for x in xrange(numHidden[1])] for x in xrange(numOutput)]
self.hoPrevBiasesDelta=[0.0]*numOutput
self.NeuralNetworkStuffInst=NeuralNetworkStuff()
def NeuralNetwork(self, horseName, horseLimit, date, distance):
"""blah"""
SqlStuffInst=SqlStuff2()
""" get all the results for this horseName from the database"""
horses=SqlStuffInst.getHorse(horseName)
if len(horses)==0:
print "No horse called " + str(horseName)
return (0, 0.0)
self.SetWeights()
self.SetBiases()
#print self.ihWeights
#print self.hoWeights
#print self.ihBiases
#print self.hoBiases
"""test reducing and sorting the horses by date here before the normalising
and try also doing the sort and reduction after the normalise"""
sortedHorses=self.NeuralNetworkStuffInst.subSortReduce(horses, horseLimit, date, distance)
del(horses)
horses=sortedHorses
eta = 0.5
alpha=0.04
ctr=0
Error=0.5
self.allInputs=self.NeuralNetworkStuffInst.subNormaliseInputs(horses)
#having normalised the input values we should now remove abnormal data from the
# training process. Abnormal data is a normalised value that lies more that
# 2std's away from the mean.
usefulInputs, usefulHorses=self.NeuralNetworkStuffInst.subUsefuliseInputs(self.allInputs, horses)
horses=usefulHorses
self.allInputs=usefulInputs
self.longestTime=0
for resultNo, horse in enumerate(horses):
if horses[resultNo][15]>self.longestTime:
self.longestTime=horses[resultNo][15]
while (ctr<10000 and Error > 0.02):
# if ctr == 1000:
# print "Error = " + str(Error)
# ctr=0
Error=0.0
#loop through all the results for this horse
for resultNo, horse in enumerate(horses):
# get the normalised inputs for all of this horses results
self.inputs=self.allInputs[resultNo]
tValue=float(horses[resultNo][4])/float(horses[resultNo][6]) #float((horses[resultNo][15]+((horses[resultNo][4]-1)*2))/self.longestTime) #
#print "Before weight update"
#print "desired outputs = " + str(tValue)
yValues=self.ComputeOutputs(self.inputs)
#print "actual value = " + str(yValues[0])
#Error=self.Error(tValue,yValues[0])
Error=max(Error,self.Error(tValue,yValues[0]))
self.AccumulateDeltas(tValue, eta)
#print 'about to update weights'
self.UpdateWeights(alpha,len(horses))
#print "After weight update"
#for resultNo, horse in enumerate(horses):
# self.inputs=self.allInputs[resultNo]
# tValue=float(horses[resultNo][4])/float(horses[resultNo][6])
# yValues=self.ComputeOutputs(self.inputs)
# Error=max(Error,self.Error(tValue,yValues[0]))
#print "desired output = " + str(tValue)
#print "outputs = " + str(yValues)
#print "Error = " + str(Error)
ctr+=1
return (len(horses), Error)
def Error(self, tValue, output):
"""blah"""
return abs(tValue-output)
def AccumulateDeltas(self, tValues, eta):
"""blah"""
#compute the output gradient
derivative=(1-self.outputs[0])*self.outputs[0]
#print derivative
self.oGrads[0]=derivative*(tValues-self.outputs[0])
#print self.oGrads[0]
for ii in range(0, len(self.hoGrads)):
derivative=(1-self.hhOutputs[ii])*self.hhOutputs[ii]
summ=0.0
for oo in range(0, len(self.oGrads)):
summ+=self.oGrads[oo]*self.hoWeights[oo][ii]
self.hoGrads[ii]=derivative*summ
for ii in range(0, len(self.hiGrads)):
derivative=(1-self.ihOutputs[ii])*self.ihOutputs[ii]
summ=0.0
for oo in range(0, len(self.hoGrads)):
summ+=self.hoGrads[oo]*self.hhWeights[oo][ii]
self.hiGrads[ii]=derivative*summ
for ii in range(0, len(self.ihWeights[0])):
for jj in range(0, len(self.ihWeights)):
self.cummulativeDeltaihWeights[jj][ii]+=eta*self.hiGrads[jj]*self.inputs[ii]
for ii in range(0, len(self.ihBiases)):
self.cummulativeDeltaihBiases[ii]+=eta*self.hiGrads[ii]*1.0
for ii in range(0, len(self.hhWeights[0])):
for jj in range(0, len(self.hhWeights)):
self.cummulativeDeltahhWeights[jj][ii]+=eta*self.hoGrads[jj]*self.hiddenInputs[ii]
for ii in range(0, len(self.hhBiases)):
self.cummulativeDeltahhBiases[ii]+=eta*self.hoGrads[ii]*1.0
for ii in range(0, len(self.hoWeights[0])):
for jj in range(0, len(self.hoWeights)):
self.cummulativeDeltahoWeights[jj][ii]+=eta*self.oGrads[jj]*self.hhOutputs[ii]
for ii in range(0, len(self.hoBiases)):
self.cummulativeDeltahoBiases[ii]+=eta*self.oGrads[ii]*1.0
def UpdateWeights(self, alpha, numRaces):
"""blah"""
#update the input to the hidden weights
for ii in range(0, len(self.ihWeights[0])):
for jj in range(0, len(self.ihWeights)):
delta=self.cummulativeDeltaihWeights[jj][ii]/numRaces
#zero this cumulatiom
self.cummulativeDeltaihWeights[jj][ii]=0.0
self.ihWeights[jj][ii]+=delta
self.ihWeights[jj][ii]+=alpha*self.ihPrevWeightsDelta[jj][ii]
self.ihPrevWeightsDelta[jj][ii]=delta
for ii in range(0, len(self.ihBiases)):
delta=self.cummulativeDeltaihBiases[ii]/numRaces
self.cummulativeDeltaihBiases[ii]=0.0
self.ihBiases[ii]+=delta
self.ihBiases[ii]+=alpha*self.ihPrevBiasesDelta[ii]
self.ihPrevBiasesDelta[ii]=delta
for ii in range(0, len(self.hhWeights[0])):
for jj in range(0, len(self.hhWeights)):
delta=self.cummulativeDeltahhWeights[jj][ii]/numRaces
#zero this cumulation
self.cummulativeDeltahhWeights[jj][ii]=0.0
self.hhWeights[jj][ii]+=delta
self.hhWeights[jj][ii]+=alpha*self.hhPrevWeightsDelta[jj][ii]
self.hhPrevWeightsDelta[jj][ii]=delta
for ii in range(0, len(self.hhBiases)):
delta=self.cummulativeDeltahhBiases[ii]/numRaces
self.cummulativeDeltahhBiases[ii]=0.0
self.hhBiases[ii]+=delta
self.hhBiases[ii]+=alpha*self.hhPrevBiasesDelta[ii]
self.hhPrevBiasesDelta[ii]=delta
for ii in range(0, len(self.hoWeights[0])):
for jj in range(0, len(self.hoWeights)):
delta=self.cummulativeDeltahoWeights[jj][ii]/numRaces
self.cummulativeDeltahoWeights[jj][ii]=0.0
self.hoWeights[jj][ii]+=delta
self.hoWeights[jj][ii]+=alpha*self.hoPrevWeightsDelta[jj][ii]
self.hoPrevWeightsDelta[jj][ii]=delta
for ii in range(0, len(self.hoBiases)):
delta=self.cummulativeDeltahoBiases[ii]/numRaces
self.cummulativeDeltahoBiases[ii]=0.0
self.hoBiases[ii]+=delta
self.hoBiases[ii]+=alpha*self.hoPrevBiasesDelta[ii]
self.hoPrevBiasesDelta[ii]=delta
def SetWeights(self):
"""blah"""
for hh in range(0, len(self.ihSums)):
for ii in range(0, len(self.inputs)):
self.ihWeights[hh][ii]=(float(random.randrange(0, 1000, 3))-500.0)/1000.0
for hh in range(0, len(self.ihSums)+1):
for h2 in range(0, len(self.hhSums)):
self.hhWeights[h2][hh]=(float(random.randrange(0, 1000, 3))-500.0)/1000.0
for h2 in range(0, len(self.hhSums)):
for oo in range(0, len(self.outputs)):
self.hoWeights[oo][h2]=(float(random.randrange(0, 1000, 3))-500.0)/1000.0
def SetBiases(self):
"""Blah"""
for hh in range(0, len(self.ihBiases)):
self.ihBiases[hh]=(float(random.randrange(0, 1000, 3))-500.0)/1000.0
for hh in range(0, len(self.hhBiases)):
self.hhBiases[hh]=(float(random.randrange(0, 1000, 3))-500.0)/1000.0
for oo in range(0, len(self.hoBiases)):
self.hoBiases[oo]=(float(random.randrange(0, 1000, 3))-500.0)/1000.0
def GetWeights(self):
"""blah"""
def ComputeOutputs(self, xValues):
"""blah"""
for ii in range(0,len(self.ihSums)):
self.ihSums[ii]=0.0
for ii in range(0,len(self.hhSums)):
self.hhSums[ii]=0.0
for ii in range(0, len(self.hoSums)):
self.hoSums[ii]=0.0
for jj in range(0,len(self.ihSums)):
for ii in range(0, len(xValues)):
#print self.ihSums
self.ihSums[jj]+=xValues[ii]*self.ihWeights[jj][ii]
#sys.exit(0)
self.ihSums[jj]+=self.ihBiases[jj]
self.ihOutputs[jj]=self.SigmoidFunction(self.ihSums[jj])
self.hiddenInputs[0:len(self.ihOutputs)]=self.ihOutputs
self.hiddenInputs[len(self.hiddenInputs)-1]=1.0
for jj in range(0,len(self.hhSums)):
for ii in range(0, len(self.hiddenInputs)):
self.hhSums[jj]+=self.hiddenInputs[ii]*self.hhWeights[jj][ii]
self.hhSums[jj]+=self.hhBiases[jj]
self.hhOutputs[jj]=self.SigmoidFunction(self.hhSums[jj])
for oo in range(0, len(self.hoSums)):
for hh in range(0, len(self.hhSums)):
self.hoSums[oo]+=self.hhOutputs[hh]*self.hoWeights[oo][hh]
self.hoSums[oo]+=self.hoBiases[oo]
#print "ihOutputs = " + str(self.ihOutputs)
#print "hoWeights = " + str(self.hoWeights)
#print "hoSums = " + str(self.hoSums)
self.outputs[oo]=self.SigmoidFunction(self.hoSums[oo])
return self.outputs
def SigmoidFunction(self, x):
"""calculate the sigmoid activation"""
if x < -45.0:
return 0.0
elif x > 45.0:
return 1.0
return 1.0 / (1.0 + exp(-x))
def LinearFunction(self, x):
""" use a linear function to calc output"""
gradient = (600.0-20.0)/18
return gradient*x + 20.0
def testFunction(self, jockeyName, numberHorses, raceLength, weight, going, draw, verbose=0):#, trainerName):
"""blah"""
jockeyNames=[]
jockeyNames.append(jockeyName)
testn=[None]*6
testn[0]=self.NeuralNetworkStuffInst.normaliseTestRaceLength(raceLength)
testn[1]=self.NeuralNetworkStuffInst.normaliseTestNumberOfHorses(numberHorses)
#testn[2]=self.normaliseTestPastPosition(horses[len(horses)-1][4])
testn[2]=self.NeuralNetworkStuffInst.normaliseTestJockey(jockeyName)
testn[3]=self.NeuralNetworkStuffInst.normaliseTestWeight(weight)
# testn[4]=self.NeuralNetworkStuffInst.subJockeyPercentWins(jockeyNames)[0]
# testn[5]=self.NeuralNetworkStuffInst.normaliseTestTrainer(trainerName)
testn[4]=self.NeuralNetworkStuffInst.normaliseTestGoing(going)
#testn[4]=self.NeuralNetworkStuffInst.normaliseTestDraw(draw, numberHorses)
testn[5]=1.0
yValues=self.ComputeOutputs(testn)[0]
#print "yValue = " + str(yValues)
#print "predicted finish = " + str(yValues[0]*float(numberHorses))
if verbose != 0:
print "Normalized racelength, no. horses, jockey, weight, going, 1.0"
print testn
for jj in range(0,len(self.ihSums)):
for ii in range(0, len(testn)):
print "input " + str(ii) + "weight in h" + str(jj) + " is " + str(self.ihWeights[jj][ii])
print "input " + str(jj) + " has bias " + str(self.ihBiases[jj])
return yValues*float(numberHorses)#*self.longestTime#
