def createNeuralNetwork(self, hiddenArr):
l_rate = None
self.nn = NeuralNetwork()
self.nn.appendLayer(
Layer(self.bounds,
size=len(self.training[0][0]),
prev=None,
l_rate=l_rate,
bias=True,
label="Input layer"))
for i in hiddenArr:
prevLayer = self.nn.layers[len(self.nn.layers) - 1]
self.nn.appendLayer(
Layer(self.bounds,
size=i,
prev=prevLayer,
l_rate=l_rate,
bias=True,
label="Hidden layer"))
prevLayer = self.nn.layers[len(self.nn.layers) - 1]
self.nn.appendLayer(
Layer(self.bounds,
size=len(self.training[0][1]),
prev=prevLayer,
l_rate=l_rate,
bias=False,
label="Output layer"))
bias=True,
label="Input layer")
hiddenLayer = Layer(bounds,
size=8,
prev=inputLayer,
l_rate=l_rate,
bias=True,
label="Hidden layer")
outputLayer = Layer(bounds,
size=len(training[0][1]),
prev=hiddenLayer,
l_rate=l_rate,
bias=False,
label="Output layer")
fnn = NeuralNetwork()
fnn.appendLayer(inputLayer)
fnn.appendLayer(hiddenLayer)
fnn.appendLayer(outputLayer)
group_training = np.array([input[0] for input in training])
group_target = np.array([output[1] for output in training])
errors = []
for i in range(8000):
mod = i % len(training)
in_out = training[mod]
fnn.fire(group_training)
i_error = fnn.backPropagation(group_target)
bias=True,
label="Input layer")
hiddenLayer = Layer(bounds,
size=12,
prev=inputLayer,
l_rate=l_rate,
bias=True,
label="Hidden layer")
outputLayer = Layer(bounds,
size=len(training[0][1]),
prev=hiddenLayer,
l_rate=l_rate,
bias=False,
label="Output layer")
fnn = NeuralNetwork()
fnn.appendLayer(inputLayer)
fnn.appendLayer(hiddenLayer)
fnn.appendLayer(outputLayer)
group_training = np.array([input[0] for input in training])
group_target = np.array([output[1] for output in training])
errors = []
plt.grid(1)
plt.xlabel('Iterations')
plt.ylabel('Error')
plt.ylim([0, 1])
plt.ion()
class VNPSONN(object):
def __init__(self):
self.nn = None
self.pso = None
self.bounds = None
self.training = None
self.generalization = None
self.testing = None
self.num_particles_x = None
self.num_particles_y = None
self.inertia_weight = None
self.cognitiveConstant = None
self.socialConstant = None
self.vmax = None
self.numberGenerator = None
self.batch_training_input = None
self.batch_training_target = None
self.color = None
def createNeuralNetwork(self, hiddenArr):
l_rate = None
self.nn = NeuralNetwork()
self.nn.appendLayer(
Layer(self.bounds,
size=len(self.training[0][0]),
prev=None,
l_rate=l_rate,
bias=True,
label="Input layer"))
for i in hiddenArr:
prevLayer = self.nn.layers[len(self.nn.layers) - 1]
self.nn.appendLayer(
Layer(self.bounds,
size=i,
prev=prevLayer,
l_rate=l_rate,
bias=True,
label="Hidden layer"))
prevLayer = self.nn.layers[len(self.nn.layers) - 1]
self.nn.appendLayer(
Layer(self.bounds,
size=len(self.training[0][1]),
prev=prevLayer,
l_rate=l_rate,
bias=False,
label="Output layer"))
def train(self, iterations):
self.pso = PSO(self.bounds,
self.num_particles_x * self.num_particles_y,
self.inertia_weight, self.cognitiveConstant,
self.socialConstant)
self.batch_training_input = np.array(
[input[0] for input in self.training])
self.batch_training_target = np.array(
[output[1] for output in self.training])
self.batch_generalization_input = np.array(
[input[0] for input in self.generalization])
self.batch_generalization_target = np.array(
[output[1] for output in self.generalization])
self.num_dimensions = len(self.nn.getAllWeights())
# Create particles
if isinstance(self.numberGenerator, CPRNG):
for i in range(self.num_particles_x):
row = []
for j in range(self.num_particles_y):
particle = ChaoticParticle(self.bounds,
self.numberGenerator,
self.inertia_weight,
self.cognitiveConstant,
self.socialConstant)
particle.initPos(
(self.bounds.maxBound - self.bounds.minBound) *
np.random.random(self.num_dimensions) +
self.bounds.minBound)
row.append(particle)
self.pso.swarm.append(row)
else:
for i in range(self.num_particles_x):
row = []
for j in range(self.num_particles_y):
particle = Particle(self.bounds, self.inertia_weight,
self.cognitiveConstant,
self.socialConstant)
particle.initPos(
(self.bounds.maxBound - self.bounds.minBound) *
np.random.random(self.num_dimensions) +
self.bounds.minBound)
row.append(particle)
self.pso.swarm.append(row)
for i in range(self.num_particles_x):
for j in range(self.num_particles_y):
if i > 0: # We can go west
self.pso.swarm[i][j].neighbourhood.append(
self.pso.swarm[i - 1][j])
if i < self.num_particles_x - 1: # We can go east
self.pso.swarm[i][j].neighbourhood.append(
self.pso.swarm[i + 1][j])
if j > 0: # We can go north
self.pso.swarm[i][j].neighbourhood.append(
self.pso.swarm[i][j - 1])
if j < self.num_particles_y - 1: # We can go south
self.pso.swarm[i][j].neighbourhood.append(
self.pso.swarm[i][j + 1])
trainingErrors = []
plt.grid(1)
plt.xlabel('Iterations')
plt.ylabel('Error')
plt.ylim([0, 1])
plt.ion()
# Iterate over training data
for x in range(iterations):
# Loop over particles
for i, row in enumerate(self.pso.swarm):
for j, col in enumerate(row):
# Set weights according to pso particle
self.nn.setAllWeights(self.pso.swarm[i][j].position)
result = self.nn.fire(np.array(self.batch_training_input))
difference = self.batch_training_target - result
error = np.mean(np.square(difference))
self.pso.swarm[i][j].error = error
# Get & set personal best
self.pso.swarm[i][j].getPersonalBest()
self.pso.group_best_position = None
self.pso.group_best_error = float('inf')
for i, row in enumerate(self.pso.swarm):
for j, col in enumerate(row):
particle = self.pso.swarm[i][j]
neighbourhoodBest = particle.error
neighbourhoodBestPos = particle.position
for neighbour in particle.neighbourhood:
if abs(neighbour.error) < abs(neighbourhoodBest):
neighbourhoodBestPos = np.array(neighbour.position)
neighbourhoodBest = neighbour.error
# Get current global best for this iteration
if abs(particle.error) < abs(self.pso.group_best_error):
self.pso.group_best_position = np.array(
particle.position)
self.pso.group_best_error = particle.error
# Get overall global best as well
if abs(particle.error) < abs(self.pso.best_error):
self.pso.best_position = np.array(particle.position)
self.pso.best_error = particle.error
self.pso.swarm[i][j].update_velocity(neighbourhoodBestPos)
self.pso.swarm[i][j].update_position(self.vmax)
if (x % 100 == 0):
trainingErrors.append([self.pso.best_error, x])
plt.scatter(x,
self.pso.best_error,
color=self.color,
s=4,
label="test1")
plt.pause(0.0001)
plt.show()
correct = 0
self.nn.setAllWeights(self.pso.best_position)
result = self.nn.fire(np.array(self.batch_training_input))
difference = self.batch_training_target - result
trainingError = np.mean(np.square(difference))
trainingErrors.append([trainingError, 5000])
result = self.nn.fire(np.array(self.batch_generalization_input))
difference = self.batch_generalization_target - result
generalizationError = np.mean(np.square(difference))
for i in range(len(self.generalization)):
in_out = self.generalization[i]
result = self.nn.fire(np.array([in_out[0]]))
if np.argmax(result) == np.argmax(in_out[1]):
correct += 1
print("Classification accuracy: ")
print(str(correct / len(self.generalization)))
return trainingErrors, trainingError, generalizationError
training = []
for x, y in zip(input, target):
training.append((x, y))
# Get data set
dataSetTool = DataSetTool()
psonn.training, psonn.testing = training, training
psonn.bounds = Bounds(-5, 5)
# Create neural network
l_rate = None
inputLayer = Layer(psonn.bounds, size = 2, prev = None, l_rate = l_rate, bias = True, label = "Input layer")
hiddenLayer = Layer(psonn.bounds, size = 4, prev = inputLayer, l_rate = l_rate, bias = True, label = "Hidden layer")
outputLayer = Layer(psonn.bounds, size = 1, prev = hiddenLayer, l_rate = l_rate, bias = False, label = "Output layer")
psonn.nn = NeuralNetwork()
psonn.nn.appendLayer(inputLayer)
psonn.nn.appendLayer(hiddenLayer)
psonn.nn.appendLayer(outputLayer)
# Create the pso with the nn weights
psonn.num_particles = 20
psonn.inertia_weight = 0.729
psonn.cognitiveConstant = 1.49445
psonn.socialConstant = 1.49445
psonn.train()
print("FIRE: " + str(psonn.nn.fire(np.array([input[0]]))))
print("FIRE: " + str(psonn.nn.fire(np.array([input[1]]))))
print("FIRE: " + str(psonn.nn.fire(np.array([input[2]]))))
class PSONN(object):
def __init__(self):
self.nn = None
self.pso = None
self.bounds = None
self.training = None
self.testing = None
self.num_particles = None
self.inertia_weight = None
self.cognitiveConstant = None
self.socialConstant = None
self.vmax = None
self.numberGenerator = None
self.batch_training_input = None
self.batch_training_target = None
def createNeuralNetwork(self, hiddenArr):
l_rate = None
self.nn = NeuralNetwork()
self.nn.appendLayer(Layer(self.bounds, size=len(self.training[0][0]), prev=None, l_rate=l_rate, bias=True,
label="Input layer"))
for i in hiddenArr:
prevLayer = self.nn.layers[len(self.nn.layers) - 1]
self.nn.appendLayer(Layer(self.bounds, size=i, prev=prevLayer, l_rate=l_rate, bias=True, label="Hidden layer"))
prevLayer = self.nn.layers[len(self.nn.layers) - 1]
self.nn.appendLayer(Layer(self.bounds, size=len(self.training[0][1]), prev=prevLayer, l_rate=l_rate, bias=False, label="Output layer"))
def train(self):
self.pso = PSO(self.bounds, self.num_particles, self.inertia_weight, self.cognitiveConstant, self.socialConstant)
self.batch_training_input = np.array([input[0] for input in self.training])
self.batch_training_target = np.array([output[1] for output in self.training])
self.num_dimensions = len(self.nn.getAllWeights())
# Create particles
if isinstance(self.numberGenerator, CPRNG):
for i in range(self.pso.num_particles):
self.pso.swarm.append(ChaoticParticle(self.bounds, self.numberGenerator, self.inertia_weight, self.cognitiveConstant, self.socialConstant))
self.pso.swarm[i].initPos((self.bounds.maxBound - self.bounds.minBound) * np.random.random(self.num_dimensions) + self.bounds.minBound)
else:
for i in range(self.pso.num_particles):
self.pso.swarm.append(Particle(self.bounds, self.inertia_weight, self.cognitiveConstant, self.socialConstant))
self.pso.swarm[i].initPos((self.bounds.maxBound - self.bounds.minBound) * np.random.random(self.num_dimensions) + self.bounds.minBound)
self.batch_training_input = np.array([input[0] for input in self.training])
self.batch_training_target = np.array([output[1] for output in self.training])
errors = []
plt.grid(1)
plt.xlabel('Iterations')
plt.ylabel('Error')
plt.ylim([0, 1])
plt.ion()
# Iterate over training data
for i in range(8000):
# Get the iteration data
mod = i % len(self.training)
in_out = self.training[mod]
# Loop over particles
for j in range(self.pso.num_particles):
# Set weights according to pso particle
self.nn.setAllWeights(self.pso.swarm[j].position)
result = self.nn.fire(np.array(self.batch_training_input))
difference = self.batch_training_target - result
error = np.mean(np.square(difference))
errors.append(error)
self.pso.swarm[j].error = error
# Get & set personal best
self.pso.swarm[j].getPersonalBest()
# Print results
# print(j, np.array(self.pso.swarm[j].error))
# Get & set global best
self.pso.getGlobalBest()
for j in range(self.pso.num_particles):
self.pso.swarm[j].update_velocity(self.pso.group_best_position)
self.pso.swarm[j].update_position(self.vmax)
if (i % 53 == 0):
plt.scatter(i, self.pso.best_error, color='blue', s=4, label="test1")
plt.pause(0.0001)
plt.show()
print("Best error:\t\t\t" + str(self.pso.group_best_error))
print("Current best error:\t" + str(self.pso.best_error) + "\n")
correct = 0
for i in range(len(self.testing)):
in_out = self.testing[i]
result = self.nn.fire(np.array([in_out[0]]))
print(result)
print(in_out[1])
print()
if np.argmax(result) == np.argmax(in_out[1]):
correct += 1
print("Classification accuracy: ", str(100 * (correct / len(self.testing)) ) + "%")
return errors
bias=True,
label="Input layer")
hiddenLayer = Layer(bounds,
size=4,
prev=inputLayer,
l_rate=l_rate,
bias=True,
label="Hidden layer")
outputLayer = Layer(bounds,
size=1,
prev=hiddenLayer,
l_rate=l_rate,
bias=False,
label="Output layer")
fnn = NeuralNetwork()
fnn.appendLayer(inputLayer)
fnn.appendLayer(hiddenLayer)
fnn.appendLayer(outputLayer)
input = np.array([[0, 0], [1, 0], [0, 1], [1, 1]])
target = np.array([[0], [1], [1], [0]])
errors = []
for i in range(20000):
mod = i % 4
i_input = np.array([input[mod]])
fnn.fire(input)
i_target = np.array([target[mod]])