public void zeros4D()
{
var a = alb.zeros(new int[] { 3, 2, 1, 1 });
AssertTools.ArrayIsEqual(a.Shape, new int[] { 3, 2, 1, 1 });
AssertTools.ArrayIsEqual(a.dataSync(), new float[] { 0, 0, 0, 0, 0, 0 });
}
public void tidyreturntensors()
{
ENV.engine = new Engine();
int current = ENV.engine.memory().numTensors;
alb.tidy(() =>
{
current = ENV.engine.memory().numTensors;
var a = alb.tensor1d(alb.data(1, 2, 3));
var b = alb.tensor1d(alb.data(0, 0, 0));
Assert.AreEqual(current + 2, ENV.engine.memory().numTensors);
alb.tidy(() =>
{
var result = alb.tidy(() =>
{
b = alb.addStrict(a, b);
b = alb.addStrict(a, b);
b = alb.addStrict(a, b);
return(alb.add(a, b));
});
// result is new. All intermediates should be disposed.
Assert.AreEqual(current + 2 + 1, ENV.engine.memory().numTensors);
AssertTools.ArrayIsEqual(result.ToArray(), alb.data(4, 8, 12));
});
// a, b are still here, result should be disposed.
Assert.AreEqual(ENV.engine.memory().numTensors, current + 2);
});
Assert.AreEqual(current + 0, ENV.engine.memory().numTensors);
}
public void ones4D()
{
var a = alb.ones(new int[] { 3, 2, 1, 1 });
AssertTools.ArrayIsEqual(a.Shape, new int[] { 3, 2, 1, 1 });
AssertTools.ArrayIsEqual(a.dataSync(), new float[] { 1, 1, 1, 1, 1, 1 });
}
public void tilepropagatesNaNs()
{
var t = alb.tensor1d(alb.data(1, 2, float.NaN));
var t2 = alb.tile(t, alb.shape(2));
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(6));
AssertTools.ArrayIsEqual(t2, alb.data(1, 2, float.NaN, 1, 2, float.NaN));
}
public void gather1d()
{
var t = alb.tensor1d(alb.data(1, 2, 3));
var t2 = alb.gather(t, alb.tensor1d(alb.data(0, 2, 0, 1)), 0);
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(4));
AssertTools.ArrayIsEqual(t2, alb.data(1, 3, 1, 2));
}
public void tile3D()
{
var t = alb.tensor3d(alb.data(1, 2, 3, 4, 5, 6, 7, 8), 2, 2, 2);
var t2 = alb.tile(t, alb.shape(1, 2, 1));
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(2, 4, 2));
AssertTools.ArrayIsEqual(t2, alb.data(1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 7, 8));
}
public void onesLike4d()
{
var a = alb.tensor4d(new float[] { 1, 2, 3, 4 }, 2, 2, 1, 1);
var b = alb.onesLike(a);
AssertTools.ArrayIsEqual(b.Shape, new int[] { 2, 2, 1, 1 });
AssertTools.ArrayIsEqual(b.dataSync(), new float[] { 1, 1, 1, 1 });
}
public void tile1d()
{
var t = alb.tensor1d(alb.data(1, 2, 3));
var t2 = alb.tile(t, alb.shape(2));
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(6));
AssertTools.ArrayIsEqual(t2, alb.data(1, 2, 3, 1, 2, 3));
}
public void zeros2D()
{
ENV.engine = new Engine();
var a = alb.zeros(new int[] { 3, 2 });
AssertTools.ArrayIsEqual(a.Shape, new int[] { 3, 2 });
AssertTools.ArrayIsEqual(a.dataSync(), new float[] { 0, 0, 0, 0, 0, 0 });
}
public void zerosLike2d()
{
var a = alb.tensor2d(new float[] { 1, 2, 3, 4 }, 2, 2);
var b = alb.zerosLike(a);
AssertTools.ArrayIsEqual(b.Shape, new int[] { 2, 2 });
AssertTools.ArrayIsEqual(b.dataSync(), new float[] { 0, 0, 0, 0 });
}
public void gather3D()
{
var t = alb.tensor3d(alb.data(1, 2, 3, 4, 5, 6, 7, 8), 2, 2, 2);
var t2 = alb.gather(t, alb.tensor1d(alb.data(1, 0, 0, 1)), 2);
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(2, 2, 4));
AssertTools.ArrayIsEqual(t2, alb.data(2, 1, 1, 2, 4, 3, 3, 4, 6, 5, 5, 6, 8, 7, 7, 8));
}
public void gradsf()
{
ENV.engine = new Engine();
var grad = alb.grads(x => x[0].square());
var result = grad(new Tensor[] { alb.tensor1d(new float[] { .1f, .2f }) }, null);
AssertTools.ArrayIsEqual(result[0].dataSync(), new float[] { .2f, .4f });
}
public void gatherpropagatesNaNs()
{
var t = alb.tensor1d(alb.data(1, 2, float.NaN));
var t2 = alb.gather(t, alb.tensor1d(alb.data(0, 2, 0, 1)), 0);
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(4));
AssertTools.ArrayIsEqual(t2, alb.data(1, float.NaN, 1, 2));
}
public void oneHotDepth2onValue3offValue_minus_2()
{
var indices = alb.tensor1d(alb.data(0, 1));
var res = alb.oneHot(indices, 2, 3, -2);
AssertTools.ArrayIsEqual(res.Shape, alb.shape(2, 2));
AssertTools.TensorIsEqual(res, alb.data(3, -2, -2, 3).ToTensor(2, 2));
}
public void gatherchaining()
{
var x = alb.zeros(alb.shape(2, 4, 6));
// [0, 2, 4]
var indices = alb.range(0, 6, 2);
var axis = 2;
AssertTools.ArrayIsEqual(x.gather(indices, axis).Shape, alb.shape(2, 4, 3));
}
public void oneHotDepth3events4()
{
var indices = alb.tensor1d(alb.data(2, 1, 2, 0));
var res = alb.oneHot(indices, 3);
AssertTools.ArrayIsEqual(res.Shape, alb.shape(4, 3));
AssertTools.TensorIsEqual(res, alb.data(0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0).ToTensor(4, 3));
}
public void oneHotDepth2transposeddiagonal()
{
var indices = alb.tensor1d(alb.data(1, 0));
var res = alb.oneHot(indices, 2);
AssertTools.ArrayIsEqual(res.Shape, alb.shape(2, 2));
AssertTools.TensorIsEqual(res, alb.data(0, 1, 1, 0).ToTensor(2, 2));
}
public void oneHotOut_of_range_events_do_not_trigger_onValue()
{
ENV.engine = new Engine();
var indices = alb.tensor1d(alb.data(-1, 5, 12345));
var res = alb.oneHot(indices, 5);
AssertTools.ArrayIsEqual(res.Shape, alb.shape(3, 5));
AssertTools.TensorIsEqual(res, alb.data(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).ToTensor(3, 5));
}
public void calling_gradf_twice_works()
{
ENV.engine = new Engine();
var grad = alb.grad(x => x.square());
var result = grad(alb.tensor1d(new float[] { .1f, .2f }), null);
var result2 = grad(alb.tensor1d(new float[] { .1f, .4f }), null);
AssertTools.ArrayIsEqual(result.dataSync(), new float[] { .2f, .4f });
AssertTools.ArrayIsEqual(result2.dataSync(), new float[] { .2f, .8f });
}
public void tile1dgradient()
{
var t = alb.tensor1d(alb.data(1, 2, 3));
var dy = alb.tensor1d(alb.data(0.1f, 0.2f, 0.3f, 1, 2, 3, 10, 20, 30));
var grad = alb.grad((Tensor x) => { return(alb.tile(x, alb.shape(3))); });
var d = grad(t, dy);
AssertTools.ArrayIsEqual(d, alb.data(11.1f, 22.2f, 33.3f));
}
public void gather2d()
{
var t = alb.tensor2d(alb.data(1, 11, 2, 22), 2, 2);
var t2 = alb.gather(t, alb.tensor1d(alb.data(1, 0, 0, 1)), 0);
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(4, 2));
AssertTools.ArrayIsEqual(t2, alb.data(2, 22, 1, 11, 1, 11, 2, 22));
t2 = alb.gather(t, alb.tensor1d(alb.data(1, 0, 0, 1)), 1);
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(2, 4));
AssertTools.ArrayIsEqual(t2, alb.data(11, 1, 1, 11, 22, 2, 2, 22));
}
public void gather1dgradient()
{
var t = alb.tensor1d(alb.data(1, 2, 3));
var indices = alb.tensor1d(alb.data(0, 2, 0, 1));
var dy = alb.tensor1d(alb.data(3, 4, 5, 6));
var grad = alb.grad((Tensor x) => { return(alb.gather(x, indices)); });
var d = grad(t, dy);
AssertTools.ArrayIsEqual(d, alb.data(8, 6, 4));
}
public void grads_grads_f()
{
ENV.engine = new Engine();
var gradgrad = alb.grads((Tensor[] x) =>
{
return(alb.grads(x2 => x2[0].mul(x2[0]).mul(x2[0]))(x, null)[0]);
}
);
var result = gradgrad(new Tensor[] { alb.tensor1d(new float[] { .1f, .2f }) }, null);
AssertTools.ArrayIsEqual(result[0].dataSync(), new float[] { .6f, 1.2f });
}
public void grad_grad_f()
{
ENV.engine = new Engine();
var gradgrad = alb.grad((Tensor x) =>
{
return(alb.grad(x2 => x2.mul(x2).mul(x2))(x, null));
}
);
var result = gradgrad(alb.tensor1d(new float[] { .1f, .2f }), null);
AssertTools.ArrayIsEqual(result.dataSync(), new float[] { .6f, 1.2f });
}
public void gather2dgradient4_1()
{
var t = alb.tensor2d(alb.data(1, 11, 2, 22), 4, 1);
var indices = alb.tensor1d(alb.data(1, 0, 0, 1));
var dy = alb.tensor2d(alb.data(23, 7, 19, 13), 4, 1);
var axis = 0;
var grad = alb.grad((Tensor x) => { return(alb.gather(x, indices, axis)); });
var d = grad(t, dy);
AssertTools.ArrayIsEqual(t.Shape, d.Shape);
AssertTools.TensorIsEqual(d, alb.data(26, 36, 0, 0).ToTensor(4, 1));
}
public void gather2dgradient2_2()
{
var t = alb.tensor2d(alb.data(1, 11, 2, 22), 2, 2);
var indices = alb.tensor1d(alb.data(1, 0, 0, 1));
var dy = alb.tensor2d(alb.data(3, 4, 5, 6, 7, 8, 9, 10), 2, 4);
var axis = 1;
var grad = alb.grad((Tensor x) => { return(alb.gather(x, indices, axis)); });
var d = grad(t, dy);
AssertTools.ArrayIsEqual(t.Shape, d.Shape);
AssertTools.TensorIsEqual(d, alb.data(9, 9, 17, 17).ToTensor(4, 1));
}
public void does_not_error_if_irrelevant_pruned_ops_are_missing_grads()
{
ENV.engine = new Engine();
var a = alb.tensor1d(new float[] { 1, 1 });
var b = alb.tensor1d(new float[] { 0, 1 });
var da = alb.grad(aI =>
{
// Logical has no gradients, but it is irrelevant.
aI.logicalAnd(b);
return(aI.sum());
})(a, null);
AssertTools.ArrayIsEqual(da.dataSync(), new float[] { 1, 1 });
}
public void works_with_reshape()
{
ENV.engine = new Engine();
var a = alb.data(1, 2, 3, 4).ToTensor(2, 2);
var exponent = alb.data(2, 2, 2, 2).ToTensor();
var da = alb.grad(aI =>
{
var b = aI.flatten();
var m = alb.pow(b, exponent);
return(alb.sum(m));
})(a, null);
AssertTools.ArrayIsEqual(da.Shape, new int[] { 2, 2 });
AssertTools.ArrayIsEqual(da.dataSync(), new float[] { 2, 4, 6, 8 });
}
public void tile2d()
{
var t = alb.tensor2d(alb.data(1, 11, 2, 22), 2, 2);
var t2 = alb.tile(t, alb.shape(1, 2));
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(2, 4));
AssertTools.ArrayIsEqual(t2, alb.data(1, 11, 1, 11, 2, 22, 2, 22));
t2 = alb.tile(t, alb.shape(2, 1));
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(4, 2));
AssertTools.ArrayIsEqual(t2, alb.data(1, 11, 2, 22, 1, 11, 2, 22));
t2 = alb.tile(t, alb.shape(2, 2));
AssertTools.ArrayIsEqual(t2.Shape, alb.shape(4, 4));
AssertTools.ArrayIsEqual(t2, alb.data(1, 11, 1, 11, 2, 22, 2, 22, 1, 11, 1, 11, 2, 22, 2, 22));
}
public void gradients()
{
ENV.engine = new Engine();
var a = alb.tensor2d(new float[] { -1, 2, -3, 10, -20, 30 }, 2, 3);
var b = alb.tensor2d(new float[] { 2, -3, 4, -1, 2, -3 }, 3, 2);
var grads = alb.grads((Tensor[] x) =>
{
var aI = x[0];
var bI = x[1];
// m = dot(a, b)
// y = relu(m)
// e = sum(y)
var m = alb.matMul(aI, bI);
var y = alb.relu(m);
return(alb.sum(y));
})(new Tensor[] { a, b }, null);
var da = grads[0];
var db = grads[1];
// de/dy = 1
// dy/dm = step(m)
// de/dm = de/dy * dy/dm = step(m)
var dedm = alb.step(alb.matMul(a, b));
// de/da = dot(de/dy, bT)
AssertTools.ArrayIsEqual(da.Shape, a.Shape);
var transposeA = false;
var transposeB = true;
AssertTools.TensorIsEqual(da, alb.matMul(dedm, b, transposeA, transposeB));
AssertTools.ArrayIsEqual(db.Shape, b.Shape);
transposeA = true;
transposeB = false;
AssertTools.TensorIsEqual(db, alb.matMul(a, dedm, transposeA, transposeB));
}
