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

Computes the absolute value of a tensor.



411
412
413
 
# File 'lib/tensor_stream/ops.rb', line 411

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

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

Returns x + y element-wise.

This operation supports broadcasting



276
277
278
279
 
# File 'lib/tensor_stream/ops.rb', line 276

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

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

Returns the index with the largest value across axes of a tensor.

Argmuments

input A Tensor. Must be one of the following types: float32, float64, int32, int16 axis Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0 output_type Output data type defaults to int32



16
17
18
 
# File 'lib/tensor_stream/ops.rb', line 16

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

Returns the index with the smallest value across axes of a tensor.

Argmuments

input A Tensor. Must be one of the following types: float32, float64, int32, int16 axis Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0 output_type Output data type defaults to int32



28
29
30
 
# File 'lib/tensor_stream/ops.rb', line 28

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

Casts a tensor to a new type.



319
320
321
 
# File 'lib/tensor_stream/ops.rb', line 319

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

#ceil(input, name: nil) ⇒ Object

Returns element-wise smallest integer in not less than x



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

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

#check_numerics(tensor, message, name: nil) ⇒ Object

Checks a tensor for NaN and Inf values. When run, reports an InvalidArgument error if tensor has any values that are not a number (NaN) or infinity (Inf). Otherwise, passes tensor as-is.



512
513
514
 
# File 'lib/tensor_stream/ops.rb', line 512

def check_numerics(tensor, message, name: nil)
  _op(:check_numerics, tensor, nil, message: message, name: name)
end

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

Concatenates tensors along one dimension.



229
230
231
 
# File 'lib/tensor_stream/ops.rb', line 229

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

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

Return true_fn() if the predicate pred is true else false_fn().



262
263
264
 
# File 'lib/tensor_stream/ops.rb', line 262

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

#cos(input, name: nil) ⇒ Object

Computes cos of input element-wise.



432
433
434
435
 
# File 'lib/tensor_stream/ops.rb', line 432

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

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

Divides x / y elementwise This operation supports broadcasting



397
398
399
400
 
# File 'lib/tensor_stream/ops.rb', line 397

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

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

Returns the truth value of (x == y) element-wise.



345
346
347
348
 
# File 'lib/tensor_stream/ops.rb', line 345

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

#exp(input, name: nil) ⇒ Object

Computes exponential of x element-wise.



474
475
476
477
 
# File 'lib/tensor_stream/ops.rb', line 474

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

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

Construct an identity matrix



85
86
87
 
# File 'lib/tensor_stream/ops.rb', line 85

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

#floor(input, name: nil) ⇒ Object

Returns element-wise largest integer not greater than x.



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

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

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

The Glorot uniform initializer, also called Xavier uniform initializer.

It draws samples from a uniform distribution within [-limit, limit] where limit is sqrt(6 / (fan_in + fan_out)) where fan_in is the number of input units in the weight tensor and fan_out is the number of output units in the weight tensor.



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

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

#gradients(ys, wrt_xs, name: 'gradients', stop_gradients: nil) ⇒ Object

Constructs symbolic derivatives of ys of input w.r.t. x in wrt_xs.

ys and xs are each a Tensor or a list of tensors. grad_ys is a list of Tensor, holding the gradients received by the ys. The list must be the same length as ys.

Arguments: ys : A Tensor or list of tensors to be differentiated. wrt_xs : A Tensor or list of tensors to be used for differentiation. stop_gradients: Optional. A Tensor or list of tensors not to differentiate through



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/tensor_stream/ops.rb', line 41

def gradients(ys, wrt_xs, name: 'gradients', stop_gradients: nil)

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

    tensor_program = if ys.graph.node_added?(gradient_program_name)
                      ys.graph.get_node(gradient_program_name)
                    else
                      ys.graph.name_scope("gradient_wrt_#{x.name}") do
                        derivative_ops = TensorStream::MathGradients.derivative(ys, x, graph: ys.graph,
                          stop_gradients: stop_gradients)
                        ys.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

Returns the truth value of (x > y) element-wise. This operation supports broadcasting



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

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

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

Returns the truth value of (x >= y) element-wise.

