TensorFlow.NET/test/TensorFlowNET.UnitTest/TensorTest.cs at master · mayuzx/TensorFlow.NET · GitHub

History

160 lines (139 loc) · 6.11 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

using Microsoft.VisualStudio.TestTools.UnitTesting;

using NumSharp;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using Tensorflow;

namespace TensorFlowNET.UnitTest

{

[TestClass]

public class TensorTest : CApiTest

{

/// <summary>

/// Port from c_api_test.cc

/// `TEST(CAPI, AllocateTensor)`

/// </summary>

[TestMethod]

public void AllocateTensor()

{

/*ulong num_bytes = 6 * sizeof(float);

long[] dims = { 2, 3 };

Tensor t = c_api.TF_AllocateTensor(TF_DataType.TF_FLOAT, dims, 2, num_bytes);

EXPECT_EQ(TF_DataType.TF_FLOAT, t.dtype);

EXPECT_EQ(2, t.NDims);

Assert.IsTrue(Enumerable.SequenceEqual(dims, t.shape));

EXPECT_EQ(num_bytes, t.bytesize);

t.Dispose();*/

}

/// <summary>

/// Port from c_api_test.cc

/// `TEST(CAPI, MaybeMove)`

/// </summary>

[TestMethod]

public void MaybeMove()

{

NDArray nd = np.array(2, 3);

Tensor t = new Tensor(nd);

Tensor o = t.MaybeMove();

ASSERT_TRUE(o == IntPtr.Zero); // It is unsafe to move memory TF might not own.

t.Dispose();

}

/// <summary>

/// Port from c_api_test.cc

/// `TEST(CAPI, Tensor)`

/// </summary>

[TestMethod]

public void Tensor()

{

var nd = np.array(1f, 2f, 3f, 4f, 5f, 6f).reshape(2, 3);

var tensor = new Tensor(nd);

var array = tensor.Data<float>();

EXPECT_EQ(tensor.dtype, TF_DataType.TF_FLOAT);

EXPECT_EQ(tensor.rank, nd.ndim);

EXPECT_EQ((int)tensor.shape[0], nd.shape[0]);

EXPECT_EQ((int)tensor.shape[1], nd.shape[1]);

EXPECT_EQ(tensor.bytesize, (ulong)nd.size * sizeof(float));

Assert.IsTrue(Enumerable.SequenceEqual(nd.Data<float>(), new float[] { 1, 2, 3, 4, 5, 6 }));

}

/// <summary>

/// Port from tensorflow\c\c_api_test.cc

/// `TEST(CAPI, SetShape)`

/// </summary>

[TestMethod]

public void SetShape()

{

var s = new Status();

var graph = new Graph();

var feed = c_test_util.Placeholder(graph, s);

var feed_out_0 = new TF_Output(feed, 0);

// Fetch the shape, it should be completely unknown.

int num_dims = c_api.TF_GraphGetTensorNumDims(graph, feed_out_0, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

EXPECT_EQ(-1, num_dims);

// Set the shape to be unknown, expect no change.

c_api.TF_GraphSetTensorShape(graph, feed_out_0, null, -1, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

num_dims = c_api.TF_GraphGetTensorNumDims(graph, feed_out_0, s);

EXPECT_EQ(-1, num_dims);

// Set the shape to be 2 x Unknown

long[] dims = { 2, -1 };

c_api.TF_GraphSetTensorShape(graph, feed_out_0, dims, dims.Length, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

num_dims = c_api.TF_GraphGetTensorNumDims(graph, feed_out_0, s);

EXPECT_EQ(2, num_dims);

// Get the dimension vector appropriately.

var returned_dims = new long[dims.Length];

c_api.TF_GraphGetTensorShape(graph, feed_out_0, returned_dims, num_dims, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

Assert.IsTrue(Enumerable.SequenceEqual(dims, returned_dims));

// Set to a new valid shape: [2, 3]

dims[1] = 3;

c_api.TF_GraphSetTensorShape(graph, feed_out_0, dims, dims.Length, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

// Fetch and see that the new value is returned.

c_api.TF_GraphGetTensorShape(graph, feed_out_0, returned_dims, num_dims, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

Assert.IsTrue(Enumerable.SequenceEqual(dims, returned_dims));

// Try to set 'unknown' with unknown rank on the shape and see that

// it doesn't change.

c_api.TF_GraphSetTensorShape(graph, feed_out_0, null, -1, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

c_api.TF_GraphGetTensorShape(graph, feed_out_0, returned_dims, num_dims, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

EXPECT_EQ(2, num_dims);

EXPECT_EQ(2, (int)returned_dims[0]);

EXPECT_EQ(3, (int)returned_dims[1]);

// Try to set 'unknown' with same rank on the shape and see that

// it doesn't change.

dims[0] = -1;

dims[1] = -1;

c_api.TF_GraphSetTensorShape(graph, feed_out_0, dims, 2, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

c_api.TF_GraphGetTensorShape(graph, feed_out_0, returned_dims, num_dims, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

EXPECT_EQ(2, num_dims);

EXPECT_EQ(2, (int)returned_dims[0]);

EXPECT_EQ(3, (int)returned_dims[1]);

// Try to fetch a shape with the wrong num_dims

c_api.TF_GraphGetTensorShape(graph, feed_out_0, returned_dims, 5, s);

Assert.IsTrue(s.Code == TF_Code.TF_INVALID_ARGUMENT);

// Try to set an invalid shape (cannot change 2x3 to a 2x5).

dims[1] = 5;

c_api.TF_GraphSetTensorShape(graph, feed_out_0, dims, 2, s);

Assert.IsTrue(s.Code == TF_Code.TF_INVALID_ARGUMENT);

// Test for a scalar.

var three = c_test_util.ScalarConst(3, graph, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

var three_out_0 = new TF_Output(three, 0);

num_dims = c_api.TF_GraphGetTensorNumDims(graph, three_out_0, s);

Assert.IsTrue(s.Code == TF_Code.TF_OK);

EXPECT_EQ(0, num_dims);

c_api.TF_GraphGetTensorShape(graph, feed_out_0, null, num_dims, s);

//Assert.IsTrue(s.Code == TF_Code.TF_OK);

// graph.Dispose();

s.Dispose();

}

TensorFlow.NET/test/TensorFlowNET.UnitTest/TensorTest.cs at master · mayuzx/TensorFlow.NET · GitHub

Expand file tree

Breadcrumbs

TensorTest.cs

Latest commit

History

Breadcrumbs

TensorTest.cs

File metadata and controls