def backpropogate(network, input_vector, targets):
hidden_outputs, outputs = feed_forward(network, input_vector)
# recall derivative of sigmoid is same as logit
output_deltas = [output * (1 - output) * (output - target)
for output, target in zip(outputs, targets)]
# adjust weights gradient descent style
for i, output_neuron in enumerate(network[-1]):
# iterate over hidden layers
for j, hidden_output in enumerate(hidden_outputs + [1]):
output_neuron[j] -= output_deltas[i] * hidden_output
# now propogate this change backward
hidden_deltas = [hidden_output * (1 - hidden_output) *
dot(output_deltas, [n[i] for n in output_layer])
for i, hidden_output in enumerate(hidden_outputs)]
# adjust weights
for i, hidden_neuron in enumerate(network[0]):
for j, input in enumerate(input_vector + [1]):
hidden_neuron[j] -= hidden_deltas[i] * input
def backpropagate(network, input_vector, targets): hidden_outputs, outputs = feed_forward(network, input_vector) #the output * (1 - output) is from teh derivative of sigmoid output_deltas = [output * (1 - output) * (output - target) for output, target in zip(outputs, targets)] #adjust weights for output layer, one neuron at a time for i, output_neuron in enumerate(network[-1]): #focus on the ith output layer neuron for j, hidden_output in enumerate(hidden_outputs + [1]): #adjust the jth weight based on both #this neurons delta and its jth input output_neuron[j] -= output_deltas[i] * hidden_output #backproagate errors to hidden layer hidden_deltas = [hidden_output * (1 - hidden_output) * lin_alg.dot(output_deltas, [n[i] for n in output_layer]) for i, hidden_output in enumerate(hidden_outputs)] #adjust weights for hidden layer, one neuron at a time for i, hidden_neuron in enumerate(network[0]): for j, input in enumerate(input_vector + [1]): hidden_neuron[j] -= hidden_deltas[i] * input
def cosine_similarity(v, w): return lin_alg.dot(v, w) / math.sqrt(lin_alg.dot(v, v) * lin_alg.dot(w, w))
def perceptron_output(weights, bias, x): '''returns 1 if the perceptron fires, 0 if not''' calculation = lin_alg.dot(weights, x) + bias return step_function(calculation)
def neuron_output(weights, inputs): return sigmoid(lin_alg.dot(weights, inputs))
def perceptron_output(weights, bias, x):
"""returns 1 if perceptron fires, 0 if not"""
calculation = dot(weights, x) + bias
return step_function(calculation)
def neuron_output(weights, inputs):
return sigmoid(dot(weights, inputs))
def transform_vector(v, components): return [lin_alg.dot(v, w) for w in components]
def project(v, w): '''projection of v onto w''' projection_length = lin_alg.dot(v, w) return lin_alg.scalar_multiply(projection_length, w)
def directional_variance_gradient_i(x_i, w): '''contribution of row x_i to gradient of direction w variance''' projection_length = lin_alg.dot(x_i, direction(w)) return [2 * projection_length * x_ij for x_ij in x_i]
def directional_variance_i(x_i, w): '''var of row x_i in direction w''' return lin_alg.dot(x_i, direction(w))**2