This operation supports broadcasting



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

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

#identity(input, name: nil) ⇒ Object

Return a tensor with the same shape and contents as input.



374
375
376
 
# File 'lib/tensor_stream/ops.rb', line 374

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

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

Returns the truth value of (x < y) element-wise. This operation supports broadcasting



166
167
168
169
 
# File 'lib/tensor_stream/ops.rb', line 166

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

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

Returns the truth value of (x <= y) element-wise.



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

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

#log(input, name: nil) ⇒ Object

Computes natural logarithm of x element-wise.



460
461
462
463
 
# File 'lib/tensor_stream/ops.rb', line 460

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

#log1p(input, name: nil) ⇒ Object

Computes natural logarithm of (1 + x) element-wise.



467
468
469
470
 
# File 'lib/tensor_stream/ops.rb', line 467

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

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

Returns the truth value of x AND y element-wise.



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

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

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

Multiplies matrix a by matrix b, producing a * b. The inputs must, following any transpositions, be tensors of rank 2 .



489
490
491
492
493
494
 
# File 'lib/tensor_stream/ops.rb', line 489

def matmul(input_a, input_b, transpose_a: false,
           transpose_b: false,
           name: nil)
  input_a, input_b = check_data_types(input_a, input_b)
  _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

Returns the max of x and y (i.e. x > y ? x : y) element-wise.



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

def max(input_a, input_b, name: nil)
  check_allowed_types(input_a, NUMERIC_TYPES)
  check_allowed_types(input_b, NUMERIC_TYPES)
  input_a, input_b = check_data_types(input_a, input_b)
  _op(:max, input_a, input_b, name: name)
end

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

Returns the max of x and y (i.e. x > y ? x : y) element-wise.



310
311
312
313
314
315
 
# File 'lib/tensor_stream/ops.rb', line 310

def maximum(input_a, input_b, name: nil)
  check_allowed_types(input_a, NUMERIC_TYPES)
  check_allowed_types(input_b, NUMERIC_TYPES)
  input_a, input_b = check_data_types(input_a, input_b)
  max(input_a, input_b, name: name)
end

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

Returns x * y element-wise. This operation supports broadcasting



389
390
391
392
 
# File 'lib/tensor_stream/ops.rb', line 389

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

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

Returns x * y element-wise. This operation supports broadcasting



381
382
383
384
 
# File 'lib/tensor_stream/ops.rb', line 381

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

#negate(input, name: nil) ⇒ Object

Computes numerical negative value element-wise.



333
334
335
 
# File 'lib/tensor_stream/ops.rb', line 333

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

#negative(input, name: nil) ⇒ Object

Computes numerical negative value element-wise.



339
340
341
 
# File 'lib/tensor_stream/ops.rb', line 339

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

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

Returns the truth value of (x != y) element-wise. This ops supports broadcasting



353
354
355
356
 
# File 'lib/tensor_stream/ops.rb', line 353

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

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

Creates a tensor with all elements set to 1.



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

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

Creates a tensor with all elements set to 1. Given a single tensor (tensor), this operation returns a tensor of the same type and shape as tensor with all elements set to 1. Optionally, you can specify a new type (dtype) for the returned tensor.



368
369
370
 
# File 'lib/tensor_stream/ops.rb', line 368

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

Pads a tensor. This operation pads a tensor according to the paddings you specify.



505
506
507
 
# File 'lib/tensor_stream/ops.rb', line 505

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

Computes the power of one value to another.



404
405
406
407
 
# File 'lib/tensor_stream/ops.rb', line 404

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

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

Prints a list of tensors.

This is an identity op (behaves like tf.identity) with the side effect of printing data when evaluating.



327
328
329
 
# File 'lib/tensor_stream/ops.rb', line 327

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

Outputs random values from a normal distribution.



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

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

Outputs random values from a uniform distribution.



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

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

Initializer that generates tensors with a uniform distribution.



125
126
127
 
# File 'lib/tensor_stream/ops.rb', line 125

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

Returns the rank of a tensor.



105
106
107
 
# File 'lib/tensor_stream/ops.rb', line 105

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

#reciprocal(tensor, name: nil) ⇒ Object

