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 __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 __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 __ESNTrain__(self, 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.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("\nOptimizing esn parameters..")
#print("Regression error"+str(regressionError)+"\n")
return regressionError
def __ESNConnTrain__(self, x):
#Extract the parameters
inputConnectivity = x[0]
reservoirConnectivity = x[1]
reservoirTopology = topology.RandomTopology(
size=self.size, connectivity=reservoirConnectivity)
cumRMSE = 0
times = self.times
#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
(nTraining, 1)), data[:nTraining].reshape((nTraining, 1))))
trainingOutputData = data[1:nTraining + 1].reshape((nTraining, 1))
#Testing data
nTesting = 300
testInputData = np.hstack((np.ones(
(nTesting, 1)), data[nTraining:nTraining + nTesting].reshape(
(nTesting, 1))))
testActualOutputData = data[nTraining + 1:nTraining + nTesting + 1].reshape(
(nTesting, 1))
#Tune and Train
size = 100
initialTransient = 5
inputConnectivity = 0.6
reservoirTopology = topology.RandomTopology(size=size, connectivity=0.9)
inputScalingBound = reservoirScalingBound = leakingRateBound = spectralRadiusBound = (
0.0, 1.0)
esnTuner = tuner.ESNTuner(size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationInputData=trainingInputData,
validationOutputData=trainingOutputData,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound,
spectralRadiusBound=spectralRadiusBound,
reservoirTopology=reservoirTopology,
inputConnectivity=inputConnectivity)
testPredictedOutputData = minMax.inverse_transform(testingPredictedOutputData)
testPredictedOutputDataErdos = testPredictedOutputData
#Error
erdosError = errorFunction.compute(
actual.reshape((actual.shape[0], 1)),
testPredictedOutputData.reshape((testPredictedOutputData.shape[0], 1)))
#Tune the standard reservoir
spectralRadiusBound = (0.0, 1.25)
inputScalingBound = (0.0, 1.0)
reservoirScalingBound = (0.0, 1.0)
leakingRateBound = (0.0, 1.0)
size = 100
initialTransient = 5
randomTopology = topology.RandomTopology(size=size, connectivity=0.6)
inputConnectivity = 0.8
inputConnectivityBound = (0.1, 0.9)
reservoirConnectivityBound = (0.1, 0.9)
resTuner = tuner.ESNTunerWithConnectivity(
size=size,
initialTransient=initialTransient,
trainingInputData=inputTrainingData,
trainingOutputData=outputTrainingData,
validationInputData=inputTrainingData,
validationOutputData=outputTrainingData,
spectralRadiusBound=spectralRadiusBound,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound,
import numpy as np
from reservoir import ReservoirTopology as topology
conn = topology.RandomTopology(size=5,
connectivity=0.6).generateConnectivityMatrix()
weight = np.random.rand(5, 5)
weight = conn * weight
scaling = 0.5
weight[weight != 0.0] = weight[weight != 0.0] - 0.5
print(weight)
from reservoir import ReservoirTopology as toplogy import numpy as np reservoirConnMatrix = toplogy.RandomTopology(size=2, connectivity=0.5).generateConnectivityMatrix() reservoirWeightRandom = np.arange(4).reshape((2,2)) multiplyOperator = reservoirWeightRandom * reservoirConnMatrix multiplyFunction = np.multiply(reservoirWeightRandom, reservoirConnMatrix) print(reservoirWeightRandom)
