def checkNNGradients(lambda_reg=0):
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = diw.debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = diw.debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = diw.debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(range(m), num_labels).T
# Unroll parameters
nn_params = np.concatenate(
(Theta1.reshape(Theta1.size,
order='F'), Theta2.reshape(Theta2.size, order='F')))
# Short hand for cost function
def costFunc(p):
return nncf.nnCostFunction(p, input_layer_size, hidden_layer_size, \
num_labels, X, y, lambda_reg)
_, grad = costFunc(nn_params)
numgrad = cng.computeNumericalGradient(costFunc, nn_params)
fmt = '{:<25}{}'
print(fmt.format('Numerical Gradient', 'Analytical Gradient'))
for numerical, analytical in zip(numgrad, grad):
print(fmt.format(numerical, analytical))
diff = Decimal(np.linalg.norm(numgrad - grad)) / Decimal(
np.linalg.norm(numgrad + grad))
def checkNNGradients(lam=0):
import numpy as np
from debugInitializeWeights import debugInitializeWeights
from nnCostFunctionVec import nnCostFunctionVec
from computeNumericalGradient import computeNumericalGradient
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.mod(np.arange(m) + 1, num_labels).T
nn_params = np.append(Theta1.flatten('F'), Theta2.flatten('F'), axis=0)
costFunc = lambda p: nnCostFunctionVec(
p, input_layer_size, hidden_layer_size, num_labels, X, y, lam)
[cost, grad] = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
print(
np.append(numgrad.reshape(numgrad.size, 1),
grad.reshape(grad.size, 1),
axis=1))
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print(diff)
def checkNNGradients(_lambda=0):
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
X = debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(range(m), num_labels).T
nn_params = arrayToVector(theta1, theta2)
def costFunc(p):
return nnCostFunction(p, input_layer_size, hidden_layer_size, \
num_labels, X, y, _lambda, True)
_, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
print('Numerical Gradient', 'Analytical Gradient')
for numerical, analytical in zip(numgrad, grad):
print(numerical, analytical)
print('The above two columns you get should be very similar.\n' \
'(Left Col.: Your Numerical Gradient, Right Col.: Analytical Gradient)')
diff = Decimal(np.linalg.norm(numgrad - grad)) / Decimal(
np.linalg.norm(numgrad + grad))
print('If your backpropagation implementation is correct, then \n' \
'the relative difference will be small (less than 1e-9). \n' \
'\nRelative Difference: {:.10E}'.format(diff))
def checkNNGradients(lmbda=0):
#CHECKNNGRADIENTS Creates a small neural network to check the
#backpropagation gradients
# CHECKNNGRADIENTS(lmbda) Creates a small neural network to check the
# backpropagation gradients, it will output the analytical gradients
# produced by your backprop code and the numerical gradients (computed
# using computeNumericalGradient). These two gradient computations should
# result in very similar values.
#
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(range(1, m + 1), num_labels)[:, None]
# Unroll parameters
nn_params = np.hstack((Theta1.ravel(), Theta2.ravel()))
# Short hand for cost function
def costFunc(p):
return nnCostFunction(p, input_layer_size, hidden_layer_size, \
num_labels, X, y, lmbda)
def gradFunc(p):
return nnGradFunction(p, input_layer_size, hidden_layer_size,
num_labels, X, y, lmbda)
grad = gradFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(np.c_[numgrad, grad])
print(['The above two columns you get should be very similar.\n' \
'(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n'])
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
minus = numgrad - grad
minus2 = minus * minus
sum1 = np.sum(minus2)
minus3 = np.sqrt(sum1)
plus = numgrad + grad
numeritor = np.linalg.norm(minus, 2)
Denominator = np.linalg.norm(plus, 2)
diff = numeritor / Denominator
print(['If your backpropagation implementation is correct, then \n' \
'the relative difference will be small (less than 1e-9). \n' \
'\nRelative Difference: #g\n'], diff)
def checkNNGradients(lambda_reg=0):
#CHECKNNGRADIENTS Creates a small neural network to check the
#backpropagation gradients
# CHECKNNGRADIENTS(lambda_reg) Creates a small neural network to check the
# backpropagation gradients, it will output the analytical gradients
# produced by your backprop code and the numerical gradients (computed
# using computeNumericalGradient). These two gradient computations should
# result in very similar values.
#
input_layer_size = 2
hidden_layer1_size = 5
hidden_layer2_size = 5
num_labels = 1
m = 5
# We generate some 'random' test data
Theta1 = diw.debugInitializeWeights(hidden_layer1_size, input_layer_size)
Theta2 = diw.debugInitializeWeights(hidden_layer2_size, hidden_layer1_size)
Theta3 = diw.debugInitializeWeights(num_labels, hidden_layer2_size)
# Reusing debugInitializeWeights to generate X
X = diw.debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(range(m), num_labels).T
# Unroll parameters
nn_params = np.concatenate(
(Theta1.reshape(Theta1.size,
order='F'), Theta2.reshape(Theta2.size, order='F'),
Theta3.reshape(Theta3.size, order='F')))
# Short hand for cost function
def costFunc(p):
return nncf.nnCostFunction(p, input_layer_size, hidden_layer1_size,hidden_layer2_size, \
num_labels, X, y, lambda_reg)
_, grad = costFunc(nn_params)
numgrad = cng.computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
# code from http://stackoverflow.com/a/27663954/583834
fmt = '{:<25}{}'
print(fmt.format('Numerical Gradient', 'Analytical Gradient'))
for numerical, analytical in zip(numgrad, grad):
print(fmt.format(numerical, analytical))
print('The above two columns you get should be very similar.\n' \
'(Left Col.: Your Numerical Gradient, Right Col.: Analytical Gradient)')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = Decimal(np.linalg.norm(numgrad - grad)) / Decimal(
np.linalg.norm(numgrad + grad))
print('If your backpropagation implementation is correct, then \n' \
'the relative difference will be small (less than 1e-9). \n' \
'\nRelative Difference: {:.10E}'.format(diff))
def checkNNGradients(lambda_param=0):
'''
CHECKNNGRADIENTS(lambda) Creates a small neural network to check the
backpropagation gradients, it will output the analytical gradients
produced by your backprop code and the numerical gradients (computed
using computeNumericalGradient). These two gradient computations should
result in very similar values.
'''
from debugInitializeWeights import debugInitializeWeights
import numpy as np
from nnCostFunction import nnCostFunction
from computeNumericalGradient import computeNumericalGradient
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# Generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(np.arange(1, m + 1), num_labels)
# Unroll parameters
nn_params = []
nn_params.extend((list(Theta1.flatten()) + list(Theta2.flatten())))
# Short hand for cost function: ANONYMOUS FUNCTION
def costFunc(p):
return nnCostFunction(p, input_layer_size, hidden_layer_size,
num_labels, X, y, lambda_param)
_, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print('The following two columns should be very similar.\n')
print('\ngradApprox:\n {}'.format(numgrad))
print('\ndeltaVector:\n{}'.format(np.array(grad)))
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print('\n\nIf your backpropagation implementation is correct, then \n'
'the relative difference will be small (less than 1e-9). \n'
'\nRelative Difference: %g\n' % diff)
def checkNNGradients(Lambda=0):
"""Creates a small neural network to check the
backpropagation gradients, it will output the analytical gradients
produced by your backprop code and the numerical gradients (computed
using computeNumericalGradient). These two gradient computations should
result in very similar values.
"""
#input_layer_size = 4
#hidden_layer_size = 5
#num_labels = 3
#m = 10
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.mod(range(1, m + 1), num_labels)
# Unroll parameters
nn_params = np.hstack((Theta1.T.ravel(), Theta2.T.ravel()))
# Short hand for cost function
costFunc = lambda p: nnCostFunction(p, input_layer_size, hidden_layer_size,
num_labels, X, y, Lambda)
#costFunc = nnCostFunction(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, Lambda)
numgrad = computeNumericalGradient(costFunc, nn_params)
grad = costFunc(nn_params)[1]
print(numgrad)
print(grad)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(np.column_stack((numgrad, grad)))
print('The above two columns you get should be very similar.\n' \
'(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print('If your backpropagation implementation is correct, then\n ' \
'the relative difference will be small (less than 1e-9). \n' \
'\nRelative Difference: %g\n' % diff)
return (nn_params, grad)
def checkNNGradients(lambda_reg=0):
#CHECKNNGRADIENTS Creates a small neural network to check the
#backpropagation gradients
# CHECKNNGRADIENTS(lambda_reg) Creates a small neural network to check the
# backpropagation gradients, it will output the analytical gradients
# produced by your backprop code and the numerical gradients (computed
# using computeNumericalGradient). These two gradient computations should
# result in very similar values.
#
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = diw.debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = diw.debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = diw.debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(range(m), num_labels).T
# Unroll parameters
nn_params = np.concatenate((Theta1.reshape(Theta1.size, order='F'), Theta2.reshape(Theta2.size, order='F')))
# Short hand for cost function
def costFunc(p):
return nncf.nnCostFunction(p, input_layer_size, hidden_layer_size, \
num_labels, X, y, lambda_reg)
_, grad = costFunc(nn_params)
numgrad = cng.computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
# code from http://stackoverflow.com/a/27663954/583834
fmt = '{:<25}{}'
print(fmt.format('Numerical Gradient', 'Analytical Gradient'))
for numerical, analytical in zip(numgrad, grad):
print(fmt.format(numerical, analytical))
print('The above two columns you get should be very similar.\n' \
'(Left Col.: Your Numerical Gradient, Right Col.: Analytical Gradient)')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = Decimal(np.linalg.norm(numgrad-grad))/Decimal(np.linalg.norm(numgrad+grad))
print('If your backpropagation implementation is correct, then \n' \
'the relative difference will be small (less than 1e-9). \n' \
'\nRelative Difference: {:.10E}'.format(diff))
def checkNNGradients(lambda_=0):
"""
Creates a small neural network to check the
backpropagation gradients, it will output the analytical gradients
produced by your backprop code and the numerical gradients (computed
using computeNumericalGradient). These two gradient computations should
result in very similar values.
"""
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.arange(1, m + 1) % num_labels
# Unroll parameters
nn_params = np.r_[Theta1.flatten(order='F'), Theta2.T.flatten(order='F')]
# Short hand for cost function
def costFunction(p):
return nnCostFunction(p, input_layer_size, hidden_layer_size,
num_labels, X, y, lambda_)
numgrad = computeNumericalGradient(costFunction, nn_params)
_, grad = costFunction(nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(np.c_[numgrad, grad])
print('The above two columns you get should be very similar.\n'
'(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON 1e-4
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print('If your backpropagation implementation is correct, then\n '
'the relative difference will be small (less than 1e-9). \n'
'\nRelative Difference: %g\n' % diff)
def checkNNGradients(reg_lambda=0):
""" Creates a small neural network to check the backpropagation gradients
CHECKNNGRADIENTS(reg_lambda) Creates a small neural network to check the
backpropagation gradients, it will output the analytical gradients
produced by your backprop code and the numerical gradients (computed
using computeNumericalGradient). These two gradient computations should
result in very similar values."""
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.mod(np.arange(m), num_labels).T.reshape(m, 1)
# Unroll parameters
nn_params = np.r_[Theta1.ravel(), Theta2.ravel()]
# Short hand for cost function
costFunc = lambda params: nnCostFunction(
params, input_layer_size, hidden_layer_size, num_labels, X, y,
reg_lambda)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(numgrad, grad)
print('The above two columns you get should be very similar.\n',
'(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.py, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print('If your backpropagation implementation is correct, then \n',
'the relative difference will be small (less than 1e-9). \n',
'\nRelative Difference: \n', diff)
def checkNNGradients(Lambda = 0):
"""Creates a small neural network to check the
backpropagation gradients, it will output the analytical gradients
produced by your backprop code and the numerical gradients (computed
using computeNumericalGradient). These two gradient computations should
result in very similar values.
"""
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.mod(range(1, m+1), num_labels)
# Unroll parameters
nn_params = np.hstack((Theta1.T.ravel(), Theta2.T.ravel()))
# Short hand for cost function
costFunc = lambda p: nnCostFunction(p, input_layer_size, hidden_layer_size, num_labels, X, y, Lambda)
numgrad = computeNumericalGradient(costFunc, nn_params)
grad = costFunc(nn_params)[1]
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print np.column_stack((numgrad, grad))
numgrad.shape #
grad.shape #
print 'The above two columns you get should be very similar.\n' \
'(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n'
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad-grad)/np.linalg.norm(numgrad+grad)
print 'If your backpropagation implementation is correct, then\n ' \
'the relative difference will be small (less than 1e-9). \n' \
'\nRelative Difference: %g\n' % diff
def checkNNGradients(lmbda):
#CHECKNNGRADIENTS Creates a small neural network to check the
#backpropagation gradients
# CHECKNNGRADIENTS(lmbda) Creates a small neural network to check the
# backpropagation gradients, it will output the analytical gradients
# produced by your backprop code and the numerical gradients (computed
# using computeNumericalGradient). These two gradient computations should
# result in very similar values.
#
if not 'lmbda' in locals():
lmbda = 0
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = (np.reshape(np.mod(range(0,m), num_labels), (1,m))).flatten()
# Unroll parameters
nn_params = np.concatenate((Theta1.ravel(), Theta2.ravel()), axis=0)
# Short hand for cost function
costFunc = lambda p : nnCostFunction(p, input_layer_size, hidden_layer_size, num_labels, X, y, lmbda)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print np.concatenate((np.reshape(numgrad, (1, numgrad.size)).T, np.reshape(grad, (1, grad.size)).T), axis=1)
print 'The above two columns you get should be very similar.\n(Left-Your Numerical Gradient, Right-Analytical Gradient)'
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad-grad) / np.linalg.norm(numgrad+grad)
print 'If your backpropagation implementation is correct, then \nthe relative difference will be small (less than 1e-9). \nRelative Difference: {}\n'.format(diff)
def checkNNGradients(_lambda=None):
if _lambda == None:
_lambda = 0
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = (1 + np.arange(m)) % num_labels
y = y.reshape(-1,1)
# Unroll parameters
nn_params = np.append(Theta1.flatten(),Theta2.flatten())
# Short hand for cost function
costFunc = lambda p: nnCostFunction(p, input_layer_size, hidden_layer_size, \
num_labels, X, y, _lambda)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(grad)
print(numgrad)
print('The above two columns you get should be very similar.\n \
(Left-Your Numerical Gradient, Right-Analytical Gradient)\n\n')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad-grad)/np.linalg.norm(numgrad+grad)
print('If your backpropagation implementation is correct, then \n \
the relative difference will be small (less than 1e-9). \n \
\nRelative Difference: %g\n'%diff)
def checkNNGradients(lambda_value=0):
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.transpose(np.mod(range(1, m + 1), num_labels))
# y=np.expand_dims(y,axis=1)
# Unroll parameters
Theta1_1d = np.reshape(Theta1, Theta1.size, order='F')
Theta2_1d = np.reshape(Theta2, Theta2.size, order='F')
nn_params = np.hstack((Theta1_1d, Theta2_1d))
# Short hand for cost function
costFunc = lambda p: nnCostFunction(p, input_layer_size, hidden_layer_size,
num_labels, X, y, lambda_value)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc,
np.expand_dims(nn_params, axis=1))
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(numgrad, grad)
print(
'The above two columns you get should be very similar.\n (Left-Numerical Gradient, Right-(Your) Analytical Gradient)\n\n'
)
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print(
'If your backpropagation implementation is correct, then \n the relative difference will be small (less than 1e-9). \n \nRelative Difference: ',
diff)
def checkNNGradients(lmbda=0):
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.mod(range(m), num_labels)
# Unroll parameters
nn_params = np.hstack((Theta1.flatten(), Theta2.flatten()))
# Short hand for cost function
costFunc = lambda nn_params: nnCostFunction(
nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, lmbda
)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(np.vstack((numgrad, grad)).T)
print('The above two columns you get should be very similar.')
print('(Left-Your Numerical Gradient, Right-Analytical Gradient)')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print('If your backpropagation implementation is correct, then')
print('the relative difference will be small (less than 1e-9).')
print('Relative Difference: %g' % (diff))
def checkNNGradients(lamda=0):
input_layer_size = 3
hidden_layer_size = 3
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
X = debugInitializeWeights(m, input_layer_size - 1)
y = 1 + np.mod(range(1, m + 1), num_labels).reshape((m, 1))
# Unroll parameters
nn_params = np.hstack((Theta1.T.ravel(), Theta2.T.ravel()))
# Short hand for cost function
costFunc = lambda p: nnCostFunction(
p, input_layer_size, hidden_layer_size, num_labels, X, y, lamda)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(np.vstack((numgrad, grad)).T)
print('The above two columns you get should be very similar.\n' +
'(Left-Your Numerical Gradient, Right-Analytical Gradient)')
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.py, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print('If your backpropagation implementation is correct, then \n' +
'the relative difference will be small (less than 1e-9). \n' +
'Relative Difference: %g\n' % diff)
def checkNNGradients(lmbda=0):
input_layer_size = 3
hidden_layer_size = 5
num_labels = 3
m = 5
# We generate some 'random' test data
Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)
Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)
# Reusing debugInitializeWeights to generate X
X = debugInitializeWeights(m, input_layer_size - 1)
y = np.mod(range(m), num_labels)
# Unroll parameters
nn_params = np.hstack((Theta1.flatten(), Theta2.flatten()))
# Short hand for cost function
costFunc = lambda nn_params: nnCostFunction(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, lmbda)
cost, grad = costFunc(nn_params)
numgrad = computeNumericalGradient(costFunc, nn_params)
# Visually examine the two gradient computations. The two columns
# you get should be very similar.
print(np.vstack((numgrad, grad)).T)
print("The above two columns you get should be very similar.")
print("(Left-Your Numerical Gradient, Right-Analytical Gradient)")
# Evaluate the norm of the difference between two solutions.
# If you have a correct implementation, and assuming you used EPSILON = 0.0001
# in computeNumericalGradient.m, then diff below should be less than 1e-9
diff = np.linalg.norm(numgrad - grad) / np.linalg.norm(numgrad + grad)
print("If your backpropagation implementation is correct, then")
print("the relative difference will be small (less than 1e-9).")
print("Relative Difference: %g" % (diff))