Computes the reciprocal of x element-wise.



256
257
258
 
# File 'lib/tensor_stream/ops.rb', line 256

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

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

Computes the mean of elements across dimensions of a tensor.



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

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

Computes the product of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.



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

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

Computes the sum of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are retained with length 1. If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.



213
214
215
 
# File 'lib/tensor_stream/ops.rb', line 213

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

Reshapes a tensor.

Given tensor, this operation returns a tensor that has the same values as tensor with shape shape.



237
238
239
 
# File 'lib/tensor_stream/ops.rb', line 237

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

#round(tensor, name: nil) ⇒ Object

Rounds the values of a tensor to the nearest integer, element-wise



249
250
251
252
 
# File 'lib/tensor_stream/ops.rb', line 249

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

This operation returns a 1-D integer tensor representing the shape of input



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

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

#sigmoid(input, name: nil) ⇒ Object

Computes sigmoid of x element-wise.



481
482
483
484
 
# File 'lib/tensor_stream/ops.rb', line 481

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

#sign(input, name: nil) ⇒ Object

Returns an element-wise indication of the sign of a number. y = sign(x) = -1 if x < 0; 0 if x == 0 or tf.is_nan(x); 1 if x > 0. Zero is returned for NaN inputs.



419
420
421
 
# File 'lib/tensor_stream/ops.rb', line 419

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

#sin(input, name: nil) ⇒ Object

Computes sin of input element-wise.



425
426
427
428
 
# File 'lib/tensor_stream/ops.rb', line 425

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

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

Extracts a slice from a tensor.

This operation extracts a slice of size size from a tensor input starting at the location specified by begin. The slice size is represented as a tensor shape, where size is the number of elements of the ‘i’th dimension of input that you want to slice. The starting location (begin) for the slice is represented as an offset in each dimension of input. In other words, begin is the offset into the ‘i’th dimension of input that you want to slice from.



133
134
135
 
# File 'lib/tensor_stream/ops.rb', line 133

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

#sqrt(input, name: nil) ⇒ Object

Computes sqrt of input element-wise.



453
454
455
456
 
# File 'lib/tensor_stream/ops.rb', line 453

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

#square(tensor, name: nil) ⇒ Object

Computes square of x element-wise.



243
244
245
 
# File 'lib/tensor_stream/ops.rb', line 243

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

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

Stops gradient computation.

When executed in a graph, this op outputs its input tensor as-is.



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

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

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

Returns x - y element-wise.

This operation supports boradcasting



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

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

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

Returns x - y element-wise.

This operation supports boradcasting



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

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

#tan(input, name: nil) ⇒ Object

Computes tan of input element-wise.



439
440
441
442
 
# File 'lib/tensor_stream/ops.rb', line 439

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

#tanh(input, name: nil) ⇒ Object

Computes tanh of input element-wise.



446
447
448
449
 
# File 'lib/tensor_stream/ops.rb', line 446

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

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

Constructs a tensor by tiling a given tensor.

This operation creates a new tensor by replicating input multiples times. The output tensor’s i’th dimension has input.dims(i) * multiples elements, and the values of input are replicated multiples times along the ‘i’th dimension. For example, tiling [a b c d] by [2] produces [a b c d a b c d].



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

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

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

Transposes a. Permutes the dimensions according to perm.



498
499
500
 
# File 'lib/tensor_stream/ops.rb', line 498

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

Return the elements, either from x or y, depending on the condition.



268
269
270
 
# File 'lib/tensor_stream/ops.rb', line 268

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

Creates a tensor with all elements set to zero



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

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

#zeros_initializer(dtype: nil) ⇒ Object

initializer that generates tensors initialized to 0.



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

def zeros_initializer(dtype: nil)
  TensorStream::Initializer.new(-> { _op(:zeros, nil, nil, data_type: dtype) })
end

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

reates a tensor with all elements set to zero. Given a single tensor (tensor), this operation returns a tensor of the same type and shape as tensor with all elements set to zero. Optionally, you can use dtype to specify a new type for the returned tensor.



361
362
363
 
# File 'lib/tensor_stream/ops.rb', line 361

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