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 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 __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()
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 60% connected
inputWeight = topology.RandomInputTopology(
inputSize=inputTrainingData.shape[1],
reservoirSize=size,
inputConnectivity=1.0).generateWeightMatrix()
# Reservoir-to-reservoir 50% connected
reservoirWeight = topology.RandomReservoirTopology(
size=size, connectivity=0.92).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,
# Remove the outliers
resampledSeries = util.detectAndRemoveOutliers(resampledSeries)
# Step 3 - Rescale the series
normalizedSeries = util.scaleSeriesStandard(resampledSeries)
del resampledSeries
# Step 4 - Split the data into training and testing series
trainingSeries, testingSeries = util.splitIntoTrainingAndTestingSeries(normalizedSeries, horizon)
# Step 4 - Form feature and target vectors
featureVectors, targetVectors = util.formContinousFeatureAndTargetVectors(trainingSeries, depth)
# Input-to-reservoir fully connected
size = 2000
inputConnMatrix = topology.RandomInputTopology(inputSize=featureVectors.shape[1], reservoirSize=size, inputConnectivity=0.7).generateConnectivityMatrix()
correlationMatrix = util.getCorrelationMatrix(featureVectors, targetVectors, size)
inputWeightMatrix = inputConnMatrix * correlationMatrix
# Reservoir-to-reservoir fully connected
reservoirWeight = topology.RandomReservoirTopology(size=size, connectivity=0.4).generateWeightMatrix()
res = ESN.Reservoir(size=size,
inputData=featureVectors,
outputData=targetVectors,
spectralRadius=0.85,
inputScaling=0.0019,
reservoirScaling=0.07,
leakingRate=0.17,
initialTransient=0,
