Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import matplotlib.pyplot
- import numpy
- # scipy.special for the sigmoid function expit()
- import scipy.special
- def normalize_columns(weights):
- #takes a weight matrix as input, returns the same matrix with each column normalized so that it adds to 1
- weights = weights.T
- return ((1/sum(weights))*weights).T
- class neuralNetwork:
- # initialise the neural network
- def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
- # set number of nodes in each input, hidden, output layer
- self.inodes = inputnodes
- self.onodes = outputnodes
- self.hnodes = hiddennodes
- # set learning rate
- self.lr = learningrate
- # set initiral random weights
- self.wih = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
- self.who = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))
- self.activation_function = lambda x : scipy.special.expit(x)
- def query(self, inputs_list):
- #make inputs_list into an array
- inputs = numpy.array(inputs_list, ndmin=2).T
- #calculate hidden inputs via matrix multiplcation
- hidden_inputs = numpy.dot(self.wih, inputs)
- #activate hidden_inputs
- hidden_outputs = self.activation_function(hidden_inputs)
- #calculate final inputs
- final_inputs = numpy.dot(self.who, hidden_outputs)
- #activate final_inputs to get final_outputs
- final_outputs = self.activation_function(final_inputs)
- return final_outputs
- def train(self, input_list, target_list):
- #calculate outputs of the network given input_list as input:
- #make inputs_list into an array, see query for comments
- inputs = numpy.array(input_list, ndmin=2).T
- hidden_inputs = numpy.dot(self.wih, inputs)
- hidden_outputs = self.activation_function(hidden_inputs)
- final_inputs = numpy.dot(self.who, hidden_outputs)
- final_outputs = self.activation_function(final_inputs)
- #make targets_list into an array as well
- targets = numpy.array(target_list, ndmin = 2).T
- #calculate error
- output_errors = targets - final_outputs
- hidden_errors = numpy.dot(normalize_columns(self.who).T, output_errors)
- self.who += self.lr*numpy.dot(output_errors*(final_outputs)*(1-final_outputs), hidden_outputs.T)
- self.wih += self.lr*numpy.dot(hidden_errors*(hidden_outputs)*(1-hidden_outputs), inputs.T)
- # number of input, hidden and output nodes
- input_nodes = 3
- hidden_nodes = 3
- output_nodes = 3
- # learning rate is 0.3
- learning_rate = 0.3
- # create instance of neural network
- n = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement