def __ESNConnTrain__(self, x): #Extract the parameters inputConnectivity = x[0] reservoirConnectivity = x[1] reservoirTopology = topology.RandomTopology( size=self.size, connectivity=reservoirConnectivity) #Create the network esn = EchoStateNetwork.EchoStateNetwork( size=self.size, inputData=self.trainingInputData, outputData=self.trainingOutputData, reservoirTopology=reservoirTopology, inputConnectivity=inputConnectivity) #Train the reservoir esn.trainReservoir() #Predict for the validation data predictedOutputData = esn.predict(self.validationInputData) #Calcuate the regression error errorFunction = rmse.MeanSquareError() regressionError = errorFunction.compute(self.validationOutputData, predictedOutputData) #Free the memory gc.collect() #Return the error #print("Optimizing connectivity..") #print("\nRegression error:"+str(regressionError)+"\n") return regressionError
def __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 __tune__(self): # First tune for the input connectivity and the reservoir connectivity connBounds = [ self.inputConnectivityBound, self.reservoirConnectivityBound ] connResult = optimize.differential_evolution(self.__ESNConnTrain__, bounds=connBounds, maxiter=1) self.inputConnectivityOptimum = connResult.x[0] self.reservoirConnectivityOptimum = connResult.x[1] # With tuned parameters, create the network with optimal connections and keep the connections as same esn = EchoStateNetwork.EchoStateNetwork( size=self.size, inputData=self.trainingInputData, outputData=self.trainingOutputData, reservoirTopology=topology.RandomTopology( size=self.size, connectivity=self.reservoirConnectivityOptimum), inputConnectivity=self.inputConnectivityOptimum) self.inputWeightConn = esn.inputWeightRandom, esn.randomInputIndices self.reservoirWeightConn = esn.reservoirWeightRandom, esn.randomReservoirIndices # Tune the other parameters bounds = [self.spectralRadiusBound, self.leakingRateBound] result = optimize.differential_evolution(self.__ESNTrain__, bounds=bounds, maxiter=1) return result.x[0], result.x[ 1], self.inputWeightConn, self.reservoirWeightConn
def runStandardESN(): standardError = 0 testPredictedOutputDataStandard = 0 for i in range(runTimes): #Tune the standard reservoir reservoirConnectivityBound = (0.1, 1.0) resTuner = tuner.ESNConnTuner( size=size, initialTransient=initialTransient, trainingInputData=trainingInputData, trainingOutputData=trainingOutputData, validationInputData=validationInputData, validationOutputData=validationOutputData, inputConnectivity=inputConnectivity, reservoirConnectivityBound=reservoirConnectivityBound, times=10) reservoirConnectivityOptimum = resTuner.getOptimalParameters() #Train the reservoir with optimal parameters esn = ESN.EchoStateNetwork( size=size, inputData=trainingInputData, outputData=trainingOutputData, reservoirTopology=topology.RandomTopology( size=size, connectivity=reservoirConnectivityOptimum), inputConnectivity=inputConnectivity) esn.trainReservoir() #Warm up for the trained data predictedTrainingOutputData = esn.predict(inputTrainingData) #Predict for future lastAvailablePoint = predictedTrainingOutputData[nTraining - 1, 0] testingPredictedOutputData = [] for i in range(nTesting): #Compose the query query = [1.0] query.append(lastAvailablePoint) #Predict the next point nextPoint = esn.predict(np.array(query).reshape(1, 2))[0, 0] testingPredictedOutputData.append(nextPoint) lastAvailablePoint = nextPoint testingPredictedOutputData = np.array( testingPredictedOutputData).reshape(nTesting, 1) #Predict testPredictedOutputDataStandard = minMax.inverse_transform( testingPredictedOutputData) actual = minMax.inverse_transform(testActualOutputData) standardError += errorFunction.compute( actual.reshape((actual.shape[0], 1)), testPredictedOutputDataStandard.reshape( (testPredictedOutputDataStandard.shape[0], 1))) return testPredictedOutputDataStandard, (standardError / runTimes)
def __init__(self, size, initialTransient, trainingInputData, trainingOutputData, validationInputData, validationOutputData, spectralRadiusBound, inputScalingBound, reservoirScalingBound, leakingRateBound, reservoirTopology, inputConnectivity=0.6): self.size = size self.initialTransient = initialTransient self.trainingInputData = trainingInputData self.trainingOutputData = trainingOutputData self.validationInputData = validationInputData self.validationOutputData = validationOutputData self.spectralRadiusBound = spectralRadiusBound self.inputScalingBound = inputScalingBound self.reservoirScalingBound = reservoirScalingBound self.leakingRateBound = leakingRateBound self.reservoirTopology = reservoirTopology self.inputConnectivity = inputConnectivity #Create a echo state network esn = EchoStateNetwork.EchoStateNetwork( size=self.size, inputData=self.trainingInputData, outputData=self.trainingOutputData, reservoirTopology=self.reservoirTopology, inputConnectivity=self.inputConnectivity) self.inputWeightConn = esn.inputWeightRandom, esn.randomInputIndices self.reservoirWeightConn = esn.reservoirWeightRandom, esn.randomReservoirIndices
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 runScaleFree(): scaleFreeError = 0 testPredictedOutputDataScaleFree = 0 for i in range(runTimes): # Tune the scale free networks attachmentBound = (1, size - 1) esnTuner = tuner.ESNScaleFreeNetworksTuner( size=size, initialTransient=initialTransient, trainingInputData=trainingInputData, trainingOutputData=trainingOutputData, validationInputData=validationInputData, validationOutputData=validationOutputData, inputConnectivity=inputConnectivity, attachmentBound=attachmentBound, times=5) attachmentOptimum = esnTuner.getOptimalParameters() res = ESN.EchoStateNetwork( size=size, inputData=trainingInputData, outputData=trainingOutputData, reservoirTopology=topology.ScaleFreeNetworks( size=size, attachmentCount=attachmentOptimum), inputConnectivity=inputConnectivity) res.trainReservoir() #Warm up using training data trainingPredictedOutputData = res.predict(trainingInputData) #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) testPredictedOutputDataScaleFree = minMax.inverse_transform( testingPredictedOutputData) #Error scaleFreeError += errorFunction.compute( actual.reshape((actual.shape[0], 1)), testPredictedOutputDataScaleFree.reshape( (testPredictedOutputDataScaleFree.shape[0], 1))) return testPredictedOutputDataScaleFree, (scaleFreeError / runTimes)
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 __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): #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 __ESNTrain__(self, x): #Extract the parameters attachment = int(np.floor(x[0])) reservoirTopology = topology.ScaleFreeNetworks( size=self.size, attachmentCount=attachment) #print("\nOptimizing connectivity..") print("\nAttachment:" + str(attachment)) cumRMSE = 0 times = self.times for i in range(times): #Create the network esn = EchoStateNetwork.EchoStateNetwork( size=self.size, inputData=self.trainingInputData, outputData=self.trainingOutputData, reservoirTopology=reservoirTopology, inputConnectivity=self.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("\nRegression error:" + str(regressionError) + "\n") return regressionError
def __ESNTrain__(self, x): #Extract the parameters spectralRadius = x[0] leakingRate = x[1] #Create the reservoir esn = EchoStateNetwork.EchoStateNetwork( size=self.size, inputData=self.trainingInputData, outputData=self.trainingOutputData, spectralRadius=spectralRadius, leakingRate=leakingRate, initialTransient=self.initialTransient, inputWeightConn=self.inputWeightConn, reservoirWeightConn=self.reservoirWeightConn, reservoirTopology=topology.RandomTopology( self.size, self.reservoirConnectivityOptimum)) #Train the reservoir esn.trainReservoir() #Predict for the validation data predictedOutputData = esn.predict(self.validationInputData) #Calcuate the regression error errorFunction = rmse.MeanSquareError() regressionError = errorFunction.compute(self.validationOutputData, predictedOutputData) #Free the memory gc.collect() #Return the error #print("Optimizing spectral radius and leaking rate...") #print("\nRegression error"+str(regressionError)+"\n") return regressionError
trainingOutputData=trainingOutputData, validationInputData=validationInputData, validationOutputData=validationOutputData, spectralRadiusBound=spectralRadiusBound, inputScalingBound=inputScalingBound, reservoirScalingBound=reservoirScalingBound, leakingRateBound=leakingRateBound) spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightOptimum, reservoirWeightOptimum = resTuner.getOptimalParameters( ) #Train the reservoir with the optimal parameters res = reservoir.Reservoir(size=size, spectralRadius=spectralRadiusOptimum, inputScaling=inputScalingOptimum, reservoirScaling=reservoirScalingOptimum, leakingRate=leakingRateOptimum, initialTransient=initialTransient, inputData=trainingInputData, outputData=trainingOutputData, inputWeightRandom=inputWeightOptimum, reservoirWeightRandom=reservoirWeightOptimum) res.trainReservoir() # To predict the test data, predict training and valiadation data as a warm up trainingPredictedOutputData = res.predict(trainingInputData) #Now, start predicting the future xAxis = [] predictedOutput = [] lastDayIndex = rawData.shape[0] - 1 lastDay = date(int(availableData[lastDayIndex, 0]),
#Train the reservoir with optimal parameters esn = esn.EchoStateNetwork(size=size, inputData=inputTrainingData, outputData=outputTrainingData, reservoirTopology=topology, spectralRadius=spectralRadiusOptimum, inputScaling=inputScalingOptimum, reservoirScaling=reservoirScalingOptimum, leakingRate=leakingRateOptimum, initialTransient=initialTransient, inputConnectivity=inputConnectivity, inputWeightConn=inputWeightConn, reservoirWeightConn=reservoirConn) esn.trainReservoir() #Warm up for the trained data predictedTrainingOutputData = esn.predict(inputTrainingData) #Predict for future lastAvailablePoint = predictedTrainingOutputData[nTraining-1,0] testingPredictedOutputData = [] for i in range(nTesting): #Compose the query query = [1.0] query.append(lastAvailablePoint) #Predict the next point nextPoint = esn.predict(np.array(query).reshape(1,2))[0,0]
inputConnectivityBound = (0.1, 0.9) # Usually dense 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)
esnTuner = tuner.ESNScaleFreeNetworksTuner( size=size, initialTransient=initialTransient, trainingInputData=trainingInputData, trainingOutputData=trainingOutputData, validationInputData=trainingInputData, validationOutputData=trainingOutputData, inputConnectivityBound=inputConnectivityBound, attachmentBound=attachmentBound) inputConnectivityOptimum, attachmentOptimum = esnTuner.getOptimalParameters() network = esn.EchoStateNetwork(size=size, inputData=trainingInputData, outputData=trainingOutputData, reservoirTopology=topology.ScaleFreeNetworks( size=size, attachmentCount=attachmentOptimum), 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)
initialTransient=initialTransient, 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 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)
horizon = 1 tsp = ts.TimeSeriesProcessor(rawData, depth, horizon, 4) processedData = tsp.getProcessedData() inputData = np.hstack((np.ones((processedData.shape[0], 1)), processedData[:processedData.shape[0], :depth])) outputData = processedData[:processedData.shape[0], depth:depth + horizon] # Train inputWeightRandom = np.load("Outputs/inputWeight.npy") reservoirWeightRandom = np.load("Outputs/reservoirWeight.npy") res = reservoir.Reservoir(size=600, spectralRadius=1.25, inputScaling=0.50, reservoirScaling=0.50, leakingRate=0.20, initialTransient=0, inputData=inputData, outputData=outputData, inputWeightRandom=inputWeightRandom, reservoirWeightRandom=reservoirWeightRandom) res.trainReservoir() #Predict for past lastDayIndex = 0 lastDayValue = rawData[lastDayIndex, 4] xAxisPast = [] testPredictedOutputDataPast = [] testActualOutputDataPast = [] numberOfDaysInPast = rawData.shape[0] - 1 for i in range(numberOfDaysInPast):
# Pre-process the data and form feature and target vectors tsp = tsi.TimeSeriesIntervalProcessor(trainingSeries, featureIntervalList, targetIntervalList) featureVectors, targetVectors = tsp.getProcessedData() #Append bias to feature vectors featureVectors = np.hstack((np.ones( (featureVectors.shape[0], 1)), featureVectors)) #Train the reservoir with the optimal parameters size = 1500 initialTransient = 50 network = esn.EchoStateNetwork(size=size, inputData=featureVectors, outputData=targetVectors, reservoirTopology=topology.RandomTopology( size=size, connectivity=0.4), spectralRadius=0.79, inputConnectivity=0.8) network.trainReservoir() # #Tune and Train # spectralRadiusBound = (0.0, 1.0) # inputScalingBound = (0.0, 1.0) # reservoirScalingBound = (0.0, 1.0) # leakingRateBound = (0.0, 1.0) # inputConnectivityBound = (0.1,1.0) #Usually, densely connected # reservoirConnectivityBound = (0.1,0.9) #Usually, sparsely connected # size = 1000 # initialTransient = 5 # inputConnectivity = 0.7
import sys import os # add path of reservoir and import sys.path.append(os.path.join(os.path.dirname(__file__), '..')) from reservoir import EchoStateNetwork # reservoir RES_SIZE = 50 C_IN = 1.0 C_RES = 0.999 C_FB = 0.0 esn = EchoStateNetwork(1, RES_SIZE, 1, in_coef=C_IN, res_coef=C_RES, fb_coef=C_FB) # input sequence LEN = 20 us = np.random.choice([0, 1], LEN).astype(np.float32) # target sequence DELAY = 5 ys_target = np.array([np.nan for i in range(DELAY)] + [us[i] for i in range(LEN - DELAY)], dtype=np.float32) # inputting LEAK = 0.9
validationOutputData = trainingOutputData #Tune the reservoir spectralRadius = 0.5 inputScaling = 0.5 reservoirScaling = 0.5 leakingRate = 0.3 size = 500 initialTransient = 50 #Train the reservoir with the optimal parameters res1 = reservoir.Reservoir(size=size, spectralRadius=spectralRadius, inputScaling=inputScaling, reservoirScaling=reservoirScaling, leakingRate=leakingRate, initialTransient=initialTransient, inputData=trainingInputData, outputData=trainingOutputData) res1.trainReservoir() # To predict the test data, predict training and valiadation data as a warm up trainingPredictedOutputData = res1.predict(trainingInputData) #Now, start predicting the future xAxis = [] predictedOutput = [] lastDayIndex = rawData.shape[0] -1 lastDay = date(int(availableData[lastDayIndex, 0]), int(availableData[lastDayIndex, 1]), int(availableData[lastDayIndex, 2]))
testActualOutputData = data[nTraining + 1:nTraining + nTesting + 1].reshape( (nTesting, 1)) # Tune the network size = 256 initialTransient = 50 inputConnectivity = 0.8 reservoirConnectivity = 0.7 reservoirTopology = topology.RandomTopology(size=size, connectivity=reservoirConnectivity) res = ESN.EchoStateNetwork(size=size, inputData=inputTrainingData, outputData=outputTrainingData, reservoirTopology=reservoirTopology, spectralRadius=0.67, inputScaling=0.87, reservoirScaling=0.44, leakingRate=0.9, initialTransient=initialTransient, inputConnectivity=inputConnectivity) res.trainReservoir() #Warm up predictedTrainingOutputData = res.predict(inputTrainingData) #Predict future values predictedTestOutputData = [] lastAvailableData = testInputData[0, 1] for i in range(nTesting): query = [1.0] query.append(lastAvailableData)
trainingOutputData=targetVectors, validationInputData=featureVectors, validationOutputData=targetVectors, spectralRadiusBound=spectralRadiusBound, inputScalingBound=inputScalingBound, reservoirScalingBound=reservoirScalingBound, leakingRateBound=leakingRateBound) spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightOptimum, reservoirWeightOptimum = resTuner.getOptimalParameters( ) #Train the reservoir with the optimal parameters res = reservoir.Reservoir(size=size, spectralRadius=spectralRadiusOptimum, inputScaling=inputScalingOptimum, reservoirScaling=reservoirScalingOptimum, leakingRate=leakingRateOptimum, initialTransient=initialTransient, inputData=featureVectors, outputData=targetVectors, inputWeightRandom=inputWeightOptimum, reservoirWeightRandom=reservoirWeightOptimum) res.trainReservoir() #Predict for the training data as a warmup trainingPredictedOutputData = res.predict(featureVectors) #Now, start predicted the future nextDate = series.last_valid_index() predicted = [] xAxis = []
inputScalingBound=inputScalingBound, reservoirScalingBound=reservoirScalingBound, leakingRateBound=leakingRateBound, spectralRadiusBound=spectralRadiusBound, reservoirTopology=reservoirTopology, inputConnectivity=inputConnectivity) spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightConn, reservoirWeightConn = esnTuner.getOptimalParameters( ) res = ESN.EchoStateNetwork(size=size, inputData=inputTrainingData, outputData=outputTrainingData, reservoirTopology=reservoirTopology, spectralRadius=spectralRadiusOptimum, inputScaling=inputScalingOptimum, reservoirScaling=reservoirScalingOptimum, leakingRate=leakingRateOptimum, initialTransient=initialTransient, inputConnectivity=inputConnectivity, inputWeightConn=inputWeightConn, reservoirWeightConn=reservoirWeightConn) res.trainReservoir() #Warm up predictedTrainingOutputData = res.predict(inputTrainingData) #Predict future values predictedTestOutputData = [] lastAvailableData = testInputData[0, 1] for i in range(nTesting): query = [1.0]
import sys import os # add path of reservoir and import sys.path.append(os.path.join(os.path.dirname(__file__), '..')) from reservoir import EchoStateNetwork # reservoir RES_SIZE = 50 C_IN = 0.5 C_RES = 0.999 C_FB = 0.0 esn = EchoStateNetwork(1, RES_SIZE, 1, in_coef=C_IN, res_coef=C_RES, fb_coef=C_FB) # input sequence LEN = 20 us = np.random.uniform(-1, 1, LEN).astype(np.float32) # target sequence (NARMA2) ALPHA = 0.4 BETA = 0.4 GAMMA = 0.6 DELTA = 0.1 ys_target = np.zeros(us.shape, us.dtype) for i in range(2, us.shape[0]): ys_target[i] = ALPHA * ys_target[i - 1] + BETA * ys_target[