scisharp
/
TensorFlow.NET
Not watched
1
0
Fork 0
Code
Releases 21 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 5e4f53077f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5e4f53077f'
${ noResults }
TensorFlow.NET/test/TensorFlowNET.UnitTest/ManagedAPI/ArrayOpsTest.cs

427 lines
15 kB
Raw Blame History 

  1. using Microsoft.VisualStudio.TestTools.UnitTesting;

  2. using Tensorflow.NumPy;

  3. using Tensorflow;

  4. using static Tensorflow.Binding;

  5. using System.Linq;

  6. using Tensorflow.Operations;

  7. 

  8. namespace TensorFlowNET.UnitTest.ManagedAPI

  9. {

  10.     [TestClass]

  11.     public class ArrayOpsTest : EagerModeTestBase

  12.     {

  13.         /// <summary>

  14.         /// https://www.tensorflow.org/api_docs/python/tf/slice

  15.         /// </summary>

  16.         [TestMethod]

  17.         public void Slice()

  18.         {

  19.             // Tests based on example code in TF documentation

  20.             var input_array = tf.constant(np.array(new int[] { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6 }).reshape((3,2,3)));

  21.             var indices = tf.constant(np.array(new int[] { 0, 2 }));

  22. 

  23.             var r1 = array_ops.slice(input_array, ops.convert_n_to_tensor(new object[] { 1, 0, 0 }), ops.convert_n_to_tensor(new object[] { 1, 1, 3 }));

  24.             Assert.AreEqual(new Shape(1,1,3), r1.shape);

  25.             var r1np = r1.numpy();

  26.             Assert.AreEqual(r1np[0, 0, 0], 3);

  27.             Assert.AreEqual(r1np[0, 0, 1], 3);

  28.             Assert.AreEqual(r1np[0, 0, 2], 3);

  29. 

  30. 

  31.             var r2 = array_ops.slice(input_array, ops.convert_n_to_tensor(new object[] { 1, 0, 0 }), ops.convert_n_to_tensor(new object[] { 1, 2, 3 }));

  32.             Assert.AreEqual(new Shape(1, 2, 3), r2.shape);

  33.             var r2np = r2.numpy();

  34.             Assert.AreEqual(r2np[0, 0, 0], 3);

  35.             Assert.AreEqual(r2np[0, 0, 1], 3);

  36.             Assert.AreEqual(r2np[0, 0, 2], 3);

  37.             Assert.AreEqual(r2np[0, 1, 0], 4);

  38.             Assert.AreEqual(r2np[0, 1, 1], 4);

  39.             Assert.AreEqual(r2np[0, 1, 2], 4);

  40. 

  41.             var r3 = array_ops.slice(input_array, ops.convert_n_to_tensor(new object[] { 1, 0, 0 }), ops.convert_n_to_tensor(new object[] { 2, 1, 3 }));

  42.             Assert.AreEqual(new Shape(2, 1, 3), r3.shape);

  43.             var r3np = r3.numpy();

  44.             Assert.AreEqual(r3np[0, 0, 0], 3);

  45.             Assert.AreEqual(r3np[0, 0, 1], 3);

  46.             Assert.AreEqual(r3np[0, 0, 2], 3);

  47.             Assert.AreEqual(r3np[1, 0, 0], 5);

  48.             Assert.AreEqual(r3np[1, 0, 1], 5);

  49.             Assert.AreEqual(r3np[1, 0, 2], 5);

  50.         }

  51. 

  52.         /// <summary>

  53.         /// https://www.tensorflow.org/api_docs/python/tf/gather

  54.         /// </summary>

  55.         [TestMethod]

  56.         public void Gather()

  57.         {

  58.             var input_array = tf.constant(np.arange(12).reshape((3, 4)).astype(np.float32));

  59.             var indices = tf.constant(np.array(new int[] { 0, 2 }));

  60. 

  61.             var result = array_ops.gather(input_array, indices);

  62.             Assert.AreEqual(new Shape(2, 4), result.shape);

  63.             Assert.AreEqual(result.numpy()[0, 0], 0.0f);

  64.             Assert.AreEqual(result.numpy()[0, 1], 1.0f);

  65.             Assert.AreEqual(result.numpy()[1, 3], 11.0f);

  66. 

  67.             // Tests based on example code in Python doc string for tf.gather()

  68. 

  69.             var p1 = tf.random.normal(new Shape(5, 6, 7, 8));

  70.             var i1 = tf.random_uniform(new Shape(10, 11), maxval: 7, dtype: tf.int32);

  71.             var r1 = tf.gather(p1, i1, axis:2);

  72.             Assert.AreEqual(new Shape(5, 6, 10, 11, 8), r1.shape);

  73. 

  74.             var p2 = tf.random.normal(new Shape(4,3));

  75.             var i2 = tf.constant(new int[,] { { 0, 2} });

  76.             var r2 = tf.gather(p2, i2, axis: 0);

  77.             Assert.AreEqual(new Shape(1, 2, 3), r2.shape);

  78. 

  79.             var r3 = tf.gather(p2, i2, axis: 1);

  80.             Assert.AreEqual(new Shape(4,1,2), r3.shape);

  81.         }

  82. 

  83.         /// <summary>

  84.         /// https://www.tensorflow.org/api_docs/python/tf/TensorArray

  85.         /// </summary>

  86.         [TestMethod]

  87.         public void TensorArray()

  88.         {

  89.             var ta = tf.TensorArray(tf.float32, size: 0, dynamic_size: true, clear_after_read: false);

  90.             ta.write(0, 10);

  91.             ta.write(1, 20);

  92.             ta.write(2, 30);

  93.             Assert.AreEqual(ta.read(0).numpy(), 10f);

  94.             Assert.AreEqual(ta.read(1).numpy(), 20f);

  95.             Assert.AreEqual(ta.read(2).numpy(), 30f);

  96.         }

  97. 

  98.         /// <summary>

  99.         /// https://www.tensorflow.org/api_docs/python/tf/reverse

  100.         /// </summary>

  101.         [TestMethod]

  102.         public void ReverseArray()

  103.         {

  104.             var a = tf.random.normal((2, 3));

  105.             var b = tf.reverse(a, -1);

  106.             Assert.IsTrue(Equal(a[0].ToArray<float>().Reverse().ToArray(), b[0].ToArray<float>()));

  107.             Assert.IsTrue(Equal(a[1].ToArray<float>().Reverse().ToArray(), b[1].ToArray<float>()));

  108.         }

  109. 

  110.         [TestMethod]

  111.         public void ReverseImgArray3D()

  112.         {

  113.             // 创建 sourceImg 数组

  114.             var sourceImgArray = new float[,,] {

  115.             {

  116.                 { 237, 28, 36 },

  117.                 { 255, 255, 255 },

  118.                 { 255, 255, 255 }

  119.             },

  120.             {

  121.                 { 255, 255, 255 },

  122.                 { 255, 255, 255 },

  123.                 { 255, 255, 255 }

  124.             }

  125.         };

  126.             var sourceImg = ops.convert_to_tensor(sourceImgArray);

  127. 

  128.             // 创建 lrImg 数组

  129.             var lrImgArray = new float[,,] {

  130.             {

  131.                 { 255, 255, 255 },

  132.                 { 255, 255, 255 },

  133.                 { 237, 28, 36 }

  134.             },

  135.             {

  136.                 { 255, 255, 255 },

  137.                 { 255, 255, 255 },

  138.                 { 255, 255, 255 }

  139.             }

  140.         };

  141.             var lrImg = ops.convert_to_tensor(lrImgArray);

  142. 

  143.             var lr = tf.image.flip_left_right(sourceImg);

  144.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr.numpy().ToArray<float>()), "tf.image.flip_left_right fail.");

  145. 

  146.             var lr2 = tf.reverse(sourceImg, 1);

  147.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr2.numpy().ToArray<float>()), "tf.reverse (axis=1) fail.");

  148. 

  149.             var lr3 = gen_array_ops.reverse_v2(sourceImg, ops.convert_to_tensor(new[] { 1 }));

  150.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr3.numpy().ToArray<float>()), "gen_array_ops.reverse_v2 axis=1 fail.");

  151. 

  152.             // 创建 udImg  数组

  153.             var udImgArray = new float[,,] {

  154.             {

  155.                 { 255, 255, 255 },

  156.                 { 255, 255, 255 },

  157.                 { 255, 255, 255 }

  158.             },

  159.             {

  160.                 { 237, 28, 36 },

  161.                 { 255, 255, 255 },

  162.                 { 255, 255, 255 }

  163.             }

  164.         };

  165.             var udImg = ops.convert_to_tensor(udImgArray);

  166. 

  167.             var ud = tf.image.flip_up_down(sourceImg);

  168.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud.numpy().ToArray<float>()), "tf.image.flip_up_down fail.");

  169. 

  170.             var ud2 = tf.reverse(sourceImg, new Axis(0));

  171.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud2.numpy().ToArray<float>()), "tf.reverse (axis=0) fail.");

  172. 

  173.             var ud3 = gen_array_ops.reverse_v2(sourceImg, ops.convert_to_tensor(new[] { 0 }));

  174.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud3.numpy().ToArray<float>()), "gen_array_ops.reverse_v2 axis=0 fail.");

  175.         }

  176. 

  177.         [TestMethod]

  178.         public void ReverseImgArray4D()

  179.         {

  180.             // 原图左上角，加一张左右翻转后的图片

  181.             var m = new float[,,,] {

  182.             {

  183.                 {

  184.                     { 237, 28, 36 },

  185.                     { 255, 255, 255 },

  186.                     { 255, 255, 255 }

  187.                 },

  188.                 {

  189.                     { 255, 255, 255 },

  190.                     { 255, 255, 255 },

  191.                     { 255, 255, 255 }

  192.                 }

  193.             },

  194.             {

  195.                 {

  196.                     { 255, 255, 255 },

  197.                     { 255, 255, 255 },

  198.                     { 237, 28, 36 }

  199.                 },

  200.                 {

  201.                     { 255, 255, 255 },

  202.                     { 255, 255, 255 },

  203.                     { 255, 255, 255 }

  204.                 }

  205.             }

  206.         };

  207.             var sourceImg = ops.convert_to_tensor(m);

  208. 

  209.             var lrArray = new float[,,,] {

  210.             {

  211.                 {

  212.                     { 255, 255, 255 },

  213.                     { 255, 255, 255 },

  214.                     { 237, 28, 36 },

  215.                 },

  216.                 {

  217.                     { 255, 255, 255 },

  218.                     { 255, 255, 255 },

  219.                     { 255, 255, 255 }

  220.                 }

  221.             },

  222.             {

  223.                 {

  224.                     { 237, 28, 36 },

  225.                     { 255, 255, 255 },

  226.                     { 255, 255, 255 },

  227.                 },

  228.                 {

  229.                     { 255, 255, 255 },

  230.                     { 255, 255, 255 },

  231.                     { 255, 255, 255 }

  232.                 }

  233.             }

  234.         };

  235.             var lrImg = ops.convert_to_tensor(lrArray);

  236. 

  237.             // 创建 ud 数组

  238.             var udArray = new float[,,,] {

  239.             {

  240.                 {

  241.                     { 255, 255, 255 },

  242.                     { 255, 255, 255 },

  243.                     { 255, 255, 255 }

  244.                 },

  245.                 {

  246.                     { 237, 28, 36 },

  247.                     { 255, 255, 255 },

  248.                     { 255, 255, 255 }

  249.                 }

  250.             },

  251.             {

  252.                 {

  253.                     { 255, 255, 255 },

  254.                     { 255, 255, 255 },

  255.                     { 255, 255, 255 }

  256.                 },

  257.                 {

  258.                     { 255, 255, 255 },

  259.                     { 255, 255, 255 },

  260.                     { 237, 28, 36 }

  261.                 }

  262.             }

  263.         };

  264.             var udImg = ops.convert_to_tensor(udArray);

  265. 

  266.             var ud3 = gen_array_ops.reverse_v2(sourceImg, ops.convert_to_tensor(new[] { 1 }));

  267.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud3.numpy().ToArray<float>()), "gen_array_ops.reverse_v2 axis=1 fail.");

  268. 

  269.             var ud2 = tf.reverse(sourceImg, new Axis(1));

  270.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud2.numpy().ToArray<float>()), "tf.reverse (axis=1) fail.");

  271. 

  272.             var ud = tf.image.flip_up_down(sourceImg);

  273.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud.numpy().ToArray<float>()), "tf.image.flip_up_down fail.");

  274. 

  275.             // 左右翻转

  276.             var lr = tf.image.flip_left_right(sourceImg);

  277.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr.numpy().ToArray<float>()), "tf.image.flip_left_right fail.");

  278. 

  279.             var lr2 = tf.reverse(sourceImg, 0);

  280.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr2.numpy().ToArray<float>()), "tf.reverse (axis=1) fail.");

  281. 

  282.             var lr3 = gen_array_ops.reverse_v2(sourceImg, ops.convert_to_tensor(new[] { 0 }));

  283.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr3.numpy().ToArray<float>()), "gen_array_ops.reverse_v2 axis=1 fail.");

  284. 

  285.         }

  286. 

  287.         [TestMethod]

  288.         public void ReverseImgArray4D_3x3()

  289.         {

  290.             // 原图左上角，加一张左右翻转后的图片

  291.             var m = new float[,,,] {

  292.             {

  293.                 {

  294.                     { 237, 28, 36 },

  295.                     { 255, 255, 255 },

  296.                     { 255, 255, 255 }

  297.                 },

  298.                 {

  299.                     { 255, 255, 255 },

  300.                     { 255, 255, 255 },

  301.                     { 255, 255, 255 }

  302.                 },

  303.                 {

  304.                     { 255, 255, 255 },

  305.                     { 255, 255, 255 },

  306.                     { 255, 255, 255 }

  307.                 }

  308.             },

  309.             {

  310.                 {

  311.                     { 255, 255, 255 },

  312.                     { 255, 255, 255 },

  313.                     { 237, 28, 36 }

  314.                 },

  315.                 {

  316.                     { 255, 255, 255 },

  317.                     { 255, 255, 255 },

  318.                     { 255, 255, 255 }

  319.                 },

  320.                 {

  321.                     { 255, 255, 255 },

  322.                     { 255, 255, 255 },

  323.                     { 255, 255, 255 }

  324.                 }

  325.             }

  326.         };

  327.             var sourceImg = ops.convert_to_tensor(m);

  328. 

  329.             var lrArray = new float[,,,] {

  330.             {

  331.                 {

  332.                     { 255, 255, 255 },

  333.                     { 255, 255, 255 },

  334.                     { 237, 28, 36 },

  335.                 },

  336.                 {

  337.                     { 255, 255, 255 },

  338.                     { 255, 255, 255 },

  339.                     { 255, 255, 255 }

  340.                 },

  341.                 {

  342.                     { 255, 255, 255 },

  343.                     { 255, 255, 255 },

  344.                     { 255, 255, 255 }

  345.                 }

  346.             },

  347.             {

  348.                 {

  349.                     { 237, 28, 36 },

  350.                     { 255, 255, 255 },

  351.                     { 255, 255, 255 },

  352.                 },

  353.                 {

  354.                     { 255, 255, 255 },

  355.                     { 255, 255, 255 },

  356.                     { 255, 255, 255 }

  357.                 },

  358.                 {

  359.                     { 255, 255, 255 },

  360.                     { 255, 255, 255 },

  361.                     { 255, 255, 255 }

  362.                 }

  363.             }

  364.         };

  365.             var lrImg = ops.convert_to_tensor(lrArray);

  366. 

  367.             // 创建 ud 数组

  368.             var udArray = new float[,,,] {

  369.             {

  370.                 {

  371.                     { 255, 255, 255 },

  372.                     { 255, 255, 255 },

  373.                     { 255, 255, 255 }

  374.                 },

  375.                                 {

  376.                     { 255, 255, 255 },

  377.                     { 255, 255, 255 },

  378.                     { 255, 255, 255 }

  379.                 },

  380.                 {

  381.                     { 237, 28, 36 },

  382.                     { 255, 255, 255 },

  383.                     { 255, 255, 255 }

  384.                 }

  385.             },

  386.             {                {

  387.                     { 255, 255, 255 },

  388.                     { 255, 255, 255 },

  389.                     { 255, 255, 255 }

  390.                 },

  391.                 {

  392.                     { 255, 255, 255 },

  393.                     { 255, 255, 255 },

  394.                     { 255, 255, 255 }

  395.                 },

  396.                 {

  397.                     { 255, 255, 255 },

  398.                     { 255, 255, 255 },

  399.                     { 237, 28, 36 }

  400.                 }

  401.             }

  402.         };

  403.             var udImg = ops.convert_to_tensor(udArray);

  404. 

  405.             var ud3 = gen_array_ops.reverse_v2(sourceImg, ops.convert_to_tensor(new[] { 1 }));

  406.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud3.numpy().ToArray<float>()), "gen_array_ops.reverse_v2 axis=1 fail.");

  407. 

  408.             var ud2 = tf.reverse(sourceImg, new Axis(1));

  409.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud2.numpy().ToArray<float>()), "tf.reverse (axis=1) fail.");

  410. 

  411.             var ud = tf.image.flip_up_down(sourceImg);

  412.             Assert.IsTrue(Equal(udImg.numpy().ToArray<float>(), ud.numpy().ToArray<float>()), "tf.image.flip_up_down fail.");

  413. 

  414.             // 左右翻转

  415.             var lr = tf.image.flip_left_right(sourceImg);

  416.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr.numpy().ToArray<float>()), "tf.image.flip_left_right fail.");

  417. 

  418.             var lr2 = tf.reverse(sourceImg, 0);

  419.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr2.numpy().ToArray<float>()), "tf.reverse (axis=1) fail.");

  420. 

  421.             var lr3 = gen_array_ops.reverse_v2(sourceImg, ops.convert_to_tensor(new[] { 0 }));

  422.             Assert.IsTrue(Equal(lrImg.numpy().ToArray<float>(), lr3.numpy().ToArray<float>()), "gen_array_ops.reverse_v2 axis=1 fail.");

  423. 

  424.         }

  425.     }

  426. }