def __reservoirTrain__(self, x):
#Extract the parameters
reservoirConnectivity = float(x)
# To get rid off the randomness in assigning weights, run it 10 times and take the average error
times = 10
cumulativeError = 0
for i in range(times):
# Input and weight connectivity Matrix
inputWeightMatrix = topology.ClassicInputTopology(
self.inputD, self.size).generateWeightMatrix()
reservoirWeightMatrix = topology.RandomReservoirTopology(
size=self.size,
connectivity=reservoirConnectivity).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 __collectOutputs__(self, featureIndices):
# Form the feature and target vectors
featureVectors = self.__formFeaturevectors__(self.inputData,
featureIndices)
targetVectors = self.outputData
# Append bias
featureVectors = np.hstack((np.ones(
(featureVectors.shape[0], 1)), featureVectors))
# Input weight matrix
inputSize = featureVectors.shape[1]
reservoirSize = self.lowerLayerParameters['size']
inputWeightRandom = topology.RandomInputTopology(
inputSize, reservoirSize, self.
lowerLayerParameters['inputConnectivity']).generateWeightMatrix()
reservoirWeightRandom = topology.RandomReservoirTopology(
reservoirSize, self.lowerLayerParameters['reservoirConnectivity']
).generateWeightMatrix()
# Generate the reservoir
res = esn.Reservoir(
size=self.lowerLayerParameters['size'],
spectralRadius=self.lowerLayerParameters['spectralRadius'],
inputScaling=self.lowerLayerParameters['inputScaling'],
reservoirScaling=self.lowerLayerParameters['reservoirScaling'],
leakingRate=self.lowerLayerParameters['leakingRate'],
initialTransient=self.lowerLayerParameters['initialTransient'],
inputData=featureVectors,
outputData=targetVectors,
inputWeightRandom=inputWeightRandom,
reservoirWeightRandom=reservoirWeightRandom,
reservoirActivationFunction=self.
lowerLayerParameters['reservoirActivation'],
outputActivationFunction=self.
lowerLayerParameters['outputActivation'])
# Train the reservoir
res.trainReservoir()
# Just assign the weights randomly
# Store the reservoir
self.lowerLayerNetworks.append(res)
# Collect the outputs
outputs = res.predict(featureVectors)
return outputs
def trainReservoir(self):
# Features for the network in the higher layer
features = None
# Collect outputs from the lower layer
for i in range(self.lowerLayerCount):
if (features is None): # First time
features = self.__collectOutputs__(self.featureIndicesList[i])
else:
features = np.hstack(
(features,
self.__collectOutputs__(self.featureIndicesList[i])))
# Append bias
features = np.hstack((np.ones((features.shape[0], 1)), features))
# Generate the higher layer reservoir
# where features are the outputs of the lower layer networks
inputSize = features.shape[1]
reservoirSize = self.higherLayerParameters['size']
inputWeightRandom = topology.RandomInputTopology(
inputSize, reservoirSize, self.
higherLayerParameters['inputConnectivity']).generateWeightMatrix()
reservoirWeightRandom = topology.RandomReservoirTopology(
self.higherLayerParameters['size'],
self.higherLayerParameters['reservoirConnectivity']
).generateWeightMatrix()
self.higherLayerReservoir = esn.Reservoir(
size=self.higherLayerParameters['size'],
spectralRadius=self.higherLayerParameters['spectralRadius'],
inputScaling=self.higherLayerParameters['inputScaling'],
reservoirScaling=self.higherLayerParameters['reservoirScaling'],
leakingRate=self.higherLayerParameters['leakingRate'],
initialTransient=self.higherLayerParameters['initialTransient'],
inputData=features,
outputData=self.outputData,
inputWeightRandom=inputWeightRandom,
reservoirWeightRandom=reservoirWeightRandom,
reservoirActivationFunction=self.
higherLayerParameters['reservoirActivation'],
outputActivationFunction=self.
higherLayerParameters['outputActivation'])
# Train the composite network
self.higherLayerReservoir.trainReservoir()
def __createTransformer__(self, featureVectors):
# Append the bias
#featureVectors = np.hstack((np.ones((featureVectors.shape[0],1)),featureVectors))
featureVectors = featureVectors
targetVectors = self.outputData
# Input weight matrix
inputSize = featureVectors.shape[1]
reservoirSize = self.featureTransformerParameters['size']
inputWeightRandom = topology.RandomInputTopology(
inputSize, reservoirSize,
self.featureTransformerParameters['inputConnectivity']
).generateWeightMatrix()
reservoirWeightRandom = topology.RandomReservoirTopology(
reservoirSize,
self.featureTransformerParameters['reservoirConnectivity']
).generateWeightMatrix()
# Generate the reservoir
self.transformer = esn.Reservoir(
size=self.featureTransformerParameters['size'],
spectralRadius=self.featureTransformerParameters['spectralRadius'],
inputScaling=self.featureTransformerParameters['inputScaling'],
reservoirScaling=self.
featureTransformerParameters['reservoirScaling'],
leakingRate=self.featureTransformerParameters['leakingRate'],
initialTransient=self.
featureTransformerParameters['initialTransient'],
inputData=featureVectors,
outputData=targetVectors,
inputWeightRandom=inputWeightRandom,
reservoirWeightRandom=reservoirWeightRandom,
reservoirActivationFunction=self.
featureTransformerParameters['reservoirActivation'],
outputActivationFunction=self.
featureTransformerParameters['outputActivation'])
# Collect and return the internal state
internalStates = self.transformer.collectInternalStates(featureVectors)
return internalStates
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
def trainReservoir(self):
# Feature transformation
features = self.__createTransformer__(self.inputData)
# Append bias
features = np.hstack((np.ones((features.shape[0], 1)), features))
# Generate the predictor
# where features are transformed using transformer(esn)
inputSize = features.shape[1]
reservoirSize = self.predictorParameters['size']
inputWeightRandom = topology.RandomInputTopology(
inputSize, reservoirSize, self.
predictorParameters['inputConnectivity']).generateWeightMatrix()
reservoirWeightRandom = topology.RandomReservoirTopology(
self.predictorParameters['size'],
self.predictorParameters['reservoirConnectivity']
).generateWeightMatrix()
self.predictor = esn.Reservoir(
size=self.predictorParameters['size'],
spectralRadius=self.predictorParameters['spectralRadius'],
inputScaling=self.predictorParameters['inputScaling'],
reservoirScaling=self.predictorParameters['reservoirScaling'],
leakingRate=self.predictorParameters['leakingRate'],
initialTransient=self.predictorParameters['initialTransient'],
inputData=features,
outputData=self.outputData,
inputWeightRandom=inputWeightRandom,
reservoirWeightRandom=reservoirWeightRandom,
reservoirActivationFunction=self.
predictorParameters['reservoirActivation'],
outputActivationFunction=self.
predictorParameters['outputActivation'])
# Train the predictor network
self.predictor.trainReservoir()
# Form feature vectors
inputTrainingData, outputTrainingData = util.formFeatureVectors(trainingData)
# Tune the network
size = 256
initialTransient = 50
# Input-to-reservoir 60% connected
inputWeight = topology.RandomInputTopology(
inputSize=inputTrainingData.shape[1],
reservoirSize=size,
inputConnectivity=1.0).generateWeightMatrix()
# Reservoir-to-reservoir 50% connected
reservoirWeight = topology.RandomReservoirTopology(
size=size, connectivity=0.92).generateWeightMatrix()
res = ESN.Reservoir(size=size,
inputData=inputTrainingData,
outputData=outputTrainingData,
spectralRadius=0.79,
inputScaling=0.5,
reservoirScaling=0.5,
leakingRate=0.3,
initialTransient=initialTransient,
inputWeightRandom=inputWeight,
reservoirWeightRandom=reservoirWeight)
res.trainReservoir()
#Warm up
predictedTrainingOutputData = res.predict(inputTrainingData)
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
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
testingData=testingData)
classicESNPredicted = minMax.inverse_transform(predictedOutputData)
classicESNError += error
classicESNError = classicESNError / iterations
# Run random ESN Tuner
randomESNError = 0
connectivityOptimum = 0.72999999999999998
print("\n Running Random ESN Tuner..")
for i in range(iterations):
predictedOutputData, error = util.tuneTrainPredict(
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationOutputData=validationData,
initialInputSeedForValidation=initialSeedForValidation,
reservoirTopology=topology.RandomReservoirTopology(
size=reservoirSize, connectivity=connectivityOptimum),
testingData=testingData)
randomESNPredicted = minMax.inverse_transform(predictedOutputData)
randomESNError += error
randomESNError = randomESNError / iterations
# Run Erdos ESN Tuner
erdosESNError = 0
probabilityOptimum = 1.0
print("\n Running Erdos ESN Tuner..")
for i in range(iterations):
print("\n Iteration:" + str(i + 1))
predictedOutputData, error = util.tuneTrainPredict(
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
validationOutputData=validationData,
