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