Module: TensorStream::Ops

Included in:
TensorStream
Defined in:
lib/tensor_stream/ops.rb

Overview

Class that defines all available ops supported by TensorStream

Constant Summary collapse

FLOATING_POINT_TYPES = 
i[float32 float64 float].freeze
INTEGER_TYPES = 
i[int32 int int64].freeze
NUMERIC_TYPES = 
FLOATING_POINT_TYPES + INTEGER_TYPES

Instance Method Summary collapse

Instance Method Details

#abs(input, name: nil) ⇒ Object 



231
232
233
 
# File 'lib/tensor_stream/ops.rb', line 231

def abs(input, name: nil)
  _op(:abs, input, nil, name: name)
end

#add(input_a, input_b, name: nil) ⇒ Object 



156
157
158
 
# File 'lib/tensor_stream/ops.rb', line 156

def add(input_a, input_b, name: nil)
  _op(:add, input_a, input_b, name: name)
end

#argmax(input, axis = nil, name: nil, dimension: nil, output_type: :int32) ⇒ Object 



8
9
10
 
# File 'lib/tensor_stream/ops.rb', line 8

def argmax(input, axis = nil, name: nil, dimension: nil, output_type: :int32)
  _op(:argmax, input, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
end

#argmin(input, axis = nil, name: nil, dimension: nil, output_type: :int32) ⇒ Object 



12
13
14
 
# File 'lib/tensor_stream/ops.rb', line 12

def argmin(input, axis = nil, name: nil, dimension: nil, output_type: :int32)
  _op(:argmin, input, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
end

#cast(input, dtype, name: nil) ⇒ Object 



179
180
181
 
# File 'lib/tensor_stream/ops.rb', line 179

def cast(input, dtype, name: nil)
  _op(:cast, input, nil, data_type: dtype, name: name)
end

#concat(values, axis, name: 'concat') ⇒ Object 



127
128
129
 
# File 'lib/tensor_stream/ops.rb', line 127

def concat(values, axis, name: 'concat')
  _op(:concat, values, nil, axis: axis, name: name)
end

#cond(pred, true_fn, false_fn, name: nil) ⇒ Object 



148
149
150
 
# File 'lib/tensor_stream/ops.rb', line 148

def cond(pred, true_fn, false_fn, name: nil)
  _op(:cond, true_fn, false_fn, pred: pred, name: name)
end

#cos(input, options = {}) ⇒ Object 



245
246
247
248
249
 
# File 'lib/tensor_stream/ops.rb', line 245

def cos(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:cos, input, nil, options)
end

#div(input_a, input_b, name: nil) ⇒ Object 



223
224
225
 
# File 'lib/tensor_stream/ops.rb', line 223

def div(input_a, input_b, name: nil)
  _op(:div, input_a, input_b, name: name)
end

#equal(input_a, input_b, name: nil) ⇒ Object 



195
196
197
 
# File 'lib/tensor_stream/ops.rb', line 195

def equal(input_a, input_b, name: nil)
  _op(:equal, input_a, input_b, name: name)
end

#exp(input, options = {}) ⇒ Object 



284
285
286
287
288
 
# File 'lib/tensor_stream/ops.rb', line 284

def exp(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:exp, input, nil, options)
end

#eye(num_rows, num_columns: nil, dtype: :float32, name: nil) ⇒ Object 



55
56
57
 
# File 'lib/tensor_stream/ops.rb', line 55

def eye(num_rows, num_columns: nil, dtype: :float32, name: nil)
  _op(:eye, num_rows, num_columns || num_rows, data_type: dtype, name: name)
end

#glorot_uniform_initializer(seed: nil, dtype: :float32) ⇒ Object 



75
76
77
 
# File 'lib/tensor_stream/ops.rb', line 75

def glorot_uniform_initializer(seed: nil, dtype: :float32)
  TensorStream::Initializer.new(-> { _op(:glorot_uniform, nil, nil, seed: seed, data_type: dtype) })
end

#gradients(input, wrt_xs, grad_ys: nil, name: 'gradients', colocate_gradients_with_ops: false, gate_gradients: false, aggregation_method: nil, stop_gradients: nil) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/tensor_stream/ops.rb', line 16

def gradients(input, wrt_xs, grad_ys: nil,
  name: 'gradients',
  colocate_gradients_with_ops: false,
  gate_gradients: false,
  aggregation_method: nil,
  stop_gradients: nil)

  gs = wrt_xs.collect do |x|
    stops = stop_gradients ? stop_gradients.map(&:name).join('_') : ''
    gradient_program_name = "grad_#{input.name}_#{x.name}_#{stops}".to_sym

    tensor_program = if input.graph.node_added?(gradient_program_name)
                      input.graph.get_node(gradient_program_name)
                    else
                      input.graph.name_scope("gradient_wrt_#{x.name}") do
                        derivative_ops = TensorStream::MathGradients.derivative(input, x, graph: input.graph,
                          stop_gradients: stop_gradients)
                        input.graph.add_node!(gradient_program_name, derivative_ops)
                      end
                    end
    tensor_program
  end
  TensorStream.group(gs)
end

#greater(input_a, input_b, name: nil) ⇒ Object 



103
104
105
 
# File 'lib/tensor_stream/ops.rb', line 103

def greater(input_a, input_b, name: nil)
  _op(:greater, input_a, input_b, name: name)
end

#greater_equal(input_a, input_b, name: nil) ⇒ Object 



107
108
109
 
# File 'lib/tensor_stream/ops.rb', line 107

def greater_equal(input_a, input_b, name: nil)
  _op(:greater_equal, input_a, input_b, name: name)
end

#identity(input, name: nil) ⇒ Object 



211
212
213
 
# File 'lib/tensor_stream/ops.rb', line 211

def identity(input, name: nil)
  _op(:identity, input, nil, name: name)
end

#less(input_a, input_b, name: nil) ⇒ Object 



95
96
97
 
# File 'lib/tensor_stream/ops.rb', line 95

def less(input_a, input_b, name: nil)
  _op(:less, input_a, input_b, name: name)
end

#less_equal(input_a, input_b, name: nil) ⇒ Object 



111
112
113
 
# File 'lib/tensor_stream/ops.rb', line 111

def less_equal(input_a, input_b, name: nil)
  _op(:less_equal, input_a, input_b, name: name)
end

#log(input, options = {}) ⇒ Object 



272
273
274
275
276
 
# File 'lib/tensor_stream/ops.rb', line 272

def log(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:log, input, nil, options)
end

#log1p(input, options = {}) ⇒ Object 



278
279
280
281
282
 
# File 'lib/tensor_stream/ops.rb', line 278

def log1p(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:log1p, input, nil, options)
end

#logical_and(input_a, input_b, name: nil) ⇒ Object 



99
100
101
 
# File 'lib/tensor_stream/ops.rb', line 99

def logical_and(input_a, input_b, name: nil)
  _op(:logical_and, input_a, input_b, name: name)
end

#matmul(input_a, input_b, transpose_a: false, transpose_b: false, name: nil) ⇒ Object 



295
296
297
298
299
 
# File 'lib/tensor_stream/ops.rb', line 295

def matmul(input_a, input_b, transpose_a: false,
           transpose_b: false,
           name: nil)
  _op(:matmul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
end

#max(input_a, input_b, name: nil) ⇒ Object 



168
169
170
171
172
173
 
# File 'lib/tensor_stream/ops.rb', line 168

def max(input_a, input_b, name: nil)
  check_allowed_types(input_a, NUMERIC_TYPES)
  check_allowed_types(input_b, NUMERIC_TYPES)

  _op(:max, input_a, input_b, name: name)
end

#maximum(input_a, input_b, name: nil) ⇒ Object 



175
176
177
 
# File 'lib/tensor_stream/ops.rb', line 175

def maximum(input_a, input_b, name: nil)
  max(input_a, input_b, name: name)
end

#mul(input_a, input_b, name: nil) ⇒ Object 



219
220
221
 
# File 'lib/tensor_stream/ops.rb', line 219

def mul(input_a, input_b, name: nil)
  _op(:mul, input_a, input_b, name: name)
end

#multiply(input_a, input_b, name: nil) ⇒ Object 



215
216
217
 
# File 'lib/tensor_stream/ops.rb', line 215

def multiply(input_a, input_b, name: nil)
  _op(:mul, input_a, input_b, name: name)
end

#negate(input, name: nil) ⇒ Object 



187
188
189
 
# File 'lib/tensor_stream/ops.rb', line 187

def negate(input, name: nil)
  _op(:negate, input, nil, name: name)
end

#negative(input, name: nil) ⇒ Object 



191
192
193
 
# File 'lib/tensor_stream/ops.rb', line 191

def negative(input, name: nil)
  negate(input, name: name)
end

#not_equal(input_a, input_b, name: nil) ⇒ Object 



199
200
201
 
# File 'lib/tensor_stream/ops.rb', line 199

def not_equal(input_a, input_b, name: nil)
  _op(:not_equal, input_a, input_b, name: name)
end

#ones(shape, dtype: :float32, name: nil) ⇒ Object 



91
92
93
 
# File 'lib/tensor_stream/ops.rb', line 91

def ones(shape, dtype: :float32, name: nil)
  _op(:ones, shape, nil, data_type: dtype, name: name)
end

#ones_like(tensor, dtype: nil, name: nil) ⇒ Object 



207
208
209
 
# File 'lib/tensor_stream/ops.rb', line 207

def ones_like(tensor, dtype: nil, name: nil)
  _op(:ones_like, tensor, nil, data_type: dtype, name: name)
end

#pad(tensor, paddings, mode: 'CONSTANT', name: nil) ⇒ Object 



305
306
307
 
# File 'lib/tensor_stream/ops.rb', line 305

def pad(tensor, paddings, mode: 'CONSTANT', name: nil)
  _op(:pad, tensor, nil, paddings: paddings, mode: mode, name: name)
end

#pow(input_a, input_e, name: nil) ⇒ Object 



227
228
229
 
# File 'lib/tensor_stream/ops.rb', line 227

def pow(input_a, input_e, name: nil)
  _op(:pow, input_a, input_e, name: name)
end

#print(input, data, message: nil, name: nil) ⇒ Object 



183
184
185
 
# File 'lib/tensor_stream/ops.rb', line 183

def print(input, data, message: nil, name: nil)
  _op(:print, input, data, message: message, name: name)
end

#random_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil) ⇒ Object 



46
47
48
49
 
# File 'lib/tensor_stream/ops.rb', line 46

def random_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
  options = { shape: shape, dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name }
  _op(:random_normal, nil, nil, options)
end

#random_uniform(shape, dtype: :float32, minval: 0, maxval: 1, seed: nil, name: nil) ⇒ Object 



41
42
43
44
 
# File 'lib/tensor_stream/ops.rb', line 41

def random_uniform(shape, dtype: :float32, minval: 0, maxval: 1, seed: nil, name: nil)
  options = { shape: shape, dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name }
  _op(:random_uniform, nil, nil, options)
end

#random_uniform_initializer(minval: 0, maxval: 1, seed: nil, dtype: nil) ⇒ Object 



79
80
81
 
# File 'lib/tensor_stream/ops.rb', line 79

def random_uniform_initializer(minval: 0, maxval: 1, seed: nil, dtype: nil)
  TensorStream::Initializer.new(-> { _op(:random_uniform, nil, nil, minval: 0, maxval: 1, seed: seed, data_type: dtype) })
end

#rank(input, name: nil) ⇒ Object 



67
68
69
 
# File 'lib/tensor_stream/ops.rb', line 67

def rank(input, name: nil)
  _op(:rank, input, name: name)
end

#reciprocal(tensor, name: nil) ⇒ Object 



144
145
146
 
# File 'lib/tensor_stream/ops.rb', line 144

def reciprocal(tensor, name: nil)
  _op(:reciprocal, tensor, nil, name: name)
end

#reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil) ⇒ Object 



115
116
117
 
# File 'lib/tensor_stream/ops.rb', line 115

def reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil)
  _op(:mean, input_tensor, axis,  keepdims: keepdims, name: name)
end

#reduce_prod(input, axis = nil, keepdims: false, name: nil) ⇒ Object 



123
124
125
 
# File 'lib/tensor_stream/ops.rb', line 123

def reduce_prod(input, axis = nil, keepdims: false, name: nil)
  _op(:prod, input, axis, keepdims: keepdims, name: name)
end

#reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil) ⇒ Object 



119
120
121
 
# File 'lib/tensor_stream/ops.rb', line 119

def reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil)
  _op(:sum, input_tensor, axis, keepdims: keepdims, name: name)
end

#reshape(tensor, shape, name: nil) ⇒ Object 



131
132
133
 
# File 'lib/tensor_stream/ops.rb', line 131

def reshape(tensor, shape, name: nil)
  _op(:reshape, tensor, shape, name: name)
end

#round(tensor, name: nil) ⇒ Object 



139
140
141
142
 
# File 'lib/tensor_stream/ops.rb', line 139

def round(tensor, name: nil)
  check_allowed_types(tensor, FLOATING_POINT_TYPES)
  _op(:round, tensor, nil, name: name)
end

#shape(input, name: nil, out_type: :int32) ⇒ Object 



59
60
61
 
# File 'lib/tensor_stream/ops.rb', line 59

def shape(input, name: nil, out_type: :int32)
  _op(:shape, input, nil, name: name, out_type: out_type)
end

#sigmoid(input, name: nil) ⇒ Object 



290
291
292
293
 
# File 'lib/tensor_stream/ops.rb', line 290

def sigmoid(input, name: nil)
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:sigmoid, input, nil, name: name)
end

