public void TestSumInt4_2() { var a = NN.Range(24).Reshape(1, 2, 3, 4); var b = NN.Range(12).Reshape(3, 4); var expected = NN.Array(new int[, , , ] { { { { 0, 2, 4, 6 }, { 8, 10, 12, 14 }, { 16, 18, 20, 22 } }, { { 12, 14, 16, 18 }, { 20, 22, 24, 26 }, { 28, 30, 32, 34 } } } }); var c = a + b; AssertArray.AreEqual(expected.Values, c.Values); }
public void TestRange() { var a = NN.Range(4); AssertArray.AreEqual(new[] { 0, 1, 2, 3 }, a); AssertArray.AreEqual(new[] { 0, 1, 2, 3 }, a[_]); AssertArray.AreEqual(new[] { 0, 1 }, a[(0, 2)]);
public void ComplexReshapeWorksWithCopyFlag() { var a = NN.Range(4 * 3).Reshape(4, 3); var exp = NN.Array(new int[] { 0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11 }); AssertArray.AreEqual(exp, a.T.Reshape(new int[] { -1 }, allowCopy: true)); }
public void TestShuffleInplaceDim3() { var a = NN.Range(24).Reshape(3, 2, 4); var b = NN.Range(24).Reshape(3, 2, 4); var c = NN.Range(24).Reshape(3, 2, 4); int[] perms1 = new int[3] { 0, 2, 1 }; int[] perms2 = new int[2] { 1, 0 }; int[] perms3 = new int[4] { 3, 1, 0, 2 }; var expected1 = NN.Array(new int[24] { 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 8, 9, 10, 11, 12, 13, 14, 15 }).Reshape(3, 2, 4); var expected2 = NN.Array(new int[24] { 4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15, 8, 9, 10, 11, 20, 21, 22, 23, 16, 17, 18, 19 }).Reshape(3, 2, 4); var expected3 = NN.Array(new int[24] { 2, 1, 3, 0, 6, 5, 7, 4, 10, 9, 11, 8, 14, 13, 15, 12, 18, 17, 19, 16, 22, 21, 23, 20 }).Reshape(3, 2, 4); a.ShuffleInplace(perms: perms1); b.ShuffleInplace(perms: perms2, axis: 1); c.ShuffleInplace(perms: perms3, axis: 2); AssertArray.AreEqual(a, expected1); AssertArray.AreEqual(b, expected2); AssertArray.AreEqual(c, expected3); }
public void ConcatWorksWithTwoArrays() { // Test Concat(1, 2D, 2D) var a = NN.Range(12).Reshape(3, 4); var b = NN.Range(9).Reshape(3, 3); var c = NN.Concat(1, a, b); var d = NN.Array(new int[, ]
public void TestMax() { var a = NN.Range(4 * 2).Reshape(4, 2); a.Item[2, 1] = -1; a.Item[0, 1] = 10; AssertArray.AreEqual(NN.Array(new[] { 6, 10 }), a.Max(axis: 0)); AssertArray.AreEqual(NN.Array(new[] { 10, 3, 4, 7 }), a.Max(axis: 1)); }
public void SlicingCompiles() { var x = T.Matrix <float>(10, 5, "x"); var loss = T.Norm2(x[From(2)]); var f = T.Function(input: x, output: loss); f(NN.Range <float>(50).Reshape(10, 5)); }
public void TestMin() { var a = NN.Range(4 * 2).Reshape(4, 2); a.Item[2, 1] = -1; a.Item[0, 1] = 10; AssertArray.AreEqual(NN.Array(new[] { 0, -1 }), a.Min(axis: 0)); AssertArray.AreEqual(NN.Array(new[] { 0, 2, -1, 6 }), a.Min(axis: 1)); }
public void TestRange() { var i = T.Scalar <int>("i"); var x = T.Range(i); var f = T.Function(i, x); AssertArray.AreEqual(NN.Range(10), f(10)); }
public void CanReshape_6_to_2_3() { var a0 = NN.Range(6); var b = NN.Array(new[, ] { { 0, 1, 2 }, { 3, 4, 5 } }); AssertArray.GenerateTests(a0, a => AssertArray.AreEqual(b, a.Reshape(2, 3))); }
public void CanReshape_6_to_2_3_WithForcedCopy() { var a0 = NN.Range(6); var b = NN.Array(new[, ] { { 0, 1, 2 }, { 3, 4, 5 } }); AssertArray.GenerateTests(a0, a => AssertArray.AreEqual(b, a.Reshape(new[] { 2, 3 }, forceCopy: true))); }
public void TestSigmoidCostGrad() { var x = Vector <float>("x"); var sigmoid = Sigmoid(x).Named("sigmoid"); var cost = (0.5f * Norm2(sigmoid)).Named("cost"); var g = Grad(cost, x).Named("g"); var f = Function(input: x, output: (cost, g)); f(NN.Range <float>(5)); }
public void TestLogOfSoftmax() { var x = T.Vector <float>("x"); var y = T.Scalar <int>("y"); var W = T.Shared(NN.Range <float>(5 * 4).Reshape(5, 4), "W"); var output = T.Tanh(T.Dot(W, x)); var p_y_given_x = T.Softmax(output); var y_pred = T.Sum(T.Argmax(p_y_given_x, axis: 0)); var nll = -T.Log(T.Sum(p_y_given_x[y])); var loss = T.Function(input: (x, y), output: nll); }
// TODO: this test doesn't work due to bugs in Elementwise public void PushCoherentGradientOnComplexAbstraction() { var x = T.Shared(NN.Range <float>(4), "x"); var b = T.Scalar <float>("b"); var y = T.Apply(x, x_ => (x_ > 0f) * b + x_ + b); var loss = T.Sum(y); AssertArray.WithMessage("Can't compile the gradient.", () => T.Function(input: b, output: T.Grad(loss, b)) ); AssertTensor.PassesGradientCheck(loss, b); }
public void TestShuffleInPlaceDim1() { var a = NN.Range(10); int[] perm = new int[10] { 1, 2, 3, 8, 9, 0, 4, 6, 7, 5 }; var expected = NN.Array(new int[10] { 5, 0, 1, 2, 6, 9, 7, 8, 3, 4 }); a.ShuffleInplace(perm); AssertArray.AreEqual(a, expected); }
// TODO: this test doesn't work due to bugs in Elementwise public void PushCoherentGradientOnSimpleAbstraction() { var x = T.Shared(NN.Range <float>(4), "x"); var b = T.Scalar <float>("b"); var y = T.Apply(x, x_ => x_ + b); var loss = T.Sum(y); var dL_db = T.Function(b, T.Grad(loss, b)); //dL_db should be 4; AssertArray.AreEqual(NN.Const(4f, 10), NN.Range <float>(10).Apply(dL_db)); }
public void CanReshapeReversedArray() { var a = NN.Zeros <int>(6); a[Step(-1)] = NN.Range(6); a = a[Step(-1)]; var b = NN.Array(new[, ] { { 0, 1, 2 }, { 3, 4, 5 } }); AssertArray.AreEqual(NN.Range(6), a); AssertArray.AreEqual(b, a.Reshape(2, 3)); }
public void TestSimpleReshape() { var a = NN.Range(4 * 3).Reshape(4, 3); var exp = NN.Array(new int[, ] { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 } }); AssertArray.AreEqual(exp, a); AssertArray.AreEqual(exp, NN.Range(4 * 3).Reshape(4, -1)); AssertArray.AreEqual(exp, NN.Range(4 * 3).Reshape(-1, 3)); AssertArray.AreEqual(NN.Range(12), a.Reshape(-1)); }
public void CanInsertNewAxis() { // http://www.onlamp.com/pub/a/python/2000/09/27/numerically.html?page=3 /* * * b=np.arange(2 * 3).reshape(2, 3) * b[:,np.newaxis,:] * */ var b = NN.Range(2 * 3).Reshape(2, 3); var c = b[_, NewAxis, _]; AssertArray.AreEqual(c.Shape, new[] { 2, 1, 3 }); AssertArray.AreEqual(c.Stride, new[] { 3, 0, 1 }); }
public void TestSum3_1() { var a = NN.Range(24).Reshape(2, 3, 4).As <float>(); var b = NN.Range(4).As <float>(); var expected = NN.Array(new float[, , ] { { { 0, 2, 4, 6 }, { 4, 6, 8, 10 }, { 8, 10, 12, 14 } }, { { 12, 14, 16, 18 }, { 16, 18, 20, 22 }, { 20, 22, 24, 26 } } }); var c = a + b; AssertArray.AreEqual(expected.Values, c.Values); }
public void TestShuffleDim2() { var a = NN.Range(20).Reshape(4, 5); int[] permsRow = new int[4] { 2, 0, 3, 1 }; int[] permsCol = new int[5] { 0, 3, 1, 4, 2 }; var expectedRow = NN.Array(new int[20] { 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 0, 1, 2, 3, 4, 10, 11, 12, 13, 14 }).Reshape(4, 5); var expectedCol = NN.Array(new int[20] { 0, 2, 4, 1, 3, 5, 7, 9, 6, 8, 10, 12, 14, 11, 13, 15, 17, 19, 16, 18 }).Reshape(4, 5); var shufARow = a.Shuffle(perms: permsRow); var shufACol = a.Shuffle(perms: permsCol, axis: 1); AssertArray.AreEqual(shufARow, expectedRow); AssertArray.AreEqual(shufACol, expectedCol); }
public void TestGenerateVec() { var a = NN.Range<float>(5); var c = a.Copy(); AssertArray.GenerateTests(a, b => AssertArray.AreAlmostEqual(c, b)); }
public static Array <int> Range(int start, int stop, int step = 1, Array <int> result = null) => NN.Range(start, stop, step, result);
public static Array <int> Range(this int start, int stop) => NN.Range(start, stop);
public void ComplexReshapeFailsWithoutCopyFlag() { var a = NN.Range(4 * 3).Reshape(4, 3); a.T.Reshape(new int[] { -1 }, allowCopy: false); }
public void TestGenerateMat() { var a = NN.Range<float>(12).Reshape(4, 3); var c = a.Copy(); AssertArray.GenerateTests(a, b => AssertArray.AreAlmostEqual(c, b)); }
public void NumNetInitArange(int n, int m) { var a = NN.Range(n * m).Reshape(n, m); }