More Complex Situation

April 25th, 2018

I modeled a single neuron, with three input connections and one output connection. Then I assigned random weights to a 3×1 matrix, with values in the range of -1 to 1. I pass the weighted sum of the inputs through this function to normalise them between 0 and 1.┬áThe derivative of the Sigmoid function indicates how confident I am about the existing weight.

After this, the neural network learns through a process of trial and error, adjusting the weight each time. In order to determine how successful the neuron learns, I calculated the error, which is the difference between the desired output and predicted output. Now, I multiplied the error by the input, thus causing the less confident weights to adjust more, meaning the inputs that equal zero do not cause change to the weights.

I give the neural network some training sets and make it run through it many times, then test it with a new situation.

 

from numpy import exp, array, random, dot

 

class NeuralNetwork():
def __init__(self):
random.seed(1)

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

def __sigmoid(self, x):
return 1 / (1 + exp(-x))

def __sigmoid_derivative(self, x):
return x * (1 – x)

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

for iteration in xrange(num_iter):
# Pass the training set through our neural network (a single neuron).
output = self.think(training_set_inputs)

error = training_set_outputs – output

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]))

# Output:

#Random starting synaptic weights:
#[[-0.16595599]
#[ 0.44064899]
#[-0.99977125]]
#New synaptic weights after training:
#[[ 9.67299303]
#[-0.2078435 ]
#[-4.62963669]]
#Considering new situation [1, 0, 0] -> ?:
#[ 0.99993704]

Entry Filed under: Uncategorized

Leave a Comment

Required

Required, hidden

Some HTML allowed:
<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Trackback this post  |  Subscribe to the comments via RSS Feed


Recent Comments

Archives

Meta