#sign(input, name: nil) ⇒ Object 



235
236
237
 
# File 'lib/tensor_stream/ops.rb', line 235

def sign(input, name: nil)
  _op(:sign, input, nil, name: name)
end

#sin(input, options = {}) ⇒ Object 



239
240
241
242
243
 
# File 'lib/tensor_stream/ops.rb', line 239

def sin(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:sin, input, nil, options)
end

#slice(input, start, size, name: nil) ⇒ Object 



83
84
85
 
# File 'lib/tensor_stream/ops.rb', line 83

def slice(input, start, size, name: nil)
  _op(:slice, input, start, size: size, name: name)
end

#sqrt(input, name: nil) ⇒ Object 



263
264
265
266
267
268
269
270
 
# File 'lib/tensor_stream/ops.rb', line 263

def sqrt(input, name: nil)
  options = {
    data_type: input.data_type,
    name: name
  }
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:sqrt, input, nil, options)
end

#square(tensor, name: nil) ⇒ Object 



135
136
137
 
# File 'lib/tensor_stream/ops.rb', line 135

def square(tensor, name: nil)
  _op(:square, tensor, nil, name: name)
end

#stop_gradient(tensor, options = {}) ⇒ Object 



51
52
53
 
# File 'lib/tensor_stream/ops.rb', line 51

