Class: TensorFlow::Tensor

Inherits:
Object
  • Object
show all
Defined in:
lib/tensorflow/tensor.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(value = nil, dtype: nil, shape: nil, pointer: nil) ⇒ Tensor

Returns a new instance of Tensor.



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
 
# File 'lib/tensorflow/tensor.rb', line 3

def initialize(value = nil, dtype: nil, shape: nil, pointer: nil)
  @status = FFI.TF_NewStatus

  if pointer
    @pointer = pointer
  else
    data = Array(value)
    shape ||= calculate_shape(value)

    if shape.size > 0
      dims_ptr = ::FFI::MemoryPointer.new(:int64, shape.size)
      dims_ptr.write_array_of_int64(shape)
    else
      dims_ptr = nil
    end

    data = data.flatten

    dtype ||= Utils.infer_type(data)
    type = FFI::DataType[dtype]
    case dtype
    when :float, :double, :int32, :uint8, :int16, :int8, :int64, :uint16, :uint32, :uint64
      data_ptr = ::FFI::MemoryPointer.new(dtype, data.size)
      data_ptr.send("write_array_of_#{dtype}", data)
    when :bfloat16
      # https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
      data_ptr = ::FFI::MemoryPointer.new(:int8, data.size * 2)
      data_ptr.write_bytes(data.map { |v| [v].pack("g")[0..1] }.join)
    when :complex64
      data_ptr = ::FFI::MemoryPointer.new(:float, data.size * 2)
      data_ptr.write_array_of_float(data.flat_map { |v| [v.real, v.imaginary] })
    when :complex128
      data_ptr = ::FFI::MemoryPointer.new(:double, data.size * 2)
      data_ptr.write_array_of_double(data.flat_map { |v| [v.real, v.imaginary] })
    when :string
      data_ptr = string_ptr(data)
    when :bool
      data_ptr = ::FFI::MemoryPointer.new(:int8, data.size)
      data_ptr.write_array_of_int8(data.map { |v| v ? 1 : 0 })
    else
      raise "Unknown type: #{dtype}"
    end

    callback = ::FFI::Function.new(:void, [:pointer, :size_t, :pointer]) do |data, len, arg|
      # FFI handles deallocation
    end

    tensor = FFI.TF_NewTensor(type, dims_ptr, shape.size, data_ptr, data_ptr.size, callback, nil)
    @pointer = FFI.TFE_NewTensorHandle(tensor, @status)
    check_status @status
  end

  ObjectSpace.define_finalizer(self, self.class.finalize(@pointer, @status, tensor))
end

Class Method Details

.finalize(pointer, status, tensor) ⇒ Object 



143
144
145
146
147
148
149
150
 
# File 'lib/tensorflow/tensor.rb', line 143

def self.finalize(pointer, status, tensor)
  # must use proc instead of stabby lambda
  proc do
    FFI.TFE_DeleteTensorHandle(pointer)
    FFI.TFE_DeleteStatus(status)
    FFI.TFE_DeleteTensor(tensor) if tensor
  end
end

Instance Method Details

#%(other) ⇒ Object 



74
75
76
 
# File 'lib/tensorflow/tensor.rb', line 74

def %(other)
  Math.floormod(self, other)
end

#*(other) ⇒ Object 



66
67
68
 
# File 'lib/tensorflow/tensor.rb', line 66

def *(other)
  Math.multiply(self, other)
end

#+(other) ⇒ Object 



58
59
60
 
# File 'lib/tensorflow/tensor.rb', line 58

def +(other)
  Math.add(self, other)
end

#-(other) ⇒ Object 



62
63
64
 
# File 'lib/tensorflow/tensor.rb', line 62

def -(other)
  Math.subtract(self, other)
end

#/(other) ⇒ Object 



70
71
72
 
# File 'lib/tensorflow/tensor.rb', line 70

def /(other)
  Math.divide(self, other)
end

#dtype ⇒ Object 



107
108
109
 
# File 'lib/tensorflow/tensor.rb', line 107

def dtype
  @dtype ||= FFI::DataType[FFI.TFE_TensorHandleDataType(@pointer)]
end

#inspect ⇒ Object 



138
139
140
141
 
# File 'lib/tensorflow/tensor.rb', line 138

def inspect
  inspection = %w(value shape dtype).map { |v| "#{v}: #{send(v).inspect}"}
  "#<#{self.class} #{inspection.join(", ")}>"
end

#shape ⇒ Object 



111
112
113
114
115
116
117
118
119
120
 
# File 'lib/tensorflow/tensor.rb', line 111

def shape
  @shape ||= begin
    shape = []
    num_dims.times do |i|
      shape << FFI.TFE_TensorHandleDim(@pointer, i, @status)
      check_status @status
    end
    shape
  end
end

#to_a ⇒ Object 



130
131
132
 
# File 'lib/tensorflow/tensor.rb', line 130

def to_a
  value
end

#to_i ⇒ Object 



126
127
128
 
# File 'lib/tensorflow/tensor.rb', line 126

def to_i
  value.to_i
end

#to_ptr ⇒ Object 



134
135
136
 
# File 'lib/tensorflow/tensor.rb', line 134

def to_ptr
  @pointer
end

#to_s ⇒ Object 



122
123
124
 
# File 'lib/tensorflow/tensor.rb', line 122

def to_s
  inspect
end

#value ⇒ Object 



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
 
# File 'lib/tensorflow/tensor.rb', line 78

def value
  value =
    case dtype
    when :float, :double, :int32, :uint8, :int16, :int8, :int64, :uint16, :uint32, :uint64
      data_pointer.send("read_array_of_#{dtype}", element_count)
    when :bfloat16
      byte_str = data_pointer.read_bytes(element_count * 2)
      element_count.times.map { |i| "#{byte_str[(2 * i)..(2 * i + 1)]}\x00\x00".unpack1("g") }
    when :complex64
      data_pointer.read_array_of_float(element_count * 2).each_slice(2).map { |v| Complex(*v) }
    when :complex128
      data_pointer.read_array_of_double(element_count * 2).each_slice(2).map { |v| Complex(*v) }
    when :string
      # string tensor format
      # https://github.com/tensorflow/tensorflow/blob/5453aee48858fd375172d7ae22fad1557e8557d6/tensorflow/c/tf_tensor.h#L57
      start_offset_size = element_count * 8
      offsets = data_pointer.read_array_of_uint64(element_count)
      element_count.times.map { |i| (data_pointer + start_offset_size + offsets[i]).read_string }
    when :bool
      data_pointer.read_array_of_int8(element_count).map { |v| v == 1 }
    when :resource
      return data_pointer
    else
      raise "Unknown type: #{dtype}"
    end

  reshape(value, shape)
end