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 __reservoirTrain__(self, x):
#Extract the parameters
meanDegree, beta = x
meanDegree = int(meanDegree)
# To get rid off the randomness in assigning weights, run it 10 times and take the average error
times = 100
cumulativeError = 0
for i in range(times):
# Input and weight connectivity Matrix
inputWeightMatrix = topology.ClassicInputTopology(
self.inputD, self.size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=self.size, meanDegree=meanDegree,
beta=beta).generateWeightMatrix()
#Create the reservoir
res = classicESN.Reservoir(
size=self.size,
spectralRadius=self.spectralRadius,
inputScaling=self.inputScaling,
reservoirScaling=self.reservoirScaling,
leakingRate=self.leakingRate,
initialTransient=self.initialTransient,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
inputWeightRandom=inputWeightMatrix,
reservoirWeightRandom=reservoirWeightMatrix)
#Train the reservoir
res.trainReservoir()
# Warm up
predictedTrainingOutputData = res.predict(
self.trainingInputData[-self.initialTransient:])
#Predict for the validation data
predictedOutputData = util.predictFuture(res, self.initialSeed,
self.horizon)
gc.collect()
#Calcuate the regression error
errorFunction = metrics.MeanSquareError()
error = errorFunction.compute(self.validationOutputData,
predictedOutputData)
cumulativeError += error
regressionError = cumulativeError / times
#Return the error
print("\nThe Parameters: " + str(x) + " Regression error:" +
str(regressionError))
return regressionError
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 __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 getNetworkStats(bestPopulation, type, size):
log = []
for item in bestPopulation:
averageDegree = 0.0
averagePathLength = 0.0
averageDiameter = 0.0
averageClusteringCoefficient = 0.0
# Run many times to get the average stats
times = 1
for i in range(times):
if(type == Topology.Random):
connectivity = item[0][0,0]
network = topology.RandomReservoirTopology(size=size, connectivity=connectivity)
elif(type == Topology.ErdosRenyi):
probability = item[0][0,0]
network = topology.ErdosRenyiTopology(size=size, probability=probability)
elif(type == Topology.ScaleFreeNetworks):
attachment = int(item[0][0,0])
network = topology.ScaleFreeNetworks(size=size, attachmentCount=attachment)
elif(type == Topology.SmallWorldGraphs):
meanDegree = item[0][0,0]
beta = item[0][1,0]
network = topology.SmallWorldGraphs(size=size, meanDegree=meanDegree, beta=beta)
averageDegree += network.networkStats.getAverageDegree()
averagePathLength += network.networkStats.getAveragePathLenth()
averageDiameter += network.networkStats.getDiameter()
averageClusteringCoefficient += network.networkStats.getAverageClusteringCoefficient()
stats = {}
stats["averageDegree"] = averageDegree/times
stats["averagePathLength"] = averagePathLength/times
stats["averageDiameter"] = averageDiameter/times
stats["averageClusteringCoefficient"] = averageClusteringCoefficient/times
log.append((item[0], item[1], stats))
return log
depth = 1
featureVectors, targetVectors = util.formContinousFeatureAndTargetVectorsInOrder(
normalizedSeries, depth)
n = featureVectors.shape[0]
# Input-to-reservoir fully connected
size = 100
inputWeight = topology.ClassicInputTopology(
inputSize=featureVectors.shape[1],
reservoirSize=size).generateWeightMatrix()
# Reservoir-to-reservoir fully connected
#reservoirWeight = topology.ClassicReservoirTopology(size=size).generateWeightMatrix()
reservoirWeight = topology.SmallWorldGraphs(size=size,
meanDegree=int(size / 2),
beta=0.8).generateWeightMatrix()
res = ESN.Reservoir(size=size,
inputData=featureVectors,
outputData=targetVectors,
spectralRadius=1.5,
inputScaling=0.1,
reservoirScaling=0.5,
leakingRate=0.7,
initialTransient=0,
inputWeightRandom=inputWeight,
reservoirWeightRandom=reservoirWeight)
res.trainReservoir()
#Warm up
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)
def tuneTrainPredictConnectivityGA(trainingInputData, trainingOutputData, validationOutputData,
initialInputSeedForValidation, horizon, noOfBest, size=256,initialTransient=50,
resTopology = Topology.Random,
popSize=100, maxGeneration=100):
# Other reservoir parameters
spectralRadius = 0.79
inputScaling = 0.5
reservoirScaling = 0.5
leakingRate = 0.3
if(resTopology == Topology.Random):
resTuner = rgTuner.RandomGraphTuner(size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
noOfBest=noOfBest,
spectralRadius=spectralRadius, inputScaling=inputScaling,
reservoirScaling=reservoirScaling, leakingRate=leakingRate,
populationSize=popSize, maxGeneration=maxGeneration)
resTuner.__tune__()
reservoirConnectivityOptimum = resTuner.getOptimalParameters()
bestPopulation = resTuner.getBestPopulation()
inputWeightMatrix = topology.ClassicInputTopology(inputSize=trainingInputData.shape[1], reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.RandomReservoirTopology(size=size, connectivity=reservoirConnectivityOptimum).generateWeightMatrix()
elif(resTopology == Topology.ErdosRenyi):
resTuner = rgTuner.ErdosRenyiTuner(size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
noOfBest=noOfBest,
spectralRadius=spectralRadius, inputScaling=inputScaling,
reservoirScaling=reservoirScaling, leakingRate=leakingRate,
populationSize=popSize, maxGeneration=maxGeneration)
resTuner.__tune__()
probabilityOptimum = resTuner.getOptimalParameters()
bestPopulation = resTuner.getBestPopulation()
inputWeightMatrix = topology.ClassicInputTopology(inputSize=trainingInputData.shape[1], reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ErdosRenyiTopology(size=size, probability=probabilityOptimum).generateWeightMatrix()
elif(resTopology == Topology.ScaleFreeNetworks):
resTuner = rgTuner.ScaleFreeNetworksTuner(size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
noOfBest=noOfBest,
spectralRadius=spectralRadius, inputScaling=inputScaling,
reservoirScaling=reservoirScaling, leakingRate=leakingRate,
populationSize=popSize, maxGeneration=maxGeneration)
resTuner.__tune__()
attachmentOptimum = resTuner.getOptimalParameters()
bestPopulation = resTuner.getBestPopulation()
inputWeightMatrix = topology.ClassicInputTopology(inputSize=trainingInputData.shape[1], reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ScaleFreeNetworks(size=size, attachmentCount=attachmentOptimum).generateWeightMatrix()
elif(resTopology == Topology.SmallWorldGraphs):
resTuner = rgTuner.SmallWorldNetworksTuner(size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
noOfBest=noOfBest,
spectralRadius=spectralRadius, inputScaling=inputScaling,
reservoirScaling=reservoirScaling, leakingRate=leakingRate,
populationSize=popSize, maxGeneration=maxGeneration)
resTuner.__tune__()
meanDegreeOptimum, betaOptimum = resTuner.getOptimalParameters()
bestPopulation = resTuner.getBestPopulation()
inputWeightMatrix = topology.ClassicInputTopology(inputSize=trainingInputData.shape[1], reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(size=size, meanDegree=int(meanDegreeOptimum), beta=betaOptimum).generateWeightMatrix()
#Train
network = esn.Reservoir(size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
inputData=trainingInputData,
outputData=trainingOutputData,
inputWeightRandom=inputWeightMatrix,
reservoirWeightRandom=reservoirWeightMatrix)
network.trainReservoir()
warmupFeatureVectors, warmTargetVectors = formFeatureVectors(validationOutputData)
predictedWarmup = network.predict(warmupFeatureVectors[-initialTransient:])
initialInputSeedForTesting = validationOutputData[-1]
predictedOutputData = predictFuture(network, initialInputSeedForTesting, horizon)[:,0]
return predictedOutputData, bestPopulation
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 tuneConnectivity(trainingInputData,
trainingOutputData,
validationOutputData,
initialInputSeedForValidation,
horizon,
testingActualOutputData,
size=256,
initialTransient=50,
resTopology=Topology.Classic):
# Other reservoir parameters
spectralRadius = 0.79
inputScaling = 0.5
reservoirScaling = 0.5
leakingRate = 0.3
# Optimal Parameters List
optimalParameters = {}
if (resTopology == Topology.Classic):
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ClassicReservoirTopology(
size=size).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.Random):
resTuner = tuner.RandomConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
reservoirConnectivityOptimum = resTuner.getOptimalParameters()
optimalParameters[
"Optimal_Reservoir_Connectivity"] = reservoirConnectivityOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.RandomReservoirTopology(
size=size, connectivity=reservoirConnectivityOptimum
).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.ErdosRenyi):
resTuner = tuner.ErdosRenyiConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
probabilityOptimum = resTuner.getOptimalParameters()
optimalParameters[
"Optimal_Connectivity_Probability"] = probabilityOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ErdosRenyiTopology(
size=size,
probability=probabilityOptimum).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.ScaleFreeNetworks):
resTuner = tuner.ScaleFreeNetworksConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
attachmentOptimum = resTuner.getOptimalParameters()
optimalParameters[
"Optimal_Preferential_Attachment"] = attachmentOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ScaleFreeNetworks(
size=size,
attachmentCount=attachmentOptimum).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.SmallWorldGraphs):
resTuner = tuner.SmallWorldGraphsConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
meanDegreeOptimum, betaOptimum = resTuner.getOptimalParameters()
optimalParameters["Optimal_MeanDegree"] = meanDegreeOptimum
optimalParameters["Optimal_Beta"] = betaOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=size, meanDegree=int(meanDegreeOptimum),
beta=betaOptimum).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
def tuneTrainPredictConnectivityNonBrute(trainingInputData,
trainingOutputData,
validationOutputData,
initialInputSeedForValidation,
horizon,
size=256,
initialTransient=50,
resTopology=Topology.Random):
# Other reservoir parameters
spectralRadius = 0.79
inputScaling = 0.5
reservoirScaling = 0.5
leakingRate = 0.3
if (resTopology == Topology.Random):
resTuner = tuner.RandomConnectivityTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
reservoirConnectivityOptimum = resTuner.getOptimalParameters()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.RandomReservoirTopology(
size=size,
connectivity=reservoirConnectivityOptimum).generateWeightMatrix()
elif (resTopology == Topology.SmallWorldGraphs):
resTuner = tuner.SmallWorldGraphsConnectivityNonBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
meanDegreeOptimum, betaOptimum = resTuner.getOptimalParameters()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=size, meanDegree=int(meanDegreeOptimum),
beta=betaOptimum).generateWeightMatrix()
#Train
network = ESN.Reservoir(size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
inputData=trainingInputData,
outputData=trainingOutputData,
inputWeightRandom=inputWeightMatrix,
reservoirWeightRandom=reservoirWeightMatrix)
network.trainReservoir()
warmupFeatureVectors, warmTargetVectors = formFeatureVectors(
validationOutputData)
predictedWarmup = network.predict(warmupFeatureVectors[-initialTransient:])
initialInputSeedForTesing = validationOutputData[-1]
predictedOutputData = predictFuture(network, initialInputSeedForTesing,
horizon)[:, 0]
return predictedOutputData
