from numpy import exp, array, random, dot

class NeuralNetwork():

 # generate the weights

 def __init__(self):

 # Seed the random number generator, so it generates the same numbers

 # every time the program runs.


 # We model a single neuron, with 3 input connections and 1 output connection.

 # We assign random weights to a 3 x 1 matrix, with values in the range -1 to 1

 # and mean 0.

 self.synaptic_weights = 2 * random.random((3, 1)) - 1

 # The Sigmoid function, which describes an S shaped curve.

 # We pass the weighted sum of the inputs through this function to

 # normalise them between 0 and 1.

 #sigmoid function

 def __sigmoid(self, x):

 return 1 /(1 + exp(-x))

 # The derivative of the Sigmoid function.

 # This is the gradient of the Sigmoid curve.

 # It indicates how confident we are about the existing weight.

 def __sigmoid_derivative(self, x):

 return x * (1 - x)

 # We train the neural network through a process of trial and error.

 # Adjusting the synaptic weights each time.

 def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):

 for iteration in range(number_of_training_iterations):

 # Pass the training set through our neural network (a single neuron).

 output = self.think(training_set_inputs)

 # Calculate the error (The difference between the desired output

 # and the predicted output).

 error = training_set_outputs - output

 # Multiply the error by the input and again by the gradient of the Sigmoid curve.

 # This means less confident weights are adjusted more.

 # This means inputs, which are zero, do not cause changes to the weights.

 adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))

 # Adjust the weights.

 self.synaptic_weights += adjustment

 # The neural network thinks.

 def think(self, inputs):

 # Pass inputs through our neural network (our single neuron).

 return self.__sigmoid(dot(inputs, self.synaptic_weights))

if __name__ == "__main__":

 #Intialise a single neuron neural network.

 neural_network = NeuralNetwork()

 print ("Random starting synaptic weights:")

 print (neural_network.synaptic_weights)

 # The training set. We have 4 examples, each consisting of 3 input values

 # and 1 output value.

 training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])

 training_set_outputs = array([[0, 1, 1, 0]]).T

 # Train the neural network using a training set.

 # Do it 10,000 times and make small adjustments each time.

 neural_network.train(training_set_inputs, training_set_outputs, 10000)

 print ("New synaptic weights after training:")

 print (neural_network.synaptic_weights)

 # Test the neural network with a new situation.

 print ("Considering new situation [1, 0, 0] ->?:")

 print (neural_network.think(array([1, 0, 0])))

first : generate the weights

second: sigmoid function -> x_ij * weights -> values(-1,1)

error = y_ij - output

# the gradient decent

weights = weights + (x_ij).T * error*dependecy 

1.A neural Network is an algorithm that learns to identify patterns in data

2.Backpropagation is a technique to train a Neural Net by updating weights via gradient descent

3.deep learning = many layers neural net + big data + big compute

a simple single layer Feedforward neural network

Copyright © 2011 Dowemo All rights reserved.    Creative Commons   AboutUs