def test_gt_forward(): ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data + 1) y = Variable(data) # ============================================================================= # assert data pass # ============================================================================= assert (x > y).all(), 'Data failed'
def test_ge_reverse(): ad.set_mode('reverse') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data + 1) y = Variable(data) # ============================================================================= # assert data pass # ============================================================================= assert (x >= y).all(), 'Data failed'
def test_eq_reverse(): ad.set_mode('reverse') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) y = x # ============================================================================= # assert data pass # ============================================================================= assert (x == y).all(), 'equality reverse failed'
def test_eq_forward(): ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) y = x # ============================================================================= # assert data pass # ============================================================================= assert (x == y).all(), 'equqlity forward failed'
def test_neq_forward(): ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) y = Variable(data + 1) # ============================================================================= # assert data pass # ============================================================================= assert (x != y).all, 'inequality forward failed'
def test_gradient_descent_forward(): ad.set_mode('forward') def loss(params): var = Variable(params) x, y = var[0], var[1] l = (x + 5)**2 + (y + 3)**2 l.compute_gradients() return (l.data, l.gradient) x_init = [10, 4] optimize_GD = GD(loss, x_init, lr=0.1, max_iter=1000, tol=1e-13) sol = optimize_GD.solve() assert round(sol[0]) == -5 and round(sol[1]) == -3
def test_adam_reverse(): ad.set_mode('reverse') def loss(params): ad.reset_graph() var = Variable(params) x = var[0] y = var[1] l = (x + 5)**2 + (y + 3)**2 l.compute_gradients() return (l.data, l.gradient) x_init = [10, 4] adam = Adam(loss, x_init, lr=0.5, max_iter=1000, tol=1e-13) sol = adam.solve() assert round(sol[0]) == -5 and round(sol[1]) == -3
def test_adam_forward(): ad.set_mode('forward') def loss(params): var = Variable(params) x = var[0] y = var[1] l = (x + 5)**2 + (y + 3)**2 l.compute_gradients() return (l.data, l.gradient) x_init = [10, 4] adam = Adam(loss, x_init, lr=0.1, max_iter=1000, tol=1e-13) sol = adam.solve() assert round(sol[0]) == -5 and round( sol[1]) == -3, 'expected -5, -3 received {}, {}'.format( sol[0], sol[1])
def test_sin_reverse(): ad.set_mode('reverse') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= sin_block = sin() # ============================================================================= # compute output of custom block # ============================================================================= y_block = sin_block(x) # ============================================================================= # Compute gradient backwards # ============================================================================= y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.sin(data) gradient_true = np.diag(np.cos(data)) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong sin data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong sin gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient)
def test_neg_forward(): ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) y_true = Variable(-x.data, -x.gradient) y_block = -x # ============================================================================= # assert data pass # ============================================================================= assert np.equal(y_true.data, y_block.data).all(), 'Data failed' # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(y_true.gradient, y_block.gradient).all(), 'Gradient failed'
def test_log_diffBase_reverse(): ad.set_mode('reverse') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= base = np.random.randint(2, 5) + np.random.random() log_block = log(base=base) # ============================================================================= # compute output of custom block # ============================================================================= y_block = log_block(x) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.log(data) / np.log(base) gradient_true = np.diag(1 / (data * np.log(base))) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong log data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong log gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient) ad.set_mode('forward')
def test_logistic_reverse(): ad.set_mode('reverse') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= logistic_block = logistic() # ============================================================================= # compute output of custom block # ============================================================================= y_block = logistic_block(x) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = 1 / (1 + np.exp(-data)) gradient_true = np.diag(np.exp(data) / (1 + np.exp(data))**2) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong exp data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong exp gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient) ad.set_mode('forward')
def test_tanh_reverse(): ad.set_mode('reverse') # ============================================================================= # define the input variablet # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= tanh_block = tanh() # ============================================================================= # compute output of custom block # ============================================================================= y_block = tanh_block(x) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.tanh(data) gradient_true = np.diag(1 - np.tanh(data)**2) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong tanh data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong tanh gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient) ad.set_mode('forward')
def test_comp_forward(): ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= sin_block = sin() exp_block = exp() # ============================================================================= # compute output of custom block # ============================================================================= y_block = sin_block(exp_block(x)) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.sin(np.exp(data)) gradient_true = np.exp(data) * np.cos(np.exp(data)) * np.identity(5) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong exp data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong exp gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient)
def test_cosh_forward(): ad.set_mode('forward') # ============================================================================= # define the input variablet # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= cosh_block = cosh() # ============================================================================= # compute output of custom block # ============================================================================= y_block = cosh_block(x) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.cosh(data) gradient_true = np.diag(np.sinh(data)) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong cosh data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong cosh gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient)
def test_arctan_forward(): ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= arctan_block = arctan() # ============================================================================= # compute output of custom block # ============================================================================= y_block = arctan_block(x) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.arctan(data) gradient_true = np.diag(1 / (1 + data**2)) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong arctan data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong arctan gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient)
def test_multiple_forward(): """ assert that the package works well when we use it repetively """ ad.set_mode('forward') # ============================================================================= # define the input variable # ============================================================================= data = np.random.random(5) x = Variable(data) # ============================================================================= # define custom block # ============================================================================= sin_block = sin() exp_block = exp() # ============================================================================= # compute output of custom block # ============================================================================= y_block = sin_block(exp_block(x)) y_block.compute_gradients() # ============================================================================= # define expected output # ============================================================================= data_true = np.sin(np.exp(data)) gradient_true = np.exp(data) * np.cos(np.exp(data)) * np.identity(5) # ============================================================================= # assert data pass # ============================================================================= assert np.equal(data_true, y_block.data).all( ), 'wrong exp data pass. expected {}, given{}'.format( data_true, y_block.data) # ============================================================================= # assert gradient forward pass # ============================================================================= assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong exp gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient) # ============================================================================= # assert multiple gradient computes work # ============================================================================= for _ in range(5): y_block.compute_gradients() assert np.equal(data_true, y_block.data).all( ), 'wrong exp data pass. expected {}, given{}'.format( data_true, y_block.data) assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong exp gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient) # ============================================================================= # assert multiple passes work # ============================================================================= for _ in range(5): y_block = sin_block(exp_block(x)) y_block.compute_gradients() assert np.equal(data_true, y_block.data).all( ), 'wrong exp data pass. expected {}, given{}'.format( data_true, y_block.data) assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong exp gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient) # ============================================================================= # assert multiple definitions work # ============================================================================= for _ in range(5): data = np.random.random(5) x = Variable(data) sin_block = sin() exp_block = exp() y_block = sin_block(exp_block(x)) y_block.compute_gradients() data_true = np.sin(np.exp(data)) gradient_true = np.exp(data) * np.cos(np.exp(data)) * np.identity(5) assert np.equal(data_true, y_block.data).all( ), 'wrong exp data pass. expected {}, given{}'.format( data_true, y_block.data) assert np.equal(gradient_true, y_block.gradient).all( ), 'wrong exp gradient forward pass. expected {}, given{}'.format( gradient_true, y_block.gradient)