def backpropagate(network, input_vector, targets):
hidden_outputs, outputs = feed_forward(network, input_vector)
# the output * (1 - output) is from the derivative 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 neuron's delta and its jth input
output_neuron[j] -= output_deltas[i] * hidden_output
# back-propagate errors to hidden layer
hidden_deltas = [hidden_output * (1 - hidden_output) *
dot(output_deltas, [n[i] for n in network[-1]])
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 perceptron_output(weights, bias, x):
"""returns 1 if the 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 project(v, w):
"""return the projection of v onto the direction of w"""
projection_length = dot(v, w)
return scalar_multiply(projection_length, w)
def transform_vector(v, components):
return [dot(v, w) for w in components]
def directional_variance_i(x_i, w):
"""the variance of the row x_i in the direction determined by w"""
return dot(x_i, direction(w))
def directional_variance_gradient_i(x_i, w):
"""the contribution of row x_i to the gradient of
the direction-w variance"""
projection_length = dot(x_i, direction(w))
return [2 * projection_length * x_ij for x_ij in x_i]
def cosine_similarity(v, w):
return dot(v, w) / math.sqrt(dot(v, v) * dot(w, w))
def matrix_product_entry(A, B, i, j):
return dot(get_row(A, i), get_column(B, j))
def logistic_log_partial_ij(x_i, y_i, beta, j):
"""here i is the index of the data point,
j is the index of the derivative"""
return (y_i - logistic(dot(x_i, beta))) * x_i[j]
def logistic_log_likelihood_i(x_i, y_i, beta):
if y_i == 1:
return math.log(logistic(dot(x_i, beta)))
else:
return math.log(1 - logistic(dot(x_i, beta)))
def predict(x_i, beta):
return dot(x_i, beta)
def ridge_penalty(beta, alpha):
return alpha * dot(beta[1:], beta[1:])
print()
random.seed(0) # so that you get the same results as me
bootstrap_betas = bootstrap_statistic(list(zip(x, daily_minutes_good)),
estimate_sample_beta, 100)
bootstrap_standard_errors = [
standard_deviation([beta[i] for beta in bootstrap_betas])
for i in range(4)
]
print("bootstrap standard errors", bootstrap_standard_errors)
print()
print("p_value(30.63, 1.174)", p_value(30.63, 1.174))
print("p_value(0.972, 0.079)", p_value(0.972, 0.079))
print("p_value(-1.868, 0.131)", p_value(-1.868, 0.131))
print("p_value(0.911, 0.990)", p_value(0.911, 0.990))
print()
print("regularization")
random.seed(0)
for alpha in [0.0, 0.01, 0.1, 1, 10]:
beta = estimate_beta_ridge(x, daily_minutes_good, alpha=alpha)
print("alpha", alpha)
print("beta", beta)
print("dot(beta[1:],beta[1:])", dot(beta[1:], beta[1:]))
print("r-squared", multiple_r_squared(x, daily_minutes_good, beta))
print()
