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)