def test_var_only_int(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 5; backward(x); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 1.")
def test_multiple_dvars_mult(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 10.; y:track_grad = 1.; backward(x * y); grad(x) + grad(y); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 11.")
def test_expr_with_intermediate_var_of_dvar_and_dvar(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 5.; y = x * 10.; backward(y + x); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 11.")
def test_dvar_shadowing(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 10.; x:track_grad = 5.; backward(10. / x); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith(f"SUCCESS: -0.4")
def test_dvar_set_to_intermediate_var(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 5.; y = x; backward(y); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 1.")
def test_binop_dvar_on_right(self, compiler_bin, binop, res): prog = inspect.cleandoc(f""" x:track_grad = 10.; backward(10. {binop} x); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith(f"SUCCESS: {res}")
def test_multiple_backward_calls_mult(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 5.; backward(x * 2.); backward(x * 5.); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 7.")
def test_fill_dims(self, compiler_bin, rows, cols): prog = inspect.cleandoc(f""" m = fill({rows}, {cols}, 0.0); numrows(m) * 10 + numcols(m); """) expected = int(rows) * 10 + int(cols) assert run_interpreter(compiler_bin, prog).startswith(f'SUCCESS: {expected}')
def test_both_matrices_tracked(self, compiler_bin): prog = inspect.cleandoc(""" m1:track_grad = Matrix[[1., 2., 3.],[4., 5., 6.]]; m2:track_grad = Matrix[[11., 12.],[13., 14.],[15., 16.]]; backward(m1 @ m2); sum(grad(m1)) + sum(grad(m2)); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 204.")
def test_binop_dvar_on_right(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Vector[10., 10.]; backward(Vector[10., 10.] + x); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: Vector[1., 1.]")
def test_binop_dvar_on_left(self, compiler_bin, binop, res): prog = inspect.cleandoc(f""" x:track_grad = Vector[10., 10.]; backward(x {binop} Vector[2., 2.]); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith(f"SUCCESS: {res}")
def test_binop_dvar_both_sides(self, compiler_bin, binop, res): prog = inspect.cleandoc(f""" x:track_grad = Matrix[[10.]]; backward(x {binop} x); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:{res}")
def test_empty_matrices(self, compiler_bin): prog = inspect.cleandoc(""" m1:track_grad = Matrix[[]]; backward(m1 @ Matrix[[]]); grad(m1); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:Matrix[[]]")
def test_access_columns(self, compiler_bin, i, sol): prog = inspect.cleandoc(f""" x:track_grad = Matrix[[1.,0.,0.],[0.,0.,0.],[0.,0.,0.]]; backward(x[{i}]); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:{sol}")
def test_binop_int_float_coercion(self, compiler_bin, x, y, res): prog = inspect.cleandoc(f""" x:track_grad = {x}; backward(x * {y}); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:{res}")
def test_flat_matrices(self, compiler_bin, m1, m2, res): prog = inspect.cleandoc(f""" m1:track_grad = {m1}; backward(m1 @ {m2}); grad(m1); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:{res}")
def test_access_one_element(self, compiler_bin, i, sol): prog = inspect.cleandoc(f""" x:track_grad = Matrix[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]; backward(x[{i}]); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:{sol}")
def test_basic_accessor_use(self, compiler_bin, i, sol): prog = inspect.cleandoc(f""" x:track_grad = Vector[1., 2., 3.]; backward(x[{i},]); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith(f"SUCCESS: {sol}")
def test_vector_only_int(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Vector[5, 5]; backward(x); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: Vector[1., 1.]")
def test_using_accessors_alternate_access(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Vector[1., 2., 3.]; z = x[,0] + 3 * x[,1] + 5 * x[,2]; backward(z); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: Vector[1., 3., 5.]")
def test_multiple_backward_calls_mult(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Matrix[[5.]]; backward(x * Matrix[[2.]]); backward(x * Matrix[[5.]]); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith("SUCCESS:Matrix[[7.]]")
def test_decimals(self, compiler_bin): prog = inspect.cleandoc(""" m1:track_grad = Matrix[[1.5, 2.0], [3.213, 4.12]]; m2 = Matrix[[1.5, 2.0], [3.213, 4.12]]; backward(m1 @ m2); grad(m1); """) assert "".join(run_interpreter(compiler_bin, prog).split()).startswith( "SUCCESS:Matrix[[3.5,7.333],[3.5,7.333]]")
def test_binop_dvar_on_right(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Matrix[[10.,10.],[10.,10.]]; backward(Matrix[[10.,10.],[10.,10.]] + x); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith("SUCCESS:Matrix[[1.,1.],[1.,1.]]")
def test_backward_without_track_grad_set_to_tracked_var( self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 5.; y = x; backward(y); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS:")
def test_multiple_backward_calls_mult(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Vector[5.]; backward(x * Vector[2.]); backward(x * Vector[5.]); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: Vector[7.]")
def test_multiple_dvars_add(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Vector[5.]; y:track_grad = Vector[5.]; backward(x + y); grad(x) + grad(y); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: Vector[2.]")
def test_square_matrices(self, compiler_bin, m2, res): prog = inspect.cleandoc(f""" m1:track_grad = Matrix[[1., 2.], [3., 4.]]; backward(m1 @ {m2}); grad(m1); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith(f"SUCCESS:{''.join(res.split())}")
def test_multiple_dvars_mult(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Matrix[[10.]]; y:track_grad = Matrix[[1.]]; backward(x * y); grad(x) + grad(y); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith("SUCCESS:Matrix[[11.]]")
def test_matrix_only_int(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = Matrix[[5, 5], [5, 5]]; backward(x); grad(x); """) assert "".join(run_interpreter( compiler_bin, prog).split()).startswith("SUCCESS:Matrix[[1.,1.],[1.,1.]]")
def test_multiple_backward_calls_intermediaries(self, compiler_bin): prog = inspect.cleandoc(""" x:track_grad = 5.; backward(x * 2.); y = (x + 10.) * x; backward(y); grad(x); """) assert run_interpreter(compiler_bin, prog).startswith("SUCCESS: 22.")