def __ESNConnTrain__(self, x):
#Extract the parameters
inputConnectivity = x[0]
reservoirConnectivity = x[1]
reservoirTopology = topology.RandomTopology(
size=self.size, connectivity=reservoirConnectivity)
#Create the network
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=reservoirTopology,
inputConnectivity=inputConnectivity)
#Train the reservoir
esn.trainReservoir()
#Predict for the validation data
predictedOutputData = esn.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
#Free the memory
gc.collect()
#Return the error
#print("Optimizing connectivity..")
#print("\nRegression error:"+str(regressionError)+"\n")
return regressionError
def __tune__(self):
# First tune for the input connectivity and the reservoir connectivity
connBounds = [
self.inputConnectivityBound, self.meanDegreeBound, self.betaBound
]
connResult = optimize.differential_evolution(self.__ESNConnTrain__,
bounds=connBounds)
self.inputConnectivityOptimum = connResult.x[0]
self.meanDegreeOptimum = int(np.floor(connResult.x[1]))
self.betaOptimum = connResult.x[2]
# With tuned parameters, create the network with optimal connections and keep the connections as same
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=topology.SmallWorldGraphs(
size=self.size,
meanDegree=self.meanDegreeOptimum,
beta=self.betaOptimum),
inputConnectivity=self.inputConnectivityOptimum)
self.inputWeightConn = esn.inputWeightRandom, esn.randomInputIndices
self.reservoirWeightConn = esn.reservoirWeightRandom, esn.randomReservoirIndices
# Tune the other parameters
bounds = [
self.spectralRadiusBound, self.inputScalingBound,
self.reservoirScalingBound, self.leakingRateBound
]
result = optimize.differential_evolution(self.__ESNTrain__,
bounds=bounds)
return result.x[0], result.x[1], result.x[2], result.x[
3], self.inputWeightConn, self.reservoirWeightConn
def __tune__(self):
# First tune for the input connectivity and the reservoir connectivity
connBounds = [
self.inputConnectivityBound, self.reservoirConnectivityBound
]
connResult = optimize.differential_evolution(self.__ESNConnTrain__,
bounds=connBounds,
maxiter=1)
self.inputConnectivityOptimum = connResult.x[0]
self.reservoirConnectivityOptimum = connResult.x[1]
# With tuned parameters, create the network with optimal connections and keep the connections as same
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=topology.RandomTopology(
size=self.size,
connectivity=self.reservoirConnectivityOptimum),
inputConnectivity=self.inputConnectivityOptimum)
self.inputWeightConn = esn.inputWeightRandom, esn.randomInputIndices
self.reservoirWeightConn = esn.reservoirWeightRandom, esn.randomReservoirIndices
# Tune the other parameters
bounds = [self.spectralRadiusBound, self.leakingRateBound]
result = optimize.differential_evolution(self.__ESNTrain__,
bounds=bounds,
maxiter=1)
return result.x[0], result.x[
1], self.inputWeightConn, self.reservoirWeightConn
def runStandardESN():
standardError = 0
testPredictedOutputDataStandard = 0
for i in range(runTimes):
#Tune the standard reservoir
reservoirConnectivityBound = (0.1, 1.0)
resTuner = tuner.ESNConnTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=validationInputData,
validationOutputData=validationOutputData,
inputConnectivity=inputConnectivity,
reservoirConnectivityBound=reservoirConnectivityBound,
times=10)
reservoirConnectivityOptimum = resTuner.getOptimalParameters()
#Train the reservoir with optimal parameters
esn = ESN.EchoStateNetwork(
size=size,
inputData=trainingInputData,
outputData=trainingOutputData,
reservoirTopology=topology.RandomTopology(
size=size, connectivity=reservoirConnectivityOptimum),
inputConnectivity=inputConnectivity)
esn.trainReservoir()
#Warm up for the trained data
predictedTrainingOutputData = esn.predict(inputTrainingData)
#Predict for future
lastAvailablePoint = predictedTrainingOutputData[nTraining - 1, 0]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
#Predict the next point
nextPoint = esn.predict(np.array(query).reshape(1, 2))[0, 0]
testingPredictedOutputData.append(nextPoint)
lastAvailablePoint = nextPoint
testingPredictedOutputData = np.array(
testingPredictedOutputData).reshape(nTesting, 1)
#Predict
testPredictedOutputDataStandard = minMax.inverse_transform(
testingPredictedOutputData)
actual = minMax.inverse_transform(testActualOutputData)
standardError += errorFunction.compute(
actual.reshape((actual.shape[0], 1)),
testPredictedOutputDataStandard.reshape(
(testPredictedOutputDataStandard.shape[0], 1)))
return testPredictedOutputDataStandard, (standardError / runTimes)
def __init__(self,
size,
initialTransient,
trainingInputData,
trainingOutputData,
validationInputData,
validationOutputData,
spectralRadiusBound,
inputScalingBound,
reservoirScalingBound,
leakingRateBound,
reservoirTopology,
inputConnectivity=0.6):
self.size = size
self.initialTransient = initialTransient
self.trainingInputData = trainingInputData
self.trainingOutputData = trainingOutputData
self.validationInputData = validationInputData
self.validationOutputData = validationOutputData
self.spectralRadiusBound = spectralRadiusBound
self.inputScalingBound = inputScalingBound
self.reservoirScalingBound = reservoirScalingBound
self.leakingRateBound = leakingRateBound
self.reservoirTopology = reservoirTopology
self.inputConnectivity = inputConnectivity
#Create a echo state network
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=self.reservoirTopology,
inputConnectivity=self.inputConnectivity)
self.inputWeightConn = esn.inputWeightRandom, esn.randomInputIndices
self.reservoirWeightConn = esn.reservoirWeightRandom, esn.randomReservoirIndices
def runErdosESN():
erdosError = 0
testPredictedOutputDataErdos = 0
for i in range(runTimes):
# Tune the Erdoys Renyi Network
probabilityBound = (
0.1, 1.0) #To avoid isolated bounds, keep the upper bound low
esnTuner = tuner.ESNErdosTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=validationInputData,
validationOutputData=validationOutputData,
inputConnectivity=inputConnectivity,
probabilityBound=probabilityBound,
times=10)
probabilityOptimum = esnTuner.getOptimalParameters()
res = ESN.EchoStateNetwork(
size=size,
inputData=trainingInputData,
outputData=trainingOutputData,
reservoirTopology=topology.ErdosRenyiTopology(
size=size, probability=probabilityOptimum),
inputConnectivity=inputConnectivity)
res.trainReservoir()
#Warm up using training data
trainingPredictedOutputData = res.predict(inputTrainingData)
#Predict for future
lastAvailablePoint = testInputData[0, 1]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
#Predict the next point
nextPoint = res.predict(np.array(query).reshape(1, 2))[0, 0]
testingPredictedOutputData.append(nextPoint)
lastAvailablePoint = nextPoint
testingPredictedOutputData = np.array(
testingPredictedOutputData).reshape(nTesting, 1)
#De-normalize
actual = minMax.inverse_transform(testActualOutputData)
testPredictedOutputDataErdos = minMax.inverse_transform(
testingPredictedOutputData)
#Error
erdosError += errorFunction.compute(
actual.reshape((actual.shape[0], 1)),
testPredictedOutputDataErdos.reshape(
(testPredictedOutputDataErdos.shape[0], 1)))
return testPredictedOutputDataErdos, (erdosError / runTimes)
def runScaleFree():
scaleFreeError = 0
testPredictedOutputDataScaleFree = 0
for i in range(runTimes):
# Tune the scale free networks
attachmentBound = (1, size - 1)
esnTuner = tuner.ESNScaleFreeNetworksTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=validationInputData,
validationOutputData=validationOutputData,
inputConnectivity=inputConnectivity,
attachmentBound=attachmentBound,
times=5)
attachmentOptimum = esnTuner.getOptimalParameters()
res = ESN.EchoStateNetwork(
size=size,
inputData=trainingInputData,
outputData=trainingOutputData,
reservoirTopology=topology.ScaleFreeNetworks(
size=size, attachmentCount=attachmentOptimum),
inputConnectivity=inputConnectivity)
res.trainReservoir()
#Warm up using training data
trainingPredictedOutputData = res.predict(trainingInputData)
#Predict for future
lastAvailablePoint = testInputData[0, 1]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
#Predict the next point
nextPoint = res.predict(np.array(query).reshape(1, 2))[0, 0]
testingPredictedOutputData.append(nextPoint)
lastAvailablePoint = nextPoint
testingPredictedOutputData = np.array(
testingPredictedOutputData).reshape(nTesting, 1)
#De-normalize
actual = minMax.inverse_transform(testActualOutputData)
testPredictedOutputDataScaleFree = minMax.inverse_transform(
testingPredictedOutputData)
#Error
scaleFreeError += errorFunction.compute(
actual.reshape((actual.shape[0], 1)),
testPredictedOutputDataScaleFree.reshape(
(testPredictedOutputDataScaleFree.shape[0], 1)))
return testPredictedOutputDataScaleFree, (scaleFreeError / runTimes)
def __ESNConnTrain__(self, x):
#Extract the parameters
inputConnectivity = x[0]
meanDegree = int(np.floor(x[1]))
beta = x[2]
reservoirTopology = topology.SmallWorldGraphs(size=self.size,
meanDegree=meanDegree,
beta=beta)
#print("\nParameters:"+str(x))
cumRMSE = 0
times = 10
#Run many times - just to get rid of randomness in assigning random weights
for i in range(times):
#Create the network
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=reservoirTopology,
inputConnectivity=inputConnectivity)
#Train the reservoir
esn.trainReservoir()
#Predict for the validation data
predictedOutputData = esn.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
cumRMSE += regressionError
#Free the memory
gc.collect()
regressionError = cumRMSE / times
#Return the error
#print("Regression error"+str(regressionError)+"\n")
return regressionError
def __ESNConnTrain__(self, x):
#Extract the parameters
inputConnectivity = x[0]
probability = x[1]
reservoirTopology = topology.ErdosRenyiTopology(
size=self.size, probability=probability)
#print("\nInput:"+str(inputConnectivity)+" Probability:"+str(probability))
cumRMSE = 0
times = 10
#Run many times - just to get rid of randomness in assigning random weights
for i in range(times):
#Create the network
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=reservoirTopology,
inputConnectivity=inputConnectivity)
#Train the reservoir
esn.trainReservoir()
#Predict for the validation data
predictedOutputData = esn.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
cumRMSE += regressionError
#Free the memory
gc.collect()
regressionError = cumRMSE / times
#Return the error
#print("\nOptimizing connectivity..")
#print("Regression error"+str(regressionError)+"\n")
return regressionError
def __ESNTrain__(self, x):
#print("\nOptimizing esn parameters:"+str(x))
#Extract the parameters
spectralRadius = x[0]
inputScaling = x[1]
reservoirScaling = x[2]
leakingRate = x[3]
#Create the reservoir
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=self.initialTransient,
inputWeightConn=self.inputWeightConn,
reservoirWeightConn=self.reservoirWeightConn,
reservoirTopology=topology.SmallWorldGraphs(
size=self.size,
meanDegree=self.meanDegreeOptimum,
beta=self.betaOptimum))
#Train the reservoir
esn.trainReservoir()
#Predict for the validation data
predictedOutputData = esn.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
#Free the memory
gc.collect()
#Return the error
#print("Regression error"+str(regressionError)+"\n")
return regressionError
def __ESNTrain__(self, x):
#Extract the parameters
attachment = int(np.floor(x[0]))
reservoirTopology = topology.ScaleFreeNetworks(
size=self.size, attachmentCount=attachment)
#print("\nOptimizing connectivity..")
print("\nAttachment:" + str(attachment))
cumRMSE = 0
times = self.times
for i in range(times):
#Create the network
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
reservoirTopology=reservoirTopology,
inputConnectivity=self.inputConnectivity)
#Train the reservoir
esn.trainReservoir()
#Predict for the validation data
predictedOutputData = esn.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
cumRMSE += regressionError
#Free the memory
gc.collect()
regressionError = cumRMSE / times
#Return the error
print("\nRegression error:" + str(regressionError) + "\n")
return regressionError
def __ESNTrain__(self, x):
#Extract the parameters
spectralRadius = x[0]
leakingRate = x[1]
#Create the reservoir
esn = EchoStateNetwork.EchoStateNetwork(
size=self.size,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
spectralRadius=spectralRadius,
leakingRate=leakingRate,
initialTransient=self.initialTransient,
inputWeightConn=self.inputWeightConn,
reservoirWeightConn=self.reservoirWeightConn,
reservoirTopology=topology.RandomTopology(
self.size, self.reservoirConnectivityOptimum))
#Train the reservoir
esn.trainReservoir()
#Predict for the validation data
predictedOutputData = esn.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
#Free the memory
gc.collect()
#Return the error
#print("Optimizing spectral radius and leaking rate...")
#print("\nRegression error"+str(regressionError)+"\n")
return regressionError
trainingOutputData=trainingOutputData,
validationInputData=validationInputData,
validationOutputData=validationOutputData,
spectralRadiusBound=spectralRadiusBound,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound)
spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightOptimum, reservoirWeightOptimum = resTuner.getOptimalParameters(
)
#Train the reservoir with the optimal parameters
res = reservoir.Reservoir(size=size,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
initialTransient=initialTransient,
inputData=trainingInputData,
outputData=trainingOutputData,
inputWeightRandom=inputWeightOptimum,
reservoirWeightRandom=reservoirWeightOptimum)
res.trainReservoir()
# To predict the test data, predict training and valiadation data as a warm up
trainingPredictedOutputData = res.predict(trainingInputData)
#Now, start predicting the future
xAxis = []
predictedOutput = []
lastDayIndex = rawData.shape[0] - 1
lastDay = date(int(availableData[lastDayIndex, 0]),
#Train the reservoir with optimal parameters
esn = esn.EchoStateNetwork(size=size,
inputData=inputTrainingData,
outputData=outputTrainingData,
reservoirTopology=topology,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
initialTransient=initialTransient,
inputConnectivity=inputConnectivity,
inputWeightConn=inputWeightConn,
reservoirWeightConn=reservoirConn)
esn.trainReservoir()
#Warm up for the trained data
predictedTrainingOutputData = esn.predict(inputTrainingData)
#Predict for future
lastAvailablePoint = predictedTrainingOutputData[nTraining-1,0]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
#Predict the next point
nextPoint = esn.predict(np.array(query).reshape(1,2))[0,0]
inputConnectivityBound = (0.1, 0.9) # Usually dense
probabilityBound = (0.0, 0.9
) #To avoid isolated bounds, keep the upper bound low
errorFunction = rmse.MeanSquareError()
esnTuner = tuner.ESNErdosTuner(size=size,
initialTransient=initialTransient,
trainingInputData=inputTrainingData,
trainingOutputData=outputTrainingData,
validationInputData=inputTrainingData,
validationOutputData=outputTrainingData,
inputConnectivityBound=inputConnectivityBound,
probabilityBound=probabilityBound)
inputConnectivityOptimum, probabilityOptimum = esnTuner.getOptimalParameters()
res = esn.EchoStateNetwork(size=size,
inputData=inputTrainingData,
outputData=outputTrainingData,
reservoirTopology=topology.ErdosRenyiTopology(
size=size, probability=probabilityOptimum),
inputConnectivity=inputConnectivityOptimum)
res.trainReservoir()
#Warm up using training data
trainingPredictedOutputData = res.predict(inputTrainingData)
#Predict for future
lastAvailablePoint = testInputData[0, 1]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
esnTuner = tuner.ESNScaleFreeNetworksTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=trainingInputData,
validationOutputData=trainingOutputData,
inputConnectivityBound=inputConnectivityBound,
attachmentBound=attachmentBound)
inputConnectivityOptimum, attachmentOptimum = esnTuner.getOptimalParameters()
network = esn.EchoStateNetwork(size=size,
inputData=trainingInputData,
outputData=trainingOutputData,
reservoirTopology=topology.ScaleFreeNetworks(
size=size,
attachmentCount=attachmentOptimum),
inputConnectivity=inputConnectivityOptimum)
network.trainReservoir()
#Warm up for the trained data
predictedTrainingOutputData = network.predict(trainingInputData)
#Predict for future
lastAvailablePoint = predictedTrainingOutputData[nTraining - 1, 0]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=trainingInputData,
validationOutputData=trainingOutputData,
inputConnectivityBound=inputConnectivityBound,
meanDegreeBound=meanDegreeBound,
betaBound=betaBound)
inputConnectivityOptimum, meanDegreeOptimum, betaOptimum = esnTuner.getOptimalParameters(
)
network = esn.EchoStateNetwork(size=size,
inputData=trainingInputData,
outputData=trainingOutputData,
reservoirTopology=topology.SmallWorldGraphs(
size=size,
meanDegree=meanDegreeOptimum,
beta=betaOptimum),
inputConnectivity=inputConnectivityOptimum)
network.trainReservoir()
#Warm up for the trained data
predictedTrainingOutputData = network.predict(trainingInputData)
#Predict for future
lastAvailablePoint = predictedTrainingOutputData[nTraining - 1, 0]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
def runSmallWorld():
smallWorldErrorError = 0
testPredictedOutputDataSmallWorld = 0
for i in range(runTimes):
# Tune the Small world graphs
meanDegreeBound = (2, size - 1)
betaBound = (0.1, 1.0)
esnTuner = tuner.ESNSmallWorldGraphsTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=validationInputData,
validationOutputData=validationOutputData,
inputConnectivity=inputConnectivity,
meanDegreeBound=meanDegreeBound,
betaBound=betaBound,
times=10)
meanDegreeOptimum, betaOptimum = esnTuner.getOptimalParameters()
res = ESN.EchoStateNetwork(size=size,
inputData=trainingInputData,
outputData=trainingOutputData,
reservoirTopology=topology.SmallWorldGraphs(
size=size,
meanDegree=meanDegreeOptimum,
beta=betaOptimum),
inputConnectivity=inputConnectivity)
res.trainReservoir()
#Warm up using training data
trainingPredictedOutputData = res.predict(inputTrainingData)
#Predict for future
lastAvailablePoint = testInputData[0, 1]
testingPredictedOutputData = []
for i in range(nTesting):
#Compose the query
query = [1.0]
query.append(lastAvailablePoint)
#Predict the next point
nextPoint = res.predict(np.array(query).reshape(1, 2))[0, 0]
testingPredictedOutputData.append(nextPoint)
lastAvailablePoint = nextPoint
testingPredictedOutputData = np.array(
testingPredictedOutputData).reshape(nTesting, 1)
#De-normalize
actual = minMax.inverse_transform(testActualOutputData)
testPredictedOutputDataSmallWorld = minMax.inverse_transform(
testingPredictedOutputData)
#Error
smallWorldErrorError += errorFunction.compute(
actual.reshape((actual.shape[0], 1)),
testPredictedOutputDataSmallWorld.reshape(
(testPredictedOutputDataSmallWorld.shape[0], 1)))
return testPredictedOutputDataSmallWorld, (smallWorldErrorError / runTimes)
horizon = 1
tsp = ts.TimeSeriesProcessor(rawData, depth, horizon, 4)
processedData = tsp.getProcessedData()
inputData = np.hstack((np.ones((processedData.shape[0], 1)),
processedData[:processedData.shape[0], :depth]))
outputData = processedData[:processedData.shape[0], depth:depth + horizon]
# Train
inputWeightRandom = np.load("Outputs/inputWeight.npy")
reservoirWeightRandom = np.load("Outputs/reservoirWeight.npy")
res = reservoir.Reservoir(size=600,
spectralRadius=1.25,
inputScaling=0.50,
reservoirScaling=0.50,
leakingRate=0.20,
initialTransient=0,
inputData=inputData,
outputData=outputData,
inputWeightRandom=inputWeightRandom,
reservoirWeightRandom=reservoirWeightRandom)
res.trainReservoir()
#Predict for past
lastDayIndex = 0
lastDayValue = rawData[lastDayIndex, 4]
xAxisPast = []
testPredictedOutputDataPast = []
testActualOutputDataPast = []
numberOfDaysInPast = rawData.shape[0] - 1
for i in range(numberOfDaysInPast):
# Pre-process the data and form feature and target vectors
tsp = tsi.TimeSeriesIntervalProcessor(trainingSeries, featureIntervalList,
targetIntervalList)
featureVectors, targetVectors = tsp.getProcessedData()
#Append bias to feature vectors
featureVectors = np.hstack((np.ones(
(featureVectors.shape[0], 1)), featureVectors))
#Train the reservoir with the optimal parameters
size = 1500
initialTransient = 50
network = esn.EchoStateNetwork(size=size,
inputData=featureVectors,
outputData=targetVectors,
reservoirTopology=topology.RandomTopology(
size=size, connectivity=0.4),
spectralRadius=0.79,
inputConnectivity=0.8)
network.trainReservoir()
# #Tune and Train
# spectralRadiusBound = (0.0, 1.0)
# inputScalingBound = (0.0, 1.0)
# reservoirScalingBound = (0.0, 1.0)
# leakingRateBound = (0.0, 1.0)
# inputConnectivityBound = (0.1,1.0) #Usually, densely connected
# reservoirConnectivityBound = (0.1,0.9) #Usually, sparsely connected
# size = 1000
# initialTransient = 5
# inputConnectivity = 0.7
import sys
import os
# add path of reservoir and import
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from reservoir import EchoStateNetwork
# reservoir
RES_SIZE = 50
C_IN = 1.0
C_RES = 0.999
C_FB = 0.0
esn = EchoStateNetwork(1,
RES_SIZE,
1,
in_coef=C_IN,
res_coef=C_RES,
fb_coef=C_FB)
# input sequence
LEN = 20
us = np.random.choice([0, 1], LEN).astype(np.float32)
# target sequence
DELAY = 5
ys_target = np.array([np.nan for i in range(DELAY)] +
[us[i] for i in range(LEN - DELAY)],
dtype=np.float32)
# inputting
LEAK = 0.9
validationOutputData = trainingOutputData
#Tune the reservoir
spectralRadius = 0.5
inputScaling = 0.5
reservoirScaling = 0.5
leakingRate = 0.3
size = 500
initialTransient = 50
#Train the reservoir with the optimal parameters
res1 = reservoir.Reservoir(size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
inputData=trainingInputData,
outputData=trainingOutputData)
res1.trainReservoir()
# To predict the test data, predict training and valiadation data as a warm up
trainingPredictedOutputData = res1.predict(trainingInputData)
#Now, start predicting the future
xAxis = []
predictedOutput = []
lastDayIndex = rawData.shape[0] -1
lastDay = date(int(availableData[lastDayIndex, 0]), int(availableData[lastDayIndex, 1]), int(availableData[lastDayIndex, 2]))
testActualOutputData = data[nTraining + 1:nTraining + nTesting + 1].reshape(
(nTesting, 1))
# Tune the network
size = 256
initialTransient = 50
inputConnectivity = 0.8
reservoirConnectivity = 0.7
reservoirTopology = topology.RandomTopology(size=size,
connectivity=reservoirConnectivity)
res = ESN.EchoStateNetwork(size=size,
inputData=inputTrainingData,
outputData=outputTrainingData,
reservoirTopology=reservoirTopology,
spectralRadius=0.67,
inputScaling=0.87,
reservoirScaling=0.44,
leakingRate=0.9,
initialTransient=initialTransient,
inputConnectivity=inputConnectivity)
res.trainReservoir()
#Warm up
predictedTrainingOutputData = res.predict(inputTrainingData)
#Predict future values
predictedTestOutputData = []
lastAvailableData = testInputData[0, 1]
for i in range(nTesting):
query = [1.0]
query.append(lastAvailableData)
trainingOutputData=targetVectors,
validationInputData=featureVectors,
validationOutputData=targetVectors,
spectralRadiusBound=spectralRadiusBound,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound)
spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightOptimum, reservoirWeightOptimum = resTuner.getOptimalParameters(
)
#Train the reservoir with the optimal parameters
res = reservoir.Reservoir(size=size,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
initialTransient=initialTransient,
inputData=featureVectors,
outputData=targetVectors,
inputWeightRandom=inputWeightOptimum,
reservoirWeightRandom=reservoirWeightOptimum)
res.trainReservoir()
#Predict for the training data as a warmup
trainingPredictedOutputData = res.predict(featureVectors)
#Now, start predicted the future
nextDate = series.last_valid_index()
predicted = []
xAxis = []
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound,
spectralRadiusBound=spectralRadiusBound,
reservoirTopology=reservoirTopology,
inputConnectivity=inputConnectivity)
spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightConn, reservoirWeightConn = esnTuner.getOptimalParameters(
)
res = ESN.EchoStateNetwork(size=size,
inputData=inputTrainingData,
outputData=outputTrainingData,
reservoirTopology=reservoirTopology,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
initialTransient=initialTransient,
inputConnectivity=inputConnectivity,
inputWeightConn=inputWeightConn,
reservoirWeightConn=reservoirWeightConn)
res.trainReservoir()
#Warm up
predictedTrainingOutputData = res.predict(inputTrainingData)
#Predict future values
predictedTestOutputData = []
lastAvailableData = testInputData[0, 1]
for i in range(nTesting):
query = [1.0]
import sys
import os
# add path of reservoir and import
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from reservoir import EchoStateNetwork
# reservoir
RES_SIZE = 50
C_IN = 0.5
C_RES = 0.999
C_FB = 0.0
esn = EchoStateNetwork(1,
RES_SIZE,
1,
in_coef=C_IN,
res_coef=C_RES,
fb_coef=C_FB)
# input sequence
LEN = 20
us = np.random.uniform(-1, 1, LEN).astype(np.float32)
# target sequence (NARMA2)
ALPHA = 0.4
BETA = 0.4
GAMMA = 0.6
DELTA = 0.1
ys_target = np.zeros(us.shape, us.dtype)
for i in range(2, us.shape[0]):
ys_target[i] = ALPHA * ys_target[i - 1] + BETA * ys_target[
