def __tune__(self):
# First tune for the input connectivity and the reservoir connectivity
connBounds = [self.inputConnectivityBound, self.probabilityBound]
connResult = optimize.differential_evolution(self.__ESNConnTrain__,
bounds=connBounds)
self.inputConnectivityOptimum = connResult.x[0]
self.probabilityOptimum = 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.ErdosRenyiTopology(
size=self.size, probability=self.probabilityOptimum),
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 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 __reservoirTrain__(self, x):
#Extract the parameters
probability = x
# 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.ErdosRenyiTopology(
size=self.size,
probability=probability).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]
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):
#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.ErdosRenyiTopology(
self.size, self.probabilityOptimum))
#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
#t("\nOptimizing esn parameters..")
#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
for i in range(self.conn.shape[0]):
for j in range(self.conn.shape[0]):
if self.conn[i, j] == 1.0:
linksData += '{"source":' + str(i) + ',"target":' + str(
j) + ',"value":1},'
linksData = linksData[0:len(linksData) - 1]
self.data.write(linksData + ']')
self.data.write('}')
def createOutput(self):
self.__generateHTMLOutput()
self.__generateDataOutput()
if __name__ == '__main__':
network2 = topology.ErdosRenyiTopology(size=10, probability=0.2)
conn, indices = network2.generateConnectivityMatrix()
plot2 = NetworkPlot("ErdosRenyi_0.2.html", "", conn)
plot2.createOutput()
# network3 = topology.ErdosRenyiTopology(size = 10, probability=0.7)
# conn, indices = network3.generateConnectivityMatrix()
# plot3 = NetworkPlot("ErdosRenyi_0.7.html", "", conn)
# plot3.createOutput()
#
# network4 = topology.ErdosRenyiTopology(size = 10, probability=0.5)
# conn, indices = network4.generateConnectivityMatrix()
# plot4 = NetworkPlot("ErdosRenyi_0.5.html", "", conn)
# plot4.createOutput()
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)
#Predict the next point
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 tuneTrainPredictConnectivity(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.RandomConnectivityBruteTuner(
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.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()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ErdosRenyiTopology(
size=size, probability=probabilityOptimum).generateWeightMatrix()
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()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ScaleFreeNetworks(
size=size,
attachmentCount=attachmentOptimum).generateWeightMatrix()
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()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=size, meanDegree=int(meanDegreeOptimum),
beta=betaOptimum).generateWeightMatrix()
# TODO: train 10 times and get the mean prediction and mean error
#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
testInputData = np.hstack((np.ones(
(nTesting, 1)), data[nTraining:nTraining + nTesting].reshape(
(nTesting, 1))))
testActualOutputData = data[nTraining + 1:nTraining + nTesting + 1].reshape(
(nTesting, 1))
size = 100
initialTransient = 5
#Run for different deterministic topologies
topologyNames = [
'Erdos Renyi - 0.1', 'Erdos Renyi - 0.3', 'Erdos Renyi - 0.5',
'Erdos Renyi - 0.7', 'Erdos Renyi - 0.9'
]
topologyObjects = [
topology.ErdosRenyiTopology(size=size, probability=0.1),
topology.ErdosRenyiTopology(size=size, probability=0.3),
topology.ErdosRenyiTopology(size=size, probability=0.5),
topology.ErdosRenyiTopology(size=size, probability=0.7),
topology.ErdosRenyiTopology(size=size, probability=0.9)
]
topologyTestOutput = []
topologyError = []
errorFunction = rmse.MeanSquareError()
for i in range(len(topologyObjects)):
res = esn.EchoStateNetwork(size=size,
inputData=inputTrainingData,
outputData=outputTrainingData,
reservoirTopology=topologyObjects[i],
nTesting = testingData.shape[0]
# Form feature vectors
inputTrainingData, outputTrainingData = util.formFeatureVectors(trainingData)
# Tune the network
size = 256
initialTransient = 50
# Input-to-reservoir fully connected
inputWeight = topology.ClassicInputTopology(
inputSize=inputTrainingData.shape[1],
reservoirSize=size).generateWeightMatrix()
# Reservoir-to-reservoir -Erdos Topology with 60% probability
reservoirWeight = topology.ErdosRenyiTopology(
size=size, probability=0.37).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)
