def __init__(self,
size,
initialTransient,
trainingInputData,
trainingOutputData,
initialSeed,
validationOutputData,
reservoirConnectivityBound=(0.1, 1.0),
minimizer=Minimizer.DifferentialEvolution,
initialGuess=0.5,
spectralRadius=0.79,
inputScaling=0.5,
reservoirScaling=0.5,
leakingRate=0.3):
self.size = size
self.initialTransient = initialTransient
self.trainingInputData = trainingInputData
self.trainingOutputData = trainingOutputData
self.initialSeed = initialSeed
self.validationOutputData = validationOutputData
self.reservoirConnectivityBound = reservoirConnectivityBound
self.horizon = self.validationOutputData.shape[0]
self.minimizer = minimizer
self.initialGuess = np.array([initialGuess])
# Input-to-reservoir is of Classic Type - Fully connected and maintained as constant
self.inputN, self.inputD = self.trainingInputData.shape
self.inputWeight = topology.ClassicInputTopology(
self.inputD, self.size).generateWeightMatrix()
# Other reservoir parameters are also kept constant
self.spectralRadius = spectralRadius
self.inputScaling = inputScaling
self.reservoirScaling = reservoirScaling
self.leakingRate = leakingRate
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 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
# Step 3 - Rescale the series
normalizedSeries = util.scaleSeriesStandard(resampledSeries)
del resampledSeries
# Step 4 - Form feature and target vectors
depth = 1
featureVectors, targetVectors = util.formContinousFeatureAndTargetVectorsInOrder(
normalizedSeries, depth)
n = featureVectors.shape[0]
# Input-to-reservoir fully connected
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,
data = data[:5000].reshape((5000, 1))
# Number of points - 5000
trainingData, testingData = util.splitData2(data, 0.4)
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 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,
# Split training and testing
horizon = 300
training_data, testing_data = split_into_training_and_testing(data, horizon)
# Form feature vectors
input_training, output_training = form_feature_vectors(training_data)
# Train an echo state network
size = 500
initial_transient = 50
reg_factor = 1e-4
leaking_rate = 0.3
spectral_radius = 0.79
# Input-to-reservoir fully connected
input_weight = topology.ClassicInputTopology(inputSize=input_training.shape[1], reservoirSize=size).generateWeightMatrix(scaling=1.0)
# Reservoir-to-reservoir fully connected
reservoir_weight = topology.ClassicReservoirTopology(size=size).generateWeightMatrix(scaling=1.0)
# Plot variables to hold data for comparison
plot_names = []
predicted = []
plot_names.append("actual")
predicted.append(testing_data)
# Train full batch - classic closed form solution
res = ESN.Reservoir(size=size,
input_data=torch.from_numpy(input_training.T),
output_data=torch.from_numpy(output_training.T),
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 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
def tuneConnectivity(trainingInputData,
trainingOutputData,
validationOutputData,
initialInputSeedForValidation,
horizon,
testingActualOutputData,
size=256,
initialTransient=50,
resTopology=Topology.Classic):
# Other reservoir parameters
spectralRadius = 0.79
inputScaling = 0.5
reservoirScaling = 0.5
leakingRate = 0.3
# Optimal Parameters List
optimalParameters = {}
if (resTopology == Topology.Classic):
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ClassicReservoirTopology(
size=size).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.Random):
resTuner = tuner.RandomConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
reservoirConnectivityOptimum = resTuner.getOptimalParameters()
optimalParameters[
"Optimal_Reservoir_Connectivity"] = reservoirConnectivityOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.RandomReservoirTopology(
size=size, connectivity=reservoirConnectivityOptimum
).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.ErdosRenyi):
resTuner = tuner.ErdosRenyiConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
probabilityOptimum = resTuner.getOptimalParameters()
optimalParameters[
"Optimal_Connectivity_Probability"] = probabilityOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ErdosRenyiTopology(
size=size,
probability=probabilityOptimum).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.ScaleFreeNetworks):
resTuner = tuner.ScaleFreeNetworksConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
attachmentOptimum = resTuner.getOptimalParameters()
optimalParameters[
"Optimal_Preferential_Attachment"] = attachmentOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.ScaleFreeNetworks(
size=size,
attachmentCount=attachmentOptimum).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
elif (resTopology == Topology.SmallWorldGraphs):
resTuner = tuner.SmallWorldGraphsConnectivityBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
meanDegreeOptimum, betaOptimum = resTuner.getOptimalParameters()
optimalParameters["Optimal_MeanDegree"] = meanDegreeOptimum
optimalParameters["Optimal_Beta"] = betaOptimum
# Run 100 times and get the average regression error
iterations = 1000
cumulativeError = 0.0
for i in range(iterations):
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=size, meanDegree=int(meanDegreeOptimum),
beta=betaOptimum).generateWeightMatrix()
error = trainAndGetError(
size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
inputWeightMatrix=inputWeightMatrix,
reservoirWeightMatrix=reservoirWeightMatrix,
validationOutputData=validationOutputData,
horizon=horizon,
testingActualOutputData=testingActualOutputData)
# Calculate the error
cumulativeError += error
return cumulativeError / iterations, optimalParameters
def tuneTrainPredictConnectivityNonBrute(trainingInputData,
trainingOutputData,
validationOutputData,
initialInputSeedForValidation,
horizon,
size=256,
initialTransient=50,
resTopology=Topology.Random):
# Other reservoir parameters
spectralRadius = 0.79
inputScaling = 0.5
reservoirScaling = 0.5
leakingRate = 0.3
if (resTopology == Topology.Random):
resTuner = tuner.RandomConnectivityTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
reservoirConnectivityOptimum = resTuner.getOptimalParameters()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.RandomReservoirTopology(
size=size,
connectivity=reservoirConnectivityOptimum).generateWeightMatrix()
elif (resTopology == Topology.SmallWorldGraphs):
resTuner = tuner.SmallWorldGraphsConnectivityNonBruteTuner(
size=size,
initialTransient=initialTransient,
trainingInputData=trainingInputData,
trainingOutputData=trainingOutputData,
initialSeed=initialInputSeedForValidation,
validationOutputData=validationOutputData,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate)
meanDegreeOptimum, betaOptimum = resTuner.getOptimalParameters()
inputWeightMatrix = topology.ClassicInputTopology(
inputSize=trainingInputData.shape[1],
reservoirSize=size).generateWeightMatrix()
reservoirWeightMatrix = topology.SmallWorldGraphs(
size=size, meanDegree=int(meanDegreeOptimum),
beta=betaOptimum).generateWeightMatrix()
#Train
network = ESN.Reservoir(size=size,
spectralRadius=spectralRadius,
inputScaling=inputScaling,
reservoirScaling=reservoirScaling,
leakingRate=leakingRate,
initialTransient=initialTransient,
inputData=trainingInputData,
outputData=trainingOutputData,
inputWeightRandom=inputWeightMatrix,
reservoirWeightRandom=reservoirWeightMatrix)
network.trainReservoir()
warmupFeatureVectors, warmTargetVectors = formFeatureVectors(
validationOutputData)
predictedWarmup = network.predict(warmupFeatureVectors[-initialTransient:])
initialInputSeedForTesing = validationOutputData[-1]
predictedOutputData = predictFuture(network, initialInputSeedForTesing,
horizon)[:, 0]
return predictedOutputData