def stop_gradient(tensor, options = {})
  _op(:stop_gradient, tensor, nil, options)
end

#sub(input_a, input_b, name: nil) ⇒ Object 



160
161
162
 
# File 'lib/tensor_stream/ops.rb', line 160

def sub(input_a, input_b, name: nil)
  _op(:sub, input_a, input_b, name: name)
end

#subtract(input_a, input_b, name: nil) ⇒ Object 



164
165
166
 
# File 'lib/tensor_stream/ops.rb', line 164

def subtract(input_a, input_b, name: nil)
  sub(input_a, input_b, name: name)
end

#tan(input, options = {}) ⇒ Object 



251
252
253
254
255
 
# File 'lib/tensor_stream/ops.rb', line 251

def tan(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:tan, input, nil, options)
end

#tanh(input, options = {}) ⇒ Object 



257
258
259
260
261
 
# File 'lib/tensor_stream/ops.rb', line 257

def tanh(input, options = {})
  options[:data_type] ||= :float32
  check_allowed_types(input, FLOATING_POINT_TYPES)
  _op(:tanh, input, nil, options)
end

#tile(input, multiples, name: nil) ⇒ Object 



63
64
65
 
# File 'lib/tensor_stream/ops.rb', line 63

def tile(input, multiples, name: nil)
  _op(:tile, input, multiples, name: name)
