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