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