def main(train, test, out): TRAIN_FILE = train TEST_FILE = test OUT_FILE = out img = Image.open(TRAIN_FILE) # read double moons image from .png file pixels = img.load() # generate pixel map width = img.size[0] height = img.size[1] training_set = dict() for i in range(width): for j in range(height): if pixels[i,j] == BLUE: # if pixel is blue training_set[i,j] = BOT # set value to bottom elif pixels[i,j] == RED: # if pixel is red training_set[i,j] = TOP # set value to top # create neuron with 2 input nodes n = Neuron(2) # x-input, y-input print "Neuron created." # training print "Training..." counter = 0 while True: errors = 0 for p in training_set: errors += n.train_step(p, training_set[p]) counter += 1 print "=====" if errors < n.get_margin() * len(training_set): break print "Length of training set: " + str(len(training_set)) print "Iterations: " + str(counter) # test cases img = Image.open(TEST_FILE) pixels = img.load() width = img.size[0] height = img.size[1] for i in range(width): for j in range(height): if pixels[i,j] == BLACK: n.set_input(0, i) n.set_input(1, j) n.activate() ans = n.get_output() if ans == TOP: pixels[i,j] = RED elif ans == BOT: pixels[i,j] = BLUE img.save(OUT_FILE, "PNG")
def main(train, test, out): TRAIN_FILE = train TEST_FILE = test OUT_FILE = out img = Image.open(TRAIN_FILE) # read double moons image from .png file pixels = img.load() # generate pixel map width = img.size[0] height = img.size[1] training_set = dict() for i in range(width): for j in range(height): if pixels[i, j] == BLUE: # if pixel is blue training_set[i, j] = BOT # set value to bottom elif pixels[i, j] == RED: # if pixel is red training_set[i, j] = TOP # set value to top # create neuron with 2 input nodes n = Neuron(2) # x-input, y-input print "Neuron created." # training print "Training..." counter = 0 while True: errors = 0 for p in training_set: errors += n.train_step(p, training_set[p]) counter += 1 print "=====" if errors < n.get_margin() * len(training_set): break print "Length of training set: " + str(len(training_set)) print "Iterations: " + str(counter) # test cases img = Image.open(TEST_FILE) pixels = img.load() width = img.size[0] height = img.size[1] for i in range(width): for j in range(height): if pixels[i, j] == BLACK: n.set_input(0, i) n.set_input(1, j) n.activate() ans = n.get_output() if ans == TOP: pixels[i, j] = RED elif ans == BOT: pixels[i, j] = BLUE img.save(OUT_FILE, "PNG")
class Network: """ Represents a neural network using sigmoidal activations. """ def __init__(self, layerCounts, activation=sigmoid.Tanh): """Constructs a neural network with a set of layers. >>> n = Network([2,3,2]) >>> len(n.neurons) 3 >>> len(n.neurons[0]) 2 >>> len(n.neurons[1]) 3 >>> len(n.neurons[2]) 2 >>> len(n.connections) 2 >>> len(n.connections[0]) 9 >>> len(n.connections[1]) 8 """ self.bias = Neuron(sigmoid.Constant) self.neurons = [] self.connections = [] for layer in range(len(layerCounts)): neuron_layer = [] connection_layer = [] for i in range(layerCounts[layer]): # Input neurons shouldn't activate their input. cur_neuron = None if layer is 0: # input neurons do not activate. cur_neuron = Neuron(sigmoid.Linear) else: # hidden and output neurons use normal sigmoids cur_neuron = Neuron(activation) # for every neuron to the left for anterior in self.neurons[layer-1]: #create an anterior connection to CUR_NEURON connection = Connection(anterior, cur_neuron) connection_layer.append(connection) # add this connection to the posterior connections # of ANTERIOR. anterior.posteriors.append(connection) cur_neuron.anteriors.append(connection) # do the same for the BIAS connection. bias_connection = Connection(self.bias, cur_neuron) connection_layer.append(bias_connection) self.bias.posteriors.append(bias_connection) # add the current neuron. neuron_layer.append(cur_neuron) #if connections were made if layer != 0: self.connections.append(connection_layer) # append the neural layer. self.neurons.append(neuron_layer) def train(self, datapair, rate): """Trains the network with a certain learning rate on a datapair. Returns the net error across ouytput neurons. Assunmes input matches network size.""" inp = datapair[0] desired = datapair[1] self.feedforward(inp) error = self.backpropagate(desired, rate) return error def feedforward(self, inputs): """ Passes the input data through the network and creates the output """ assert len(inputs) == len(self.neurons[0]), \ "Input vector does not match the network intut layer" for i in range(len(inputs)): self.neurons[0][i].feed(inputs[i]) self.bias.activate() for layer in self.neurons: for neuron in layer: neuron.activate() return [x.output for x in self.neurons[-1]] def backpropagate(self, desired, learning_rate): """ Updates the weights based on the desired output and the learning rate using error backpropagation.""" outputs = [n.output for n in self.neurons[-1]] losses = [x[0] - x[1] for x in zip(outputs, desired)] error = sum(map(lambda x: x ** 2, losses)) # manually set the error coefficients for the output error. for output_neuron, loss in zip(self.neurons[-1], losses): output_neuron.set_error(loss) for n_layer in self.neurons[:-1][::-1]: for neuron in n_layer: error_coef = 0 for con in neuron.posteriors: error_coef += con.posterior.error * con.weight con.update_weight(learning_rate) neuron.set_error(error_coef) # fix bias error for con in self.bias.posteriors: con.update_weight(learning_rate) return error def set_weight(self, layer, left, right, value): """Sets a weight from a neuron indexed LEFT in LAYER to a neuron indexed RIGHT on the posterior neuron with a new weight VALUE.""" self.neurons[layer][left].posteriors[right].weight = value return value def get_weight(self, layer, left, right): """Gets a weight from a neuron indexed LEFT in LAYER to a neuron indexed RIGHT on the posterior neuron""" return self.neurons[layer][left].posteriors[right].weight def save(self, filename): """Requires json pickle.""" f = open(filename, "wb") pickle.dump(self, f) def load(filename): """Requires json pickle.""" f = open(filename, "rb") return pickle.load(f)
master.update() radius_range[0] = r1Slider.get() * 10 radius_range[1] = r2Slider.get() * 10 distance = distanceSlider.get() * 10 for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() screen.fill(black) xyPoints = getMofifiedPoints(points) pygame.draw.line( screen, (0, 255, 0), [0, (-neuron.w[1] * (-250) + neuron.w[0]) / neuron.w[2] + center[1]], [500, (-neuron.w[1] * (250) + neuron.w[0]) / neuron.w[2] + center[1]]) for x in xyPoints: color = (0, 255, 255) if neuron.activate(x) and x[2] == 1: color = (255, 0, 0) elif not neuron.activate(x) and x[2] == 0: color = (0, 0, 255) elif neuron.activate(x) and x[2] == 0: color = (255, 0, 255) pygame.draw.circle(screen, color, [int(x[0] + center[0]), int(x[1] + center[1])], 1) pygame.display.flip()
class MLP: # Class Constructor # This method initializes all properties of this class. # @param iterations: The number of iterations. # @param architecture: (Number of hidden neurons, Number of input Neurons) # @param patterns: Collection of training patterns def __init__(self, patterns, iterations, architecture): self.hidden_dims, self.input_dims = architecture self.iteration = 0 self.iterations = iterations self.patterns = list(patterns) self.absolute_error = 0.0 self.squared_error = 0.0 self.hidden_layer = None self.input_layer = None self.output = None self.theta = 0.01 self.rand = random.Random() self.initialize() # Initialize the network based on its architecture. def initialize(self): self.input_layer = Layer(self.input_dims) self.hidden_layer = Layer(self.hidden_dims, self.input_layer, self.rand) self.output = Neuron(self.hidden_layer, self.rand) self.iteration = 0 # Adjust the network weights. def adjust_weights(self, delta): self.output.adjust_weights(delta) for neuron in self.hidden_layer.get_layer(): neuron.adjust_weights(self.output.error_feedback(neuron)) # Propagates the perceptron and calculate the output. def activate(self, pattern): for i in range(len(pattern[0])): self.input_layer.get_layer()[i].set_output_neuron(pattern[0][i]) for neuron in self.hidden_layer.get_layer(): neuron.activate() self.output.activate() return self.output.output_neuron() # Do the training of the perceptron network. def train(self): error = 1.0 while error > self.theta: error = 0.0 for pattern in self.patterns: delta = pattern[1] - self.activate(pattern) self.absolute_error += delta self.adjust_weights(delta) error += math.pow(delta, 2) self.squared_error += error self.iteration += 1 if self.iteration > self.iterations: self.initialize() self.absolute_error = self.absolute_error / self.iteration self.squared_error = self.squared_error / self.iteration # Test the network after trained. def execute(self, pattern): return self.activate(pattern)