end

#transpose(tensor, perm: nil, name: 'transpose') ⇒ Object 



301
302
303
 
# File 'lib/tensor_stream/ops.rb', line 301

def transpose(tensor, perm: nil, name: 'transpose')
  _op(:transpose, tensor, nil, perm: perm, name: name)
end

#where(condition, true_t = nil, false_t = nil, name: nil) ⇒ Object 



152
153
154
 
# File 'lib/tensor_stream/ops.rb', line 152

def where(condition, true_t = nil, false_t = nil, name: nil)
  _op(:where, true_t, false_t, pred: condition, name: name)
end

#zeros(shape, dtype: :float32, name: nil) ⇒ Object 



87
88
89
 
# File 'lib/tensor_stream/ops.rb', line 87

def zeros(shape, dtype: :float32, name: nil)
  _op(:zeros, shape, nil, data_type: dtype, name: name)
end

#zeros_initializer(options = {}) ⇒ Object 



71
72
73
 
# File 'lib/tensor_stream/ops.rb', line 71

def zeros_initializer(options = {})
  _op(:zeros, nil, nil, options)
end

#zeros_like(tensor, dtype: nil, name: nil) ⇒ Object 



203
204
205
 
# File 'lib/tensor_stream/ops.rb', line 203

def zeros_like(tensor, dtype: nil, name: nil)
  _op(:zeros_like, tensor, nil, data_type: dtype, name: name)
end