FilesExpand file tree

 master

/

Tensor.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

245 lines (214 loc) · 7.58 KB

 master

/

Tensor.cs

Copy path

Top

File metadata and controls

• Code
• Blame

245 lines (214 loc) · 7.58 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

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

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

using NumSharp.Core;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using static Tensorflow.c_api;

namespace Tensorflow

{

/// <summary>

/// A tensor is a generalization of vectors and matrices to potentially higher dimensions.

/// Internally, TensorFlow represents tensors as n-dimensional arrays of base datatypes.

/// </summary>

public partial class Tensor : IDisposable

{

private readonly IntPtr _handle;

public Graph Graph => op.Graph;

public Operation op { get; }

/// <summary>

/// The string name of this tensor.

/// </summary>

public string name => $"{(op == null ? "Operation was not named" : $"{op.Name}:{value_index}")}";

public int value_index { get; }

private Status status = new Status();

private TF_DataType _dtype = TF_DataType.DtInvalid;

public TF_DataType dtype => _handle == IntPtr.Zero ? _dtype : c_api.TF_TensorType(_handle);

public ulong bytesize => _handle == IntPtr.Zero ? 0 : c_api.TF_TensorByteSize(_handle);

public ulong dataTypeSize => _handle == IntPtr.Zero ? 0 : c_api.TF_DataTypeSize(dtype);

public ulong size => _handle == IntPtr.Zero ? 0 : bytesize / dataTypeSize;

public IntPtr buffer => _handle == IntPtr.Zero ? IntPtr.Zero : c_api.TF_TensorData(_handle);

public int num_consumers(TF_Output oper_out) => _handle == IntPtr.Zero ? 0 : c_api.TF_OperationOutputNumConsumers(oper_out);

public long[] shape

{

get

{

var dims = new long[rank];

if (_handle == IntPtr.Zero)

{

c_api.TF_GraphGetTensorShape(op.Graph, _as_tf_output(), dims, rank, status);

status.Check();

}

else

{

for (int i = 0; i < rank; i++)

dims[i] = c_api.TF_Dim(_handle, i);

}

return dims;

}

}

/// <summary>

/// number of dimensions

/// 0 Scalar (magnitude only)

/// 1 Vector (magnitude and direction)

/// 2 Matrix (table of numbers)

/// 3 3-Tensor (cube of numbers)

/// n n-Tensor (you get the idea)

/// </summary>

public int rank

{

get

{

if (_handle == IntPtr.Zero)

{

var output = _as_tf_output();

return c_api.TF_GraphGetTensorNumDims(op.Graph, output, status);

}

else

{

return c_api.TF_NumDims(_handle);

}

}

}

public int NDims => rank;

/// <summary>

/// if original buffer is free.

/// </summary>

private bool deallocator_called;

public Tensor(IntPtr handle)

{

_handle = handle;

}

public Tensor(NDArray nd)

{

_handle = Allocate(nd);

}

private IntPtr Allocate(NDArray nd)

{

IntPtr dotHandle = IntPtr.Zero;

ulong size = 0;

if (nd.dtype.Name != "String")

{

dotHandle = Marshal.AllocHGlobal(nd.dtypesize * nd.size);

size = (ulong)(nd.size * nd.dtypesize);

}

switch (nd.dtype.Name)

{

case "Int16":

Marshal.Copy(nd.Data<short>(), 0, dotHandle, nd.size);

break;

case "Int32":

Marshal.Copy(nd.Data<int>(), 0, dotHandle, nd.size);

break;

case "Single":

Marshal.Copy(nd.Data<float>(), 0, dotHandle, nd.size);

break;

case "Double":

Marshal.Copy(nd.Data<double>(), 0, dotHandle, nd.size);

break;

case "String":

var value = nd.Data<string>()[0];

var bytes = Encoding.UTF8.GetBytes(value);

dotHandle = Marshal.AllocHGlobal(bytes.Length + 1);

Marshal.Copy(bytes, 0, dotHandle, bytes.Length);

size = (ulong)bytes.Length;

break;

default:

throw new NotImplementedException("Marshal.Copy failed.");

}

var dataType = ToTFDataType(nd.dtype);

// shape

var dims = nd.shape.Select(x => (long)x).ToArray();

// Free the original buffer and set flag

Deallocator deallocator = (IntPtr values, IntPtr len, ref bool closure) =>

{

Marshal.FreeHGlobal(dotHandle);

closure = true;

};

var tfHandle = c_api.TF_NewTensor(dataType,

dims,

nd.ndim,

dotHandle,

size,

deallocator,

ref deallocator_called);

return tfHandle;

}

public Tensor(Operation op, int value_index, TF_DataType dtype)

{

this.op = op;

this.value_index = value_index;

this._dtype = dtype;

}

public List<Operation> consumers()

{

var output = _as_tf_output();

var consumer_names = c_api.TF_OperationOutputConsumers_wrapper(output);

return consumer_names.Select(x => Graph.OperationByName(x)).ToList();

}

public TF_Output _as_tf_output()

{

return new TF_Output(op, value_index);

}

public T[] Data<T>()

{

// Column major order

// https://en.wikipedia.org/wiki/File:Row_and_column_major_order.svg

// matrix:[[1, 2, 3], [4, 5, 6]]

// index: 0 2 4 1 3 5

// result: 1 4 2 5 3 6

var data = new T[size];

for (ulong i = 0; i < size; i++)

{

data[i] = Marshal.PtrToStructure<T>(buffer + (int)(i * dataTypeSize));

}

return data;

}

public byte[] Data()

{

var data = new byte[bytesize];

Marshal.Copy(buffer, data, 0, (int)bytesize);

return data;

}

public Tensor MaybeMove()

{

var tensor = c_api.TF_TensorMaybeMove(_handle);

return tensor;

}

public TF_DataType ToTFDataType(Type type)

{

switch (type.Name)

{

case "Int16":

return TF_DataType.TF_INT16;

case "Int32":

return TF_DataType.TF_INT32;

case "Single":

return TF_DataType.TF_FLOAT;

case "Double":

return TF_DataType.TF_DOUBLE;

case "String":

return TF_DataType.TF_STRING;

default:

throw new NotImplementedException("ToTFDataType error");

}

}

public override string ToString()

{

if(NDims == 0)

{

switch (dtype)

{

case TF_DataType.TF_INT32:

return Data<int>()[0].ToString();

}

}

return $"{name} shape=({string.Join(",", shape)}) dtype={dtype.ToString()}";

}

public void Dispose()

{

c_api.TF_DeleteTensor(_handle);

status.Dispose();

}

}

}