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);
}
