def trainAndGetError(size, spectralRadius, inputScaling, reservoirScaling,
leakingRate, initialTransient, trainingInputData,
trainingOutputData, inputWeightMatrix,
reservoirWeightMatrix, validationOutputData, horizon,
testingActualOutputData):
# Error function
errorFun = metrics.MeanSquareError()
# 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]
# Calculate the error
error = errorFun.compute(testingActualOutputData, predictedOutputData)
return error
def __reservoirTrain__(self, x):
#Extract the parameters
spectralRadius = x[0]
inputScaling = x[1]
reservoirScaling = x[2]
leakingRate = x[3]
#Create the reservoir
res = classicESN.Reservoir(
size=self.size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=self.initialTransient,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
inputWeightRandom=self.inputWeightRandom,
reservoirWeightRandom=self.reservoirWeightRandom)
#Train the reservoir
res.trainReservoir()
#Predict for the validation data
predictedOutputData = res.predict(self.validationInputData)
#Calcuate the regression error
errorFunction = rmse.MeanSquareError()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
#Return the error
return regressionError
def __reservoirTrain__(self, x):
#Extract the parameters
meanDegree, beta = x
meanDegree = int(meanDegree)
# To get rid off the randomness in assigning weights, run it 10 times and take the average error
times = 100
cumulativeError = 0
for i in range(times):
# Input and weight connectivity Matrix
inputWeightMatrix = topology.ClassicInputTopology(
self.inputD, self.size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=self.size, meanDegree=meanDegree,
beta=beta).generateWeightMatrix()
#Create the reservoir
res = classicESN.Reservoir(
size=self.size,
spectralRadius=self.spectralRadius,
inputScaling=self.inputScaling,
reservoirScaling=self.reservoirScaling,
leakingRate=self.leakingRate,
initialTransient=self.initialTransient,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
inputWeightRandom=inputWeightMatrix,
reservoirWeightRandom=reservoirWeightMatrix)
#Train the reservoir
res.trainReservoir()
# Warm up
predictedTrainingOutputData = res.predict(
self.trainingInputData[-self.initialTransient:])
#Predict for the validation data
predictedOutputData = util.predictFuture(res, self.initialSeed,
self.horizon)
gc.collect()
#Calcuate the regression error
errorFunction = metrics.MeanSquareError()
error = errorFunction.compute(self.validationOutputData,
predictedOutputData)
cumulativeError += error
regressionError = cumulativeError / times
#Return the error
print("\nThe Parameters: " + str(x) + " Regression error:" +
str(regressionError))
return regressionError
def evaluate(self, x):
# Extract the parameters
attachment = int(x[0, 0])
# To get rid off the randomness in assigning weights, run it 10 times and take the average error
times = 1
cumulativeError = 0
for i in range(times):
# Input and weight connectivity Matrix
inputWeightMatrix = topology.ClassicInputTopology(
self.inputD, self.size).generateWeightMatrix()
network = topology.ScaleFreeNetworks(size=self.size,
attachmentCount=attachment)
reservoirWeightMatrix = network.generateWeightMatrix()
# Create the reservoir
res = esn.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()
# Calculate the regression error
errorFunction = metrics.MeanSquareError()
error = errorFunction.compute(self.validationOutputData,
predictedOutputData)
cumulativeError += error
regressionError = cumulativeError / times
# Return the error
#print("Attachment: "+str(attachment) + "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 tuneTrainPredictGA(trainingInputData, trainingOutputData, validationOutputData,
initialInputSeedForValidation, testingData, size = 256,initialTransient=50,
spectralRadiusBound=(0.0,1.0),
inputScalingBound=(0.0,1.0),
reservoirScalingBound=(0.0,1.0),
leakingRateBound=(0.0,1.0),
reservoirTopology=None):
# Generate the input and reservoir weight matrices based on the reservoir topology
inputWeightMatrix = topology.ClassicInputTopology(inputSize=trainingInputData.shape[1], reservoirSize=size).generateWeightMatrix()
if reservoirTopology is None:
reservoirWeightMatrix = topology.ClassicReservoirTopology(size=size).generateWeightMatrix()
else: #TODO - think about matrix multiplication
reservoirWeightMatrix = reservoirTopology.generateWeightMatrix()
resTuner = tuner.ReservoirParameterTuner(size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadiusBound=spectralRadiusBound,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix)
spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum = resTuner.getOptimalParameters()
#Train
network = esn.Reservoir(size=size,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
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, testingData.shape[0])[:,0]
return predictedOutputData
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 __reservoirTrain__(self, x):
#Extract the parameters
spectralRadius = x[0]
inputScaling = x[1]
reservoirScaling = x[2]
leakingRate = x[3]
#Create the reservoir
res = classicESN.Reservoir(
size=self.size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=self.initialTransient,
inputData=self.trainingInputData,
outputData=self.trainingOutputData,
inputWeightRandom=self.inputWeightRandom,
reservoirWeightRandom=self.reservoirWeightRandom)
#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()
regressionError = errorFunction.compute(self.validationOutputData,
predictedOutputData)
#Return the error
print("\nThe Parameters: " + str(x) + " Regression error:" +
str(regressionError))
return regressionError
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 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()
arbitraryDepth=depth,
spectralRadiusBound=(0.0,1.25),
inputScalingBound=(0.0,1.0),
reservoirScalingBound=(0.0,1.0),
leakingRateBound=(0.0,1.0),
inputWeightMatrix=inputWeight,
reservoirWeightMatrix=reservoirWeight)
spectralRadiusOptimum, inputScalingOptimium, reservoirScalingOptimum, leakingRateOptimum = tuner.getOptimalParameters()
res = ESN.Reservoir(size=size,
inputData=featureVectors,
outputData=targetVectors,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimium,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
initialTransient=0,
inputWeightRandom=inputWeight,
reservoirWeightRandom=reservoirWeight)
res.trainReservoir()
# Warm up
predictedTrainingOutputData = res.predict(featureVectors[:initialTransient])
# Predict the future
predictedTestingOutputData = util.predictFutureDays(res, trainingSeries, depth, horizon)
error = metrics.RootMeanSquareError().compute(testingSeries.values.flatten().reshape(horizon,1), predictedTestingOutputData.values.flatten().reshape(horizon,1))
print("Regression error:"+str(error))
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 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
def tuneTrainPredict(trainingInputData,
trainingOutputData,
validationOutputData,
initialInputSeedForValidation,
testingData,
size=256,
initialTransient=50,
spectralRadiusBound=(0.0, 1.0),
inputScalingBound=(0.0, 1.0),
reservoirScalingBound=(0.0, 1.0),
leakingRateBound=(0.0, 1.0),
reservoirTopology=None):
# Generate the input and reservoir weight matrices based on the reservoir topology
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
if reservoirTopology is None:
reservoirWeightMatrix = topology.ClassicReservoirTopology(
size=size).generateWeightMatrix()
else: #TODO - think about matrix multiplication
reservoirWeightMatrix = reservoirTopology.generateWeightMatrix()
resTuner = tuner.ReservoirParameterTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadiusBound=spectralRadiusBound,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
minimizer=tuner.Minimizer.DifferentialEvolution)
spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum = resTuner.getOptimalParameters(
)
#Train
network = ESN.Reservoir(size=size,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
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,
testingData.shape[0])[:, 0]
cumError = 0
times = 100
for i in range(times):
# Run for many time and get the average regression error
regressionError = util.trainAndGetError(
size=size,
spectralRadius=spectralRadiusOptimum,
inputScaling=inputScalingOptimum,
reservoirScaling=reservoirScalingOptimum,
leakingRate=leakingRateOptimum,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=testingData.shape[0],
testingActualOutputData=testingData)
cumError += regressionError
error = cumError / times
return predictedOutputData, error
initialTransient = 50
# Input-to-reservoir fully connected
inputWeight = topology.ClassicInputTopology(
inputSize=inputTrainingData.shape[1],
reservoirSize=size).generateWeightMatrix()
# Reservoir-to-reservoir fully connected
reservoirWeight = topology.ClassicReservoirTopology(
size=size).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)
#Predict future values
predictedTestOutputData = util.predictFuture(res, trainingData[-1], nTesting)
#Calculate the error
errorFunction = rmse.MeanSquareError()
error = errorFunction.compute(testingData, predictedTestOutputData)
size = 100
inputWeight = topology.ClassicInputTopology(
inputSize=featureVectors.shape[1],
reservoirSize=size).generateWeightMatrix()
# Reservoir-to-reservoir fully connected
#reservoirWeight = topology.ClassicReservoirTopology(size=size).generateWeightMatrix()
reservoirWeight = topology.SmallWorldGraphs(size=size,
meanDegree=int(size / 2),
beta=0.8).generateWeightMatrix()
res = ESN.Reservoir(size=size,
inputData=featureVectors,
outputData=targetVectors,
spectralRadius=1.5,
inputScaling=0.1,
reservoirScaling=0.5,
leakingRate=0.7,
initialTransient=0,
inputWeightRandom=inputWeight,
reservoirWeightRandom=reservoirWeight)
res.trainReservoir()
#Warm up
predictedTrainingOutputData = res.predict(featureVectors)
predictedSeries = pd.Series(
data=predictedTrainingOutputData.flatten(),
index=normalizedSeries.index[-predictedTrainingOutputData.shape[0]:])
predictedSeries = util.descaleSeries(predictedSeries)
actualSeries = util.descaleSeries(normalizedSeries)
trainingOutputData=trainingOutputData,
validationInputData=validationInputData,
validationOutputData=validationOutputData,
spectralRadiusBound=spectralRadiusBound,
inputScalingBound=inputScalingBound,
reservoirScalingBound=reservoirScalingBound,
leakingRateBound=leakingRateBound)
spectralRadiusOptimum, inputScalingOptimum, reservoirScalingOptimum, leakingRateOptimum, inputWeightOptimum, reservoirWeightOptimum = resTuner.getOptimalParameters(
)
#Train
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()
#Warm up
predictedTrainingOutputData = res.predict(validationInputData)
# Predict
predictedTestOutputData = util.predictFuture(res, validationData[-1], nTesting)
#Plotting of the prediction output and error
outplot = outputPlot.OutputPlot("Outputs/Prediction.html",
"Mackey-Glass Time Series",
