public void SumTest()
{
var data = new float[] { 1.0f, 2.0f, 3.0f };
var res1 = FloatTensor.From(data).Sum();
var res1_0 = res1.DataItem <float>();
Assert.Equal(6.0f, res1_0);
var res2 = FloatTensor.From(data).Sum(type: ScalarType.Double);
var res2_0 = res2.DataItem <double>();
Assert.Equal(6.0, res2_0);
// summing integers gives long unless type is explicitly specified
var dataInt32 = new int[] { 1, 2, 3 };
var res3 = IntTensor.From(dataInt32).Sum();
Assert.Equal(ScalarType.Long, res3.Type);
var res3_0 = res3.DataItem <long>();
Assert.Equal(6L, res3_0);
// summing integers gives long unless type is explicitly specified
var res4 = IntTensor.From(dataInt32).Sum(type: ScalarType.Int);
Assert.Equal(ScalarType.Int, res4.Type);
var res4_0 = res4.DataItem <int>();
Assert.Equal(6L, res4_0);
}
public void AtanTest()
{
var data = new float[] { 1.0f, 0.2f, -0.1f };
var expected = data.Select(MathF.Atan).ToArray();
var res = FloatTensor.From(data).Atan();
Assert.True(res.AllClose(FloatTensor.From(expected)));
}
public void RoundTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f };
var expected = data.Select(x => MathF.Round(x)).ToArray();
var res = FloatTensor.From(data).Round();
Assert.True(res.AllClose(FloatTensor.From(expected)));
}
public void TestErrorHandling()
{
using (TorchTensor input = FloatTensor.From(new float[] { 0.5f, 1.5f }))
using (TorchTensor target = FloatTensor.From(new float[] { 1f, 2f, 3f }))
{
Assert.Throws <SEHException>(() => NN.LossFunction.PoissonNLL()(input, target));
}
}
public void CosTest()
{
var data = new float[] { 1.0f, 2.0f, 3.0f };
var expected = data.Select(MathF.Cos).ToArray();
var res = FloatTensor.From(data).Cos();
Assert.True(res.AllClose(FloatTensor.From(expected)));
}
public void CreateFloatTensorFromScalar()
{
float scalar = 333.0f;
using (var tensor = FloatTensor.From(scalar))
{
Assert.AreEqual(tensor.Item <float>(), 333);
}
}
public void CreateFloatTensorFromScalar()
{
float scalar = 333.0f;
using (var tensor = FloatTensor.From(scalar))
{
Assert.Equal(333.0f, tensor.DataItem <float>());
}
}
public void NarrowTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f };
var res = FloatTensor.From(data).Narrow(0, 1, 2);
Assert.Equal(new long[] { 2 }, res.Shape);
Assert.Equal(2.0f, res[0].DataItem <float>());
Assert.Equal(3.1f, res[1].DataItem <float>());
}
public void GetSetItem6()
{
var shape = new long[] { 2, 3, 4, 5, 6, 7 };
TorchTensor t = FloatTensor.Ones(shape);
Assert.Equal(shape, t.Shape);
Assert.Equal(1.0f, t[0, 0, 0, 0, 0, 0].DataItem <float>());
Assert.Equal(1.0f, t[1, 2, 3, 4, 5, 6].DataItem <float>());
t[1, 2, 3, 4, 5, 6] = FloatTensor.From(2.0f);
Assert.Equal(2.0f, t[1, 2, 3, 4, 5, 6].DataItem <float>());
}
public void CreateFloatTensorFromData()
{
var data = new float[1000];
data[100] = 1;
using (var tensor = FloatTensor.From(data, new long[] { 100, 10 }))
{
Assert.Equal(1, tensor.Data <float>()[100]);
}
}
public void SqueezeTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f };
var res = FloatTensor.From(data).Expand(new long[] { 1, 1, 3 }).Squeeze(0).Squeeze(0);
Assert.Equal(new long[] { 3 }, res.Shape);
Assert.Equal(1.1f, res[0].DataItem <float>());
Assert.Equal(2.0f, res[1].DataItem <float>());
Assert.Equal(3.1f, res[2].DataItem <float>());
}
public void TestPoissonNLLLoss()
{
using (TorchTensor input = FloatTensor.From(new float[] { 0.5f, 1.5f, 2.5f }))
using (TorchTensor target = FloatTensor.From(new float[] { 1f, 2f, 3f }))
{
var componentWiseLoss = ((TorchTensor)input.Exp()) - target * input;
Assert.True(componentWiseLoss.Equal(NN.LossFunction.PoissonNLL(reduction: NN.Reduction.None)(input, target)));
Assert.True(componentWiseLoss.Sum().Equal(NN.LossFunction.PoissonNLL(reduction: NN.Reduction.Sum)(input, target)));
Assert.True(componentWiseLoss.Mean().Equal(NN.LossFunction.PoissonNLL(reduction: NN.Reduction.Mean)(input, target)));
}
}
public void SplitWithSizesTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f };
var res = FloatTensor.From(data).SplitWithSizes(new long[] { 2, 1 });
Assert.Equal(2, res.Length);
Assert.Equal(new long[] { 2 }, res[0].Shape);
Assert.Equal(new long[] { 1 }, res[1].Shape);
Assert.Equal(1.1f, res[0][0].DataItem <float>());
Assert.Equal(2.0f, res[0][1].DataItem <float>());
Assert.Equal(3.1f, res[1][0].DataItem <float>());
}
public void CreateFloatTensorFromDataCheckDispose()
{
var data = new float[1000];
data[100] = 1;
using (var tensor = FloatTensor.From(data, new long[] { 100, 10 }))
{
Assert.AreEqual(tensor.Data <float>()[100], 1);
}
Assert.AreEqual(data[100], 1);
}
public void TestSparse()
{
using (var i = LongTensor.From(new long[] { 0, 1, 1, 2, 0, 2 }, new long[] { 2, 3 }))
using (var v = FloatTensor.From(new float[] { 3, 4, 5 }, new long[] { 3 }))
{
var sparse = FloatTensor.Sparse(i, v, new long[] { 2, 3 });
Assert.True(sparse.IsSparse);
Assert.False(i.IsSparse);
Assert.False(v.IsSparse);
Assert.Equal(sparse.SparseIndices.Data <long>().ToArray(), new long[] { 0, 1, 1, 2, 0, 2 });
Assert.Equal(sparse.SparseValues.Data <float>().ToArray(), new float[] { 3, 4, 5 });
}
}
public void UnbindTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f };
var res = FloatTensor.From(data).Unbind();
Assert.Equal(3, res.Length);
Assert.Equal(new long[] { }, res[0].Shape);
Assert.Equal(new long[] { }, res[1].Shape);
Assert.Equal(new long[] { }, res[2].Shape);
Assert.Equal(1.1f, res[0].DataItem <float>());
Assert.Equal(2.0f, res[1].DataItem <float>());
Assert.Equal(3.1f, res[2].DataItem <float>());
}
public void SliceTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f, 4.0f };
var res = FloatTensor.From(data).Slice(0, 1, 1, 1);
Assert.Equal(new long[] { 0 }, res.Shape);
var res2 = FloatTensor.From(data).Slice(0, 1, 2, 1);
Assert.Equal(new long[] { 1 }, res2.Shape);
Assert.Equal(2.0f, res2[0].DataItem <float>());
var res3 = FloatTensor.From(data).Slice(0, 1, 4, 2);
Assert.Equal(new long[] { 2 }, res3.Shape);
Assert.Equal(2.0f, res3[0].DataItem <float>());
Assert.Equal(4.0f, res3[1].DataItem <float>());
}
public void TopKTest()
{
var data = new float[] { 1.1f, 2.0f, 3.1f };
var res1 = FloatTensor.From(data).TopK(1);
var res1_0 = res1.values[0].DataItem <float>();
var index1_0 = res1.indexes[0].DataItem <long>();
Assert.Equal(3.1f, res1_0);
Assert.Equal(2L, index1_0);
var res2 = FloatTensor.From(data).TopK(2, sorted: true);
var res2_0 = res2.values[0].DataItem <float>();
var index2_0 = res2.indexes[0].DataItem <long>();
var res2_1 = res2.values[1].DataItem <float>();
var index2_1 = res2.indexes[1].DataItem <long>();
Assert.Equal(3.1f, res2_0);
Assert.Equal(2L, index2_0);
Assert.Equal(2.0f, res2_1);
Assert.Equal(1L, index2_1);
}
public void Conv1DTest()
{
var t1 =
new float[3, 4, 5]
{
{ { 0.3460f, 0.4414f, 0.2384f, 0.7905f, 0.2267f },
{ 0.5161f, 0.9032f, 0.6741f, 0.6492f, 0.8576f },
{ 0.3373f, 0.0863f, 0.8137f, 0.2649f, 0.7125f },
{ 0.7144f, 0.1020f, 0.0437f, 0.5316f, 0.7366f } },
{ { 0.9871f, 0.7569f, 0.4329f, 0.1443f, 0.1515f },
{ 0.5950f, 0.7549f, 0.8619f, 0.0196f, 0.8741f },
{ 0.4595f, 0.7844f, 0.3580f, 0.6469f, 0.7782f },
{ 0.0130f, 0.8869f, 0.8532f, 0.2119f, 0.8120f } },
{ { 0.5163f, 0.5590f, 0.5155f, 0.1905f, 0.4255f },
{ 0.0823f, 0.7887f, 0.8918f, 0.9243f, 0.1068f },
{ 0.0337f, 0.2771f, 0.9744f, 0.0459f, 0.4082f },
{ 0.9154f, 0.2569f, 0.9235f, 0.9234f, 0.3148f } }
};
var t2 =
new float[2, 4, 3]
{
{ { 0.4941f, 0.8710f, 0.0606f },
{ 0.2831f, 0.7930f, 0.5602f },
{ 0.0024f, 0.1236f, 0.4394f },
{ 0.9086f, 0.1277f, 0.2450f } },
{ { 0.5196f, 0.1349f, 0.0282f },
{ 0.1749f, 0.6234f, 0.5502f },
{ 0.7678f, 0.0733f, 0.3396f },
{ 0.6023f, 0.6546f, 0.3439f } }
};
var t1raw = new float[3 * 4 * 5];
var t2raw = new float[2 * 4 * 3];
{ for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
t1raw[i * 4 * 5 + j * 5 + k] = t1[i, j, k];
}
}
}
}
{ for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 3; k++)
{
t2raw[i * 4 * 3 + j * 3 + k] = t2[i, j, k];
}
}
}
}
var t1t = FloatTensor.From(t1raw, new long[] { 3, 4, 5 });
var t2t = FloatTensor.From(t2raw, new long[] { 2, 4, 3 });
var t3t = t1t.Conv1D(t2t);
// Check the answer
var t3Correct =
new float[3, 2, 3]
{
{ { 2.8516f, 2.0732f, 2.6420f },
{ 2.3239f, 1.7078f, 2.7450f } },
{ { 3.0127f, 2.9651f, 2.5219f },
{ 3.0899f, 3.1496f, 2.4110f } },
{ { 3.4749f, 2.9038f, 2.7131f },
{ 2.7692f, 2.9444f, 3.2554f } }
};
{
var data = t3t.Data <float>();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 2; j++)
{
for (int k = 0; k < 3; k++)
{
var itemCorrect = t3Correct[i, j, k];
var item = data[i * 2 * 3 + j * 3 + k];
Assert.True(Math.Abs(itemCorrect - item) < 0.01f);
}
}
}
}
var t3p2d3 = t1t.Conv1D(t2t, padding: 2, dilation: 3);
// Check the answer
var t3p2d3Correct =
new float[3, 2, 3]
{
{ { 2.1121f, 0.8484f, 2.2709f },
{ 1.6692f, 0.5406f, 1.8381f } },
{ { 2.5078f, 1.2137f, 0.9173f },
{ 2.2395f, 1.1805f, 1.1954f } },
{ { 1.5215f, 1.3946f, 2.1327f },
{ 1.0732f, 1.3014f, 2.0696f } }
};
{
var data = t3p2d3.Data <float>();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 2; j++)
{
for (int k = 0; k < 3; k++)
{
var itemCorrect = t3p2d3Correct[i, j, k];
var item = data[i * 2 * 3 + j * 3 + k];
Assert.True(Math.Abs(itemCorrect - item) < 0.01f);
}
}
}
}
}
